okstra 0.159.0 → 0.161.0

package/runtime/python/okstra_ctl/team.py

@@ -1,4 +1,9 @@
-"""Neutral okstra team CLI for external tmux-pane worker dispatch."""
+"""Neutral okstra team CLI for pane-backed worker dispatch.
+
+Outside cmux this is the external lead's door onto tmux panes. Under cmux it
+is every lead's door onto cmux surfaces, because okstra owns the panes there
+rather than the host. Which backend a run uses is read from its run manifest.
+"""
 from __future__ import annotations
 
 import argparse
@@ -7,8 +12,10 @@ import sys
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 
+from . import cmux
 from . import tmux
 from .dispatch_core import (
+    BACKEND_CMUX_PANE,
     BACKEND_TMUX_PANE,
     DispatchError,
     DispatchPlan,
@@ -51,7 +58,7 @@ def _parser() -> argparse.ArgumentParser:
 
 
 def _add_dispatch_parser(sub) -> None:
-    parser = sub.add_parser("dispatch", help="dispatch tmux-pane workers")
+    parser = sub.add_parser("dispatch", help="dispatch pane-backed workers")
     _add_run_args(parser)
     parser.add_argument("--workers", default="")
     parser.add_argument("--jobs-file", default="")
@@ -61,7 +68,7 @@ def _add_dispatch_parser(sub) -> None:
 
 
 def _add_await_parser(sub) -> None:
-    parser = sub.add_parser("await", help="wait for tmux-pane workers")
+    parser = sub.add_parser("await", help="wait for pane-backed workers")
     _add_run_args(parser)
     parser.add_argument("--poll-interval-seconds", type=int, default=5)
     parser.add_argument("--timeout-seconds", type=int, default=None)
@@ -70,7 +77,7 @@ def _add_await_parser(sub) -> None:
 
 
 def _add_teardown_parser(sub) -> None:
-    parser = sub.add_parser("teardown", help="kill tmux-pane workers")
+    parser = sub.add_parser("teardown", help="reclaim this run's worker panes")
     _add_run_args(parser)
     parser.add_argument("--dry-run", action="store_true")
     parser.add_argument("--json", action="store_true")
@@ -94,8 +101,8 @@ def _dispatch(args) -> int:
         okstra_bin=Path(args.okstra_bin),
         requested_workers=requested,
         idle_timeout_seconds=args.idle_timeout_seconds,
-        required_lead_runtime="external",
-        default_backend=BACKEND_TMUX_PANE,
+        required_lead_runtime=None if _is_cmux_run(manifest) else "external",
+        default_backend=_manifest_backend(manifest),
         supported_worker_wrappers=_SUPPORTED_WRAPPERS,
         unsupported_worker_label="external lead",
         dispatch_kind=args.dispatch_kind,
@@ -133,13 +140,13 @@ def _teardown(args) -> int:
     team_state_path = _resolve_project_path(project_root, _require_string(manifest, "teamStatePath"))
     team_state = _load_json(team_state_path, "team-state")
     run_dir = _resolve_project_path(project_root, _require_string(manifest, "runDirectoryPath"))
-    lead_pane = tmux.resolve_caller_pane()
-    panes = _teardown_panes(team_state, run_dir, lead_pane)
+    panes = _reclaimable_panes(manifest, team_state, run_dir)
     if args.dry_run:
         _emit_teardown(args.json, panes)
         return 0
+    reclaim = cmux.close_surface if _is_cmux_run(manifest) else tmux.kill_pane
     for pane in panes:
-        tmux.kill_pane(pane["paneId"])
+        reclaim(pane["paneId"])
     _mark_teardown_errors(team_state_path)
     _emit_teardown(args.json, panes)
     return 0
@@ -158,7 +165,7 @@ def _plan_for_existing(
         lead_events_path=_resolve_project_path(root, _require_string(manifest, "leadEventsPath")),
         manifest=manifest,
         jobs=(),
-        default_backend=BACKEND_TMUX_PANE,
+        default_backend=_manifest_backend(manifest),
     )
 
 
@@ -174,12 +181,25 @@ def _await_payload(plan: DispatchPlan, completed: bool) -> dict[str, Any]:
     }
 
 
-def _teardown_panes(team_state: Mapping[str, Any], run_dir: Path, lead_pane: str) -> list[dict[str, str]]:
+def _reclaimable_panes(
+    manifest: Mapping[str, Any], team_state: Mapping[str, Any], run_dir: Path
+) -> list[dict[str, str]]:
+    """Everything this run owns and may close.
+
+    Under cmux the recorded ids are the whole list. There is no per-pane tag API
+    to sweep with, and scanning by title would be worse than nothing: cmux labels
+    its own agent surfaces with the same glyph okstra's tmux cleanup treats as a
+    teammate marker, so a sweep could close the lead. Only surfaces okstra
+    created are recorded, so only those can be closed.
+    """
     seen: set[str] = set()
     panes: list[dict[str, str]] = []
     for record in team_state.get("workerDispatches", []):
         if isinstance(record, dict):
             _append_pane(panes, seen, str(record.get("paneId", "")), "worker")
+    if _is_cmux_run(manifest):
+        return panes
+    lead_pane = tmux.resolve_caller_pane()
     for pane in tmux.list_run_panes(run_dir, lead_pane=lead_pane):
         _append_pane(panes, seen, pane.pane_id, pane.kind)
     return panes
@@ -208,10 +228,29 @@ def _emit_teardown(as_json: bool, panes: list[dict[str, str]]) -> None:
         print(f"{pane['paneId']}\t{pane['kind']}")
 
 
+def _manifest_backend(manifest: Mapping[str, Any]) -> str:
+    """The backend prepare recorded for this run.
+
+    Deliberately not a flag on this command: the manifest already answers it,
+    and a flag would be a second answer free to disagree. A manifest written
+    before the field existed reads as tmux, which is what those runs used.
+    """
+    return str(manifest.get("terminalBackend") or "") or BACKEND_TMUX_PANE
+
+
+def _is_cmux_run(manifest: Mapping[str, Any]) -> bool:
+    return _manifest_backend(manifest) == BACKEND_CMUX_PANE
+
+
 def _validate_external_manifest(manifest: Mapping[str, Any]) -> None:
     runtime = manifest.get("leadRuntime")
     if runtime == "external":
         return
+    if _is_cmux_run(manifest):
+        # Under cmux okstra owns the panes for every lead, so this command is no
+        # longer the external lead's private door and the advice below no longer
+        # applies — there is nowhere else for a codex or Claude Code lead to go.
+        return
     if runtime == "codex":
         raise DispatchError("use okstra codex-dispatch for leadRuntime=codex")
     if runtime == "claude-code":

package/runtime/python/okstra_ctl/user_response.py

@@ -20,6 +20,7 @@ from typing import Optional
 
 from okstra_ctl.report_views import (
     serialize_user_response, UserResponseEntry, UserResponseApproval, infer_run_meta,
+    parse_expected_form_options,
 )
 from okstra_ctl.report_view_artifacts import user_responses_dir_for_report
 from okstra_ctl.listing import list_runs, absolute_final_report_path
@@ -473,18 +474,31 @@ def list_awaiting_tasks(home: Path, project_id: str, limit: int) -> list[dict]:
 # match. `§x.y` and `path.ext:line` are the other two ref shapes.
 _SECTION_REF_RE = re.compile(r"§[\d.]+|[A-Z]{1,4}-\d+|[\w./-]+\.\w+:\d+")
 _ID_TOKEN_RE = re.compile(r"^[A-Z]{1,4}-\d+$")
-_ALTERNATIVES_CUE = "Alternatives:"
 _DEFINITION_SNIPPET_CAP = 200
 _SNIPPET_NOISE_RE = re.compile(r'<a id="[^"]*"></a>|`|\*\*')
+_OPTION_LETTER_LABEL_RE = re.compile(r"^\([a-z]\)\s*")
 
 
-def _alternatives_from_expected(expected_form: str) -> list[str]:
-    idx = expected_form.find(_ALTERNATIVES_CUE)
-    if idx < 0:
-        return []
-    tail = expected_form[idx + len(_ALTERNATIVES_CUE):]
-    parts = re.split(r"[/;]", tail)
-    return [p.strip(" .,;—-") for p in parts if p.strip(" .,;—-")]
+def _options_from_expected_form(expected_form: str) -> list[dict]:
+    """Rebuild a schema-v1 row's options from its ``Expected form`` cell.
+
+    v1 keeps the choices as one string and has nowhere to record their impact,
+    so those fields come back empty and the picker reports them as unstated
+    rather than inventing them. Splitting goes through the canonical
+    ``parse_expected_form_options`` — the parser the HTML view already uses and
+    the only one under test.
+    """
+    return [
+        {
+            "role": "recommended" if value == "recommended" else "alternative",
+            "answer": _OPTION_LETTER_LABEL_RE.sub("", label).strip(),
+            "rationale": "",
+            "scopeImpact": [],
+            "addedWork": "",
+            "directionChange": "",
+        }
+        for value, label in parse_expected_form_options(expected_form)
+    ]
 
 
 def _clean_snippet(line: str) -> str:
@@ -558,8 +572,9 @@ def show_open_rows(report_path: Path) -> dict:
         refs = sorted(set(_SECTION_REF_RE.findall(statement + " " + expected)))
         rows.append({"id": it.row_id, "kind": it.kind, "blocks": it.blocks,
                      "status": it.status, "statement": statement,
-                     "recommended": expected,  # raw cell keeps answer + rationale
-                     "alternatives": _alternatives_from_expected(expected),
+                     "expectedForm": expected,
+                     # v2 authors the choices; v1 only ever had the string.
+                     "options": r["options"] or _options_from_expected_form(expected),
                      "contextRefs": refs,
                      "resolvedRefs": resolve_refs(text, refs)})
     return {"reportPath": str(report_path), "rows": rows}

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:]))