sortie-dogs 0.13.21 → 0.13.22

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.21-operation-recovery-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.22-owned-task-lifecycle-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.21-operation-recovery-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.22-owned-task-lifecycle-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";

package/dist/cli/codex-mission.js

@@ -47,7 +47,7 @@ export async function runCodexMissionCommand(argv) {
         const result = await adapter.run(prompt);
         process.stdout.write(`${JSON.stringify({ status: result.accepted ? "succeeded" : "incomplete", root_session_id: result.rootSessionID,
             thread_id: result.turn.threadID, turn_id: result.turn.turnID, native_status: result.turn.status,
-            response: result.turn.finalResponse, sessions: result.sessions, cost: null })}\n`);
+            response: result.turn.finalResponse, lifecycle: result.lifecycle, sessions: result.sessions, cost: null })}\n`);
         return signalExit ?? (result.accepted ? 0 : 1);
     }
     catch (error) {
@@ -66,6 +66,11 @@ export async function runCodexMissionCommand(argv) {
 }
 /** Bounded user-facing progress; do not dump control packets or hidden reasoning. */
 export function codexMissionProgress(event) {
+    if (event.method === "turn/completed")
+        return { thread_id: event.threadId, phase: "native-turn-terminal", turn_id: event.params.turn?.id,
+            native_status: event.params.turn?.status };
+    if (event.method === "sortie/continuation")
+        return { thread_id: event.threadId, turn_id: event.params.turnId, phase: event.params.phase, calls: event.params.calls };
     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 };

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

@@ -46,6 +46,14 @@ export interface CodexTurnResult {
     readonly finalResponse?: string;
     readonly items: readonly JsonObject[];
     readonly usage?: JsonObject;
+    /** Host tools still running at native turn completion, drained without resending them. */
+    readonly deferredToolResults?: readonly CodexDeferredToolResult[];
+}
+export interface CodexDeferredToolResult {
+    readonly callID: string;
+    readonly tool: string;
+    readonly success: boolean;
+    readonly output: string;
 }
 export interface CodexAuthenticationState {
     readonly type: string | null;

package/dist/codex/app-server.js

@@ -188,7 +188,7 @@ export class CodexAppServerHost {
         if (!turnID)
             throw new CodexHostError("protocol-invalid-response", "turn/start returned no turn id.");
         return new Promise((resolve, reject) => {
-            this.active = { threadID, turnID, items: [], observer: Promise.resolve(), onEvent: options.onEvent, resolve, reject };
+            this.active = { threadID, turnID, items: [], observer: Promise.resolve(), tools: new Set(), onEvent: options.onEvent, resolve, reject };
             const backlog = this.notificationBacklog.splice(0);
             void backlog.reduce((prior, event) => prior.then(() => this.notification(event.method, event.params)), Promise.resolve())
                 .catch(error => { this.active?.reject(error); this.active = undefined; });
@@ -289,20 +289,34 @@ export class CodexAppServerHost {
         const params = object(message.params) ? message.params : {};
         if (method === "item/tool/call") {
             const active = this.active;
-            let result;
+            if (!active || active.completing || params.threadId !== active.threadID || params.turnId !== active.turnID ||
+                (params.namespace != null) || typeof params.callId !== "string" || typeof params.tool !== "string" || !this.options.dynamicTool) {
+                this.transport.send({ id: message.id, result: { contentItems: [{ type: "inputText",
+                                text: "Dynamic tool call does not belong to an active Sortie turn." }], success: false } });
+                return;
+            }
+            const call = { threadId: active.threadID, turnId: active.turnID, callId: params.callId, tool: params.tool, arguments: params.arguments };
+            const pending = Promise.resolve().then(async () => {
+                let output, success;
+                try {
+                    output = await this.options.dynamicTool(call);
+                    success = true;
+                }
+                catch (error) {
+                    output = error instanceof Error ? error.message : "Dynamic tool failed.";
+                    success = false;
+                }
+                if (!this.closed && !this.fault)
+                    this.transport.send({ id: message.id, result: { contentItems: [{ type: "inputText", text: output }], success } });
+                return { callID: call.callId, tool: call.tool, success, output };
+            });
+            active.tools.add(pending);
             try {
-                if (!active || active.completing || params.threadId !== active.threadID || params.turnId !== active.turnID ||
-                    (params.namespace != null) || typeof params.callId !== "string" || typeof params.tool !== "string" || !this.options.dynamicTool)
-                    throw new Error("Dynamic tool call does not belong to an active Sortie turn.");
-                const output = await this.options.dynamicTool({ threadId: active.threadID, turnId: active.turnID,
-                    callId: params.callId, tool: params.tool, arguments: params.arguments });
-                result = { contentItems: [{ type: "inputText", text: output }], success: true };
+                await pending;
             }
-            catch (error) {
-                result = { contentItems: [{ type: "inputText", text: error instanceof Error ? error.message : "Dynamic tool failed." }], success: false };
+            finally {
+                active.tools.delete(pending);
             }
-            if (!this.closed)
-                this.transport.send({ id: message.id, result });
             return;
         }
         if (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval") {
@@ -374,14 +388,23 @@ export class CodexAppServerHost {
         // requests such as interrupt(), whose response must be read by this pump.
         // Keep the completing turn active until observers settle so close() can
         // reject it and a later turn cannot receive an interrupt meant for it.
-        void active.observer.then(() => {
+        const deferred = status === "completed" ? [...active.tools] : [];
+        // Native response completion is not host execution completion. Keep pumping
+        // command responses and child Tasks; explicit close/transport loss can still
+        // reject this turn. Failed/interrupted native turns never auto-continue.
+        void Promise.all([active.observer, Promise.all(deferred)]).then(([, tools]) => {
             if (this.active !== active)
                 return;
             this.active = undefined;
             if (active.observerError)
                 active.reject(new CodexHostError("request-failed", "Codex turn event observer failed.", active.observerError));
             else
-                active.resolve(result);
+                active.resolve({ ...result, ...(tools.length ? { deferredToolResults: tools } : {}) });
+        }).catch(error => {
+            if (this.active !== active)
+                return;
+            this.active = undefined;
+            active.reject(error);
         });
     }
 }

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

@@ -67,6 +67,12 @@ export declare class CodexMissionSession {
         rootSessionID: string;
         turn: CodexTurnResult;
         accepted: boolean;
+        lifecycle: {
+            root_turn_terminal: boolean;
+            owned_tasks_settled: boolean;
+            mission_phase: string | null;
+            mission_accepted: boolean;
+        };
         sessions: readonly JsonObject[];
     }>;
     private stopHosts;
@@ -85,6 +91,7 @@ export declare class CodexMissionSession {
     private restoreSession;
     private tools;
     private prompt;
+    private promptTurn;
     private execute;
 }
 export {};

package/dist/codex/mission-session.js

@@ -72,8 +72,11 @@ export class CodexMissionSession {
         const previous = await new OperatorMissionRuntime(this.directory, profile).read(session.id);
         const turn = await this.prompt(session, prompt);
         const mission = await new OperatorMissionRuntime(this.directory, profile).read(session.id);
-        return { rootSessionID: session.id, turn, accepted: turn.status === "completed" && mission?.phase === "completed" &&
-                (previous?.phase !== "completed" || previous.id !== mission.id), sessions: [...this.sessions.values()].map(item => ({ thread_id: item.id, agent: item.agent, model: item.model, usage: item.usage ?? null, usage_scope: "native-thread-cumulative", cost: null })) };
+        const ownedTasksSettled = [...this.sessions.values()].every(item => !["running", "unknown"].includes(item.outcome));
+        const accepted = turn.status === "completed" && ownedTasksSettled && mission?.phase === "completed" &&
+            (previous?.phase !== "completed" || previous.id !== mission.id);
+        return { rootSessionID: session.id, turn, accepted, lifecycle: { root_turn_terminal: ["completed", "failed", "interrupted", "cancelled"].includes(turn.status),
+                owned_tasks_settled: ownedTasksSettled, mission_phase: mission?.phase ?? null, mission_accepted: accepted }, sessions: [...this.sessions.values()].map(item => ({ thread_id: item.id, agent: item.agent, model: item.model, usage: item.usage ?? null, usage_scope: "native-thread-cumulative", cost: null })) };
     }
     async stopHosts() {
         this.closed = true;
@@ -459,11 +462,33 @@ export class CodexMissionSession {
         return tools;
     }
     async prompt(session, prompt, onDispatch) {
+        let result = await this.promptTurn(session, prompt, onDispatch);
+        while (result.status === "completed" && result.deferredToolResults?.length) {
+            if (this.closed)
+                throw new Error("Codex Mission adapter is closed.");
+            const mission = await new OperatorMissionRuntime(this.directory, profile).read(this.rootOf(session));
+            if (!mission || ["completed", "cancelled"].includes(mission.phase))
+                break;
+            await this.claimOwner(this.rootOf(session));
+            await this.options.onEvent?.({ method: "sortie/continuation", threadId: session.id,
+                params: { turnId: result.turnID, phase: "owned-tools-settled", calls: result.deferredToolResults.map(item => ({ callId: item.callID, tool: item.tool, success: item.success })) } });
+            result = await this.promptTurn(session, "The previous native response ended while existing host tools were still running. Those exact calls have now returned:\n" +
+                JSON.stringify(result.deferredToolResults) +
+                "\nContinue this same Mission from these results through the remaining validation, delivery, review and root acceptance. " +
+                "Do not resend the original request or redispatch the completed Tasks. Preserve failures, ownership and cumulative budget; use existing Mission status for the next action.", undefined, true);
+        }
+        return result;
+    }
+    async promptTurn(session, prompt, onDispatch, continuation = false) {
         const startedAt = Date.now();
         const messageID = randomUUID();
         const message = { id: messageID, agent: session.agent, model: { ...session.model } };
-        const parts = [{ type: "text", text: prompt }];
-        await this.hooks["chat.message"]?.({ sessionID: session.id, messageID, agent: session.agent }, { message, parts });
+        const parts = [{ type: "text", text: prompt, ...(continuation ? { synthetic: true } : {}) }];
+        // Only this host's drained results can continue an already-admitted execution.
+        // Reclaiming that Task with the result prompt rejects Workers' exact handoff;
+        // treating it as a real root request also grants spurious user-turn authority.
+        if (!continuation)
+            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 (message.model.providerID !== "openai")
             throw new Error("Codex Mission cannot use a non-OpenAI model route.");

package/package.json

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