sortie-dogs 0.13.7 → 0.13.9

package/.agents/skills/sortie-dogs/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: sortie-dogs
+description: Run a task through the installed Sortie-dogs Codex Mission adapter when the user explicitly invokes $sortie-dogs. Preserve the existing Mission ledger and keep OpenCode configuration separate.
+---
+
+# Sortie-dogs
+
+Treat the user's text accompanying `$sortie-dogs` as the Mission request. If no task was supplied, ask for it and stop.
+
+## Boundaries
+
+- Use the reviewed, locally installed `sortie-dogs` package. Never install or update a package, use `@latest`, publish, or switch authentication as part of invocation.
+- Require the existing Codex CLI ChatGPT authentication. Do not use an API key or metered API fallback.
+- Do not run `sortie-dogs init`; that command configures OpenCode. This skill uses only `sortie-dogs codex ...` and never edits `.opencode`.
+- Do not create another ledger. The Codex adapter must reuse Sortie's existing Mission state, protected evidence, and scope leases.
+- After starting a child Mission, observe it; do not edit the same project concurrently from the parent Codex chat.
+- Preserve the user's authority boundaries. Invocation does not authorize push, publication, dependency installation, broader permissions, or unrelated changes.
+
+## Resolve the local entrypoint
+
+Prefer `npx --no-install sortie-dogs` when the current project has the package installed. In the Sortie-dogs source repository itself, use `node dist/cli/main.js` after the repository's normal build when needed. Do not resolve a missing command from the network.
+
+Check the selected entrypoint with `<entrypoint> codex --help` before starting work. If the packaged command lacks `codex mission` and `codex run`, report that the installed candidate is too old.
+
+## Choose one route
+
+On a POSIX host with `/bin/bash`, use the natural-language Mission route:
+
+```text
+<entrypoint> codex mission --project-root <repository-root> --prompt <exact-user-request>
+```
+
+Forward `--model`, `--effort`, or `--permissions` only when the user selected those values. Never silently widen the native permission profile. If an existing Mission is reported, resume only its exact root with `--resume`; do not launch replacement work.
+
+On Windows, use the manifest-bound route until the full Mission shell path supports Windows natively:
+
+1. Read repository instructions and inspect only enough to identify bounded project-relative read scope, write scope, and meaningful validation commands.
+2. Create one temporary manifest under `.sortie-dogs/codex-skill/` with `version`, `task_id`, `read`, `write`, and non-empty `validation`. Reject external or uncertain write scope instead of broadening it.
+3. Resolve the exact PowerShell executable with `(Get-Command pwsh.exe -ErrorAction Stop).Source`. Invoke:
+
+```text
+<entrypoint> codex run --project-root <repository-root> --manifest <temporary-manifest> --prompt <exact-user-request> --trusted-pwsh <resolved-pwsh.exe>
+```
+
+4. Remove only the temporary manifest created by this invocation after the command reaches a terminal result. Preserve `.git/sortie-dogs` evidence and any other state.
+
+If no defensible validation or bounded write scope can be derived, explain the missing contract and stop without starting Codex.
+
+## Completion
+
+Treat only Mission acceptance or manifest settlement `succeeded` with admitted validation evidence as success. A completed native turn, model prose, or validation exit zero without admitted evidence is not completion.
+
+Report the route, terminal status, root/thread identity, validation evidence count, changed paths, and any explicit remaining boundary. Subscription monetary cost is unavailable unless the host supplies it; never fabricate one.

package/.agents/skills/sortie-dogs/agents/openai.yaml

@@ -0,0 +1,6 @@
+interface:
+  display_name: "Sortie-dogs"
+  short_description: "Run a verified Sortie Mission through Codex"
+  default_prompt: "Use $sortie-dogs to execute and verify this task through the existing Mission workflow."
+policy:
+  allow_implicit_invocation: false

package/.agents/skills/sortie-dogs/sortie-dogs.version

@@ -0,0 +1 @@
+0.13.9-codex-skill-v1

package/README.md

@@ -35,10 +35,10 @@ implementation, validation, review, and model routing.
 Guides: [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md) ·
 [Testing](docs/testing.md) · [CLI testing](docs/cli-testing.md)
 
-**Current release: [v0.13.7](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.7)**
-([release notes](docs/release-v0.13.7.md)). The default Mission runtime retains the `v010`
+**Current release: [v0.13.9](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.9)**
+([release notes](docs/release-v0.13.9.md)). The default Mission runtime retains the `v010`
 profile, command and configuration names for compatibility; these names do not mean v0.10 is installed.
-The current asset marker is `0.13.7-review-recovery-v1`.
+The current asset marker is `0.13.9-codex-operation-v1`.
 
 ## SWE-bench Lite: 170/300 (56.67%)
 
@@ -48,7 +48,7 @@ The fixed **Sortie-dogs v0.12.24** harness resolved **170 of 300 SWE-bench Lite
 
 The single official 300-instance report and frozen predictions are hash-bound in the report. Confirmed inference expense was **$162.99**; a separate **$34.60** of usage has unknown pricing and is held against the campaign cap, **not** counted as known expense. Leaderboard registration and maintainer acceptance are separate from this official local evaluation.
 
-Historical scores below belong to their fixed candidates, not v0.13.7. SWE-bench is a separate,
+Historical scores below belong to their fixed candidates, not v0.13.9. SWE-bench is a separate,
 optional measurement rather than a mandatory release gate.
 
 > **Beta:** v0.13.x is still stabilizing. Runtime behavior,
@@ -56,7 +56,203 @@ optional measurement rather than a mandatory release gate.
 
 ## Quick start
 
-Requirements: Node.js 22.6 or newer, npm, and OpenCode V2.
+### Codex host adapter (experimental)
+
+Choose this route for Codex; OpenCode is not required and **do not run `sortie-dogs init` for it**.
+Use Node.js 22.6 or newer and an existing Codex CLI with ChatGPT authentication. Ubuntu validation
+used Node.js 22.22.1 and Codex 0.160.1. Sortie neither installs Codex nor starts a login flow, copies
+credentials, or creates a second host configuration. Mission execution refuses non-ChatGPT auth.
+
+The Codex Mission adapter and explicit skill are included in v0.13.9. Install the release in the
+target project and inspect the entrypoint before running a prompt:
+
+```sh
+npm install --save-dev sortie-dogs@0.13.9
+npx --no-install sortie-dogs codex init .
+npx --no-install sortie-dogs codex mission --help
+```
+
+For an unpublished development candidate, a maintainer with checkout dependencies already present
+can produce a local tarball with `npm pack` (build included) and install that tarball instead.
+This does not publish it. Use the same installed version for the CLI and SDK below.
+`codex init` installs only `.agents/skills/sortie-dogs`; it does not create or edit `.opencode`.
+It refuses to overwrite a skill whose ownership cannot be established.
+
+After restarting Codex or opening the project in a new chat, invoke the installed skill explicitly:
+
+```text
+$sortie-dogs Implement and verify the requested change
+```
+
+`$sortie-dogs` is the current direct Skills syntax. Codex does not expose arbitrary custom commands
+as exact `/sortie-dogs` slash commands; `/skills` opens the skill picker. The skill is intentionally
+explicit-only so child Codex Mission turns cannot invoke another Sortie Mission recursively.
+On POSIX it selects the natural-language Mission route below. On Windows it derives a bounded
+operation manifest and uses `codex run`, which retains the documented post-execution observation
+boundary instead of claiming a pre-execution guard.
+
+Sortie-dogs also exports a host adapter for the official Codex app-server stdio protocol. This is
+separate from selecting an OpenAI model through OpenCode: OpenCode model routing still uses the
+OpenCode host, while `CodexAppServerHost` starts and observes native Codex threads and turns.
+
+```ts
+import { CodexAppServerHost, createCodexAppServerTransport } from "sortie-dogs";
+
+const transport = createCodexAppServerTransport({ executable: "codex" });
+const host = new CodexAppServerHost(transport);
+const threadID = await host.startThread({ cwd: process.cwd(), ephemeral: true });
+const result = await host.runTurn(threadID, "Implement the admitted unit.", {
+  cwd: process.cwd(),
+  approvalPolicy: "unlessTrusted",
+  sandboxPolicy: {
+    type: "workspaceWrite",
+    writableRoots: [process.cwd()],
+    networkAccess: false,
+  },
+});
+await host.close();
+```
+
+The adapter reuses Sortie's host-neutral core instead of copying its goal, acceptance, evidence, or
+ledger implementation. It exposes completed Codex items as authoritative observations, supports
+exact persisted-thread resume and turn interruption (ephemeral threads have no resumable rollout), and declines command/file approvals unless the caller
+provides an approval handler. Permission-subset requests receive an empty grant unless the caller
+connects `permissionsApproval`; approved responses are limited to the native request. Unsupported
+server-initiated requests fail closed.
+
+For the existing Operator → Coordinator → Worker → Reviewer Mission workflow, use:
+
+```sh
+npx --no-install sortie-dogs codex mission --prompt "Implement and review the requested change" --model gpt-6.1-sol --effort medium
+```
+
+The equivalent public SDK entrypoint is:
+
+```ts
+import { CodexMissionSession } from "sortie-dogs";
+
+const mission = await CodexMissionSession.create({
+  projectRoot: process.cwd(),
+  model: "gpt-6.1-sol", // Choose a model available to the existing signed-in account.
+  effort: "medium",
+  // resumeThreadID: "saved-root-thread-id", // Continue the same Mission when needed.
+});
+try {
+  const result = await mission.run("Implement and review the requested change");
+  console.log(JSON.stringify(result));
+  process.exitCode = result.accepted ? 0 : 1;
+} finally {
+  await mission.close();
+}
+```
+
+This Linux-first route uses `CodexMissionSession` and the existing Mission tools, correction grants,
+validation evidence, and final Operator acceptance. It runs saved native Codex threads with existing
+ChatGPT authentication; it does not import OpenCode settings or introduce a second Mission ledger.
+Commands run through `/bin/bash` using the native app-server's configured permissions. Sortie does not
+replace them with a fixed repository-only or network-disabled policy, change host configuration, or select
+full access. Thread turns retain native thread permissions; standalone `command/exec` uses the server's
+configured policy, not a thread's temporary grants. A parent application's in-memory approval is not
+automatically transferred to a separately launched app-server.
+SDK hosts can forward native command/file approval requests through `approval` and permission-subset
+requests through `permissionsApproval`. The native host remains responsible for deciding and enforcing
+the grant. The CLI reports approval requests but has no interactive approval bridge; without a connected
+host callback, no grant is returned. `command/exec` has no thread-scoped approval API, so inheriting the
+configured policy does not add an escalation path for these standalone commands.
+Use SDK `permissions` or CLI `--permissions <native-profile>` only to explicitly select an existing
+native profile for thread start/resume and standalone commands. Omission retains native defaults,
+which may be read-only. Invalid or disallowed profiles fail through the native server without fallback;
+no configuration file is changed. Low-level `CodexAppServerHost` callers must opt into
+`experimentalApi: true` for profile APIs; Mission sessions already negotiate that capability. Progress reports the effective native profile, sandbox and approval
+routing. This selection does not configure a delegated parent-host executor's own permissions.
+See [Ubuntu acceptance evidence and remaining work](docs/codex-mission-acceptance-20261006.md).
+
+For a parent application with an existing approval-aware executor, pass the optional SDK
+`executeCommand` callback. It receives the exact post-hook argv, cwd, timeout, thread/turn/call identity,
+and an AbortSignal for bash/read/write operations. The parent owns approval and execution; Sortie does
+not infer a grant from prompt text or create another permission store. Return `completed` only after
+execution ends, with the real integer exitCode, stdout and stderr. Approval alone is not a result.
+`denied` and `not-started` explicitly mean nothing ran and create no validation exit. `interrupted`,
+`unknown`, exceptions and invalid results retain unknown execution and stop resends. The host owns
+command timeout enforcement; Sortie does not add a separate deadline to its approval interaction.
+Closing the adapter signals cancellation; late callback results cannot establish validation, and the
+host must reconcile any still-running process. Omission keeps native `command/exec`; a connected
+executor never falls back to native execution after rejection or failure. Existing Mission before/after
+hooks, command identity and validation acceptance remain shared. CLI progress identifies the selected
+executor; the CLI itself does not attach a parent executor.
+The bash tool accepts `workdir` (absolute or relative to the project root). The shared hooks and both
+executors use that directory; progress and receipts include the effective cwd. A successful command in
+another directory does not satisfy a validation declared for the project root.
+
+Packaged role models and reasoning levels apply by default. `--model` and `--effort` explicitly
+override all roles; SDK callers can use `roleModels` for individual roles. Unsupported native model
+names fail rather than silently selecting another model. Availability depends on the signed-in account.
+
+Use `--resume <root-thread-id>` to continue a saved Mission root. Without it, a single unfinished Codex
+Mission in this repository is selected automatically; multiple unfinished roots require an explicit
+selection. Resume restores native messages and tool evidence, including child sessions. Completed native
+receipts feed the existing reservation reconciliation without replaying tool execution. A new Task stopped
+before child binding can be recovered when the exact terminal parent thread/turn/call/input matches and
+the prior adapter is closed or its Linux process identity proves it is gone. The host retains that proof in
+the existing Mission and reconciles the reservation before another model prompt; repeated recovery does
+not settle it again. Concurrent recovery claims are serialized.
+
+A newly created ordinary Worker also saves its exact dispatch binding before the child prompt is sent.
+If its parent Task result is lost, recovery can match that binding to the child's single, fully loaded,
+completed native turn. The initial recovery path supports leaf Workers only: later turns, nested Tasks,
+untracked native children, missing bindings and ambiguous identities remain unknown. Recovery restores
+execution completion for the existing settlement path; missing validation evidence is a process defect,
+not an invented PASS. It does not rerun the implementation. Continue with only the work or validation
+still needed for normal Operator acceptance.
+
+SIGINT/SIGTERM closes the adapter and exits 130/143. Bound children without an exact completed dispatch,
+and commands sent without a saved terminal receipt, remain unknown and are not resent. App-server exit
+does not prove an external command has stopped. Linux process-death checks do not prove external writer
+quiescence either; other platforms require a clean adapter close for automatic prelaunch recovery.
+Inspect the original executor before recovery; do not delete Mission state to force a retry.
+Per-session usage is native thread cumulative usage (including earlier turns), not a Mission total;
+monetary cost is unavailable and reported as `null`.
+The existing Mission report uses observed per-turn token deltas and execution times. Cache and reasoning
+subtotals are counted once. Its pre-terminal snapshot excludes final-answer generation, while final JSON
+retains native thread totals. Terminal accounting observations survive cold reload in the existing Mission;
+missing baselines remain unavailable. Native turn aggregates do not establish model-request counts, API
+costs or remaining subscription allowance, so these values are not inferred.
+CLI exit 0 means Operator acceptance; exit 1 means incomplete work or an execution error; exit 2
+means invalid arguments. A native turn completing alone is not acceptance.
+The CLI writes bounded progress records to stderr: tool start/completion, commands and exit codes,
+replan reasons, next actions, child identity, and public model commentary. Final JSON remains on stdout.
+
+For a manifest-bound mission, use the SDK `runCodexMission(...)` or the CLI:
+
+```sh
+sortie-dogs codex run --manifest operation-manifest.json --prompt "Implement the requested change"
+```
+
+The operation manifest remains required. The mission runner reuses Sortie's existing goal ledger,
+protected evidence capture, settlement, and repository-wide scope leases. It does not emulate
+OpenCode plugin hooks, install Codex assets, switch models implicitly, or copy/import/modify OpenCode
+settings and sessions. Codex command and file events are post-execution observations, not a claimed
+pre-execution write guard. The stdio transport is the supported initial integration; experimental
+WebSocket transport is intentionally out of scope.
+
+The manifest-run CLI handles SIGINT/SIGTERM by requesting interruption and cleaning up its
+app-server (exit 130/143). SDK callers can pass an `AbortSignal` as `signal`. Before
+turn dispatch, cancellation settles the reservation and releases its lease. After
+dispatch, app-server exit or an interrupt acknowledgement does not prove that an
+externally hosted command stopped. Cancellation or transport loss therefore preserves
+the active goal/reservation as an unknown outcome and stops lease heartbeats without
+claiming completion. SIGKILL can leave the same unresolved state.
+
+Lease expiry alone does not authorize a retry: subsequent Codex missions refuse with
+`codex-mission-outcome-unknown:no-resend` and the ledger path, including across
+stable/v010 profiles. Inspect the prior worker and ledger before recovery; do not
+delete the ledger or automatically resend the prompt. This is a Codex admission
+check; it does not establish quiescence of external command executors.
+
+### OpenCode plugin
+
+Requirements: Node.js 22.6 or newer, npm, and OpenCode V2. These installation and `init` steps
+configure the OpenCode route; they are not prerequisites for the Codex route above.
 
 Run these commands in the target project:
 
@@ -93,7 +289,29 @@ existing local bridge loads enforcement and model routing. OpenCode can reload w
 but replacing an installed dependency may require a full restart. A new chat session alone does not
 prove the newly installed plugin is loaded.
 
-## v0.13.7 runtime updates
+## v0.13.9 runtime updates
+
+PRs #163–#166 connect native Codex sessions to the existing Mission lifecycle, add the explicit
+`$sortie-dogs` skill and `codex init`, restore operation Reviewer correction within existing write
+scope, and reconcile native terminal observations without reviving completed work from delayed events.
+Codex settings and authentication remain separate from OpenCode. Real Ubuntu Codex acceptance
+evidence and host-specific limits remain in [the acceptance record](docs/codex-mission-acceptance-20261006.md);
+they are not a new all-host or performance benchmark. Release CLI proof observes actual OpenCode
+Worker startup and model identity only, not Mission completion. See [release notes](docs/release-v0.13.9.md).
+
+## v0.13.8 runtime updates
+
+PR #161 captures native validation bindings through the readable resolved target of a Windows
+directory junction instead of enumerating its failing logical alias. Logical evidence labels,
+link identity and complete target bytes remain bound; unchanged readable junctions retain their
+evidence identity. External-link/cycle handling, actual source/output freshness and Review remain
+unchanged. No new approval, permissions or model changes. The PR's isolated native Windows fixture
+reached independent Review PASS and accepted completion after resuming the same Mission, without
+rerunning its successful check; this does not claim original product recovery or uninterrupted
+single-turn completion. Release receipts: `_testenv/releases/0.13.8/`;
+see [release notes](docs/release-v0.13.8.md).
+
+## v0.13.7 runtime updates (retained)
 
 PRs #158/#159 prevent late write-only reports from falsely invalidating bound non-generating
 native checks, while preserving actual source/output freshness, failed checks and legacy recipes.
@@ -436,7 +654,7 @@ register stable and `v010` from the same package installation path in one host.
 Project-local installation is recommended. To expose the current Mission assets globally:
 
 ```sh
-npm install --global sortie-dogs@0.13.7
+npm install --global sortie-dogs@0.13.9
 sortie-dogs init --global --profile v010
 ```
 
@@ -448,7 +666,7 @@ can resolve a **separate dependency** under that config root. Updating npm-globa
 it. For that layout, also install the same release at the actual config root, then rerun global init:
 
 ```sh
-npm install --prefix "$HOME/.config/opencode" sortie-dogs@0.13.7
+npm install --prefix "$HOME/.config/opencode" sortie-dogs@0.13.9
 sortie-dogs init --global --profile v010
 ```
 
@@ -471,7 +689,7 @@ version, preserves user configuration, and stops safely on unknown ownership or
 conflicting files.
 
 Align any exact version pin or separate bridge dependency with the intended release too. An installed
-marker of `0.13.7-review-recovery-v1` identifies the assets; it does not prove an already-running
+marker of `0.13.9-codex-operation-v1` identifies the assets; it does not prove an already-running
 OpenCode process has reloaded the plugin.
 
 There is no supported uninstall command. Remove the npm dependency separately,

package/dist/asset-version.d.ts

@@ -3,5 +3,6 @@
  * installed project marker without importing every asset body.
  */
 export declare const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export declare const V010_RUNTIME_ASSET_VERSION = "0.13.7-review-recovery-v1";
-export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION;
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.9-codex-operation-v1";
+export declare const CODEX_SKILL_ASSET_VERSION = "0.13.9-codex-skill-v1";
+export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION | typeof CODEX_SKILL_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,4 +3,5 @@
  * installed project marker without importing every asset body.
  */
 export const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export const V010_RUNTIME_ASSET_VERSION = "0.13.7-review-recovery-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.9-codex-operation-v1";
+export const CODEX_SKILL_ASSET_VERSION = "0.13.9-codex-skill-v1";

package/dist/cli/codex-mission.d.ts

@@ -0,0 +1,7 @@
+import type { CodexTurnEvent } from "../codex/app-server.js";
+export declare const CODEX_MISSION_USAGE = "Usage: sortie-dogs codex mission --prompt <text>\n  [--resume <root-thread-id>] [--project-root <path>] [--executable <codex>] [--model <model>] [--effort <effort>] [--permissions <native-profile>]\n\nRuns the existing Mission Operator, Coordinator, Worker and Reviewer through Codex.\n--model and --effort explicitly override all roles; otherwise packaged role defaults apply.\n--permissions explicitly selects an existing native profile; omission retains native defaults.\nUses existing ChatGPT authentication and native Codex permissions.";
+export declare function runCodexMissionCommand(argv: readonly string[]): Promise<number>;
+/** Bounded user-facing progress; do not dump control packets or hidden reasoning. */
+export declare function codexMissionProgress(event: CodexTurnEvent & {
+    threadId: string;
+}): Record<string, unknown> | undefined;

package/dist/cli/codex-mission.js

@@ -0,0 +1,118 @@
+import { CodexMissionSession } from "../codex/mission-session.js";
+export const CODEX_MISSION_USAGE = `Usage: sortie-dogs codex mission --prompt <text>
+  [--resume <root-thread-id>] [--project-root <path>] [--executable <codex>] [--model <model>] [--effort <effort>] [--permissions <native-profile>]
+
+Runs the existing Mission Operator, Coordinator, Worker and Reviewer through Codex.
+--model and --effort explicitly override all roles; otherwise packaged role defaults apply.
+--permissions explicitly selects an existing native profile; omission retains native defaults.
+Uses existing ChatGPT authentication and native Codex permissions.`;
+export async function runCodexMissionCommand(argv) {
+    if (argv.length === 1 && argv[0] === "--help") {
+        process.stdout.write(`${CODEX_MISSION_USAGE}\n`);
+        return 0;
+    }
+    const values = new Map();
+    const allowed = new Set(["--prompt", "--resume", "--project-root", "--executable", "--model", "--effort", "--permissions"]);
+    for (let index = 0; index < argv.length; index += 2) {
+        const key = argv[index], value = argv[index + 1];
+        if (!key || !allowed.has(key) || !value || value.startsWith("--") || values.has(key)) {
+            process.stderr.write(`${CODEX_MISSION_USAGE}\n`);
+            return 2;
+        }
+        values.set(key, value);
+    }
+    const prompt = values.get("--prompt");
+    if (!prompt) {
+        process.stderr.write(`${CODEX_MISSION_USAGE}\n`);
+        return 2;
+    }
+    let adapter;
+    let signalExit;
+    const stop = (exit) => { signalExit ??= exit; void adapter?.close().catch(() => undefined); };
+    const onTerm = () => stop(143), onInt = () => stop(130);
+    process.on("SIGTERM", onTerm);
+    process.on("SIGINT", onInt);
+    try {
+        adapter = await CodexMissionSession.create({ projectRoot: values.get("--project-root") ?? process.cwd(),
+            resumeThreadID: values.get("--resume"), permissions: values.get("--permissions"), executable: values.get("--executable"), model: values.get("--model"), effort: values.get("--effort"), onEvent: event => {
+                const progress = codexMissionProgress(event);
+                if (progress)
+                    process.stderr.write(`${JSON.stringify(progress)}\n`);
+            } });
+        if (signalExit)
+            return signalExit;
+        const result = await adapter.run(prompt);
+        process.stdout.write(`${JSON.stringify({ status: result.accepted ? "succeeded" : "incomplete", root_session_id: result.rootSessionID,
+            thread_id: result.turn.threadID, turn_id: result.turn.turnID, native_status: result.turn.status,
+            response: result.turn.finalResponse, sessions: result.sessions, cost: null })}\n`);
+        return signalExit ?? (result.accepted ? 0 : 1);
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : "codex-mission-failed"}\n`);
+        return signalExit ?? 1;
+    }
+    finally {
+        try {
+            await adapter?.close();
+        }
+        finally {
+            process.off("SIGTERM", onTerm);
+            process.off("SIGINT", onInt);
+        }
+    }
+}
+/** Bounded user-facing progress; do not dump control packets or hidden reasoning. */
+export function codexMissionProgress(event) {
+    if (event.method === "sortie/permissions")
+        return { thread_id: event.threadId, phase: "permissions", requested_profile: event.params.requestedProfile,
+            effective_profile: event.params.profile, sandbox: event.params.sandbox, network_access: event.params.networkAccess,
+            approval_policy: event.params.approvalPolicy, approvals_reviewer: event.params.approvalsReviewer,
+            command_executor: event.params.commandExecutor };
+    if (event.method === "sortie/commandExecution")
+        return { thread_id: event.threadId, turn_id: event.params.turnId, call_id: event.params.callId,
+            tool: event.params.tool, executor: event.params.executor, cwd: event.params.cwd, phase: event.params.status,
+            detail: typeof event.params.reason === "string" ? event.params.reason.slice(0, 1600) : undefined };
+    if (["item/commandExecution/requestApproval", "item/fileChange/requestApproval", "item/permissions/requestApproval"].includes(event.method))
+        return { thread_id: event.threadId, turn_id: event.params.turnId, phase: "approval-required", method: event.method,
+            reason: typeof event.params.reason === "string" ? event.params.reason.slice(0, 1600) : undefined,
+            command: typeof event.params.command === "string" ? event.params.command.slice(0, 1600) : undefined,
+            item_id: event.params.itemId, host_approval_available: event.params.hostApprovalAvailable === true,
+            next_action: event.params.hostApprovalAvailable === true ? "Await the host approval decision." :
+                "No host approval callback is connected; this request receives no grant. Use a host-integrated SDK client for approval." };
+    if (!["item/started", "item/completed"].includes(event.method))
+        return;
+    const item = event.params.item;
+    if (event.method === "item/completed" && item?.type === "agentMessage" && item.phase === "commentary" && typeof item.text === "string")
+        return { thread_id: event.threadId, turn_id: event.params.turnId, phase: "commentary", text: item.text.slice(0, 1600) };
+    if (item?.type !== "dynamicToolCall")
+        return;
+    const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+    const bounded = (value) => typeof value === "string" ? value.slice(0, 1600) : undefined;
+    const args = record(item.arguments) ? item.arguments : {};
+    let receipt = {};
+    const contents = Array.isArray(item.contentItems) ? item.contentItems : [];
+    const text = contents.find(part => record(part) && part.type === "inputText")?.text;
+    try {
+        const parsed = JSON.parse(String(text));
+        if (record(parsed))
+            receipt = parsed;
+    }
+    catch { /* Plain native failure. */ }
+    if (typeof receipt.output === "string") {
+        try {
+            const nested = JSON.parse(receipt.output);
+            if (record(nested))
+                receipt = { ...nested, ...receipt };
+        }
+        catch { /* Ordinary command output. */ }
+    }
+    const metadata = record(receipt.metadata) ? receipt.metadata : {};
+    return { thread_id: event.threadId, turn_id: event.params.turnId, tool: item.tool,
+        phase: event.method === "item/started" ? "started" : "completed", status: item.status, success: item.success,
+        command: bounded(args.command), workdir: bounded(args.workdir), cwd: bounded(metadata.cwd), reason: bounded(args.reason),
+        agent: bounded(args.subagent_type), description: bounded(args.description), child_session_id: bounded(metadata.sessionId),
+        outcome: bounded(receipt.status), exit: metadata.exit, executor: metadata.executor,
+        next_action: bounded(receipt.next_action),
+        summary: bounded(args.summary ?? receipt.summary),
+        detail: bounded(receipt.reason ?? receipt.error ?? (item.success === false ? text : undefined)) };
+}

package/dist/cli/main.js

@@ -32,6 +32,19 @@ const USAGE = `Usage: sortie-dogs lint <handoff.json> [<handoff.json> ...]
 const INIT_USAGE = `Usage: sortie-dogs init [project-root] [--profile stable|v010]
        sortie-dogs init --global [--profile stable|v010]
 This beta package defaults to the v010 profile.`;
+const CODEX_USAGE = `Natural-language Mission: sortie-dogs codex mission --prompt <text> (mission --help for options)
+
+Install the direct Codex skill: sortie-dogs codex init [project-root]
+
+Usage: sortie-dogs codex run --manifest <operation-manifest.json> --prompt <text>
+  [--project-root <path>] [--executable <codex>] [--model <model>] [--effort <effort>]
+  [--trusted-pwsh <absolute-pwsh.exe>] [--profile stable|v010]
+
+The operation manifest is required. This command reuses Sortie's goal ledger and
+scope leases; it does not import or modify OpenCode settings or sessions.`;
+const CODEX_INIT_USAGE = `Usage: sortie-dogs codex init [project-root]
+
+Installs the explicit $sortie-dogs skill under .agents/skills without modifying OpenCode settings.`;
 class InputFailure extends Error {
     safeMessage;
     constructor(safeMessage) {
@@ -225,6 +238,89 @@ function render(output, format) {
     return output.map(({ file, pointer, code, severity, message }) => `${file} ${neutralizeTextControlCharacters(pointer || "/")} ${code} ${severity} ${neutralizeTextControlCharacters(message)}\n`).join("");
 }
 export async function run(argv) {
+    if (argv[0] === "codex") {
+        if (argv[1] === "init") {
+            if (argv[2] === "--help" && argv.length === 3) {
+                process.stdout.write(`${CODEX_INIT_USAGE}\n`);
+                return 0;
+            }
+            if (argv.length > 3 || argv[2]?.startsWith("-")) {
+                process.stderr.write(`${CODEX_INIT_USAGE}\n`);
+                return 2;
+            }
+            try {
+                const initialized = await initializer.initializeCodexSkill(argv[2]);
+                process.stdout.write(initialized.status === "installed"
+                    ? `Installed the $sortie-dogs Codex skill (${initialized.version}).\n`
+                    : `The $sortie-dogs Codex skill (${initialized.version}) is already installed.\n`);
+                return 0;
+            }
+            catch (error) {
+                process.stderr.write(`${error instanceof Error ? error.message : "codex-skill-init-failed"}\n`);
+                return 1;
+            }
+        }
+        if (argv[1] === "mission")
+            return (await import("./codex-mission.js")).runCodexMissionCommand(argv.slice(2));
+        if (argv.length === 3 && argv[1] === "run" && argv[2] === "--help") {
+            process.stdout.write(`${CODEX_USAGE}\n`);
+            return 0;
+        }
+        if (argv[1] === "--help" && argv.length === 2) {
+            process.stdout.write(`${CODEX_USAGE}\n`);
+            return 0;
+        }
+        if (argv[1] !== "run") {
+            process.stderr.write(`${CODEX_USAGE}\n`);
+            return 2;
+        }
+        const values = new Map();
+        const allowed = new Set(["--manifest", "--prompt", "--project-root", "--executable", "--model", "--effort", "--trusted-pwsh", "--profile"]);
+        for (let index = 2; index < argv.length; index += 2) {
+            const key = argv[index], value = argv[index + 1];
+            if (!key || !allowed.has(key) || value === undefined || value.startsWith("--") || values.has(key)) {
+                process.stderr.write(`${CODEX_USAGE}\n`);
+                return 2;
+            }
+            values.set(key, value);
+        }
+        const manifest = values.get("--manifest"), prompt = values.get("--prompt"), profile = values.get("--profile") ?? "stable";
+        if (!manifest || !prompt || !["stable", "v010"].includes(profile)) {
+            process.stderr.write(`${CODEX_USAGE}\n`);
+            return 2;
+        }
+        const cancellation = new AbortController();
+        let signalExit;
+        const onTerm = () => { signalExit ??= 143; cancellation.abort(); };
+        const onInt = () => { signalExit ??= 130; cancellation.abort(); };
+        process.on("SIGTERM", onTerm);
+        process.on("SIGINT", onInt);
+        try {
+            const runner = await import("../codex/run-mission.js");
+            const profiles = await import("../core/runtime-profile.js");
+            const result = await runner.runCodexMission({ signal: cancellation.signal, projectRoot: values.get("--project-root") ?? process.cwd(), manifestPath: manifest,
+                prompt, ...(values.get("--executable") ? { executable: values.get("--executable") } : {}),
+                ...(values.get("--model") ? { model: values.get("--model") } : {}),
+                ...(values.get("--effort") ? { effort: values.get("--effort") } : {}),
+                ...(values.get("--trusted-pwsh") ? { trustedPowerShellExecutable: values.get("--trusted-pwsh") } : {}),
+                profile: profile === "stable" ? profiles.STABLE_RUNTIME_PROFILE : profiles.V010_RUNTIME_PROFILE });
+            process.stdout.write(`${JSON.stringify({ status: result.settlement.disposition, root_session_id: result.rootSessionID,
+                thread_id: result.validation.threadID, turn_id: result.validation.turnID, ledger_path: result.ledgerPath,
+                evidence: result.settlement.evidence.length,
+                validation_commands: result.validation.items.filter(item => item.type === "commandExecution").map(item => ({
+                    command: item.command, status: item.status, exit_code: item.exitCode,
+                })) })}\n`);
+            return signalExit ?? (result.settlement.disposition === "succeeded" ? 0 : 1);
+        }
+        catch (error) {
+            process.stderr.write(`${error instanceof Error ? error.message : "codex-mission-failed"}\n`);
+            return signalExit ?? 1;
+        }
+        finally {
+            process.off("SIGTERM", onTerm);
+            process.off("SIGINT", onInt);
+        }
+    }
     if (argv[0] === "init") {
         if (argv[1] === "--help" && argv.length === 2) {
             process.stdout.write(`${INIT_USAGE}\n`);