okstra 0.197.0 → 0.197.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.197.0",
+  "version": "0.197.1",
   "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.197.0",
-  "builtAt": "2026-09-09T23:39:16.253Z",
+  "package": "0.197.1",
+  "builtAt": "2026-09-10T06:36:00.582Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/python/okstra_ctl/conformance.py

@@ -41,11 +41,32 @@ _CONFORMANCE_TESTS_RE = re.compile(
 )
 
 
-def normalize_conformance_script(script: str) -> str:
-    """`<task_root>/` 접두사를 뗀다. 선언과 매니페스트 entry 가 같은 스크립트를
-    서로 다른 접두사로 적을 수 있어, 대조 전에 양쪽을 이 형태로 맞춘다."""
+def normalize_conformance_script(
+    script: str,
+    task_root: Path | None = None,
+) -> str:
+    """script 표기를 task-root 상대형 한 가지로 맞춘다.
+
+    같은 스크립트를 선언(승인 계획)과 매니페스트 entry 가 서로 다른 접두사로
+    적는다 — `<task_root>/qa/...`, `./qa/...`, 그리고 계획이 절대경로
+    `/…/<task_root>/qa/scripts/stage-2.ts` 를 쓰고 실행자는 `qa/scripts/stage-2.ts`
+    를 쓴 실측(2026-09-10 dev-10628-3 stage 2). 대조 전에 양쪽을 이 함수로
+    통과시켜 표기 차이만으로 stage 가 막히지 않게 한다.
+
+    `task_root` 를 주면 그 아래를 가리키는 절대경로도 상대형으로 접는다. 주지
+    않으면 절대경로는 그대로 둔다 — 계획 단계 파싱처럼 task_root 를 모르는
+    호출부가 있다.
+    """
     prefix = "<task_root>/"
-    return script[len(prefix):] if script.startswith(prefix) else script
+    value = script[len(prefix):] if script.startswith(prefix) else script
+    while value.startswith("./"):
+        value = value[2:]
+    if task_root is not None and value.startswith("/"):
+        try:
+            return Path(value).resolve().relative_to(task_root.resolve()).as_posix()
+        except (ValueError, OSError):
+            return value
+    return value
 
 
 # 계획 서사의 정본 줄은 `Conformance tests: stage-<N> — <나머지>` 이고 data.json
@@ -87,7 +108,7 @@ def missing_declared_scripts(entries: object, task_root: Path) -> list[str]:
         script = entry.get("script")
         if not isinstance(script, str) or not script.strip():
             continue
-        relative = normalize_conformance_script(script)
+        relative = normalize_conformance_script(script, task_root)
         candidate = (root / relative).resolve()
         stage_number = str(entry.get("stageKey") or "").rsplit("-stage-", 1)[-1]
         try:

package/runtime/python/okstra_ctl/group_context.py

@@ -70,7 +70,8 @@ _NONE_MARKERS = {"_(none)_", ""}
 MEMORY_BEGIN = "<!-- okstra:task-memory:begin -->"
 MEMORY_END = "<!-- okstra:task-memory:end -->"
 MEMORY_NOTE = (
-    "<!-- okstra rewrites this region at every report-finalize. "
+    "<!-- 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. -->"
 )
 MEMORY_HEADING = "## Task Memory"
@@ -323,6 +324,32 @@ def record_task_memory(
     return target, queue
 
 
+def refresh_group_queue(project_root: Path, task_group: str) -> Path | None:
+    """그룹 문서의 시작 순서만 지금 값으로 다시 그린다. 문서가 없으면 아무것도 안 한다.
+
+    기록된 항목과 사람 절은 바이트 그대로 두고 큐만 다시 계산한다. 이 투영을
+    쓰는 곳은 원래 report-finalize 의 `record-group-memory` 하나뿐이라, 리포트
+    없이 끝난 run 이나 사람이 손으로 바꾼 상태는 다음 finalize 까지 문서에
+    닿지 않았다(2026-09-10 실측, cache 그룹 dev-10635: `workStatus` 를 done 으로
+    적었는데 큐는 `[in progress] — requirements-discovery (blocked)` 그대로).
+    같은 그룹의 finalize 와 겹칠 수 있으므로 같은 flock 아래에서 읽고-쓴다.
+    """
+    target = group_context_file(project_root, task_group)
+    if not target.is_file():
+        return None
+    with dir_flock(target.parent, LOCK_FILENAME):
+        text = target.read_text(encoding="utf-8")
+        before, region, after = split_memory_region(text)
+        if not region:
+            return None
+        entries = parse_memory_entries(region)
+        queue = group_queue(project_root, task_group, entries)
+        updated = before + render_memory_region(entries, queue) + after
+        if updated != text:
+            target.write_text(updated, encoding="utf-8")
+    return target
+
+
 # --- 시작 순서 ----------------------------------------------------------------
 #
 # 그룹의 task 는 순서가 있을 수 있다. 순서는 brief-gen 이 매긴 브리프 순번
@@ -332,6 +359,11 @@ def record_task_memory(
 # 15번 가드 티켓이 1번을 `blocks` 한다고 적었지만 사용자는 1번을 먼저 끝냈다.
 # 큐는 영역 머리에 실리고, 이 task 가 끝나는 closeout 은 큐의 다음 task 를 이름한다.
 
+# `okstra set-work-status` 가 task-manifest 에 적는 값 중 큐 상태를 덮는 것.
+# 나머지(`todo` / `in-progress` / `blocked`)는 큐의 세 상태로 옮길 때 파생값보다
+# 나은 정보가 없어 덮지 않는다.
+WORK_STATUS_DONE = "done"
+
 QUEUE_DONE = "done"
 QUEUE_IN_PROGRESS = "in progress"
 QUEUE_NOT_STARTED = "not started"
@@ -354,6 +386,9 @@ class QueueRow:
     status: str         # QUEUE_*
     progress: str       # "<task-type> #<seq>" for a recorded task, else ""
     waits_for: tuple[str, ...] = ()   # ticket ids the graph says come first and are not done
+    # 같은 `brief-id` 를 가진 다른 브리프 파일들. 하나의 task 를 두 파일이
+    # 주장하는 상태이므로 큐는 정본 한 줄만 싣고 나머지를 여기 이름한다.
+    duplicate_briefs: tuple[str, ...] = ()
 
 
 def group_briefs(project_root: Path, task_group: str) -> list[dict[str, Any]]:
@@ -417,6 +452,15 @@ def catalog_progress(project_root: Path, task_group: str) -> dict[str, tuple[str
         state = str(entry.get("currentPhaseState") or entry.get("latestRunStatus") or "")
         progress = f"{phase} ({state})" if phase and state else phase
         status = QUEUE_DONE if pointer.get("status") == STATUS_TERMINAL else QUEUE_IN_PROGRESS
+        # 사용자가 `okstra set-work-status <task> done` 으로 끝났다고 선언한 task
+        # 는 끝난 것이다. 파생 포인터만 보면 리포트 없이 끝난 run 이 영원히
+        # `[in progress]` 로 남는다 — 실측(2026-09-10, fontsninja-v3-site cache
+        # 그룹 dev-10635): 사람이 AWS 콘솔에서 작업을 마치고 `done` 을 적었는데,
+        # 그 run 이 리포트 조립 실패로 끝나 포인터가 `blocked` 에 멈춰 있었다.
+        # 파생 표기는 지우지 않는다 — 왜 done 인지가 그 차이에 남는다.
+        if str(entry.get("workStatus") or "") == WORK_STATUS_DONE:
+            status = QUEUE_DONE
+            progress = f"{progress} · marked done" if progress else "marked done"
         out[task_id] = (status, progress)
     return out
 
@@ -439,6 +483,7 @@ def group_queue(
     for brief in briefs:
         for ticket, before in brief["waits_for"].items():
             waits.setdefault(ticket, set()).update((before & by_ticket.keys()) - {ticket})
+    briefs, duplicates = _fold_duplicate_briefs(briefs)
     ordered = sorted(briefs, key=lambda b: (b["ordinal"] is None, b["ordinal"] or 0, b["brief_id"]))
     by_task = {entry.task_id: entry for entry in entries}
     recorded = catalog_progress(project_root, task_group)
@@ -464,10 +509,50 @@ def group_queue(
         rows.append(QueueRow(
             slugify_task_segment(brief["brief_id"]), brief["brief_id"], brief["ticket_id"],
             brief["brief"], status, progress, open_waits,
+            duplicates.get(brief["brief_id"], ()),
         ))
     return rows
 
 
+def _fold_duplicate_briefs(
+    briefs: list[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], dict[str, tuple[str, ...]]]:
+    """같은 `brief-id` 를 주장하는 브리프들을 정본 하나로 접는다.
+
+    `brief-id` 는 task 디렉터리 이름(`task_id`)의 출처라, 두 파일이 같은 id 를
+    달면 하나의 task 를 둘이 주장하는 상태다. 접지 않으면 큐가 같은 task 를 두
+    줄로 싣고 번호가 브리프 수보다 커진다 — `next_in_group` 과 closeout 도 같은
+    task 를 두 번 가리킨다(2026-09-10 실측, fontsninja-v3-site `cache` 그룹:
+    개정 전 브리프를 `.superseded-<날짜>.md` 로 같은 디렉터리에 남겨 15개 그룹의
+    큐가 16번까지 갔다).
+
+    정본은 파일 이름이 곧 `brief-id` 인 파일이다 — brief-gen 이 쓰는 이름이고,
+    같은 id 를 단 다른 이름은 사본이다. 그런 파일이 없거나 여럿이면 경로 순서로
+    첫 번째다. 거절하지 않는 이유는 이 큐를 report-finalize 와 위저드가 읽기
+    때문이다: 브리프 디렉터리 정리가 안 됐다고 run 발행을 막을 일은 아니다.
+    대신 남은 사본을 `duplicate_briefs` 로 실어 큐가 그 사실을 말한다.
+    """
+    by_id: dict[str, list[dict[str, Any]]] = {}
+    for brief in briefs:
+        by_id.setdefault(brief["brief_id"], []).append(brief)
+    kept: list[dict[str, Any]] = []
+    duplicates: dict[str, tuple[str, ...]] = {}
+    for brief_id, group in by_id.items():
+        if len(group) == 1:
+            kept.append(group[0])
+            continue
+        ordered_group = sorted(group, key=lambda b: b["brief"])
+        canonical = next(
+            (b for b in ordered_group if Path(b["brief"]).stem == brief_id),
+            ordered_group[0],
+        )
+        kept.append(canonical)
+        duplicates[brief_id] = tuple(
+            b["brief"] for b in ordered_group if b is not canonical
+        )
+    return kept, duplicates
+
+
 def next_in_group(queue: list[QueueRow]) -> QueueRow | None:
     """시작 순서에서 아직 시작하지 않은 첫 task."""
     return next((row for row in queue if row.status == QUEUE_NOT_STARTED), None)
@@ -482,6 +567,13 @@ def render_queue(queue: list[QueueRow]) -> str:
         if row.waits_for:
             tail += f" (waits for {', '.join(row.waits_for)})"
         lines.append(f"{number}. [{row.status}] {row.task_id}{tail}")
+        # 사본을 이름한다. 이 줄이 없으면 큐가 조용히 한 파일을 무시하고, 그
+        # 파일을 고친 사람은 자기 편집이 어디로 갔는지 알 길이 없다.
+        for extra in row.duplicate_briefs:
+            lines.append(
+                f"   - ignored duplicate of this brief-id: `{extra}` — one task, "
+                "two brief files. Move the copy out of the briefs directory."
+            )
     return "\n".join(lines) + "\n"
 
 
@@ -657,8 +749,9 @@ def _init_command(args: argparse.Namespace) -> int:
         "line remains; delete the file if the group needs no context."
     )
     print(
-        f"The trailing `{MEMORY_HEADING}` region is written by okstra at every "
-        "report-finalize; leave it alone."
+        f"The trailing `{MEMORY_HEADING}` region is okstra's — redrawn after every "
+        "report-finalize, at `okstra set-work-status`, and before each run copies "
+        "this file; leave it alone."
     )
     return 0
 

package/runtime/python/okstra_ctl/run.py

@@ -3631,6 +3631,23 @@ def _stage_or_clear(path: Path, body: str) -> None:
     path.unlink(missing_ok=True)
 
 
+def _refresh_group_context_queue(project_root: Path, task_group: str) -> None:
+    """그룹 문서의 시작 순서를 지금 값으로 다시 그린다. 실패해도 run 은 계속한다.
+
+    파생 표면이라 이것 때문에 run 준비를 멈출 이유가 없다. 대신 삼키지 않고
+    stderr 로 알린다 — 워커가 낡은 형제 상태를 읽었다는 사실을 나중에 설명할
+    근거가 남아야 한다.
+    """
+    try:
+        group_context.refresh_group_queue(project_root, task_group)
+    except (OSError, ValueError) as exc:
+        print(
+            f"prepare: group-context start order for {task_group!r} could not be "
+            f"redrawn before it was copied into the instruction set: {exc}",
+            file=sys.stderr,
+        )
+
+
 def _write_instruction_set_sources(
     inp: PrepareInputs,
     ctx: dict,
@@ -3694,6 +3711,12 @@ def _write_instruction_set_sources(
     (instruction_set / "analysis-material.md").write_text(review_material, encoding="utf-8")
     shutil.copyfile(inp.brief_path, instruction_set / "task-brief.md")
     # 그룹 맥락은 preflight 를 통과한 파일만 여기 온다(`_validate_group_context_preflight`).
+    #
+    # 복사 직전에 시작 순서를 다시 그린다. 이 파일은 그대로 워커의 analysis
+    # packet 에 실리므로, 형제 task 의 상태가 낡은 채로 복사되면 워커는 이미 끝난
+    # task 를 진행 중으로 읽는다. 투영을 쓰는 곳이 report-finalize 뿐이던 동안
+    # 리포트 없이 끝난 run 의 상태는 다음 finalize 까지 문서에 닿지 않았다.
+    _refresh_group_context_queue(Path(inp.project_root), inp.task_group)
     group_context_source = group_context.group_context_file(
         Path(inp.project_root), inp.task_group
     )

package/runtime/python/okstra_ctl/set_work_status.py

@@ -14,6 +14,7 @@ import sys
 from datetime import datetime, timezone
 from pathlib import Path
 
+from okstra_ctl import group_context
 from okstra_ctl.ids import slugify_task_segment
 from okstra_ctl.fixed_text import line, scalar
 from okstra_ctl.paths import task_dir, task_manifest_file
@@ -38,6 +39,7 @@ def _emit(payload: dict, *, text: bool = False) -> None:
         ("taskKey", "Task key"), ("previousWorkStatus", "Previous work status"),
         ("workStatus", "Work status"), ("workStatusUpdatedAt", "Updated at"),
         ("workStatusNote", "Note"), ("taskManifestPath", "Task manifest"),
+        ("groupContextPath", "Group context"),
     ):
         if key in payload:
             lines.append(line(label, payload.get(key)).rstrip("\n"))
@@ -152,6 +154,29 @@ def _updated_payload(manifest_path: Path, manifest: dict, entry: dict, args) ->
     }
 
 
+def _refresh_group_queue(project_root: Path, entry: dict) -> str:
+    """상태를 바꾼 task 가 속한 그룹 문서의 시작 순서를 다시 그린다.
+
+    그 투영을 쓰는 곳이 report-finalize 하나뿐이라, 여기서 갱신하지 않으면
+    사람이 적은 상태가 다음 finalize 까지 그룹 문서에 닿지 않는다. 그룹 문서가
+    없거나 갱신에 실패해도 상태 기록 자체는 성공이다 — 매니페스트는 이미
+    쓰였고, 이것은 파생 표면이다. 실패는 삼키지 않고 stderr 로 알린다.
+    """
+    task_group = str(entry.get("taskGroup") or "")
+    if not task_group:
+        return ""
+    try:
+        target = group_context.refresh_group_queue(project_root, task_group)
+    except (OSError, ValueError) as exc:
+        print(
+            f"set-work-status: work status recorded, but the group-context start "
+            f"order for {task_group!r} could not be redrawn: {exc}",
+            file=sys.stderr,
+        )
+        return ""
+    return str(target) if target is not None else ""
+
+
 def main(argv: list[str] | None = None) -> int:
     args = _parse_args(argv)
     project_root, entry, resolution_exit = _resolve_entry(args)
@@ -184,7 +209,11 @@ def main(argv: list[str] | None = None) -> int:
         )
         return 1
 
-    _emit(_updated_payload(manifest_path, manifest, entry, args), text=args.text)
+    payload = _updated_payload(manifest_path, manifest, entry, args)
+    refreshed = _refresh_group_queue(project_root, entry)
+    if refreshed:
+        payload["groupContextPath"] = refreshed
+    _emit(payload, text=args.text)
     return 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/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

@@ -2002,10 +2002,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 +2052,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 +2260,7 @@ def _validate_conformance(
                 declared_manifest,
                 empty_scoped_manifest,
                 stage_name,
+                task_root,
             ):
                 failures.append(
                     f"conformance gate BLOCKING: approved plan {error}; "
@@ -2257,6 +2287,7 @@ def _validate_conformance(
             declared_manifest,
             manifest,
             stage_name,
+            task_root,
         ):
             failures.append(
                 f"conformance gate BLOCKING: approved plan {error} "