okstra 0.149.0 → 0.150.0

package/runtime/python/okstra_ctl/report_views.py

@@ -132,12 +132,23 @@ def _infer_run_meta_from_path(path: Path) -> dict:
     return {"task_type": m.group("task_type"), "seq": m.group("seq")} if m else {}
 
 
+# 리포트 헤더는 이 값들을 인라인 코드로 렌더한다 (`- Task Type: \`x\``). 마커를
+# 벗기지 않으면 백틱이 sidecar 파일명과 frontmatter 로 새고, 다음 run 의
+# clarification 캐리인이 `user-response-<task-type>-<seq>.md` 매칭에 실패한다.
+_INLINE_CODE_VALUE_RE = re.compile(r"^`(?P<value>.+)`$")
+
+
+def _strip_inline_code(value: str) -> str:
+    m = _INLINE_CODE_VALUE_RE.match(value)
+    return m.group("value").strip() if m else value
+
+
 def _infer_run_meta_from_body(text: str) -> dict:
     found: dict[str, str] = {}
     for label, key in (("Task Key", "task_key"), ("Task Type", "task_type")):
         m = re.search(rf"^- {label}:\s*(\S.*?)\s*$", text, re.MULTILINE)
         if m:
-            found[key] = m.group(1)
+            found[key] = _strip_inline_code(m.group(1))
     return found
 
 
@@ -145,9 +156,14 @@ def infer_run_meta(report_path: Path, *, task_key: Optional[str] = None,
                    task_type: Optional[str] = None, seq: Optional[str] = None,
                    source_report: Optional[str] = None) -> RunMeta:
     """Derive a ``RunMeta`` from a final-report path/body, honouring any
-    explicit override. Single reference point for BOTH the HTML view render
-    script and the in-session user-response writer, so sidecar match keys
-    (task_type/seq/source-report) never drift between the two paths."""
+    explicit override.
+
+    Used by the schema-v1 HTML view render script and by the in-session
+    user-response writer. Schema-v2 resolves its own ``HtmlRunMeta`` from the
+    data.json header instead, so the sidecar match keys (task_type/seq/
+    source-report) this produces must agree with that header — the sidecar
+    name the v2 HTML advertises is the one the next run's carry-in looks for.
+    """
     text = report_path.read_text(encoding="utf-8")
     inferred = {**_infer_run_meta_from_path(report_path), **_infer_run_meta_from_body(text)}
     return RunMeta(
@@ -1194,9 +1210,7 @@ def analysis_review_context(src_md_path: Path) -> AnalysisReviewContext | None:
     return AnalysisReviewContext(selector_ids=tuple(sorted(found)))
 
 
-def plan_approval_context(
-    src_md_path: Path, src_text: str
-) -> PlanApprovalContext | None:
+def plan_approval_context(src_md_path: Path) -> PlanApprovalContext | None:
     """implementation-planning 보고서 + sibling data.json 의 optionCandidates 가
     있을 때만 컨텍스트를 만든다. planning 여부는 task-type 문자열이 아니라
     data.json 의 ``implementationPlanning`` 키(SSOT)로 판정한다 — renderer 와
@@ -1209,7 +1223,7 @@ def plan_approval_context(
     state = plan_approval_state(data)
     if state is None:
         return None
-    scan = scan_approval_gate(src_text)
+    scan = scan_approval_gate(src_md_path)
     blocker_ids = state.blocker_ids
     reason = state.disabled_reason
     if scan.unreadable_reason:
@@ -1418,7 +1432,7 @@ def render_html_view(
             "re-render the report so §1 matches the schema before generating "
             "the HTML view."
         )
-    approval_ctx = plan_approval_context(src_md_path, src_text)
+    approval_ctx = plan_approval_context(src_md_path)
     analysis_review_ctx = analysis_review_context(src_md_path)
     reader_ctx = reader_dashboard_context(src_md_path, src_text, approval_ctx)
     has_clarifications = report_has_clarification_items(src_text)

package/runtime/python/okstra_ctl/run.py

@@ -434,7 +434,7 @@ def _validate_approved_plan(path: str) -> None:
     _validate_data_json_approval_consistency(p, markdown_approved=True)
     # frontmatter approved == true 상태. §1 Clarification Items 의
     # Blocks=approval 행이 아직 open/answered 면 승인을 무효화한다.
-    scan = scan_approval_gate(body)
+    scan = scan_approval_gate(p)
     if scan.unreadable_reason:
         raise PrepareError(
             f"approved plan §1 approval gate could not be read: {path}\n"

package/runtime/python/okstra_ctl/user_response.py

@@ -24,7 +24,7 @@ from okstra_ctl.report_views import (
 from okstra_ctl.report_view_artifacts import user_responses_dir_for_report
 from okstra_ctl.listing import list_runs, absolute_final_report_path
 from okstra_ctl.clarification_items import (
-    parse_clarification_rows,
+    read_clarification_rows,
     scan_open_user_input,
     section_1_present_but_unparsed,
     _section_1_slice,
@@ -320,9 +320,14 @@ def load_authoritative_analysis_review(
         if _analysis_review_matches_with_valid_created_at(text):
             attached.append(f"\n## {sidecar.name}\n\n{text.strip()}\n")
     if not attached:
-        raise UserResponseError(
-            "existing review sidecar has no ANALYSIS REVIEW block"
-        )
+        # `sidecar_name` matches every user-response sidecar for this run, not
+        # just review ones — recording a clarification answer produces the same
+        # filename. No `## ANALYSIS REVIEW` block in any of them means no review
+        # was attached, which is what `None` says; raising here made the routine
+        # act of answering a clarification disqualify the report as a carry-in
+        # candidate. A block that *is* present but malformed still raises, in
+        # `_analysis_review_matches_with_valid_created_at` above.
+        return None
     review = parse_analysis_review("".join(attached))
     if review is None:
         raise UserResponseError("analysis review sidecar is unreadable")
@@ -443,7 +448,7 @@ def list_awaiting_tasks(home: Path, project_id: str, limit: int) -> list[dict]:
         if report is None or not report.is_file():
             continue
         text = report.read_text(encoding="utf-8")
-        scan = scan_open_user_input(text)
+        scan = scan_open_user_input(report)
         base = {"taskKey": key, "taskType": row.get("taskType", ""),
                 "seq": _seq_from_report(report), "reportPath": str(report),
                 "reportMtime": report.stat().st_mtime}
@@ -541,7 +546,7 @@ def resolve_refs(report_text: str, refs: list[str]) -> list[dict]:
 def show_open_rows(report_path: Path) -> dict:
     text = report_path.read_text(encoding="utf-8")
     rows = []
-    for r in parse_clarification_rows(text):
+    for r in read_clarification_rows(report_path):
         it = r["item"]
         if it.status not in ("open", "answered"):
             continue

package/runtime/python/okstra_ctl/wizard.py

@@ -185,6 +185,8 @@ _RECOMMENDATION_CAP = 3
 # Pick-vs-free-text tokens shared by suggestion-aware prompts.
 PICK_USE_SUGGESTED = "__use_suggested__"
 PICK_TYPE_CUSTOM = "__free_input__"
+# workers_override 에서 "옵션 워커를 추가하지 않음" 을 뜻하는 sentinel.
+_DEFAULT_ROSTER_TOKEN = "__default_roster__"
 _RECENT_PREFIX = "__recent:"
 _REPORT_PREFIX = "__report:"
 _BRIEF_PREFIX = "__brief:"
@@ -318,6 +320,7 @@ S_CRITIC_TEXT = "critic_text"
 S_REUSE_PREVIOUS = "reuse_previous"
 S_DEFAULTS_OR_CUSTOM = "defaults_or_custom"
 S_WORKERS_OVERRIDE = "workers_override"
+S_WORKERS_CUSTOM = "workers_custom"
 S_LEAD_MODEL = "lead_model"
 S_EXECUTOR_MODEL = "executor_model"
 S_CLAUDE_MODEL = "claude_model"
@@ -444,6 +447,7 @@ class WizardState:
     # customize
     use_defaults: Optional[bool] = None
     workers_override: str = ""
+    workers_custom_pending: bool = False
     lead_provider: str = ""
     lead_model: str = ""
     claude_model: str = ""
@@ -632,7 +636,7 @@ def _classify_approved_plan(path_str: str, project_root: Path) -> tuple[Path, bo
     # A blocking gate or an open Blocks=approval row makes the plan UN-approvable
     # — these raise regardless of the current flag value.
     _reject_blocking_plan_body_gate(p, body, action="approved plan validation")
-    scan = scan_approval_gate(body)
+    scan = scan_approval_gate(p)
     if scan.unreadable_reason:
         raise WizardError(
             f"approved plan §1 approval gate could not be read: {p}\n"
@@ -3367,35 +3371,29 @@ def _submit_defaults_or_custom(state: WizardState, value: str) -> Optional[str]:
     return f"model-mode: {mode}"
 
 
-def _build_workers_override(state: WizardState) -> Prompt:
-    """분석 워커 멀티픽. report-writer 는 옵션에서 빼고 항상 결과에 강제
-    포함시킨다(프로필이 report-writer 를 Required 로 가질 때)."""
-    t = _p(state.workspace_root, "workers_override")
-    optional_suffix = t["options"].get("_OPTIONAL_SUFFIX", "")
-    analyser_choices = [
+def _analyser_choices(state: WizardState) -> list[str]:
+    """프로필이 분석 워커로 허용하는 전체 후보 (report-writer 제외)."""
+    return [
         w for w in (state.profile_workers + state.profile_optional_workers)
         if w != "report-writer"
     ]
-    options: list[Option] = []
-    for w in analyser_choices:
-        is_optional = w in state.profile_optional_workers
-        label = f"{w}{optional_suffix}" if is_optional else w
-        options.append(_opt(value=w, label=label))
-    return Prompt(
-        step=S_WORKERS_OVERRIDE, kind="pick", multi=True,
-        label=t["label"],
-        options=options,
-        echo_template=t["echo_template"],
-    )
 
 
-def _submit_workers_override(state: WizardState, value: str) -> Optional[str]:
-    raw = (value or "").strip()
+def _default_analysers(state: WizardState) -> list[str]:
+    """옵션 워커를 하나도 고르지 않았을 때 쓰는 기본 분석 로스터."""
+    return [w for w in state.profile_workers if w != "report-writer"]
+
+
+def _analyser_option(state: WizardState, worker: str, suffix: str) -> Option:
+    label = f"{worker}{suffix}" if worker in state.profile_optional_workers else worker
+    return _opt(value=worker, label=label)
+
+
+def _finalize_workers(state: WizardState, workers: list[str]) -> str:
+    """정규화 → 프로필 allowlist 검증 → report-writer 강제 포함까지의 확정 경로.
+    두 워커 단계가 공유한다."""
     try:
-        chosen = normalize_workers(raw) if raw else []
-        if not chosen:
-            t = _p(state.workspace_root, "workers_override")
-            raise WizardError(t["errors"]["min_one_required"])
+        chosen = normalize_workers(",".join(workers))
         validate_workers_against_profile(
             chosen,
             state.profile_workers,
@@ -3411,6 +3409,72 @@ def _submit_workers_override(state: WizardState, value: str) -> Optional[str]:
     return f"workers: {state.workers_override}"
 
 
+def _build_workers_override(state: WizardState) -> Prompt:
+    """분석 워커 멀티픽. 기본 로스터(예: claude·codex)는 매 run 사실상 고정이라
+    옵션에서 빼고 결과에 항상 포함시킨다 — 화면에는 '기본 그대로' + 옵션 워커 +
+    '직접 선택'만 남는다. report-writer 도 같은 이유로 빠진다. 기본 로스터에서
+    워커를 빼는 축소는 '직접 선택'(`workers_custom`)에서만 가능하다."""
+    t = _p(state.workspace_root, "workers_override")
+    labels = t["labels"]
+    options = [_opt(
+        _DEFAULT_ROSTER_TOKEN,
+        labels["default_roster"].format(
+            workers=" + ".join(_default_analysers(state))),
+    )]
+    for w in state.profile_optional_workers:
+        options.append(_opt(w, labels["add_optional"].format(worker=w)))
+    options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
+    return Prompt(
+        step=S_WORKERS_OVERRIDE, kind="pick", multi=True,
+        label=t["label"],
+        options=options,
+        echo_template=t["echo_template"],
+    )
+
+
+def _submit_workers_override(state: WizardState, value: str) -> Optional[str]:
+    t = _p(state.workspace_root, "workers_override")
+    picked = [v.strip() for v in (value or "").split(",") if v.strip()]
+    if not picked:
+        raise WizardError(t["errors"]["min_one_required"])
+    if PICK_TYPE_CUSTOM in picked:
+        if len(picked) > 1:
+            raise WizardError(t["errors"]["custom_must_be_alone"])
+        state.workers_custom_pending = True
+        return None
+    allowed = {_DEFAULT_ROSTER_TOKEN, *state.profile_optional_workers}
+    unknown = [w for w in picked if w not in allowed]
+    if unknown:
+        raise WizardError(
+            t["errors"]["unknown_option"].format(values=",".join(unknown)))
+    state.workers_custom_pending = False
+    added = [w for w in picked if w != _DEFAULT_ROSTER_TOKEN]
+    return _finalize_workers(state, _default_analysers(state) + added)
+
+
+def _build_workers_custom(state: WizardState) -> Prompt:
+    """'직접 선택' 화면 — 기본 로스터까지 포함한 전체 분석 워커 후보.
+    기본 워커를 빼는 축소는 이 화면에서만 가능하다."""
+    t = _p(state.workspace_root, "workers_custom")
+    suffix = t["options"].get("_OPTIONAL_SUFFIX", "")
+    return Prompt(
+        step=S_WORKERS_CUSTOM, kind="pick", multi=True,
+        label=t["label"],
+        options=[_analyser_option(state, w, suffix)
+                 for w in _analyser_choices(state)],
+        echo_template=t["echo_template"],
+    )
+
+
+def _submit_workers_custom(state: WizardState, value: str) -> Optional[str]:
+    picked = [v.strip() for v in (value or "").split(",") if v.strip()]
+    if not picked:
+        t = _p(state.workspace_root, "workers_custom")
+        raise WizardError(t["errors"]["min_one_required"])
+    state.workers_custom_pending = False
+    return _finalize_workers(state, picked)
+
+
 def _model_pick(step: str, label: str, options: list[str], echo: str) -> Prompt:
     # "default" picks the role's recommended model — leaving it here yields
     # the SAME result as the 'Use defaults' branch. Spell that out on the
@@ -4065,7 +4129,14 @@ STEPS: list[Step] = [
                             )
                             and S_WORKERS_OVERRIDE not in s.answered),
          build=_build_workers_override, submit=_submit_workers_override,
-         owns=("workers_override",)),
+         owns=("workers_override", "workers_custom_pending")),
+    # "직접 선택" 을 고른 run 에서만 등장한다 — 기본 로스터에서 워커를 빼는
+    # 축소가 가능한 유일한 화면.
+    Step(S_WORKERS_CUSTOM,
+         applies=lambda s: (s.workers_custom_pending
+                            and S_WORKERS_CUSTOM not in s.answered),
+         build=_build_workers_custom, submit=_submit_workers_custom,
+         owns=("workers_override", "workers_custom_pending")),
     Step(S_LEAD_MODEL,
          applies=lambda s: (s.use_defaults is False
                             and S_LEAD_MODEL not in s.answered),
@@ -4234,6 +4305,8 @@ def _ready_for_confirm(s: WizardState) -> bool:
     workers_step = STEP_BY_ID[S_WORKERS_OVERRIDE]
     if workers_step.applies(s):
         return False
+    if STEP_BY_ID[S_WORKERS_CUSTOM].applies(s):
+        return False
     if s.use_defaults:
         return True
     # customize: every customize-branch step must be answered or not-applicable.
@@ -4264,6 +4337,7 @@ def _reset_from(state: WizardState, target_step: str) -> None:
         S_FEATURE_EVIDENCE: "feature_evidence_pending_text",
         S_PROJECT_EVIDENCE: "project_evidence_pending_text",
         S_ANALYSIS_TARGET: "analysis_target_pending_text",
+        S_WORKERS_CUSTOM: "workers_custom_pending",
     }
     pending_field = direct_input_pending.get(target_step)
     if pending_field is not None:
@@ -4294,6 +4368,7 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "executor": "", "critic": "", "critic_pending_text": False,
     "reuse_previous": None,
     "use_defaults": None, "workers_override": "",
+    "workers_custom_pending": False,
     "lead_provider": "", "lead_model": "", "claude_model": "", "codex_model": "",
     "antigravity_model": "", "grok_model": "", "kimi_model": "",
     "report_writer_provider": "", "report_writer_model": "", "directive": "",

package/runtime/python/okstra_ctl/worker_liveness.py

@@ -10,27 +10,40 @@ one-retry budget") and the absence of any `did-not-launch` status at all.
 This module is that mechanism. It reports, not decides: the lead reads the
 verdict and spends its existing one-retry budget.
 
-Two probes, matching the two ways a pending worker goes quiet:
-
-* ``--audit`` — an in-process worker audit sidecar. Stale past the heartbeat
-  cadence (or present with no heartbeat at all) means the worker hung. Uses
-  the same line shape and budget the Phase 7 validator applies.
-* ``--team-state`` + ``--worker`` — a CLI-wrapper assignment. Neither the
-  worker's `<prompt>.log` nor `<prompt>.status.json` past the launch grace means
-  the wrapper never ran. The grace starts at the persisted dispatch timestamp,
-  not when the prompt was materialized.
+Every probe is selected the same way — ``--team-state`` + ``--worker`` — and the
+worker row's ``livenessMode`` decides which of the two artifacts answers:
+
+* ``audit-heartbeat`` — an in-process worker's audit sidecar. Stale past the
+  heartbeat cadence (or present with no heartbeat at all) means the worker
+  hung. Uses the same line shape and budget the Phase 7 validator applies.
+* ``wrapper-status`` — a CLI-wrapper assignment. Neither the worker's
+  `<prompt>.log` nor `<prompt>.status.json` past the launch grace means the
+  wrapper never ran.
+
+Both graces start at the persisted dispatch timestamp (``workers[].startedAt``),
+never at an artifact's mtime. That anchor is why the selector needs team-state:
+the audit sidecar is reused when a worker is re-dispatched, so without knowing
+when *this* dispatch started, the previous dispatch's last heartbeat reads as
+this worker's newest signal and a freshly launched worker probes `stalled`.
 """
 from __future__ import annotations
 
 import argparse
 import json
 import sys
+from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
 
-from okstra_ctl.dispatch_state import DispatchError, load_json_object
+from okstra_ctl.dispatch_state import (
+    DispatchError,
+    LIVENESS_AUDIT_HEARTBEAT,
+    LIVENESS_WRAPPER_STATUS,
+    load_json_object,
+)
 from okstra_ctl.worker_heartbeat import (
     HEARTBEAT_MAX_GAP_SECONDS,
+    Heartbeat,
     latest_heartbeat,
     max_gap_seconds_after,
 )
@@ -43,7 +56,13 @@ def _log_path(prompt: Path) -> Path:
     return prompt.with_suffix(".log") if prompt.suffix == ".md" else Path(f"{prompt}.log")
 
 
-def probe_heartbeat(sidecar: Path, now: datetime, max_idle: float) -> dict:
+def probe_heartbeat(
+    sidecar: Path,
+    dispatched_at: datetime,
+    now: datetime,
+    max_idle: float,
+    grace: float,
+) -> dict:
     """Liveness of one in-process worker, read from its audit sidecar.
 
     ``max_idle`` is the floor. A stage whose work is one uninterruptible tool
@@ -62,6 +81,8 @@ def probe_heartbeat(sidecar: Path, now: datetime, max_idle: float) -> dict:
             "state": "stalled",
             "reason": "audit sidecar carries no `- PROGRESS:` heartbeat",
         }
+    if beat.at < dispatched_at:
+        return _probe_before_first_beat(probe, beat, dispatched_at, now, grace)
     budget = max(max_idle, max_gap_seconds_after(beat.stage))
     idle = (now - beat.at).total_seconds()
     state = "stalled" if idle > budget else "live"
@@ -81,6 +102,41 @@ def probe_heartbeat(sidecar: Path, now: datetime, max_idle: float) -> dict:
     }
 
 
+def _probe_before_first_beat(
+    probe: dict,
+    beat: Heartbeat,
+    dispatched_at: datetime,
+    now: datetime,
+    grace: float,
+) -> dict:
+    """Verdict when the newest heartbeat predates this dispatch.
+
+    The audit sidecar is reused on re-dispatch, so that beat belongs to the
+    previous attempt and this one has produced no signal yet — the launch
+    grace decides, and the idle measure runs from the dispatch, never from a
+    heartbeat this worker never wrote.
+    """
+    waited = (now - dispatched_at).total_seconds()
+    if waited <= grace:
+        return {
+            **probe,
+            "state": "pending",
+            "waitedSeconds": int(waited),
+            "lastStage": beat.stage,
+            "reason": "within launch grace",
+        }
+    return {
+        **probe,
+        "state": "stalled",
+        "waitedSeconds": int(waited),
+        "lastStage": beat.stage,
+        "reason": (
+            f"no heartbeat for this dispatch {int(waited)}s after it started "
+            f"(grace {int(grace)}s); newest beat `{beat.stage}` predates it"
+        ),
+    }
+
+
 def probe_launch(
     prompt: Path, dispatched_at: datetime, now: datetime, grace: float
 ) -> dict:
@@ -108,18 +164,34 @@ def probe_launch(
     }
 
 
+@dataclass(frozen=True)
+class ProbeTarget:
+    """One pending worker resolved from team-state: which artifact answers for
+    it, where that artifact is, and when this dispatch started."""
+    liveness_mode: str
+    artifact: Path
+    dispatched_at: datetime
+
+
+def probe_one(target: ProbeTarget, *, now: datetime, max_idle: float,
+              launch_grace: float) -> dict:
+    if target.liveness_mode == LIVENESS_AUDIT_HEARTBEAT:
+        return probe_heartbeat(
+            target.artifact, target.dispatched_at, now, max_idle, launch_grace
+        )
+    return probe_launch(target.artifact, target.dispatched_at, now, launch_grace)
+
+
 def probe_all(
-    audits: list[str],
-    launches: list[tuple[str, datetime]],
+    targets: list[ProbeTarget],
     *,
     now: datetime,
     max_idle: float,
     launch_grace: float,
 ) -> dict:
-    probes = [probe_heartbeat(Path(p), now, max_idle) for p in audits]
-    probes += [
-        probe_launch(Path(prompt), dispatched_at, now, launch_grace)
-        for prompt, dispatched_at in launches
+    probes = [
+        probe_one(t, now=now, max_idle=max_idle, launch_grace=launch_grace)
+        for t in targets
     ]
     unhealthy = [p for p in probes if p["state"] in ("stalled", "did-not-launch")]
     return {"ok": not unhealthy, "checkedAt": now.isoformat(), "probes": probes,
@@ -147,8 +219,13 @@ def _project_root_for_team_state(team_state_path: Path) -> Path:
     )
 
 
-def _launch_target(team_state_value: str, worker_id: str) -> tuple[str, datetime]:
-    team_state_path = Path(team_state_value).resolve()
+_ARTIFACT_FIELD_BY_MODE = {
+    LIVENESS_AUDIT_HEARTBEAT: "auditSidecarPath",
+    LIVENESS_WRAPPER_STATUS: "promptPath",
+}
+
+
+def _worker_row(team_state_path: Path, worker_id: str) -> dict:
     state = load_json_object(team_state_path, "team-state")
     workers = state.get("workers")
     if not isinstance(workers, list):
@@ -162,14 +239,34 @@ def _launch_target(team_state_value: str, worker_id: str) -> tuple[str, datetime
     )
     if worker is None:
         raise DispatchError(f"team-state has no workerId={worker_id}: {team_state_path}")
-    prompt_value = worker.get("promptPath")
-    if not isinstance(prompt_value, str) or not prompt_value.strip():
-        raise DispatchError(f"worker {worker_id} has no promptPath")
-    prompt = Path(prompt_value)
-    if not prompt.is_absolute():
-        prompt = _project_root_for_team_state(team_state_path) / prompt
+    return worker
+
+
+def probe_target(team_state_value: str, worker_id: str) -> ProbeTarget:
+    """Resolve one worker's probe target from team-state.
+
+    ``livenessMode`` is authoritative — never infer the transport from the
+    provider or a filename, which is how a lead ends up probing an in-process
+    worker for a wrapper log that will never exist.
+    """
+    team_state_path = Path(team_state_value).resolve()
+    worker = _worker_row(team_state_path, worker_id)
+    mode = worker.get("livenessMode")
+    field = _ARTIFACT_FIELD_BY_MODE.get(mode) if isinstance(mode, str) else None
+    if field is None:
+        allowed = ", ".join(sorted(_ARTIFACT_FIELD_BY_MODE))
+        raise DispatchError(
+            f"worker {worker_id} has missing or unknown livenessMode {mode!r}; "
+            f"expected one of: {allowed}"
+        )
+    artifact_value = worker.get(field)
+    if not isinstance(artifact_value, str) or not artifact_value.strip():
+        raise DispatchError(f"worker {worker_id} has no {field}")
+    artifact = Path(artifact_value)
+    if not artifact.is_absolute():
+        artifact = _project_root_for_team_state(team_state_path) / artifact
     dispatched_at = _parse_utc(worker.get("startedAt"), f"worker {worker_id} startedAt")
-    return str(prompt), dispatched_at
+    return ProbeTarget(mode, artifact, dispatched_at)
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -177,35 +274,32 @@ def main(argv: list[str] | None = None) -> int:
         prog="okstra worker-liveness",
         description="Report whether pending workers are still alive (read-only).",
     )
-    parser.add_argument("--audit", action="append", default=[],
-                        help="in-process worker audit sidecar path (repeatable)")
     parser.add_argument("--team-state", action="append", default=[],
-                        help="team-state path for a CLI-wrapper assignment (repeatable)")
+                        help="team-state path for a pending worker (repeatable)")
     parser.add_argument("--worker", action="append", default=[],
                         help="worker id paired with --team-state (repeatable)")
     parser.add_argument("--max-idle", type=float, default=HEARTBEAT_MAX_GAP_SECONDS,
                         help="heartbeat staleness budget in seconds")
     parser.add_argument("--launch-grace", type=float, default=DEFAULT_LAUNCH_GRACE_SECONDS,
-                        help="seconds a wrapper may take to write its first artifact")
+                        help="seconds a worker may take to write its first artifact")
     parser.add_argument("--json", action="store_true", help="emit JSON (always on)")
     args = parser.parse_args(argv)
 
     if len(args.team_state) != len(args.worker):
         parser.error("each --team-state must have one paired --worker")
-    if not args.audit and not args.team_state:
-        parser.error("pass at least one --audit or --team-state/--worker pair")
+    if not args.team_state:
+        parser.error("pass at least one --team-state/--worker pair")
 
     try:
-        launches = [
-            _launch_target(team_state, worker)
+        targets = [
+            probe_target(team_state, worker)
             for team_state, worker in zip(args.team_state, args.worker, strict=True)
         ]
     except DispatchError as exc:
         parser.error(str(exc))
 
     result = probe_all(
-        args.audit,
-        launches,
+        targets,
         now=datetime.now(timezone.utc),
         max_idle=args.max_idle,
         launch_grace=args.launch_grace,

package/runtime/templates/reports/html/base.template.html

@@ -8,15 +8,15 @@
   <style>{{ css | safe }}</style>
 </head>
 <body>
-  <a class="skip-link" href="#main-content">Skip to report content</a>
+  <a class="skip-link" href="#main-content">{{ t('base.skip-to-report-content') }}</a>
   <header class="human-report-header">
     <p class="eyebrow">{{ taskType }}</p>
     <h1>{{ taskType }} #{{ runMeta.seq }}</h1>
     <dl class="report-meta">
-      <div><dt>Task</dt><dd data-report-meta="taskTitle">{{ reportMeta.taskTitle | inline_code }}</dd></div>
-      <div><dt>Task key</dt><dd data-report-meta="taskKey"><code>{{ reportMeta.taskKey }}</code></dd></div>
-      <div><dt>Written</dt><dd data-report-meta="createdAt">{{ reportMeta.createdAt }}</dd></div>
-      {% if reportMeta.elapsed %}<div><dt>Elapsed</dt><dd data-report-meta="elapsed">{{ reportMeta.elapsed }}</dd></div>{% endif %}
+      <div><dt>{{ t('base.task') }}</dt><dd data-report-meta="taskTitle">{{ reportMeta.taskTitle | inline_code }}</dd></div>
+      <div><dt>{{ t('base.task-key') }}</dt><dd data-report-meta="taskKey"><code>{{ reportMeta.taskKey }}</code></dd></div>
+      <div><dt>{{ t('base.written') }}</dt><dd data-report-meta="createdAt">{{ reportMeta.createdAt }}</dd></div>
+      {% if reportMeta.elapsed %}<div><dt>{{ t('base.elapsed') }}</dt><dd data-report-meta="elapsed">{{ reportMeta.elapsed }}</dd></div>{% endif %}
     </dl>
     <p class="lede">{{ humanSummary.headline | inline_code }}</p>
     <p>{{ humanSummary.outcome | inline_code }}</p>
@@ -25,14 +25,14 @@
     {% block human_content %}{% endblock %}
     {{ clarification_responses(clarificationItems) }}
     {% if evidenceIndex %}
-    <section data-report-section="evidence-ledger">
-      <h2>Evidence ledger</h2>
+    <section data-report-section="evidence-ledger" data-reader-kind="audit">
+      <h2>{{ t('base.evidence-ledger') }}</h2>
       <ol class="ledger">
         {% for row_id, row in evidenceIndex.items() %}
         <li class="ledger-item" id="id-{{ row_id }}">
           <p class="ledger-key"><span class="ledger-id">{{ row_id }}</span><span class="ledger-kind">{{ row.kind }}</span></p>
           <p class="ledger-text">{{ row.text | inline_code }}</p>
-          <p class="ledger-source"><span>Source · confidence</span> {% if row.codeEvidence %}{{ row.codeEvidence | code_evidence }}{% else %}{{ row.source | inline_code }}{% endif %}</p>
+          <p class="ledger-source"><span>{{ t('base.source-confidence') }}</span> {% if row.codeEvidence %}{{ row.codeEvidence | code_evidence }}{% else %}{{ row.source | inline_code }}{% endif %}</p>
         </li>
         {% endfor %}
       </ol>
@@ -40,10 +40,10 @@
     {% endif %}
   </main>
   <footer class="human-report-footer">
-    <button type="button" data-action="export-user-response">Export my answers</button>
-    <button type="button" data-action="copy-user-response">Copy</button>
-    <button type="button" data-action="dismiss-user-response" hidden>Dismiss</button>
-    <p class="user-response-hint">Export downloads <code>user-response-{{ runMeta.task_type }}-{{ runMeta.seq }}.md</code>. Drop that file into <code>runs/{{ runMeta.task_type }}/user-responses/</code> and the next run picks your answers up on its own.</p>
+    <button type="button" data-action="export-user-response">{{ t('base.export-my-answers') }}</button>
+    <button type="button" data-action="copy-user-response">{{ t('base.copy') }}</button>
+    <button type="button" data-action="dismiss-user-response" hidden>{{ t('base.dismiss') }}</button>
+    <p class="user-response-hint">{{ t('base.export-downloads') }} <code>user-response-{{ runMeta.task_type }}-{{ runMeta.seq }}.md</code>{{ t('base.drop-that-file-into') }} <code>runs/{{ runMeta.task_type }}/user-responses/</code> {{ t('base.and-the-next-run-picks-your-answers-up-on-it') }}</p>
     <pre id="user-response-output" aria-live="polite"></pre>
   </footer>
   <script id="run-meta" type="application/json">{{ {