okstra 0.198.1 → 0.199.0

package/runtime/python/okstra_ctl/analysis_packet.py

@@ -106,6 +106,7 @@ def build_analysis_packet(
     stage_ledger_json: str = "",
     stage_ledger_notice: str = "",
     prior_planning_summary: str = "",
+    direct_work_text: str = "",
 ) -> str:
     """Return the primary compact input for Claude/Codex/Antigravity analysers.
 
@@ -146,7 +147,13 @@ def build_analysis_packet(
     )
     parts.extend(_group_context_block(group_human))
     parts.extend(_brief_block(brief_text))
-    parts.extend(_group_memory_block(group_memory, _own_task_segment(task_key)))
+    if direct_work_text:
+        parts.extend(["", direct_work_text, ""])
+    parts.extend(_group_memory_block(
+        group_memory, _own_task_segment(task_key),
+        "\n".join((brief_text, group_human, clarification_text, directive,
+                   fix_history_text, prior_planning_summary, stage_ledger_json)),
+    ))
     parts.extend(_profile_block(task_type, profile_text))
     parts.extend(_reference_block(reference_text))
     parts.extend(_fix_history_block(fix_history_text))
@@ -166,6 +173,47 @@ _FENCE_RE = re.compile(r"\A\s*(```|~~~)")
 _INDEX_PREAMBLE_LINES = 5
 
 
+def reference_source_extracts(
+    packet_text: str, task_type: str, *, brief_text: str, profile_text: str,
+    reference_text: str, clarification_text: str,
+) -> str:
+    """합성 입력 안에 원문이 함께 있을 때 일치하는 발췌만 참조로 바꾼다."""
+    lines = packet_text.splitlines()
+    headings = _heading_lines(lines)
+    if headings and headings[0][1] == "## Section Index":
+        start = headings[0][0] - 2
+        end = start + _INDEX_PREAMBLE_LINES + len(headings) - 1
+        unindexed = "\n".join(lines[:start] + lines[end:]) + "\n"
+        # 생성기가 만든 목차임을 재구성으로 확인한다. 수정된 목차가 있으면
+        # 원문 전체를 유지해 내용 손실이나 잘못된 줄번호를 만들지 않는다.
+        if _with_section_index(unindexed) != packet_text:
+            return packet_text
+        lines = unindexed.splitlines()
+    blocks = (
+        ("Task brief", brief_text, _brief_block(brief_text)),
+        ("Analysis profile", profile_text, _profile_block(task_type, profile_text)),
+        ("Reference expectations", reference_text, _reference_block(reference_text)),
+        ("Clarification response", clarification_text, _clarification_block(clarification_text)),
+    )
+    changed = False
+    for label, source_text, parts in blocks:
+        expected = "\n".join(part.rstrip() for part in parts).strip()
+        if not source_text.strip() or not expected:
+            continue
+        heading = expected.splitlines()[0]
+        reference = f'{heading}\n\nRead the same extract in "Source: {label}" below.'
+        if len(reference) >= len(expected):
+            continue
+        for number, text in _heading_lines(lines):
+            start = number - 1
+            end = start + len(expected.splitlines())
+            if text == heading and "\n".join(lines[start:end]) == expected:
+                lines[start:end] = reference.splitlines()
+                changed = True
+                break
+    return "\n".join(lines).rstrip() + "\n" if changed else packet_text
+
+
 def _with_section_index(body: str) -> str:
     """Prefix the rendered packet with every section's line range.
 
@@ -310,7 +358,13 @@ GROUP_MEMORY_PREFACE = (
     "`record`. This section is not this task's requirement ledger, and a sibling's "
     "decision does not bind this run: where a sibling's conclusion conflicts with "
     "the `## Task-Specific Brief Extract`, raise a `Clarification Items` row rather "
-    "than re-deriving what the sibling already settled or silently overriding it."
+    "than re-deriving what the sibling already settled or silently overriding it. "
+    "Every sibling has a headline and record pointer below. Full details are "
+    "included for explicit task references and their referenced siblings, and "
+    "for entries with watch-outs or no record pointer. For an index-only entry, "
+    "read its section in the Task-group context source or its record when its "
+    "headline may affect this task or the relationship is unclear. Omitted "
+    "details do not mean the sibling has no decisions or follow-ups."
 )
 
 
@@ -332,22 +386,51 @@ def _own_task_segment(task_key: str) -> str:
     return group_context.slugify_task_segment(re.split(r"[:/]", task_key)[-1])
 
 
-def _group_memory_block(region: str, own_task_segment: str) -> list[str]:
-    """형제 task 의 항목만 싣는다. 자기 항목은 timeline·prior-planning 이 이미 나른다."""
+_TASK_REFERENCE_RE = re.compile(r"[a-z0-9](?:[a-z0-9_.-]*[a-z0-9])?", re.IGNORECASE)
+
+
+def _group_memory_block(
+    region: str, own_task_segment: str, reference_text: str,
+) -> list[str]:
+    """형제 전체의 색인을 유지하며 참조 연결과 주의사항이 있는 항목을 펼친다."""
     entries = [
         entry for entry in group_context.parse_memory_entries(region)
         if entry.task_id != own_task_segment
     ]
     if not entries:
         return []
-    return [
-        "",
-        "## Task-Group Memory",
-        "",
-        GROUP_MEMORY_PREFACE,
-        "",
-        group_context.render_memory_entries(entries).strip(),
-    ]
+    tokens = set(_TASK_REFERENCE_RE.findall(reference_text.casefold()))
+    own_ids = {own_task_segment, group_context.ticket_id_from_brief_id(own_task_segment)}
+    rendered = [group_context.render_memory_entries([entry]).strip() for entry in entries]
+    entry_tokens = [set(_TASK_REFERENCE_RE.findall(text.casefold())) for text in rendered]
+    selected: set[int] = set()
+    while True:
+        previous_count = len(selected)
+        for index, entry in enumerate(entries):
+            aliases = {entry.task_id.casefold(), group_context.ticket_id_from_brief_id(entry.task_id).casefold()}
+            if index in selected:
+                continue
+            if (aliases & tokens or own_ids & entry_tokens[index]
+                    or entry.watch_out or not entry.record):
+                selected.add(index)
+                tokens.update(entry_tokens[index])
+        if len(selected) == previous_count:
+            break
+    lines = ["", "## Task-Group Memory", "", GROUP_MEMORY_PREFACE, ""]
+    for index, entry in enumerate(entries):
+        if index in selected:
+            lines.extend([rendered[index], ""])
+        else:
+            lines.extend([
+                f"### {entry.task_id}",
+                f"- headline: {entry.headline or '_(none)_'}",
+                f"- record: `{entry.record}`",
+                "- Detail: index-only; read the source if relevant or uncertain.",
+                "",
+            ])
+            if entry.source == "direct":
+                lines.extend(["- Source: direct work; no cross-verification performed for this record.", ""])
+    return lines
 
 
 def _brief_block(brief_text: str) -> list[str]:

package/runtime/python/okstra_ctl/context_cost.py

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

package/runtime/python/okstra_ctl/direct_work.py

@@ -0,0 +1,109 @@
+"""실행 없이 등록한 작업의 결과를 기존 작업·그룹 조회 경로에 연결한다."""
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import date
+from pathlib import Path
+
+from okstra_project import project_json_path, tasks_root
+from okstra_project.dirs import TASK_CATALOG_RELATIVE
+
+from . import group_context
+from .brief_frontmatter import read_brief_frontmatter
+from .ids import slugify_task_segment
+from .json_boundary import load_owned_object, write_owned_object_atomic
+from .paths import task_dir, task_manifest_file
+from .render import render_task_catalog_discovery
+from .run_context import dir_flock
+
+
+def find_brief_tasks(project_root: Path, token: str, task_group: str) -> list[dict]:
+    project = load_owned_object(project_json_path(project_root), artifact="project config")
+    project_id = project.get("projectId", "")
+    if not project_id:
+        raise ValueError("project.json has no projectId")
+    matches = []
+    for folder in sorted(group_context.briefs_root(project_root).glob("*")):
+        if not folder.is_dir() or (task_group and folder.name != slugify_task_segment(task_group)):
+            continue
+        for brief in group_context.group_briefs(project_root, folder.name):
+            identities = (brief["brief_id"], brief["ticket_id"], folder.name)
+            if token.casefold() not in {str(value).casefold() for value in identities}:
+                continue
+            path = project_root / brief["brief"]
+            frontmatter = read_brief_frontmatter(path)
+            group = frontmatter.get("task-group") or folder.name
+            if slugify_task_segment(group) != folder.name:
+                raise ValueError(f"Brief task-group does not match its directory: {brief['brief']}")
+            task_id = slugify_task_segment(brief["brief_id"])
+            root = task_dir(project_root, slugify_task_segment(group), task_id)
+            matches.append({
+                "_briefVerified": True,
+                "schemaVersion": "1.0", "projectId": project_id,
+                "projectRoot": str(project_root), "taskGroup": group, "taskId": task_id,
+                "taskKey": f"{project_id}:{group}:{task_id}",
+                "taskGroupPathSegment": slugify_task_segment(group),
+                "taskIdPathSegment": task_id, "taskBriefPath": brief["brief"],
+                "taskRootPath": root.relative_to(project_root).as_posix(),
+                "taskManifestPath": task_manifest_file(root).relative_to(project_root).as_posix(),
+            })
+    return matches
+
+
+def record_direct_work(project_root: Path, manifest_path: Path, manifest: dict) -> None:
+    """상태와 본문이 같은 재시도는 기존 결과를 재사용한다. 정본 포인터는 호출자가 쓴다."""
+    summary = str(manifest.get("workStatusNote") or "").strip()
+    if not summary:
+        raise ValueError("Direct completion requires --note or --note-file with the work and verification summary")
+    previous_path = manifest.get("latestWorkRecordPath", "")
+    if previous_path:
+        (project_root / previous_path).resolve().relative_to(manifest_path.parent.resolve())
+    previous = (
+        load_owned_object(project_root / previous_path, artifact="direct work record")
+        if previous_path else {}
+    )
+    if previous.get("summary") == summary and previous.get("statusUpdatedAt") == manifest["workStatusUpdatedAt"]:
+        return
+    record = {
+        "schemaVersion": "1.0", "taskKey": manifest["taskKey"], "source": "direct",
+        "summary": summary, "crossVerification": "not-performed",
+        "statusUpdatedAt": manifest["workStatusUpdatedAt"],
+        "previousRecordPath": previous_path,
+    }
+    identity = {key: value for key, value in record.items() if key != "statusUpdatedAt"}
+    digest = hashlib.sha256(json.dumps(identity, sort_keys=True).encode()).hexdigest()
+    path = manifest_path.parent / "work-records" / f"{digest}.json"
+    if path.exists():
+        saved = load_owned_object(path, artifact="direct work record")
+        manifest["workStatusUpdatedAt"] = saved["statusUpdatedAt"]
+        manifest["updatedAt"] = saved["statusUpdatedAt"]
+    else:
+        write_owned_object_atomic(path, record, artifact="direct work record")
+    manifest["latestWorkRecordPath"] = path.relative_to(project_root).as_posix()
+
+
+def publish_direct_work(project_root: Path, manifest: dict) -> Path | None:
+    """상태 저장 뒤 재실행해도 같은 그룹 항목을 갱신한다."""
+    catalog = project_root / TASK_CATALOG_RELATIVE
+    with dir_flock(catalog.parent, ".task-catalog.lock"):
+        render_task_catalog_discovery(str(catalog), {
+            "PROJECT_ROOT": str(project_root), "OKSTRA_TASKS_ROOT": str(tasks_root(project_root)),
+            "PROJECT_ID": manifest["projectId"], "TASK_KEY": manifest["taskKey"],
+            "RUN_TIMESTAMP_ISO": manifest["workStatusUpdatedAt"],
+        })
+    if not manifest.get("latestWorkRecordPath") or manifest["workStatus"] != "done":
+        return group_context.refresh_group_queue(project_root, manifest["taskGroup"])
+    record = load_owned_object(
+        project_root / manifest["latestWorkRecordPath"], artifact="direct work record"
+    )
+    entry = group_context.MemoryEntry(
+        task_id=manifest["taskId"], task_type="", seq="", next_phase="",
+        date=record["statusUpdatedAt"][:10], headline=" ".join(record["summary"].split())[:group_context.HEADLINE_MAX],
+        decisions=(), follow_ups=(), record=manifest["latestWorkRecordPath"],
+        source="direct",
+    )
+    target, _ = group_context.record_task_memory(
+        project_root, manifest["taskGroup"], entry, today=date.today()
+    )
+    return target

package/runtime/python/okstra_ctl/group_context.py

@@ -102,6 +102,7 @@ class MemoryEntry:
     follow_ups: tuple[str, ...]
     record: str
     watch_out: tuple[str, ...] = ()
+    source: str = "run"
 
 
 def memory_entry_from_record(
@@ -198,6 +199,8 @@ def parse_memory_entries(region: str) -> list[MemoryEntry]:
                 task_type=match.group("type"), seq=match.group("seq"),
                 date=match.group("date"), next_phase=match.group("next").strip(),
             )
+        elif line.startswith("- direct: "):
+            current.update(source="direct", date=line[len("- direct: "):].strip())
         elif line.startswith("- headline: "):
             current["headline"] = line[len("- headline: "):].strip()
         elif line == "- decisions:":
@@ -215,6 +218,7 @@ def parse_memory_entries(region: str) -> list[MemoryEntry]:
 
 
 def _entry_from_fields(fields: Mapping[str, Any]) -> MemoryEntry:
+    record = fields.get("record", "")
     return MemoryEntry(
         task_id=fields.get("task_id", ""),
         task_type=fields.get("task_type", ""),
@@ -224,8 +228,9 @@ def _entry_from_fields(fields: Mapping[str, Any]) -> MemoryEntry:
         headline=fields.get("headline", ""),
         decisions=tuple(fields.get("decisions", [])),
         follow_ups=tuple(fields.get("follow_ups", [])),
-        record=fields.get("record", ""),
+        record="" if record in _NONE_MARKERS else record,
         watch_out=tuple(fields.get("watch_out", [])),
+        source=fields.get("source", "run"),
     )
 
 
@@ -237,9 +242,12 @@ def render_memory_entries(entries: list[MemoryEntry]) -> str:
     for entry in entries:
         lines = [
             f"### {entry.task_id}",
-            f"- latest: {entry.task_type} #{entry.seq} · {entry.date} · next: {entry.next_phase or '_(none)_'}",
+            (f"- direct: {entry.date}" if entry.source == "direct" else
+             f"- latest: {entry.task_type} #{entry.seq} · {entry.date} · next: {entry.next_phase or '_(none)_'}"),
             f"- headline: {entry.headline or '_(none)_'}",
         ]
+        if entry.source == "direct":
+            lines.append("- Verification: direct work; no cross-verification performed for this record.")
         if entry.decisions:
             lines.append("- decisions:")
             lines.extend(f"  - {item}" for item in entry.decisions)
@@ -391,6 +399,12 @@ class QueueRow:
     duplicate_briefs: tuple[str, ...] = ()
 
 
+def ticket_id_from_brief_id(brief_id: str) -> str:
+    """순번이 붙은 브리프 식별자에서 이슈 식별자를 복원한다."""
+    match = _ORDINAL_RE.match(brief_id)
+    return match.group("ticket") if match else brief_id
+
+
 def group_briefs(project_root: Path, task_group: str) -> list[dict[str, Any]]:
     """그룹 디렉터리의 브리프(프론트매터 `type: brief`)와 각 브리프의 대기 간선."""
     group_dir = group_context_file(project_root, task_group).parent
@@ -407,7 +421,7 @@ def group_briefs(project_root: Path, task_group: str) -> list[dict[str, Any]]:
         match = _ORDINAL_RE.match(brief_id)
         briefs.append({
             "brief_id": brief_id,
-            "ticket_id": frontmatter.get("ticket-id") or (match.group("ticket") if match else brief_id),
+            "ticket_id": frontmatter.get("ticket-id") or ticket_id_from_brief_id(brief_id),
             "ordinal": int(match.group("ordinal")) if match else None,
             "brief": path.relative_to(project_root).as_posix(),
             "waits_for": _wait_edges(path.read_text(encoding="utf-8")),
@@ -461,6 +475,12 @@ def catalog_progress(project_root: Path, task_group: str) -> dict[str, tuple[str
         if str(entry.get("workStatus") or "") == WORK_STATUS_DONE:
             status = QUEUE_DONE
             progress = f"{progress} · marked done" if progress else "marked done"
+        elif entry.get("workStatus") == "todo":
+            status = QUEUE_NOT_STARTED
+        elif entry.get("workStatus") in ("in-progress", "blocked"):
+            status = QUEUE_IN_PROGRESS
+        if entry.get("latestWorkRecordPath"):
+            progress = f"{progress} · direct work recorded" if progress else "direct work recorded"
         out[task_id] = (status, progress)
     return out
 

package/runtime/python/okstra_ctl/material.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 import json
 from pathlib import Path
 from typing import Optional
+from okstra_project import list_project_tasks
 
 from .json_boundary import JsonBoundaryError, load_owned_object
 
@@ -64,3 +65,31 @@ def related_tasks_bullets(items: list[str]) -> str:
 
 def related_tasks_inline(items: list[str]) -> str:
     return ", ".join(items) if items else "None"
+
+
+def direct_work_context(project_root: Path, task_key: str, related: list[str]) -> str:
+    """자기 작업과 다른 그룹의 명시적 관련 작업 결과를 준비 입력에 싣는다."""
+    own_group = task_key.split(":")[1].casefold()
+    wanted = {value.casefold() for value in related}
+    blocks = []
+    for task in list_project_tasks(project_root):
+        key = task["taskKey"]
+        is_own = key.casefold() == task_key.casefold()
+        is_related = key.casefold() in wanted or str(task.get("taskId", "")).casefold() in wanted
+        if not is_own and (not is_related or str(task.get("taskGroup", "")).casefold() == own_group):
+            continue
+        record_path = task.get("latestWorkRecordPath")
+        if not record_path:
+            continue
+        record_file = project_root / record_path
+        record_file.resolve().relative_to((project_root / ".okstra").resolve())
+        record = load_owned_object(record_file, artifact="direct work record")
+        blocks.extend([
+            f"### {key}", f"- Current work status: {task.get('workStatus', '')}",
+            "- Source: direct work; no cross-verification performed for this record.",
+            f"- Summary: {' '.join(record['summary'].split())[:400]}",
+            f"- Record: `{record_path}`", "",
+        ])
+    if not blocks:
+        return ""
+    return "\n".join(["## Direct Work Context", "", *blocks])

package/runtime/python/okstra_ctl/model_io/lines.py

@@ -114,6 +114,7 @@ def _status_overview_text(rows: list[dict[str, object]]) -> str:
             _line("Latest report", row.get("latestReportRecordPath")),
             _line("Latest resume command", row.get("latestResumeCommandPath")),
             _line("Work status", row.get("workStatus")),
+            _line("Direct work record", row.get("latestWorkRecordPath")),
         ))
     return "# Okstra Status Input\n\n" + "".join(blocks)
 

package/runtime/python/okstra_ctl/model_io/renderers.py

@@ -106,6 +106,7 @@ def _overview_rows(
             "latestReportRecordPath": manifest.get("latestReportRecordPath") or latest_run.get("reportRecordPath"),
             "latestResumeCommandPath": latest_run.get("resumeCommandPath") or manifest.get("latestResumeCommandPath"),
             "workStatus": manifest.get("workStatus"),
+            "latestWorkRecordPath": manifest.get("latestWorkRecordPath"),
             "lastRun": latest_run.get("runTimestamp"),
         }
         if task_type and row["taskType"] != task_type:
@@ -310,6 +311,7 @@ def render_status_input(
         + _line("Work status", manifest.get("workStatus"))
         + _line("Work status updated at", manifest.get("workStatusUpdatedAt"))
         + _line("Work status note", manifest.get("workStatusNote"))
+        + _line("Direct work record", manifest.get("latestWorkRecordPath"))
         + _line("Latest report", manifest.get("latestReportRecordPath"))
         + _line("Latest resume command", manifest.get("latestResumeCommandPath"))
         + _line("History timeline", manifest.get("historyTimelinePath"))
@@ -363,6 +365,8 @@ def render_recap_input(project_root: Path, task_ref: str) -> str:
         "# Okstra Recap Input\n\n",
         _line("Task key", recap.get("taskKey")),
         _line("Run count", recap.get("runCount")),
+        _line("Work status", recap.get("workStatus")),
+        _line("Direct work record", recap.get("latestWorkRecordPath")),
     ]
     transitions = recap.get("transitions")
     for transition in transitions if isinstance(transitions, list) else []:
@@ -426,6 +430,8 @@ def render_group_recap_input(project_root: Path, task_group: str) -> str:
             _line("Phase state", task.get("currentPhaseState")),
             _line("Latest run status", task.get("latestRunStatus")),
             _line("Work status", task.get("workStatus")),
+            _line("Direct work record", task.get("latestWorkRecordPath")),
+            _line("Memory source", memory.get("source")),
             _line("Run count", task.get("runCount")),
             _line("Next phase", pointer.get("phase")),
             _line("Next phase status", pointer.get("status")),

package/runtime/python/okstra_ctl/plan_items.py

@@ -930,11 +930,36 @@ class NextDispatch:
         }
 
 
+def self_fix_rounds(verification: Mapping[str, Any]) -> frozenset[int]:
+    """마지막 검증 라운드 번호와 자동 수정 횟수를 구분한다."""
+    rounds = frozenset(
+        group["round"] for group in (verification.get("selfFixGroups") or [])
+        if isinstance(group, Mapping)
+        and type(group.get("round")) is int and group["round"] > 0
+    )
+    applied = verification.get("selfFixRoundsApplied")
+    if not rounds and type(applied) is int and applied > 0:
+        return frozenset({applied})
+    return rounds
+
+
+def lead_decision_basis(item: Mapping[str, Any]) -> str:
+    """본문·범위·판정이 바뀌면 이전 리드 결정으로 새 쟁점을 해소할 수 없다."""
+    basis = {key: item.get(key) for key in (
+        "id", "subject", "block", "stageScope", "contentHash",
+        "verifiedContentHash", "verdicts",
+    )}
+    return hashlib.sha256(
+        json.dumps(basis, sort_keys=True, ensure_ascii=False).encode("utf-8")
+    ).hexdigest()
+
+
 def next_dispatch(
     items: Sequence[Mapping[str, Any]],
     payloads: Mapping[str, Mapping[str, Any]] | None = None,
     *,
     critic_rostered: bool = True,
+    decision_items: Sequence[Mapping[str, Any]] = (),
 ) -> NextDispatch:
     """환경 전용 UNVERIFIABLE 은 전체 라운드를 만들지 않는다. 일괄 오류만 그 워커.
 
@@ -945,6 +970,19 @@ def next_dispatch(
     `critic-tie` 다: critic 이 있는 run 을 사용자 결정으로 보내는 쪽이 더
     나쁜 오답이다.
     """
+    for authority in ("lead", "user"):
+        pending = tuple(
+            str(row["id"]) for row in decision_items
+            if row.get("decisionAuthority") == authority
+            and not row.get("leadDecisionApplied")
+        )
+        if pending:
+            return NextDispatch(
+                kind=f"{authority}-decision", workers=(), item_ids=pending,
+                reason="automatic self-fix finished; resolve remaining decisions without another worker batch",
+            )
+    if decision_items:
+        return NextDispatch(kind="none", workers=(), item_ids=(), reason="remaining decisions resolved")
     assigned = tuple(
         str(item["id"]) for item in items
         if isinstance(item.get("id"), str) and item["id"]
@@ -981,10 +1019,7 @@ def next_dispatch(
                 "approval decision per item"
             ),
         )
-    return NextDispatch(
-        kind="none", workers=(), item_ids=(),
-        reason="no worker batch",
-    )
+    return NextDispatch(kind="none", workers=(), item_ids=(), reason="no worker batch")
 
 
 def correction_prompt_text(queue_markdown: str) -> str:
@@ -1000,4 +1035,3 @@ def critic_tie_prompt_text(queue_markdown: str) -> str:
 def reverify_prompt_text(queue_markdown: str) -> str:
     """라운드 2+ 프롬프트. 직전 반대 의견을 읽으라는 지시가 큐보다 앞이다."""
     return f"{REVERIFY_PREAMBLE.rstrip()}\n\n{queue_markdown.lstrip()}"
-