okstra 0.158.1 → 0.160.0

package/runtime/python/okstra_ctl/verdict_blocks.py

@@ -0,0 +1,183 @@
+"""Parser for the worker verdict block that plan-body and convergence share.
+
+The response shape is fixed by contract (`prompts/lead/plan-body-verification.md`
+§"Response format"), so the parser belongs here rather than in each lead. A
+per-round ad-hoc regex makes the round's fidelity depend on whoever wrote it,
+and its failure mode is silence: dev-10400 lost 19 of 37 assigned items to a
+no-match that nothing reported. Every shape this module cannot read is an error.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+VERDICT_TOKENS = frozenset({
+    "AGREE", "DISAGREE", "SUPPLEMENT", "UNVERIFIABLE", "VERIFICATION-ERROR",
+})
+FIXABILITY_VALUES = frozenset({"planner-fixable", "needs-user-input"})
+
+# The convergence reverify prompts use their own vocabularies. Collaborative and
+# full-reanalysis rounds speak the schema's own words; the adversarial round asks
+# the verifier to break the finding, so it answers in break/survive terms that
+# have to be translated back (`prompts/lead/convergence.md`
+# §"Adversarial Re-verification Prompt").
+COLLABORATIVE_VERDICTS = {
+    "AGREE": "agree",
+    "DISAGREE": "disagree",
+    "SUPPLEMENT": "supplement",
+    "UNVERIFIABLE": "unverifiable",
+    "VERIFICATION-ERROR": "verification-error",
+}
+ADVERSARIAL_VERDICTS = {
+    "SURVIVES": "agree",
+    "SURVIVES-WITH-CAVEAT": "supplement",
+    "REFUTED": "disagree",
+    # A verifier that looked and could not check is not a verifier that failed.
+    # `verification-error` drops the vote from the participating count, which
+    # shrinks the roster without saying so.
+    "UNVERIFIABLE": "unverifiable",
+    "VERIFICATION-ERROR": "verification-error",
+}
+DISAGREE_BASES = frozenset({"counter-evidence", "burden-not-met"})
+
+_ITEM_RE = re.compile(r"^###[ \t]+(?P<id>[^\s:]+)[ \t]*:?.*$", re.MULTILINE)
+# The contract writes some labels with a parenthetical qualifier —
+# `**Fixability** (only when DISAGREE):` — so the colon may trail a `(...)`.
+_FIELD_RE = re.compile(
+    r"^\*\*(?P<key>Verdict|Fixability|Note|Explanation|Prior dissent|Basis"
+    r"|Your evidence)\*\*"
+    r"(?:[ \t]*\([^)]*\))?[ \t]*:[ \t]*(?P<value>.*)$",
+    re.MULTILINE,
+)
+_VERDICT_RE = re.compile(r"^(?P<token>[A-Z-]+)(?:\((?P<kind>[a-f])\))?$")
+
+
+class VerdictBlockError(ValueError):
+    """Raised when a worker response does not match the contract shape."""
+
+
+@dataclass(frozen=True)
+class FindingVote:
+    """One worker's vote on one convergence finding, in schema vocabulary."""
+
+    finding_id: str
+    verdict: str
+    disagree_basis: str | None
+    explanation: str
+
+
+def _scan_blocks(text: str) -> dict[str, dict[str, str]]:
+    """Every `### <id>` block in *text*, as id → field map, in document order."""
+    matches = list(_ITEM_RE.finditer(text))
+    blocks: dict[str, dict[str, str]] = {}
+    for index, match in enumerate(matches):
+        end = matches[index + 1].start() if index + 1 < len(matches) else len(text)
+        item_id = match.group("id")
+        if item_id in blocks:
+            raise VerdictBlockError(f"item `{item_id}` appears twice in one response")
+        body = text[match.end():end]
+        blocks[item_id] = {
+            m.group("key"): m.group("value").strip() for m in _FIELD_RE.finditer(body)
+        }
+    return blocks
+
+
+def parse_finding_votes(text: str, *, adversarial: bool) -> dict[str, FindingVote]:
+    """Convergence reverify votes in *text*, keyed by finding id.
+
+    *adversarial* selects the vocabulary; guessing it from the content would make
+    an unfamiliar token silently read as a different verdict.
+    """
+    vocabulary = ADVERSARIAL_VERDICTS if adversarial else COLLABORATIVE_VERDICTS
+    return {
+        finding_id: _finding_vote(finding_id, fields, vocabulary)
+        for finding_id, fields in _scan_blocks(text).items()
+    }
+
+
+def _finding_vote(
+    finding_id: str, fields: dict[str, str], vocabulary: dict[str, str]
+) -> FindingVote:
+    raw = fields.get("Verdict", "")
+    token = raw.strip().strip("`").strip().upper()
+    if token not in vocabulary:
+        raise VerdictBlockError(
+            f"finding `{finding_id}` has an unknown verdict: {raw or '(missing)'} "
+            f"— expected one of {sorted(vocabulary)}"
+        )
+    verdict = vocabulary[token]
+    explanation = fields.get("Explanation", "")
+    if not explanation:
+        raise VerdictBlockError(
+            f"finding `{finding_id}` has no `**Explanation**:` line — every vote "
+            f"the classifier reads carries one"
+        )
+    basis = fields.get("Basis", "").strip() or None
+    if verdict != "disagree":
+        basis = None
+    elif basis is not None and basis not in DISAGREE_BASES:
+        raise VerdictBlockError(
+            f"finding `{finding_id}` has basis `{basis}` — expected one of "
+            f"{sorted(DISAGREE_BASES)}"
+        )
+    return FindingVote(finding_id, verdict, basis, explanation)
+
+
+@dataclass(frozen=True)
+class VerdictBlock:
+    """One worker's verdict on one item."""
+
+    item_id: str
+    verdict: str
+    breakage_kind: str
+    fixability: str
+    note: str
+    explanation: str
+    prior_dissent: str
+
+
+def parse_verdict_blocks(text: str) -> dict[str, VerdictBlock]:
+    """Every `### <item-id>` plan-body verdict block in *text*, keyed by item id."""
+    return {
+        item_id: _block(item_id, fields)
+        for item_id, fields in _scan_blocks(text).items()
+    }
+
+
+def _verdict_token(item_id: str, raw: str) -> tuple[str, str]:
+    parsed = _VERDICT_RE.match(raw.strip().strip("`").strip())
+    if parsed is None or parsed.group("token") not in VERDICT_TOKENS:
+        raise VerdictBlockError(
+            f"item `{item_id}` has an unknown verdict: {raw or '(missing)'}"
+        )
+    return parsed.group("token"), parsed.group("kind") or ""
+
+
+def _block(item_id: str, fields: dict[str, str]) -> VerdictBlock:
+    raw = fields.get("Verdict", "")
+    if not raw:
+        raise VerdictBlockError(f"item `{item_id}` has no `**Verdict**:` line")
+    token, kind = _verdict_token(item_id, raw)
+    fixability = fields.get("Fixability", "")
+    if token == "DISAGREE":
+        if not kind:
+            raise VerdictBlockError(
+                f"item `{item_id}` is DISAGREE with no breakage kind — the gate "
+                f"reads the kind to decide whether one vote blocks, so a bare "
+                f"`DISAGREE` cannot be scored"
+            )
+        if fixability not in FIXABILITY_VALUES:
+            raise VerdictBlockError(
+                f"item `{item_id}` is DISAGREE with fixability "
+                f"`{fixability or '(missing)'}` — expected one of "
+                f"{sorted(FIXABILITY_VALUES)}"
+            )
+    return VerdictBlock(
+        item_id=item_id,
+        verdict=token,
+        breakage_kind=kind,
+        fixability=fixability,
+        note=fields.get("Note", ""),
+        explanation=fields.get("Explanation", ""),
+        prior_dissent=fields.get("Prior dissent", ""),
+    )

package/runtime/python/okstra_ctl/wizard.py

@@ -53,8 +53,10 @@ from okstra_ctl.lead_runtime import lead_runtime_info
 from okstra_ctl.runner_resolution import native_provider_for_host
 from okstra_ctl.clarification_items import (
     scan_approval_gate,
+    sidecar_answers,
     user_response_sidecars,
 )
+from okstra_ctl.incremental_scope import preview_link_availability_for_report
 from okstra_ctl.design_prep import (
     DesignPrepError,
     load_design_prep_items,
@@ -94,6 +96,7 @@ from okstra_ctl.workers import (
 from okstra_ctl.workflow import PHASE_SEQUENCE
 from okstra_ctl.wizard_stage_intent import (
     WHOLE_TASK_STAGE,
+    WizardStageIntent,
     WizardStageIntentError,
     resolve_wizard_stage_intent,
     wizard_stage_confirmation_label,
@@ -4570,6 +4573,23 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
     return {"echo": echo or "", "next": prompt_payload(state, nxt)}
 
 
+def _stage_intent(state: WizardState) -> WizardStageIntent:
+    """This state's stage selection, resolved once for every consumer.
+
+    `render_args` needs the single stage this run prepares; `wizard_outcome`
+    needs the chain the skill drives. Deriving them separately would let the two
+    disagree about which stage the run is for.
+    """
+    try:
+        return resolve_wizard_stage_intent(
+            task_type=state.task_type,
+            selected_stage=state.selected_stage,
+            selected_stages=state.selected_stages,
+        )
+    except WizardStageIntentError as exc:
+        raise WizardError(str(exc)) from exc
+
+
 def render_args(state: WizardState) -> dict[str, str]:
     """Convert finalized state into ``okstra render-bundle`` argument map."""
     if state.aborted:
@@ -4584,14 +4604,7 @@ def render_args(state: WizardState) -> dict[str, str]:
         if state.reuse_worktree or state.task_type == "final-verification"
         else state.base_ref
     )
-    try:
-        stage_intent = resolve_wizard_stage_intent(
-            task_type=state.task_type,
-            selected_stage=state.selected_stage,
-            selected_stages=state.selected_stages,
-        )
-    except WizardStageIntentError as exc:
-        raise WizardError(str(exc)) from exc
+    stage_intent = _stage_intent(state)
     pr_template = (
         state.pr_template_path
         if state.task_type == "release-handoff"
@@ -4624,7 +4637,6 @@ def render_args(state: WizardState) -> dict[str, str]:
         "approved-plan": state.approved_plan_path,
         "stage": stage_intent.stage,
         "stages": state.handoff_stages,
-        "chain-stages": stage_intent.chain_stages,
         "base-ref": base_ref,
         "workers": workers,
         "directive": state.directive,
@@ -4643,6 +4655,37 @@ def render_args(state: WizardState) -> dict[str, str]:
     }
 
 
+def _reverify_scope_line(state: WizardState) -> Optional[str]:
+    """이번 clarification 재실행이 좁혀질지 — 확인 단계에서 미리 보여주는 줄.
+
+    이 판정의 절반(답변된 id 가 stage 로 되짚어지는지)은 base SHA 없이 결정되고
+    직전 리포트만 있으면 이미 정해져 있다. 그런데 지금까지는 `okstra recap
+    assemble` 을 따로 돌려야만 보였고, run 이 시작된 뒤에 full 로 밝혀지면 두
+    시간을 물린 뒤였다. 확인 단계는 그 전에 되돌릴 수 있는 마지막 지점이다.
+    """
+    if state.task_type != "implementation-planning":
+        return None
+    if not state.clarification_response_path or not state.project_root:
+        return None
+    report = _resolve_path(
+        state.clarification_response_path, Path(state.project_root)
+    )
+    if not report.is_file():
+        return None
+    preview = preview_link_availability_for_report(
+        report, set(sidecar_answers(report))
+    )
+    if not preview["wouldForceFull"]:
+        return _msg(state.workspace_root, "confirmation",
+                    "reverify_scope_incremental")
+    if preview["unlinkedIds"]:
+        return _msg(state.workspace_root, "confirmation",
+                    "reverify_scope_unlinked",
+                    ids=", ".join(preview["unlinkedIds"]))
+    return _msg(state.workspace_root, "confirmation", "reverify_scope_full",
+                reason=preview["reason"])
+
+
 def confirmation_block(state: WizardState) -> str:
     """Human-readable echo of the resolved selections (for the Confirm step)."""
     header = _msg(state.workspace_root, "confirmation", "header")
@@ -4727,6 +4770,9 @@ def confirmation_block(state: WizardState) -> str:
         lines.append(f"  stage         : {stage}")
     if state.clarification_response_path:
         lines.append(f"  clarification : {state.clarification_response_path}")
+        reverify_line = _reverify_scope_line(state)
+        if reverify_line is not None:
+            lines.append(reverify_line)
     if state.task_type == "release-handoff" and state.handoff_mode:
         scope = (
             _msg(state.workspace_root, "confirmation",
@@ -4760,13 +4806,21 @@ def _wizard_persist_actions(state: WizardState) -> list[dict[str, str]]:
 
 
 def wizard_outcome(state: WizardState) -> dict[str, Any]:
-    """Public outcome for callers that need launch data and follow-up writes."""
+    """Public outcome for callers that need launch data and follow-up writes.
+
+    `renderArgs` carries only what `okstra render-bundle` accepts, so a caller
+    can pass every entry through unfiltered — which is exactly what the
+    okstra-run skill is told to do. Signals the skill consumes itself, like the
+    unattended stage chain, live under `orchestration`; mixing them into
+    `renderArgs` made the renderer reject the wizard's own output.
+    """
     if state.aborted:
         raise WizardError("wizard was aborted by the user — outcome is unavailable")
     if state.confirmed is not True:
         raise WizardError("wizard is not complete — outcome is unavailable")
     return {
         "renderArgs": render_args(state),
+        "orchestration": {"chainStages": _stage_intent(state).chain_stages},
         "persistActions": _wizard_persist_actions(state),
         "confirmationText": confirmation_block(state),
     }

package/runtime/python/okstra_ctl/worker_audit_check.py

@@ -0,0 +1,44 @@
+"""CLI adapter for the worker audit-sidecar contract (`okstra worker-audit-check`).
+
+Phase 7 runs the same rules through `validate-run.py`, but by then the worker
+session is gone and the only remedies left are a retroactive edit — which breaks
+the audit chain — or a failed run. Called the moment a worker returns, the same
+rules cost one message to a worker that is still listening.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from okstra_ctl.worker_audit_ledger import check_worker_results_audit
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="okstra worker-audit-check",
+        description="Check one run's worker audit sidecars (read-only).",
+    )
+    parser.add_argument("--run-dir", type=Path, required=True,
+                        help="runs/<task-type>/ for this run")
+    parser.add_argument("--task-type", required=True)
+    parser.add_argument("--seq", required=True,
+                        help="this run's 3-digit seq")
+    parser.add_argument("--worker", default=None,
+                        help="check only this worker id (default: every worker)")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    failures = check_worker_results_audit(
+        args.run_dir, args.task_type, args.seq, worker=args.worker
+    )
+    print(json.dumps({"ok": not failures, "failures": failures},
+                     ensure_ascii=False, indent=2))
+    return 2 if failures else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/runtime/python/okstra_ctl/worker_audit_ledger.py

@@ -0,0 +1,207 @@
+"""The worker audit-sidecar contract, shared by Phase 7 and the mid-run check.
+
+Phase 7 has always enforced this post-hoc, but by then the worker session is
+gone and the only remedies left are editing the result after the fact — which
+breaks the audit chain — or failing the run. `okstra worker-audit-check` runs
+the same rules the moment a worker returns, while the worker is still listening
+and can fix its own citation. Both consumers must agree on what a violation is,
+so the rules live here rather than inside either one — the same split
+`worker_heartbeat` makes for the heartbeat cadence.
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from okstra_ctl.worker_prompt_headers import EVIDENCE_LEDGER_HEADER
+
+# Worker-results filename pattern: `<worker-role>-<task-type>-<seq>.md`.
+# Every analysis-worker role name ends in `-worker` (`claude-worker`,
+# `codex-worker`, `antigravity-worker`, `report-writer-worker`), so anchor the
+# split on that suffix — otherwise `antigravity-worker-error-analysis-001.md`
+# ambiguously parses as `worker=antigravity, task=worker-error-analysis`.
+# Audit sidecars (`*-audit-*`) and errors sidecars (`.json`) are not matched here.
+_WORKER_RESULT_BASENAME_RE = re.compile(
+    r"^(?P<worker>[a-z][a-z0-9-]*-worker)-(?P<task_type>[a-z][a-z-]*?)-(?P<seq>\d{3})\.md$"
+)
+
+READING_CONFIRMATION_HEADING_RE = re.compile(
+    r"^##[ \t]+0\.[ \t]+Reading Confirmation\b", re.MULTILINE
+)
+
+_EVIDENCE_READ_RE = re.compile(
+    r"^- Evidence read: `(?P<path>[^`\n]+)`\s*$",
+    re.MULTILINE,
+)
+_FILE_LINE_CITATION_RE = re.compile(
+    r"`(?P<path>(?!https?://)[^`\n]+?):(?P<line>\d+(?:-\d+)?)`"
+)
+_EXTENSIONLESS_SOURCE_FILENAMES = frozenset(
+    {"Dockerfile", "Justfile", "Makefile", "Procfile", "Rakefile"}
+)
+
+
+def _looks_like_file_path(path: str) -> bool:
+    if (
+        not path
+        or path.startswith(("-", "$"))
+        or any(char.isspace() for char in path)
+    ):
+        return False
+    if re.fullmatch(r"[0-9a-fA-F]{7,64}", path):
+        return False
+    return (
+        "/" in path
+        or "." in Path(path).name
+        or Path(path).name in _EXTENSIONLESS_SOURCE_FILENAMES
+    )
+
+
+def _cited_file_paths(content: str) -> set[str]:
+    paths: set[str] = set()
+    for match in _FILE_LINE_CITATION_RE.finditer(content):
+        path = match.group("path")
+        if _looks_like_file_path(path):
+            paths.add(path)
+    return paths
+
+
+def _audit_evidence_read_paths(content: str) -> set[str]:
+    return {
+        match.group("path")
+        for match in _EVIDENCE_READ_RE.finditer(content)
+    }
+
+
+def _worker_prompt_path(
+    run_dir: Path,
+    worker_role: str,
+    task_type: str,
+    seq: str,
+) -> Path:
+    return run_dir / "prompts" / f"{worker_role}-prompt-{task_type}-{seq}.md"
+
+
+def _evidence_read_ledger_failures(
+    *,
+    run_dir: Path,
+    worker_role: str,
+    task_type: str,
+    seq: str,
+    result_name: str,
+    result_content: str,
+    audit_path: Path,
+) -> list[str]:
+    if worker_role == "report-writer-worker":
+        return []
+    prompt_path = _worker_prompt_path(run_dir, worker_role, task_type, seq)
+    try:
+        prompt_content = prompt_path.read_text(encoding="utf-8")
+    except OSError:
+        return []
+    if EVIDENCE_LEDGER_HEADER not in prompt_content.splitlines():
+        return []
+    try:
+        audit_content = audit_path.read_text(encoding="utf-8")
+    except OSError as exc:
+        return [f"worker audit sidecar unreadable: {audit_path.name} ({exc})"]
+
+    missing_paths = sorted(
+        _cited_file_paths(result_content) - _audit_evidence_read_paths(audit_content)
+    )
+    return [
+        f"worker `{worker_role}` result `{result_name}` cites "
+        f"`{missing_path}:line` without an Evidence read row for "
+        f"`{missing_path}` in `{audit_path.name}`"
+        for missing_path in missing_paths
+    ]
+
+
+def _result_files(run_dir: Path, task_type: str, seq: str | None, worker: str | None):
+    """Every worker-results file in *run_dir* this check owns, in name order."""
+    for path in sorted((run_dir / "worker-results").glob("*.md")):
+        if "-audit-" in path.name:
+            continue
+        match = _WORKER_RESULT_BASENAME_RE.match(path.name)
+        if match is None:
+            # Files that don't match the canonical pattern (e.g. ad-hoc notes
+            # left by the operator) are out of contract scope.
+            continue
+        if match.group("task_type") != task_type:
+            # Cross-phase artifacts shouldn't appear here; skip rather than
+            # fail to keep the check focused on the current phase.
+            continue
+        if seq is not None and match.group("seq") != seq:
+            # A prior run's artifact. Its contract was judged when it ran.
+            continue
+        if worker is not None and match.group("worker") != worker:
+            continue
+        yield path, match.group("worker"), match.group("seq")
+
+
+def check_worker_results_audit(
+    run_dir: Path,
+    task_type: str,
+    seq: str | None,
+    *,
+    worker: str | None = None,
+) -> list[str]:
+    """Every audit-sidecar contract failure among this run's worker results.
+
+    *run_dir* is `runs/<task-type>/`; `worker-results/` and `prompts/` hang off
+    it. *seq* scopes the check to one run — `worker-results/` accumulates every
+    run's artifacts, so scanning the whole directory judged a run by files it
+    did not produce. Pass ``None`` only when the seq is genuinely unknown, which
+    falls back to not filtering rather than silently checking nothing.
+
+    For each result file this checks that it carries no `## 0. Reading
+    Confirmation` heading (that block moved to the sidecar), that the matching
+    sidecar exists, and — for prompts carrying the required-v1 evidence-ledger
+    marker — that every backticked `path:line` citation has an Evidence read row.
+    """
+    failures: list[str] = []
+    if not (run_dir / "worker-results").is_dir():
+        # No worker-results directory means no analysis workers ran (e.g.
+        # `release-handoff`, which is single-lead). Nothing to enforce.
+        return failures
+
+    for path, worker_role, result_seq in _result_files(run_dir, task_type, seq, worker):
+        rel = path.name
+        try:
+            content = path.read_text()
+        except OSError as exc:
+            failures.append(f"worker-results file unreadable: {rel} ({exc})")
+            continue
+
+        if READING_CONFIRMATION_HEADING_RE.search(content) is not None:
+            failures.append(
+                f"worker-results file `{rel}` contains a `## 0. Reading "
+                f"Confirmation` heading — that block moved to the audit "
+                f"sidecar (`{worker_role}-audit-{task_type}-{result_seq}.md`). "
+                f"Remove the §0 heading + body from the main file and "
+                f"write a fresh sidecar."
+            )
+
+        audit_path = (
+            run_dir / "worker-results"
+            / f"{worker_role}-audit-{task_type}-{result_seq}.md"
+        )
+        if not audit_path.exists():
+            failures.append(
+                f"worker `{worker_role}` produced `{rel}` but no audit sidecar "
+                f"at `{audit_path.name}` — the sidecar must carry the Reading "
+                f"Confirmation block (one short line per input file). Workers "
+                f"write this in the same step as the main worker-results file."
+            )
+            continue
+
+        failures.extend(_evidence_read_ledger_failures(
+            run_dir=run_dir,
+            worker_role=worker_role,
+            task_type=task_type,
+            seq=result_seq,
+            result_name=rel,
+            result_content=content,
+            audit_path=audit_path,
+        ))
+    return failures

package/runtime/python/okstra_ctl/worker_heartbeat.py

@@ -18,6 +18,10 @@ HEARTBEAT_LINE_RE = re.compile(
     r"^-[ \t]*PROGRESS:[ \t]*(?P<stage>\S+)[ \t]+(?P<ts>\S+)[ \t]*$", re.MULTILINE
 )
 
+# 한 단계가 cadence 보다 길어질 때 워커가 append 하는 진행 라인의 접두사
+# (claude-worker.md "Heartbeat"). 뒤에 붙는 stage 이름은 원래 단계 그대로다.
+IN_STAGE_PREFIX = "in-stage:"
+
 # 계약상 cadence 는 5분. append 직전 측정한 시각과 실제 쓰기 사이 지연을 흡수하는
 # 고정 grace 60초를 더한다.
 HEARTBEAT_MAX_GAP_SECONDS = 5 * 60 + 60
@@ -48,10 +52,12 @@ def max_gap_seconds_after(stage: str) -> int:
     """*stage* 를 알린 뒤 다음 하트비트까지 허용되는 최대 공백(초).
 
     간격이 재는 것은 직전에 선언된 단계의 작업 시간이므로, 예산은 언제나
-    구간을 *여는* 단계에서 고른다."""
-    if stage in SINGLE_WRITE_STAGES:
+    구간을 *여는* 단계에서 고른다. `in-stage:<X>` 는 아직 X 안에 있다는 뜻이라
+    그 라인이 여는 구간도 여전히 X 의 일부다 — 접두사를 떼고 X 의 예산을 쓴다."""
+    opener = stage.removeprefix(IN_STAGE_PREFIX)
+    if opener in SINGLE_WRITE_STAGES:
         return SINGLE_WRITE_MAX_GAP_SECONDS
-    if stage in SYNTHESIS_STAGES:
+    if opener in SYNTHESIS_STAGES:
         return SYNTHESIS_MAX_GAP_SECONDS
     return HEARTBEAT_MAX_GAP_SECONDS