okstra 0.198.1 → 0.198.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.198.1",
+  "version": "0.198.2",
   "description": "Host-aware multi-provider cross-verification orchestrator runtime and agent skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.198.1",
-  "builtAt": "2026-09-11T12:26:44.689Z",
+  "package": "0.198.2",
+  "builtAt": "2026-09-11T13:42:28.980Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/bin/okstra-report-translate.py

@@ -32,7 +32,11 @@ from okstra_bootstrap import prefer_colocated_modules  # noqa: E402
 
 prefer_colocated_modules(__file__, "okstra_ctl/report_translation.py")
 
-from okstra_ctl.report_translation import extract, overlay  # noqa: E402
+from okstra_ctl.report_translation import (  # noqa: E402
+    extract,
+    group_translation_pointers,
+    overlay,
+)
 from okstra_ctl.final_report_paths import (  # noqa: E402
     translation_sidecar_path,
     translation_source_path,
@@ -82,6 +86,7 @@ def _report_snapshot(path: Path):
 def _source_payload(
     authority: RunArtifactAuthority, data_path: Path, raw_bytes: bytes, data: dict
 ) -> dict:
+    strings = extract(data)
     return {
         "taskKey": authority.task_key,
         "runManifestPath": authority.manifest_ref,
@@ -89,7 +94,8 @@ def _source_payload(
         "sourceDataPath": data_path.relative_to(authority.project_root).as_posix(),
         "sourceDataSha256": hashlib.sha256(raw_bytes).hexdigest(),
         "lang": str((data.get("meta") or {}).get("reportLanguage") or ""),
-        "strings": extract(data),
+        "strings": strings,
+        "translationGroups": group_translation_pointers(data, strings),
     }
 
 
@@ -108,6 +114,10 @@ def _validate_source_payload(
         raise SystemExit(
             "error: report changed after translation source publication"
         )
+    if "translationGroups" in source and (
+        source["translationGroups"] != expected["translationGroups"]
+    ):
+        raise SystemExit("error: translation groups do not match report source")
 
 
 def cmd_extract(args: argparse.Namespace) -> int:
@@ -154,9 +164,13 @@ def cmd_source(args: argparse.Namespace) -> int:
     print(line("Report", payload["sourceDataPath"]), end="")
     print(line("Run manifest", authority.manifest_ref), end="")
     print(line("Source digest", payload["sourceDataSha256"]), end="")
-    print(line("String count", len(strings)), end="")
-    for index, source in enumerate(strings.values(), 1):
-        print(f"\n## T-{index:03d}\n{block(source)}")
+    groups = payload["translationGroups"]
+    print(line("Field count", len(strings)), end="")
+    print(line("String count", len(groups)), end="")
+    print(line("Source characters", sum(len(value) for value in strings.values())), end="")
+    print(line("Translation characters", sum(len(strings[row[0]]) for row in groups)), end="")
+    for index, pointers in enumerate(groups, 1):
+        print(f"\n## T-{index:03d}\n{block(strings[pointers[0]])}")
     return 0
 
 
@@ -212,12 +226,14 @@ def cmd_write(args: argparse.Namespace) -> int:
     source = _load(source_path)
     _validate_source_payload(source, expected, args.source_digest)
     sources = expected["strings"]
+    # 발행된 구형 작업 목록은 필드당 한 블록이므로 진행 중 번역의 번호를 보존한다.
+    groups = source.get("translationGroups", [[pointer] for pointer in sources])
     translated = _translation_blocks(Path(args.translations))
-    if len(translated) != len(sources):
+    if len(translated) != len(groups):
         raise SystemExit(
             f"error: translation blocks must match every T-NNN item — "
             f"{len(translated)} blocks in {Path(args.translations).name}, "
-            f"{len(sources)} items in the translation source"
+            f"{len(groups)} items in the translation source"
         )
     empty = [f"T-{index + 1:03d}" for index, value in enumerate(translated) if not value]
     if empty:
@@ -229,7 +245,11 @@ def cmd_write(args: argparse.Namespace) -> int:
     sidecar = translation_sidecar_path(data_path, lang)
     if sidecar.is_symlink():
         raise SystemExit("error: translation sidecar path is a symlink")
-    strings = dict(zip(sources, translated))
+    strings = {
+        pointer: value
+        for pointers, value in zip(groups, translated)
+        for pointer in pointers
+    }
     _, report = overlay(data, strings)
     if report.unresolved or report.applied != len(strings):
         raise SystemExit("error: translations do not validate against report source")

package/runtime/prompts/lead/convergence.md

@@ -334,6 +334,23 @@ Lightweight reverify does not require the original `analysis-packet.md`, `analys
 
 This is the single largest avoidable cost in `requirements-discovery`, `error-analysis`, `implementation-option-selection`, and `implementation-planning` runs. Treat as mandatory.
 
+## Conditional reference reading
+
+The common read retains finding classification, queue pruning, dispatch gates,
+state ownership, and output rules. Use the generated `okstra convergence
+reverify-prompt` body for every verifier. The following reads are guidance for
+avoiding unused examples; queue and dispatch validators still enforce execution.
+
+| Current operation | Additional section to read |
+|---|---|
+| Diagnosing a rejected verifier prompt | The reference prompt matching the selected verification mode |
+| `config.critic.enabled` is true | Coverage critic pass, including its shared dispatch procedure |
+| An enabled critic uses acceptance mode for `final-verification` | Acceptance critic pass as well as the shared Coverage critic dispatch procedure |
+
+Read the matching sections before their dispatch. A disabled critic needs neither
+critic section. Generated prompts retain the selected mode's instructions even
+when the lead does not read the example text.
+
 ### Lightweight Re-verification Prompt
 
 Rendered by `okstra convergence reverify-prompt` when `config.adversarial` is false; the block below is the reference shape, and the rendered body additionally carries each finding's `**Origin item**` and `**Origin audit sidecar**` lines.

package/runtime/prompts/lead/okstra-lead-contract.md

@@ -22,8 +22,8 @@ This document is the operating contract and phase index. Detailed procedures liv
 |-------|-------|
 | [context-loader](./context-loader.md) | Phase 1 task-bundle discovery, manifest fields, run-directory layout |
 | [team-contract](./team-contract.md) | Phase 2–5 worker roster, model assignment rules, prompt composition (anchor headers, `[Required reading]`, `[Error reporting]`), worker output contract, terminal statuses, usage tracking |
-| [convergence](./convergence.md) | Phase 5.5 finding convergence loop, finding categories, reverify dispatch (anchor headers, required-reading suppression), convergence state schema |
-| [plan-body-verification](./plan-body-verification.md) | Phase 6 plan-body verification sub-step (implementation-planning only) — plan-item extraction, verdict semantics, gate resolution, state schema. Read only at that sub-step |
+| [convergence](./convergence.md) | Phase 5.5 finding convergence loop, finding categories, reverify dispatch, convergence state schema. Use the bounded common read under Doctrine lazy reads |
+| [plan-body-verification](./plan-body-verification.md) | Phase 6 plan-body verification sub-step (implementation-planning only) — plan-item extraction, verdict semantics, gate resolution, state schema. Read only the common procedure at that sub-step, using the bounded read below |
 | [report-writer](./report-writer.md) | Phase 6 final-report authorship, dispatch template, resume-safe dispatch, shared-graph integrity check, Phase 7 token-usage collector |
 
 Read-side inspection (`/okstra-inspect`) and scheduling (`/okstra-schedule-gen`) are user-invoked skills, not lead support contracts — the lead does not consult them during a run.
@@ -262,11 +262,23 @@ After context-loader completes, read **only the compact intake files below** in
 
 **Doctrine lazy reads (BLOCKING — read at the round, not at Phase 1):**
 
-- [convergence](./convergence.md) — read before the first `PROGRESS: phase-5.5-convergence` line of any run that runs a convergence round.
-- [plan-body-verification](./plan-body-verification.md) — read before the first `PROGRESS: phase-5.5.9-plan-verify` line.
+- [convergence](./convergence.md) — read the common procedure with the bounded command below before the first `PROGRESS: phase-5.5-convergence` line of any run that runs a convergence round.
+- [plan-body-verification](./plan-body-verification.md) — read the common procedure with the bounded command in the Phase 6 sub-step before the first `PROGRESS: phase-5.5.9-plan-verify` line.
 
 Both stay out of the Phase 1 baseline for the token reason above, and neither is optional at its round: together they carry more than half of this contract family's MUST clauses, so a round dispatched without the read is a round run from memory. **Enforced:** `validators/validate_session_conformance.py` `_ENTRY_GUARD_READS` requires each read — a `Read` call or a shell command naming the file — inside this run's window and before that checkpoint. The requirement is conditioned on the checkpoint actually appearing, so a run that holds no such round is never asked for it.
 
+Read the convergence common procedure from the resolved resource path. Replace
+`<convergence-contract-path>` with its absolute path. This skips reference prompt
+examples and critic-specific procedures; the conditional reading table in the
+output identifies when those sections are needed:
+
+```sh
+awk '/^### Lightweight Re-verification Prompt$/ {skip=1} /^## Convergence State Artifact$/ {skip=0} /^## Coverage critic pass$/ {skip=1} /^## Output$/ {skip=0} !skip {print}' '<convergence-contract-path>'
+```
+
+`tests/contract/test_contract_examples_execute.py::test_convergence_common_read_keeps_protocol`
+checks the emitted common procedure. The same entry-guard read trace applies.
+
 **Lazy reading discipline (do NOT read at Phase 1):**
 
 - `task-index.md` — only when the user explicitly asks for a human summary or when history disambiguation is required.
@@ -429,7 +441,21 @@ After the Report writer worker narrative is reviewed, **if** `task_type == "impl
 
 This is a Phase 6 sub-step — it does NOT introduce a new top-level lifecycle phase; the lead operating-phase model (Phase 1 Intake → Phase 7 Persist, labels in the "Quick Reference" table above as the single source of truth) is preserved. The round's outcome is read from the final report's `### 5.5.9 Plan Body Verification` section and `implementationPlanning.planBodyVerification` in its data.json — it is not a separate lifecycle phase identifier.
 
-**REQUIRED RESOURCE:** Read [plan-body-verification](./plan-body-verification.md) for the round protocol, plan-item ID scheme (`P-Dir-1` for selected-direction; `P-Opt-*` for legacy candidate comparison; then `P-Step-*` / `P-Dep-*` / `P-Val-*` / `P-Rb-*` / `P-Req-*` / `P-Prep-*`), verdict semantics (`AGREE` / `DISAGREE(a-f)` / `SUPPLEMENT`), classification rules, gate-result resolution, and the state-file schema at `runs/<task-type>/state/plan-body-verification.json`. For `P-Dir-1`, compare `directionRealization` with `selectedDirectionRef` and its snapshot: verify the core mechanism, architecture boundaries, planning invariants, and any hidden direction change.
+**REQUIRED RESOURCE:** Read the common procedure of [plan-body-verification](./plan-body-verification.md) for the round protocol, plan-item ID scheme (`P-Dir-1` for selected-direction; `P-Opt-*` for legacy candidate comparison; then `P-Step-*` / `P-Dep-*` / `P-Val-*` / `P-Rb-*` / `P-Req-*` / `P-Prep-*`), verdict semantics (`AGREE` / `DISAGREE(a-f)` / `SUPPLEMENT`), classification rules, gate-result resolution, and state-path authority. Read the state-file schema only when diagnosing state or projection validation. For `P-Dir-1`, compare `directionRealization` with `selectedDirectionRef` and its snapshot: verify the core mechanism, architecture boundaries, planning invariants, and any hidden direction change.
+
+Read from the resolved runtime resource path, replacing `<plan-body-contract-path>`
+with that resource's absolute path. This prints the complete common procedure and
+its conditional reading table, stopping before reference examples:
+
+```sh
+awk '/^## Reference material$/ {exit} {print}' '<plan-body-contract-path>'
+```
+
+Follow the conditional reading table for later rounds and validation failures.
+The command keeps the filename in the read trace used by
+`validators/validate_session_conformance.py` `_ENTRY_GUARD_READS`.
+The bounded output is checked by
+`tests/contract/test_contract_examples_execute.py::test_plan_body_common_read_keeps_gate_rules`.
 
 Distinct from Phase 5.5 finding convergence:
 

package/runtime/prompts/lead/plan-body-verification.md

@@ -376,7 +376,7 @@ round before any host or provider process starts.
    **On a re-run, add `--prior-state <the previous run's plan-body-verification-<task-type>-<seq>.json>`.** A newly seeded item whose `contentHash` equals that run's `verifiedContentHash` for the same id inherits its verdicts, is tagged `carriedForwardFromSeq`, and drops out of round 1's `dispatchQueue` — in the state and in the sibling `plan-items-*.json` the next `okstra plan-items prompt` reads. Without it a re-run re-judges every line the previous run already settled, and the same dissent re-opens under a new `P-*` number. A matching id alone never carries: `P-*` ids are positional, so a plan that gained one line hands the old id to a different sentence. The flag requires `--state` and refuses a prior state file that sits under another task's root — a plan-body state carries no task identity of its own, so its path is the only identity there is. **Enforced:** `okstra_ctl.plan_items_cli._carry_prior_run_verdicts`.
 
    **`--run-manifest` is what scopes the gate to the stage you are starting.** Seed uses it to overlay disk `done` / `active` onto `planBodyVerification.stageLedger`. The current plan's depends-on fills `ready` / `blocked` when no prior plan exists, so a first run does not treat every stage as in-scope. **Enforced:** `okstra_ctl.plan_items.planning_stage_ledger`.
-2. For each analyser worker in the roster (`claude`, `codex`, and `antigravity` if opted in), lead constructs a reverify prompt using the template in §"Plan-body reverify prompt" below.
+2. For each analyser worker in the roster, use `okstra plan-items prompt` output verbatim as the instruction body in the materialization sequence above. Read §"Re-verification rounds (round 2+)" before preparing a later round; read §"Plan-body reverify prompt" only when diagnosing a prompt-contract failure.
 3. Dispatch uses the same wrapper infrastructure as finding convergence, so the `--role-slug` is the same canonical `<role>-worker` that convergence uses — not a round-specific slug. Result file path: `runs/<task-type>/worker-results/<role>-worker-plan-verify-r<N>-implementation-planning-<seq>.md` (e.g. `codex-worker-plan-verify-r1-implementation-planning-003.md`). **`<seq>` is the report's sequence** — the one in this run's `final-report-<task-type>-<seq>` filename, NOT the `workerResults` sequence the initial analysis results carry. The two are equal in most runs and diverge in some (`reports: 004` alongside `workerResults: 005` is a real case). Provenance no longer globs by either seq: it resolves the expected filenames from this run's team-state `workerDispatches[]` rows — the paths the dispatches actually recorded — and falls back to the seq glob only when no team-state is readable, saying so in its finding. The `-worker-` token is load-bearing twice over: §"Plan-body reverify prompt" requires the same anchor headers as convergence, whose `**Audit sidecar path:**` is derived by `okstra_ctl.worker_artifact_paths.audit_sidecar_rel()` inserting `-audit-` after that token — a slug without it makes the header underivable and the helper raises. Record each `planItems[].verdicts[].worker` as the same `<role>-worker` string, because provenance compares it to this filename's prefix. **Enforced:** `tests/contract/test_reverify_dispatch_anchors.py` derives the sidecar from the documented name and re-extracts the prefix the provenance resolver uses.
    **Verdict provenance.** Every verdict recorded in `planItems[].verdicts[]` MUST trace back to a dispatch that actually returned a result file. The whole gate — classification, self-fix eligibility, promotion, `gateBlockedBy` — is computed from these votes, so an unbacked vote lets the round be skipped while the gate still reads `passed`. **Enforced (advisory):** `validators/validate-run.py` `_validate_plan_body_verdict_provenance` reports any `verdicts[].worker` with no recorded reverify dispatch whose result file exists; the finding is not in the blocking allowlist, so it surfaces as an advisory rather than failing the run — record it, never dismiss it. Recording a `verification-error` for a dispatch that produced no result is the correct way to represent a failed worker — inventing an `AGREE` is a contract violation, and renaming a result file to make provenance match destroys the link the check reads.
 
@@ -474,7 +474,13 @@ round before any host or provider process starts.
    - A terminal row preserves its original dissent classification only from the convergence-owned state history. Every `user-decision-required` / `user-decision-evaluated` activity cites the row's `C-NNN` in `clarificationRefs` and affected plan items in `planItemIds`. A resolved decision names only existing `A-NNN` checks. Report assembly validates those links and derives the report backtraces; it does not accept copied IDs from the approval ledger. When an independent coverage-only blocker is corrected, keep the `C-NNN` in the non-blocking Requirement Coverage row's `decisionRefs`. `obsolete` is valid only after current evidence shows that the question or blocker disappeared.
 9. Approval lives in the report record `frontmatter.approved` field — there is no in-body marker line. The user may set it to `true` (via `--approve` or the in-session wizard) when remaining `Blocks=approval` rows are user-proceeded (`accept-risk` / `select` / `answer`) even if the recorded `gateResult` is still `blocked-by-disagreement`. `aborted-non-result` still withholds approval. **Enforced:** run-prep (`scripts/okstra_ctl/run.py` `_validate_approved_plan` / `_blocking_gate_survives_user_decision`) and `validators/validate-run.py` `_validate_plan_body_gate_recompute`.
 
-## `plan-body-verification-<task-type>-<seq>.json` schema
+## Worker non-result handling in plan-body round (BLOCKING)
+
+Mirrors finding convergence ([convergence](./convergence.md) §"Worker failure handling in reverify"). Concretely:
+
+- A dispatch that returns terminal non-result MUST NOT be aggregated as `DISAGREE`.
+- If at least one dispatch was issued AND **all** plan-body dispatches return non-result, the Gate result is `aborted-non-result`. Record one `contract-violation` event per non-result dispatch.
+- When the gate is `aborted-non-result`, report-writer MUST keep the frontmatter `approved: false` (publishing `approved: true` under this gate result is a validator failure). A single row is added to `## 1. Clarification Items` with `Statement="plan-body verification could not run — all workers returned non-result"`, `Kind=decision`, `Blocks=approval`, allowing the user to either retry the phase or override by running `--approve` on the resume command (or confirming in the in-session wizard). The row MUST name which dispatches returned no result and what re-running them requires. **Enforced:** `validators/validate-run.py` `_validate_aborted_gate_has_clarification` — `_validate_plan_body_clarification_matching` cannot cover this case because it walks `majority-disagree` items and an aborted round produces none, which is exactly how an aborted run used to reach the user with no stated blocker and stall.
 
 **Take the path from the launch prompt, never from this filename (BLOCKING).**
 The run's `## Run Paths` block renders `Plan-body verification state:` with the
@@ -488,6 +494,27 @@ team-state name, so the round count reads as 0 and
 `verification-round-completed count must match automatic plan-body rounds=0`
 fails a run whose rounds all ran.
 
+## Conditional reference reading
+
+The common procedure ends here. Keep the sections above in context for every
+plan-body round. Read the reference sections below only for the matching operation:
+
+| Operation | Additional section to read |
+|---|---|
+| Inspecting a state-shape or projection validation failure | `plan-body-verification-<task-type>-<seq>.json` schema |
+| Investigating a generated prompt rejected by the dispatch gate | Plan-body reverify prompt |
+| Preparing round 2 or later after a rewrite | Re-verification rounds (round 2+) — carry the dissent forward |
+
+Use `okstra plan-items prompt` output verbatim for every round. The reference
+prompt is explanatory; it does not replace the generated queue or authorize
+hand-written items. Read a referenced section when an unresolved error requires
+it; do not load every reference pre-emptively. This reading policy is guidance;
+queue validation and dispatch checks continue to enforce the generated input.
+
+## Reference material
+
+## `plan-body-verification-<task-type>-<seq>.json` schema
+
 **Which file is authoritative for what.** Contract v3 keeps both views in one convergence-owned state file before publication:
 
 | | records | what a self-fix round does to it |
@@ -805,11 +832,3 @@ An item with no recorded vote carrying a round number gets no block, and an enve
 **Enforced:** `okstra plan-items validate-prepared --state <same state>` re-derives the carry and exits 2 when the prepared envelope's `priorRounds` does not match, alongside the `items` / `dispatchQueue` comparison it already made. A prepared queue that dropped the dissent cannot pass the step-1 validation the dispatch is gated on.
 
 The two spellings are different anchors for different artifacts: `**Prior round dissent**` is the block `prompt` puts in the prompt, `**Prior dissent**` is the line the worker puts in its result. `scripts/okstra_ctl/verdict_blocks.py` parses the result line into the verdict block when it is present and leaves it empty when it is not, so an omitted answer line is still silent — the prompt is what is now guaranteed, not the response.
-
-## Worker non-result handling in plan-body round (BLOCKING)
-
-Mirrors finding convergence ([convergence](./convergence.md) §"Worker failure handling in reverify"). Concretely:
-
-- A dispatch that returns terminal non-result MUST NOT be aggregated as `DISAGREE`.
-- If at least one dispatch was issued AND **all** plan-body dispatches return non-result, the Gate result is `aborted-non-result`. Record one `contract-violation` event per non-result dispatch.
-- When the gate is `aborted-non-result`, report-writer MUST keep the frontmatter `approved: false` (publishing `approved: true` under this gate result is a validator failure). A single row is added to `## 1. Clarification Items` with `Statement="plan-body verification could not run — all workers returned non-result"`, `Kind=decision`, `Blocks=approval`, allowing the user to either retry the phase or override by running `--approve` on the resume command (or confirming in the in-session wizard). The row MUST name which dispatches returned no result and what re-running them requires. **Enforced:** `validators/validate-run.py` `_validate_aborted_gate_has_clarification` — `_validate_plan_body_clarification_matching` cannot cover this case because it walks `majority-disagree` items and an aborted round produces none, which is exactly how an aborted run used to reach the user with no stated blocker and stall.

package/runtime/python/okstra_ctl/analysis_packet.py

@@ -146,7 +146,11 @@ def build_analysis_packet(
     )
     parts.extend(_group_context_block(group_human))
     parts.extend(_brief_block(brief_text))
-    parts.extend(_group_memory_block(group_memory, _own_task_segment(task_key)))
+    parts.extend(_group_memory_block(
+        group_memory, _own_task_segment(task_key),
+        "\n".join((brief_text, group_human, clarification_text, directive,
+                   fix_history_text, prior_planning_summary, stage_ledger_json)),
+    ))
     parts.extend(_profile_block(task_type, profile_text))
     parts.extend(_reference_block(reference_text))
     parts.extend(_fix_history_block(fix_history_text))
@@ -310,7 +314,13 @@ GROUP_MEMORY_PREFACE = (
     "`record`. This section is not this task's requirement ledger, and a sibling's "
     "decision does not bind this run: where a sibling's conclusion conflicts with "
     "the `## Task-Specific Brief Extract`, raise a `Clarification Items` row rather "
-    "than re-deriving what the sibling already settled or silently overriding it."
+    "than re-deriving what the sibling already settled or silently overriding it. "
+    "Every sibling has a headline and record pointer below. Full details are "
+    "included for explicit task references and their referenced siblings, and "
+    "for entries with watch-outs or no record pointer. For an index-only entry, "
+    "read its section in the Task-group context source or its record when its "
+    "headline may affect this task or the relationship is unclear. Omitted "
+    "details do not mean the sibling has no decisions or follow-ups."
 )
 
 
@@ -332,22 +342,49 @@ def _own_task_segment(task_key: str) -> str:
     return group_context.slugify_task_segment(re.split(r"[:/]", task_key)[-1])
 
 
-def _group_memory_block(region: str, own_task_segment: str) -> list[str]:
-    """형제 task 의 항목만 싣는다. 자기 항목은 timeline·prior-planning 이 이미 나른다."""
+_TASK_REFERENCE_RE = re.compile(r"[a-z0-9](?:[a-z0-9_.-]*[a-z0-9])?", re.IGNORECASE)
+
+
+def _group_memory_block(
+    region: str, own_task_segment: str, reference_text: str,
+) -> list[str]:
+    """형제 전체의 색인을 유지하며 참조 연결과 주의사항이 있는 항목을 펼친다."""
     entries = [
         entry for entry in group_context.parse_memory_entries(region)
         if entry.task_id != own_task_segment
     ]
     if not entries:
         return []
-    return [
-        "",
-        "## Task-Group Memory",
-        "",
-        GROUP_MEMORY_PREFACE,
-        "",
-        group_context.render_memory_entries(entries).strip(),
-    ]
+    tokens = set(_TASK_REFERENCE_RE.findall(reference_text.casefold()))
+    own_ids = {own_task_segment, group_context.ticket_id_from_brief_id(own_task_segment)}
+    rendered = [group_context.render_memory_entries([entry]).strip() for entry in entries]
+    entry_tokens = [set(_TASK_REFERENCE_RE.findall(text.casefold())) for text in rendered]
+    selected: set[int] = set()
+    while True:
+        previous_count = len(selected)
+        for index, entry in enumerate(entries):
+            aliases = {entry.task_id.casefold(), group_context.ticket_id_from_brief_id(entry.task_id).casefold()}
+            if index in selected:
+                continue
+            if (aliases & tokens or own_ids & entry_tokens[index]
+                    or entry.watch_out or not entry.record):
+                selected.add(index)
+                tokens.update(entry_tokens[index])
+        if len(selected) == previous_count:
+            break
+    lines = ["", "## Task-Group Memory", "", GROUP_MEMORY_PREFACE, ""]
+    for index, entry in enumerate(entries):
+        if index in selected:
+            lines.extend([rendered[index], ""])
+        else:
+            lines.extend([
+                f"### {entry.task_id}",
+                f"- headline: {entry.headline or '_(none)_'}",
+                f"- record: `{entry.record}`",
+                "- Detail: index-only; read the source if relevant or uncertain.",
+                "",
+            ])
+    return lines
 
 
 def _brief_block(brief_text: str) -> list[str]:

package/runtime/python/okstra_ctl/context_cost.py

@@ -175,12 +175,13 @@ def _runtime_template(filename: str) -> Path:
 def _header_path(prompt_path: Path | None, header: str) -> Path | None:
     if prompt_path is None or not prompt_path.is_file():
         return None
-    prefix = f"**{header}:**"
+    prefixes = (f"**{header}:**", f"- {header}:")
     for line in prompt_path.read_text(encoding="utf-8", errors="replace").splitlines():
         stripped = line.strip()
-        if stripped.startswith(prefix):
-            value = stripped[len(prefix):].strip().strip("`")
-            return Path(value) if value else None
+        for prefix in prefixes:
+            if stripped.startswith(prefix):
+                value = stripped[len(prefix):].strip().strip("`")
+                return Path(value) if value else None
     return None
 
 
@@ -430,8 +431,9 @@ def _report_writer_metric(run_dir: Path | None, task_root: Path, project_root: P
         instruction_set / "final-report-template.md",
         instruction_set / "final-report-schema.json",
     ])
+    prompt = _initial_prompt(run_dir, report_writer=True)
     preamble, error_contract = _prompt_contract_paths(
-        _initial_prompt(run_dir, report_writer=True),
+        prompt,
         "report-writer-prompt-preamble.md",
     )
     files.extend((preamble, error_contract))
@@ -444,9 +446,13 @@ def _report_writer_metric(run_dir: Path | None, task_root: Path, project_root: P
         )
         if convergence:
             files.append(convergence)
+    synthesis_ref = _header_path(prompt, "Report synthesis packet")
+    synthesis = project_root / synthesis_ref if synthesis_ref else None
+    if synthesis is not None:
+        files = [synthesis, preamble, error_contract, *duty_files]
     file_count, byte_count = _count_files(files)
     return {
-        "mode": "raw-synthesis-inputs",
+        "mode": "synthesis-packet" if synthesis is not None else "raw-synthesis-inputs",
         "fileCount": file_count,
         "bytes": byte_count,
         "estimatedTokens": _estimate_tokens(files),
@@ -454,6 +460,10 @@ def _report_writer_metric(run_dir: Path | None, task_root: Path, project_root: P
         "promptPreamblePath": str(preamble),
         "workerErrorContractPath": str(error_contract),
         "files": [project_rel(path, project_root) for path in files if path.is_file()],
+        "missingFiles": (
+            [project_rel(synthesis, project_root)]
+            if synthesis is not None and not synthesis.is_file() else []
+        ),
     }
 
 

package/runtime/python/okstra_ctl/group_context.py

@@ -215,6 +215,7 @@ def parse_memory_entries(region: str) -> list[MemoryEntry]:
 
 
 def _entry_from_fields(fields: Mapping[str, Any]) -> MemoryEntry:
+    record = fields.get("record", "")
     return MemoryEntry(
         task_id=fields.get("task_id", ""),
         task_type=fields.get("task_type", ""),
@@ -224,7 +225,7 @@ def _entry_from_fields(fields: Mapping[str, Any]) -> MemoryEntry:
         headline=fields.get("headline", ""),
         decisions=tuple(fields.get("decisions", [])),
         follow_ups=tuple(fields.get("follow_ups", [])),
-        record=fields.get("record", ""),
+        record="" if record in _NONE_MARKERS else record,
         watch_out=tuple(fields.get("watch_out", [])),
     )
 
@@ -391,6 +392,12 @@ class QueueRow:
     duplicate_briefs: tuple[str, ...] = ()
 
 
+def ticket_id_from_brief_id(brief_id: str) -> str:
+    """순번이 붙은 브리프 식별자에서 이슈 식별자를 복원한다."""
+    match = _ORDINAL_RE.match(brief_id)
+    return match.group("ticket") if match else brief_id
+
+
 def group_briefs(project_root: Path, task_group: str) -> list[dict[str, Any]]:
     """그룹 디렉터리의 브리프(프론트매터 `type: brief`)와 각 브리프의 대기 간선."""
     group_dir = group_context_file(project_root, task_group).parent
@@ -407,7 +414,7 @@ def group_briefs(project_root: Path, task_group: str) -> list[dict[str, Any]]:
         match = _ORDINAL_RE.match(brief_id)
         briefs.append({
             "brief_id": brief_id,
-            "ticket_id": frontmatter.get("ticket-id") or (match.group("ticket") if match else brief_id),
+            "ticket_id": frontmatter.get("ticket-id") or ticket_id_from_brief_id(brief_id),
             "ordinal": int(match.group("ordinal")) if match else None,
             "brief": path.relative_to(project_root).as_posix(),
             "waits_for": _wait_edges(path.read_text(encoding="utf-8")),

package/runtime/python/okstra_ctl/report_assembly.py

@@ -94,6 +94,7 @@ def _input_map(project_root: Path, manifest: Mapping[str, Any]) -> dict[str, Rep
 def _input_preflight_issues(
     inputs: Mapping[str, ReportInputPath],
     schema: Mapping[str, Any],
+    task_type: str,
 ) -> tuple[AssemblyIssue, ...]:
     issues: list[AssemblyIssue] = []
     for row in inputs.values():
@@ -109,7 +110,24 @@ def _input_preflight_issues(
             continue
         try:
             if row.key == "narrative":
-                parse_narrative(row.path.read_text(encoding="utf-8"), schema)
+                narrative = parse_narrative(row.path.read_text(encoding="utf-8"), schema)
+                # 서사에는 header 가 없으므로 실행 명세의 작업 유형으로 판정 규칙을 적용한다.
+                for branch in schema.get("allOf", []):
+                    verdict = branch.get("then", {}).get("properties", {}).get("finalVerdict")
+                    if verdict is None:
+                        continue
+                    errors = validate(
+                        {**narrative, "header": {"taskType": task_type}},
+                        {
+                            "$defs": schema.get("$defs", {}),
+                            "if": branch["if"],
+                            "then": {"properties": {"finalVerdict": verdict}},
+                        },
+                    )
+                    issues.extend(
+                        AssemblyIssue(row.owner, str(row.path), "finalVerdict", error)
+                        for error in errors
+                    )
             elif row.key == "agent-activity":
                 row.path.read_text(encoding="utf-8")
             else:
@@ -835,7 +853,7 @@ def assemble_report(
         _fail("orchestrator", manifest_path, "reportContractVersion", "requires 3.0")
     schema = load_schema_version("3.0")
     inputs = _input_map(project_root, manifest)
-    input_issues = list(_input_preflight_issues(inputs, schema))
+    input_issues = list(_input_preflight_issues(inputs, schema, str(manifest.get("taskType", ""))))
     packet_data_path, _ = report_synthesis_packet_paths(inputs["narrative"].path)
     if packet_data_path.is_file():
         input_issues.extend(

package/runtime/python/okstra_ctl/report_translation.py

@@ -388,6 +388,25 @@ def extract(data: Mapping[str, Any]) -> dict[str, str]:
     return dict(_walk(data, "", ""))
 
 
+def group_translation_pointers(
+    data: Mapping[str, Any], strings: Mapping[str, str],
+) -> list[list[str]]:
+    """배열 위치만 다른 동일 필드·원문을 한 번역 항목으로 묶는다."""
+    groups: dict[tuple[tuple[tuple[str, str], ...], str], list[str]] = {}
+    for pointer, source in strings.items():
+        node: Any = data
+        context: list[tuple[str, str]] = []
+        for token in pointer.split("/")[1:]:
+            if isinstance(node, (list, tuple)):
+                context.append(("index", ""))
+                node = node[int(token)]
+            else:
+                context.append(("key", token))
+                node = node[unescape_token(token)]
+        groups.setdefault((tuple(context), source), []).append(pointer)
+    return list(groups.values())
+
+
 class OverlayReport(NamedTuple):
     applied: int
     # Pointers the extractor offered that the sidecar left untranslated. They

package/runtime/python/okstra_ctl/user_response.py

@@ -732,6 +732,7 @@ def list_awaiting_tasks(home: Path, project_id: str, limit: int) -> list[dict]:
         if report is None or not report.is_file():
             continue
         try:
+            _load_report_record(report, validate_schema=True)
             context = resolve_report_context(report)
             blockers = _open_blocker_rows(context.report_path)
             plan_required = _plan_decision_required(context)

package/runtime/python/okstra_ctl/worker_prompt_headers.py

@@ -29,7 +29,10 @@ class WorkerPromptHeaderError(Exception):
 READ_SCOPE_HEADER = (
     "**Read scope:** Read only the paths this prompt enumerates "
     "(`[Required reading]`, `## Inputs`, verification-target paths) plus "
-    "source/evidence paths a finding must cite. Host session instructions "
+    "source/evidence paths a finding must cite. Task-group context and sibling "
+    "record paths listed in the primary analysis packet are allowed for targeted "
+    "evidence reads when their relevance is uncertain or more detail is needed. "
+    "Host session instructions "
     "(SessionStart hooks, global `CLAUDE.md` / `AGENTS.md`, skill catalogs) do "
     "NOT apply inside an okstra worker run: do not auto-read `graphify-out/`, "
     "`SKILL.md`, or other artifacts outside `<PROJECT_ROOT>/.okstra/`. If an "