sortie-dogs 0.16.2 → 0.16.3

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.16.2-direct-validation-registration-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.16.3-strategy-admission-recovery-v1";
 export declare const CODEX_SKILL_ASSET_VERSION = "0.14.6-codex-skill-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION | typeof CODEX_SKILL_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,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.16.2-direct-validation-registration-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.16.3-strategy-admission-recovery-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.14.6-codex-skill-v1";

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

@@ -344,7 +344,10 @@ export declare class OperatorRuntime {
     prepareMission(root: string, raw: unknown, dispatcher?: {
         sessionID: string;
         callID: string;
-    }, supersededRunID?: string, terminalChildren?: readonly string[], replaceRequirements?: boolean, context?: Record<string, unknown>): Promise<OperatorState>;
+    }, supersededRunID?: string, terminalChildren?: readonly string[], replaceRequirements?: boolean, context?: Record<string, unknown>, terminalTaskCalls?: {
+        runID: string;
+        callIDs: readonly string[];
+    }): Promise<OperatorState>;
     /** Stage a settled mission's replacement; rejected preparation never cancels the usable run. */
     replanMission(root: string, runID: string, raw: unknown, dispatcher?: {
         sessionID: string;
@@ -380,6 +383,8 @@ export declare class OperatorRuntime {
     }>;
     private matchesWorkerTask;
     matchesRecordedWorkerTask(state: OperatorState, unitID: string, args: unknown): boolean;
+    /** Historical comparison only: cancellation revoked the admission generation. */
+    matchesCancelledWorkerTask(state: OperatorState, unitID: string, args: unknown): boolean;
     admitOperator(root: string, callID: string, args: unknown): Promise<OperatorTask>;
     private admitOperatorOnce;
     bindOperator(root: string, sessionID: string, prompt: string): Promise<void>;

package/dist/core/operator-runtime.js

@@ -766,8 +766,8 @@ export class OperatorRuntime {
         }
     }
     /** Mission authority is supplied only by the owning profile, never by a model-authored plan. */
-    prepareMission(root, raw, dispatcher, supersededRunID, terminalChildren = [], replaceRequirements = false, context) {
-        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, supersededRunID, terminalChildren, replaceRequirements, context }));
+    prepareMission(root, raw, dispatcher, supersededRunID, terminalChildren = [], replaceRequirements = false, context, terminalTaskCalls) {
+        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, supersededRunID, terminalChildren, replaceRequirements, context, terminalTaskCalls }));
     }
     /** Stage a settled mission's replacement; rejected preparation never cancels the usable run. */
     replanMission(root, runID, raw, dispatcher, context) {
@@ -946,6 +946,17 @@ export class OperatorRuntime {
         if (mission?.supersededRunID !== undefined && !superseding)
             throw new Error("mission-superseded-run-mismatch");
         const terminalChildren = mission?.terminalChildren ?? [];
+        const unclaimedCalls = previous?.units.flatMap(unit => !unit.directExecution && unit.status === "cancelled" &&
+            unit.childSessionID === null && unit.callID !== null ? [unit.callID] : []) ?? [];
+        // A cancelled admission can precede its child's first prompt. Only the owning
+        // profile's exact native Task proof, not null or cancellation alone, closes it.
+        if (mission && previous?.phase === "cancelled" && unclaimedCalls.length &&
+            (mission?.terminalTaskCalls?.runID !== previous.runID ||
+                new Set(mission.terminalTaskCalls.callIDs).size !== unclaimedCalls.length ||
+                mission.terminalTaskCalls.callIDs.length !== unclaimedCalls.length ||
+                unclaimedCalls.some(call => !mission.terminalTaskCalls.callIDs.includes(call)))) {
+            throw new Error("mission-cancelled-run-task-not-terminal");
+        }
         const retainAcceptance = previous !== undefined && cancelledMissionRetainsAcceptance(previous);
         const predecessorChildren = previous?.units.flatMap(unit => !unit.directExecution && unit.childSessionID !== null
             ? [unit.childSessionID] : []) ?? [];
@@ -957,7 +968,7 @@ export class OperatorRuntime {
             unit.repairValidation !== null || (unit.status === "pending" && (unit.callID !== null || unit.childSessionID !== null ||
             unit.evidence.length > 0 || unit.resultClass !== null)) ||
             (unit.status === "succeeded" && (unit.childSessionID === null || unit.callID === null || unit.evidence.length === 0 || unit.resultClass !== "acceptance")) ||
-            (unit.status === "cancelled" && (unit.childSessionID === null || unit.callID === null))))) {
+            (unit.status === "cancelled" && unit.callID === null)))) {
             throw new Error("mission-superseded-run-has-work: reconcile prior workers and evidence before changing acceptance");
         }
         if (plan.git_lifecycle !== undefined) {
@@ -1197,9 +1208,11 @@ export class OperatorRuntime {
                     await handle.close();
                 }
             }
-            if ((superseding || replanning || previous?.phase === "completed") && previous) {
+            if ((superseding || replanning || previous?.phase === "completed" ||
+                previous?.phase === "cancelled" && unclaimedCalls.length > 0 && mission?.terminalTaskCalls !== undefined) && previous) {
                 // A crash before the state switch may leave a checkpoint while the old run later advances.
                 // Sequence-qualified replan snapshots keep that history without blocking a subsequent correction.
+                // Same-request recovery also retains the original unclaimed cancellation, not just its costs.
                 const archive = replanning || previous.phase === "completed" ? this.replanArchivePath(previous)
                     : `${this.file(root)}.${previous.runID}.archive`;
                 try {
@@ -1370,6 +1383,28 @@ export class OperatorRuntime {
             : args;
         return unit !== undefined && this.matchesWorkerTask(state, unit, normalized);
     }
+    /** Historical comparison only: cancellation revoked the admission generation. */
+    matchesCancelledWorkerTask(state, unitID, args) {
+        const unit = state.units.find(item => item.unit.id === unitID);
+        if (state.phase !== "cancelled" || !unit || unit.status !== "cancelled" || unit.childSessionID !== null ||
+            !record(args) || typeof args.prompt !== "string")
+            return false;
+        if (args.prompt === unit.task.prompt)
+            return this.matchesRecordedWorkerTask(state, unitID, args);
+        if (!args.prompt.startsWith(`${OPERATOR_TASK_REFERENCE} `))
+            return false;
+        let reference;
+        try {
+            reference = JSON.parse(args.prompt.slice(OPERATOR_TASK_REFERENCE.length + 1));
+        }
+        catch {
+            return false;
+        }
+        if (!record(reference) || !Number.isSafeInteger(reference.g) || reference.g < 1 ||
+            reference.g >= state.generation)
+            return false;
+        return this.matchesRecordedWorkerTask({ ...state, generation: reference.g }, unitID, args);
+    }
     admitOperator(root, callID, args) {
         return this.serial(root, () => this.admitOperatorOnce(root, callID, args));
     }

package/dist/plugin/profiled.js

@@ -1251,6 +1251,9 @@ export function createProfiledPlugin(profile, assetVersion) {
             return packet;
         }
         function missionDispatchPacket(mission, run) {
+            const strategyRecovery = " If a method stalled or proposed avoidable extra work, Operator: compare the original goal, actual result and concrete unmet work before choosing to continue, change or stop that method. " +
+                `For a concrete adjustment, use ${profile.toolPrefix}plan_units with proposed units, reason and handoff_context, then dispatch its returned same-Coordinator continuation. ` +
+                "Preserve required checks through lawful registration/replanning and reuse current evidence. Otherwise continue normally; no extra approval or logging-only step.";
             const packet = { ...missionPacket(mission, run), project_root: input.directory,
                 coordinator_dispatch: mission.dispatchOpen ? "active" : ["completed", "cancelled"].includes(mission.phase) ? "terminal" : "resumable" };
             if (mission.phase === "submitted" && mission.submission?.status === "blocked" &&
@@ -1284,7 +1287,7 @@ export function createProfiledPlugin(profile, assetVersion) {
             if (mission.runID === run?.runID && run?.units.some(unit => unit.status === "running")) {
                 if (mission.coordinator && !mission.dispatchOpen && !["completed", "cancelled"].includes(mission.phase))
                     return { ...packet, task: missions.task(mission),
-                        next_action: "Resume this existing Coordinator Task with its task_id to continue the retained unit. Do not dispatch a replacement or wait for background work that has already ended." };
+                        next_action: "Resume this existing Coordinator Task with its task_id to continue the retained unit. Do not dispatch a replacement or wait for background work that has already ended." + strategyRecovery };
                 return { ...packet, next_action: "The current unit is active. Continue its owning session; do not dispatch a replacement Worker or Coordinator. Native background completion will return to the parent." };
             }
             if (mission.coordinator === null && mission.runID === run?.runID && !mission.dispatchOpen &&
@@ -1330,7 +1333,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     next_action: (run?.units.some(unit => unit.dispatchDenial) ? `${packet.next_action}\n` : "") +
                         (mission.coordinator === null
                             ? "Fast-lane needs correction or coordination: dispatch this exact Coordinator Task with the existing Worker changes, checks and concrete remaining work. Keep the same mission, requirements and cumulative budget; do not replace an active Worker."
-                            : "The previous Coordinator Task is finished. Dispatch this exact Task to continue the same mission and Coordinator session; keep the original requirements and cumulative budget.") };
+                            : "The previous Coordinator Task is finished. Dispatch this exact Task to continue the same mission and Coordinator session; keep the original requirements and cumulative budget." + strategyRecovery) };
             }
             return packet;
         }
@@ -1559,6 +1562,58 @@ export function createProfiledPlugin(profile, assetVersion) {
                 await operators.recordStoppedChild(root, run.runID, child);
             }
         }
+        async function cancelledUnclaimedTaskCalls(root, run) {
+            const units = run.units.filter(unit => !unit.directExecution && unit.status === "cancelled" &&
+                unit.childSessionID === null && unit.callID !== null);
+            if (!units.length)
+                return undefined;
+            const owner = run.operatorSessionID ?? root;
+            const deny = () => new Error("mission-cancelled-run-task-not-terminal");
+            // The bounded chat context may omit the old Task. Use the existing native
+            // history reader, and never substitute a model's stop report for a tool terminal.
+            const history = await reviewMessages(owner, undefined, true);
+            for (const unit of units) {
+                const parts = history.flatMap(message => record(message.info) && message.info.role === "assistant" &&
+                    message.info.sessionID === owner && Array.isArray(message.parts) ? message.parts : []).filter(part => record(part) && part.type === "tool" && part.tool === "task" && part.callID === unit.callID);
+                const part = parts.length === 1 && record(parts[0]) ? parts[0] : undefined;
+                const state = part && record(part.state) ? part.state : undefined;
+                if (!part || part.sessionID !== undefined && part.sessionID !== owner || !state ||
+                    !["completed", "error"].includes(String(state.status)) ||
+                    record(state.metadata) && ["running", "pending", "unknown"].includes(String(state.metadata.status)) ||
+                    !record(state.time) || typeof state.time.end !== "number" || !Number.isFinite(state.time.end) ||
+                    !operators.matchesCancelledWorkerTask(run, unit.unit.id, state.input) || taskChildSessionID(state) !== undefined)
+                    throw deny();
+            }
+            // A parent Task terminal does not prove that an unclaimed child never started.
+            // Reuse the owning service's active snapshot and child lineage before allowing
+            // this formerly unrepresentable cancellation into prepareMission.
+            const active = payload(await session("active", {}));
+            if (!record(active) || !Object.values(active).every(value => record(value) &&
+                ["running", "retry"].includes(String(value.type))) || owner !== root && Object.hasOwn(active, owner))
+                throw deny();
+            const children = payload(await session("children", { path: { id: owner }, query: { directory: input.directory } }));
+            if (!Array.isArray(children) || children.some(child => !record(child) || typeof child.id !== "string") ||
+                new Set(children.map(child => child.id)).size !== children.length)
+                throw deny();
+            for (const child of children) {
+                const info = payload(await session("get", { path: { id: child.id }, query: { directory: input.directory } }));
+                if (!record(info) || info.id !== child.id || info.parentID !== owner ||
+                    typeof info.agent !== "string" || !info.agent.trim())
+                    throw deny();
+                const role = canonicalAgent(profile, info.agent);
+                // Root Fast-lane Tasks must not claim unrelated profile or native agents.
+                if (owner === root && role !== "dog-worker" && role !== "dog-luna-worker")
+                    continue;
+                if (!role)
+                    throw deny();
+                const descendants = payload(await session("children", { path: { id: child.id }, query: { directory: input.directory } }));
+                if (Object.hasOwn(active, child.id) || !Array.isArray(descendants) || descendants.length ||
+                    !["succeeded", "failed", "interrupted"].includes(String(info.outcome)) &&
+                        !(info.outcome === undefined && run.stoppedChildren?.includes(child.id)))
+                    throw deny();
+            }
+            return { runID: run.runID, callIDs: units.map(unit => unit.callID) };
+        }
         async function stop(root, reason, retireRoot = true) {
             const directActor = (await operators.read(root))?.units.find(unit => unit.status === "running" && unit.directExecution)?.directExecution?.actor;
             // Stopping owned execution does not write its artifacts. Its existing reservation
@@ -3031,8 +3086,24 @@ export function createProfiledPlugin(profile, assetVersion) {
                 // packet can already contain one even while its Reviewer is still pending.
                 const { task: _dispatchTask, ...packet } = missionDispatchPacket(mission, previous);
                 const reviewPending = mission.runID === previous?.runID && mission.review?.verdict === "pending";
-                const active = mission.dispatchOpen || reviewPending || mission.runID === previous?.runID &&
-                    previous?.units.some(unit => unit.status === "running");
+                const running = mission.runID === previous?.runID ? previous.units.filter(unit => unit.status === "running") : [];
+                let retainedDirectOwnerEnded = false;
+                if (!mission.dispatchOpen && !reviewPending && mission.coordinator && running.length &&
+                    running.every(unit => unit.directExecution?.actor === mission.coordinator && !unit.reviewerCorrection)) {
+                    // This only forwards a proposal to the SAME owner. Native session termination
+                    // does not settle its retained unit or authorize a new writer/contract.
+                    const native = payload(await session("get", { path: { id: mission.coordinator } }).catch(() => undefined));
+                    if (record(native) && native.id === mission.coordinator && native.parentID === root &&
+                        canonicalAgent(profile, native.agent) === "dog-operator" &&
+                        ["succeeded", "failed", "interrupted"].includes(String(native.outcome))) {
+                        try {
+                            await assertDirectPlanningQuiescent(mission.coordinator);
+                            retainedDirectOwnerEnded = true;
+                        }
+                        catch { /* A live/unproven native tool still owns this work; do not offer another Task. */ }
+                    }
+                }
+                const active = mission.dispatchOpen || reviewPending || running.length > 0 && !retainedDirectOwnerEnded;
                 const continuation = !active ? missions.task(mission) : undefined;
                 // Existing Coordinator resumes accept a concrete prompt. Do not use the opaque
                 // initial reference here: claim() would expand it from unchanged Mission state
@@ -3108,7 +3179,8 @@ export function createProfiledPlugin(profile, assetVersion) {
             const cancelledPredecessor = previous?.phase === "cancelled" &&
                 (mission.supersededRunID === previous.runID ||
                     (mission.supersededRunID === undefined && ["explicit-cancellation", "agent-changed"].includes(previous.decision ?? "") &&
-                        previous.units.some(unit => (previous.decision === "agent-changed" || unit.status === "cancelled") && unit.childSessionID !== null)));
+                        previous.units.some(unit => (previous?.decision === "agent-changed" || unit.status === "cancelled") &&
+                            (unit.childSessionID !== null || !unit.directExecution && unit.callID !== null))));
             let budget = await control.currentBudget(root);
             if (cancelledPredecessor && budget?.reserved_units) {
                 await control.reconcileAbortedOperatorOrphan(root);
@@ -3119,6 +3191,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 // Reconcile it even when reservation recovery has nothing to do. Never resume it,
                 // interrupt live work here, or manufacture its native terminal/validation records.
                 await stopCancelledChildren(root, previous, true);
+                previous = await operators.required(root);
             }
             if (budget && budget.remaining_units < plan.units.length && !same)
                 throw new Error(`mission-budget-exhausted: plan needs ${plan.units.length} units; ${budget.remaining_units} remain. ` +
@@ -3156,8 +3229,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                 ...(previous ? { retained_validation: missionReviewValidation(previous, replanning || previous.phase === "completed"
                         ? operators.replanArchivePath(previous) : cancelledPredecessor ? `${operators.statePath(root)}.${previous.runID}.archive` : operators.statePath(root)),
                     prior_run_id: previous.runID } : {}) };
+            const terminalTaskCalls = cancelledPredecessor && previous ? await cancelledUnclaimedTaskCalls(root, previous) : undefined;
             const state = replanning && previous ? await operators.replanMission(root, previous.runID, plan, dispatcher, context)
-                : await operators.prepareMission(root, plan, dispatcher, mission.supersededRunID, terminalChildren, mission.requirementsReplaced, context);
+                : await operators.prepareMission(root, plan, dispatcher, mission.supersededRunID, terminalChildren, mission.requirementsReplaced, context, terminalTaskCalls);
             // prepareMission retains an identical prepared run after either registration stage
             // fails. Verify its pinned controls, then idempotently register the same declaration;
             // only the durable Mission binding below makes it eligible for admission.

package/dist/runtime-mission-assets.js

@@ -163,6 +163,18 @@ ${controls(profile, ["start_mission", "plan_units", "start_direct_unit", "finish
 You are Operator, the user-facing strategic authority. Preserve every current requirement, prohibition,
 quality threshold and explicit model/budget choice. Follow AGENTS.md and use the user's language.
 
+Own strategy, not just the relay of a stopped author's reply. At a method stall or proposed extra step,
+compare the user's goal, actual result and concrete unmet work. Continue planned useful work without
+intervention; suppress unnecessary expansion, and choose only the recovery needed for a real obstacle.
+Separate a required outcome/check from an AI-selected method. Do not promote your own checker, evidence
+format or procedure into an immutable user requirement. An AI-selected method already registered as
+formal validation still needs lawful recipe correction or replanning; never silently omit it or invent PASS.
+When a change of method is needed, give the existing author the concrete alternative, rationale and
+retained obligations, not merely "resume" or the same failing instruction. Use plan_units with proposed
+units, reason and handoff_context to obtain its concrete Coordinator continuation when available.
+Do not restart a release, cancel live work or take over implementation just to exercise strategic authority.
+Ordinary implementation decisions remain with the author; no per-Task approval or decision-record ritual.
+
 ${MISSION_DEPENDENCY_WORKFLOW}
 
 1. For an implementation or operation request, give at most three short lines, then call ${profile.toolPrefix}start_mission

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.16.2",
+  "version": "0.16.3",
   "description": "Adaptive execution harness for OpenCode and Codex: goal retention, validation, review, and evidence-backed handoff",
   "keywords": [
     "opencode",