okstra 0.223.2 → 0.225.0

package/runtime/python/okstra_ctl/phases/implementation_planning/round_completion.py

@@ -0,0 +1,177 @@
+"""채택된 계획 검증 배치의 결정적 후처리."""
+from __future__ import annotations
+
+import hashlib
+import json
+import subprocess
+from collections.abc import Mapping
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from okstra_ctl.convergence import validated_run_authority
+from okstra_ctl.convergence_store import load_owned_json_object, write_json_atomic
+from okstra_ctl.dispatch_state import dispatch_worker_key
+from okstra_ctl.error_log_write import record_runtime_failure
+from okstra_ctl.plan_items import PlanItemContractError, analyser_key, critic_is_rostered
+from okstra_ctl.run_context import dir_flock
+from okstra_ctl.worker_prompt_policy import (
+    is_plan_verify_dispatch_kind, verification_dispatch_round,
+)
+from .authoring import finish_verification_round, validate_current_review
+
+if TYPE_CHECKING:
+    from okstra_ctl.dispatch_core import DispatchPlan
+
+
+def _verifier_key(row: Mapping[str, Any]) -> str:
+    if row.get("assignmentRef") == "critic/scope":
+        return "critic"
+    return analyser_key(dispatch_worker_key(row))
+
+
+def _round_dispatches(plan: DispatchPlan, team: Mapping[str, Any]) -> tuple[int, list[dict]] | None:
+    accepted = {row.get("dispatchId") for row in team.get("agentResultLinks", [])
+                if isinstance(row, Mapping) and not row.get("supersededBy")}
+    native = [{**row, "kind": row.get("dispatchKind", ""),
+               "status": "completed" if row.get("status") == "dispatched" and row.get("dispatchId") in accepted else row.get("status"),
+               "workerResultPath": row.get("workerResultPath") or next(
+                   (link.get("resultPath") for link in team.get("agentResultLinks", [])
+                    if link.get("dispatchId") == row.get("dispatchId") and not link.get("supersededBy")), "")}
+              for row in team.get("agentDispatches", []) if isinstance(row, dict)]
+    tails = [rows[-1] for rows in (team.get("workerDispatches", []), native) if rows]
+    if not plan.jobs and tails and all(
+        not is_plan_verify_dispatch_kind(str(row.get("kind", ""))) for row in tails
+    ):
+        return None
+    rows = [row for row in [*team.get("workerDispatches", []), *native] if isinstance(row, dict)
+            and is_plan_verify_dispatch_kind(str(row.get("kind", "")))]
+    targets = {verification_dispatch_round(job.dispatch_kind) for job in plan.jobs
+               if is_plan_verify_dispatch_kind(job.dispatch_kind)}
+    if plan.jobs and not targets:
+        return None
+    if not rows:
+        return None
+    if len(targets) > 1:
+        raise PlanItemContractError("one plan-verification batch cannot span multiple rounds")
+    number = next(iter(targets)) if targets else max(
+        verification_dispatch_round(row["kind"]) for row in rows
+    )
+    superseded = {row.get("dispatchId") for row in team.get("agentResultLinks", [])
+                  if isinstance(row, Mapping) and row.get("supersededBy")}
+    latest: dict[str, dict] = {}
+    for row in rows:
+        if verification_dispatch_round(row["kind"]) != number or row.get("dispatchId") in superseded:
+            continue
+        key = _verifier_key(row)
+        previous = latest.get(key)
+        identity = row.get("invocationRef") or row.get("invocationId")
+        if previous and (not identity or identity != (previous.get("invocationRef") or previous.get("invocationId"))):
+            raise PlanItemContractError(f"ambiguous plan-verification invocations for {key}")
+        if previous is None or row.get("attempt", 1) > previous.get("attempt", 1):
+            latest[key] = row
+    return int(number), list(latest.values())
+
+
+def _accepted_results(plan: DispatchPlan, team: Mapping[str, Any], rows: list[dict]) -> list[str]:
+    authority = validated_run_authority(plan.manifest_path)
+    execution = authority.execution_manifest
+    results = []
+    for row in rows:
+        declared_path = plan.project_root / str(row.get("workerResultPath", ""))
+        path = declared_path.resolve(strict=True)
+        if declared_path.is_symlink():
+            raise PlanItemContractError("plan-verification result must not be a symlink")
+        if not path.is_relative_to(authority.run_dir / "worker-results") or not path.is_file():
+            raise PlanItemContractError("plan-verification result must stay inside this run's worker-results")
+        links = [link for link in team.get("agentResultLinks", []) if isinstance(link, Mapping)
+                 and link.get("dispatchId") == row.get("dispatchId") and not link.get("supersededBy")]
+        if len(links) != 1 or (plan.project_root / str(links[0].get("resultPath", ""))).resolve() != path:
+            raise PlanItemContractError("plan-verification result has no unique accepted result link")
+        if execution is not None:
+            attempts = [attempt for attempt in execution.attempts
+                        if attempt.invocation_ref == row.get("invocationRef")
+                        and attempt.attempt == row.get("attempt")]
+            if len(attempts) != 1 or attempts[0].status != "ok":
+                raise PlanItemContractError("plan-verification attempt is not accepted")
+            if (plan.project_root / str(attempts[0].result_path or "")).resolve() != path:
+                raise PlanItemContractError("accepted attempt result path does not match the dispatch")
+        token = f'-plan-verify-r{verification_dispatch_round(row["kind"])}-'
+        if token not in path.name:
+            raise PlanItemContractError("plan-verification result filename has the wrong round")
+        worker = path.name.split(token, 1)[0]
+        if analyser_key(worker) != _verifier_key(row):
+            raise PlanItemContractError("plan-verification result has the wrong worker")
+        results.append(f"{worker}={path}")
+    return sorted(results)
+
+
+def _completion_receipt(plan: DispatchPlan, number: int, results: list[str]) -> dict[str, Any]:
+    review = validate_current_review(plan.manifest_path)
+    digest = hashlib.sha256()
+    for path in [review.items, review.narrative, *(Path(value.split("=", 1)[1]) for value in results)]:
+        digest.update(str(path).encode())
+        digest.update(path.read_bytes())
+    digest.update(json.dumps(results).encode())
+    fingerprint = digest.hexdigest()
+    receipt = review.state.with_name(f"plan-round-completion-r{number}-{review.state.name.removeprefix('plan-body-verification-')}")
+    state = load_owned_json_object(review.state)
+    if receipt.is_file():
+        recorded = load_owned_json_object(receipt)
+        if recorded.get("inputDigest") == fingerprint and recorded.get("stateDigest") == hashlib.sha256(review.state.read_bytes()).hexdigest():
+            return recorded
+    if any(row.get("round") == number for row in state.get("roundHistory", [])):
+        return {"status": "needs-lead", "round": number,
+                "reason": "round already closed; automatic completion will not replace its recorded inputs"}
+    prepared = load_owned_json_object(review.items)
+    if prepared.get("dispatchKind") == "reverify":
+        return {"status": "needs-lead", "round": number,
+                "reason": "self-fix re-verification needs the lead's cause groups and completion metadata"}
+    completed = finish_verification_round(review, results, number)
+    output = {**completed, "status": "completed", "round": number,
+              "inputDigest": fingerprint, "stateDigest": hashlib.sha256(review.state.read_bytes()).hexdigest(),
+              "receiptPath": str(receipt)}
+    write_json_atomic(receipt, output)
+    return output
+
+
+def complete_ready_plan_round(plan: DispatchPlan) -> dict[str, Any] | None:
+    from okstra_ctl.dispatch_core import TERMINAL_DISPATCH_STATUSES
+
+    if plan.manifest.get("taskType") != "implementation-planning":
+        return None
+    number = 0
+    try:
+        with dir_flock(plan.team_state_path.parent, ".plan-round-completion.lock"):
+            team = load_owned_json_object(plan.team_state_path)
+            batch = _round_dispatches(plan, team)
+            if batch is None:
+                return None
+            number, rows = batch
+            review = validate_current_review(plan.manifest_path)
+            prepared = load_owned_json_object(review.items)
+            workers = {analyser_key(worker) for worker in prepared.get("reviewInputs", {}).get("workers", [])}
+            actual = {_verifier_key(row) for row in rows}
+            if prepared.get("dispatchKind") == "critic-tie":
+                if not critic_is_rostered(plan.manifest):
+                    return {"status": "needs-lead", "round": number,
+                            "reason": "the run has no rostered critic to settle this tie"}
+                if actual & workers and not actual - (workers | {"critic"}):
+                    return {"status": "needs-lead", "round": number,
+                            "reason": "critic shares an analyser round; preserve its queue through manual append"}
+                workers = {"critic"}
+            if actual - workers:
+                raise PlanItemContractError("plan-verification dispatch includes an unassigned verifier")
+            if not workers or actual != workers:
+                return {"status": "pending", "round": number, "reason": "waiting for the complete prepared verifier roster"}
+            if any(row.get("status") not in TERMINAL_DISPATCH_STATUSES for row in rows):
+                return {"status": "pending", "round": number, "reason": "waiting for every verifier to settle"}
+            if any(row.get("status") != "completed" for row in rows):
+                raise PlanItemContractError("one or more plan verifiers failed; preserve their results for lead recovery")
+            return _completion_receipt(plan, number, _accepted_results(plan, team, rows))
+    except (OSError, ValueError, RuntimeError, subprocess.TimeoutExpired) as exc:
+        output = {"status": "failed", "round": number, "reason": str(exc)}
+        logged = record_runtime_failure(plan.manifest_path, command="plan-round automatic completion",
+                                        exit_code=2, detail=str(exc))
+        if not logged["ok"]:
+            output["errorLogFailure"] = logged["reason"]
+        return output

package/runtime/python/okstra_ctl/plan_item_evidence.py

@@ -0,0 +1,237 @@
+"""Conservative evidence snapshots for plan-verification verdict reuse."""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import stat
+from collections.abc import Mapping, Sequence
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, TypedDict
+
+from .plan_items import content_hash, is_critic_worker
+from .paths import find_asset_root
+from .report_narrative import writer_owned_data
+
+
+class FileSnapshot(TypedDict):
+    path: str
+    hash: str
+    mode: int | None
+
+
+class ReviewInputs(TypedDict):
+    version: int
+    items: dict[str, dict[str, Any]]
+    files: dict[str, FileSnapshot | None]
+    dependencies: dict[str, list[dict[str, Any]]]
+    workers: list[str]
+    context: str
+    complete: bool
+    planContext: dict[str, Any]
+    priorReviewHashes: dict[str, str]
+
+
+def _digest(value: object) -> str:
+    return hashlib.sha256(
+        json.dumps(value, sort_keys=True, ensure_ascii=False).encode("utf-8")
+    ).hexdigest()
+
+
+def _file_snapshot(root: Path, name: str) -> FileSnapshot | None:
+    path = root / name
+    try:
+        resolved = path.resolve(strict=False)
+        if not resolved.is_relative_to(root.resolve()):
+            return None
+        before = path.stat()
+        if stat.S_ISREG(before.st_mode):
+            digest = hashlib.sha256(path.read_bytes()).hexdigest()
+            after = path.stat()
+            changed = any(getattr(before, field) != getattr(after, field) for field in (
+                "st_dev", "st_ino", "st_size", "st_mtime_ns", "st_ctime_ns", "st_mode",
+            ))
+            if changed or resolved != path.resolve(strict=False):
+                return None
+            return {"path": str(resolved), "hash": digest, "mode": stat.S_IMODE(before.st_mode)}
+    except FileNotFoundError:
+        if not path.is_symlink():
+            return {"path": str(path.resolve(strict=False)), "hash": "absent", "mode": None}
+    except (OSError, RuntimeError):
+        return None
+    return None
+
+
+def _payload_paths(value: object) -> set[str]:
+    if isinstance(value, str):
+        return {value} if value and not any(c in value for c in "\n`*") else set()
+    if isinstance(value, list):
+        return set().union(*(_payload_paths(entry) for entry in value))
+    if isinstance(value, Mapping):
+        return _payload_paths(value.get("path"))
+    return set()
+
+
+def capture_review_inputs(
+    items: Sequence[Mapping[str, Any]],
+    planning: Mapping[str, Any],
+    manifest: Mapping[str, Any],
+    root: Path,
+    previous_rows: Sequence[Mapping[str, Any]] = (),
+) -> ReviewInputs:
+    paths: set[str] = set()
+    for item in items:
+        payload = item.get("payload") or {}
+        paths.update(
+            match for match in re.findall(r"`([^`\s]+)`", json.dumps(payload))
+            if "/" in match or "." in match
+        )
+        for field in ("files", "plannedPaths"):
+            paths.update(_payload_paths(payload.get(field)))
+    for row in previous_rows:
+        for vote in row.get("verdicts", []):
+            dependencies = vote.get("dependencies")
+            if isinstance(dependencies, Mapping) and isinstance(dependencies.get("paths"), list):
+                paths.update(p for p in dependencies.get("paths", []) if isinstance(p, str))
+    packet = manifest.get("analysisPacketPath")
+    if isinstance(packet, str) and packet:
+        paths.add(packet)
+    metadata = writer_owned_data({"implementationPlanning": planning})["implementationPlanning"]
+    for field in ("planBodyVerification", "optionCandidates", "stepwiseExecution",
+                  "dependencyMigrationRisk", "validationChecklist", "rollbackStrategy",
+                  "requirementCoverage", "variationPointAnalysis"):
+        metadata.pop(field, None)
+    metadata["stages"] = [
+        {key: value for key, value in stage.items() if key != "stepwiseExecution"}
+        for stage in metadata.get("stages", [])
+    ]
+    contracts = find_asset_root(("agents", "common.json"))
+    contract_hashes = {
+        name: _file_snapshot(contracts, name) if contracts else None for name in (
+            "agents/common.json", "agents/roles/analyser.json",
+            "prompts/duties/reverification-worker.json",
+        )
+    }
+    package = Path(__file__).resolve().parent
+    contract_hashes.update({name: _file_snapshot(package, name) for name in (
+        "plan_items.py", "plan_item_evidence.py", "plan_review_context.py", "phases/implementation_planning/authoring.py",
+        "phases/implementation_planning/instructions/plan-body-verification.md",
+    )})
+    files = {name: _file_snapshot(root, name) for name in sorted(paths)}
+    return {
+        "version": 1,
+        "planContext": metadata,
+        "priorReviewHashes": {str(row["id"]): str(row.get("verifiedReviewHash", "")) for row in previous_rows},
+        "items": {str(item["id"]): dict(item) for item in items},
+        "files": files,
+        "dependencies": dependency_scopes(previous_rows),
+        "workers": [row["workerId"] for row in manifest.get("workerAssignments", [])
+                    if row.get("workerId") and not is_critic_worker(row["workerId"])
+                    and not row["workerId"].startswith("report-writer")],
+        "context": _digest([metadata, contract_hashes, manifest.get("workerAssignments"),
+                            manifest.get("agentContract"), manifest.get("invocationAssignments"),
+                            files.get(packet)]),
+        "complete": bool(packet and files.get(packet) and files[packet]["hash"] != "absent"
+                         and all(value and value["hash"] != "absent" for value in contract_hashes.values())),
+    }
+
+
+def dependency_scopes(rows: Sequence[Mapping[str, Any]]) -> dict[str, list[dict[str, Any]]]:
+    return {
+        str(row["id"]): deepcopy(row["verdicts"]) for row in rows
+        if isinstance(row.get("id"), str) and isinstance(row.get("verdicts"), list)
+        and row["verdicts"]
+    }
+
+
+def _vote_dependencies(votes: object, workers: Sequence[str]) -> tuple[set[str], set[str]] | None:
+    if (not isinstance(votes, list) or not votes or not workers
+            or any(not isinstance(vote, Mapping) for vote in votes)
+            or set(workers) - {vote.get("worker") for vote in votes}):
+        return None
+    item_ids, paths = set(), set()
+    for vote in votes:
+        dependencies = vote.get("dependencies")
+        if (vote.get("verdict") not in {"AGREE", "DISAGREE", "SUPPLEMENT"}
+                or vote.get("claimKind") == "fact"
+                or not isinstance(dependencies, Mapping)
+                or dependencies.get("complete") is not True):
+            return None
+        for field in ("itemIds", "paths"):
+            values = dependencies.get(field)
+            if not isinstance(values, list) or any(not isinstance(v, str) or not v for v in values):
+                return None
+        item_ids.update(dependencies["itemIds"])
+        paths.update(dependencies["paths"])
+    return item_ids, paths
+
+
+def _dependency_closure(row: Mapping[str, Any], inputs: Mapping[str, Any]) -> tuple[set[str], set[str]] | None:
+    items = inputs.get("items", {})
+    graph = {**inputs.get("dependencies", {}), str(row["id"]): row.get("verdicts")}
+    pending, item_ids, paths = [str(row["id"])], set(), set()
+    while pending:
+        key = pending.pop()
+        if key in item_ids:
+            continue
+        if key not in items:
+            return None
+        declared = _vote_dependencies(graph.get(key), inputs.get("workers", []))
+        if declared is None:
+            return None
+        if any(not inputs.get("files", {}).get(name)
+               or inputs["files"][name]["hash"] == "absent" for name in declared[1]):
+            return None
+        item_ids.add(key)
+        pending.extend(declared[0])
+        paths.update(declared[1])
+        payload = items[key].get("payload") or {}
+        if key.startswith(("P-Opt-", "P-Var-", "P-Dir-", "P-Dep-", "P-Prep-")):
+            pending.extend(items)
+            paths.update(inputs.get("files", {}))
+        elif key.startswith("P-Step-"):
+            pending.extend(
+                other_id for other_id, other in items.items()
+                if other_id.startswith("P-Step-") and other["payload"].get("stage") == payload.get("stage")
+                and other["payload"].get("step", 0) < payload.get("step", 0)
+            )
+        for field in ("files", "plannedPaths"):
+            paths.update(_payload_paths(payload.get(field)))
+    return item_ids, paths
+
+
+def review_fingerprint(row: Mapping[str, Any], inputs: Mapping[str, Any]) -> str | None:
+    items, files = inputs.get("items", {}), inputs.get("files", {})
+    item = items.get(row.get("id"))
+    if not inputs.get("complete") or not item or row.get("contentHash") != content_hash(item):
+        return None
+    closure = _dependency_closure(row, inputs)
+    if closure is None:
+        return None
+    item_ids, paths = closure
+    if any(name not in files or files[name] is None for name in paths):
+        return None
+    return _digest({
+        "context": inputs["context"],
+        "items": {key: content_hash(items[key]) for key in sorted(item_ids)},
+        "files": {name: files[name] for name in sorted(paths)},
+        "votes": row["verdicts"],
+    })
+
+
+def review_files_unchanged(inputs: Mapping[str, Any], root: Path) -> bool:
+    return all(
+        value == _file_snapshot(root, name)
+        for name, value in inputs.get("files", {}).items()
+    )
+
+
+def reusable_item_ids(
+    rows: Sequence[Mapping[str, Any]], inputs: Mapping[str, Any],
+) -> set[str]:
+    return {
+        str(row["id"]) for row in rows
+        if row.get("verifiedReviewHash")
+        and row["verifiedReviewHash"] == review_fingerprint(row, inputs)
+    }

package/runtime/python/okstra_ctl/plan_items.py

@@ -410,11 +410,6 @@ def _is_plan_wide(item_id: str) -> bool:
 
 
 def content_hash(item: Mapping[str, Any]) -> str:
-    """이 항목 본문의 지문. 문구가 같으면 라운드가 달라도 같은 판정이다.
-
-    라운드 번호만 보면 고치지 않은 항목까지 재검증해야 한다. subject·payload·
-    block·stageScope 가 같으면 그 항목이 가리키는 텍스트는 재작성 전과 같다.
-    """
     payload = {
         "block": item.get("block"),
         "payload": item.get("payload"),
@@ -828,6 +823,14 @@ PLAN_VERIFY_RESPONSE_FORMAT = (
     "**Note**: <the falsification candidate considered and why it is "
     "excluded; required even for AGREE>\n"
     "**Explanation**: <2-3 sentences>\n"
+    '**Dependencies**: {"complete": false, "itemIds": [], "paths": []}\n'
+    "Keep the detailed Note and Explanation above. Set complete=true only when "
+    "you can enumerate ALL direct and transitive evidence dependencies: other "
+    "P-* items in itemIds and whole local files in paths (project-relative). "
+    "Include source files behind citations, not just the citing document. "
+    "If the dependency boundary, dynamic state, an external source, or any "
+    "reference cannot be resolved, keep complete=false. Missing or uncertain "
+    "dependencies cause re-verification; they never suppress your verdict.\n"
 )
 
 
@@ -851,7 +854,7 @@ def with_response_format(queue_markdown: str) -> str:
     return queue_markdown.rstrip("\n") + "\n" + PLAN_VERIFY_RESPONSE_FORMAT
 
 
-def item_cites_build_command(item: Mapping[str, Any]) -> bool:
+def _item_cites_build_command(item: Mapping[str, Any]) -> bool:
     """이 항목이 계획 워크트리에서 실행 불가한 빌드/테스트 명령을 인용하는가."""
     payload = item.get("payload") if isinstance(item.get("payload"), Mapping) else item
     if not isinstance(payload, Mapping):
@@ -914,13 +917,13 @@ def _worker_is_blanket(
     if not votes or any(not _error_verdict(token) for _item_id, token in votes):
         return False
     return any(
-        not item_cites_build_command(_with_payload(items_by_id[item_id], payloads))
+        not _item_cites_build_command(_with_payload(items_by_id[item_id], payloads))
         for item_id, _token in votes
         if item_id in items_by_id
     )
 
 
-def blanket_unverifiable_workers(
+def _blanket_unverifiable_workers(
     items: Sequence[Mapping[str, Any]],
     payloads: Mapping[str, Mapping[str, Any]] | None = None,
 ) -> list[str]:
@@ -1028,7 +1031,7 @@ def next_dispatch(
         str(item["id"]) for item in items
         if isinstance(item.get("id"), str) and item["id"]
     )
-    blanket = tuple(blanket_unverifiable_workers(items, payloads))
+    blanket = tuple(_blanket_unverifiable_workers(items, payloads))
     if blanket:
         return NextDispatch(
             kind="worker-correction",

package/runtime/python/okstra_ctl/plan_review_context.py

@@ -0,0 +1,82 @@
+"""Lossless plan context with conservative dependency-based selection."""
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+from .analysis_packet import _heading_lines
+from .plan_item_evidence import _dependency_closure, review_fingerprint
+from .plan_items import content_hash
+
+
+def _packet_excerpt(text: str) -> str:
+    lines = text.splitlines(keepends=True)
+    headings = _heading_lines([line.rstrip("\r\n") for line in lines])
+    omitted: set[int] = set()
+    for index, (start, heading) in enumerate(headings):
+        stop = headings[index + 1][0] - 1 if index + 1 < len(headings) else len(lines)
+        section = "".join(lines[start - 1:stop])
+        generated_census = (
+            heading == "## Coverage Census"
+            and "The fixed worklist for this run. okstra built it from the phase " in section
+            and "| Cell | Scope | Subject | Question |" in section
+        )
+        if heading != "## Section Index" and not generated_census:
+            continue
+        omitted.update(range(start - 1, stop))
+    excerpt = "".join(line for index, line in enumerate(lines) if index not in omitted)
+    if re.search(r"(?im)^###\s+(?:[FC]-|P-)", excerpt):
+        return "".join("> " + line for line in excerpt.splitlines(keepends=True))
+    return excerpt
+
+
+def _supporting_ids(queue: Sequence[str], inputs: Mapping[str, Any]) -> set[str]:
+    items = inputs["items"]
+    selected: set[str] = set()
+    for key in queue:
+        row = {"id": key, "verdicts": inputs.get("dependencies", {}).get(key),
+               "contentHash": content_hash(items[key])}
+        previous = inputs.get("priorReviewHashes", {}).get(key)
+        if not previous or previous != review_fingerprint(row, inputs):
+            return set(items)
+        closure = _dependency_closure(row, inputs)
+        if closure is None:
+            return set(items)
+        selected.update(closure[0])
+    return selected
+
+
+def render_review_context(
+    queue: Sequence[str], inputs: Mapping[str, Any], manifest: Mapping[str, Any], root: Path,
+) -> str:
+    if not inputs.get("complete") or "planContext" not in inputs:
+        return ""
+    packet = str(manifest["analysisPacketPath"])
+    supporting = _supporting_ids(queue, inputs) - set(queue)
+    context = {
+        "planMetadata": inputs["planContext"],
+        "availableEvidencePaths": sorted(name for name in inputs["files"] if name != packet),
+        "supportingItems": [
+            item
+            for key, item in inputs["items"].items() if key in supporting
+        ],
+    }
+    return (
+        "\n## Review context\n\n"
+        "Use the inline packet and plan context below first. The plan items assigned below "
+        "carry their complete payloads; supporting items are context, not extra verdicts. "
+        "Do not reread the full narrative or packet unless a reference is unresolved, "
+        "context is missing, or a cross-item contradiction needs investigation. Read the "
+        "original paths in Inputs in that case and declare all additional dependencies. "
+        "Never infer that an omitted item or an unread source is absent. "
+        "Only the packet's navigation index and generated analysis Coverage Census are "
+        "omitted; task requirements, directives, carry-in, and unknown sections are retained.\n\n"
+        f"### Primary packet excerpt: `{packet}`\n\n"
+        + _packet_excerpt((root / packet).read_text(encoding="utf-8"))
+        + "\n### Plan context (lossless JSON)\n\n"
+        + json.dumps(context, ensure_ascii=False, separators=(",", ":"))
+        + "\n"
+    )

package/runtime/python/okstra_ctl/render.py

@@ -1761,6 +1761,8 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
             Path(ctx.get("PROJECT_ROOT", "")), task_manifest, {}
         ),
         "leadModel": ctx.get("LEAD_MODEL", ""),
+        # `okstra-provider-exec.py` 가 워커를 띄울 때마다 읽는다.
+        "reasoningEffort": ctx.get("REASONING_EFFORT", ""),
         # Every other path in this manifest is project-relative; this is the
         # anchor they resolve against. Convergence reads it to place run
         # artifacts, so a manifest without it cannot seed a round.

package/runtime/python/okstra_ctl/run.py

@@ -130,6 +130,7 @@ from .domain.host import (
     ProviderUnavailable,
 )
 from .domain.provider import ServedModelAttestation
+from .domain.worker_exec import REASONING_EFFORTS
 from .execution_identity import (
     ExecutionManifest,
     ParticipantAssignment,
@@ -634,6 +635,9 @@ class PrepareInputs:
     # discussion 전용: 링크·짧은 설명·이 task 의 key. brief 자리는 prepare 가
     # 이 값으로 만든 입력 문서가 채운다.
     discussion_start: str = ""
+    # 이 run 이 띄우는 모든 워커 CLI 의 추론 강도(`REASONING_EFFORTS`). 빈 값이면
+    # 각 CLI 가 자기 설정을 따른다.
+    reasoning_effort: str = ""
 
 
 @dataclass
@@ -4257,6 +4261,7 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
         "OKSTRA_PLAN_VERIFICATION": (
             "false" if not inp.plan_verification_enabled else ""
         ),
+        "REASONING_EFFORT": inp.reasoning_effort,
         "ANALYSIS_SOURCE_COMMIT": analysis_source_commit,
         "ANALYSIS_TARGET_JSON": json.dumps(resolved_target, ensure_ascii=False),
         "EVIDENCE_INPUTS_JSON": json.dumps(
@@ -4687,6 +4692,10 @@ def build_prepare_argument_parser():
         ),
     )
     p.add_argument("--render-only", action="store_true", dest="render_only")
+    p.add_argument(
+        "--summary-only", action="store_true",
+        help="Omit the lead prompt body from render-only output; still prepare all artifacts.",
+    )
     p.add_argument(
         "--terminal-backend",
         dest="terminal_backend",
@@ -4698,6 +4707,16 @@ def build_prepare_argument_parser():
             "않고 멈춘다."
         ),
     )
+    p.add_argument(
+        "--reasoning-effort",
+        default="",
+        choices=["", *REASONING_EFFORTS],
+        dest="reasoning_effort",
+        help=(
+            "Reasoning effort every worker CLI in this run is started with. "
+            "Empty leaves each CLI on its own configuration."
+        ),
+    )
     p.add_argument(
         "--no-plan-verification",
         action="store_false",
@@ -4897,6 +4916,7 @@ def main(argv: list[str]) -> int:
         plan_verification_enabled=args.plan_verification_enabled,
         fix_cycle=args.fix_cycle,
         discussion_start=args.discussion_start,
+        reasoning_effort=args.reasoning_effort,
     )
     try:
         out = prepare_task_bundle(inputs)
@@ -4919,8 +4939,9 @@ def main(argv: list[str]) -> int:
         stages_csv = ",".join(str(s) for s in cr["active_stages"])
         print(f"okstra concurrent-run stages: {stages_csv}")
     if inputs.render_only:
-        print()
-        print(out.prompt_text, end="")
+        if not args.summary_only:
+            print()
+            print(out.prompt_text, end="")
     else:
         print(f"okstra current run dir: {ctx['RUN_DIR']}")
         print(f"final report path: {ctx['FINAL_REPORT_PATH']}")