sortie-dogs 0.13.10 → 0.13.11

package/README.md

@@ -194,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.

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.10-codex-windows-v1";
-export declare const CODEX_SKILL_ASSET_VERSION = "0.13.10-codex-skill-v2";
+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.10-codex-windows-v1";
-export const CODEX_SKILL_ASSET_VERSION = "0.13.10-codex-skill-v2";
+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/codex/mission-session.d.ts

@@ -59,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

@@ -9,6 +9,7 @@ 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 {
@@ -24,6 +25,7 @@ export class CodexMissionSession {
     observations = [];
     ownedRoots = new Set();
     toolQueues = new Map();
+    observationsInFlight = new Set();
     directory;
     constructor(options, shell) {
         this.options = options;
@@ -80,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) => {
@@ -269,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;
@@ -530,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;
@@ -547,9 +559,11 @@ export class CodexMissionSession {
                 metadata = { sessionId: child.id, status: result.status };
             }
             else {
+                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))]
-                        : [process.execPath, "-e", "require('node:fs').writeFileSync(process.argv[1],process.argv[2])", resolve(this.directory, String(args.filePath)), String(args.content)];
+                        : 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" } });
@@ -610,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-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

@@ -301,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

@@ -116,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. */
@@ -535,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");
@@ -684,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 } : {}),
@@ -712,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,
@@ -723,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.10",
+  "version": "0.13.11",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",