sortie-dogs 0.13.8 → 0.13.10

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

@@ -0,0 +1,59 @@
+---
+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
+
+Use the natural-language Mission route on POSIX and Windows:
+
+```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.
+
+Leave `--model` unset to retain role-specific defaults: Sol 6.1 Operator/Coordinator/Reviewer and Luna-fast Worker. The Codex adapter maps the shared Luna-fast alias to native `gpt-6-luna` plus the `priority` (Fast) service tier; it does not alter OpenCode defaults. Fast consumes subscription limits faster than Standard; no metered API fallback is allowed.
+
+On Windows the same Mission command resolves existing PowerShell 7 automatically. Add `--trusted-pwsh <absolute-pwsh.exe>` only when an exact existing executable needs to be selected; do not add a separate shell preflight or approval step.
+
+The compatibility tool named `bash` executes PowerShell commands on Windows and POSIX bash on POSIX. Do not supply POSIX commands to the Windows shell. Shell and file commands still use the configured native permissions, or an explicitly integrated host executor. A sandbox startup failure is not a validation failure or success: preserve the failed execution and report the environment blocker; do not widen permissions or stop unrelated Codex processes.
+
+Use the manifest-bound `codex run` route only for an explicitly selected single-task manifest workflow. It is not the full multi-role Mission route:
+
+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. On Windows the manifest workflow needs the exact PowerShell executable for command-envelope observation. Resolve it with `(Get-Command pwsh.exe -ErrorAction Stop).Source`, then 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.10-codex-skill-v2

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.8](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.8)**
-([release notes](docs/release-v0.13.8.md)). The default Mission runtime retains the `v010`
+**Current release: [v0.13.10](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.10)**
+([release notes](docs/release-v0.13.10.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.8-native-binding-v1`.
+The current asset marker is `0.13.10-codex-windows-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.8. SWE-bench is a separate,
+Historical scores below belong to their fixed candidates, not v0.13.10. 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,217 @@ 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.10. Install the release in the
+target project and inspect the entrypoint before running a prompt:
+
+```sh
+npm install --save-dev sortie-dogs@0.13.10
+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 and Windows it selects the natural-language, multi-role Mission route below.
+Windows uses existing PowerShell 7; it does not route natural-language Missions through the
+single-task `codex run` manifest workflow. That workflow remains available when explicitly selected
+and retains its post-execution observation boundary, not 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"
+```
+
+The equivalent public SDK entrypoint is:
+
+```ts
+import { CodexMissionSession } from "sortie-dogs";
+
+const mission = await CodexMissionSession.create({
+  projectRoot: process.cwd(),
+  // Leave model/effort unset to preserve packaged role defaults.
+  // model: "gpt-6.1-sol", effort: "medium", // Explicit override for every role.
+  // trustedPowerShellExecutable: "C:/Program Files/PowerShell/7/pwsh.exe", // Windows, optional.
+  // 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 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` on POSIX or existing `pwsh.exe -NoProfile -NonInteractive -Command`
+on Windows, using the native app-server's configured permissions. The compatibility tool remains
+named `bash`, but its Windows input must be PowerShell syntax. Windows callers can pin an absolute
+PowerShell 7 path with SDK `trustedPowerShellExecutable` or CLI `--trusted-pwsh`.
+Packaged roles retain Sol 6.1/xhigh for Operator, Coordinator and Reviewer. The shared Luna-fast/max
+Worker alias maps only in Codex to native `gpt-6-luna`/max plus `serviceTier: "priority"` (Fast).
+OpenCode routing is unchanged. Fast uses subscription limits faster than Standard; no metered API
+fallback is introduced. CLI progress exposes each role's native model, effort and separate service tier.
+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.
+Windows recovery can reclaim a killed adapter only when its recorded Windows PID is absent.
+A live/reused PID, access denial, legacy owner without platform identity, or unresolved native
+execution remains unknown; no command is replayed. Sandbox startup errors must be resolved at the
+native host, not by silently widening Sortie's permissions or stopping unrelated Codex processes.
+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,6 +303,28 @@ 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.10 runtime updates
+
+PR #169 connects natural-language Windows Codex Missions to the same multi-role lifecycle using
+existing PowerShell 7, preserves command failure exits and native resume settings, and maps the
+Luna-fast Worker alias to native Luna/max with the separate priority tier. Directory reads list
+direct entries instead of requiring filename guesses. OpenCode model settings and native permission
+profiles remain unchanged. PR #168 provides one host-aware Anko runner, reuses unchanged setup,
+removes mandatory paid diagnostic probes, and preserves prior attempts, unknown usage and service
+evidence. Its recorded v0.13.9 Anko completion and PR #169's Windows Codex host-executor completion
+are historical fixed-candidate observations, not new v0.13.10 benchmark or native sandbox results.
+See [release notes](docs/release-v0.13.10.md).
+
+## v0.13.9 runtime updates (retained)
+
+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
@@ -448,7 +680,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.8
+npm install --global sortie-dogs@0.13.10
 sortie-dogs init --global --profile v010
 ```
 
@@ -460,7 +692,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.8
+npm install --prefix "$HOME/.config/opencode" sortie-dogs@0.13.10
 sortie-dogs init --global --profile v010
 ```
 
@@ -483,7 +715,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.8-native-binding-v1` identifies the assets; it does not prove an already-running
+marker of `0.13.10-codex-windows-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.8-native-binding-v1";
-export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION;
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.10-codex-windows-v1";
+export declare const CODEX_SKILL_ASSET_VERSION = "0.13.10-codex-skill-v2";
+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.8-native-binding-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.10-codex-windows-v1";
+export const CODEX_SKILL_ASSET_VERSION = "0.13.10-codex-skill-v2";

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>] [--trusted-pwsh <absolute-pwsh.exe>]\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.\nWindows uses existing PowerShell 7; --trusted-pwsh pins its absolute executable path.\nThe packaged Luna-fast worker maps to native gpt-6-luna with the priority (Fast) service tier.\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,124 @@
+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>] [--trusted-pwsh <absolute-pwsh.exe>]
+
+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.
+Windows uses existing PowerShell 7; --trusted-pwsh pins its absolute executable path.
+The packaged Luna-fast worker maps to native gpt-6-luna with the priority (Fast) service tier.
+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", "--trusted-pwsh"]);
+    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"),
+            trustedPowerShellExecutable: values.get("--trusted-pwsh"), 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/modelRoute")
+        return { thread_id: event.threadId, phase: "model-route", agent: event.params.agent, model: event.params.model,
+            effort: event.params.effort, service_tier: event.params.serviceTier };
+    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`);