okstra 0.196.0 → 0.197.1

package/runtime/python/okstra_ctl/dispatch_state.py

@@ -61,7 +61,10 @@ from .worker_prompt_contract import (
     validate_prompt_model_header,
     validate_reverify_prompt,
 )
-from .worker_prompt_policy import is_verification_dispatch_kind
+from .worker_prompt_policy import (
+    is_verification_dispatch_kind,
+    verification_dispatch_round,
+)
 from .worker_runner import LIVE, QUIET
 from .worker_request import verifier_extra_dirs
 from .worker_artifact_paths import audit_sidecar_rel
@@ -1000,13 +1003,14 @@ def prompt_anchor_values(
 
 
 def _execution_dispatch_round(dispatch_kind: str) -> int:
-    prefix = "reverify-r"
-    if not dispatch_kind.startswith(prefix):
+    """attempt 행에 적는 라운드 번호. 예약(`agent-prompt materialize` 의
+    `_reservation_round`)과 같은 계산을 써야 한다."""
+    if not is_verification_dispatch_kind(dispatch_kind):
         return 1
-    suffix = dispatch_kind[len(prefix):]
-    if not suffix.isdigit() or int(suffix) < 1:
-        raise DispatchError(f"invalid reverify dispatch kind: {dispatch_kind}")
-    return int(suffix)
+    round_number = verification_dispatch_round(dispatch_kind)
+    if round_number is None:
+        raise DispatchError(f"invalid verification dispatch kind: {dispatch_kind}")
+    return round_number
 
 
 def link_agent_dispatch_result(

package/runtime/python/okstra_ctl/domain/worker_stream.py

@@ -38,7 +38,6 @@ _MAX_SUMMARY = 120
 # 결과 하나가 pane 을 다 차지하면 직전 호출이 위로 밀려 나가므로 앞부분만
 # 보여주고, 나머지는 로그가 갖는다.
 _LIVE_BODY_ROWS = 4
-_BODY_INDENT = "    "
 
 
 @dataclass(frozen=True)
@@ -197,8 +196,8 @@ def _rows(event: StreamEvent, *, limit: int | None, body_rows: int | None) -> li
             tail = (
                 f"the tool reported: {report}" if report else "the tool reported nothing"
             )
-            return [_truncate(f"  ← {_outcome(event.failed)} — no body returned; {tail}", limit)]
-        head = f"  ← {_outcome(event.failed)} ({event.size_bytes} bytes)"
+            return [_truncate(f"← {_outcome(event.failed)} — no body returned; {tail}", limit)]
+        head = f"← {_outcome(event.failed)} ({event.size_bytes} bytes)"
         return [head, *_result_body(event.body, limit=limit, keep=body_rows)]
     if isinstance(event, Denial):
         return [_truncate(f"!! PERMISSION DENIED — {event.tool}: {event.reason}", limit)]
@@ -217,10 +216,10 @@ def _result_body(body: str, *, limit: int | None, keep: int | None) -> list[str]
     rows = _body_rows(body)
     if keep is None:
         return rows
-    shown = [_truncate(_BODY_INDENT + row, limit) for row in rows[:keep]]
+    shown = [_truncate(row, limit) for row in rows[:keep]]
     dropped = len(rows) - keep
     if dropped > 0:
-        shown.append(f"{_BODY_INDENT}… +{dropped} more line(s) — full body in the log")
+        shown.append(f"… +{dropped} more line(s) — full body in the log")
     return shown
 
 

package/runtime/python/okstra_ctl/final_report_schema.py

@@ -202,7 +202,68 @@ class _Validator:
             elif schema.get("additionalProperties") is False:
                 # Don't fire for keys we know are part of the conditional
                 # branches (we still validate values when they appear).
-                self._err(path, f"additional property '{name}' is not allowed")
+                self._err(
+                    path,
+                    f"additional property '{name}' is not allowed"
+                    + self._misplaced_property_hint(name, path),
+                )
+
+    def _misplaced_property_hint(
+        self, name: str, path: tuple[str | int, ...],
+    ) -> str:
+        """이 키가 스키마의 다른 자리에서 정의된 필드면 "옮겨라" 를 덧붙인다.
+
+        `additional property 'X' is not allowed` 만 보면 "스키마에 그런 칸이
+        없다" 로 읽힌다. 실제로는 X 가 다른 객체의 필드이고 작성자가 자리를
+        틀린 경우가 있고, 그때 지우면 다음 라운드에서 `required property 'X'
+        is missing` 이 나온다 — 라운드 하나를 왕복에 쓴다(2026-09-09 실측,
+        dev-10642 implementation-planning: 최상위 필수 `summary` 를
+        `rationale` 안에 써서 지웠다가 되살렸다).
+        """
+        found = self._required_property_owners(name) - {_format_path(path)}
+        if not found:
+            return ""
+        # 최상위를 앞에 둔다. 잘못 놓인 키는 대개 최상위 필드가 한 단계 안으로
+        # 들어간 것이고, 나머지 소유자는 같은 이름을 쓰는 다른 행 타입이다.
+        owners = (
+            ["<root>"] if "<root>" in found else []
+        ) + sorted(found - {"<root>"})
+        return (
+            f" — '{name}' is a REQUIRED property of {', '.join(owners[:3])}, not "
+            f"of {_format_path(path)}; move it there rather than removing it"
+        )
+
+    def _required_property_owners(self, name: str) -> set[str]:
+        """`name` 을 **필수**로 요구하는 객체들의 이름.
+
+        정의만 가진 자리까지 세면(예: `summary` 는 8곳에서 정의된다) 힌트가
+        이름 목록이 돼 아무것도 가리키지 못한다. 지우면 다음 라운드에서
+        `required property ... is missing` 이 나오는 자리, 즉 필수인 곳만 센다.
+        """
+        owners: set[str] = set()
+
+        def walk(node: Any, label: str) -> None:
+            if isinstance(node, list):
+                for item in node:
+                    walk(item, label)
+                return
+            if not isinstance(node, dict):
+                return
+            required = node.get("required")
+            if isinstance(required, list) and name in required:
+                owners.add(label)
+            for key, value in node.items():
+                if key == "properties" and isinstance(value, dict):
+                    for child, sub in value.items():
+                        walk(sub, f"{label}.{child}" if label else child)
+                elif key in ("definitions", "$defs") and isinstance(value, dict):
+                    for child, sub in value.items():
+                        walk(sub, child)
+                elif key in ("items", "allOf", "oneOf", "anyOf", "then", "else"):
+                    walk(value, label)
+
+        walk(self.root, "<root>")
+        return owners
 
     def _validate_array(self, instance: list, schema: dict, path: tuple[str | int, ...]) -> None:
         min_items = schema.get("minItems")

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/plan_items.py

@@ -790,6 +790,20 @@ PLAN_VERIFY_RESPONSE_FORMAT = (
 )
 
 
+# 계획 항목 큐의 렌더러 서명. 검증 계약(`worker_prompt_contract.
+# validate_reverify_prompt`)이 `plan-verify-r<N>` 디스패치에 이 줄을 요구한다 —
+# 번호 reverify 가 `okstra convergence reverify-prompt` 서명을 요구하는 것과
+# 같은 이유다. 손으로 쓴 큐는 항목 id·직전 반대 의견·응답 형식이 임의로 빠지고,
+# 그렇게 버려진 라운드가 실재한다(run 003 실측, `with_response_format` 주석).
+RENDERED_BY_LINE = "**Rendered by:** okstra plan-items prompt"
+
+
+def with_rendered_by(queue_markdown: str) -> str:
+    """렌더러 서명을 프롬프트 맨 앞에 붙인다. 디스패치는 이 출력을 그대로
+    `--instruction` 으로 받으므로 서명은 `## Task Instructions` 뒤에 놓인다."""
+    return f"{RENDERED_BY_LINE}\n\n{queue_markdown.lstrip()}"
+
+
 def with_response_format(queue_markdown: str) -> str:
     """큐 본문 뒤에 응답 형식 블록을 덧붙인다. run 003 실측: 리드가 손 조립
     중 이 블록을 빼먹어 검증자 2명의 판정 32건 전부가 형식 불일치로 버려졌다."""

package/runtime/python/okstra_ctl/plan_items_cli.py

@@ -43,6 +43,7 @@ from .plan_items import (
     reverify_prompt_text,
     tie_vote_item_ids,
     voting_analyser_keys,
+    with_rendered_by,
     with_response_format,
 )
 from .paths import RunRef
@@ -242,6 +243,14 @@ def _parser() -> argparse.ArgumentParser:
         metavar="<worker-id>=<path>",
         help="one worker's plan-verify Markdown result (repeatable)",
     )
+    apply_verdicts.add_argument(
+        "--items", type=Path,
+        metavar="<plan-items artifact>",
+        help="the plan-items artifact this round dispatched, when it dispatched "
+             "part of the queue (the `--tie-vote` artifact). Its dispatchQueue "
+             "is what each --result must answer; without it a result is checked "
+             "against the whole persisted queue",
+    )
     apply_verdicts.add_argument(
         "--run-manifest", type=Path,
         help="resolve the project a `fact` claim's probe runs against; without "
@@ -831,10 +840,10 @@ def _prompt(args: argparse.Namespace) -> str:
             rows.append(split)
     body = with_response_format("".join(rows))
     if envelope.get("dispatchKind") == "critic-tie":
-        return critic_tie_prompt_text(body)
+        return with_rendered_by(critic_tie_prompt_text(body))
     if envelope.get("dispatchKind") == "reverify":
-        return reverify_prompt_text(body)
-    return body
+        return with_rendered_by(reverify_prompt_text(body))
+    return with_rendered_by(body)
 
 
 def _validate_prepared(args: argparse.Namespace) -> dict[str, Any]:
@@ -1377,6 +1386,7 @@ def _apply_verdicts(args: argparse.Namespace) -> dict[str, Any]:
         {item_id for item_id in queue if isinstance(item_id, str)}
         if isinstance(queue, list) else known
     )
+    assigned = _narrow_assignment(args, assigned)
     rows = _incoming_verdict_rows(args, assigned)
     missing = sorted(item_id for item_id in rows if item_id not in known)
     if missing:
@@ -1872,6 +1882,38 @@ def _correction_prompt(args: argparse.Namespace) -> str:
     return correction_prompt_text(_prompt(args))
 
 
+def _narrow_assignment(
+    args: argparse.Namespace, assigned: set[object],
+) -> set[object]:
+    """이 라운드가 실제로 배정한 항목들.
+
+    tie 라운드는 큐의 일부(7항목)만 critic 에게 보낸다. 그런데 `--result` 는
+    지금까지 state 에 남은 라운드 큐(44항목) 전체를 배정으로 보고 답 없는
+    37항목을 미응답으로 거절했다 — 문서가 "model-facing" 이라고 적은 형식이
+    tie 라운드에서는 쓸 수 없고, 우회로가 헬프 스스로 historical 이라 적은
+    `--verdicts` 뿐이었다(실측 2026-09-10, fontsninja-v3-site dev-10628-3).
+    `--items` 로 그 라운드의 artifact 를 주면 그 `dispatchQueue` 가 배정이
+    된다. 미응답 검사 자체는 그대로다 — 좁힌 배정 안에서 여전히 전건을
+    요구하므로, 워커가 자기 몫을 조용히 빠뜨리는 것은 계속 잡힌다.
+    """
+    items_path = getattr(args, "items", None)
+    if items_path is None:
+        return assigned
+    narrowed = {item_id for item_id in _assigned_item_ids(items_path)}
+    if not narrowed:
+        raise PlanItemContractError(
+            f"items artifact dispatches nothing: {items_path}"
+        )
+    unknown = sorted(narrowed - {i for i in assigned if isinstance(i, str)})
+    if unknown:
+        raise PlanItemContractError(
+            f"items artifact dispatches {unknown}, which this round's persisted "
+            f"queue does not contain — pass the artifact this round dispatched, "
+            f"not another round's"
+        )
+    return narrowed
+
+
 def _incoming_verdict_rows(
     args: argparse.Namespace, known: set[object],
 ) -> dict[str, list[dict[str, Any]]]:

package/runtime/python/okstra_ctl/run.py

@@ -551,6 +551,11 @@ class PrepareInputs:
     # implementation 전용: `--qa-waiver "<stageKey>:<reason>"` 사용자 확인형 우회.
     # prepare-time 에 task-level conformance 매니페스트 entry.waiver 를 채운다.
     qa_waiver: str = ""
+    # implementation-planning 전용: `--tdd-bypass "<stage>:<reason>"` 사용자
+    # 확인형 TDD 우회. prepare-time 에 `<task-root>/qa/tdd-bypass.json` 에
+    # 사유를 원문 그대로 남기고, S10e 는 그 원장이 있을 때만 계획서의
+    # `tddExemption: user-bypass` 를 인정한다.
+    tdd_bypass: str = ""
     stage: str = "auto"
     # release-handoff 전용: PR 로 내보낼 stage 묶음 (csv, 예: "2,3"). 빈 값 =
     # whole-task 모드. `--stage`(impl/fv 의 Stage Map 실행/검증 선택)와는
@@ -1915,6 +1920,40 @@ def validate_project_qa_commands(task_type: str, project_root: Path) -> None:
         raise PrepareError(_format_qa_errors(qa_errors))
 
 
+def _apply_tdd_bypass_if_requested(inp: "PrepareInputs", project_root: Path) -> None:
+    """`--tdd-bypass` 가 있으면 task-level TDD 우회 원장에 사유를 남긴다.
+
+    같은 task-key 의 다른 prepare 와 같은 파일을 read-modify-write 하므로
+    `_apply_qa_waiver_if_requested` 와 동일한 per-task-key 락 안에서 쓴다.
+    원장이 없으면 만든다 — 사용자가 빈 파일을 손으로 만들 이유가 없다.
+    """
+    if not inp.tdd_bypass:
+        return
+    from .paths import task_dir
+    from .tdd_bypass import (
+        TddBypassError,
+        bypass_file,
+        parse_bypass_arg,
+        record_bypass,
+    )
+    parsed = parse_bypass_arg(inp.tdd_bypass)
+    if parsed is None:
+        raise PrepareError(
+            '--tdd-bypass must be "<stage>:<reason>" with a positive stage '
+            f"number, got {inp.tdd_bypass!r}"
+        )
+    stage, reason = parsed
+    path = bypass_file(task_dir(project_root, inp.task_group, inp.task_id))
+    when = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    with worktree_provision_mutex(
+        okstra_home(), inp.project_id, slugify(inp.task_group), slugify(inp.task_id),
+    ):
+        try:
+            record_bypass(path, stage, reason, at=when)
+        except TddBypassError as exc:
+            raise PrepareError(f"--tdd-bypass: {exc}") from exc
+
+
 def _apply_qa_waiver_if_requested(inp: "PrepareInputs", project_root: Path) -> None:
     """`--qa-waiver` 가 있으면 task-level 매니페스트 entry 의 waiver 를 채운다.
 
@@ -2008,6 +2047,9 @@ def _register_and_check_project(project_root: Path, inp: PrepareInputs) -> None:
     # waiver 는 stage 단위 Tier 3 면제라 implementation 진입에서만 적용한다.
     if inp.task_type == "implementation":
         _apply_qa_waiver_if_requested(inp, project_root)
+    # TDD 우회는 계획서의 stage 를 면제하므로 계획 진입에서만 적용한다.
+    if inp.task_type == "implementation-planning":
+        _apply_tdd_bypass_if_requested(inp, project_root)
 
 
 def _resolve_roster(inp: PrepareInputs, profile_file: Path) -> tuple[list[str], str]:
@@ -3589,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,
@@ -3652,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
     )
@@ -5058,6 +5123,17 @@ def build_prepare_argument_parser():
     p.add_argument("--critic", default="")
     p.add_argument("--related-tasks", default="", dest="related_tasks_raw")
     p.add_argument("--approved-plan", default="", dest="approved_plan_path")
+    p.add_argument(
+        "--tdd-bypass",
+        default="",
+        dest="tdd_bypass",
+        help=(
+            'User-recorded TDD bypass for one plan stage: "<stage>:<reason>" '
+            "(implementation-planning only). Records the reason verbatim into "
+            "<task-root>/qa/tdd-bypass.json; S10e accepts a stage declaring "
+            "tddExemption `user-bypass` only while that record exists."
+        ),
+    )
     p.add_argument(
         "--qa-waiver",
         default="",
@@ -5323,6 +5399,7 @@ def main(argv: list[str]) -> int:
         base_ref=args.base_ref,
         approved_plan_path=args.approved_plan_path,
         qa_waiver=args.qa_waiver,
+        tdd_bypass=args.tdd_bypass,
         stage=args.stage,
         stages=args.stages,
         clarification_response_path=clarification_abs,

package/runtime/python/okstra_ctl/session_transcript.py

@@ -18,10 +18,10 @@ _RESET = "\x1b[0m"
 _MUTED = "\x1b[90m"
 _LIVE_COLORS = (
     ("→ ", "\x1b[36m"),
-    ("  ← ok", "\x1b[32m"),
-    ("  ← error", "\x1b[31m"),
+    ("← ok", "\x1b[32m"),
+    ("← error", "\x1b[31m"),
     ("!! PERMISSION DENIED", "\x1b[1;31m"),
-    ("  ← done", "\x1b[33m"),
+    ("← done", "\x1b[33m"),
 )
 
 # 파일 사본이 담는 워커 진행 줄의 상한. 진행은 워커 출력의 부피가 몰리는
@@ -99,7 +99,7 @@ class SessionTranscript:
             self._keep(self._row(speaker, line), capped=True)
 
     def _row(self, speaker: str, line: str) -> str:
-        label = f"[{speaker}] "
+        label = f"[{speaker}]"
         return f"{self._clock()} {label}{line}".rstrip()
 
     def _show(self, row: str, line: str) -> None:

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