okstra 0.197.0 → 0.198.0

package/runtime/skills/okstra-brief-gen/SKILL.md

@@ -1024,13 +1024,30 @@ per-page ratio instead of origin load). If the file is absent, ask once via
 - `Skip — this group needs no shared context`.
 
 Never fill the skeleton yourself from the tickets: a ticket summary decides
-nothing, and the sections ask for what the tickets do not say. If the file
-exists, leave it untouched and mention its path in the hand-off block. The
-file's trailing `## Task Memory` region (between `<!-- okstra:task-memory:begin -->`
-and `end`) is okstra's: `report-finalize` rewrites it after every run with the
-group's start order and each task's latest conclusion, and a group whose
-runs finished before anyone created the file already has one holding that
-region alone — `init` then inserts the human sections above it.
+nothing, and the sections ask for what the tickets do not say.
+
+If the file exists, what you do with it depends on what you are writing:
+
+- **A new brief** leaves it untouched. Mention its path in the hand-off block.
+- **A rewrite or correction of an existing brief** reconciles it in the same
+  response, whenever the change supersedes something the group document
+  states — a Definition of Better figure, a success signal, a Group-Wide
+  Constraint, a Ticket Relation, or what it says is executable from the
+  project root. okstra copies this file into every run's
+  `instruction-set/task-group-context.md` and carries it in the analysis
+  packet **ahead of the brief extract**, so a sentence you corrected in the
+  brief is still outranked by the group document's stale copy of it. Qualify a
+  diverged figure with the date and method of the measurement that contradicts
+  it rather than deleting it, and name the brief the correction came from.
+
+Either way, edit only the authored sections. The file's trailing `## Task Memory`
+region (between `<!-- okstra:task-memory:begin -->` and `end`) is okstra's: it
+holds the group's start order and each task's latest conclusion, and okstra
+redraws it after every run's `report-finalize`, at `okstra set-work-status`, and
+before each run copies the file into its instruction set. Anything written there
+by hand is overwritten without warning. A group whose runs finished before
+anyone created the file already has one holding that region alone — `init` then
+inserts the human sections above it.
 
 Then stop. Do not invoke `okstra-run` directly — the user chooses when to
 proceed, and they may want to edit the brief externally first. In the

package/runtime/skills/okstra-inspect/facets/recap.md

@@ -6,7 +6,7 @@ Loaded lazily by the dispatch table in `SKILL.md` (core). Shared rules — Step
 
 Trigger phrases: "okstra recap", "recap", "work summary", "summarize this task", "before/after summary", "explain this work", "task question".
 
-On top of the `.okstra` artifacts accumulated for a single task-id — or for every task of one task-group — (a) produce a before/after summary and (b) answer free-form questions about that work. By default it reads only the `.okstra/` subtree (artifact mode). It expands to code mode only when the user explicitly asks to look at the code changes too. This sub-command performs only the `recap-log.jsonl` append and the `notes/` note authoring (recap.5); it never mutates `task-manifest.json` / catalog / timeline / `group-context.md`.
+On top of the `.okstra` artifacts accumulated for a single task-id — or for every task of one task-group — (a) produce a before/after summary and (b) answer free-form questions about that work. By default it reads only the `.okstra/` subtree (artifact mode). It expands to code mode only when the user explicitly asks to look at the code changes too. This sub-command performs the `recap-log.jsonl` append, the `notes/` note authoring (recap.5), and the group-context reconciliation that note triggers (recap.6); it never mutates `task-manifest.json` / catalog / timeline, and it touches `group-context.md` only in the authored sections above the `<!-- okstra:task-memory:begin -->` marker.
 
 ### recap.1 — Resolve target
 
@@ -144,3 +144,19 @@ Write the body to the scratchpad as markdown first, then pass it with `--body-fi
 4. **`notes/` is inert to okstra** — no run reads it automatically. After writing, relay the `clarificationResponseArg` the CLI printed (e.g. `--clarification-response <notePath>`) to the user verbatim, telling them it only takes effect when the next run is executed with that argument.
 
 **Guardrail:** `.okstra/` is gitignored — treat `notes/` as local scratch and never `git add` it. Creating a new note is easy to undo (delete the file), so always prefer it over editing a generated or user-owned file.
+
+### recap.6 — Reconcile the task-group context (required whenever recap.5 writes a note)
+
+A group's shared context does not stay true while its tasks run. Figures get re-measured, a success signal turns out to be satisfiable without a fix, a constraint names the wrong place. `group-context.md` states in its own header that okstra copies it into each run's `instruction-set/task-group-context.md` and carries it in the analysis packet's `## Task-Group Context` section, **ahead of the brief extract** — so a stale sentence there outranks a corrected brief for every task in the group.
+
+**After writing a note, read `<PROJECT_ROOT>/.okstra/briefs/<task-group>/group-context.md` if it exists.** If anything the note establishes touches its Definition of Better figures, success signals, Group-Wide Constraints, Ticket Relations, or its statement of what is executable from the project root, update those sections **in the same response that wrote the note**. A note written without that check is an incomplete deliverable, the same way a `.project-docs/` document without its index row is.
+
+Three rules for the edit:
+
+1. **Only above the marker.** Edit the authored sections above `<!-- okstra:task-memory:begin -->`. The region below is okstra's projection — start order, per-task status, recorded runs — and it is redrawn from the task manifests at every `report-finalize`, at `okstra set-work-status`, and before each run copies the file. Anything you write there is overwritten without warning.
+2. **Qualify a diverged figure; do not delete it.** An audit number is the baseline for the window it was measured in, not a current reading. Where a direct measurement contradicts it, say so with the measurement's date and method, and keep both. Deleting the old figure destroys the reason the group exists.
+3. **Say which task and note the correction came from.** The next reader needs to get from the sentence back to its evidence.
+
+If the group has no `group-context.md`, do not create one here — `okstra group-context init` (via okstra-brief-gen) owns that skeleton, and creating an empty one pre-empts the sections a human meant to author.
+
+The same exposure applies to any other edit that supersedes group-wide facts, a brief rewrite most of all. Treat this check as belonging to the fact, not to this sub-command.

package/runtime/skills/okstra-run/SKILL.md

@@ -191,6 +191,7 @@ Repeat until `next.kind == "done"` (or `"aborted"` — terminal cancel, see "How
 
 That is the entire interactive flow. The wizard handles:
 
+- project report language before task selection: when `.okstra/project.json` has no `reportLanguage` value, ask for a language tag and save the answer to that file. An existing value skips this question. Prompt rendering and progress estimation do not save a language,
 - new-vs-existing task split (remaining work — `workStatus != done` — top-3 newest recommendations + Enter directly), task-group / task-id slug validation (task-group offers the top-3 newest candidates combining recent task use + recent `.okstra/briefs/<group>/` creation activity + Enter directly; task-id offers the top-3 recent candidates from the same group + Enter directly),
 - task-type pick (3 options + Enter directly; Enter directly is validated against the full task-type whitelist in a follow-up `text` step). **For a brand-new task the brief is asked first** and the three options are entry phases only (`requirements-discovery` / `improvement-discovery` / `project-analysis` / `feature-analysis` / `change-impact-analysis` / `error-analysis`) — a new task-key has no approved plan, no implementation and no commits, so `implementation`, `final-verification` and `release-handoff` cannot be entered there; the recommended slot comes from the selected brief's `Recommended next phase:` line and falls back to `requirements-discovery` when the brief carries none. For an existing task-key what fills those three depends on `workflow.nextRecommendedPhase` — an object `{phase, status, rationale}`, not a phase-name string. `status: ready` gives the classic trio: its `phase` marked recommended, re-run the current phase, the lifecycle's next step. Any other status contributes nothing at all, since both the recommended slot and the next-step slot derive from that phase — re-run the current phase becomes the first option and the remaining slots fill unlabelled from recently used task-types and then the whitelist. Never recover a phase name from a non-`ready` pointer and propose it yourself: prepare deliberately lowers the pointer to `pending` while its run is unfinished, and the missing recommendation is that signal,
 - brief path — **for a new task it is asked right after task-group, before the task-type** (it is the only input that says what the task is, and the task-type recommendation reads it); for an existing task it is **asked only for entry task-types (requirements-discovery / error-analysis / improvement-discovery / project-analysis / feature-analysis / change-impact-analysis)** (same-group `.okstra/briefs/<task-group>/**/*.md` candidates first, sorted by the newer of file-created/modified time and latest task-catalog use; direct input last; `Keep / Change` for existing entry tasks). `project-analysis`, `feature-analysis`, and `change-impact-analysis` are brief entry task types. On an existing task a downstream lifecycle task-type auto carries in the manifest's brief, and when no registered brief exists a `brief_carry` 3-option prompt appears (recommend switching to entry / Enter directly / Abort). `release-handoff` has no brief step of its own — a new-task run answers the brief before the type is known, and the brief is dropped at render time, so prepare always generates the input document that cites the verification report,

package/runtime/templates/reports/group-context.template.md

@@ -31,7 +31,7 @@ generator: okstra-brief-gen
 <Which tickets are causes, which are observation means, which depend on which. Write `_(none)_` when the briefs' Related Task Graph already says it all.>
 
 <!-- okstra:task-memory:begin -->
-<!-- okstra rewrites this region at every report-finalize. Edit the sections above it, not this one. -->
+<!-- okstra redraws this region after every report-finalize, at `okstra set-work-status`, and before each run copies this file. Edit the sections above it, not this one. -->
 ## Task Memory
 
 _(no runs recorded yet)_

package/runtime/validators/validate-run.py

@@ -115,6 +115,7 @@ from okstra_ctl.final_report_paths import (  # noqa: E402
 )
 from okstra_token_usage.report import _match_worker_index  # noqa: E402
 from okstra_ctl.implementation_options import (  # noqa: E402
+    validate_blocked_answer_channel,
     validate_implementation_option_selection,
 )
 from okstra_ctl.implementation_direction import (  # noqa: E402
@@ -149,6 +150,7 @@ from okstra_ctl.agent.invocation import (  # noqa: E402
     AgentInvocationError,
     agent_model_assignment_from_payload,
     invocation_execution_identity_from_manifest,
+    invocation_input_digest,
     verify_agent_invocation,
 )
 from okstra_ctl.execution_identity import ExecutionManifestError  # noqa: E402
@@ -253,6 +255,39 @@ def _result_link_attempt_status_failure(
     )
 
 
+def _dispatch_input_digest(
+    project_root: Path, row: Mapping[str, Any]
+) -> tuple[str | None, str]:
+    """이 디스패치의 예약 입력 해시, 예약이 계산한 것과 같은 방법으로.
+
+    `inputDigest` 와 `promptDigest` 는 서로 다른 대상이다. 전달 계약
+    `execution-identity-v1` 부터 예약은 **논리 작업**을 해시한다 — 시도별 전달값과
+    prompt history 경로를 뺀 본문(`agent_prompt_task_bytes`) — 반면 `promptDigest`
+    는 프롬프트 파일 전체 바이트다. 둘을 동등 비교하면 그 계약을 쓰는 run 은
+    통과할 수 있는 값이 하나도 없다(2026-09-08 f56ec08 이후 전부, 2026-09-10
+    dev-10642-15 final-verification 001 에서 7/7 디스패치가 이 규칙에 걸렸다).
+
+    그래서 재구현하지 않고 예약이 쓰는 함수를 그대로 부른다. 메타데이터 경로가
+    없는 구형 행만 `promptDigest` 로 돌아간다 — 그 계약에서는 두 값이 같다.
+    """
+    metadata_value = row.get("promptMetadataPath")
+    if not isinstance(metadata_value, str) or not metadata_value.strip():
+        return row.get("promptDigest"), ""
+    try:
+        metadata = json.loads(
+            _resolve_prompt_record_path(project_root, metadata_value)
+            .read_text(encoding="utf-8")
+        )
+    except (OSError, json.JSONDecodeError):
+        return None, "prompt metadata is missing or invalid"
+    if not isinstance(metadata, Mapping):
+        return None, "prompt metadata is not an object"
+    try:
+        return invocation_input_digest(metadata, project_root), ""
+    except (AgentInvocationError, KeyError, OSError, ValueError) as exc:
+        return None, f"input digest cannot be recomputed: {exc}"
+
+
 def _validate_agent_dispatch_contract(
     *,
     project_root: Path,
@@ -399,12 +434,16 @@ def _validate_agent_dispatch_contract(
                 )
                 continue
             invocation = canonical_invocations.get(row.get("invocationRef"))
+            input_digest, digest_error = _dispatch_input_digest(project_root, row)
+            if digest_error:
+                failures.append(f"agent dispatch {dispatch_id}: {digest_error}")
+                continue
             if not isinstance(invocation, Mapping) or any((
                 invocation.get("participantRef") != row.get("participantRef"),
                 invocation.get("roleExecutionRef") != row.get("roleExecutionRef"),
                 invocation.get("dutyId") != row.get("dutyId"),
                 invocation.get("dispatchKind") != dispatch_kind,
-                invocation.get("inputDigest") != row.get("promptDigest"),
+                invocation.get("inputDigest") != input_digest,
                 )):
                 failures.append(
                     f"agent dispatch {dispatch_id}: does not match canonical invocation"
@@ -2002,10 +2041,32 @@ def _approved_plan_conformance_manifest(
     }
 
 
+def _conformance_script_matches(actual: str, declared: str) -> bool:
+    """두 script 표기가 같은 파일을 가리키는지 판정한다.
+
+    1순위는 task-root 상대형끼리의 일치다. task_root 아래로 접히지 않는
+    절대경로(예: 워크트리 경로로 적힌 선언)가 남으면, 남은 쪽이 다른 쪽을
+    경로 경계에서 후행 일치하는지까지 본다 — `/…/wt/qa/scripts/s.ts` 와
+    `qa/scripts/s.ts` 는 같은 파일이다. 후행 일치는 경계(`/`)를 요구하므로
+    `renamed-stage-1.ts` 같은 다른 파일은 걸리지 않는다.
+    """
+    if actual == declared:
+        return True
+    if not actual or not declared:
+        return False
+    if actual.startswith("/") != declared.startswith("/"):
+        longer, shorter = (
+            (actual, declared) if actual.startswith("/") else (declared, actual)
+        )
+        return longer.endswith("/" + shorter)
+    return False
+
+
 def _declared_conformance_errors(
     declared_manifest: dict,
     actual_manifest: dict,
     stage_name: str | None,
+    task_root: Path,
 ) -> list[str]:
     """Compare scoped plan declarations with their one actual manifest entry."""
     declared = _scope_manifest_entries(declared_manifest, stage_name).get("entries", [])
@@ -2030,8 +2091,15 @@ def _declared_conformance_errors(
             errors.append(f"stage {stage_number} has multiple matching entries")
             continue
         actual_entry = matches[0]
-        actual_script = _normalize_conformance_script(str(actual_entry.get("script") or ""))
-        if actual_script != declaration.get("script"):
+        # 양쪽을 같은 task-root 상대형으로 접은 뒤 대조한다 — 계획이 절대경로를,
+        # 실행자가 상대형을 쓰면 같은 파일이 문자열로는 영영 안 맞는다.
+        actual_script = _normalize_conformance_script(
+            str(actual_entry.get("script") or ""), task_root
+        )
+        declared_script = _normalize_conformance_script(
+            str(declaration.get("script") or ""), task_root
+        )
+        if not _conformance_script_matches(actual_script, declared_script):
             errors.append(f"stage {stage_number} script mismatch")
         actual_requires = actual_entry.get("requires")
         actual_capabilities = (
@@ -2231,6 +2299,7 @@ def _validate_conformance(
                 declared_manifest,
                 empty_scoped_manifest,
                 stage_name,
+                task_root,
             ):
                 failures.append(
                     f"conformance gate BLOCKING: approved plan {error}; "
@@ -2257,6 +2326,7 @@ def _validate_conformance(
             declared_manifest,
             manifest,
             stage_name,
+            task_root,
         ):
             failures.append(
                 f"conformance gate BLOCKING: approved plan {error} "
@@ -3242,6 +3312,10 @@ def validate_final_report_data(
                 participating_analysers,
             )
         )
+        failures.extend(
+            f"implementation-option-selection: {error}"
+            for error in validate_blocked_answer_channel(data)
+        )
     elif task_type == "implementation":
         _validate_stage_carry_sidecar_exists(data, report_path, failures)
     _validate_lead_authored_report(data, report_path, failures)