okstra 0.220.0 → 0.221.0

package/runtime/python/okstra_ctl/phases/release_handoff/spec.md

@@ -33,7 +33,7 @@ When a predecessor advances, `okstra_ctl.stage_rebase.synchronize_stage_stack` r
 
 Because the PRs are a stack, they must be merged in dependency order with a merge commit or a rebase-merge. A squash replaces the commits the next PR's base points at, so the stack breaks — every PR body states this, and the lead never merges.
 
-This phase has no worker dispatch. It does not use a provider or report-writer roster; the host-native Okstra lead performs git/gh inspection, user questions, the PR draft, and the final report inline.
+This phase has no worker dispatch. It does not use a provider or report-writer roster; the host-native Okstra lead performs git/gh inspection, user questions, the PR draft, and the report narrative inline; `okstra report-finalize` assembles the final report from that narrative.
 
 ## 2. okstra-run wizard flow
 

package/runtime/python/okstra_ctl/phases/technical_verification/entry.py

@@ -98,3 +98,40 @@ def materialize_technical_input_packet(payload_json: str, run_root: Path, seq: s
         "- Read the input before planning experiments; copy each fact identity verbatim into results.\n"
         + "\n```json\n" + payload_json + "\n```\n"
     )
+
+
+def technical_evidence_packet_block(source: Path, project_root: Path) -> str:
+    """carry-in 이 시험 결과 기록이면 후속 비교 워커가 읽을 증거 위치를 렌더한다.
+
+    clarification carry-in 은 §1 행만 싣고 원문은 `Source report:` 한 줄로만
+    가리키므로, 이 블록이 없으면 워커는 시험 결과와 로그에 닿지 못한다.
+    """
+    from okstra_ctl.path_resolve import relative_to_project_root
+    from okstra_ctl.phases.technical_verification.validation import REPORT_NAME_RE
+
+    match = REPORT_NAME_RE.fullmatch(source.name)
+    if match is None or not source.is_file():
+        return ""
+    data = load_owned_object_snapshot(
+        source, artifact="technical verification result"
+    ).value
+    if (data.get("header") or {}).get("taskType") != "technical-verification":
+        return ""
+    experiments = source.parent.parent / "experiments" / match[1]
+    lines = [
+        "## Technical Verification Evidence",
+        "",
+        "The clarification response is a technical-verification record. Apply"
+        " `Technical evidence loop` in `## Phase Focus Extract`: read each"
+        " check's plan, commands and logs below before authoring a fresh"
+        " feasibility vote.",
+        "",
+        f"- Result record: `{relative_to_project_root(source, project_root)}`",
+        "- Experiment plans and logs:"
+        f" `{relative_to_project_root(experiments, project_root)}/`",
+    ]
+    for check in (data.get("technicalVerification") or {}).get("checks") or []:
+        lines.append(
+            f"- `{check.get('id')}` on `{check.get('candidateId')}`: {check.get('status')}"
+        )
+    return "\n".join(lines)

package/runtime/python/okstra_ctl/phases/technical_verification/validation.py

@@ -10,6 +10,8 @@ from okstra_ctl.implementation_direction import validate_task_artifact_path
 from okstra_ctl.json_boundary import load_owned_object_snapshot
 from okstra_ctl.technical_verification_facts import TechnicalVerificationError
 
+REPORT_NAME_RE = re.compile(r"final-report-technical-verification-(\d{3,})\.data\.json")
+
 
 def _check_execution_evidence(
     check: Mapping[str, Any], project_root: Path, run_root: Path, seq: str
@@ -51,9 +53,7 @@ def validate_technical_verification_report(
     """발행·최종 검증에서 같은 사실 집합과 실제 시험 산출물을 대조한다."""
     if (data.get("header") or {}).get("taskType") != "technical-verification":
         return []
-    match = re.fullmatch(
-        r"final-report-technical-verification-(\d{3,})\.data\.json", report_path.name
-    )
+    match = REPORT_NAME_RE.fullmatch(report_path.name)
     if match is None:
         return ["technical verification report must use its canonical record path"]
     run_root = report_path.parent.parent

package/runtime/python/okstra_ctl/render.py

@@ -26,7 +26,7 @@ import sys
 from collections.abc import Mapping
 from pathlib import Path
 
-from okstra_project.dirs import TASK_MANIFEST_FILENAME, OKSTRA_DIR_NAME, project_json_path
+from okstra_project.dirs import TASK_MANIFEST_FILENAME
 
 # phase 시퀀스 / 기본 next-phase 매핑의 SSOT 는 workflow 모듈이다. 과거
 # render_task_manifest 가 동일한 리스트/딕셔너리를 로컬에 중복 정의했는데,
@@ -50,6 +50,8 @@ from .registry.provider_registry import default_provider_registry
 from .path_hints import compact_active_run_context, hydrate_run_context
 from .paths import task_timeline_file
 from .json_boundary import JsonBoundaryError, load_owned_object, write_owned_object_atomic
+from .mcp_servers import load_declarations as load_mcp_declarations
+from .mcp_servers import render_block as render_mcp_block
 from .report_contract import CURRENT_REPORT_SCHEMA_VERSION
 from .report_language import resolve_report_language
 from .validation_contract import CURRENT_VALIDATION_CONTRACT_VERSION
@@ -2509,54 +2511,11 @@ def render_task_index(template_path: str, output_path: str, ctx: dict) -> None:
 # --------------------------------------------------------------------------- #
 
 
-_NO_MCP_SERVERS_LINE = (
-    f"- No MCP servers are declared in `{OKSTRA_DIR_NAME}/project.json`'s "
-    "`mcpServers` array. Treat MCP tools as unavailable for this run. To enable "
-    "them, add entries shaped `{name, description, tools, notes?}` to that array "
-    "and re-render the bundle."
-)
-
-
 def build_available_mcp_servers_block(project_root: Path) -> str:
-    """Render the `## Available MCP Servers` first bullet from project.json.
-
-    The MCP server list used to be hardcoded for one specific environment.
-    It now comes from the project's okstra project.json (`mcpServers` array),
-    so each user/project declares the MCP surface available to their
-    lead+workers. Missing file or empty array yields a generic "none declared"
-    fallback.
-    """
-    config_path = project_json_path(project_root)
-    try:
-        raw = load_owned_object(config_path, artifact="project config")
-    except JsonBoundaryError:
-        return _NO_MCP_SERVERS_LINE
-    servers = raw.get("mcpServers") if isinstance(raw, dict) else None
-    if not isinstance(servers, list) or not servers:
-        return _NO_MCP_SERVERS_LINE
-    lines: list[str] = []
-    for entry in servers:
-        if not isinstance(entry, dict):
-            continue
-        name = str(entry.get("name", "")).strip()
-        if not name:
-            continue
-        description = str(entry.get("description", "")).strip()
-        tools = entry.get("tools") or []
-        notes = str(entry.get("notes", "")).strip()
-        parts = [f"`mcp__{name}`"]
-        if description:
-            parts.append(description)
-        if isinstance(tools, list) and tools:
-            tool_names = ", ".join(
-                f"`{str(t).strip()}`" for t in tools if str(t).strip()
-            )
-            if tool_names:
-                parts.append(f"Tools: {tool_names}")
-        if notes:
-            parts.append(notes)
-        lines.append("- " + ". ".join(parts) + ".")
-    return "\n".join(lines) if lines else _NO_MCP_SERVERS_LINE
+    """provider 판정 없이 렌더한다. prepare 는 판정한 블록을 ctx 로 넘기므로
+    이 경로는 prepare 를 거치지 않는 렌더 호출자만 쓴다."""
+    declarations, _problems = load_mcp_declarations(project_root)
+    return render_mcp_block(declarations)
 
 
 # --------------------------------------------------------------------------- #

package/runtime/python/okstra_ctl/report_assembly.py

@@ -762,7 +762,7 @@ def _attach_machine_planning(
     _sync_human_summary_with_plan_body_gate(data, projection)
 
 
-def _schema_owner(error: str) -> str:
+def _schema_owner(error: str, narrative_owner: str) -> str:
     field = error.split(" ", 1)[0]
     owners = {
         "executionStatus": "team-state",
@@ -781,8 +781,8 @@ def _schema_owner(error: str) -> str:
     if "planBodyVerification" in error:
         return "convergence"
     if "selectedDirectionRef" in error:
-        return "report-writer"
-    return owners.get(field.split(".", 1)[0], "report-writer")
+        return narrative_owner
+    return owners.get(field.split(".", 1)[0], narrative_owner)
 
 
 def _publish(
@@ -864,7 +864,7 @@ def assemble_report(
     path_errors = planned_path_declaration_errors(data)
     if path_errors:
         raise ReportAssemblyError(tuple(
-            AssemblyIssue("report-writer", str(inputs["narrative"].path), error.split(":", 1)[0], error)
+            AssemblyIssue(inputs["narrative"].owner, str(inputs["narrative"].path), error.split(":", 1)[0], error)
             for error in path_errors
         ))
     direction_errors = selected_direction_plan_errors(
@@ -888,7 +888,7 @@ def assemble_report(
         raise ReportAssemblyError(
             tuple(
                 AssemblyIssue(
-                    _schema_owner(error),
+                    _schema_owner(error, inputs["narrative"].owner),
                     str(target),
                     error.split(" ", 1)[0],
                     error,

package/runtime/python/okstra_ctl/report_inputs.py

@@ -28,6 +28,10 @@ _INPUT_FIELDS = (
     ("convergence", "convergence", "convergenceStatePath"),
 )
 
+# 워커 없이 리드가 리포트까지 쓰는 phase. 서사의 저자가 리드이므로, 서사가
+# 없을 때 조립이 report-writer 를 지목하면 띄울 수 없는 워커를 찾게 된다.
+_LEAD_AUTHORED_NARRATIVE_TASK_TYPES = frozenset({"release-handoff"})
+
 _PLANNING_INPUT_FIELDS = (
     ("design-preparation", "design-surface-detector", "designPreparationPath"),
     ("plan-body-verification", "convergence", "planBodyVerificationPath"),
@@ -63,8 +67,13 @@ def report_input_paths(
         if manifest.get("taskType") == "implementation-planning"
         else ()
     )
+    lead_authored = manifest.get("taskType") in _LEAD_AUTHORED_NARRATIVE_TASK_TYPES
     rows = tuple(
-        ReportInputPath(key, owner, _project_path(project_root, manifest.get(field), field))
+        ReportInputPath(
+            key,
+            "lead" if lead_authored and key == "narrative" else owner,
+            _project_path(project_root, manifest.get(field), field),
+        )
         for key, owner, field in fields
     )
     if len({row.key for row in rows}) != len(rows):

package/runtime/python/okstra_ctl/report_language.py

@@ -1,10 +1,9 @@
 """Report-language resolution — the one place the precedence lives.
 
-Two surfaces need the answer and must agree: the `**Report Language:**` line
-both dispatchers stamp into the report-writer prompt, and `reportLanguage` in
-the run manifest, which report assembly copies into `meta.reportLanguage` and
-the HTML renderer reads. When only the prompt called this, a project could ask
-for `ko`, get a Korean-instructed writer, and still ship an English report.
+Prepare calls this once and freezes the answer as `reportLanguage` in the run
+manifest. Both report-writer dispatch paths stamp that manifest value as the
+`**Report Language:**` line, and report assembly copies it into
+`meta.reportLanguage`, so a config edit after prepare cannot split the two.
 
 The value is a language tag (`en`, `ko`, `fr`, `pt-BR`, …). The report writer
 authors the report prose in that language; nothing here knows any particular

package/runtime/python/okstra_ctl/run.py

@@ -23,6 +23,7 @@ from okstra_ctl.phases.implementation_planning.validation import validate_select
 from .phases.technical_verification.entry import (
     prepare_technical_verification_input,
     materialize_technical_input_packet,
+    technical_evidence_packet_block,
 )
 
 from argparse import (
@@ -55,6 +56,7 @@ from .phases.implementation_planning.entry import (
 )
 from . import fix_cycles
 from .analysis_packet import build_analysis_packet
+from .mcp_servers import NO_MCP_SERVERS_LINE, prepare_mcp
 from .coverage_census import (
     CensusError,
     census_filename,
@@ -3051,6 +3053,16 @@ def _write_instruction_set_sources(
         ),
         coverage_census_text=coverage_census_text,
         has_selected_direction=(instruction_set / "selected-direction.json").is_file(),
+        mcp_servers_text=(
+            "" if ctx.get("AVAILABLE_MCP_SERVERS", NO_MCP_SERVERS_LINE) == NO_MCP_SERVERS_LINE
+            else ctx["AVAILABLE_MCP_SERVERS"]
+        ),
+        technical_evidence_text=(
+            technical_evidence_packet_block(
+                Path(inp.clarification_response_path), Path(ctx["PROJECT_ROOT"]),
+            )
+            if inp.clarification_response_path else ""
+        ),
     )
     if inp.task_type == "technical-verification":
         packet += materialize_technical_input_packet(
@@ -4055,6 +4067,20 @@ def _prepare_user_authorization(inp: PrepareInputs) -> dict:
     return record
 
 
+def _prepare_mcp_block(
+    project_root: Path, plan: AssignmentPlan, brief_path: Path,
+) -> str:
+    brief_text = brief_path.read_text(encoding="utf-8") if brief_path.is_file() else ""
+    prepared = prepare_mcp(
+        project_root,
+        (assignment.provider_id for assignment in plan.assignments),
+        brief_text,
+    )
+    for warning in prepared.warnings:
+        print(f"prepare: {warning}", file=sys.stderr)
+    return prepared.block
+
+
 def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
     """Produce a complete okstra task bundle on disk. See module docstring."""
     user_authorization = _prepare_user_authorization(inp)
@@ -4326,6 +4352,9 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
         "DYNAMIC_EXECUTION_ROLES_JSON": json.dumps(
             dynamic_roles, ensure_ascii=False,
         ),
+        "AVAILABLE_MCP_SERVERS": _prepare_mcp_block(
+            project_root, assignment_plan, inp.brief_path,
+        ),
     })
     refresh_run_context_snapshot(ctx)
     if lead_runtime == "codex":

package/runtime/python/okstra_ctl/stage_done.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 import argparse
 import json
 import re
+import subprocess
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -23,6 +24,7 @@ from .consumers import (
     carry_head_commit,
     read_consumers,
 )
+from .file_size_cap import file_size_violations
 from .json_boundary import JsonBoundaryError, load_owned_object, write_owned_object_atomic
 from .paths import RunRef
 from .stage_reopen import resolve_planned_stage
@@ -49,6 +51,34 @@ def _read_carry(carry_file: Path, stage: int) -> dict:
     return carry
 
 
+def _check_file_size(project_root: Path, carry: dict, head: str) -> str:
+    """Refuse to settle a stage whose diff breaks the file-size limit; return what was checked.
+
+    Verifiers report the limit from `okstra correction file-size`; this re-runs it so a stage
+    a verifier did not check still reaches the correction round instead of landing. A range
+    git cannot read is reported in the output, not refused: the limit is a code-quality rule
+    and must not strand a stage whose verdict already passed.
+    """
+    rng = carry.get("stageCommitRange")
+    base = rng.get("base") if isinstance(rng, dict) else None
+    if not base:
+        return "not checked: the carry has no stageCommitRange.base"
+    try:
+        violations = [
+            v for v in file_size_violations(project_root, str(base), head) if v.blocking
+        ]
+    except subprocess.CalledProcessError as exc:
+        return f"not checked: git: {exc.stderr.decode(errors='replace').strip()}"
+    if violations:
+        raise StateError(
+            "the stage diff breaks the 400-line file-size limit:\n"
+            + "\n".join(v.line() for v in violations)
+            + f"\nRun a correction round (`okstra correction prompt ... --base {head} "
+            f"--stage-base {base}`) so the executor splits these files, or end the run FAIL "
+            "with `okstra stage-fail` when no round is left.", stage="file-size")
+    return f"pass: {base}..{head}"
+
+
 def _supersede(target: Path, rows: list[dict], stage: int) -> Path:
     """Move the sidecar of the run that first settled a reopened stage aside, unchanged."""
     settled = [r for r in rows if r.get("stage") == stage and r.get("status") == "done"]
@@ -76,6 +106,7 @@ def done_stage(
     identity, plan_run_root = resolve_planned_stage(project_root, task_key, stage)
     carry = _read_carry(carry_file, stage)
     head = carry_head_commit(carry)
+    file_size_cap = _check_file_size(project_root, carry, head)
     report = report if report.is_absolute() else project_root / report
     try:
         report_rel = report.relative_to(RunRef.from_report_path(report).run_dir).as_posix()
@@ -118,6 +149,7 @@ def done_stage(
         "supersededCarryPath": str(superseded) if superseded else "",
         "reportPath": report_rel,
         "consumersPath": str(plan_run_root / "consumers.jsonl"),
+        "fileSizeCap": file_size_cap,
     }
 
 
@@ -131,11 +163,13 @@ canonical sidecar `runs/implementation/carry/stage-<N>.json`, then appends the
 `done` row with that carry path, the report path relative to its run directory,
 the carry's head and the completion time. A reopened stage's previous sidecar
 is moved to `carry/superseded/stage-<N>-from-<task-type>-<seq>.json` first.
-Refuses a carry for another stage, a failed carry, and a stage already done at
-another head. Re-running with the same carry writes nothing new.
+Refuses a carry for another stage, a failed carry, a stage already done at
+another head, and a carry whose stageCommitRange diff leaves a source or test
+file over the 400-line limit (`okstra correction file-size`). Re-running with the
+same carry writes nothing new.
 
 Output: JSON { ok, taskKey, stage, headCommit, carryPath, supersededCarryPath,
-reportPath, consumersPath }. Exit 1 on a refusal, 2 when
+reportPath, consumersPath, fileSizeCap }. Exit 1 on a refusal, 2 when
 PROJECT_ROOT cannot be resolved.
 """
 

package/runtime/python/okstra_ctl/wizard/engine.py

@@ -96,7 +96,7 @@ def _build_group_prompt(state: WizardState, group_id: str) -> Prompt:
 
 
 def _is_lone_choice_pick(prompt: Prompt) -> bool:
-    """고를 것이 한 줄뿐인 단일 선택 픽인가.
+    """고를 것이 한 줄뿐인 픽인가 — 단일 선택이든 체크박스든.
 
     호스트 선택기는 옵션 2개 미만을 받지 않아(`nativeLimits` `minOptions`) 이런
     화면은 번호 1개짜리 목록으로 내려간다 — 사용자는 고를 것이 없는 목록에서
@@ -106,7 +106,6 @@ def _is_lone_choice_pick(prompt: Prompt) -> bool:
     """
     return (
         prompt.kind == "pick"
-        and not prompt.multi
         and len(prompt.options) == 1
         and prompt.options[0].value != _ABORT_OPTION
     )

package/runtime/skills/_fragments/wizard-lead-takeover.md

@@ -1,6 +1,6 @@
 ## Step 6: Take over as Okstra lead
 
-Read `resources.leadExecutionPromptPath` from the run manifest at `<RUN_MANIFEST_PATH>` — the same manifest Step 5 already opened for `resources.leadPromptMetadataPath` — then read that file verbatim and take over as `Okstra lead` in the current host-native session. Do not construct the path yourself: the prompt is written per run under `runs/<task-type>/prompts/lead-execution-prompt-<task-type>-<seq>.md`, not in the instruction set, and the `<seq>` is assigned at prepare time. The prompt selects exactly one runtime adapter and points to compact intake artifacts first (`active-run-context`, `analysis-profile.md`, and `analysis-packet.md`); full source files such as `analysis-material.md`, `reference-expectations.md`, and `final-report-template.md` are lazy/fallback inputs. Follow the rendered prompt order, do not preempt it.
+Read `resources.leadExecutionPromptPath` from the run manifest at `<RUN_MANIFEST_PATH>` — the same manifest Step 5 already opened for `resources.leadPromptMetadataPath` — then read that file verbatim and take over as `Okstra lead` in the current host-native session. Do not construct the path yourself: the prompt is written per run under `runs/<task-type>/prompts/lead-execution-prompt-<task-type>-<seq>.md`, not in the instruction set, and the `<seq>` is assigned at prepare time. The prompt selects exactly one runtime adapter and points to compact intake artifacts first (`active-run-context`, `analysis-profile.md`, and `analysis-packet.md`); full source files such as `analysis-material.md`, `reference-expectations.md`, and `final-report-template.md` are lazy/fallback inputs. Follow the rendered prompt order, do not preempt it. The run manifest's `reportLanguage` sets the language of okstra report artifacts; a host, project or global instruction file (`CLAUDE.md`, `AGENTS.md`) does not override it, and the lead never tells the report writer to use another language.
 
 Then proceed through the phases exactly as the lead prompt directs (Phase 1 context → Phase 2+ worker dispatch → final synthesis → final report).
 

package/runtime/skills/_fragments/wizard-relay-protocol.md

@@ -20,8 +20,8 @@ On `ok: false`, re-prompt with the same `current.step` using the error message.
 The wizard tells you which relay operation to use via `next.interaction.kind`. Step 1 loads the current registered host's relay contract. Use the matching entry under its `interactions` object, including the runtime-generated navigation and completion options. If the entry is absent, stop instead of inventing a host function or falling back silently. Use the explicit `Legacy text relay compatibility` mapping only when the preflight response has no `relayContract`.
 
 - `native-single` → use the current registered host's relay contract for its native single-select function. Pass every option in its original order and submit the selected `options[].value`.
-- `native-multi` → use the relay contract's native multi-select function. Pass every option in its original order and submit the selected values as one CSV answer; submit an empty selection as `--answer ""`.
-- `native-group` → use the relay contract's native grouped-question function once. Preserve every question and option, then submit one JSON object keyed by `questions[].step`; when a grouped question is multi-select, its step value is the selected option values joined as one CSV string, not a JSON array.
+- `native-multi` → use the relay contract's native multi-select function. Pass every option in its original order and submit the host's selected-labels string unchanged (labels may contain `, `; the wizard decodes it against the option list); submit an empty selection as `--answer ""`.
+- `native-group` → use the relay contract's native grouped-question function once. Preserve every question and option, then submit one JSON object keyed by `questions[].step`; a single-select step value is the selected option value, and a multi-select step value is the host's selected-labels string unchanged, not a JSON array.
 - `numbered-single` → render every option as a 1-based numbered Markdown list and submit the user's next message unchanged.
 - `numbered-multi` → render every option as a 1-based numbered Markdown list and submit the user's comma-separated reply unchanged.
 - `sequential-group` → render every question in order, preserve each complete option list, collect every answer, and submit one JSON object keyed by `questions[].step`.

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

@@ -47,8 +47,8 @@ On `ok: false`, re-prompt with the same `current.step` using the error message.
 The wizard tells you which relay operation to use via `next.interaction.kind`. Step 1 loads the current registered host's relay contract. Use the matching entry under its `interactions` object, including the runtime-generated navigation and completion options. If the entry is absent, stop instead of inventing a host function or falling back silently. Use the explicit `Legacy text relay compatibility` mapping only when the preflight response has no `relayContract`.
 
 - `native-single` → use the current registered host's relay contract for its native single-select function. Pass every option in its original order and submit the selected `options[].value`.
-- `native-multi` → use the relay contract's native multi-select function. Pass every option in its original order and submit the selected values as one CSV answer; submit an empty selection as `--answer ""`.
-- `native-group` → use the relay contract's native grouped-question function once. Preserve every question and option, then submit one JSON object keyed by `questions[].step`; when a grouped question is multi-select, its step value is the selected option values joined as one CSV string, not a JSON array.
+- `native-multi` → use the relay contract's native multi-select function. Pass every option in its original order and submit the host's selected-labels string unchanged (labels may contain `, `; the wizard decodes it against the option list); submit an empty selection as `--answer ""`.
+- `native-group` → use the relay contract's native grouped-question function once. Preserve every question and option, then submit one JSON object keyed by `questions[].step`; a single-select step value is the selected option value, and a multi-select step value is the host's selected-labels string unchanged, not a JSON array.
 - `numbered-single` → render every option as a 1-based numbered Markdown list and submit the user's next message unchanged.
 - `numbered-multi` → render every option as a 1-based numbered Markdown list and submit the user's comma-separated reply unchanged.
 - `sequential-group` → render every question in order, preserve each complete option list, collect every answer, and submit one JSON object keyed by `questions[].step`.
@@ -290,7 +290,7 @@ You can delete the literal state-file path after this point — its job is done.
 <!-- BEGIN FRAGMENT: wizard-lead-takeover -->
 ## Step 6: Take over as Okstra lead
 
-Read `resources.leadExecutionPromptPath` from the run manifest at `<RUN_MANIFEST_PATH>` — the same manifest Step 5 already opened for `resources.leadPromptMetadataPath` — then read that file verbatim and take over as `Okstra lead` in the current host-native session. Do not construct the path yourself: the prompt is written per run under `runs/<task-type>/prompts/lead-execution-prompt-<task-type>-<seq>.md`, not in the instruction set, and the `<seq>` is assigned at prepare time. The prompt selects exactly one runtime adapter and points to compact intake artifacts first (`active-run-context`, `analysis-profile.md`, and `analysis-packet.md`); full source files such as `analysis-material.md`, `reference-expectations.md`, and `final-report-template.md` are lazy/fallback inputs. Follow the rendered prompt order, do not preempt it.
+Read `resources.leadExecutionPromptPath` from the run manifest at `<RUN_MANIFEST_PATH>` — the same manifest Step 5 already opened for `resources.leadPromptMetadataPath` — then read that file verbatim and take over as `Okstra lead` in the current host-native session. Do not construct the path yourself: the prompt is written per run under `runs/<task-type>/prompts/lead-execution-prompt-<task-type>-<seq>.md`, not in the instruction set, and the `<seq>` is assigned at prepare time. The prompt selects exactly one runtime adapter and points to compact intake artifacts first (`active-run-context`, `analysis-profile.md`, and `analysis-packet.md`); full source files such as `analysis-material.md`, `reference-expectations.md`, and `final-report-template.md` are lazy/fallback inputs. Follow the rendered prompt order, do not preempt it. The run manifest's `reportLanguage` sets the language of okstra report artifacts; a host, project or global instruction file (`CLAUDE.md`, `AGENTS.md`) does not override it, and the lead never tells the report writer to use another language.
 
 Then proceed through the phases exactly as the lead prompt directs (Phase 1 context → Phase 2+ worker dispatch → final synthesis → final report).
 

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

@@ -29,7 +29,7 @@ okstra manager task status --manager-id <manager-id> --task-group <task-group> -
 okstra manager task sync --manager-id <manager-id> --task-group <task-group> --task-id <task-id>
 okstra manager task assign --manager-id <manager-id> --task-group <task-group> --task-id <task-id> --project-id <project-id> [--child-task-id <child-task-id>] [--role <role>] [--tag <tag>] [--assignment <text>]
 okstra manager task note --manager-id <manager-id> --task-group <task-group> --task-id <task-id> --scope <shared|project> [--project-id <project-id>] --body <text>
-okstra manager task run --manager-id <manager-id> --project-id <project-id> --task-group <task-group> --task-id <task-id> [--child-task-id <child-task-id>]
+okstra manager task run --manager-id <manager-id> --project-id <project-id> --task-group <task-group> --task-id <task-id> [--child-task-id <child-task-id>] [--allow-completed]
 okstra manager task split --manager-id <manager-id> --task-group <task-group> --task-id <task-id> --plan <split-plan.json> [--overwrite]
 okstra manager list managers
 okstra manager list projects --manager-id <manager-id>
@@ -52,6 +52,7 @@ okstra manager view --manager-id <manager-id>
 
 `remove project`, `remove task`, `remove task-group` and `task remove-child` change nothing without `--confirm`; they print what would be removed (`Removed: no — dry run`). Run the command without `--confirm` first, show the user the listed project, path, tasks or kept children, and rerun with `--confirm` only after the user approves that exact target. These commands touch manager files only; project `.okstra/` state and briefs written by `task split` stay.
 
+- `task status` shows the snapshot as of `Synced at` with its `Sync age`; a child marked `changed since sync: yes` has a project task manifest written after that sync, so run `task sync` before reporting its state.
 - `remove project` unregisters the project and keeps its child tasks. `task status` shows them with `project linked: no`, the view marks them `unlinked`, and `task run` refuses them until the project is registered again with `new project`.
 - `task update` changes only the fields given and needs no confirmation. `new task` still refuses to change an existing task's objective, common brief or progress mode.
 
@@ -104,7 +105,7 @@ When the user wants to see a manager at a glance, run `okstra manager task sync
 For launching child work:
 
 1. Run `okstra manager task sync ...` if the manager snapshot must be refreshed first.
-2. Run `okstra manager task run ...`.
+2. Run `okstra manager task run ...`. It re-reads the child's state from its project, not from the snapshot. When the child is already done there (terminal next phase, or work status `done`), it refuses with the last phase and report path; tell the user that and do not add `--allow-completed` unless the user asks to run the child again.
 3. Read the returned fixed fields `Backend`, `Worker dispatch backend`, `Project root`, `Context path`, `Run command`, every numbered `Run arg N`, and `Shell command`.
 4. Give the user the `Shell command` line verbatim and tell them to run it in a new terminal. It starts the installed launcher in the child project: the launcher fills the task type and brief from the child task manifest or asks for them, prepares the run with the manager context directive, and starts the child lead as a separate host process (`Backend` `spawn-process`).
 

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

@@ -47,8 +47,8 @@ On `ok: false`, re-prompt with the same `current.step` using the error message.
 The wizard tells you which relay operation to use via `next.interaction.kind`. Step 1 loads the current registered host's relay contract. Use the matching entry under its `interactions` object, including the runtime-generated navigation and completion options. If the entry is absent, stop instead of inventing a host function or falling back silently. Use the explicit `Legacy text relay compatibility` mapping only when the preflight response has no `relayContract`.
 
 - `native-single` → use the current registered host's relay contract for its native single-select function. Pass every option in its original order and submit the selected `options[].value`.
-- `native-multi` → use the relay contract's native multi-select function. Pass every option in its original order and submit the selected values as one CSV answer; submit an empty selection as `--answer ""`.
-- `native-group` → use the relay contract's native grouped-question function once. Preserve every question and option, then submit one JSON object keyed by `questions[].step`; when a grouped question is multi-select, its step value is the selected option values joined as one CSV string, not a JSON array.
+- `native-multi` → use the relay contract's native multi-select function. Pass every option in its original order and submit the host's selected-labels string unchanged (labels may contain `, `; the wizard decodes it against the option list); submit an empty selection as `--answer ""`.
+- `native-group` → use the relay contract's native grouped-question function once. Preserve every question and option, then submit one JSON object keyed by `questions[].step`; a single-select step value is the selected option value, and a multi-select step value is the host's selected-labels string unchanged, not a JSON array.
 - `numbered-single` → render every option as a 1-based numbered Markdown list and submit the user's next message unchanged.
 - `numbered-multi` → render every option as a 1-based numbered Markdown list and submit the user's comma-separated reply unchanged.
 - `sequential-group` → render every question in order, preserve each complete option list, collect every answer, and submit one JSON object keyed by `questions[].step`.
@@ -455,7 +455,7 @@ If `render-bundle` raises Step 5's concurrent-run conflict detection (concurrent
 <!-- BEGIN FRAGMENT: wizard-lead-takeover -->
 ## Step 6: Take over as Okstra lead
 
-Read `resources.leadExecutionPromptPath` from the run manifest at `<RUN_MANIFEST_PATH>` — the same manifest Step 5 already opened for `resources.leadPromptMetadataPath` — then read that file verbatim and take over as `Okstra lead` in the current host-native session. Do not construct the path yourself: the prompt is written per run under `runs/<task-type>/prompts/lead-execution-prompt-<task-type>-<seq>.md`, not in the instruction set, and the `<seq>` is assigned at prepare time. The prompt selects exactly one runtime adapter and points to compact intake artifacts first (`active-run-context`, `analysis-profile.md`, and `analysis-packet.md`); full source files such as `analysis-material.md`, `reference-expectations.md`, and `final-report-template.md` are lazy/fallback inputs. Follow the rendered prompt order, do not preempt it.
+Read `resources.leadExecutionPromptPath` from the run manifest at `<RUN_MANIFEST_PATH>` — the same manifest Step 5 already opened for `resources.leadPromptMetadataPath` — then read that file verbatim and take over as `Okstra lead` in the current host-native session. Do not construct the path yourself: the prompt is written per run under `runs/<task-type>/prompts/lead-execution-prompt-<task-type>-<seq>.md`, not in the instruction set, and the `<seq>` is assigned at prepare time. The prompt selects exactly one runtime adapter and points to compact intake artifacts first (`active-run-context`, `analysis-profile.md`, and `analysis-packet.md`); full source files such as `analysis-material.md`, `reference-expectations.md`, and `final-report-template.md` are lazy/fallback inputs. Follow the rendered prompt order, do not preempt it. The run manifest's `reportLanguage` sets the language of okstra report artifacts; a host, project or global instruction file (`CLAUDE.md`, `AGENTS.md`) does not override it, and the lead never tells the report writer to use another language.
 
 Then proceed through the phases exactly as the lead prompt directs (Phase 1 context → Phase 2+ worker dispatch → final synthesis → final report).
 

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

@@ -174,6 +174,8 @@ matching section:
 - **F. declared architecture style** (`architecture.style`) — `hexagonal` /
   `layered` / `none`; hand-added, default `none`. Declaring one makes that
   architecture's placement rules binding in planning + verification.
+- **H. MCP servers** (`mcpServers`) — `okstra mcp add` declares a server,
+  `okstra mcp check` shows which provider CLIs reach it.
 
 ## Step 4: Verify
 

package/runtime/skills/okstra-setup/references/project-config.md

@@ -301,3 +301,37 @@ preserves it:
   records that it read no rules and the run still passes. Whether a pack that
   does resolve was actually read and applied stays the phase's own
   `project-review-rules:` record — no machine check reads a worker's reasoning.
+
+## H. MCP servers (`mcpServers`)
+
+`mcpServers` declares the MCP servers a run may use — a Figma file server for a
+visual check, for example. Without a declaration the launch prompt and the
+analysis packet tell every worker that MCP is unavailable, even when a provider
+CLI has the server configured.
+
+Register each server with `okstra mcp add`. `--tool` repeats per tool;
+`--alias` repeats per name a provider CLI lists the server under (one provider
+may list Figma as `claude.ai Figma`, another as `figma-desktop`):
+
+```bash
+okstra mcp add --name figma --description "Figma design files" --tool get_screenshot --tool get_metadata --alias "claude.ai Figma" --alias figma-desktop
+```
+
+Then check which providers can reach it:
+
+```bash
+okstra mcp check
+```
+
+Each provider adapter lists its own CLI's MCP servers without an inference
+call. `reachable` means the provider listed the server enabled; `disabled`
+means listed but disabled or awaiting authentication; `missing` means not
+listed; `unknown` means the adapter cannot list. Show the result to the user.
+For a provider that is not `reachable`, tell the user to add the server to that
+provider CLI's own MCP configuration — okstra never edits a provider's
+configuration. `okstra mcp list` and `okstra mcp remove --name <name>` manage
+existing entries.
+
+prepare repeats the check for the providers a run selects and prints a warning
+for each gap; it never refuses the run. It also warns when the task brief cites
+a Figma URL and no declared server name or alias contains `figma`.

package/runtime/templates/report-writer-prompt-preamble.md

@@ -30,7 +30,7 @@ The narrative is not free-form Markdown. A narrative file is the line `# OKSTRA
 
 Blank lines are ignored. **Every other line is rejected**, including Markdown headings (`#`, `##`, `###`), a pipe table written at column 0, code fences, bare paragraphs, JSON, YAML, and JSON Pointer. A heading or table that belongs in the reader's report is written as the text of a `> ` value, never as a narrative line of its own.
 
-Follow the task-specific schema order. Write every `> ` prose value directly in the language named by `**Report Language:**`; do not draft in English first, because no translation step follows. Field names, `Verdict Token` and other enum or status values, finding and requirement ids, paths, symbols, commands, and model names stay exactly as the schema and sources spell them.
+Follow the task-specific schema order. Write every `> ` prose value directly in the language named by `**Report Language:**`; do not draft in English first, because no translation step follows. A host, project or global instruction file (`CLAUDE.md`, `AGENTS.md`) does not change that language for report artifacts. Field names, `Verdict Token` and other enum or status values, finding and requirement ids, paths, symbols, commands, and model names stay exactly as the schema and sources spell them.
 
 ### Top-level fields you may author
 

package/runtime/templates/reports/task-brief.template.md

@@ -154,13 +154,13 @@ taskType: "{{FM_TASK_TYPE}}"
 
 ## Available MCP Servers
 
-The MCP servers available to this run are declared in `.okstra/project.json`'s `mcpServers` array and rendered into the Okstra lead's launch prompt under `## Available MCP Servers`. The lead is responsible for forwarding the rendered list verbatim into worker prompts (Phase 2) so each assignment can determine whether its selected runner exposes the named tools.
+The MCP servers available to this run are declared in `.okstra/project.json`'s `mcpServers` array. Prepare renders them, with the providers that list each server, into the lead's launch prompt and the analysis packet under `## Available MCP Servers`.
 
-To declare servers, add entries shaped `{ "name": "<server>", "description": "...", "tools": ["..."], "notes": "..." }` to that array. If the array is empty or absent, treat MCP as unavailable for this run.
+To declare a server, run `okstra mcp add --name <server> --description <text> --tool <tool>... [--alias <name-as-a-provider-lists-it>...]`, then `okstra mcp check` to see which providers reach it. If nothing is declared, treat MCP as unavailable for this run.
 
 How to invoke (worker-by-worker):
 
-- **Native-session assignments**: invoke an MCP tool directly by its tool name (e.g. `mcp__<server>__<tool>`) only when the selected host adapter exposes it. Do not call an MCP tool name through a shell.
+- **Native-session assignments**: invoke an MCP tool directly through the host's tool interface, under the name the host adapter exposes, only when it exposes the server. Do not call an MCP tool name through a shell.
 - **CLI-wrapper assignments**: use only the MCP or tool configuration explicitly supported and forwarded by that provider wrapper. If the wrapper has no matching MCP configuration, record `MCP not available in this CLI` in `Missing Information or Assumptions`; do not attempt a shell fallback.
 - All workers: cite the exact server, tool, and SELECT (or `WHERE` filters) used in the result file. Tool-call failures must be logged in the worker's `*-errors.json` (commandKind `mcp_call`) so the lead can decide whether to retry under a different worker.
 

package/runtime/validators/validate-run.py

@@ -2342,6 +2342,15 @@ def _validate_conformance_surfaces(
         )
 
 
+def _stage_ended_without_a_commit(report_data: dict) -> bool:
+    implementation = report_data.get("implementation")
+    if not isinstance(implementation, dict):
+        return False
+    evidence = implementation.get("stageSidecarEvidence")
+    withheld = isinstance(evidence, dict) and str(evidence.get("withheld") or "").strip()
+    return bool(withheld) and not implementation.get("commitList")
+
+
 def _validate_conformance(
     report_path: Path,
     failures: list[str],
@@ -2389,6 +2398,10 @@ def _validate_conformance(
         )
         if declared_manifest is None:
             return warnings
+        # 스크립트와 manifest 항목은 stage 를 실행한 run 이 쓴다. 커밋 없이 carry 를
+        # 보류한 run(첫 편집 전 정지 후 재계획)은 그것을 쓸 기회가 없었다.
+        if _stage_ended_without_a_commit(report_data):
+            declared_manifest = None
     if declared_manifest is not None:
         scoped_declared = _scope_manifest_entries(declared_manifest, stage_name)
         for error in missing_declared_scripts(