sortie-dogs 0.12.4 → 0.12.6

package/dist/core/failure-swarm-runtime.d.ts

@@ -67,8 +67,8 @@ export declare class FailureSwarmRuntime {
                 probe_iterations: number;
                 model_attempts: number;
             }>;
-            capsule_id: string;
             proposal: string;
+            capsule_id: string;
             recovery_kind: Exclude<import("./run-flight-ledger.js").RecoveryKind, "read_only_diagnosis">;
             diagnosis_id: string;
             plan_id: string;

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

@@ -22,6 +22,8 @@ export interface OperatorMission {
     callID: string | null;
     dispatchOpen: boolean;
     runID: string | null;
+    /** A cancelled run replaced by a later real user turn; never reuse its acceptance or evidence. */
+    supersededRunID?: string;
     plans: number;
     progress: {
         unit: string;
@@ -51,6 +53,10 @@ export declare class OperatorMissionRuntime {
     constructor(projectRoot: string, profile: RuntimeProfile);
     private file;
     private load;
+    /** Recover the predecessor link for missions started before this fix, using one exact archived mission. */
+    private loadMission;
+    /** Find exactly one archived cancelled mission that owned this run; ambiguity never grants recovery. */
+    archivedRun(root: string, runID: string): Promise<OperatorMission | undefined>;
     private save;
     private serial;
     read(root: string): Promise<OperatorMission | undefined>;

package/dist/core/operator-mission.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { normalizeRelativePath } from "./path.js";
 import { parseOperatorPlan } from "./operator-runtime.js";
@@ -40,6 +40,59 @@ export class OperatorMissionRuntime {
             throw error;
         }
     }
+    /** Recover the predecessor link for missions started before this fix, using one exact archived mission. */
+    async loadMission(root) {
+        const state = await this.load(this.file(root));
+        if (!state || state.supersededRunID !== undefined || state.runID !== null ||
+            !["open", "running", "submitted"].includes(state.phase) || state.requests.length === 0)
+            return state;
+        const directory = join(this.projectRoot, this.profile.stateDirectory, "missions");
+        let entries;
+        try {
+            entries = await readdir(directory);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return state;
+            throw error;
+        }
+        const prefix = `${digest(root)}.mission-`;
+        const candidates = entries.filter(name => name.startsWith(prefix) && /^mission-[a-f0-9-]+\.json$/u.test(name.slice(digest(root).length + 1)));
+        const matches = [];
+        for (const name of candidates) {
+            const previous = await this.load(join(directory, name));
+            if (previous?.root === root && previous.phase === "cancelled" && previous.runID !== null &&
+                previous.requests[0]?.id !== state.requests[0].id &&
+                previous.requests.some(request => request.id === state.requests[0].id))
+                matches.push(previous);
+        }
+        if (matches.length === 1)
+            state.supersededRunID = matches[0].runID;
+        return state;
+    }
+    /** Find exactly one archived cancelled mission that owned this run; ambiguity never grants recovery. */
+    async archivedRun(root, runID) {
+        const directory = join(this.projectRoot, this.profile.stateDirectory, "missions");
+        let entries;
+        try {
+            entries = await readdir(directory);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+        const prefix = `${digest(root)}.mission-`;
+        const matches = [];
+        for (const name of entries.filter(name => name.startsWith(prefix) &&
+            /^mission-[a-f0-9-]+\.json$/u.test(name.slice(digest(root).length + 1)))) {
+            const state = await this.load(join(directory, name));
+            if (state?.root === root && state.phase === "cancelled" && state.runID === runID &&
+                state.coordinator !== null && state.callID !== null)
+                matches.push(state);
+        }
+        return matches.length === 1 ? matches[0] : undefined;
+    }
     async save(file, value) {
         const temporary = `${file}.${randomUUID()}.tmp`;
         await mkdir(join(this.projectRoot, this.profile.stateDirectory, "missions"), { recursive: true });
@@ -64,7 +117,7 @@ export class OperatorMissionRuntime {
     }
     async read(root) {
         await this.writes.get(root);
-        const state = await this.load(this.file(root));
+        const state = await this.loadMission(root);
         if (state && (state.version !== "0.12" || state.root !== root))
             throw new Error("mission-state-invalid");
         return state;
@@ -81,7 +134,7 @@ export class OperatorMissionRuntime {
         await this.serial(root, async () => {
             // Captured before prompt rewriting, including exact whitespace. Never ask a model to recopy it.
             await this.save(this.file(root, ".request"), request);
-            const state = await this.load(this.file(root));
+            const state = await this.loadMission(root);
             if (state && !["completed", "cancelled"].includes(state.phase) && !state.requests.some(item => item.id === request.id)) {
                 state.requests.push(request);
                 await this.save(this.file(root), state);
@@ -97,7 +150,7 @@ export class OperatorMissionRuntime {
             const request = await this.load(this.file(root, ".request"));
             if (!request)
                 throw new Error("mission-original-request-unavailable");
-            const previous = await this.load(this.file(root));
+            const previous = await this.loadMission(root);
             if (previous && !["completed", "cancelled"].includes(previous.phase)) {
                 if (previous.requirements.some((item, index) => requirements[index] !== item.text)) {
                     throw new Error("mission-requirements-preserved: keep the existing ordered requirements and append user additions");
@@ -110,14 +163,16 @@ export class OperatorMissionRuntime {
                 await this.save(this.file(root, `.${previous.id}`), previous);
             const state = { version: "0.12", id: `mission-${randomUUID()}`, root, requests: [request],
                 requirements: requirements.map((text, index) => ({ id: `R${index + 1}`, text })), phase: "open",
-                coordinator: null, callID: null, dispatchOpen: false, runID: null, plans: 0, progress: [], submission: null };
+                coordinator: null, callID: null, dispatchOpen: false, runID: null, plans: 0, progress: [], submission: null,
+                ...(previous?.phase === "cancelled" && previous.runID !== null && request.id !== previous.requests[0]?.id
+                    ? { supersededRunID: previous.runID } : {}) };
             await this.save(this.file(root), state);
             return state;
         });
     }
     update(root, change) {
         return this.serial(root, async () => {
-            const state = await this.load(this.file(root));
+            const state = await this.loadMission(root);
             if (!state)
                 throw new Error("mission-missing");
             change(state);

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

@@ -172,6 +172,8 @@ export interface OperatorState {
     readonly sourceRefs: readonly string[];
     readonly createdAt: string;
     readonly parentRunID: string | null;
+    /** Archived cancelled run replaced by a later user-authorized mission. */
+    readonly supersededRunID?: string;
     readonly priorAcceptedUnits: readonly OperatorAcceptanceAnchor[];
     readonly remediationParent: {
         readonly taskID: string;
@@ -243,7 +245,7 @@ export declare class OperatorRuntime {
     prepareMission(root: string, raw: unknown, dispatcher?: {
         sessionID: string;
         callID: string;
-    }): Promise<OperatorState>;
+    }, supersededRunID?: string): Promise<OperatorState>;
     retireMissionRun(root: string): Promise<void>;
     private prepareOnce;
     operatorTask(state: OperatorState): OperatorTask;

package/dist/core/operator-runtime.js

@@ -299,7 +299,8 @@ export class OperatorRuntime {
             !identifier(state.runID) || !Array.isArray(state.units) || state.units.length > OPERATOR_LIMITS.units ||
             !strings(state.acceptance, true) || !Array.isArray(state.acceptanceProof) || state.acceptanceProof.length !== state.acceptance.length ||
             state.acceptanceProof.some(ids => !strings(ids, true)) || state.acceptanceFingerprint !== acceptanceContinuityFingerprint(state.acceptance) ||
-            (state.parentRunID !== null && !identifier(state.parentRunID)) || !Array.isArray(state.priorAcceptedUnits) ||
+            (state.parentRunID !== null && !identifier(state.parentRunID)) ||
+            (state.supersededRunID !== undefined && !identifier(state.supersededRunID)) || !Array.isArray(state.priorAcceptedUnits) ||
             state.priorAcceptedUnits.some(anchor => !record(anchor) || !identifier(anchor.taskID) || typeof anchor.handoffPath !== "string" || !isAbsolute(anchor.handoffPath) ||
                 typeof anchor.handoffHash !== "string" || !/^[a-f0-9]{64}$/u.test(anchor.handoffHash)) ||
             (state.remediationParent !== null && (!record(state.remediationParent) || !identifier(state.remediationParent.taskID) ||
@@ -677,8 +678,8 @@ export class OperatorRuntime {
         }
     }
     /** Mission authority is supplied only by the owning profile, never by a model-authored plan. */
-    prepareMission(root, raw, dispatcher) {
-        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher }));
+    prepareMission(root, raw, dispatcher, supersededRunID) {
+        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, supersededRunID }));
     }
     retireMissionRun(root) {
         return this.serial(root, async () => {
@@ -718,18 +719,30 @@ export class OperatorRuntime {
             immutableReplacement = { ...immutableReplacement, goal_declaration: declaration };
         }
         const plan = parseOperatorPlan(immutableReplacement);
+        const validatedPlanHash = hash(JSON.stringify(plan));
+        if (mission?.supersededRunID !== undefined && previous?.supersededRunID === mission.supersededRunID &&
+            previous.planHash === validatedPlanHash && previous.phase !== "cancelled")
+            return previous;
+        const superseding = mission?.supersededRunID !== undefined && previous?.runID === mission.supersededRunID &&
+            previous.phase === "cancelled";
+        if (mission?.supersededRunID !== undefined && !superseding)
+            throw new Error("mission-superseded-run-mismatch");
+        if (superseding && previous && (previous.decision !== "explicit-cancellation" || previous.gitLifecycle !== null ||
+            previous.repairResidualPaths.length > 0 || previous.priorAcceptedUnits.length > 0 ||
+            previous.units.some(unit => unit.childSessionID !== null || unit.status === "succeeded"))) {
+            throw new Error("mission-superseded-run-has-work: reconcile prior workers and evidence before changing acceptance");
+        }
         if (plan.git_lifecycle !== undefined) {
             await ensureGitManagedStateExcluded(this.projectRoot, this.profile, this.gitPath);
         }
-        const planHash = hash(JSON.stringify(plan));
         if (previous && !["completed", "cancelled"].includes(previous.phase)) {
-            if (previous.planHash === planHash)
+            if (previous.planHash === validatedPlanHash)
                 return previous;
             throw new Error("operator-active-contract-immutable");
         }
         // Cancellation stops execution, not the accepted user order. A replacement
         // plan must carry the original ordered criteria; only a completed root clears them.
-        const parent = previous?.phase === "cancelled" ? previous : undefined;
+        const parent = !superseding && previous?.phase === "cancelled" ? previous : undefined;
         if (parent?.decision === "operator-contract-repair-unavailable-after-cancel") {
             // The diagnosed transients, not the cancellation itself, block a replacement. Once they are
             // gone the same accepted order may proceed; while they remain the refusal names them exactly.
@@ -878,9 +891,9 @@ export class OperatorRuntime {
                 childSessionID: null, evidence: [], resultClass: null, repairValidationAttempts: 0, repairValidation: null });
         }
         const gitLifecycle = await this.createGitLifecycle(plan, remediationHead);
-        const state = { schema_version: "0.1", profile: this.profile.id, rootSessionID: root, runID, planHash,
+        const state = { schema_version: "0.1", profile: this.profile.id, rootSessionID: root, runID, planHash: validatedPlanHash,
             acceptance: plan.acceptance, acceptanceProof: plan.acceptance_proof, acceptanceFingerprint, sourceRefs: plan.source_refs, createdAt: new Date().toISOString(),
-            parentRunID: parent?.runID ?? null, priorAcceptedUnits,
+            parentRunID: parent?.runID ?? null, ...(superseding ? { supersededRunID: previous.runID } : {}), priorAcceptedUnits,
             remediationParent: remediationTaskID && remediationHead && parent?.gitLifecycle ? {
                 taskID: remediationTaskID, committedHead: remediationHead, runID: parent.runID,
                 acceptanceFingerprint: parent.acceptanceFingerprint, approvedWriteUnion: parent.gitLifecycle.writeUnion,
@@ -908,6 +921,17 @@ export class OperatorRuntime {
                     await handle.close();
                 }
             }
+            if (superseding && previous) {
+                const archive = `${this.file(root)}.${previous.runID}.archive`;
+                try {
+                    await writeFile(archive, JSON.stringify(previous), { flag: "wx", mode: 0o600 });
+                }
+                catch (error) {
+                    if (error.code !== "EEXIST" ||
+                        await readFile(archive, "utf8") !== JSON.stringify(previous))
+                        throw error;
+                }
+            }
             await this.save(state);
             return state;
         }

package/dist/plugin/index.js

@@ -7,12 +7,13 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { createHash, randomUUID } from "node:crypto";
-import { lstat, mkdir, open, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
+import { lstat, mkdir, open, readFile, readdir, readlink, realpath, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { RUNTIME_ASSET_VERSION } from "../asset-version.js";
 import { GOAL_DECLARATION_FORMAT, GOAL_DELIVERY_INTENTS, GOAL_DELIVERY_MODES, GOAL_CRITERION_ENUMS, expandGoalDeclaration } from "../core/goal-declaration-format.js";
 import { ACCEPTANCE_CONTINUITY_AUTHORITY, ACCEPTANCE_CONTINUITY_EXTENSION, ACCEPTANCE_CONTINUITY_SCHEMA_VERSION, acceptanceContinuityFingerprint, inspectAcceptanceContinuity, normalizeAcceptanceCriteria, } from "../core/acceptance-continuity.js";
 import { resolveGlobalConfigRoot } from "../core/initialize.js";
+import { OperatorMissionRuntime } from "../core/operator-mission.js";
 import { admitLunaFabric } from "../core/luna-fabric-contract.js";
 import { summarizeExperienceEvidence } from "../core/experience-evidence-summary.js";
 import { selectExperienceRoute } from "../core/experience-route-policy.js";
@@ -234,6 +235,7 @@ async function durableScopeRoot(projectRoot) {
 }
 async function protectedScopeDigest(projectRoot, paths, manifestHash) {
     const entries = [];
+    const canonicalRoot = await realpath(projectRoot);
     const visit = async (absolute) => {
         const scoped = relative(projectRoot, absolute).replaceAll("\\", "/");
         if (scoped === ".." || scoped.startsWith("../") || isAbsolute(scoped))
@@ -247,8 +249,22 @@ async function protectedScopeDigest(projectRoot, paths, manifestHash) {
             entries.push([scoped, "missing"]);
             return true;
         }
-        if (metadata.isSymbolicLink())
-            return false;
+        if (metadata.isSymbolicLink()) {
+            // Package managers place executable links under node_modules/.bin. Record
+            // both the link and its target bytes, but never follow a link out of the
+            // project or recurse through a linked directory (which may form a cycle).
+            const target = await realpath(absolute).catch(() => undefined);
+            if (target === undefined)
+                return false;
+            const relativeTarget = relative(canonicalRoot, target);
+            if (relativeTarget === ".." || relativeTarget.startsWith("../") || isAbsolute(relativeTarget) ||
+                !(await stat(target)).isFile())
+                return false;
+            const link = await readlink(absolute);
+            const contents = await readFile(target);
+            entries.push([scoped, `symlink:${link}`, createHash("sha256").update(contents).digest("hex")]);
+            return true;
+        }
         if (metadata.isDirectory()) {
             entries.push([scoped, "directory"]);
             const children = await readdir(absolute);
@@ -1609,6 +1625,82 @@ export const SortieDogsPlugin = async (input, options) => {
             const data = isRecord(response) ? response.data : undefined;
             if (!Array.isArray(data))
                 return;
+            const rootHistory = data;
+            async function terminalCancelledMissionTask(unitID, reservationID, goalID) {
+                const runID = unitID.replace(/-[1-9][0-9]*$/u, "");
+                if (runID === unitID || !/^operator-[a-f0-9-]+$/u.test(runID) ||
+                    input.client?.session?.get === undefined)
+                    return undefined;
+                const sessionAPI = input.client.session;
+                const childrenMethod = sessionAPI.children;
+                const getMethod = sessionAPI.get;
+                const mission = await new OperatorMissionRuntime(input.directory, runtimeProfile).archivedRun(root, runID);
+                if (!mission || !rootHistory.some(message => isRecord(message) && isRecord(message.info) &&
+                    message.info.sessionID === root && message.info.role === "assistant" && Array.isArray(message.parts) &&
+                    message.parts.some(part => isRecord(part) && part.type === "tool" && part.tool === "task" &&
+                        part.callID === mission.callID && isRecord(part.state) && part.state.status === "completed" &&
+                        isRecord(part.state.input) && typeof part.state.input.prompt === "string" &&
+                        part.state.input.prompt.startsWith("SORTIE_MISSION_REF ") && (() => {
+                        try {
+                            const ref = JSON.parse(part.state.input.prompt.slice("SORTIE_MISSION_REF ".length));
+                            return isRecord(ref) && ref.r === root && ref.m === mission.id;
+                        }
+                        catch {
+                            return false;
+                        }
+                    })())))
+                    return undefined;
+                const coordinatorResponse = await getMethod.call(sessionAPI, { path: { id: mission.coordinator }, query: { directory: input.directory } });
+                const coordinatorInfo = isRecord(coordinatorResponse) ? coordinatorResponse.data : undefined;
+                if (!isRecord(coordinatorInfo) || coordinatorInfo.id !== mission.coordinator ||
+                    coordinatorInfo.parentID !== root || coordinatorInfo.agent !== "dogs-coordinator" ||
+                    coordinatorInfo.outcome !== "succeeded")
+                    return undefined;
+                if (childrenMethod !== undefined) {
+                    const childrenResponse = await childrenMethod.call(sessionAPI, { path: { id: root }, query: { directory: input.directory } });
+                    const children = isRecord(childrenResponse) && Array.isArray(childrenResponse.data) ? childrenResponse.data : [];
+                    if (!children.some(child => isRecord(child) && child.id === mission.coordinator &&
+                        child.parentID === root && child.agent === "dogs-coordinator"))
+                        return undefined;
+                }
+                const coordinator = mission.coordinator;
+                const historyResponse = await messages.call(sessionAPI, { path: { id: coordinator }, query: { directory: input.directory } });
+                const history = isRecord(historyResponse) && Array.isArray(historyResponse.data) ? historyResponse.data : [];
+                const candidates = [];
+                for (const message of history) {
+                    if (!isRecord(message) || !isRecord(message.info) || message.info.role !== "assistant" ||
+                        message.info.sessionID !== coordinator || !Array.isArray(message.parts))
+                        continue;
+                    for (const part of message.parts) {
+                        if (!isRecord(part) || part.type !== "tool" || part.tool !== "task" ||
+                            !isRecord(part.state) || part.state.status !== "error" || !isRecord(part.state.input) ||
+                            typeof part.state.input.prompt !== "string" || !part.state.input.prompt.startsWith("SORTIE_OPERATOR_TASK_REF ") ||
+                            typeof part.callID !== "string")
+                            continue;
+                        try {
+                            const ref = JSON.parse(part.state.input.prompt.slice("SORTIE_OPERATOR_TASK_REF ".length));
+                            if (isRecord(ref) && ref.r === root && ref.n === runID && ref.t === unitID &&
+                                /^[a-f0-9]{64}$/u.test(String(ref.p)) && /^[a-f0-9]{64}$/u.test(String(ref.h)) &&
+                                goalFingerprint({ goal_id: goalID, unit_id: unitID, call_id: part.callID }) === reservationID) {
+                                const error = isRecord(part.state.error) ? part.state.error : undefined;
+                                candidates.push({ callID: part.callID, depthRefused: error?.type === "tool.execution" &&
+                                        error.message === 'Subagent depth limit reached (1). Increase "experimental.subagent_depth" to allow nested subagents.' });
+                            }
+                        }
+                        catch { /* malformed native reference cannot prove this reservation */ }
+                    }
+                }
+                if (candidates.length !== 1)
+                    return undefined;
+                if (childrenMethod !== undefined) {
+                    const descendantsResponse = await childrenMethod.call(sessionAPI, { path: { id: coordinator }, query: { directory: input.directory } });
+                    if (!isRecord(descendantsResponse) || !Array.isArray(descendantsResponse.data) || descendantsResponse.data.length !== 0)
+                        return undefined;
+                }
+                else if (mission.submission?.status !== "blocked" || !candidates[0].depthRefused)
+                    return undefined;
+                return candidates[0].callID;
+            }
             for (const reservation of pending) {
                 const matches = [];
                 for (const message of data) {
@@ -1686,8 +1778,12 @@ export const SortieDogsPlugin = async (input, options) => {
                         matches.push({ callID: part.callID, status: String(part.state.status), elapsed });
                     }
                 }
-                if (matches.length !== 1)
-                    continue;
+                if (matches.length !== 1) {
+                    const callID = matches.length === 0 ? await terminalCancelledMissionTask(reservation.unit_id, reservation.reservation_id, state.goal_id) : undefined;
+                    if (callID === undefined)
+                        continue;
+                    matches.push({ callID, status: "error", elapsed: null });
+                }
                 const match = matches[0];
                 // Reconcile lifecycle accounting only. Lost in-memory validation bindings cannot be
                 // reconstructed from worker prose and must not manufacture acceptance evidence.
@@ -7743,6 +7839,9 @@ export const SortieDogsPlugin = async (input, options) => {
         currentBudget: async (root) => {
             if (!isCoordinatorSession(root) && !await recoverCoordinatorRoot(root))
                 throw new Error("operator-coordinator-required");
+            // Planning must account for terminal native Tasks before reserving new units.
+            // Otherwise a cancelled predecessor keeps a stale unit reservation across missions.
+            await recoverCompletedGoalReservations(root);
             const state = await currentGoal(root);
             if (state.goal_id === null || state.budget === null)
                 return null;

package/dist/plugin/profiled.js

@@ -1139,7 +1139,7 @@ export function createProfiledPlugin(profile, assetVersion) {
             if (budget && budget.remaining_units < plan.units.length && !same)
                 throw new Error("mission-budget-exhausted: report the required cumulative extension to Operator");
             const state = await operators.prepareMission(root, plan, actor === root ? undefined
-                : { sessionID: actor, callID: mission.callID });
+                : { sessionID: actor, callID: mission.callID }, mission.supersededRunID);
             await restorePriorAcceptance(root, state);
             await control.registerGoalDeclaration(root, state.units[0].task.prompt, true);
             control.enableUnits(root, state.units.filter(unit => unit.status === "pending").length);
@@ -1149,6 +1149,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 item.runID = state.runID;
                 item.phase = "running";
                 item.submission = null;
+                delete item.supersededRunID;
             });
             return JSON.stringify(await operators.next(root, actor));
         }

package/package.json

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