okstra 0.199.4 → 0.200.0

package/runtime/python/okstra_ctl/final_report_schema.py

@@ -211,26 +211,17 @@ class _Validator:
     def _misplaced_property_hint(
         self, name: str, path: tuple[str | int, ...],
     ) -> str:
-        """이 키가 스키마의 다른 자리에서 정의된 필드면 "옮겨라" 를 덧붙인다.
-
-        `additional property 'X' is not allowed` 만 보면 "스키마에 그런 칸이
-        없다" 로 읽힌다. 실제로는 X 가 다른 객체의 필드이고 작성자가 자리를
-        틀린 경우가 있고, 그때 지우면 다음 라운드에서 `required property 'X'
-        is missing` 이 나온다 — 라운드 하나를 왕복에 쓴다(2026-09-09 실측,
-        dev-10642 implementation-planning: 최상위 필수 `summary` 를
-        `rationale` 안에 써서 지웠다가 되살렸다).
-        """
+        """동명 필수 필드의 위치만 알린다. 이름 일치는 값의 의미를 증명하지 않는다."""
         found = self._required_property_owners(name) - {_format_path(path)}
         if not found:
             return ""
-        # 최상위를 앞에 둔다. 잘못 놓인 키는 대개 최상위 필드가 한 단계 안으로
-        # 들어간 것이고, 나머지 소유자는 같은 이름을 쓰는 다른 행 타입이다.
         owners = (
             ["<root>"] if "<root>" in found else []
         ) + sorted(found - {"<root>"})
         return (
-            f" — '{name}' is a REQUIRED property of {', '.join(owners[:3])}, not "
-            f"of {_format_path(path)}; move it there rather than removing it"
+            f" — '{name}' is also required at {', '.join(owners[:3])}; "
+            "a shared name does not establish where this value belongs. "
+            "Check the target field's schema and meaning before moving any value"
         )
 
     def _required_property_owners(self, name: str) -> set[str]:
@@ -495,14 +486,14 @@ def verdict_token_rule(schema: Mapping[str, Any], task_type: str) -> tuple[str,
 
 
 def task_block_rules(schema: Mapping[str, Any], block_key: str) -> tuple[str, ...]:
-    """이 task type 의 데이터 블록(`properties[block_key]`)이 요구하는 모양을 한
+    """최상위 필드(`properties[block_key]`)가 요구하는 모양을 한
     객체당 한 줄의 저작 계약 문장으로 편다.
 
     리드는 report-writer 지시문을 쓸 때 블록 안쪽의 필수 필드·식별자 패턴·
     정수 필드·고정 길이 배열을 알 길이 프롬프트 경로에 없어 스키마 JSON 을
     손으로 파싱했고, 그래도 놓친 만큼 같은 리포트를 다시 썼다(2026-09-03 실측,
     dev-10626 implementation-option-selection: 네 회차). 여기서 뽑아 합성 묶음의
-    저작 계약에 싣는다. 블록이 없거나 객체가 아니면 빈 튜플이다.
+    저작 계약에 싣는다. 필드가 없으면 빈 튜플이다.
 
     경로는 스키마 키다(`rankedOptions[]` 는 `- Item N` 목록의 각 항목). 같은
     정의(`$ref`)가 두 경로에 나오면 두 번째는 첫 경로를 가리킨다 — 랭킹 옵션과
@@ -514,7 +505,16 @@ def task_block_rules(schema: Mapping[str, Any], block_key: str) -> tuple[str, ..
         return ()
     lines: list[str] = []
     described: dict[str, str] = {}
-    _describe_object(root, block, block_key, lines, described)
+    resolved, _ = _resolved(root, block)
+    if resolved.get("type") == "object" or "properties" in resolved:
+        _describe_object(root, block, block_key, lines, described)
+    else:
+        nested: list[tuple[str, Any]] = []
+        constraint = _describe_property(root, block, block_key, nested)
+        if constraint:
+            lines.append(f"`{block_key}`: {constraint}")
+        for child_path, child in nested:
+            _describe_object(root, child, child_path, lines, described)
     return tuple(lines)
 
 

package/runtime/python/okstra_ctl/plan_items_cli.py

@@ -1935,6 +1935,12 @@ def _state_next_dispatch(args: argparse.Namespace) -> NextDispatch:
     data, current, _audit, _history = _round_inputs(args)
     run_manifest = getattr(args, "run_manifest", None)
     payloads = _prepared_payloads(run_manifest)
+    # 실제 목록에서 제외할 항목을 다음 비평 검증으로 요구하면 빈 큐에서 멈춘다.
+    allowed = set(dispatch_item_ids(
+        [payloads.get(item["id"], item) for item in current],
+        data["planBodyVerification"].get("stageLedger"),
+    ))
+    current = [item for item in current if item["id"] in allowed]
     return next_dispatch(
         current, payloads, critic_rostered=_rostered_critic(run_manifest),
         decision_items=(

package/runtime/python/okstra_ctl/report_assembly.py

@@ -594,7 +594,10 @@ def validate_plan_draft(
         *task_narrative_errors(
             draft, load_schema_version("3.0"), str(manifest.get("taskType", "")),
         ),
-        *selected_direction_plan_errors(draft, project_root, manifest),
+        *[
+            f"implementationPlanning: {error}"
+            for error in selected_direction_plan_errors(draft, project_root, manifest)
+        ],
     ]
 
 

package/runtime/python/okstra_ctl/report_corrections.py

@@ -20,7 +20,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Callable, Mapping, Sequence
 
-from .final_report_schema import validate
+from .final_report_schema import task_block_rules, validate
 from .json_boundary import JsonBoundaryError, load_owned_object
 from .report_markdown import humanise
 from .report_narrative import (
@@ -29,6 +29,7 @@ from .report_narrative import (
     render_narrative,
     validate_writer_owned,
     writer_owned_path_defect,
+    writer_owned_schema,
 )
 
 
@@ -204,7 +205,7 @@ def check_corrections(
     3. 경로 해소와 `current` 일치. `rewrite` 는 배열의 `[len]` 추가 위치를 허용한다.
     4. 작성자 소유 경로인가.
     5. replace·remove 를 적용한 사본을 작성자 소유 값 스키마와 task 의미 검증기로
-       대조한다. rewrite 경로 아래의 스키마 결함은 뺀다(작성자가 다시 쓸 자리다).
+       대조한다. rewrite 경로 아래로 특정된 결함은 뺀다(작성자가 다시 쓸 자리다).
     6. rewrite 마다 그 경로의 스키마 제약 문장을 붙인다.
     """
     ledger_dict = dict(ledger)
@@ -279,7 +280,7 @@ def check_corrections(
             continue
         if kind == "rewrite":
             rewrite_paths.append(path)
-            constraints[correction_id] = _constraints_for(path, block_rules)
+            constraints[correction_id] = _constraints_for(path, block_rules, schema)
 
     replacements = [c for c in corrections if c.get("kind") == "replace" and str(c.get("id")) in parsed]
     removals = [c for c in corrections if c.get("kind") == "remove" and str(c.get("id")) in parsed]
@@ -305,15 +306,16 @@ def check_corrections(
     # 회차에 전건을 보게 하려는 것이 이 모듈의 이유다. 결함인 교정은 적용하지
     # 않았으므로 그 자리는 기준 서사의 값 그대로다.
     if scratch is not None:
-        for error in validate_writer_owned(scratch, schema):
-            location = error.split(": ", 1)[0]
+        errors = validate_writer_owned(scratch, schema)
+        if semantic_validator is not None:
+            errors.extend(semantic_validator(scratch))
+        for error in errors:
+            location, separator, _ = error.partition(": ")
+            location = location if separator else "-"
             if any(location == rp or location.startswith(f"{rp}.") or location.startswith(f"{rp}[")
                    for rp in rewrite_paths):
                 continue
             defects.append(_defect("applied", location, error))
-        if semantic_validator is not None:
-            for error in semantic_validator(scratch):
-                defects.append(_defect("applied", "-", str(error)))
 
     mechanical = not defects and not rewrite_paths
     return CorrectionsCheck(
@@ -321,16 +323,22 @@ def check_corrections(
     )
 
 
-def _constraints_for(path: str, block_rules: Sequence[str]) -> tuple[str, ...]:
-    """이 경로(또는 가장 가까운 상위 객체)의 `task_block_rules` 줄."""
+def _constraints_for(
+    path: str, block_rules: Sequence[str], schema: Mapping[str, Any],
+) -> tuple[str, ...]:
+    """가장 가까운 필드의 제약. 공통 필드도 검증에 쓰는 스키마에서 추출한다."""
     normalised = normalise_field_path(path)
+    root_key = str(parse_field_path(path)[0])
+    rules = block_rules
+    if not any(rule.startswith(f"`{root_key}`: ") for rule in rules):
+        rules = task_block_rules(writer_owned_schema(schema), root_key)
     candidates = [normalised]
     while "." in candidates[-1]:
         candidates.append(candidates[-1].rsplit(".", 1)[0])
     for candidate in candidates:
         lines = tuple(
-            rule for rule in block_rules
-            if rule.startswith(f"`{candidate}`: ")
+            rule for rule in rules
+            if rule.startswith(f"`{candidate}`: ") or rule.startswith(f"`{candidate}[]")
         )
         if lines:
             return lines
@@ -423,9 +431,10 @@ def render_corrections_section(
         lines.extend(["", "### Context", "", context.strip()])
     lines.extend([
         "",
-        "Change nothing else: not a sentence, not a score, not an evidence path, not a "
-        "verdict, not the `Human Summary`, and not the blockquote indentation where each "
-        "value line sits two spaces deeper than its own `- **Label**` line.",
+        "Outside the correction paths, preserve every sentence, score, evidence path, "
+        "and verdict. Follow the schema constraints when a correction describes an "
+        "incompatible shape. Preserve the blockquote indentation: each value line "
+        "sits two spaces deeper than its own `- **Label**` line.",
     ])
     return lines
 

package/runtime/python/okstra_ctl/report_finalize.py

@@ -1088,7 +1088,7 @@ def _parser() -> argparse.ArgumentParser:
         "--only",
         action="append",
         default=[],
-        choices=list(STEP_ORDER),
+        choices=list(dict.fromkeys((*STEP_ORDER, *V3_STEP_ORDER))),
         help=(
             "run only these steps (repeatable, contractual order preserved). "
             "Use `--only validate-run` to retry the step that usually fails "

package/runtime/python/okstra_ctl/report_narrative.py

@@ -118,8 +118,8 @@ _MACHINE_OWNED_NESTED = frozenset(
 )
 
 
-def _without_machine_owned_required(node: Any, *, negated: bool = False) -> Any:
-    """`required` 목록에서 기계 소유 필드 이름만 뺀 스키마 사본.
+def _without_machine_owned_fields(node: Any, *, negated: bool = False) -> Any:
+    """기계 소유 필드의 정의와 필수 조건을 뺀 작성자용 스키마 사본.
 
     `not` 아래는 건드리지 않는다. 거기서 `required: [designPreparation]` 은
     "이 필드가 있으면 안 된다" 는 뜻이고 서사에는 원래 없으니 이미 만족한다.
@@ -128,7 +128,7 @@ def _without_machine_owned_required(node: Any, *, negated: bool = False) -> Any:
     뒤집는다. 실제로 `direction-invalidated` 계획 분기가 그렇게 죽었다.
     """
     if isinstance(node, list):
-        return [_without_machine_owned_required(item, negated=negated) for item in node]
+        return [_without_machine_owned_fields(item, negated=negated) for item in node]
     if not isinstance(node, dict):
         return node
     result: dict[str, Any] = {}
@@ -137,8 +137,13 @@ def _without_machine_owned_required(node: Any, *, negated: bool = False) -> Any:
             result[key] = [
                 name for name in value if name not in _MACHINE_OWNED_NESTED
             ]
+        elif key == "properties" and isinstance(value, dict) and not negated:
+            result[key] = {
+                name: _without_machine_owned_fields(field)
+                for name, field in value.items() if name not in _MACHINE_OWNED_NESTED
+            }
         else:
-            result[key] = _without_machine_owned_required(
+            result[key] = _without_machine_owned_fields(
                 value, negated=negated or key == "not"
             )
     return result
@@ -169,8 +174,8 @@ def writer_owned_schema(schema: Mapping[str, Any]) -> dict[str, Any]:
     return {
         "type": "object",
         "additionalProperties": False,
-        "properties": _without_machine_owned_required(properties),
-        "$defs": _without_machine_owned_required(schema.get("$defs", {})),
+        "properties": _without_machine_owned_fields(properties),
+        "$defs": _without_machine_owned_fields(schema.get("$defs", {})),
     }
 
 

package/runtime/python/okstra_ctl/report_projections.py

@@ -21,6 +21,7 @@ _AGENT_LABELS = {
     "antigravity": "Antigravity",
     "grok": "Grok",
     "kimi": "Kimi",
+    "zai": "Z.ai GLM",
 }
 _STATUS = {
     "done": "completed",

package/runtime/python/okstra_ctl/report_synthesis_packet.py

@@ -811,7 +811,7 @@ def _schema_authoring_rules(
         if isinstance(key, str) and key in allowed
     )
     block_key = TASK_TYPE_DATA_PROPERTY.get(task_type, "")
-    block_rules = task_block_rules(schema, block_key) if block_key else ()
+    block_rules = task_block_rules(writer_owned_schema(schema), block_key) if block_key else ()
     return (
         required_top_level,
         verdict_token_rule(schema, task_type),

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

@@ -340,4 +340,8 @@ def confirmation_block(state: WizardState) -> str:
         lines.append(f"  pr-template   : {state.pr_template_path} ({state.pr_template_scope or 'once'})")
     if state.fix_cycle:
         lines.append(f"  fix-cycle     : {state.fix_cycle}")
+    lines.append(_msg(
+        state.workspace_root, "confirmation", "provider_data_scope",
+        project_root=state.project_root,
+    ))
     return "\n".join(lines)

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

@@ -35,7 +35,6 @@ from .ids import (
 from .state import Prompt, WizardError, WizardState, _is_role_selection_step
 from .prompts import _domain_prompt
 from .picker_navigation import (
-    accept_picker_answer,
     is_split_picker,
     merge_split_picker_answer,
     present_picker,
@@ -150,11 +149,8 @@ def _native_picker_screen(state: WizardState, prompt: Prompt) -> Prompt:
     때마다 턴이 하나씩 들었다(실측 2026-09-09, 후보 13개인 critic 화면).
 
     묶음에 못 실리면(옵션 16개 초과, 라벨 중복, 질문 묶음이 없는 세션)
-    단일 선택은 종전대로 쪽으로 나누고(`present_picker`), 체크박스는
-    `CapabilityInteractionPort.plan` 이 `numbered-multi` 로 내려 전체 목록을
-    한 번에 보인다. 체크박스는 쪽으로 나누지 않는다 — 쪽 사본이 추천 표시를
-    단 채 단일 선택이 돼 `Prompt` 의 추천 불변식(단일 선택은 추천 정확히
-    하나)에 걸려 화면이 열리지 않았다(실측 2026-09-09, verifier 전체 후보 화면).
+    `CapabilityInteractionPort.plan` 이 단일 선택은 `numbered-single`,
+    체크박스는 `numbered-multi` 로 내려 전체 목록을 한 번에 보인다.
     """
     if "native_single_select" not in state.available_functions:
         return prompt
@@ -172,7 +168,7 @@ def _native_picker_screen(state: WizardState, prompt: Prompt) -> Prompt:
         return split
     if prompt.multi:
         return prompt
-    return present_picker(state, prompt, limit=port.native_option_limit)
+    return present_picker(prompt)
 
 
 def _next_prompt_screen(state: WizardState) -> Prompt:
@@ -404,13 +400,6 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
         return {"echo": "", "next": prompt_payload(state, prompt)}
     plan = _interaction_plan(state, prompt)
     value = _normalize_interaction_answer(state, prompt, plan, value)
-    if plan.kind == "native-single":
-        original = _next_prompt_screen(state)
-        if original.kind == "pick_group":
-            original = next(q for q in original.questions if q.step == prompt.step)
-        value = accept_picker_answer(state, original, value)
-        if value is None:
-            return {"echo": "", "next": prompt_payload(state, next_prompt(state))}
     if is_split_picker(prompt):
         # 질문 묶음으로 잘린 픽 — 탭별 CSV 를 한 줄로 합쳐 원본 step 의 제출
         # 경로로 보낸다. 원본의 선택지로 검증한다.
@@ -419,8 +408,7 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
     elif prompt.kind == "pick_group":
         return _submit_group(state, prompt, value)
     if _is_role_selection_step(prompt.step):
-        # 고정 단일 역할의 화면은 호스트 한도에 맞춰 쪽으로 잘린 사본일 수
-        # 있다(`present_picker`). 답은 잘리지 않은 원본의 선택지로 검증한다.
+        # 화면의 중복 라벨을 구분했어도 답은 원본 선택지의 값으로 검증한다.
         original = next_role_prompt(state)
         if original is not None and original.step == prompt.step:
             prompt = original

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

@@ -6,20 +6,16 @@
 원래 step 의 제출 경로로 간다. 단일 선택(예: critic 처럼 최대 1개인 역할)도
 같은 방식으로 자르되 통틀어 하나만 고른 답이어야 한다.
 
-그 크기도 넘거나 질문 묶음이 없는 세션이면, 단일 선택은 쪽으로 나누고
-(`present_picker`) 체크박스는 `numbered-multi` 로 전체 목록을 한 번에 보인다
-(`engine._native_picker_screen`). 체크박스를 쪽으로 나누던 경로는 쪽 사본이
-추천 표시를 단 채 단일 선택이 돼 `Prompt` 의 추천 불변식에 걸리므로
-2026-09-09 에 뺐다.
+그 크기도 넘거나 질문 묶음이 없는 세션이면 전체 번호 목록을 한 번에 보인다.
+`present_picker` 는 중복 라벨만 구분하고 선택지 순서와 값을 보존한다.
 """
 import json
 import math
 from dataclasses import replace
 
 from .ids import PICK_TYPE_CUSTOM
-from .state import Option, Prompt, WizardError, WizardState
+from .state import Prompt, WizardError
 
-_PAGE_PREFIX = "__okstra_picker_page__:"
 _SPLIT_SEPARATOR = "#"
 
 
@@ -113,7 +109,7 @@ def merge_split_picker_answer(prompt: Prompt, value: str) -> str:
     return ",".join(chosen)
 
 
-def present_picker(state: WizardState, prompt: Prompt, *, limit: int) -> Prompt:
+def present_picker(prompt: Prompt) -> Prompt:
     if prompt.kind != "pick" or not prompt.options:
         return prompt
     labels = [option.label for option in prompt.options]
@@ -121,33 +117,7 @@ def present_picker(state: WizardState, prompt: Prompt, *, limit: int) -> Prompt:
         option,
         label=option.label + (f" [{option.value}]" if labels.count(option.label) > 1 else ""),
     ) for option in prompt.options]
-    paged = len(options) > limit
-    size = max(1, limit - 1) if paged else len(options)
-    offset = state.picker_offsets.get(prompt.step, 0)
-    offset = offset if 0 <= offset < len(options) else 0
-    shown = options[offset:offset + size]
-    label = prompt.label
-    if paged:
-        next_offset = offset + size if offset + size < len(options) else 0
-        shown.append(Option(
-            f"{_PAGE_PREFIX}{next_offset}",
-            "다음 선택지" if next_offset else "처음 선택지로",
-        ))
-        label += f" ({offset + 1}–{min(offset + size, len(options))}/{len(options)})"
-    if len(shown) == 1:
-        shown.append(Option(f"{_PAGE_PREFIX}0", "다시 보기"))
-    shown = [o for o in shown if o.value != PICK_TYPE_CUSTOM] + [
-        o for o in shown if o.value == PICK_TYPE_CUSTOM
+    options = [o for o in options if o.value != PICK_TYPE_CUSTOM] + [
+        o for o in options if o.value == PICK_TYPE_CUSTOM
     ]
-    return replace(prompt, label=label, options=shown)
-
-
-def accept_picker_answer(state: WizardState, prompt: Prompt, value: str) -> str | None:
-    if value.startswith(_PAGE_PREFIX):
-        raw_offset = value.removeprefix(_PAGE_PREFIX)
-        if not raw_offset.isdecimal() or not 0 <= int(raw_offset) < len(prompt.options):
-            raise WizardError("invalid picker page; select a returned navigation option")
-        state.picker_offsets[prompt.step] = int(raw_offset)
-        return None
-    state.picker_offsets.pop(prompt.step, None)
-    return value
+    return replace(prompt, options=options)

package/runtime/python/okstra_ctl/worker_runner.py

@@ -202,7 +202,7 @@ def _launch(
             stdout=subprocess.PIPE,
             stderr=_stderr_target(strategy),
             start_new_session=True,
-            env=_child_env(),
+            env=_child_env(command.environment),
         )
         on_spawn(process)
         exit_code, timed_out, idle_seconds = _pump(
@@ -604,7 +604,7 @@ def _terminate(process: subprocess.Popen[bytes]) -> None:
         process.wait()
 
 
-def _child_env() -> dict[str, str]:
+def _child_env(overrides: Mapping[str, str | None]) -> dict[str, str]:
     """The worker's environment with git's fsmonitor disabled.
 
     The main worktree's fsmonitor daemon leaks its IPC socket into task
@@ -614,6 +614,11 @@ def _child_env() -> dict[str, str]:
     GIT_CONFIG_* the caller already set.
     """
     env = dict(os.environ)
+    for key, value in overrides.items():
+        if value is None:
+            env.pop(key, None)
+        else:
+            env[key] = value
     index = int(env.get("GIT_CONFIG_COUNT", "0") or "0")
     env[f"GIT_CONFIG_KEY_{index}"] = "core.fsmonitor"
     env[f"GIT_CONFIG_VALUE_{index}"] = "false"

package/runtime/python/okstra_ctl/worktree_status_cli.py

@@ -19,9 +19,8 @@ and stage-integration steps use.
 Use it as the assertion in a plan step:
   okstra worktree-status --check-clean
 
-Do not chain a `git tag stage-<N>-exit` onto it. okstra writes that tag when it
-settles the stage, at the commit the carry evidence records; a step that tags
-while the stage is still running puts it on an earlier commit.
+Do not chain a `git tag stage-<N>-exit` onto it. Stage completion records the
+commit in the consumer ledger without creating or moving git tags.
 
 Output: JSON { ok, path, clean, entries, excluded }. `entries` holds the
 `git status --short` rows that made it dirty; `excluded` lists the paths left

package/runtime/python/okstra_ctl/write_policy.py

@@ -51,6 +51,8 @@ def build_write_policy(
             _relative_paths(invocation.get("protectedPaths", (".okstra", ".git")))
         ),
     }
+    if "plannedPathsDeclared" in invocation:
+        source_policy["plannedPathsDeclared"] = invocation["plannedPathsDeclared"]
     git_policy = _git_policy(invocation, source_root, source_mode)
     external_roots = _validated_auxiliary_roots(invocation, assignment)
     auxiliary_policy = {
@@ -144,18 +146,21 @@ def build_invocation_write_contract(
             )
         )
     )
+    source_root = worktree.resolve() if worktree is not None else root
+    source_paths = _planned_source_paths(
+        planned_paths, root, source_root, relative_artifacts
+    )
     invocation: dict[str, Any] = {
         "role": role,
         "projectRoot": str(root),
         "artifactPaths": list(relative_artifacts),
-        "plannedPaths": list(planned_paths),
+        "plannedPaths": list(source_paths),
         "plannedPathsDeclared": planned_paths_declared,
         "protectedPaths": [".okstra", ".git"],
         "generatedPaths": list(generated_paths),
         "scratchRoots": [str(path) for path in scratch_roots],
         "auxiliaryRoots": [str(path) for path in auxiliary_roots],
     }
-    source_root = worktree.resolve() if worktree is not None else root
     if role == "implementer":
         invocation.update({
             "expectedBaseCommit": _git_output(source_root, "rev-parse", "HEAD"),
@@ -173,6 +178,47 @@ def build_invocation_write_contract(
     return policy, derive_write_enforcement(policy, maximum_precision, role=role)
 
 
+def _planned_source_paths(
+    paths: Sequence[str],
+    project_root: Path,
+    source_root: Path,
+    artifact_paths: Sequence[str],
+) -> tuple[str, ...]:
+    """산출물 권한은 프로젝트에, 소스 변경 목록은 배정 작업 디렉터리에 결속한다."""
+    sources: set[str] = set()
+    for value in paths:
+        candidate = Path(value)
+        if candidate.is_absolute():
+            root = (
+                source_root if candidate.is_relative_to(source_root) else project_root
+            )
+            relative = _relative_to_root(candidate, root, "planned")
+        else:
+            relative = _relative_paths((value,))[0]
+            root = (
+                project_root
+                if PurePosixPath(relative).parts[0] == ".okstra"
+                else source_root
+            )
+            _relative_to_root(root / relative, root, "planned")
+        relative = _relative_paths((relative,))[0]
+        path = PurePosixPath(relative)
+        if path.parts[0] == ".okstra":
+            if root != project_root or not any(
+                path.is_relative_to(allowed) for allowed in artifact_paths
+            ):
+                raise WritePolicyError(
+                    f"planned artifact path exceeds this worker's artifact permissions: {value}"
+                )
+        else:
+            if path.parts[0] == ".git":
+                raise WritePolicyError(f"planned source path is protected: {value}")
+            # 원래 체크아웃의 절대 소스 경로도 실제 쓰기는 배정 작업 디렉터리에 한정된다.
+            _relative_to_root(source_root / relative, source_root, "planned source")
+            sources.add(relative)
+    return tuple(sorted(sources))
+
+
 def task_root_from_run_manifest(
     project_root: Path, manifest: Mapping[str, Any]
 ) -> Path | None:
@@ -191,7 +237,7 @@ def task_root_from_run_manifest(
 
 def planned_paths_from_run_manifest(
     project_root: Path, manifest: Mapping[str, Any]
-) -> tuple[str, ...]:
+) -> tuple[tuple[str, ...], bool]:
     active_value = manifest.get("activeRunContextPath")
     if not isinstance(active_value, str) or not active_value:
         raise WritePolicyError("implementer write policy has no active run context")
@@ -421,7 +467,8 @@ def _planned_paths_from_report(
         if isinstance(path, str) and path.strip()
     }
     if paths:
-        return _relative_paths(tuple(sorted(paths))), True
+        # 경로 분류는 산출물 권한과 배정 작업 디렉터리를 함께 아는 정책 생성기가 맡는다.
+        return tuple(sorted(paths)), True
     # A plan approved before `plannedPaths` existed carries its paths only in
     # the prose `files` cell. That prose does not survive being split into
     # paths — it mis-splits globs and parentheticals — so the ledger stays

package/runtime/python/okstra_token_usage/claude.py

@@ -9,6 +9,7 @@ from pathlib import Path
 
 from .cursor import MAX_NEEDLES, fresh_cache, load_cache, save_cache
 from .paths import claude_project_dir, ts_in_window
+from okstra_ctl.wrapper_status import read_wrapper_status
 
 # lead 의 단계 체크포인트 라인(prompts/lead/okstra-lead-contract.md "Progress reporting") — phase id 가
 # `phase-<digit>` 로 시작하는 라인만 마커로 인정해 일반 대화의 오탐을 줄인다.
@@ -16,6 +17,34 @@ _PROGRESS_RE = re.compile(r"^PROGRESS:\s+(phase-\d\S*(?:[ \t].*)?)$", re.MULTILI
 _PROGRESS_MARKER_MAX_CHARS = 160
 
 
+def claude_code_status_total(status_path: Path) -> dict:
+    """Claude Code의 최종 누적 사용량을 제공자 가격과 분리해서 읽는다."""
+    status = read_wrapper_status(status_path)
+    usage = status.raw.get("usage") if status is not None else None
+    if not isinstance(usage, dict) or not usage:
+        return {"available": False, "totalTokens": 0}
+    attestation = status.raw.get("servedModelAttestation")
+    model = attestation.get("observedModel") if isinstance(attestation, dict) else None
+    input_tokens = usage.get("input_tokens")
+    output_tokens = usage.get("output_tokens")
+    cache_creation = usage.get("cache_creation_input_tokens", 0)
+    cache_read = usage.get("cache_read_input_tokens", 0)
+    if any(
+        not isinstance(value, int) or isinstance(value, bool) or value < 0
+        for value in (input_tokens, output_tokens, cache_creation, cache_read)
+    ):
+        return {"available": False, "totalTokens": 0}
+    return {
+        "available": True,
+        "totalTokens": input_tokens + output_tokens + cache_creation,
+        "inputTokens": input_tokens,
+        "outputTokens": output_tokens,
+        "cacheCreationTokens": cache_creation,
+        "cacheReadTokens": cache_read,
+        "model": model,
+    }
+
+
 def _event_from_record(rec: dict) -> dict | None:
     """jsonl 레코드 1개 → 압축 이벤트. 집계에 기여하지 않으면 None.
 

package/runtime/python/okstra_token_usage/collect.py

@@ -11,6 +11,7 @@ from okstra_project.dirs import OKSTRA_RELATIVE
 
 from .blocks import na_block, usage_block
 from .claude import (
+    claude_code_status_total,
     claude_session_totals,
     find_claude_agent_sessions,
     find_claude_team_sessions,
@@ -662,6 +663,8 @@ def _cli_session_totals(
             )
         elif provider == "grok":
             total = grok_session_total(session_path)
+        elif provider == "zai":
+            total = claude_code_status_total(session_path)
         else:
             continue
         if total.get("available"):
@@ -705,12 +708,15 @@ def _cli_usage_block(provider: str, totals: dict, session_paths: list[Path]) ->
         billable = provider_billable_equivalent(provider, *rates)
         if billable is not None:
             block["billableEquivalentTokens"] = billable
-    else:
+    elif provider == "antigravity":
         cost = antigravity_cost_usd(
             totals.get("model"),
             totals.get("inputTokens", 0) or 0,
             totals.get("outputTokens", 0) or 0,
         )
+    else:
+        cost = None
+        block["cliNote"] = "Token usage recorded; provider billing cost is unavailable."
     if cost is not None:
         block["cliEstimatedCostUsd"] = cost
     return block
@@ -919,6 +925,10 @@ def _worker_cli_usage_block(
             if path not in session_paths:
                 session_paths.append(path)
     status_path = status_paths[-1] if status_paths else None
+    if provider == "zai":
+        session_paths = list(dict.fromkeys(
+            path for path in status_paths if path is not None and path.is_file()
+        ))
     if provider == "antigravity":
         for raw, source_status in zip(prompt_paths, status_paths):
             for source in _antigravity_usage_sources(

package/runtime/schemas/execution-manifest-v2.schema.json

@@ -148,6 +148,7 @@
             "mode": {"enum": ["source-readonly", "project-mutation"]},
             "allowedRoot": {"type": "string", "pattern": "^/"},
             "plannedPaths": {"type": "array", "items": {"type": "string", "pattern": "\\S"}, "uniqueItems": true},
+            "plannedPathsDeclared": {"type": "boolean"},
             "protectedPaths": {"type": "array", "items": {"type": "string", "pattern": "\\S"}, "uniqueItems": true}
           },
           "additionalProperties": false