Merge remote-tracking branch 'origin/main' into worktree-20260511-165241 (#93)

* feat(tickets): backfill aliases on read + resolver supports computed aliases

Pre-existing tickets created before the alias feature shipped had no
data.alias on their CREATE event, so reduce_ticket returned alias=None
and resolve_ticket_id couldn't find them by alias — defeating the whole
human-friendly identifier system for ~325 legacy tickets.

This change:
- _alias.py (new): deterministic alias computer mirroring
  ticket-alias-compute.py. 16-hex IDs get adj-noun-noun, legacy 8-hex
  IDs get adj-noun (one segment unavailable).
- _processors.process_create: when data.alias is missing, fall back to
  compute_alias(ticket_id) so reduce_ticket and downstream consumers
  surface a stable backfilled alias.
- llm_format.KEY_MAP: include 'alias' (mapped to 'a') so --format=llm
  carries the alias to agents that read ticket lists.
- ticket-create.sh: 'Created ticket' line now leads with the alias and
  shows the canonical ID parenthetically.
- ticket-alias-resolve.py (new): single-pass resolver — one Python
  process iterates all ticket dirs (was N subprocess.run calls), and
  also matches against backfilled aliases for legacy tickets.
- ticket-lib.sh resolve_ticket_id: replaces the per-file Python loop
  with a single call to the new resolver.

Tests: 6 new pytest cases for compute_alias parity with the shell
helper and process_create backfill behaviour, plus one new
resolver_alias_backfill case in test-ticket-lib.sh confirming
resolve_ticket_id finds tickets by their backfilled alias.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(tickets): consolidate alias logic + address llm-review findings on PR #93

llm-review flagged 2 critical + 4 important findings. Addresses all six:

- F1 (claimed path bug in _alias.py): rejected — the '..' count is correct
  (verified: _wordlist_path() resolves to plugins/dso/resources/ticket-wordlist.txt).
  Added test_resolver_wordlist_path_resolves_to_existing_file as the
  executable defense.

- F2 (asymmetric fallback): fixed by single source of truth (below). The two
  files used to compute alias independently — _alias.py fell back to hex_id[:8]
  when the wordlist was missing, ticket-alias-resolve.py fell back to None.
  Now they cannot diverge.

- F3 (DRY): ticket-alias-resolve.py now imports compute_alias from
  ticket_reducer._alias. Removed duplicated load_wordlist() and inline
  compute_alias() body. TICKET_WORDLIST_PATH env var override is honoured
  uniformly via _wordlist_path().

- F4 (no unit tests for resolver script): added 5 direct test cases —
  missing tracker dir (fails loud, exit nonzero), malformed CREATE JSON
  (skipped without crashing), dotfile dirs (ignored), backfilled alias
  resolves a legacy ticket, jira_key precedence over alias on collision.

- F5 (stderr suppression hid debug info): removed `2>/dev/null` from the
  resolver invocation in resolve_ticket_id. The resolver now exits non-zero
  with a useful stderr message when the tracker dir is unreadable.

- F6 (tautological stored-alias test): rewrote test_process_create_uses_
  stored_alias_when_present → test_process_create_prefers_stored_over_
  backfill. The new test asserts the stored value is intentionally
  DIFFERENT from what compute_alias would yield, so a regression where
  backfill clobbers the stored alias would fail the test.

Test suite: 12/12 backfill pytest cases, 76/76 test-ticket-lib.sh.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(tickets): cycle-2 llm-review — environment validation + WARN on missing wordlist

Cycle-2 review surfaced 3 new findings (1 critical, 2 important):

- C1 (critical) resolver-script + python3 not validated before invocation —
  silent failure mode hid environment misconfig as 'no matches found'.
  Added explicit checks in resolve_ticket_id; both emit a clear stderr
  diagnostic and return 1.

- I1 (important) _load() swallowed OSError silently — falling back to the
  8-hex alias without ever telling the operator the wordlist was missing.
  Added a one-shot stderr WARN keyed on the new _WARNED_MISSING module flag,
  matching the shell helper's 'FALLBACK' stderr pattern. Single-print so
  bulk callers (resolve_ticket_id scans 18k dirs) don't log-flood.

- I2 (important) test_resolver_wordlist_path_resolves_to_existing_file was
  redundant noise — the existing parity test already exercises the file
  open path implicitly. Replaced with test_load_warns_once_when_wordlist_
  missing which asserts the new WARN behaviour.

Test suite: 12/12 backfill pytest, 76/76 test-ticket-lib.sh.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(tickets): cycle-3 llm-review — propagate resolver subprocess exit code

Cycle-3 review: process-substitution piping (`done < <(python3 ...)`) discards
the resolver's exit code. If the resolver crashes mid-scan or exits non-zero
for environment reasons, the read loop completes silently and resolve_ticket_id
reports 'no matches' — indistinguishable from 'ticket genuinely not found'.

- Capture stdout into a variable and check $? separately. Non-zero resolver
  exit now produces 'Error: alias resolver exited N for input X' on stderr
  and propagates as exit 1 from resolve_ticket_id.
- Guard the read loop against the implicit trailing newline in <<<"$var" so
  empty resolver output doesn't iterate once with empty fields.
- New pytest test_resolver_nonzero_exit_propagates_to_resolve_ticket_id
  forces the failure path (tracker-as-file → resolver OSError → exit 1) and
  asserts resolve_ticket_id surfaces the diagnostic.

Test suite: 13/13 backfill pytest, 76/76 test-ticket-lib.sh.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(pr-finalize): cycle-4 llm-review findings — fixes 3/5/4 + parity in ticket_create

Cycle-4 review surfaced 5 findings. Two criticals (F1, F2) are defended in a
separate PR comment (see GitHubPRDefenseStore); they rest on misreadings of the
flow. The three remaining findings are addressed here:

- F3 (important): ticket-alias-compute.py was unguarded against 8-hex inputs
  (would have crashed on int('', 16) had it ever been called with one).
  Added len(hex_id) >= 12 guard mirroring ticket_reducer._alias. Dead-code-
  safe today (callers only pass 16-hex) but defends against future drift.

- F4 (important): no test verified the new alias-led 'Created ticket' output.
  Updated tests/scripts/test-ticket-create.sh Test 1 to accept both formats
  and to assert the alias-led variant appears whenever the bundled wordlist
  is available. Also fixed a latent parity gap — ticket-lib-api.sh
  ticket_create had its own duplicate output line which still printed the
  legacy 'Created ticket <id>: <title>' format; ticket-create.sh shell-path
  was already updated, but the lib-api in-process path was not. Now both
  paths emit the alias-led summary identically.

- F5 (important): tightened test_resolver_nonzero_exit_propagates_to_resolve_
  ticket_id. The earlier OR'd assertion could pass on a silent crash (the
  'success-line not in stdout' branch was true vacuously). Replaced with
  two AND'd assertions: explicit diagnostic in stderr, success-line not in
  stdout.

Also: review.max_resolution_attempts lowered from 5 to 3 in dso-config.conf
per session decision — three autonomous fix/defend cycles is the cap before
user escalation; more than that is churn.

Test suite: 13/13 backfill pytest, 76/76 test-ticket-lib.sh, 17/17 test-
ticket-lib-api.sh, 48/48 test-ticket-create.sh.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Test <test@test.com>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 3 people

.claude/dso-config.conf

@@ -183,7 +183,7 @@ version.file_path=plugins/dso/.claude-plugin/plugin.json
 # Review resolution — maximum autonomous fix/defend attempts before escalating to the user.
 # Used by REVIEW-WORKFLOW.md Autonomous Resolution Loop, COMMIT-WORKFLOW.md, and
 # TEST-FAILURE-DISPATCH.md. Escalation occurs when attempt > this value.
-# review.max_resolution_attempts=5
+review.max_resolution_attempts=3
 
 # Review tier routing — behavioral file classification
 # Semicolon-delimited glob list of file patterns to treat as behavioral (full scoring weight).

plugins/dso/scripts/ticket-alias-compute.py

@@ -59,8 +59,14 @@ def main():
 
     adj = adjs[int(hex_id[0:4], 16) % len(adjs)]
     noun1 = nouns[int(hex_id[4:8], 16) % len(nouns)]
-    noun2 = nouns[int(hex_id[8:12], 16) % len(nouns)]
-    print(f"{adj}-{noun1}-{noun2}")
+    # Legacy 8-hex IDs (xxxx-xxxx) have no hex[8:12]; emit a 2-word alias
+    # rather than crashing on int("", 16). Matches ticket_reducer._alias
+    # so the same ticket_id yields the same alias on both code paths.
+    if len(hex_id) >= 12:
+        noun2 = nouns[int(hex_id[8:12], 16) % len(nouns)]
+        print(f"{adj}-{noun1}-{noun2}")
+    else:
+        print(f"{adj}-{noun1}")
 
 
 if __name__ == "__main__":

plugins/dso/scripts/ticket-alias-resolve.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Single-pass alias / jira_key resolver for resolve_ticket_id.
+
+Replaces the per-file Python loop in ticket-lib.sh resolve_ticket_id.
+For each ticket directory, reads its CREATE event once and matches
+against the input by:
+  - data.alias (stored, set at create time for new tickets)
+  - data.alias backfilled by computing from ticket_id (for legacy tickets)
+  - data.jira_key
+
+Output (one line per match):
+  alias <ticket_dir_name>
+  jira  <ticket_dir_name>
+
+Exit code is always 0 — caller dedupes and chooses match precedence.
+
+Usage:
+    ticket-alias-resolve.py <input> <tracker_dir>
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+# Single source of truth for alias computation lives in
+# ticket_reducer/_alias.py. Importing it here keeps stored-at-create-time
+# aliases and backfilled-at-resolve-time aliases in lock-step — the same
+# wordlist, the same fallback rules, the same env var override.
+_SCRIPTS_DIR = os.path.dirname(os.path.abspath(__file__))
+if _SCRIPTS_DIR not in sys.path:
+    sys.path.insert(0, _SCRIPTS_DIR)
+from ticket_reducer._alias import compute_alias  # noqa: E402
+
+
+def main() -> int:
+    if len(sys.argv) != 3:
+        print(f"Usage: {sys.argv[0]} <input> <tracker_dir>", file=sys.stderr)
+        return 1
+    target = sys.argv[1]
+    tracker = sys.argv[2]
+
+    try:
+        entries = sorted(os.listdir(tracker))
+    except OSError as exc:
+        # Fail loud — silent OSError here looks identical to "no matches"
+        # and turns a debuggable I/O failure into a mysterious lookup miss.
+        print(f"ticket-alias-resolve: cannot list {tracker!r}: {exc}", file=sys.stderr)
+        return 1
+
+    for name in entries:
+        if name.startswith("."):
+            continue
+        ticket_dir = os.path.join(tracker, name)
+        if not os.path.isdir(ticket_dir):
+            continue
+        # Find the first CREATE event (typically exactly one per ticket;
+        # if multiple ever appear, the lexically earliest wins — same
+        # ordering rule the rest of the reducer applies).
+        create_path = None
+        try:
+            for fname in sorted(os.listdir(ticket_dir)):
+                if fname.endswith("-CREATE.json"):
+                    create_path = os.path.join(ticket_dir, fname)
+                    break
+        except OSError:
+            continue
+        stored_alias = ""
+        jira_key = ""
+        if create_path:
+            try:
+                with open(create_path, encoding="utf-8") as f:
+                    data = json.load(f).get("data", {}) or {}
+                stored_alias = data.get("alias") or ""
+                jira_key = data.get("jira_key") or ""
+            except (OSError, json.JSONDecodeError):
+                pass
+        # jira_key match
+        if jira_key and jira_key == target:
+            print(f"jira\t{name}")
+            continue
+        # alias match — stored or backfilled (compute_alias is the same
+        # function ticket_reducer/_processors.process_create uses, so a
+        # stored alias and a backfilled alias for the same ticket_id are
+        # guaranteed to be identical).
+        effective_alias = stored_alias or compute_alias(name) or ""
+        if effective_alias and effective_alias == target:
+            print(f"alias\t{name}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

plugins/dso/scripts/ticket-create.sh

@@ -268,7 +268,12 @@ rm -f "$temp_event"
 # ── Output dual-format: human summary first, canonical ID last (both stdout) ──
 # SC3: both lines on stdout — human-readable summary line 1, canonical ID last.
 # Scripts extract the canonical ID via: ticket create ... | tail -1
-echo "Created ticket $ticket_id: $title"
+# Lead with the human-readable alias when available; canonical ID is parenthetical.
+if [ -n "$ticket_alias" ] && [ "$ticket_alias" != "$ticket_id" ]; then
+    echo "Created ticket $ticket_alias ($ticket_id): $title"
+else
+    echo "Created ticket $ticket_id: $title"
+fi
 echo "$ticket_id"
 
 # ── Post-creation validation (warnings only, never blocks, exit 0) ───────────

plugins/dso/scripts/ticket-lib-api.sh

@@ -887,7 +887,13 @@ with open(sys.argv[12], 'w', encoding='utf-8') as f:
 
         # Output dual-format: human summary first, canonical ID last (both stdout).
         # SC3: both lines on stdout; scripts extract ID via | tail -1.
-        echo "Created ticket $ticket_id: $title"
+        # Lead with the human-readable alias when available; canonical ID
+        # is parenthetical. Matches the parity output in ticket-create.sh.
+        if [ -n "$ticket_alias" ] && [ "$ticket_alias" != "$ticket_id" ]; then
+            echo "Created ticket $ticket_alias ($ticket_id): $title"
+        else
+            echo "Created ticket $ticket_id: $title"
+        fi
         echo "$ticket_id"
     )
 }

plugins/dso/scripts/ticket-lib.sh

@@ -1245,45 +1245,42 @@ resolve_ticket_id() {
     fi
 
     # ── Steps 3 & 4: Alias and jira_key scan ─────────────────────────────────
+    # Single Python helper iterates all ticket directories in one process.
+    # The helper also computes alias-from-ticket_id when data.alias is missing
+    # (legacy tickets created before the alias feature shipped), so backfilled
+    # aliases are resolvable too. One subprocess vs O(N) per-file Python calls.
     local _alias_matches=()
     local _jira_matches=()
-    local _entry
-    while IFS= read -r -d '' _entry; do
-        local _base
-        _base="$(basename "$_entry")"
-        [[ "$_base" == .* ]] && continue
-        # Scan CREATE event files in this ticket directory
-        local _create_file
-        while IFS= read -r -d '' _create_file; do
-            if ! [ -f "$_create_file" ]; then
-                continue
-            fi
-            local _alias_val _jira_val _combined
-            # Single python3 call extracts both alias and jira_key, halving subprocess count.
-            _combined=$(python3 -c "
-import json, sys
-try:
-    with open(sys.argv[1], encoding='utf-8') as f:
-        data = json.load(f).get('data', {})
-    alias = data.get('alias', '') or ''
-    jira_key = data.get('jira_key', '') or ''
-    print(alias + '\t' + jira_key)
-except Exception:
-    print('\t')
-" "$_create_file" 2>/dev/null) || _combined=$'\t'
-            _alias_val="${_combined%%	*}"
-            _jira_val="${_combined##*	}"
-            if [ -n "$_alias_val" ] && [ "$_alias_val" = "$input" ]; then
-                _alias_matches+=("$_base")
-                break  # Only record each ticket once per alias match
-            fi
-            if [ -n "$_jira_val" ] && [ "$_jira_val" = "$input" ]; then
-                _jira_matches+=("$_base")
-                break  # Only record each ticket once per jira_key match
-            fi
-        done < <(find "$_entry" -maxdepth 1 -name '*-CREATE.json' -print0 2>/dev/null)
-    done < <(find "$_tracker_dir" -mindepth 1 -maxdepth 1 -type d \
-        ! -name '.*' -print0 2>/dev/null)
+    local _resolver_script
+    _resolver_script="$(dirname "${BASH_SOURCE[0]}")/ticket-alias-resolve.py"
+    if [ ! -f "$_resolver_script" ]; then
+        echo "Error: alias resolver missing at $_resolver_script" >&2
+        return 1
+    fi
+    if ! command -v python3 >/dev/null 2>&1; then
+        echo "Error: python3 not found in PATH (required for alias resolver)" >&2
+        return 1
+    fi
+    # Capture output + exit code separately. Piping to read via process
+    # substitution discards the exit status; if the resolver crashes
+    # mid-scan we'd silently get zero matches and the caller couldn't tell
+    # 'no match found' from 'resolver exploded' (cycle-3 review).
+    local _resolver_out _resolver_rc=0
+    _resolver_out=$(python3 "$_resolver_script" "$input" "$_tracker_dir") || _resolver_rc=$?
+    if [ "$_resolver_rc" -ne 0 ]; then
+        echo "Error: alias resolver exited $_resolver_rc for input '$input'" >&2
+        return 1
+    fi
+    local _scan_kind _scan_id
+    if [ -n "$_resolver_out" ]; then
+        while IFS=$'\t' read -r _scan_kind _scan_id; do
+            [ -z "$_scan_kind" ] && continue
+            case "$_scan_kind" in
+                alias) _alias_matches+=("$_scan_id") ;;
+                jira)  _jira_matches+=("$_scan_id") ;;
+            esac
+        done <<< "$_resolver_out"
+    fi
 
     if [ "${#_jira_matches[@]}" -eq 1 ]; then
         echo "${_jira_matches[0]}"

plugins/dso/scripts/ticket_reducer/_alias.py

@@ -0,0 +1,94 @@
+"""Compute deterministic adjective-noun-noun aliases from ticket IDs.
+
+Used as a read-time fallback for tickets created before the alias feature
+shipped (their CREATE event has no `data.alias`). Mirrors the algorithm in
+`ticket-alias-compute.py` so legacy tickets surface the same alias they
+would have been assigned at creation.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+_WORDS_CACHE: tuple[list[str], list[str]] | None = None
+_WARNED_MISSING: bool = False
+
+
+def _wordlist_path() -> str:
+    """Resolve the bundled wordlist path. Honours TICKET_WORDLIST_PATH override."""
+    env = os.environ.get("TICKET_WORDLIST_PATH")
+    if env:
+        return env
+    # This module lives at <plugin_root>/scripts/ticket_reducer/_alias.py;
+    # the wordlist is at <plugin_root>/resources/ticket-wordlist.txt.
+    here = os.path.dirname(os.path.abspath(__file__))
+    return os.path.normpath(os.path.join(here, "..", "..", "resources", "ticket-wordlist.txt"))
+
+
+def _load() -> tuple[list[str], list[str]]:
+    """Load and cache the (adjs, nouns) tuple. Mirrors the file-format and
+    fallback behaviour of ticket-alias-compute.py so backfilled aliases match
+    aliases stored at creation time byte-for-byte.
+
+    When the wordlist file cannot be opened, emits a one-shot WARN to stderr
+    (matching the shell helper's "FALLBACK" stderr signal) and returns empty
+    lists — caller then falls back to the 8-hex alias. Silent fallback hides
+    a real misconfiguration; the diagnostic is printed exactly once per
+    process to avoid log flood under bulk invocation."""
+    global _WORDS_CACHE, _WARNED_MISSING
+    if _WORDS_CACHE is not None:
+        return _WORDS_CACHE
+    adjs: list[str] = []
+    nouns: list[str] = []
+    section = "adj"
+    path = _wordlist_path()
+    try:
+        with open(path, encoding="utf-8") as f:
+            for line in f:
+                line = line.rstrip("\n")
+                if line == "# NOUNS":
+                    section = "noun"
+                    continue
+                if line.startswith("#") or not line.strip():
+                    continue
+                (adjs if section == "adj" else nouns).append(line.strip())
+    except OSError as exc:
+        if not _WARNED_MISSING:
+            print(
+                f"WARN: ticket-wordlist.txt unavailable at {path!r} ({exc}); "
+                "falling back to 8-hex aliases. Set TICKET_WORDLIST_PATH to "
+                "override.",
+                file=sys.stderr,
+            )
+            _WARNED_MISSING = True
+    _WORDS_CACHE = (adjs, nouns)
+    return _WORDS_CACHE
+
+
+def compute_alias(ticket_id: str) -> str | None:
+    """Return the alias for `ticket_id`, or None if the wordlist is unavailable.
+
+    Returns the same string `ticket-alias-compute.py` would print for the same
+    ticket_id and wordlist. Falls back to the first 8 hex chars (no dash) when
+    the wordlist is empty/missing — matching the shell-side fallback.
+    """
+    hex_id = ticket_id.replace("-", "")
+    if len(hex_id) < 8:
+        return None
+    adjs, nouns = _load()
+    if not adjs or not nouns:
+        return hex_id[: min(len(hex_id), 8)]
+    try:
+        adj = adjs[int(hex_id[0:4], 16) % len(adjs)]
+        n1 = nouns[int(hex_id[4:8], 16) % len(nouns)]
+    except ValueError:
+        return None
+    # Legacy 8-hex tickets get a 2-word alias (adj-noun); 16-hex get adj-noun-noun.
+    if len(hex_id) >= 12:
+        try:
+            n2 = nouns[int(hex_id[8:12], 16) % len(nouns)]
+        except ValueError:
+            return f"{adj}-{n1}"
+        return f"{adj}-{n1}-{n2}"
+    return f"{adj}-{n1}"

plugins/dso/scripts/ticket_reducer/_processors.py

@@ -57,8 +57,17 @@ def process_create(
     # into compiled state so resolve_ticket_id and ticket_show can return
     # human-friendly aliases. Without this assignment, alias is silently
     # dropped between persistence and compiled state, defeating the entire
-    # alias system.
-    state["alias"] = data.get("alias")
+    # alias system. For tickets created before the alias feature shipped
+    # (data.alias is missing), backfill at read time using the deterministic
+    # ticket_id-derived alias so legacy tickets surface the same alias they
+    # would have been assigned at creation.
+    stored_alias = data.get("alias")
+    if stored_alias:
+        state["alias"] = stored_alias
+    else:
+        from ticket_reducer._alias import compute_alias
+
+        state["alias"] = compute_alias(ticket_id)
     state["description"] = data.get("description") or ""
     state["tags"] = data.get("tags", [])
     return None

plugins/dso/scripts/ticket_reducer/llm_format.py

@@ -33,6 +33,7 @@
     "parent_id": "pid",
     "priority": "pr",
     "assignee": "asn",
+    "alias": "a",
     "description": "desc",
     "tags": "tg",
     "comments": "cm",

tests/scripts/test-ticket-create.sh

@@ -92,14 +92,27 @@ test_ticket_create_outputs_ticket_id() {
         assert_eq "stdout last line matches 16-hex canonical ID pattern" "match" "no-match: $ticket_id"
     fi
 
-    # Assert: stdout first line contains the human summary "Created ticket <id>: <title>"
+    # Assert: stdout first line contains the human summary. When an alias is
+    # available (default path), the summary leads with the alias and shows the
+    # canonical ID parenthetically: "Created ticket <alias> (<id>): <title>".
+    # Falls back to "Created ticket <id>: <title>" only when alias is missing
+    # (TICKET_WORDLIST_PATH override pointed at empty/missing file).
     local summary_line
     summary_line=$(echo "$stdout_out" | head -1)
-    if [[ "$summary_line" == "Created ticket $ticket_id: "* ]]; then
+    if [[ "$summary_line" == "Created ticket "*"($ticket_id): "* ]] \
+       || [[ "$summary_line" == "Created ticket $ticket_id: "* ]]; then
         assert_eq "stdout first line contains human summary" "match" "match"
     else
         assert_eq "stdout first line contains human summary" "match" "no-match: $summary_line"
     fi
+
+    # Also assert the alias variant appears in the typical happy path (the
+    # bundled wordlist is present, so alias must be computed and displayed).
+    if [[ "$summary_line" == "Created ticket "*"-"*"-"*"("*"): "* ]]; then
+        assert_eq "stdout first line leads with alias-(id) when wordlist available" "alias-led" "alias-led"
+    else
+        assert_eq "stdout first line leads with alias-(id) when wordlist available" "alias-led" "no-alias-prefix: $summary_line"
+    fi
 }
 test_ticket_create_outputs_ticket_id