sortie-dogs 0.13.9 → 0.13.11

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

@@ -24,7 +24,7 @@ Check the selected entrypoint with `<entrypoint> codex --help` before starting w
 
 ## Choose one route
 
-On a POSIX host with `/bin/bash`, use the natural-language Mission route:
+Use the natural-language Mission route on POSIX and Windows:
 
 ```text
 <entrypoint> codex mission --project-root <repository-root> --prompt <exact-user-request>
@@ -32,11 +32,17 @@ On a POSIX host with `/bin/bash`, use the natural-language Mission route:
 
 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:
+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. Resolve the exact PowerShell executable with `(Get-Command pwsh.exe -ErrorAction Stop).Source`. Invoke:
+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>

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

@@ -1 +1 @@
-0.13.9-codex-skill-v1
+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.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`
+**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.9-codex-operation-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.9. 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,
@@ -63,11 +63,11 @@ Use Node.js 22.6 or newer and an existing Codex CLI with ChatGPT authentication.
 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
+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.9
+npm install --save-dev sortie-dogs@0.13.10
 npx --no-install sortie-dogs codex init .
 npx --no-install sortie-dogs codex mission --help
 ```
@@ -87,9 +87,10 @@ $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.
+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
@@ -123,7 +124,7 @@ 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
+npx --no-install sortie-dogs codex mission --prompt "Implement and review the requested change"
 ```
 
 The equivalent public SDK entrypoint is:
@@ -133,8 +134,9 @@ 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",
+  // 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 {
@@ -146,14 +148,26 @@ try {
 }
 ```
 
-This Linux-first route uses `CodexMissionSession` and the existing Mission tools, correction grants,
+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` using the native app-server's configured permissions. Sortie does not
+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
@@ -180,6 +194,11 @@ host must reconcile any still-running process. Omission keeps native `command/ex
 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.
+File writes use a short argv referencing a temporary UTF-8 payload, so large files and literal quotes,
+newlines or NUL characters do not overflow Windows command-line limits. Staging does not write the
+project file; the same configured executor performs that write, and the payload is removed afterward.
+Status observations (without `confirmed_conditions`) can return during an active child Task. Condition
+registration and other modifying tools remain serialized; status does not imply Task completion.
 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.
@@ -289,7 +308,19 @@ 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.9 runtime updates
+## 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
@@ -654,7 +685,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.9
+npm install --global sortie-dogs@0.13.10
 sortie-dogs init --global --profile v010
 ```
 
@@ -666,7 +697,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.9
+npm install --prefix "$HOME/.config/opencode" sortie-dogs@0.13.10
 sortie-dogs init --global --profile v010
 ```
 
@@ -689,7 +720,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.9-codex-operation-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,6 +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.9-codex-operation-v1";
-export declare const CODEX_SKILL_ASSET_VERSION = "0.13.9-codex-skill-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.11-operation-result-v1";
+export declare const CODEX_SKILL_ASSET_VERSION = "0.13.11-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,5 +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.9-codex-operation-v1";
-export const CODEX_SKILL_ASSET_VERSION = "0.13.9-codex-skill-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.11-operation-result-v1";
+export const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";

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

@@ -1,5 +1,5 @@
 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 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 & {

package/dist/cli/codex-mission.js

@@ -1,10 +1,12 @@
 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>]
+  [--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") {
@@ -12,7 +14,7 @@ export async function runCodexMissionCommand(argv) {
         return 0;
     }
     const values = new Map();
-    const allowed = new Set(["--prompt", "--resume", "--project-root", "--executable", "--model", "--effort", "--permissions"]);
+    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)) {
@@ -34,7 +36,8 @@ export async function runCodexMissionCommand(argv) {
     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 => {
+            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`);
@@ -63,6 +66,9 @@ export async function runCodexMissionCommand(argv) {
 }
 /** 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,

package/dist/codex/app-server.d.ts

@@ -34,6 +34,8 @@ export interface CodexTurnOptions {
     readonly approvalPolicy?: "untrusted" | "on-failure" | "on-request" | "never" | "unlessTrusted" | "onRequest";
     readonly model?: string;
     readonly effort?: string;
+    /** Native service tier, separate from the model slug (for example priority/Fast). */
+    readonly serviceTier?: string;
     readonly outputSchema?: JsonObject;
     readonly onEvent?: (event: CodexTurnEvent) => void | Promise<void>;
 }
@@ -90,6 +92,8 @@ export declare class CodexAppServerHost {
     private initialized;
     private readonly permissions;
     private readonly models;
+    private readonly serviceTiers;
+    private readonly efforts;
     private closed;
     private closing?;
     private fault?;
@@ -104,6 +108,7 @@ export declare class CodexAppServerHost {
     startThread(params: {
         cwd: string;
         model?: string;
+        serviceTier?: string;
         ephemeral?: boolean;
         permissions?: string;
         developerInstructions?: string;
@@ -111,6 +116,10 @@ export declare class CodexAppServerHost {
         config?: JsonObject;
     }): Promise<string>;
     threadModel(threadID: string): string | undefined;
+    /** Null means the native default was observed; undefined means no observation. */
+    threadServiceTier(threadID: string): string | null | undefined;
+    threadEffort(threadID: string): string | null | undefined;
+    private captureModelSettings;
     threadPermissions(threadID: string): JsonObject | undefined;
     private capturePermissions;
     /** Read only the authentication mode and plan class; never expose tokens or account identifiers. */

package/dist/codex/app-server.js

@@ -76,6 +76,8 @@ export class CodexAppServerHost {
     initialized = false;
     permissions = new Map();
     models = new Map();
+    serviceTiers = new Map();
+    efforts = new Map();
     closed = false;
     closing;
     fault;
@@ -93,7 +95,7 @@ export class CodexAppServerHost {
     async initialize() {
         if (this.initialized)
             return;
-        await this.request("initialize", { clientInfo: { name: "sortie_dogs", title: "Sortie-dogs", version: this.options.clientVersion ?? "0.13.9" },
+        await this.request("initialize", { clientInfo: { name: "sortie_dogs", title: "Sortie-dogs", version: this.options.clientVersion ?? "0.13.10" },
             ...(this.options.dynamicTool || this.options.experimentalApi ? { capabilities: { experimentalApi: true } } : {}) });
         this.transport.send({ method: "initialized", params: {} });
         this.initialized = true;
@@ -102,6 +104,7 @@ export class CodexAppServerHost {
         await this.initialize();
         const result = await this.request("thread/start", { cwd: params.cwd, ...(params.model ? { model: params.model, allowProviderModelFallback: false } : {}),
             ...(params.ephemeral === undefined ? {} : { ephemeral: params.ephemeral }),
+            ...(params.serviceTier ? { serviceTier: params.serviceTier } : {}),
             ...(params.permissions ? { permissions: params.permissions } : {}),
             ...(params.developerInstructions ? { developerInstructions: params.developerInstructions } : {}),
             ...(params.dynamicTools ? { dynamicTools: params.dynamicTools } : {}),
@@ -109,12 +112,28 @@ export class CodexAppServerHost {
         const id = object(result) && object(result.thread) ? text(result.thread.id) : undefined;
         if (!id)
             throw new CodexHostError("protocol-invalid-response", "thread/start returned no thread id.");
-        if (object(result) && typeof result.model === "string")
-            this.models.set(id, result.model);
+        this.captureModelSettings(id, result);
         this.capturePermissions(id, result);
         return id;
     }
     threadModel(threadID) { return this.models.get(threadID); }
+    /** Null means the native default was observed; undefined means no observation. */
+    threadServiceTier(threadID) { return this.serviceTiers.get(threadID); }
+    threadEffort(threadID) { return this.efforts.get(threadID); }
+    captureModelSettings(threadID, result) {
+        if (!object(result))
+            return;
+        if (typeof result.model === "string")
+            this.models.set(threadID, result.model);
+        if (typeof result.serviceTier === "string")
+            this.serviceTiers.set(threadID, result.serviceTier);
+        else if (result.serviceTier === null)
+            this.serviceTiers.set(threadID, null);
+        if (typeof result.reasoningEffort === "string")
+            this.efforts.set(threadID, result.reasoningEffort);
+        else if (result.reasoningEffort === null)
+            this.efforts.set(threadID, null);
+    }
     threadPermissions(threadID) { return this.permissions.get(threadID); }
     capturePermissions(threadID, result) {
         if (!object(result))
@@ -149,6 +168,7 @@ export class CodexAppServerHost {
         const id = object(result) && object(result.thread) ? text(result.thread.id) : undefined;
         if (id !== threadID)
             throw new CodexHostError("protocol-invalid-response", "thread/resume returned a different thread id.");
+        this.captureModelSettings(id, result);
         this.capturePermissions(threadID, result);
     }
     async runTurn(threadID, prompt, options) {
@@ -160,6 +180,7 @@ export class CodexAppServerHost {
             ...(options.sandboxPolicy ? { sandboxPolicy: options.sandboxPolicy } : {}),
             ...(options.approvalPolicy ? { approvalPolicy: options.approvalPolicy } : {}),
             ...(options.model ? { model: options.model } : {}), ...(options.effort ? { effort: options.effort } : {}),
+            ...(options.serviceTier ? { serviceTier: options.serviceTier } : {}),
             ...(options.outputSchema ? { outputSchema: options.outputSchema } : {}) });
         if (this.closed)
             throw new CodexHostError("server-closed", "Codex host was closed.");

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

@@ -34,6 +34,8 @@ export interface CodexMissionSessionOptions {
     }>>;
     readonly effort?: string;
     readonly executable?: string;
+    /** Windows only: existing absolute PowerShell 7 executable; otherwise resolve pwsh.exe on PATH. */
+    readonly trustedPowerShellExecutable?: string;
     readonly transportFactory?: () => CodexAppServerTransport;
     /** Delegate exact post-hook commands to the parent host; omission retains native command/exec. */
     readonly executeCommand?: CodexMissionCommandExecutor;
@@ -46,6 +48,7 @@ export interface CodexMissionSessionOptions {
 /** Native Codex transport for the existing Mission tools, roles and acceptance state. */
 export declare class CodexMissionSession {
     private readonly options;
+    private readonly shell;
     private hooks;
     private readonly sessions;
     private closed;
@@ -56,6 +59,7 @@ export declare class CodexMissionSession {
     private observations;
     private readonly ownedRoots;
     private readonly toolQueues;
+    private readonly observationsInFlight;
     readonly directory: string;
     private constructor();
     static create(options: CodexMissionSessionOptions): Promise<CodexMissionSession>;

package/dist/codex/mission-session.js

@@ -8,10 +8,13 @@ import { V010_RUNTIME_PROFILE as profile } from "../core/runtime-profile.js";
 import { runtimeAssets } from "../runtime-assets-v010.js";
 import { OperatorRuntime } from "../core/operator-runtime.js";
 import { OperatorMissionRuntime, codexProcessOwner, codexOwnerGone } from "../core/operator-mission.js";
+import { resolveCodexMissionShell } from "./mission-shell.js";
+import { prepareCodexWrite } from "./mission-write.js";
 const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 /** Native Codex transport for the existing Mission tools, roles and acceptance state. */
 export class CodexMissionSession {
     options;
+    shell;
     hooks;
     sessions = new Map();
     closed = false;
@@ -22,13 +25,15 @@ export class CodexMissionSession {
     observations = [];
     ownedRoots = new Set();
     toolQueues = new Map();
+    observationsInFlight = new Set();
     directory;
-    constructor(options) {
+    constructor(options, shell) {
         this.options = options;
+        this.shell = shell;
         this.directory = resolve(options.projectRoot);
     }
     static async create(options) {
-        const adapter = new CodexMissionSession(options);
+        const adapter = new CodexMissionSession(options, await resolveCodexMissionShell(options.trustedPowerShellExecutable));
         adapter.owner = await codexProcessOwner();
         const id = (request) => request.path.id;
         const info = (session) => ({ id: session.id, agent: session.agent, parentID: session.parentID,
@@ -77,7 +82,7 @@ export class CodexMissionSession {
     }
     async close() {
         await this.stopHosts();
-        await Promise.allSettled([...this.toolQueues.values()]);
+        await Promise.allSettled([...this.toolQueues.values(), ...this.observationsInFlight]);
         const missions = new OperatorMissionRuntime(this.directory, profile);
         for (const root of this.ownedRoots)
             await missions.codexRecovery(root, async (state) => {
@@ -266,6 +271,15 @@ export class CodexMissionSession {
                 return await this.options.permissionsApproval?.(request) ?? { permissions: {}, scope: "turn" };
             },
             dynamicTool: call => {
+                // Observations must remain available while a Task awaits its child. Status
+                // with confirmed_conditions writes launch conditions and stays serialized.
+                if (call.tool === `${profile.toolPrefix}operator_status` && object(call.arguments) &&
+                    legacyToolArgs(call.arguments, this.hooks.tool?.[call.tool]?.args ?? {}).confirmed_conditions === undefined) {
+                    const observation = this.execute(call);
+                    this.observationsInFlight.add(observation);
+                    void observation.finally(() => this.observationsInFlight.delete(observation)).catch(() => undefined);
+                    return observation;
+                }
                 const execution = (this.toolQueues.get(call.threadId) ?? Promise.resolve()).catch(() => undefined).then(() => this.execute(call));
                 this.toolQueues.set(call.threadId, execution);
                 return execution;
@@ -284,7 +298,13 @@ export class CodexMissionSession {
             throw new Error(`Codex Mission requires an OpenAI model for ${agent}. Set model or roleModels explicitly.`);
         const effort = this.options.roleModels?.[agent]?.effort || this.options.effort || selection?.variant || embeddedEffort ||
             stored?.variant || /^variant: (.+)$/m.exec(header)?.[1];
-        return { providerID: "openai", modelID: model, ...(effort ? { variant: effort } : {}) };
+        // The shared OpenCode alias is not a native Codex model. Keep its speed
+        // selection separate, including after shared Task routing and cold resume.
+        const fast = model === "gpt-6-luna-fast";
+        // A model/effort override does not silently change the independent native speed setting.
+        const serviceTier = fast ? "priority" : stored?.serviceTier;
+        return { providerID: "openai", modelID: fast ? "gpt-6-luna" : model,
+            ...(effort ? { variant: effort } : {}), ...(serviceTier ? { serviceTier } : {}) };
     }
     async reportPermissions(host, threadId) {
         await this.options.onEvent?.({ method: "sortie/permissions", threadId,
@@ -298,25 +318,29 @@ export class CodexMissionSession {
         if (!content)
             throw new Error(`Codex Mission role not supported: ${agent}`);
         const route = this.modelRoute(agent, undefined, selection);
-        const model = route.modelID, effort = route.variant;
+        const model = route.modelID;
         const host = this.createHost();
         try {
             const auth = await host.authenticationState();
             if (auth.type !== "chatgpt")
                 throw new Error("Codex Mission requires existing ChatGPT authentication.");
-            const thread = await host.startThread({ cwd: this.directory, model, ephemeral: false, permissions: this.options.permissions,
+            const thread = await host.startThread({ cwd: this.directory, model, serviceTier: route.serviceTier, ephemeral: false, permissions: this.options.permissions,
                 developerInstructions: content.replace(/^---\n[\s\S]*?\n---\n/, "") +
                     "\nHost transport: use the supplied bash/read/write/task functions and sortie tools. They invoke the existing Mission hooks. " +
                     "Use task to run or resume the returned native Task with its exact prompt and subagent_type. Tool failures are feedback for the same Mission. " +
                     "Native shell and file operations outside these functions do not provide Mission validation evidence. " +
+                    (this.options.executeCommand ? "Native apply_patch still uses the native sandbox, not the configured host executor; use the supplied write function for Mission edits. " : "") +
+                    `The bash function runs ${this.shell.description}; supply commands in that shell's syntax. ` +
                     "Declare formal validation as exact executable shell commands from the project root, without prose annotations such as (workdir: ...). " +
                     "Use a root-relative command or an explicit shell cd for a subdirectory formal check. bash workdir changes that invocation only; " +
                     "a command run in another directory does not validate a root-directory entry.",
                 dynamicTools: this.tools(content), config: { "features.shell_tool": false, "features.unified_exec": false } });
             if (this.closed)
                 throw new Error("Codex Mission adapter is closed.");
+            const serviceTier = host.threadServiceTier(thread) ?? route.serviceTier;
             const session = { id: thread, agent, parentID, outcome: "idle", host, history: [], usageBaseline: emptyCodexUsage(), createdAt: Date.now(),
-                model: { providerID: "openai", modelID: host.threadModel(thread) ?? model, ...(effort ? { variant: effort } : {}) } };
+                model: { ...route, modelID: host.threadModel(thread) ?? model,
+                    ...(serviceTier ? { serviceTier } : {}) } };
             this.sessions.set(thread, session);
             await this.reportPermissions(host, thread);
             return session;
@@ -366,9 +390,16 @@ export class CodexMissionSession {
             }
             await host.resumeThread(id, this.options.permissions);
             await this.reportPermissions(host, id);
+            const nativeModel = host.threadModel(id) ?? (typeof thread.model === "string" ? thread.model : undefined);
+            const observedTier = host.threadServiceTier(id), observedEffort = host.threadEffort(id);
+            // An observed native default is authoritative, not a missing value to fill
+            // from an older thread/read snapshot. Older hosts may omit these fields.
+            const nativeTier = observedTier === undefined ? (typeof thread.serviceTier === "string" ? thread.serviceTier : undefined) : observedTier;
+            const nativeEffort = observedEffort === undefined ? (typeof thread.reasoningEffort === "string" ? thread.reasoningEffort : undefined) : observedEffort;
             const session = { id, agent, parentID, outcome: turns.at(-1)?.status === "completed" ? "succeeded" : "interrupted", host, history: [], createdAt: codexNativeTime(thread.createdAt),
-                model: this.modelRoute(agent, { providerID: String(thread.modelProvider), modelID: typeof thread.model === "string" ? thread.model : "unknown",
-                    ...(typeof thread.reasoningEffort === "string" ? { variant: thread.reasoningEffort } : {}) }) };
+                model: this.modelRoute(agent, nativeModel ? { providerID: String(thread.modelProvider), modelID: nativeModel,
+                    ...(nativeTier ? { serviceTier: nativeTier } : {}),
+                    ...(nativeEffort ? { variant: nativeEffort } : {}) } : undefined) };
             const lastUsage = this.observations.find(item => item.threadID === id && item.turnID === turns.at(-1)?.id && item.terminal);
             session.usageBaseline = codexUsageTotal(lastUsage?.total);
             if (lastUsage?.total)
@@ -421,9 +452,9 @@ export class CodexMissionSession {
             description: tool.description, inputSchema: toolSchema(tool.args) }));
         const define = (name, description, properties, required = Object.keys(properties)) => ({ type: "function", name, description, inputSchema: { type: "object", properties, required, additionalProperties: false } });
         const string = { type: "string" };
-        tools.push(define("bash", "Run a foreground command through the native Codex sandbox. Preserve formal validation commands exactly.", { command: string, workdir: string, timeout: { type: "integer", minimum: 1, maximum: 1200000 } }, ["command"]));
-        tools.push(define("read", "Read a UTF-8 file through the native Codex sandbox.", { filePath: string }));
-        tools.push(define("write", "Write a UTF-8 file through the native Codex sandbox.", { filePath: string, content: string }));
+        tools.push(define("bash", `Run a foreground ${this.shell.description} command through the configured executor. Preserve formal validation commands exactly.`, { command: string, workdir: string, timeout: { type: "integer", minimum: 1, maximum: 1200000 } }, ["command"]));
+        tools.push(define("read", "Read a UTF-8 file or list a directory's direct entries through the configured executor. Read directories to discover filenames instead of guessing them.", { filePath: string }));
+        tools.push(define("write", "Write a UTF-8 file through the configured executor and existing Mission hooks.", { filePath: string, content: string }));
         tools.push(define("task", "Run a returned Mission Task, or resume its existing task_id. Preserve the host's prompt and subagent_type.", { description: string, prompt: string, subagent_type: string, task_id: string, model: string, variant: string }, ["description", "prompt", "subagent_type"]));
         return tools;
     }
@@ -434,10 +465,10 @@ export class CodexMissionSession {
         const parts = [{ type: "text", text: prompt }];
         await this.hooks["chat.message"]?.({ sessionID: session.id, messageID, agent: session.agent }, { message, parts });
         // Shared Task routing may select a model; explicit adapter overrides still govern every native turn.
-        if (this.options.model || this.options.effort || this.options.roleModels?.[session.agent])
-            message.model = this.modelRoute(session.agent, message.model);
         if (message.model.providerID !== "openai")
             throw new Error("Codex Mission cannot use a non-OpenAI model route.");
+        message.model = this.modelRoute(session.agent, { ...message.model,
+            serviceTier: message.model.serviceTier ?? session.model.serviceTier });
         session.model = message.model;
         session.history.push({ info: { ...message, role: "user", sessionID: session.id }, parts });
         session.outcome = "running";
@@ -446,9 +477,13 @@ export class CodexMissionSession {
         const accounting = { info: { ...codexUsageInfo(observation), time: { created: startedAt } }, parts: [] };
         session.history.push(accounting);
         try {
+            await this.options.onEvent?.({ method: "sortie/modelRoute", threadId: session.id,
+                params: { agent: session.agent, model: session.model.modelID, effort: session.model.variant ?? null,
+                    serviceTier: session.model.serviceTier ?? null } });
             await onDispatch?.(messageID);
             const result = await session.host.runTurn(session.id, parts.map(part => part.text).join("\n"), { cwd: this.directory, clientUserMessageId: messageID,
                 model: message.model.modelID === "unknown" ? undefined : message.model.modelID, effort: message.model.variant ?? this.options.effort,
+                serviceTier: message.model.serviceTier,
                 onEvent: event => {
                     if (event.method === "thread/tokenUsage/updated" && object(event.params.tokenUsage)) {
                         observation.turnID = typeof event.params.turnId === "string" ? event.params.turnId : observation.turnID;
@@ -506,6 +541,7 @@ export class CodexMissionSession {
         let dispatched = false;
         let child;
         let metadata;
+        let payload;
         try {
             if (call.tool === "task") {
                 child = typeof args.task_id === "string" && args.task_id ? this.required(args.task_id) : undefined;
@@ -523,9 +559,11 @@ export class CodexMissionSession {
                 metadata = { sessionId: child.id, status: result.status };
             }
             else {
-                const command = call.tool === "bash" ? ["/bin/bash", "-c", String(args.command)]
-                    : call.tool === "read" ? [process.execPath, "-e", "process.stdout.write(require('node:fs').readFileSync(process.argv[1],'utf8'))", resolve(this.directory, String(args.filePath))]
-                        : [process.execPath, "-e", "require('node:fs').writeFileSync(process.argv[1],process.argv[2])", resolve(this.directory, String(args.filePath)), String(args.content)];
+                if (call.tool === "write")
+                    payload = await prepareCodexWrite(resolve(this.directory, String(args.filePath)), String(args.content));
+                const command = call.tool === "bash" ? this.shell.command(String(args.command))
+                    : call.tool === "read" ? [process.execPath, "-e", "const fs=require('node:fs'),p=process.argv[1];process.stdout.write(fs.statSync(p).isDirectory()?fs.readdirSync(p,{withFileTypes:true}).map(e=>e.name+(e.isDirectory()?'/':'')).sort().join('\\n')+'\\n':fs.readFileSync(p,'utf8'))", resolve(this.directory, String(args.filePath))]
+                        : payload.command;
                 const executor = this.options.executeCommand ? "host" : "native";
                 await this.options.onEvent?.({ method: "sortie/commandExecution", threadId: session.id,
                     params: { turnId: call.turnId, callId: call.callId, tool: call.tool, executor, cwd, status: "started" } });
@@ -586,6 +624,16 @@ export class CodexMissionSession {
                 await this.stopHosts().catch(() => undefined);
             throw error;
         }
+        finally {
+            if (payload)
+                await payload.dispose().catch(async (error) => {
+                    try {
+                        await this.options.onEvent?.({ method: "sortie/payloadCleanup", threadId: session.id,
+                            params: { callId: call.callId, status: "failed", reason: String(error) } });
+                    }
+                    catch { /* Cleanup reporting cannot replace the authoritative command outcome. */ }
+                });
+        }
         const time = { start, end: Date.now() };
         metadata.sortie_execution = time;
         session.history.push({ info: { id: call.callId, role: "assistant", sessionID: session.id, codexToolReceipt: true,

package/dist/codex/mission-settlement.js

@@ -12,10 +12,11 @@ const commandText = (item) => {
 const powershellEnvelopePayload = (raw, trustedExecutable) => {
     if (!trustedExecutable)
         return undefined;
-    // Windows Codex 0.160 reports a quoted absolute pwsh.exe plus one single-quoted
+    // Windows Codex 0.160/0.162 reports a quoted absolute pwsh.exe plus one single-quoted
     // -Command payload. It may protocol-escape the boundary quotes/backslashes.
-    // Reject every other shell shape, nested quote, option, and trailing token.
-    const match = /^(?:"|\\")([A-Za-z]:[\\/](?:[^"'\r\n]|\\\\)+[\\/]pwsh\.exe)(?:"|\\") -Command '([^'`\r\n]*)'$/iu.exec(raw);
+    // Only the observed optional -NoProfile flag is admitted. Other options,
+    // nested quotes and trailing tokens remain rejected.
+    const match = /^(?:"|\\")([A-Za-z]:[\\/](?:[^"'\r\n]|\\\\)+[\\/]pwsh\.exe)(?:"|\\") (?:-NoProfile )?-Command '([^'`\r\n]*)'$/iu.exec(raw);
     if (!match)
         return undefined;
     const identity = (value) => value.replaceAll("\\\\", "\\").replaceAll("/", "\\").toLowerCase();

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

@@ -0,0 +1,8 @@
+export interface CodexMissionShell {
+    readonly description: string;
+    command(source: string): readonly string[];
+}
+/** Keep the source literal; only the host-owned exit trailer is appended. */
+export declare function codexPowerShellCommand(executable: string, source: string): readonly string[];
+/** Resolve the existing host shell, without installation or permission changes. */
+export declare function resolveCodexMissionShell(trustedPowerShellExecutable?: string): Promise<CodexMissionShell>;

package/dist/codex/mission-shell.js

@@ -0,0 +1,22 @@
+import { basename, isAbsolute } from "node:path";
+import { stat } from "node:fs/promises";
+import { resolveValidationExecutable } from "../core/worktree-commit-artifact.js";
+/** Keep the source literal; only the host-owned exit trailer is appended. */
+export function codexPowerShellCommand(executable, source) {
+    return [executable, "-NoProfile", "-NonInteractive", "-Command", source +
+            "\nif (-not $?) { if ($LASTEXITCODE) { exit $LASTEXITCODE }; exit 1 }"];
+}
+/** Resolve the existing host shell, without installation or permission changes. */
+export async function resolveCodexMissionShell(trustedPowerShellExecutable) {
+    if (process.platform !== "win32") {
+        if (trustedPowerShellExecutable)
+            throw new Error("--trusted-pwsh is only supported on Windows.");
+        return { description: "POSIX bash", command: source => ["/bin/bash", "-c", source] };
+    }
+    if (trustedPowerShellExecutable && (!isAbsolute(trustedPowerShellExecutable) || basename(trustedPowerShellExecutable).toLowerCase() !== "pwsh.exe"))
+        throw new Error("Codex Mission requires an absolute existing pwsh.exe path.");
+    const executable = await resolveValidationExecutable(trustedPowerShellExecutable ?? "pwsh.exe");
+    if (!executable || !(await stat(executable)).isFile())
+        throw new Error("Codex Mission requires existing PowerShell 7 (pwsh.exe). Select it with --trusted-pwsh; no shell is installed automatically.");
+    return { description: "Windows PowerShell 7 (not POSIX bash)", command: source => codexPowerShellCommand(executable, source) };
+}

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

@@ -0,0 +1,5 @@
+/** Stage transport data only. The configured executor still performs the project write. */
+export declare function prepareCodexWrite(filePath: string, content: string): Promise<{
+    command: readonly string[];
+    dispose: () => Promise<void>;
+}>;

package/dist/codex/mission-write.js

@@ -0,0 +1,13 @@
+import { randomUUID } from "node:crypto";
+import { writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/** Stage transport data only. The configured executor still performs the project write. */
+export async function prepareCodexWrite(filePath, content) {
+    const payload = join(tmpdir(), `sortie-codex-write-${randomUUID()}`);
+    await writeFile(payload, content, { encoding: "utf8", flag: "wx" });
+    return {
+        command: [process.execPath, "-e", "const fs=require('node:fs');fs.writeFileSync(process.argv[1],fs.readFileSync(process.argv[2]))", filePath, payload],
+        dispose: () => rm(payload, { force: true }),
+    };
+}

package/dist/core/operator-mission.d.ts

@@ -165,6 +165,7 @@ export interface CodexMissionOwner {
     startTicks?: string;
     generation: string;
     closed?: boolean;
+    platform?: NodeJS.Platform;
 }
 export declare function codexProcessOwner(): Promise<CodexMissionOwner>;
 export declare function codexOwnerGone(owner: CodexMissionOwner | undefined): Promise<boolean>;
@@ -300,6 +301,11 @@ export declare function missionReviewAccepted(review: NonNullable<OperatorMissio
 /** A short native report, not a tag/hash-based second-review policy or an approval checklist. */
 export declare function missionSelfRecheckReport(text: string, source: string, hostBound?: boolean): Pick<MissionSelfRecheck, "unresolvedFindings" | "residualMajor"> | undefined;
 export declare function missionExecutionStatus(mission: OperatorMission): "not-required" | "not-started" | "running" | "execution-failed" | "executed";
+/** A terminal failure is a collected result, not a successful operation. Required success
+ * remains in the declared formal checks and Operator's original-request comparison. */
+export declare function missionExecutionComplete(mission: OperatorMission): boolean;
+/** Projection of existing observations only; never another check or inferred success. */
+export declare function missionOperationSummary(mission: OperatorMission): Record<string, unknown>;
 /** Observe the command's own terminal summary, never Worker/Reviewer prose. Scores are result data,
  * not process success. Unstructured commands retain their native exit semantics. */
 export declare function missionCommandOutcome(output: unknown, exit: unknown, status: unknown): {

package/dist/core/operator-mission.js

@@ -27,7 +27,7 @@ async function codexProcessStart(pid) {
     return ticks;
 }
 export async function codexProcessOwner() {
-    const owner = { pid: process.pid, generation: randomUUID() };
+    const owner = { pid: process.pid, generation: randomUUID(), platform: process.platform };
     if (process.platform === "linux") {
         owner.bootID = (await readFile("/proc/sys/kernel/random/boot_id", "utf8")).trim();
         owner.startTicks = await codexProcessStart(process.pid);
@@ -39,7 +39,20 @@ export async function codexOwnerGone(owner) {
         return false;
     if (owner.closed)
         return true;
-    if (process.platform !== "linux" || !owner.bootID || !owner.startTicks || !Number.isSafeInteger(owner.pid) || owner.pid < 1)
+    if (!Number.isSafeInteger(owner.pid) || owner.pid < 1 || owner.platform && owner.platform !== process.platform)
+        return false;
+    if (process.platform === "win32" && owner.platform === "win32") {
+        // Windows has no /proc identity. Only an absent PID proves this owner gone;
+        // PID reuse, access denial and legacy/unidentified owners stay unresolved.
+        try {
+            process.kill(owner.pid, 0);
+            return false;
+        }
+        catch (error) {
+            return error.code === "ESRCH";
+        }
+    }
+    if (process.platform !== "linux" || !owner.bootID || !owner.startTicks)
         return false;
     try {
         if ((await readFile("/proc/sys/kernel/random/boot_id", "utf8")).trim() !== owner.bootID)
@@ -103,14 +116,28 @@ export function missionExecutionStatus(mission) {
     if (mission.kind !== "operation")
         return "not-required";
     const execution = mission.execution;
-    if (!execution || execution.observations.length === 0)
+    if (!execution || execution.commands.length === 0 || execution.observations.length === 0)
         return "not-started";
     const latest = execution.commands.map(command => [...execution.observations].reverse().find(item => item.command === command && item.directory === execution.directory));
     if (latest.some(item => item && !item.completedAt))
         return "running";
+    if (latest.some(item => !item || !["executed", "execution-failed"].includes(item.outcome ?? "")))
+        return "not-started";
     if (latest.some(item => item?.outcome === "execution-failed" || (item && (item.status === "error" || item.exit !== 0))))
         return "execution-failed";
-    return latest.every(item => item?.outcome === "executed") ? "executed" : "not-started";
+    return "executed";
+}
+/** A terminal failure is a collected result, not a successful operation. Required success
+ * remains in the declared formal checks and Operator's original-request comparison. */
+export function missionExecutionComplete(mission) {
+    return ["not-required", "executed", "execution-failed"].includes(missionExecutionStatus(mission));
+}
+/** Projection of existing observations only; never another check or inferred success. */
+export function missionOperationSummary(mission) {
+    const status = missionExecutionStatus(mission);
+    return { kind: mission.kind ?? "implementation", status, terminal_complete: missionExecutionComplete(mission),
+        process_succeeded: status === "executed" ? true : status === "execution-failed" ? false : null,
+        ...(mission.execution ? { ...mission.execution } : {}) };
 }
 /** Observe the command's own terminal summary, never Worker/Reviewer prose. Scores are result data,
  * not process success. Unstructured commands retain their native exit semantics. */
@@ -267,7 +294,7 @@ export class OperatorMissionRuntime {
     async codexRecovery(root, action) {
         const lock = `${this.file(root)}.codex-recovery.lock`;
         const owner = await codexProcessOwner();
-        const marker = `owner.${owner.pid}.${owner.bootID ?? "unknown"}.${owner.startTicks ?? "unknown"}.${owner.generation}`;
+        const marker = `owner.${owner.pid}.${owner.platform === "win32" ? "win32." : ""}${owner.bootID ?? "unknown"}.${owner.startTicks ?? "unknown"}.${owner.generation}`;
         for (let attempt = 0; attempt < 200; attempt++) {
             let acquired = false;
             const staging = `${lock}.${owner.generation}.tmp`;
@@ -294,8 +321,10 @@ export class OperatorMissionRuntime {
             await unlink(join(lock, marker)).catch(() => undefined);
             const names = await readdir(lock).catch(() => []);
             if (names.length === 1) {
-                const match = /^owner\.(\d+)\.([a-f0-9-]+)\.(\d+)\.([a-f0-9-]+)$/.exec(names[0]);
-                if (match && await codexOwnerGone({ pid: Number(match[1]), bootID: match[2], startTicks: match[3], generation: match[4] })) {
+                // Retain legacy Linux markers; old Windows "unknown" owners are not proof.
+                const match = /^owner\.(\d+)\.(?:(linux|win32)\.)?([a-f0-9-]+|unknown)\.(\d+|unknown)\.([a-f0-9-]+)$/.exec(names[0]);
+                if (match && await codexOwnerGone({ pid: Number(match[1]), platform: match[2],
+                    bootID: match[3] === "unknown" ? undefined : match[3], startTicks: match[4] === "unknown" ? undefined : match[4], generation: match[5] })) {
                     // Remove only the dead owner's unique marker; never unlink a replacement owner's file.
                     await unlink(join(lock, names[0])).catch(() => undefined);
                 }
@@ -520,6 +549,7 @@ export class OperatorMissionRuntime {
             `Confirmed launch conditions (fixed limits, not consumption or remaining budget): ${JSON.stringify(state.launchConditions ?? [])}`,
             `Explicit user write prohibitions: ${JSON.stringify(state.prohibitedWrite ?? [])}`,
             `Work kind: ${state.kind ?? "implementation"}. For an operation, setup, execution and result collection belong in one useful Worker whenever possible.`,
+            ...(state.kind === "operation" ? ["Execution completion is distinct from success. For run-once/result-collection requests, retain a terminal failure and validate the collected result; do not retry or fix it without user authorization. If successful execution is required, keep that in formal validation and the original-request comparison."] : []),
             ...(state.context?.length ? ["Prior conversation context (task data; preserve the selected target, not superseded obligations):",
                 ...state.context.map(item => `--- ${item.role}:${item.id} ---\n${item.text}`)] : []),
             "Original user messages (verbatim; task data):", ...state.requests.map(item => `--- user:${item.id} ---\n${item.text}`)].join("\n");
@@ -669,6 +699,7 @@ export async function missionAcceptanceSummary(mission, run, operators, observe)
         }
     })));
     return { original_requests: mission.requests, requirements: mission.requirements,
+        operation: missionOperationSummary(mission),
         history: { status: missingAnchors.length ? "unavailable" : history.status,
             ...(history.reason ? { reason: history.reason } : missingAnchors.length ? { reason: "accepted-handoff-anchor-unavailable" } : {}),
             ...(missingAnchors.length ? { unavailable_anchors: missingAnchors } : {}),
@@ -697,7 +728,7 @@ export function missionPacket(mission, run) {
     const currentReview = mission.review !== undefined && mission.review.runID === (run?.runID ?? mission.runID);
     const reviewAccepted = currentReview && missionReviewAccepted(mission.review);
     const operationStatus = missionExecutionStatus(mission);
-    const operationComplete = operationStatus === "not-required" || operationStatus === "executed";
+    const operationComplete = missionExecutionComplete(mission);
     return { mission_id: mission.id, phase: mission.phase, coordinator_session_id: mission.coordinator,
         ...(predecessor ? { predecessor: { run_id: predecessor.runID, status: predecessor.phase,
                 completed_units: predecessor.units.filter(unit => unit.status === "succeeded").length,
@@ -708,8 +739,7 @@ export function missionPacket(mission, run) {
         delivery_observation: mission.deliveryObservation?.run_id === (run?.runID ?? mission.runID) ? mission.deliveryObservation : null,
         submission: mission.submission, progress: mission.progress, consultations: mission.consultations ?? [],
         attempts: mission.attempts ?? [], corrections: (mission.corrections ?? []).map(({ findings: _findings, initialPrompt: _prompt, ...item }) => item), ...(mission.rescue ? { rescue: mission.rescue } : {}),
-        operation: { kind: mission.kind ?? "implementation", status: missionExecutionStatus(mission),
-            ...(mission.execution ? { ...mission.execution } : {}) },
+        operation: missionOperationSummary(mission),
         execution_summary: { completed_units: run?.units.filter(unit => unit.status === "succeeded").length ?? 0,
             running_units: run?.units.filter(unit => unit.status === "running").map(unit => ({ id: unit.unit.id, title: unit.unit.title, child_session_id: unit.childSessionID })) ?? [],
             pending_units: run?.units.filter(unit => unit.status === "pending").length ?? 0,

package/dist/plugin/profiled.js

@@ -13,7 +13,7 @@ import { decoratePreviewHeadings, returnReportPanel } from "./receipt-presentati
 import { sanitizeTerminalReport, terminalRunOutcome } from "./run-metrics.js";
 import { normalizeCommand, canonicalDeclaredValidationMembers, extractWritePaths } from "./gate.js";
 import { normalizeExecutionScope, normalizeManifestScope, normalizeRelativePath } from "../core/path.js";
-import { OperatorMissionRuntime, missionAcceptanceSummary, missionPacket, missionPlan, missionReviewAccepted, missionReviewIndependent, missionReviewScope, missionReviewTask, missionCommandOutcome, missionConversationContext, missionExecutionStatus, missionValidationCommand, missionReviewTraces, missionReviewVerdict, missionSelfRecheckReport } from "../core/operator-mission.js";
+import { OperatorMissionRuntime, missionAcceptanceSummary, missionPacket, missionPlan, missionReviewAccepted, missionReviewIndependent, missionReviewScope, missionReviewTask, missionCommandOutcome, missionConversationContext, missionExecutionComplete, missionExecutionStatus, missionOperationSummary, missionValidationCommand, missionReviewTraces, missionReviewVerdict, missionSelfRecheckReport } from "../core/operator-mission.js";
 import { publishMissionProgress } from "./mission-progress.js";
 import { completedMissionReviewPrompts, initialMissionReviewPrompt, missionDeliveryObservation, missionReviewBaseline, missionReviewSource, observedMissionValidation, observedMissionValidationSummary, missionReviewValidation, reviewerCorrectionValidation, reviewerCorrectionValidationFresh, validationDirectoryMatches } from "./mission-review.js";
 import { missionLocations, missionLocationPacket } from "./mission-location.js";
@@ -983,6 +983,12 @@ export function createProfiledPlugin(profile, assetVersion) {
             taskOwners.delete(mission.callID);
             return reconciled;
         }
+        function withMissionOperationOutcome(text, mission) {
+            if (!mission || missionExecutionStatus(mission) !== "execution-failed" || terminalRunOutcome(text) !== "DONE")
+                return text;
+            const detail = "Operation result: execution-failed (result accepted; process did not succeed).";
+            return text.includes(detail) ? text : text.replace(/^((?:[ \t]*\r?\n)*[^\r\n]+)/u, `$1 ${detail}`);
+        }
         function missionDispatchPacket(mission, run) {
             const packet = { ...missionPacket(mission, run), project_root: input.directory,
                 coordinator_dispatch: mission.dispatchOpen ? "active" : ["completed", "cancelled"].includes(mission.phase) ? "terminal" : "resumable" };
@@ -1006,7 +1012,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     next_action: "Fast-lane: plan one useful Worker unit with the meaningful formal check known from user, project or task context and estimated scope, then dispatch its Task immediately. Investigation/edit/check/requested commit belong inside Worker before independent Review. Objective: target 2000 characters; original requests are supplied separately. Use Coordinator for an unknown check or real unit decomposition." };
             }
             if (mission.coordinator === null && mission.runID === run?.runID && !mission.dispatchOpen &&
-                run?.phase === "awaiting-acceptance" && mission.kind === "operation" && missionExecutionStatus(mission) !== "executed") {
+                run?.phase === "awaiting-acceptance" && mission.kind === "operation" && !missionExecutionComplete(mission)) {
                 return { ...packet, task: missions.task(mission),
                     next_action: "Fast-lane operation is not executed. Dispatch this same mission's Coordinator Task to finish or report its actual blocker; a setup or validation success is not operation completion." };
             }
@@ -1442,6 +1448,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 budget_remaining_units: budget?.remaining_units ?? null,
                 next_action: typeof packet.next_action === "string" ? packet.next_action : null,
                 ...(record(packet.acceptance_summary) ? { observations: {
+                        operation: packet.acceptance_summary.operation,
                         formal_validation: packet.acceptance_summary.formal_validation,
                         native_declared_validation: packet.acceptance_summary.native_declared_validation,
                         worker_terminals: (mission.attempts ?? []).map(attempt => ({ run_id: attempt.runID, status: attempt.status, terminal: attempt.terminal ?? null })),
@@ -1627,7 +1634,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 await requireRoot(context.sessionID);
                 const state = await operators.required(context.sessionID);
                 let mission = await missions.read(context.sessionID);
-                if (mission?.kind === "operation" && missionExecutionStatus(mission) !== "executed")
+                if (mission?.kind === "operation" && !missionExecutionComplete(mission))
                     return JSON.stringify({
                         status: "not-ready", operation_status: missionExecutionStatus(mission),
                         next_action: "The requested operation has not completed. Preserve its real outcome; auxiliary checks and a bounded review do not complete it. Continue the declared operation or report its blocker.",
@@ -1658,7 +1665,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     const reviewGaps = missionReportReview(mission, state.runID) === "evidence-gaps"
                         ? mission.review.result?.trim() || "独立Reviewの未解決証拠あり" : undefined;
                     const gapSummary = reviewGaps?.replace(/^EVIDENCE_GAPS\s*/u, "").replace(/\s+/gu, " ").slice(0, 500);
-                    const text = `✅ **DONE** \`${state.runID}\` — declared checks passed; Operator accepted the result.\n\n` +
+                    const text = withMissionOperationOutcome(`✅ **DONE** \`${state.runID}\` — declared checks passed; Operator accepted the result.`, mission) + `\n\n` +
                         `**変更点:** ${state.units.map(unit => unit.unit.title).join("; ")}\n\n` +
                         `**確認結果:** 宣言検証合格 — ${[...new Set(state.units.flatMap(unit => unit.unit.validation))].join("; ")}` +
                         (mission?.review ? `\nレビュー: ${mission.review.verdict === "self-rechecked" ? "修正著者の自己再確認（独立PASSではない）" : mission.review.verdict === "evidence-gaps" ? "証拠不足を残して受入れ（レビューPASSではない）" : mission.review.verdict}.` : "") +
@@ -1670,6 +1677,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                         panel = returnReportPanel(rendered);
                 }
                 return JSON.stringify({ status: result.status, run_id: state.runID,
+                    ...(mission?.kind === "operation" ? { operation: missionOperationSummary(mission) } : {}),
                     acceptance_fingerprint: state.acceptanceFingerprint, receipt: result.receipt ?? null,
                     ...(result.receipt?.status === "succeeded" && missionReportReview(mission, state.runID) === "evidence-gaps"
                         ? { review_evidence_gaps: mission.review.result ?? null } : {}),
@@ -2032,9 +2040,13 @@ export function createProfiledPlugin(profile, assetVersion) {
                         next_action: "Read operator_status: if the Coordinator dispatch is active, continue it; otherwise dispatch the returned task to resume the same Coordinator. Retain requirements, spend and candidate; no new mission or plan approval." });
                 });
             } };
-        tools[startMission] = { description: `Operator: save current requirements; the host retains the original request verbatim. With a meaningful formal check known from user, project or task context and one useful unit, include unit NOW and dispatch its Worker directly; plan_units remains available after start. A literal command in the original request is not required. Worker owns investigation/edit/check/requested commit before independent Review; no routine preparation or commit-only handoff. ${MISSION_GIT_SCOPE} Unknown checks or real unit decomposition use Coordinator. intent=replace follows an actual user requirement change, retaining unchanged constraints and cumulative spend; for mission-source-reconciliation-required use the saved requirements when they reflect that change. intent=new is separate work in another location.`,
+        const missionExecutionSchema = { type: "object", properties: { commands: stringList, directory: { type: "string" } },
+            required: ["commands", "directory"], additionalProperties: false,
+            description: "For an operation: the actual run/grade commands, not a preflight or NO_START check. Host observes their native shell completion separately from successful exits; no handwritten proof file is needed. For run-once/result collection, validate the collected result without rerunning the operation.", "x-sortie-optional": true };
+        tools[startMission] = { description: `Operator: save current requirements; the host retains the original request verbatim. With a meaningful formal check known from user, project or task context and one useful unit, include unit NOW (and execution for an operation) and dispatch its Worker directly; plan_units remains available after start. A literal command in the original request is not required. Worker owns investigation/edit/check/requested commit before independent Review; no routine preparation or commit-only handoff. ${MISSION_GIT_SCOPE} Unknown checks or real unit decomposition use Coordinator. intent=replace follows an actual user requirement change, retaining unchanged constraints and cumulative spend; for mission-source-reconciliation-required use the saved requirements when they reflect that change. intent=new is separate work in another location.`,
             args: { requirements: { ...stringList, minItems: 1, maxItems: 64 },
                 unit: { ...missionUnitSchema, description: "When the meaningful check and single-unit scope are already known, include this unit now. Returns its configured Worker directly, combining start_mission and plan_units without another model round trip.", "x-sortie-optional": true },
+                execution: missionExecutionSchema,
                 confirmed_conditions: conditionsSchema,
                 prohibited_write: { ...stringList, description: "Only explicit path prohibitions from the user or applicable instructions. Never infer a parent glob from project/repository names, semantic 'do not modify the product', or the complement of estimated unit.write. Preserve the authorized clone and exact prohibited paths; semantic constraints stay in requirements.", "x-sortie-optional": true },
                 kind: { type: "string", enum: ["implementation", "operation"], description: "Use operation for running an existing benchmark, command or procedure. The host records its actual execution separately from setup and checks.", "x-sortie-optional": true },
@@ -2123,10 +2135,16 @@ export function createProfiledPlugin(profile, assetVersion) {
                         if (baseline)
                             mission = await missions.update(context.sessionID, state => { state.reviewBaseline = baseline; });
                     }
-                    if (args.unit !== undefined && mission.runID === null && !mission.dispatchOpen && mission.kind !== "operation") {
-                        const planned = JSON.parse(await declareMissionUnits(context.sessionID, context.sessionID, mission, [args.unit]));
+                    if (args.unit !== undefined && mission.runID === null && !mission.dispatchOpen &&
+                        (mission.kind !== "operation" || args.execution !== undefined || mission.execution)) {
+                        const planned = JSON.parse(await declareMissionUnits(context.sessionID, context.sessionID, mission, [args.unit], undefined, args.execution));
                         return JSON.stringify({ ...locationObservation(context.sessionID), mission_id: mission.id, requirements: mission.requirements, ...planned });
                     }
+                    if (args.execution !== undefined && mission.runID === null && !mission.dispatchOpen) {
+                        const operation = declaredMissionExecution(mission, args.execution);
+                        if (operation)
+                            mission = await missions.update(context.sessionID, state => { state.kind = "operation"; state.execution = operation; });
+                    }
                     return JSON.stringify({ ...locationObservation(context.sessionID), ...(mission.dispatchOpen
                             ? missionDispatchPacket(mission, await operators.read(context.sessionID))
                             : { mission_id: mission.id, requirements: mission.requirements, task: missions.task(mission),
@@ -2267,6 +2285,19 @@ export function createProfiledPlugin(profile, assetVersion) {
                         obligations: policy.proposal.obligations }, run_id: prepared.runID, unit_id: unitID,
                     task: record(next) ? next.task : undefined, budget: await control.currentBudget(root) });
             } };
+        function declaredMissionExecution(mission, execution) {
+            const operation = mission.execution;
+            // Optional empty operation fields must not turn a normal edit into an operation.
+            if (execution === undefined || mission.kind === "implementation" && record(execution) &&
+                Array.isArray(execution.commands) && execution.commands.length === 0)
+                return operation;
+            if (!record(execution) || typeof execution.directory !== "string" || !execution.directory.trim() ||
+                !Array.isArray(execution.commands) || execution.commands.length === 0 || execution.commands.length > 16 ||
+                !execution.commands.every(command => typeof command === "string" && command.trim()))
+                throw new Error("mission-operation-input: supply the actual operation commands and their working directory");
+            const commands = [...new Set(execution.commands.map(missionValidationCommand).map(normalizeCommand))];
+            return { commands, directory: resolve(input.directory, execution.directory), observations: operation?.observations ?? [] };
+        }
         async function declareMissionUnits(root, actor, mission, raw, reason, execution, planningCallID) {
             await control.currentBudget(root);
             mission = await missions.required(root);
@@ -2281,21 +2312,11 @@ export function createProfiledPlugin(profile, assetVersion) {
                         `requirements to Operator. Operator can relink this mission in place via ${startMission} intent=replace ` +
                         `with those exact requirements when they match the user's changed scope; no Worker can start before that decision.` });
             mission = await retainCancelledMissionAcceptance(root, mission, previous);
-            let operation = mission.execution;
+            const operation = declaredMissionExecution(mission, execution);
             // Models can serialize an optional operation field as an empty object for a normal edit.
             // Do not turn an implementation mission into an operation (or block its first Worker).
             const emptyImplementationExecution = mission.kind === "implementation" && record(execution) &&
                 Array.isArray(execution.commands) && execution.commands.length === 0;
-            if (execution !== undefined && !emptyImplementationExecution) {
-                if (!record(execution) || typeof execution.directory !== "string" || !execution.directory.trim() ||
-                    !Array.isArray(execution.commands) || execution.commands.length === 0 || execution.commands.length > 16 ||
-                    !execution.commands.every(command => typeof command === "string" && command.trim()))
-                    throw new Error("mission-operation-input: supply the actual operation commands and their working directory");
-                const commands = [...new Set(execution.commands.map(missionValidationCommand).map(normalizeCommand))];
-                const directory = resolve(input.directory, execution.directory);
-                // A corrected command is allowed on replan; retain prior observations for accounting.
-                operation = { commands, directory, observations: operation?.observations ?? [] };
-            }
             const plan = missionPlan(mission, raw, input.directory);
             assertMissionWritePaths(mission, plan.units.flatMap(unit => unit.write));
             if (actor === root && (mission.coordinator !== null || plan.units.length !== 1))
@@ -2462,9 +2483,7 @@ export function createProfiledPlugin(profile, assetVersion) {
         }
         tools[planUnits] = { description: `Coordinator or single-unit Fast-lane Operator: declare useful work with estimated read/write scope and meaningful formal checks. executor=self starts implementation/correction and formal validation HERE without a Worker or handoff read; otherwise dispatch the returned configured Worker promptly. Keep investigation/edit/check/requested commit with the same author before independent Review, not a commit-only handoff. ${MISSION_GIT_SCOPE} Native scope reconciliation/expand_unit retain host permissions and explicit path prohibitions. Objective is the target or corrective delta: aim for 2000 characters; the full original request/public reproduction is supplied separately, not copied here. Oversized unit instructions are retained verbatim in handoff Mission context, not rejected for another planning round. Keep every requirement covered. Final validation proves the unit; empty or dummy checks do not qualify. Diagnostics need no registration. write: [] is read-only; dir/** and native absolute paths support actual outputs. reason replans settled work, or ends your own quiescent direct unit without acceptance to correct its declaration, in the same requirements/budget; same-scope failed validation uses retry_mission_unit. Reviewer FINDINGS stay with the same Reviewer for correction, formal validation and self-recheck.`,
             args: { units: { type: "array", minItems: 1, maxItems: 32, items: missionUnitSchema },
-                execution: { type: "object", properties: { commands: stringList, directory: { type: "string" } },
-                    required: ["commands", "directory"], additionalProperties: false,
-                    description: "For an operation: the actual run/grade commands, not a preflight or NO_START check. Host observes their native shell completion; no handwritten proof file is needed.", "x-sortie-optional": true },
+                execution: missionExecutionSchema,
                 reason: { type: "string", "x-sortie-optional": true },
                 executor: { type: "string", enum: ["worker", "self"], description: "Use self to implement/correct and formally validate here without a Worker handoff. Default worker retains configured Worker routing.", "x-sortie-optional": true } }, execute: async (args, context) => {
                 const { root, mission } = await missionAuthority(context.sessionID);
@@ -2870,7 +2889,7 @@ export function createProfiledPlugin(profile, assetVersion) {
             args: { status: { type: "string", enum: ["ready", "needs-decision", "blocked"] }, summary: stringSchema }, execute: async (args, context) => {
                 const { root, mission } = await missionAuthority(context.sessionID);
                 if (args.status === "ready") {
-                    if (mission.kind === "operation" && missionExecutionStatus(mission) !== "executed") {
+                    if (mission.kind === "operation" && !missionExecutionComplete(mission)) {
                         return JSON.stringify({ ...missionPacket(mission, await operators.read(root)), status: "operation-incomplete",
                             next_action: missionExecutionStatus(mission) === "running"
                                 ? "The declared operation is already running. Inspect its native shell/progress; do not start another Worker or run. Wait for a terminal result, or report the existing run as blocked if its completion cannot be observed."
@@ -2890,7 +2909,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     ...missionPacket(updated, submittedRun),
                     next_action: "Return this result and acceptance_summary to Operator now. Compare the original requests with the candidate and actual evidence; inspect concrete gaps only, then complete_mission if satisfied. No routine archive search or full source reread. Completion still requires its final comparison and complete_mission receipt." });
             } };
-        tools[completeMission] = { description: "Operator only: after comparing the original request, source, actual checks and current review disposition (explicit native author self-recheck is not independent PASS), explicitly accept the whole mission. Returns the measured 🐾 report on success; never treat Worker start, CORRECTION_READY or one passing check as completion.",
+        tools[completeMission] = { description: "Operator only: after comparing the original request, source, actual checks and current review disposition (explicit native author self-recheck is not independent PASS), explicitly accept the whole mission. A collected terminal failure can satisfy a run-once/report request, not a request for successful execution. Returns operation outcome separately from the measured 🐾 Mission receipt; never treat Worker start, CORRECTION_READY or one passing check as completion.",
             args: {}, execute: async (_args, context) => {
                 await requireRoot(context.sessionID);
                 await missions.required(context.sessionID);
@@ -2941,7 +2960,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     return;
                 const run = await operators.read(sessionID);
                 const mission = await missions.read(sessionID);
-                const text = await control.renderReturnReport(sessionID, decoratePreviewHeadings(part.text), goalFingerprint(receipt), run ? missionReportReview(mission, run.runID) : undefined, run ? missionReportReviewGaps(mission, run.runID) : undefined);
+                const text = await control.renderReturnReport(sessionID, withMissionOperationOutcome(decoratePreviewHeadings(part.text), mission), goalFingerprint(receipt), run ? missionReportReview(mission, run.runID) : undefined, run ? missionReportReviewGaps(mission, run.runID) : undefined);
                 if (text === undefined)
                     return;
                 if (text === part.text) {
@@ -3606,7 +3625,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                 }
                 if (ownership?.mission) {
                     const current = await missions.required(ownership.root);
-                    if (current.callID !== request.callID) {
+                    // Native completion can arrive after cancellation/acceptance or an agent switch.
+                    // Close its historical owner without reviving the Mission or requiring revoked root authority.
+                    if (current.callID !== request.callID || ["completed", "cancelled"].includes(current.phase)) {
                         taskOwners.delete(request.callID);
                         return;
                     }
@@ -3941,7 +3962,11 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const role = (await identity(request.sessionID)).role;
                 if (role === "dog-operator" || !await rootFor(request.sessionID))
                     return;
-                const forwardedText = role === "dog-coordinator" ? forwardTerminalText(output.text) : output.text;
+                let forwardedText = role === "dog-coordinator" ? forwardTerminalText(output.text) : output.text;
+                if (role === "dog-coordinator" && terminalRunOutcome(forwardedText) === "DONE" &&
+                    (await control.currentReceipt(request.sessionID))?.status === "succeeded") {
+                    forwardedText = withMissionOperationOutcome(forwardedText, await missions.read(request.sessionID));
+                }
                 // Ordinary Operator chat is not a request for a historical Mission return panel.
                 if (role === "dog-coordinator" && terminalRunOutcome(forwardedText) === undefined)
                     return;

package/dist/runtime-mission-assets.js

@@ -54,6 +54,11 @@ not its exit; it cannot complete the declared operation. This does not restrict
 For a declared operation, do not append a tee pipeline, redirection or wrapper that was not declared. Save output separately
 when needed. Use that same run's terminal state and result for completion. If a run already started,
 inspect its progress and report a missing terminal observation instead of launching it again.
+Execution completion is not successful execution. For a run-once/result-collection request, preserve
+a terminal failure, validate the collected result and return it without a repair loop or another run.
+Successful execution requirements stay in meaningful formal validation and Operator's comparison
+with the original request. Mission acceptance must report the operation's exit/outcome separately;
+a succeeded Mission receipt never changes a failed benchmark into a successful benchmark.
 `;
 function controls(profile, names) {
     return names.map(name => `  ${profile.toolPrefix}${name}: true`).join("\n");
@@ -114,7 +119,8 @@ quality threshold and explicit model/budget choice. Follow AGENTS.md and use the
     ${profile.toolPrefix}start_mission with intent: "replace" and the saved requirements. The cancelled
     Mission is archived; cumulative spend is retained. Dispatch only the returned Coordinator Task.
   2. If a meaningful formal check is known from the user, project or task context and the work fits one unit,
-    include unit in start_mission to receive its Worker immediately in the same call. If already started,
+    include unit in start_mission to receive its Worker immediately in the same call. For a known operation,
+    include execution commands/directory alongside unit. If already started,
     call plan_units and dispatch its Worker. Source investigation, shell/environment checks,
     fix design and output inventory belong inside that Worker, not a routine Operator preflight.
     Use estimated read/write paths; native scope reconciliation and expand_unit cover actual outputs.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.13.9",
+  "version": "0.13.11",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",