okstra 0.96.1 → 0.97.1

package/runtime/python/okstra_ctl/improvement_lenses.py

@@ -34,6 +34,8 @@ def is_valid_lens(value: str) -> bool:
 def is_valid_lens_subset(values: list[str]) -> bool:
     if not (MIN_PRIORITY_LENSES <= len(values) <= MAX_PRIORITY_LENSES):
         return False
+    if len(set(values)) != len(values):
+        return False
     return all(v in LENSES for v in values)
 
 

package/runtime/python/okstra_ctl/index.py

@@ -6,49 +6,28 @@ import os
 from pathlib import Path
 
 from .ids import build_run_id
-from .invocation import invocation_path, save_invocation
+from .invocation import save_invocation
 from .jsonl import append_jsonl, read_jsonl, remove_jsonl_row, rotate_recent_if_needed
 from .project_meta import upsert_project_meta
+from .run_index_row import build_run_index_row, slim_run_row
 
 
-def _replace_or_append_active_row(home: Path, run_id: str, row: dict) -> None:
-    active = home / "active.jsonl"
-    rows = read_jsonl(active)
-    replaced = False
+def _replace_or_append_row(path: Path, run_id: str, row: dict) -> None:
+    """run_id 매칭 row 를 교체하고 없으면 append. 디스크에는 항상 slim 으로
+    기록한다 — 파생 4필드가 새지 않도록 모든 인덱스 쓰기가 거치는 단일 길목."""
+    slim = slim_run_row(row)
+    rows = read_jsonl(path)
     for i, r in enumerate(rows):
         if r.get("runId") == run_id:
-            rows[i] = row
-            replaced = True
-            break
-    if not replaced:
-        append_jsonl(active, row)
-        return
-    tmp = active.with_suffix(".jsonl.tmp")
-    with tmp.open("w") as f:
-        for r in rows:
-            f.write(json.dumps(r, separators=(",", ":")) + "\n")
-    os.replace(tmp, active)
-
-
-def _replace_or_append_project_row(home: Path, project_id: str,
-                                   run_id: str, row: dict) -> None:
-    proj_index = home / "projects" / project_id / "index.jsonl"
-    rows = read_jsonl(proj_index)
-    replaced = False
-    for i, r in enumerate(rows):
-        if r.get("runId") == run_id:
-            rows[i] = row
-            replaced = True
-            break
-    if not replaced:
-        append_jsonl(proj_index, row)
-        return
-    proj_index.parent.mkdir(parents=True, exist_ok=True)
-    tmp = proj_index.with_suffix(".jsonl.tmp")
-    with tmp.open("w") as f:
-        for r in rows:
-            f.write(json.dumps(r, separators=(",", ":")) + "\n")
-    os.replace(tmp, proj_index)
+            rows[i] = slim
+            path.parent.mkdir(parents=True, exist_ok=True)
+            tmp = path.with_suffix(path.suffix + ".tmp")
+            with tmp.open("w") as f:
+                for rr in rows:
+                    f.write(json.dumps(rr, separators=(",", ":")) + "\n")
+            os.replace(tmp, path)
+            return
+    append_jsonl(path, slim)
 
 
 def record_start(home: Path, *, project_id: str, project_root: str,
@@ -65,36 +44,17 @@ def record_start(home: Path, *, project_id: str, project_root: str,
     반환값: 생성된 runId.
     """
     run_id = build_run_id(project_id, task_group, task_id, task_type, run_seq)
-    inv_path_abs = invocation_path(home, project_id, task_group, task_id,
-                                   task_type, run_seq)
-    inv_path_rel = inv_path_abs.relative_to(home)
     # 종결 상태(prepared/aborted/etc) 로 시작하는 경우 finishedAt 도 같이 채워
     # 인덱스 위치를 active 가 아닌 recent 로 라우팅한다.
     is_terminal = initial_status != "running"
-    row = {
-        "runId": run_id,
-        "projectId": project_id,
-        "projectRoot": project_root,
-        "taskGroup": task_group,
-        "taskId": task_id,
-        "taskKey": f"{task_group}/{task_id}",
-        "taskType": task_type,
-        "runSeq": run_seq,
-        "status": initial_status,
-        "startedAt": when,
-        "finishedAt": when if is_terminal else None,
-        "workers": workers,
-        "leadModel": lead_model,
-        "validation": "not-run",
-        "finalReportRel": final_report_rel,
-        # FINAL_STATUS_PATH 의 카운터(RUN_STATUS_SEQ) 는 RUN_MANIFESTS_SEQ
-        # 와 별개로 advance 한다(render-only/실패 prep 은 manifest 만 증가).
-        # 따라서 status 파일을 추적할 때는 manifest seq 를 추정해 glob 으로
-        # 찾지 말고 run 시작 시점의 정식 경로를 row 에 박아 두고 사용한다.
-        "finalStatusRel": final_status_rel,
-        "runDirRel": run_dir_rel,
-        "invocationFile": str(inv_path_rel),
-    }
+    row = build_run_index_row(
+        project_id=project_id, project_root=project_root,
+        task_group=task_group, task_id=task_id, task_type=task_type,
+        run_seq=run_seq, status=initial_status, started_at=when,
+        finished_at=when if is_terminal else None,
+        workers=workers, lead_model=lead_model, validation="not-run",
+        run_dir_rel=run_dir_rel, final_report_rel=final_report_rel,
+        final_status_rel=final_status_rel)
     # okstra-ctl 가 미리 'reserving' 예약 row 를 작성했을 수 있다(P1-2). 같은
     # runId 의 예약 row 가 있으면 update; 없으면 append.
     existing_rows = read_jsonl(home / "active.jsonl")
@@ -118,9 +78,10 @@ def record_start(home: Path, *, project_id: str, project_root: str,
         # 넘어도 archive 로 이동되지 않는다.
         rotate_recent_if_needed(home)
     else:
-        _replace_or_append_active_row(home, run_id, row)
+        _replace_or_append_row(home / "active.jsonl", run_id, row)
         had_recent = False
-    _replace_or_append_project_row(home, project_id, run_id, row)
+    _replace_or_append_row(
+        home / "projects" / project_id / "index.jsonl", run_id, row)
     save_invocation(home, project_id, task_group, task_id, task_type, run_seq, {
         "runId": run_id,
         "okstraVersion": okstra_version or os.environ.get("OKSTRA_SCRIPT_VERSION", ""),
@@ -156,31 +117,13 @@ def reserve_run_in_active(home: Path, *,
     record_start 가 나중에 같은 (project, group, task, task_type, seq) 를 만나면
     이 row 를 update 한다.
     """
-    run_id = build_run_id(project_id, task_group, task_id, task_type, run_seq)
-    inv_rel = invocation_path(home, project_id, task_group, task_id,
-                              task_type, run_seq).relative_to(home)
-    row = {
-        "runId": run_id,
-        "projectId": project_id,
-        "projectRoot": project_root,
-        "taskGroup": task_group,
-        "taskId": task_id,
-        "taskKey": f"{task_group}/{task_id}",
-        "taskType": task_type,
-        "runSeq": run_seq,
-        "status": "reserving",
-        "startedAt": when,
-        "finishedAt": None,
-        "workers": [],
-        "leadModel": "",
-        "validation": "not-run",
-        "finalReportRel": final_report_rel,
-        # 예약 시점 best-effort: 정상 run 은 RUN_STATUS_SEQ == RUN_MANIFESTS_SEQ
-        # 라 일치한다. record_start 가 실제 경로로 update 한다.
-        "finalStatusRel": final_status_rel,
-        "runDirRel": run_dir_rel,
-        "invocationFile": str(inv_rel),
-    }
+    row = build_run_index_row(
+        project_id=project_id, project_root=project_root,
+        task_group=task_group, task_id=task_id, task_type=task_type,
+        run_seq=run_seq, status="reserving", started_at=when,
+        finished_at=None, workers=[], lead_model="", validation="not-run",
+        run_dir_rel=run_dir_rel, final_report_rel=final_report_rel,
+        final_status_rel=final_status_rel)
     append_jsonl(home / "active.jsonl", row)
     # project index 도 미리 한 줄 — record_start 가 나중에 update 하므로 동일 row 형태로.
     append_jsonl(home / "projects" / project_id / "index.jsonl", row)

package/runtime/python/okstra_ctl/jsonl.py

@@ -21,14 +21,15 @@ def read_jsonl(path: Path) -> List[dict]:
     if not path.is_file():
         return []
     rows: List[dict] = []
-    for line in path.open():
-        line = line.strip()
-        if not line:
-            continue
-        try:
-            rows.append(json.loads(line))
-        except json.JSONDecodeError:
-            continue
+    with path.open() as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                rows.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
     return rows
 
 
@@ -66,19 +67,29 @@ def rotate_recent_if_needed(home: Path, max_rows: int = 2000,
     recent = home / "recent.jsonl"
     if not recent.is_file():
         return None
-    rows = list(recent.open())
+    with recent.open() as f:
+        rows = list(f)
     size_ok = recent.stat().st_size < max_bytes
     rows_ok = len(rows) < max_rows
     if size_ok and rows_ok:
         return None
-    # archive 키는 첫 행의 finishedAt 월. 없으면 현재 월.
-    first_row = json.loads(rows[0]) if rows else {}
-    finished = first_row.get("finishedAt") or datetime.now(timezone.utc).replace(tzinfo=None).strftime("%Y-%m-%dT%H:%M:%SZ")
-    yyyy, yyyymm = finished[:4], finished[:7]
-    archive = home / "archive" / yyyy / f"{yyyymm}.jsonl"
-    archive.parent.mkdir(parents=True, exist_ok=True)
-    with archive.open("a") as out:
-        for line in rows:
+    last_archive: Optional[Path] = None
+    for line in rows:
+        archive = _archive_path_for_line(home, line)
+        archive.parent.mkdir(parents=True, exist_ok=True)
+        with archive.open("a") as out:
             out.write(line)
+        last_archive = archive
     recent.write_text("")
-    return archive
+    return last_archive
+
+
+def _archive_path_for_line(home: Path, line: str) -> Path:
+    """행의 finishedAt 월(YYYY-MM)로 archive/YYYY/YYYY-MM.jsonl 경로 결정. 없으면 현재 월."""
+    try:
+        finished = json.loads(line).get("finishedAt")
+    except json.JSONDecodeError:
+        finished = None
+    finished = finished or datetime.now(timezone.utc).replace(
+        tzinfo=None).strftime("%Y-%m-%dT%H:%M:%SZ")
+    return home / "archive" / finished[:4] / f"{finished[:7]}.jsonl"

package/runtime/python/okstra_ctl/listing.py

@@ -7,8 +7,8 @@ from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import List, Optional
 
-from .jsonl import read_jsonl
 from .reconcile import _parse_iso
+from .run_index_row import read_run_index
 
 
 def list_projects(home: Path, *, only_active: bool = False,
@@ -22,7 +22,12 @@ def list_projects(home: Path, *, only_active: bool = False,
         meta_file = child / "meta.json"
         if not meta_file.is_file():
             continue
-        meta = json.loads(meta_file.read_text())
+        try:
+            meta = json.loads(meta_file.read_text())
+        except (OSError, json.JSONDecodeError):
+            # 동시 쓰기/이전 크래시로 깨진 meta.json 하나가 전체 listing 을
+            # 죽이지 않도록 해당 프로젝트만 건너뛴다(다른 JSON 리더와 동일 정책).
+            continue
         # projectRoot 가 누락/빈 문자열이면 Path("").is_dir() 이 cwd 를 가리켜
         # True 가 되므로(missing 으로 잡히지 않음), 빈 값은 명시적으로 missing
         # 처리한다.
@@ -77,16 +82,36 @@ def _parse_since(value: str) -> Optional[datetime]:
         ) from exc
 
 
+def _parse_started_at(ts: str) -> Optional[datetime]:
+    """--since 비교용 startedAt 파싱. 기준값은 naive UTC 이므로 결과도 naive UTC.
+
+    _parse_iso 는 `...Z` 형식만 받지만 backfill 이 manifest createdAt 을 그대로
+    startedAt 으로 옮기면 offset 형식(`+00:00`)이 섞일 수 있다. 그 경우 None 으로
+    빠지면 --since 필터가 fail-open 으로 모든 row 를 통과시키므로, fromisoformat
+    fallback 으로 offset 형식도 받아 naive UTC 로 정규화한다.
+    """
+    parsed = _parse_iso(ts)
+    if parsed is not None:
+        return parsed
+    try:
+        dt = datetime.fromisoformat(ts)
+    except (ValueError, TypeError):
+        return None
+    if dt.tzinfo is not None:
+        dt = dt.astimezone(timezone.utc).replace(tzinfo=None)
+    return dt
+
+
 def list_runs(home: Path, *, project: str = "all", task_group: str = "all",
               status: str = "all", since: str = "", limit: int = 0,
               include_archive: bool = False) -> List[dict]:
     """active + recent (옵션 archive) 를 합쳐 필터/정렬 후 반환."""
-    rows = read_jsonl(home / "active.jsonl") + read_jsonl(home / "recent.jsonl")
+    rows = read_run_index(home / "active.jsonl") + read_run_index(home / "recent.jsonl")
     if include_archive:
         archive_dir = home / "archive"
         if archive_dir.is_dir():
             for f in sorted(archive_dir.glob("*/*.jsonl")):
-                rows.extend(read_jsonl(f))
+                rows.extend(read_run_index(f))
     threshold = _parse_since(since)
     out: List[dict] = []
     for r in rows:
@@ -97,7 +122,7 @@ def list_runs(home: Path, *, project: str = "all", task_group: str = "all",
         if status != "all" and r.get("status") != status:
             continue
         if threshold:
-            started = _parse_iso(r.get("startedAt", ""))
+            started = _parse_started_at(r.get("startedAt", ""))
             if started and started < threshold:
                 continue
         out.append(r)

package/runtime/python/okstra_ctl/md_table.py

@@ -15,7 +15,7 @@ from typing import Any
 # A `|` not preceded by a backslash: a real column boundary.
 UNESCAPED_PIPE_RE = re.compile(r"(?<!\\)\|")
 
-_SEPARATOR_CELL_RE = re.compile(r"\s*:?-{2,}:?\s*")
+_SEPARATOR_CELL_RE = re.compile(r"\s*:?-+:?\s*")
 
 
 def escape_pipes(value: Any) -> str:

package/runtime/python/okstra_ctl/migrate.py

@@ -127,7 +127,11 @@ def prepare_migration_plan(
             text = gitignore.read_text(encoding="utf-8")
         except OSError:
             text = ""
-        if LEGACY_OKSTRA_DIR_NAME in text or f"{LEGACY_OKSTRA_DIR_NAME}/" in text:
+        # Detect using the same line predicate apply uses, so a previewed
+        # gitignore_path always corresponds to an actual rewrite. A bare
+        # substring match would flag comments or longer paths
+        # (`.project-docs/okstra-archive/`) that _update_gitignore never touches.
+        if any(_is_legacy_gitignore_line(line) for line in text.splitlines()):
             gitignore_path = gitignore
 
     registry_updates = _scan_registries(
@@ -238,19 +242,25 @@ def _maybe_remove_empty_parent(plan: MigrationPlan) -> bool:
     return False
 
 
+def _is_legacy_gitignore_line(line: str) -> bool:
+    """A gitignore line that names exactly the legacy okstra entry.
+
+    Comment lines and longer paths (`.project-docs/okstra-archive/`) that merely
+    contain the legacy prefix are intentionally excluded — they are not the
+    ignore rule the migration rewrites.
+    """
+    stripped = line.strip()
+    return stripped == LEGACY_OKSTRA_DIR_NAME or stripped == f"{LEGACY_OKSTRA_DIR_NAME}/"
+
+
 def _update_gitignore(plan: MigrationPlan) -> bool:
     if plan.gitignore_path is None:
         return False
     text = plan.gitignore_path.read_text(encoding="utf-8")
-    # Match both forms: with and without trailing slash. Use word-boundary-ish
-    # replacement by anchoring on the legacy prefix; downstream comment lines
-    # that mention the old path in narrative are left alone because they
-    # never start at line-start with the bare path.
     new_lines = []
     changed = False
     for line in text.splitlines(keepends=True):
-        stripped = line.strip()
-        if stripped == LEGACY_OKSTRA_DIR_NAME or stripped == f"{LEGACY_OKSTRA_DIR_NAME}/":
+        if _is_legacy_gitignore_line(line):
             indent = line[: len(line) - len(line.lstrip())]
             new_lines.append(f"{indent}{OKSTRA_DIR_NAME}/\n")
             changed = True

package/runtime/python/okstra_ctl/paths.py

@@ -60,7 +60,7 @@ def next_run_seq(run_seq_dir: Path, task_type_segment: str) -> int:
     """run_seq_dir 안에서 `*-<task-type>-NNN.<ext>` 파일을 스캔해 다음 seq 번호를
     돌려준다. 디렉터리 부재 시 1.
     """
-    pattern = re.compile(rf"-{re.escape(task_type_segment)}-(\d{{3}})\.[^.]+$")
+    pattern = re.compile(rf"-{re.escape(task_type_segment)}-(\d{{3,}})\.[^.]+$")
     max_seq = 0
     if run_seq_dir.is_dir():
         for entry in os.listdir(run_seq_dir):

package/runtime/python/okstra_ctl/recap.py

@@ -10,6 +10,7 @@ import json
 import sys
 from pathlib import Path
 
+from okstra_ctl.run_context import dir_flock
 from okstra_ctl.task_target import resolve_task_root, project_rel
 
 
@@ -55,7 +56,10 @@ def assemble_recap(task_root: Path, project_root: Path) -> dict:
             "reportPath": run.get("reportPath", ""),
         })
         prev_phase = cur
-        latest_states = snap.get("phaseStates", {}) or latest_states
+        # latestPhaseStates 는 항상 가장 최근 run 의 상태를 반영해야 한다.
+        # 빈/누락 snapshot 일 때 이전 run 값으로 폴백하면 오래된 phase map 을
+        # 최신 상태인 양 보고하게 된다.
+        latest_states = snap.get("phaseStates", {}) or {}
     return {
         "taskKey": _task_key(task_root),
         "runCount": len(runs),
@@ -77,8 +81,13 @@ def append_recap_entry(task_root, project_root, *, kind, mode, question,
         "answerSummary": answer_summary,
         "citations": list(citations),
     }
-    with log_path.open("a", encoding="utf-8") as fh:
-        fh.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    # 같은 task 에 대한 동시 record 호출이 한 JSONL 줄을 쪼개지 않도록
+    # open+write+close(flush) 전체를 dir_flock 으로 직렬화한다 (consumers.jsonl
+    # 과 같은 append-only idiom — 데이터 fd 가 아닌 별도 .lock 파일을 잠가야
+    # flush 가 락 안에서 끝난다).
+    with dir_flock(recap_dir, ".recap-log.lock"):
+        with log_path.open("a", encoding="utf-8") as fh:
+            fh.write(json.dumps(entry, ensure_ascii=False) + "\n")
     return {"logPath": project_rel(log_path, project_root), "entry": entry}
 
 

package/runtime/python/okstra_ctl/reconcile.py

@@ -7,9 +7,10 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
 
-from .jsonl import append_jsonl, read_jsonl, rotate_recent_if_needed
+from .jsonl import append_jsonl, rotate_recent_if_needed
 from .locks import central_lock
 from .project_meta import upsert_project_meta
+from .run_index_row import read_run_index, slim_run_row
 
 
 DEFAULT_ABORT_AFTER_SECONDS = 12 * 3600  # 12시간 무진척이면 aborted 로 간주
@@ -86,7 +87,7 @@ def _sync_project_index(home: Path, project_id: str, updated_rows: list) -> None
     if not proj_index.is_file():
         return
     by_id = {r["runId"]: r for r in updated_rows}
-    existing = read_jsonl(proj_index)
+    existing = read_run_index(proj_index)
     for er in existing:
         src = by_id.get(er.get("runId"))
         if src:
@@ -94,7 +95,7 @@ def _sync_project_index(home: Path, project_id: str, updated_rows: list) -> None
     tmp = proj_index.with_suffix(".jsonl.tmp")
     with tmp.open("w") as f:
         for er in existing:
-            f.write(json.dumps(er, separators=(",", ":")) + "\n")
+            f.write(json.dumps(slim_run_row(er), separators=(",", ":")) + "\n")
     os.replace(tmp, proj_index)
 
 
@@ -118,17 +119,18 @@ def _reconcile_active_locked(home: Path, *,
                              project: Optional[str] = None) -> dict:
     active = home / "active.jsonl"
     summary = {"completed": 0, "failed": 0, "aborted": 0, "running": 0}
-    rows = read_jsonl(active)
+    rows = read_run_index(active)
     if not rows:
         return summary
     survivors = []
     promoted = []
     now = datetime.now(timezone.utc).replace(tzinfo=None)
     for row in rows:
-        # project 필터: 스코프 외 행은 추론 없이 active 에 그대로 남긴다.
+        # project 필터: 스코프 외 행은 추론하지 않고 active 에 그대로 남긴다.
+        # 상태를 추론하지 않았으므로 running 으로 집계하지 않는다 — summary 는
+        # 이번 패스가 실제로 추론/이동한 행만 반영한다.
         if project and row.get("projectId") != project:
             survivors.append(row)
-            summary["running"] += 1
             continue
         project_root = Path(row.get("projectRoot", ""))
         final_rel = row.get("finalReportRel", "")
@@ -136,7 +138,7 @@ def _reconcile_active_locked(home: Path, *,
         if final_abs and final_abs.is_file():
             validation_status = _read_run_manifest_validation(
                 project_root, row.get("runDirRel", ""),
-                row.get("taskType", ""), int(row.get("runSeq", 0)))
+                row.get("taskType", ""), int(row.get("runSeq", 0) or 0))
             # validate-okstra-run.py 가 아직 실행되지 않은 시점에는 final-report
             # 만 존재하고 validation 은 'not-run' 으로 보고된다. 이때 promote 하면
             # normalize_reconciled_report_status 가 'completed' 로 매핑하여 행이
@@ -168,10 +170,10 @@ def _reconcile_active_locked(home: Path, *,
     tmp = active.with_suffix(".jsonl.tmp")
     with tmp.open("w") as f:
         for row in survivors:
-            f.write(json.dumps(row, separators=(",", ":")) + "\n")
+            f.write(json.dumps(slim_run_row(row), separators=(",", ":")) + "\n")
     os.replace(tmp, active)
     for row in promoted:
-        append_jsonl(home / "recent.jsonl", row)
+        append_jsonl(home / "recent.jsonl", slim_run_row(row))
         _sync_project_index(home, row["projectId"], [row])
         upsert_project_meta(home, row["projectId"],
                             project_root=row["projectRoot"],
@@ -195,7 +197,7 @@ def reconcile_recent(home: Path, *, project: Optional[str] = None) -> dict:
 def _reconcile_recent_locked(home: Path, *, project: Optional[str] = None) -> dict:
     recent = home / "recent.jsonl"
     summary = {"completed": 0, "failed": 0, "unchanged": 0}
-    rows = read_jsonl(recent)
+    rows = read_run_index(recent)
     updated_by_project: dict = {}
     for row in rows:
         if (project and row.get("projectId") != project) or \
@@ -222,7 +224,7 @@ def _reconcile_recent_locked(home: Path, *, project: Optional[str] = None) -> di
     tmp = recent.with_suffix(".jsonl.tmp")
     with tmp.open("w") as f:
         for row in rows:
-            f.write(json.dumps(row, separators=(",", ":")) + "\n")
+            f.write(json.dumps(slim_run_row(row), separators=(",", ":")) + "\n")
     os.replace(tmp, recent)
     for pid, urows in updated_by_project.items():
         _sync_project_index(home, pid, urows)

package/runtime/python/okstra_ctl/render.py

@@ -720,6 +720,39 @@ def render_latest_task_discovery(output_path: str, ctx: dict) -> None:
 # --------------------------------------------------------------------------- #
 
 
+_PATH_BOUNDARY_CHARS = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789._-/")
+
+
+def _rewrite_path_refs(text: str, path_rewrites: dict) -> str:
+    """저장된 경로 문자열을 새 경로로 교체하되, 경계를 검사해 더 긴 무관한
+    경로 안에 부분 문자열로 끼어든 경우는 건드리지 않는다.
+
+    `old_rel` 앞뒤가 경로를 잇는 문자(영숫자/`.`/`-`/`_`/`/`)면 그 위치는
+    다른 경로의 일부이므로 교체 대상에서 제외한다."""
+    for old_rel, new_rel in path_rewrites.items():
+        if not old_rel:
+            continue
+        out: list[str] = []
+        idx = 0
+        while True:
+            hit = text.find(old_rel, idx)
+            if hit == -1:
+                out.append(text[idx:])
+                break
+            before = text[hit - 1] if hit > 0 else ""
+            after_pos = hit + len(old_rel)
+            after = text[after_pos] if after_pos < len(text) else ""
+            on_boundary = (
+                before not in _PATH_BOUNDARY_CHARS
+                and after not in _PATH_BOUNDARY_CHARS
+            )
+            out.append(text[idx:hit])
+            out.append(new_rel if on_boundary else old_rel)
+            idx = after_pos
+        text = "".join(out)
+    return text
+
+
 def migrate_legacy_run_artifacts(ctx: dict) -> None:
     import shutil
 
@@ -768,9 +801,7 @@ def migrate_legacy_run_artifacts(ctx: dict) -> None:
             original = path.read_text(encoding="utf-8")
         except Exception:
             continue
-        updated = original
-        for old_rel, new_rel in path_rewrites.items():
-            updated = updated.replace(old_rel, new_rel)
+        updated = _rewrite_path_refs(original, path_rewrites)
         if updated != original:
             path.write_text(updated, encoding="utf-8")
 
@@ -2063,6 +2094,9 @@ def apply_lead_prompt_defaults(ctx: dict) -> None:
     # Empty for non-final-verification runs; the final-verification prepare
     # path overwrites it with the resolved verification target block.
     ctx.setdefault("VERIFICATION_TARGET", "")
+    # Empty except for whole-task final-verification, where the prepare path
+    # overwrites it with the stage auto-integration summary.
+    ctx.setdefault("STAGE_INTEGRATION", "")
     runtime_home = okstra_home()
     ctx.setdefault(
         "WORKER_PROMPT_PREAMBLE_PATH",
@@ -2115,18 +2149,21 @@ def render_template_with_ctx(template_path: str, output_path: str, ctx: dict) ->
         key = tok_with_braces[2:-2]   # "{{X}}" -> "X"
         lookup[key] = value
 
-    rendered = template
     missing: list[str] = []
-    for match in _TOKEN_RE.finditer(template):
+
+    def _resolve(match: "re.Match[str]") -> str:
         token = match.group(1)
         if token in lookup:
-            value = lookup[token]
-        elif token in ctx:
-            value = str(ctx[token])
-        else:
-            missing.append(token)
-            continue
-        rendered = rendered.replace("{{" + token + "}}", value)
+            return lookup[token]
+        if token in ctx:
+            return str(ctx[token])
+        missing.append(token)
+        return match.group(0)
+
+    # 단일 패스 치환: 토큰을 _TOKEN_RE 매칭으로 한 번만 훑어 치환값으로 바꾼다.
+    # 치환값 안에 `{{TOKEN}}`/`{% if %}` 같은 마커가 들어 있어도 이미 소비된
+    # 구간이라 재치환되지 않는다 (데이터를 통한 토큰/마커 주입 방지).
+    rendered = _TOKEN_RE.sub(_resolve, template)
 
     if missing:
         names = ", ".join(sorted(set(missing)))

package/runtime/python/okstra_ctl/render_final_report.py

@@ -89,6 +89,10 @@ def _format_duration_ms(value: Any) -> str:
         ms = int(value)
     except (TypeError, ValueError):
         return "--"
+    # A negative elapsed time is nonsensical (clock skew between start/end
+    # timestamps); divmod would otherwise produce a malformed "-1m 59s".
+    if ms < 0:
+        return "--"
     total_seconds = ms // 1000
     hours, remainder = divmod(total_seconds, 3600)
     minutes, seconds = divmod(remainder, 60)