bmad-module-ultracode-goal 0.1.0

package/skills/ultracode-goal/scripts/gate_eval.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.11"
+# dependencies = []
+# ///
+"""Decide an Epic/story verdict from TEA's deterministic quality gate.
+
+Completion truth for ultracode-goal: this script reads TEA's gate artifact and
+maps the gate_status to a verdict. It NEVER re-derives the TEA thresholds
+(P0=100%, P1>=90%, overall>=80%) — those are decided upstream by the trace
+workflow and written into the artifact; here we read gate_status as given.
+
+Verdict mapping (gate_status -> verdict):
+    PASS | WAIVED  -> advance
+    CONCERNS       -> defer
+    FAIL           -> reloop
+    NOT_EVALUATED  -> escalate
+
+Profile:
+    light       -> the trace gate is the whole decision.
+    production  -> additionally AND two signals; any failure downgrades an
+                   otherwise-advance verdict to reloop (never below — a CONCERNS
+                   stays defer, a FAIL stays reloop):
+                     - nfr-assessment.md  : Overall Status != FAIL
+                     - test-review.md     : Quality Score >= 80 AND
+                                            Recommendation != Block
+
+Artifact resolution:
+    Read gate-decision.json (the slim file). Its name is resolved from the trace
+    report markdown frontmatter when it records one, else defaults to
+    <trace-output>/gate-decision.json. The slim file is only written by TEA when
+    the run is gate-eligible AND the decision is PASS/CONCERNS/FAIL/WAIVED, so
+    its ABSENCE is normal, not an error: fall back to the always-written
+    e2e-trace-summary.json and read its gate fields. When even the summary
+    carries no gate fields (not gate-eligible), gate_status is NOT_EVALUATED.
+
+    python3 gate_eval.py --trace-output DIR --profile production \
+        --nfr DIR/nfr-assessment.md --test-review DIR/test-review.md
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+GATE_VERDICT = {
+    "PASS": "advance",
+    "WAIVED": "advance",
+    "CONCERNS": "defer",
+    "FAIL": "reloop",
+    "NOT_EVALUATED": "escalate",
+}
+
+# Frontmatter keys a trace report may use to point at its slim gate file.
+_FRONTMATTER_GATE_KEYS = ("gateDecisionFile", "gateDecisionPath", "gate_decision_path")
+
+
+def _read_json(path: Path) -> dict:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _frontmatter(text: str) -> dict[str, str]:
+    """Parse the leading ``---`` YAML frontmatter as flat key: value scalars.
+
+    Stdlib-only: we only need top-level string scalars (the gate-file hint), so
+    a line scan is sufficient and avoids a yaml dependency.
+    """
+    match = re.match(r"^---\n(.*?)\n---", text, re.DOTALL)
+    if not match:
+        return {}
+    out: dict[str, str] = {}
+    for line in match.group(1).splitlines():
+        kv = re.match(r"^([A-Za-z_][\w]*):\s*(.*)$", line)
+        if not kv:
+            continue
+        value = kv.group(2).strip().strip("'\"")
+        out[kv.group(1)] = value
+    return out
+
+
+def _resolve_gate_file(trace_output: Path) -> Path:
+    """Locate the slim gate-decision file, honoring a trace-report hint."""
+    for report in sorted(trace_output.glob("*.md")):
+        try:
+            fm = _frontmatter(report.read_text(encoding="utf-8"))
+        except OSError:
+            continue
+        if fm.get("workflowType") not in ("testarch-trace", "trace"):
+            continue
+        for key in _FRONTMATTER_GATE_KEYS:
+            hint = fm.get(key)
+            if hint:
+                hinted = Path(hint)
+                return hinted if hinted.is_absolute() else trace_output / hinted
+    return trace_output / "gate-decision.json"
+
+
+def _gate_fields_from_summary(summary: dict) -> dict:
+    """Lift gate fields from e2e-trace-summary.json.
+
+    The summary only carries gate_status / gate_criteria when the run was
+    gate-eligible; otherwise those keys are absent and the gate is NOT_EVALUATED.
+    """
+    criteria = summary.get("gate_criteria") or {}
+    return {
+        "gate_status": summary.get("gate_status", "NOT_EVALUATED"),
+        "p0_status": criteria.get("p0_status"),
+        "p1_status": criteria.get("p1_status"),
+        "overall_status": criteria.get("overall_status"),
+    }
+
+
+def load_gate(trace_output: Path, reasons: list[str]) -> dict:
+    """Return normalized gate fields, preferring the slim file, else the summary."""
+    gate_file = _resolve_gate_file(trace_output)
+    if gate_file.is_file():
+        slim = _read_json(gate_file)
+        reasons.append(f"gate read from {gate_file.name}")
+        return {
+            "gate_status": slim.get("gate_status", "NOT_EVALUATED"),
+            "p0_status": slim.get("p0_status"),
+            "p1_status": slim.get("p1_status"),
+            "overall_status": slim.get("overall_status"),
+        }
+
+    summary_file = trace_output / "e2e-trace-summary.json"
+    if summary_file.is_file():
+        reasons.append(
+            f"{gate_file.name} absent; gate read from {summary_file.name} (not a failure)"
+        )
+        return _gate_fields_from_summary(_read_json(summary_file))
+
+    reasons.append(
+        f"neither {gate_file.name} nor e2e-trace-summary.json present in {trace_output}"
+    )
+    return {
+        "gate_status": "NOT_EVALUATED",
+        "p0_status": None,
+        "p1_status": None,
+        "overall_status": None,
+    }
+
+
+def _scan_nfr_overall_status(text: str) -> str | None:
+    """Read the NFR audit's Overall Status (PASS | CONCERNS | FAIL)."""
+    match = re.search(
+        r"(?:Overall\s+Status|overallStatus)[*:_\s]*[`*]*\s*(PASS|CONCERNS|FAIL|NOT_ASSESSED)",
+        text,
+        re.IGNORECASE,
+    )
+    return match.group(1).upper() if match else None
+
+
+def _scan_review_score(text: str) -> int | None:
+    """Read the test-review Quality Score (``{score}/100``)."""
+    match = re.search(r"(?:Quality\s+Score|score)[*:_\s]*[`*]*\s*(\d{1,3})\s*/\s*100", text, re.IGNORECASE)
+    return int(match.group(1)) if match else None
+
+
+def _scan_review_recommendation(text: str) -> str | None:
+    """Read the test-review Recommendation (Approve / ... / Block)."""
+    match = re.search(
+        r"Recommendation[*:_\s]*[`*]*\s*"
+        r"(Approve with Comments|Approve|Request Changes|Block)",
+        text,
+        re.IGNORECASE,
+    )
+    return match.group(1) if match else None
+
+
+def apply_production_and(
+    verdict: str,
+    nfr_path: Path | None,
+    review_path: Path | None,
+    reasons: list[str],
+) -> tuple[str, str | None, int | None]:
+    """AND the production signals; downgrade an advance to reloop on any failure.
+
+    Returns (verdict, nfr_status, review_score). The downgrade floor is reloop:
+    only an otherwise-advance verdict moves; defer/reloop/escalate are unchanged.
+
+    FAIL-CLOSED CONTRACT (deliberate — do not "relax"): a missing file or a
+    field the scanners below cannot parse is treated as a *failing* signal, not
+    a neutral/absent one (see the ``nfr_status is None`` / ``review_score is None``
+    / file-not-found branches). TEA prose-format drift therefore degrades to a
+    conservative reloop rather than a silent false-advance. The conservative
+    direction is intentional: we would rather re-loop a green story than advance
+    a story whose evidence we could not actually read.
+    """
+    nfr_status: str | None = None
+    review_score: int | None = None
+    failed = False
+
+    if nfr_path is not None and nfr_path.is_file():
+        nfr_status = _scan_nfr_overall_status(nfr_path.read_text(encoding="utf-8"))
+        if nfr_status == "FAIL":
+            reasons.append("nfr overallStatus is FAIL")
+            failed = True
+        elif nfr_status is None:
+            reasons.append(f"nfr Overall Status not found in {nfr_path.name}; treated as failing")
+            failed = True
+    elif nfr_path is not None:
+        reasons.append(f"nfr file {nfr_path} not found; treated as failing")
+        failed = True
+
+    if review_path is not None and review_path.is_file():
+        review_text = review_path.read_text(encoding="utf-8")
+        review_score = _scan_review_score(review_text)
+        recommendation = _scan_review_recommendation(review_text)
+        if review_score is None:
+            reasons.append(f"test-review score not found in {review_path.name}; treated as failing")
+            failed = True
+        elif review_score < 80:
+            reasons.append(f"test-review score {review_score} < 80")
+            failed = True
+        if recommendation is not None and recommendation.lower() == "block":
+            reasons.append("test-review recommendation is Block")
+            failed = True
+    elif review_path is not None:
+        reasons.append(f"test-review file {review_path} not found; treated as failing")
+        failed = True
+
+    if failed and verdict == "advance":
+        reasons.append("production signal failed; advance downgraded to reloop")
+        verdict = "reloop"
+
+    return verdict, nfr_status, review_score
+
+
+def evaluate(args: argparse.Namespace) -> dict:
+    reasons: list[str] = []
+    trace_output = Path(args.trace_output)
+
+    gate = load_gate(trace_output, reasons)
+    gate_status = (gate["gate_status"] or "NOT_EVALUATED").upper()
+    verdict = GATE_VERDICT.get(gate_status, "escalate")
+    if gate_status not in GATE_VERDICT:
+        reasons.append(f"unrecognized gate_status {gate_status!r}; escalating")
+    else:
+        reasons.append(f"gate_status {gate_status} -> {verdict}")
+
+    nfr_status: str | None = None
+    review_score: int | None = None
+    if args.profile == "production":
+        nfr_path = Path(args.nfr) if args.nfr else None
+        review_path = Path(args.test_review) if args.test_review else None
+        verdict, nfr_status, review_score = apply_production_and(
+            verdict, nfr_path, review_path, reasons
+        )
+
+    return {
+        "verdict": verdict,
+        "gate_status": gate_status,
+        "p0_status": gate["p0_status"],
+        "p1_status": gate["p1_status"],
+        "overall_status": gate["overall_status"],
+        "nfr_status": nfr_status,
+        "review_score": review_score,
+        "reasons": reasons,
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Evaluate the TEA quality gate into a verdict.")
+    parser.add_argument("--trace-output", required=True, help="Directory holding the trace gate artifacts.")
+    parser.add_argument("--profile", required=True, choices=["light", "production"])
+    parser.add_argument("--nfr", help="Path to nfr-assessment.md (production only).")
+    parser.add_argument("--test-review", help="Path to test-review.md (production only).")
+    args = parser.parse_args(argv)
+
+    result = evaluate(args)
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/ultracode-goal/scripts/health_check_fp.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.11"
+# dependencies = []
+# ///
+"""Deterministic fingerprint + seen-cache plumbing for the ultracode-goal health check.
+
+Plumbing ONLY. This script computes the dedup fingerprint for a health-check
+finding and manages the machine-local seen-cache. It does NO network, NO `gh`,
+and makes NO submit/queue/route decisions — that judgment lives in
+references/health-check.md (the LLM). Here we only guarantee a byte-stable
+fingerprint and a crash-proof cache.
+
+The fingerprint is install-mode-invariant: the `step_file` component is ALWAYS
+the source-repo form `skills/ultracode-goal/references/{stage}.md` regardless of
+where the skill is installed, so the same defect dedups to the same key across a
+dev checkout and an installed `_bmad/` tree.
+
+    fp = "fp-" + sha1("{severity}|ultracode-goal/{stage}|"
+                      "skills/ultracode-goal/references/{stage}.md|{section-slug}")[:7]
+
+Subcommands:
+  fingerprint --severity S --stage T --section-slug SLUG
+      Validate S against the 3 severities and T against the 6 stages; validate
+      SLUG against ^[a-z0-9]+(-[a-z0-9]+)*$. Emit {"fp": ..., "tuple": ...}.
+  seen --fp FP --cache PATH
+      Validate FP. Missing/empty/corrupt cache -> {"seen": false, "record": null}
+      (never crash). Found -> {"seen": true, "record": {...}}.
+  record --fp FP --cache PATH --issue-url URL --action A --date YYYY-MM-DD
+      Validate FP + action. Create parent dirs. Merge-write (preserve other fps),
+      atomic via temp file + os.replace. Emit {"written": true, "fp": FP}.
+
+Output: JSON to stdout. Errors are JSON to stdout with exit code 1. A successful
+payload exits 0.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import sys
+import tempfile
+from pathlib import Path
+
+SEVERITIES = ("bug", "friction", "gap")
+STAGES = (
+    "ingest-and-scope",
+    "preflight",
+    "define-done",
+    "execute",
+    "gate",
+    "finalize",
+)
+ACTIONS = ("created", "reacted", "commented", "queued")
+
+SLUG_RE = re.compile(r"^[a-z0-9]+(-[a-z0-9]+)*$")
+FP_RE = re.compile(r"^fp-[0-9a-f]{7}$")
+
+
+def _fail(message: str) -> int:
+    print(json.dumps({"error": message}))
+    return 1
+
+
+def _compute_fp(severity: str, stage: str, slug: str) -> tuple[str, str]:
+    """Return (fp, tuple_string). The tuple string is the exact sha1 input."""
+    step_file = f"skills/ultracode-goal/references/{stage}.md"
+    tuple_str = f"{severity}|ultracode-goal/{stage}|{step_file}|{slug}"
+    digest = hashlib.sha1(tuple_str.encode("utf-8")).hexdigest()[:7]
+    return f"fp-{digest}", tuple_str
+
+
+def cmd_fingerprint(args: argparse.Namespace) -> int:
+    if args.severity not in SEVERITIES:
+        return _fail(
+            "invalid severity %r; expected one of %s"
+            % (args.severity, ", ".join(SEVERITIES))
+        )
+    if args.stage not in STAGES:
+        return _fail(
+            "invalid stage %r; expected one of %s" % (args.stage, ", ".join(STAGES))
+        )
+    if not SLUG_RE.match(args.section_slug):
+        return _fail(
+            "invalid section-slug %r; expected kebab-case ^[a-z0-9]+(-[a-z0-9]+)*$"
+            % args.section_slug
+        )
+
+    fp, tuple_str = _compute_fp(args.severity, args.stage, args.section_slug)
+    print(json.dumps({"fp": fp, "tuple": tuple_str}))
+    return 0
+
+
+def _load_cache(cache: Path) -> dict:
+    """Read the seen-cache as a dict. Missing/empty/corrupt -> {} (never raises)."""
+    try:
+        # errors="replace" so raw non-UTF-8 garbage decodes to junk text rather
+        # than raising at the read stage; the json.loads below then rejects it.
+        text = cache.read_text(encoding="utf-8", errors="replace")
+    except (FileNotFoundError, OSError):
+        return {}
+    if not text.strip():
+        return {}
+    try:
+        data = json.loads(text)
+    except ValueError:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def cmd_seen(args: argparse.Namespace) -> int:
+    if not FP_RE.match(args.fp):
+        return _fail("invalid fp %r; expected ^fp-[0-9a-f]{7}$" % args.fp)
+
+    cache = Path(args.cache).expanduser()
+    data = _load_cache(cache)
+    record = data.get(args.fp)
+    if isinstance(record, dict):
+        print(json.dumps({"seen": True, "record": record}))
+    else:
+        print(json.dumps({"seen": False, "record": None}))
+    return 0
+
+
+def cmd_record(args: argparse.Namespace) -> int:
+    if not FP_RE.match(args.fp):
+        return _fail("invalid fp %r; expected ^fp-[0-9a-f]{7}$" % args.fp)
+    if args.action not in ACTIONS:
+        return _fail(
+            "invalid action %r; expected one of %s"
+            % (args.action, ", ".join(ACTIONS))
+        )
+
+    cache = Path(args.cache).expanduser()
+    cache.parent.mkdir(parents=True, exist_ok=True)
+
+    # Merge: preserve every other fp; a corrupt/empty cache is treated as empty.
+    data = _load_cache(cache)
+    data[args.fp] = {
+        "issue_url": args.issue_url,
+        "action": args.action,
+        "date": args.date,
+    }
+
+    # Atomic write: temp file in the same dir, then os.replace.
+    fd, tmp_name = tempfile.mkstemp(dir=str(cache.parent), prefix=".hc-seen-", suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(data, handle, indent=2, sort_keys=True)
+            handle.write("\n")
+        os.replace(tmp_name, str(cache))
+    except OSError as exc:
+        try:
+            os.unlink(tmp_name)
+        except OSError:
+            pass
+        return _fail("could not write cache %s: %s" % (cache, exc))
+
+    print(json.dumps({"written": True, "fp": args.fp}))
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Fingerprint + seen-cache plumbing for the ultracode-goal health check."
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    fp_parser = sub.add_parser("fingerprint", help="Compute the dedup fingerprint.")
+    fp_parser.add_argument("--severity", required=True)
+    fp_parser.add_argument("--stage", required=True)
+    fp_parser.add_argument("--section-slug", required=True, dest="section_slug")
+    fp_parser.set_defaults(func=cmd_fingerprint)
+
+    seen_parser = sub.add_parser("seen", help="Check the seen-cache for a fingerprint.")
+    seen_parser.add_argument("--fp", required=True)
+    seen_parser.add_argument("--cache", required=True)
+    seen_parser.set_defaults(func=cmd_seen)
+
+    rec_parser = sub.add_parser("record", help="Record a fingerprint outcome to the cache.")
+    rec_parser.add_argument("--fp", required=True)
+    rec_parser.add_argument("--cache", required=True)
+    rec_parser.add_argument("--issue-url", required=True, dest="issue_url")
+    rec_parser.add_argument("--action", required=True)
+    rec_parser.add_argument("--date", required=True)
+    rec_parser.set_defaults(func=cmd_record)
+
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/ultracode-goal/scripts/hooks/budget_stop.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.11"
+# dependencies = []
+# ///
+"""UltraCode-Goal budget Stop hook (Claude Code hook).
+
+Belt-and-suspenders to the in-/goal-condition "stop after N turns" clause:
+counts Stop events (turns) and accumulated tokens for the current story against
+max_turns_per_story / story_token_budget. On overrun it writes an escalation
+marker and surfaces a clear message, then LETS THE STOP PROCEED.
+
+KNOWN LIMITATION: a Stop hook fires only when Claude is *already* trying to stop.
+It cannot interrupt a /goal condition mid-turn — it can record the overrun and
+warn, but the budget ceiling is ultimately advisory at this layer. The hard
+runaway guard is the gate_eval re-loop budget plus the /goal stop-after-N clause;
+this hook is the third, defensive layer.
+
+Hook contract (reads one JSON object on stdin):
+  in : {session_id, cwd, hook_event_name:"Stop", ...}
+  out: exit 0. We never set decision:"block" (we WANT the stop to proceed);
+       on overrun we emit {systemMessage, suppressOutput:false} so the user
+       sees the escalation. JSON is best-effort; absence is also valid.
+
+State + config (env wins so the conductor injects per-story values):
+  ULTRACODE_IMPL_ARTIFACTS    state dir; default <cwd>/_bmad-output/implementation-artifacts
+  ULTRACODE_STORY_ID          current story id; else <impl>/.current-story
+  ULTRACODE_MAX_TURNS         int; default 25
+  ULTRACODE_TOKEN_BUDGET      int; default 1500000
+  ULTRACODE_TURN_TOKENS       int tokens to add this turn (optional; 0 if unknown)
+
+State file: <impl>/.budget-<story>.json  {turns:int, tokens:int}
+Escalation marker: <impl>/.escalation-<story>.md
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+DEFAULT_MAX_TURNS = 25
+DEFAULT_TOKEN_BUDGET = 1_500_000
+
+
+def _read_event() -> dict:
+    try:
+        raw = sys.stdin.read()
+        return json.loads(raw) if raw.strip() else {}
+    except (json.JSONDecodeError, ValueError):
+        return {}
+
+
+def _emit(message: str | None) -> None:
+    """Exit 0 and let the stop proceed; surface a message only on overrun."""
+    if message:
+        print(json.dumps({"systemMessage": message, "suppressOutput": False}))
+    sys.exit(0)
+
+
+def _int_env(name: str, default: int) -> int:
+    try:
+        return int(os.environ.get(name, "") or default)
+    except ValueError:
+        return default
+
+
+def _impl_artifacts(cwd: str | None) -> Path | None:
+    env = os.environ.get("ULTRACODE_IMPL_ARTIFACTS")
+    if env:
+        return Path(env)
+    if cwd:
+        return Path(cwd) / "_bmad-output" / "implementation-artifacts"
+    return None
+
+
+def _current_story(impl: Path | None) -> str:
+    sid = os.environ.get("ULTRACODE_STORY_ID")
+    if sid:
+        return sid.strip()
+    if impl is not None:
+        marker = impl / ".current-story"
+        if marker.is_file():
+            try:
+                return marker.read_text(encoding="utf-8").strip() or "unknown"
+            except OSError:
+                return "unknown"
+    return "unknown"
+
+
+def _load_state(path: Path) -> dict:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return {
+            "turns": int(data.get("turns", 0)),
+            "tokens": int(data.get("tokens", 0)),
+        }
+    except (OSError, json.JSONDecodeError, ValueError, TypeError):
+        return {"turns": 0, "tokens": 0}
+
+
+def _save_state(path: Path, state: dict) -> None:
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(state), encoding="utf-8")
+    except OSError:
+        pass  # state best-effort; never crash a Stop hook
+
+
+def main() -> None:
+    event = _read_event()
+    cwd = event.get("cwd")
+    impl = _impl_artifacts(cwd)
+
+    if impl is None:
+        _emit(None)  # nowhere to keep state; proceed silently
+
+    story = _current_story(impl)
+    max_turns = _int_env("ULTRACODE_MAX_TURNS", DEFAULT_MAX_TURNS)
+    token_budget = _int_env("ULTRACODE_TOKEN_BUDGET", DEFAULT_TOKEN_BUDGET)
+    turn_tokens = _int_env("ULTRACODE_TURN_TOKENS", 0)
+
+    state_path = impl / f".budget-{story}.json"
+    state = _load_state(state_path)
+    state["turns"] += 1
+    state["tokens"] += max(turn_tokens, 0)
+    _save_state(state_path, state)
+
+    over_turns = state["turns"] >= max_turns
+    over_tokens = token_budget > 0 and state["tokens"] >= token_budget
+    if not (over_turns or over_tokens):
+        _emit(None)
+
+    breached = []
+    if over_turns:
+        breached.append(f"turns {state['turns']}/{max_turns}")
+    if over_tokens:
+        breached.append(f"tokens {state['tokens']}/{token_budget}")
+    detail = "; ".join(breached)
+
+    marker = impl / f".escalation-{story}.md"
+    try:
+        marker.parent.mkdir(parents=True, exist_ok=True)
+        marker.write_text(
+            f"# Budget escalation — story {story}\n\n"
+            f"Story budget exceeded ({detail}). UltraCode-Goal stops this story "
+            f"and escalates: re-scope, split, or hand off. A Stop hook cannot "
+            f"interrupt a /goal condition mid-turn, so treat this as advisory — "
+            f"the deterministic guard is the gate_eval re-loop budget.\n",
+            encoding="utf-8",
+        )
+    except OSError:
+        pass
+
+    _emit(
+        f"UltraCode-Goal budget exceeded for story {story} ({detail}). "
+        f"Escalation marker written to {marker}. Stop and escalate this story; "
+        f"do not keep re-looping."
+    )
+
+
+if __name__ == "__main__":
+    main()