okstra 0.186.7 → 0.187.0

package/runtime/python/okstra_ctl/adapters/providers/antigravity/adapter.py

@@ -33,30 +33,28 @@ ANTIGRAVITY = {
         "gemini-3.1-pro", "Gemini 3.1 Pro", "gemini-3.1-pro",
         aliases=("gemini 3.1 pro",),
     ),
-    "gemini-3.6-flash": ModelSpec(
-        "gemini-3.6-flash", "Gemini 3.6 Flash", "gemini-3.6-flash",
-        aliases=("gemini 3.6 flash",),
-    ),
-    "gemini-3.5-flash": ModelSpec(
-        "gemini-3.5-flash", "Gemini 3.5 Flash", "gemini-3.5-flash",
-        aliases=("gemini 3.5 flash",),
+    "gemini-3.7-flash": ModelSpec(
+        "gemini-3.7-flash", "Gemini 3.7 Flash", "gemini-3.7-flash",
+        aliases=("gemini 3.7 flash",),
     ),
 }
 
 
 def _catalog_model_id(observed: str) -> str:
-    """Undo the dispatch-time tier suffix so the id is catalog-comparable.
+    """Undo the tier suffix so the id is catalog-comparable.
 
-    Dispatch sends `gemini-3.1-pro-low`; agy serves that identity back
+    Dispatch sends `gemini-3.1-pro-high`; agy serves that identity back
     verbatim. The catalog holds the bare `gemini-3.1-pro`, so reading the
     observation as-is made the served-model gate reject a model okstra itself
-    had asked for. Only suffixes dispatch can append are stripped, and only
-    when what remains is a catalog entry — anything else passes through for
-    the gate to judge.
+    had asked for. Only agy's tier suffixes are stripped, and only when what
+    remains is a catalog entry — anything else passes through for the gate to
+    judge. The stripped set is agy's tier vocabulary, not the tier this run
+    asked for: a task provisioned before the tier policy changed still reports
+    the tier it was dispatched with, and its gate must keep passing.
     """
     if observed in ANTIGRAVITY:
         return observed  # identity already carries its tier (agy's Claude models)
-    for suffix in model_discovery.dispatch_tier_suffixes():
+    for suffix in model_discovery.agy_tier_suffixes():
         bare = observed.removesuffix(f"-{suffix}")
         if bare != observed and bare in ANTIGRAVITY:
             return bare
@@ -91,6 +89,18 @@ def observe_served_model(event: Mapping[str, Any]) -> str | None:
 # kill a healthy worker mid-run. Idle is the runner's watchdog to enforce.
 _PRINT_TIMEOUT = "7200s"
 
+# 본문 대신 결과 요약을 돌려주는 것으로 실측된 도구. agy 는 `view_file` 을
+# `6 lines, 46 bytes` 로 닫는다 — 파일 내용은 스트림 어디에도 오지 않는다.
+# 실측 2026-08-27, agy 1.1.21 프로브: 이벤트 10건 전량을 훑어 본문 0건이고,
+# `--log-file` 은 language server 로그라 도구 출력을 담지 않는다. 같은 날
+# fontsninja-v3-site 의 antigravity 로그 4개에서 `view_file` 47건 중 47건.
+#
+# 값을 보고 판정하지 않는다 — 요약처럼 생긴 파일 내용은 얼마든지 있다.
+# 판정 근거는 도구 이름이고, 그 이름은 agy 자신이 보낸다. 같은 프로브에서
+# `list_dir` / `grep_search` / `find_by_name` 은 실제 출력을 실어 보냈으므로
+# 이 집합에 넣지 않는다.
+_DESCRIBES_RESULT_TOOLS = frozenset({"view_file"})
+
 _STEP_UPDATE = "step_update"
 _RESULT = "result"
 _CALL_STARTED = "ACTIVE"
@@ -113,13 +123,6 @@ class AntigravityExecutionNormalizer:
         )
 
 
-def normalize_execution(execution: str, role: str) -> str:
-    """Compatibility entry point for direct adapter callers."""
-    return model_discovery.normalize_execution_for_dispatch(
-        provider="antigravity", execution=execution, role=role
-    )
-
-
 def step_update_events(event: Mapping[str, Any]) -> tuple[StreamEvent, ...]:
     """Normalise this CLI's stream-json, which shares no key with the other four.
 
@@ -159,11 +162,26 @@ def _tool_events(step: Mapping[str, Any]) -> tuple[StreamEvent, ...]:
     if step.get("state") != _CALL_FINISHED:
         return ()
     output = str(info.get("output", ""))
+    # `output` 키가 아예 없는 것과 빈 문자열은 다른 사건이다. 실측(2026-08-27,
+    # agy 1.1.21): `write_to_file` 과 `replace_file_content` 는 키를 보내지
+    # 않는다 — 아무것도 보고하지 않은 것이다. 그것을 빈 본문으로 접으면
+    # `← done (0 bytes)` 가 되어, 출력이 없던 명령과 보고 자체가 없던 쓰기가
+    # 같은 줄이 된다.
+    reported_nothing = "output" not in info
     # No outcome field: a `run_command` whose command exited non-zero was
     # measured closing as `DONE` with the failure text in `output` and nothing
     # else to distinguish it, so the outcome is left unreported rather than
-    # rendered as success.
-    return (ToolResult(body=output, size_bytes=len(output.encode("utf-8"))),)
+    # rendered as success. Re-measured 2026-08-27 on agy 1.1.21: still no such
+    # field — a failing `cat` closes `DONE` with the error text in `output`.
+    return (
+        ToolResult(
+            body=output,
+            size_bytes=len(output.encode("utf-8")),
+            body_describes_result=(
+                reported_nothing or name in _DESCRIBES_RESULT_TOOLS
+            ),
+        ),
+    )
 
 
 def _argument(parameters: Any) -> str:

package/runtime/python/okstra_ctl/adapters/providers/claude/adapter.py

@@ -20,50 +20,43 @@ CLAUDE = {
     "fable": ModelSpec(
         "fable", "fable", "fable", version_kind="channel", channel_family="fable"
     ),
+    # picker 에서는 감춘다: fable 채널이 서빙하는 실체와 같은 모델이라
+    # 목록에 두 줄로 뜬다. 엔트리는 남긴다 — served-model 게이트가 관측값
+    # claude-fable-5 를 카탈로그에서 못 찾으면 dispatch 가 실패한다.
     "fable-5": ModelSpec(
         "fable-5", "fable-5", "claude-fable-5", aliases=("claude-fable-5",),
-        channel_family="fable",
+        channel_family="fable", selectable=False,
     ),
     "opus": ModelSpec(
         "opus", "opus", "opus", version_kind="channel", channel_family="opus"
     ),
+    # picker 에서는 감춘다(사유는 fable-5 와 동일).
     "opus-5": ModelSpec(
         "opus-5", "opus-5", "claude-opus-5", aliases=("claude-opus-5",),
-        channel_family="opus",
-    ),
-    "opus-4-8": ModelSpec(
-        "opus-4-8", "opus-4-8", "claude-opus-4-8", aliases=("claude-opus-4-8",),
-        channel_family="opus",
-    ),
-    "opus-4-7": ModelSpec(
-        "opus-4-7", "opus-4-7", "claude-opus-4-7", aliases=("claude-opus-4-7",),
-        channel_family="opus",
-    ),
-    "opus-4-6": ModelSpec(
-        "opus-4-6", "opus-4-6", "claude-opus-4-6", aliases=("claude-opus-4-6",),
-        channel_family="opus",
+        channel_family="opus", selectable=False,
     ),
     "sonnet": ModelSpec(
         "sonnet", "sonnet", "sonnet", version_kind="channel", channel_family="sonnet"
     ),
+    # picker 에서는 감춘다(사유는 fable-5 와 동일).
     "sonnet-5": ModelSpec(
         "sonnet-5", "sonnet-5", "claude-sonnet-5", aliases=("claude-sonnet-5",),
-        channel_family="sonnet",
-    ),
-    "sonnet-4-6": ModelSpec(
-        "sonnet-4-6", "sonnet-4-6", "claude-sonnet-4-6", aliases=("claude-sonnet-4-6",),
-        channel_family="sonnet",
+        channel_family="sonnet", selectable=False,
     ),
     "haiku": ModelSpec(
         "haiku", "haiku", "haiku", version_kind="channel", channel_family="haiku"
     ),
+    # picker 에서는 감춘다(사유는 fable-5 와 동일).
     "haiku-4-5": ModelSpec(
         "haiku-4-5", "haiku-4-5", "claude-haiku-4-5", aliases=("claude-haiku-4-5",),
-        channel_family="haiku",
+        channel_family="haiku", selectable=False,
     ),
+    # 구버전이 아니라 haiku 채널이 실제로 서빙하는 날짜-고정 id 다. 이 엔트리가
+    # 없으면 served-model 게이트가 관측값을 카탈로그에서 못 찾아 dispatch 가
+    # "served model is not in the catalog" 로 실패한다(dispatch_core.py).
     "haiku-4-5-20251001": ModelSpec(
         "haiku-4-5-20251001", "haiku-4-5", "claude-haiku-4-5-20251001",
-        channel_family="haiku",
+        channel_family="haiku", selectable=False,
     ),
 }
 

package/runtime/python/okstra_ctl/adapters/providers/codex/adapter.py

@@ -16,14 +16,19 @@ from okstra_ctl.domain.worker_presentation import SplitText
 import okstra_ctl.model_discovery as model_discovery
 
 
+# Slugs and order follow the provider catalog the codex CLI caches in
+# `~/.codex/models_cache.json` (read 2026-08-26, client 0.150.0): sol / terra /
+# luna are the three visible 5.6 entries, in the priority the provider assigns.
+# `gpt-5.6` is not a slug that catalog offers at all, so it is gone from here;
+# its rate moved to `_LEGACY_CODEX_PRICING` so past runs still price.
 CODEX = {
-    # ChatGPT-account hosts serve this model without per-token billing.
+    # ChatGPT-account hosts serve these models without per-token billing.
     "gpt-5.6-sol": ModelSpec("gpt-5.6-sol", "gpt-5.6-sol", "gpt-5.6-sol"),
-    "gpt-5.6": ModelSpec("gpt-5.6", "gpt-5.6", "gpt-5.6", pricing=(5.00, 0.50, 30.0)),
-    "gpt-5.5": ModelSpec("gpt-5.5", "gpt-5.5", "gpt-5.5", pricing=(5.00, 0.50, 30.0)),
-    "gpt-5.4": ModelSpec("gpt-5.4", "gpt-5.4", "gpt-5.4", aliases=("gpt-5.3-codex",), pricing=(2.50, 0.25, 15.00)),
-    "gpt-5.4-mini": ModelSpec("gpt-5.4-mini", "gpt-5.4-mini", "gpt-5.4-mini", pricing=(0.75, 0.075, 4.50)),
-    "gpt-5.2": ModelSpec("gpt-5.2", "gpt-5.2", "gpt-5.2", pricing=(1.75, 0.175, 14.0)),
+    "gpt-5.6-terra": ModelSpec("gpt-5.6-terra", "gpt-5.6-terra", "gpt-5.6-terra"),
+    "gpt-5.6-luna": ModelSpec("gpt-5.6-luna", "gpt-5.6-luna", "gpt-5.6-luna"),
+    # picker 에서는 감춘다. 엔트리는 남긴다 — 과거 run 의 토큰 사용량을
+    # 정산할 때 pricing 을 이 표에서 찾는다.
+    "gpt-5.4-mini": ModelSpec("gpt-5.4-mini", "gpt-5.4-mini", "gpt-5.4-mini", pricing=(0.75, 0.075, 4.50), selectable=False),
     "codex-auto-review": ModelSpec("codex-auto-review", "codex-auto-review", "codex-auto-review", selectable=False),
 }
 
@@ -52,21 +57,29 @@ class CodexExecutionNormalizer:
         )
 
 
-def normalize_execution(execution: str, role: str) -> str:
-    """Compatibility entry point for direct adapter callers."""
-    return model_discovery.normalize_execution_for_dispatch(
-        provider="codex", execution=execution, role=role
-    )
-
-
 class CodexExecution:
     """codex CLI invocation.
 
-    The sandbox stays `workspace-write` even when the approval gate is opened:
-    removing the gate is not the same as removing the boundary. A non-interactive
-    codex run under the default `on-request` policy blocks on the first approval
-    it wants, and with no TTY to answer it ends the turn with exit 0 and no
-    output — a success that produced nothing.
+    No sandbox bounds this worker, which is what every other provider CLI
+    already does: grok and kimi expose no sandbox flag at all, antigravity's
+    `--sandbox` was measured not to block writes, and the claude CLI applies
+    none. codex was the only worker running behind an enforced boundary, and a
+    boundary carried by one provider out of five decided whether the same task
+    passed by which CLI drew it, not by the code under test.
+
+    The approval gate still has to be open. A non-interactive codex run under
+    the default `on-request` policy blocks on the first approval it wants, and
+    with no TTY to answer it ends the turn with exit 0 and no output — a success
+    that produced nothing.
+
+    `workspace-write` also closed every socket. Measured 2026-08-26 (macOS):
+    under it `socket.bind(("127.0.0.1", 0))`, an outbound `connect`, and an
+    `AF_UNIX` connect all raise `PermissionError [Errno 1]`; outside it all
+    three succeed. A verifier that cannot open a port cannot run the suite, the
+    HTTP contract test, or the DB test its own profile requires, so it returned
+    FAIL for a reason that was never about the code. Dropping the sandbox
+    removes that failure mode at its source, so no per-role network grant is
+    needed any more.
 
     Working directory is the project root even when a stage worktree exists:
     this CLI attaches the worktree with `--add-dir` and runs from the root,
@@ -78,7 +91,7 @@ class CodexExecution:
         for directory in request.policy.write_scope:
             if directory != request.project_root:
                 argv += ["--add-dir", str(directory)]
-        argv += ["--model", request.model, "--sandbox", "workspace-write"]
+        argv += ["--model", request.model, "--sandbox", "danger-full-access"]
         if request.policy.auto_approve:
             argv += ["-c", "approval_policy=never"]
         argv.append("-")
@@ -90,7 +103,11 @@ class CodexExecution:
         )
 
     def policy_support(self) -> PolicySupport:
-        return PolicySupport(can_auto_approve=True, can_bound_write_scope=True)
+        return PolicySupport(
+            can_auto_approve=True,
+            can_bound_write_scope=False,
+            note="this CLI no longer runs behind a sandbox boundary",
+        )
 
 
 def create_provider() -> ProviderSpec:

package/runtime/python/okstra_ctl/adapters/providers/grok/adapter.py

@@ -22,8 +22,8 @@ from okstra_ctl.domain.worker_stream import StreamEvent, Text, ToolCall, ToolRes
 
 GROK = {
     "grok-4.6": ModelSpec("grok-4.6", "grok-4.6", "grok-4.6", pricing=(2.00, 0.50, 6.00)),
-    "grok-4.5": ModelSpec("grok-4.5", "grok-4.5", "grok-4.5", pricing=(2.00, 0.30, 6.00)),
-    "grok-build-0.1": ModelSpec("grok-build-0.1", "grok-build-0.1", "grok-build-0.1", pricing=(1.00, 0.20, 2.00)),
+    # picker 에서는 감춘다(사유는 codex 의 gpt-5.4-mini 와 동일).
+    "grok-build-0.1": ModelSpec("grok-build-0.1", "grok-build-0.1", "grok-build-0.1", pricing=(1.00, 0.20, 2.00), selectable=False),
 }
 
 
@@ -31,8 +31,7 @@ def _catalog_model_id(observed: str) -> str:
     """Undo the `-build` suffix grok reports its served model under.
 
     Measured on grok 1.x: asking for `grok-4.6` closes with
-    `modelUsage: {"grok-4.6-build": ...}`, and `grok-4.5` with
-    `grok-4.5-build`. The catalog holds the requested ids, so reading the
+    `modelUsage: {"grok-4.6-build": ...}`. The catalog holds the requested ids, so reading the
     reported one as-is would fail the served-model gate on the very model
     okstra asked for. A catalog entry that already carries the suffix
     (`grok-build-0.1`) is matched first and left alone.
@@ -110,6 +109,16 @@ def observe_served_model(event: Mapping[str, Any]) -> str | None:
     return None
 
 
+def run_concluded(event: Mapping[str, Any]) -> bool:
+    """이 어휘의 정상 종결 — `end` 이벤트.
+
+    grok 은 Result 이벤트를 내지 않는다. 실측(status 사이드카 100건): 건강한
+    run 71건이 `end.modelUsage` 에서만 나오는 observedModel 을 갖고, result
+    이벤트 없이 exit 0 으로 끝난 실패 run 들에는 `end` 가 없다.
+    """
+    return event.get("type") == "end"
+
+
 def stream_events(event: Mapping[str, Any]) -> tuple[StreamEvent, ...]:
     """grok `--output-format streaming-json` 한 줄을 공통 이벤트로 옮긴다.
 
@@ -150,23 +159,85 @@ def _call_detail(event: Mapping[str, Any]) -> str:
     return str(title) if isinstance(title, str) else ""
 
 
+# `rawOutput` 의 첫 키는 도구 판별자다 — `ReadFile`, `ListDir`, `GrepSearch`.
+# 값 중 첫 문자열을 고르던 동안에는 언제나 이 이름표가 잡혀, 46KB 를 읽은
+# 호출도 로그와 pane 에 `← done (8 bytes)` 한 줄로만 남았다.
+_TOOL_DISCRIMINATOR = "type"
+_FINISHED = ("completed", "failed")
+
+
 def _completed_tool(event: Mapping[str, Any]) -> tuple[StreamEvent, ...]:
-    if event.get("status") != "completed":
+    """끝난 도구 호출 하나를 본문과 성패까지 담아 옮긴다.
+
+    `failed` 를 실제로 읽는다. 상태를 무시하고 `completed` 만 통과시키던
+    동안에는 존재하지 않는 파일을 읽은 호출이 스트림에서 통째로 사라져,
+    워커가 왜 다음 수를 바꿨는지 기록에 남지 않았다(실측 2026-08-26,
+    grok 1.x: 완료 76건 중 `failed` 2건).
+    """
+    status = event.get("status")
+    if status not in _FINISHED:
         return ()
-    body = _output_body(event.get("rawOutput"))
-    return (ToolResult(body=body, size_bytes=len(body.encode("utf-8"))),)
+    body = _finished_body(event)
+    return (
+        ToolResult(
+            body=body,
+            size_bytes=len(body.encode("utf-8")),
+            failed=status == "failed",
+        ),
+    )
+
+
+def _finished_body(event: Mapping[str, Any]) -> str:
+    """이 호출이 실제로 돌려준 것.
+
+    ACP `content` 블록이 정본이다 — 실측한 완료 76건 중 70건이 도구 출력을
+    그대로 담았다. 남은 6건(`list_dir`)은 블록 없이 `rawOutput` 만 보내므로
+    그쪽을 폴백으로 둔다.
+    """
+    blocks = event.get("content")
+    if isinstance(blocks, list):
+        rendered = [text for block in blocks if (text := _content_text(block))]
+        if rendered:
+            return "\n".join(rendered)
+    return _output_body(event.get("rawOutput"))
+
+
+def _content_text(block: Any) -> str:
+    if not isinstance(block, Mapping):
+        return ""
+    kind = block.get("type")
+    if kind == "content":
+        inner = block.get("content")
+        return str(inner.get("text", "")) if isinstance(inner, Mapping) else ""
+    if kind == "diff":
+        # 파일을 고친 호출은 텍스트가 아니라 diff 로 닫는다. 이 호출이 남긴
+        # 것은 새 본문이므로 경로와 함께 그것을 적는다.
+        return f"--- {block.get('path', '')}\n{block.get('newText', '')}"
+    return ""
 
 
 def _output_body(output: Any) -> str:
+    """`rawOutput` 에서 사람이 읽을 것을 꺼낸다.
+
+    판별자 키를 건너뛴 다음, 한 겹 안쪽까지 문자열을 찾는다 — `list_dir` 은
+    `Content.content`, `read_file` 은 `FileContent.content` 에 본문을 둔다.
+    """
     if isinstance(output, str):
         return output
-    if isinstance(output, Mapping):
-        text = next(
-            (str(value) for value in output.values() if isinstance(value, str) and value),
-            "",
-        )
-        return text or json.dumps(output, ensure_ascii=False)
-    return "" if output is None else str(output)
+    if not isinstance(output, Mapping):
+        return "" if output is None else str(output)
+    for key, value in output.items():
+        if key == _TOOL_DISCRIMINATOR:
+            continue
+        if isinstance(value, str) and value:
+            return value
+        if isinstance(value, Mapping):
+            nested = next(
+                (item for item in value.values() if isinstance(item, str) and item), ""
+            )
+            if nested:
+                return nested
+    return json.dumps(output, ensure_ascii=False)
 
 GROK_LEAD_LAUNCH = LeadLaunchSpec(
     executable="grok",
@@ -205,6 +276,7 @@ class GrokExecution:
                 normalise=stream_events,
                 observe=observe_served_model,
                 join_adjacent_text=True,
+                is_conclusion=run_concluded,
             ),
         )
 

package/runtime/python/okstra_ctl/adapters/providers/kimi/adapter.py

@@ -17,11 +17,11 @@ from okstra_ctl.domain.worker_stream import content_block_events
 
 
 KIMI = {
-    "kimi-k2.7-code": ModelSpec("kimi-k2.7-code", "Kimi K2.7 Code", "kimi-k2.7-code", aliases=("kimi k2.7 code",), pricing=(0.95, 0.19, 4.00)),
-    "kimi-for-coding": ModelSpec("kimi-for-coding", "Kimi K2.7 Code", "kimi-for-coding"),
     "kimi-k3": ModelSpec("kimi-k3", "Kimi K3", "kimi-k3", aliases=("kimi k3",), pricing=(3.00, 0.30, 15.00)),
-    "k3": ModelSpec("k3", "Kimi K3", "k3"),
-    "k3-256k": ModelSpec("k3-256k", "Kimi K3 256K", "k3-256k", aliases=("kimi k3 256k",)),
+    # picker 에서는 감춘다: kimi-k3 와 표시명·실체가 같아 목록에 두 줄로 뜬다.
+    "k3": ModelSpec("k3", "Kimi K3", "k3", selectable=False),
+    # picker 에서는 감춘다(사유는 codex 의 gpt-5.4-mini 와 동일).
+    "k3-256k": ModelSpec("k3-256k", "Kimi K3 256K", "k3-256k", aliases=("kimi k3 256k",), selectable=False),
 }
 
 
@@ -93,15 +93,15 @@ def create_provider() -> ProviderSpec:
         display_label="Kimi",
         models=KIMI,
         default_models={
-            "lead": "kimi-k2.7-code",
-            "analyser": "kimi-k2.7-code",
+            "lead": "kimi-k3",
+            "analyser": "kimi-k3",
             "critic": "kimi-k3",
-            "designer": "kimi-k2.7-code",
-            "planner": "kimi-k2.7-code",
-            "executor": "kimi-k2.7-code",
-            "verifier": "kimi-k2.7-code",
-            "report-writer": "kimi-k2.7-code",
-            "translator": "kimi-k2.7-code",
+            "designer": "kimi-k3",
+            "planner": "kimi-k3",
+            "executor": "kimi-k3",
+            "verifier": "kimi-k3",
+            "report-writer": "kimi-k3",
+            "translator": "kimi-k3",
         },
         wrapper="okstra-kimi-exec.sh",
         supported_roles=ALL_ROLE_TOKENS,

package/runtime/python/okstra_ctl/adapters/runtime/cmux.py

@@ -22,17 +22,14 @@ class CmuxRuntime:
         if not workspace:
             reason = cmux.unreachable_reason()
             if reason in (cmux.LOST_ENVIRONMENT, cmux.LOST_DENIED):
-                observed = (
-                    "this process has no cmux environment left — a sandbox sanitized it"
-                    if reason == cmux.LOST_ENVIRONMENT
-                    else "cmux is running but this process may not connect to its socket"
-                )
+                # 두 사유는 처방이 다르고, 그 문구는 prepare 의 강등 거부와
+                # 공유한다 — cmux.unreachable_advice 가 정본이다.
+                observed, remedy = cmux.unreachable_advice(reason)
                 raise EnvironmentBlocked(
                     "this run was prepared for cmux panes, but "
                     f"{observed}. The same sandbox blocks worker CLIs from "
                     "their own config, so falling back to blocking workers "
-                    "would fail too. Relaunch the lead outside a sandbox "
-                    "(use a full-access lead sandbox)."
+                    f"would fail too. {remedy}"
                 )
             raise SurfaceUnavailable("cmux lead workspace is gone")
         try:

package/runtime/python/okstra_ctl/agent/__init__.py

@@ -0,0 +1 @@
+"""에이전트 호출 명세, 프롬프트 CLI, 활동 기록을 모은 패키지."""

package/runtime/python/okstra_ctl/{agent_activity.py → agent/activity.py}

@@ -373,8 +373,19 @@ def _project(args: argparse.Namespace) -> int:
     return 0
 
 
+_CLI_EPILOG = r"""Usage:
+  okstra agent-activity append --project-root <dir> --run-manifest <path> --summary-file <md> [--command <text> --command-cwd <dir> --command-exit-code <n> --command-output-file <md>]
+  okstra agent-activity project --project-root <dir> --run-manifest <path> --data <data.json>  # v2 diagnostic compatibility
+"""
+_CLI_DESCRIPTION = "Record and project structured lead activity."
+
+
 def _parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="okstra agent-activity")
+    parser = argparse.ArgumentParser(
+        description=_CLI_DESCRIPTION,
+        epilog=_CLI_EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        prog="okstra agent-activity")
     subparsers = parser.add_subparsers(dest="command", required=True)
     append_parser = subparsers.add_parser("append")
     append_parser.add_argument("--project-root", type=Path, required=True)

package/runtime/python/okstra_ctl/{agent_invocation.py → agent/invocation.py}

@@ -14,8 +14,8 @@ import re
 import tempfile
 from typing import Iterator, Literal, Mapping, get_args
 
-from .domain.role import RoleCatalogError, role_for_duty
-from .json_boundary import (
+from ..domain.role import RoleCatalogError, role_for_duty
+from ..json_boundary import (
     JsonBoundaryError,
     external_invocation_json_source,
     load_external_json,
@@ -1214,14 +1214,28 @@ def _render_prompt(
     duty: DutyContract,
 ) -> str:
     assignment = request.assignment
+    task_body = request.instruction.body.rstrip("\n")
+    task_declares_model = any(
+        line.strip().startswith("**Model:**") for line in task_body.splitlines()
+    )
     header = [
         *request.instruction.anchor_lines,
         f"**Provider:** {assignment.provider}",
-        f"**Model:** {assignment.model}",
         f"**Model execution value:** {assignment.model_execution_value}",
         f"**Runner:** {assignment.runner}",
         f"**Host runtime:** {assignment.host_runtime}",
     ]
+    if not task_declares_model:
+        header.insert(
+            len(request.instruction.anchor_lines) + 1,
+            # 실행값이다. 카탈로그 id 가 아니다. 두 값은 antigravity 에서만
+            # 갈라진다 — agy 는 tier 를 모델 식별자에 붙여야만 받으므로
+            # `gemini-3.1-pro` 의 실행값은 `gemini-3.1-pro-high` 다. 여기에
+            # 카탈로그 id 를 쓰면 이 헤더만 실제로 돌아가는 모델과 다른 값을
+            # 가리키고, 리드가 이 줄을 읽어 재검증 프롬프트에 옮길 때 그
+            # 어긋남이 다음 라운드로 옮겨 간다.
+            f"**Model:** {assignment.model_execution_value}",
+        )
     # The dispatch prompt contract requires exactly one of these on every prompt
     # it checks, and a critic pass is checked under the same contract as the
     # initial analysis it audits — but only the initial-prompt path emitted one,
@@ -1242,7 +1256,6 @@ def _render_prompt(
     if assignment.host_model_value is not None:
         header.append(f"**Host model value:** {assignment.host_model_value}")
     duty_body = f"{common.body.rstrip()}\n\n{duty.body.rstrip()}"
-    task_body = request.instruction.body.rstrip("\n")
     return (
         "\n".join(header)
         + "\n\n## Duty Contract\n\n"
@@ -1773,7 +1786,6 @@ def _verify_model_header(
     prompt = prompt_bytes.decode("utf-8")
     required = {
         f"**Provider:** {assignment['provider']}",
-        f"**Model:** {assignment['model']}",
         f"**Model execution value:** {assignment['modelExecutionValue']}",
         f"**Runner:** {assignment['runner']}",
         f"**Host runtime:** {assignment['hostRuntime']}",
@@ -1784,6 +1796,23 @@ def _verify_model_header(
     prefix = prompt.split("\n\n## Duty Contract\n\n", 1)[0]
     if not required.issubset(set(prefix.splitlines())):
         return ["prompt model header does not match model assignment"]
+    model_values = [
+        line.split("**Model:**", 1)[1].strip()
+        for line in prompt.splitlines()
+        if line.strip().startswith("**Model:**")
+    ]
+    # 프롬프트의 `**Model:**` 이 싣는 값은 실행값이다. 리드가 지시문에 직접
+    # 쓰는 형식(`**Model:** <role>, <modelExecutionValue>`)도, 지시문에 그 줄이
+    # 없을 때 materialize 가 채우는 형식도 실행값 한 가지다. 카탈로그 id 로
+    # 비교하면 두 값이 같은 provider 에서는 통과하고 antigravity 에서만
+    # 실패하므로, 규칙이 아니라 provider 를 판정하게 된다.
+    expected_model = str(assignment["modelExecutionValue"])
+    if (
+        len(model_values) != 1
+        or not model_values[0]
+        or model_values[0].rsplit(",", 1)[-1].strip() != expected_model
+    ):
+        return ["prompt model header does not match model assignment"]
     return []
 
 

package/runtime/python/okstra_ctl/agent/prompt_cli/__init__.py

@@ -0,0 +1,19 @@
+"""Materialize and verify one auditable LLM invocation specification.
+
+구현은 네 층이다. 바닥의 `inputs`(경로를 믿지 않고 해석한다)와 `emit`(결과를
+내보낸다)은 서로를 모른다. 그 위에 `dynamic_verifier`(추가 검증자 예약)와
+`run_identity`(요청한 신원이 이 run 의 것인가)가 있고, `materialize`(명세를
+만든다)와 `results`(만들어진 명세와 결과를 잇는다)가 그것들을 쓴다. `cli` 는
+argparse 표면과 분기뿐이다.
+
+이 파일은 밖으로 나가는 이름만 모아 둔다.
+"""
+from __future__ import annotations
+
+from .cli import main
+from .inputs import AgentPromptCliError
+
+__all__ = [
+    "AgentPromptCliError",
+    "main",
+]

package/runtime/python/okstra_ctl/agent/prompt_cli/__main__.py

@@ -0,0 +1,11 @@
+"""`python3 -m okstra_ctl.agent.prompt_cli` 진입점.
+
+CLI 레지스트리(`src/cli-registry.mts`)가 이 모듈을 `-m` 으로 띄운다. 단일
+파일이던 시절에는 모듈 본문 끝의 `__name__` 가드가 그 역할을 했고, 패키지가
+되면서 그 자리가 여기로 왔다.
+"""
+from __future__ import annotations
+
+from .cli import main
+
+raise SystemExit(main())