sortie-dogs 0.12.3 → 0.12.5

package/README.md

@@ -42,8 +42,8 @@ npm install --save-dev sortie-dogs
 npx sortie-dogs init .
 ```
 
-The package retains the `v010` profile/namespace for compatibility. Add the OpenCode V2 plugin and the required
-two-level subagent depth to `.opencode/opencode.json`, preserving existing values:
+The package retains the `v010` profile/namespace for compatibility. `init` adds the OpenCode V2 plugin and the required
+two-level subagent depth to `.opencode/opencode.json(c)`, preserving existing settings:
 
 ```json
 {
@@ -62,8 +62,8 @@ Selecting `dog-operator` directly starts the same workflow. `dog-operator` is th
 only user-facing v0.10 authority. `dogs-coordinator` and every `*-v010` role are
 internal children and must not be selected as task entry points.
 
-`init` installs runtime assets; the `plugins` entry loads runtime enforcement and
-model routing. Both are required. A new session alone does not reload an updated
+`init` installs runtime assets and merges the required OpenCode settings; the `plugins` entry loads runtime enforcement and
+model routing. A new session alone does not reload an updated
 plugin process, so restart OpenCode after installation or upgrade.
 
 ## v0.12.0 workflow
@@ -262,9 +262,8 @@ npm install --global sortie-dogs
 sortie-dogs init --global --profile v010
 ```
 
-Then add `sortie-dogs` and `experimental.subagent_depth: 2` to the global OpenCode config.
-Global initialization installs assets only; it does not silently change the
-default agent or merge user settings.
+Global initialization also merges `sortie-dogs` and `experimental.subagent_depth: 2` into the
+global OpenCode config, preserving unrelated settings and the default agent.
 
 ## Updates and removal
 

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/initialize.js

@@ -11,6 +11,7 @@ import { constants } from "node:fs";
 import { lstat, mkdir, open, readFile, realpath, rm, rmdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { applyEdits, modify, parse } from "jsonc-parser";
 import { RUNTIME_PROFILES } from "./runtime-profile.js";
 const assets = await import(__rewriteRelativeImportExtension(`../runtime-assets.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`));
 const { runtimeAssets } = assets;
@@ -348,6 +349,46 @@ function layoutLegacyPath(asset, layout) {
         ? asset.relativePath.slice(`${OPEN_CODE_DIRECTORY}/`.length)
         : asset.relativePath;
 }
+async function v010Config(root, global) {
+    const prefix = global ? "" : `${OPEN_CODE_DIRECTORY}/`;
+    const json = `${prefix}opencode.json`, jsonc = `${prefix}opencode.jsonc`;
+    const presentJSON = await assertSafeExistingPath(root, json, true);
+    const presentJSONC = await assertSafeExistingPath(root, jsonc, true);
+    if (presentJSON && presentJSONC)
+        throw new ProjectInitializationError("conflict", "Both OpenCode JSON and JSONC configs exist; choose one before initialization.");
+    const relativePath = presentJSONC ? jsonc : json;
+    const previous = presentJSONC || presentJSON ? await readFile(resolve(root, relativePath)) : undefined;
+    let content = previous?.toString("utf8") ?? "{}\n";
+    const errors = [];
+    const config = parse(content, errors, { allowTrailingComma: true });
+    if (errors.length || config === null || typeof config !== "object" || Array.isArray(config)) {
+        throw new ProjectInitializationError("conflict", `OpenCode config ${relativePath} must be a valid JSON/JSONC object.`);
+    }
+    const current = config;
+    const plugins = current.plugins;
+    if (plugins !== undefined && (!Array.isArray(plugins) || !plugins.every(item => typeof item === "string" ||
+        (item !== null && typeof item === "object" && !Array.isArray(item) && typeof item.package === "string")))) {
+        throw new ProjectInitializationError("conflict", `OpenCode config ${relativePath} has an invalid plugins list.`);
+    }
+    if (current.experimental !== undefined && (current.experimental === null || typeof current.experimental !== "object" ||
+        Array.isArray(current.experimental)))
+        throw new ProjectInitializationError("conflict", `OpenCode config ${relativePath} has invalid experimental settings.`);
+    const depth = current.experimental?.subagent_depth;
+    if (depth !== undefined && (!Number.isSafeInteger(depth) || depth < 0)) {
+        throw new ProjectInitializationError("conflict", `OpenCode config ${relativePath} has an invalid subagent depth.`);
+    }
+    const options = { formattingOptions: { insertSpaces: true, tabSize: 2 } };
+    const update = (path, value) => { content = applyEdits(content, modify(content, path, value, options)); };
+    if (!plugins?.some(item => item === "sortie-dogs" ||
+        (item !== null && typeof item === "object" && item.package === "sortie-dogs"))) {
+        update(["plugins"], [...(plugins ?? []), "sortie-dogs"]);
+    }
+    if (depth === undefined || depth < 2)
+        update(["experimental", "subagent_depth"], 2);
+    if (previous?.toString("utf8") === content)
+        return undefined;
+    return { entry: { relativePath, content }, previous };
+}
 async function initializeRoot(requestedRoot, layout, installAssets = runtimeAssets) {
     const root = resolve(requestedRoot);
     const legacyAssets = layout.legacyAssets ?? LEGACY_RUNTIME_ASSETS;
@@ -355,6 +396,7 @@ async function initializeRoot(requestedRoot, layout, installAssets = runtimeAsse
     if (rootInfo === undefined || !rootInfo.isDirectory() || rootInfo.isSymbolicLink()) {
         throw new ProjectInitializationError("invalid-project", layout.invalidRootMessage);
     }
+    const configUpdate = layout.configureV010 ? await v010Config(root, layout.assetPrefix === "") : undefined;
     const version = assetVersion(installAssets);
     const assetEntries = installAssets.map(({ installPath, content }) => ({
         relativePath: safeAssetPath(installPath, layout.assetPrefix),
@@ -381,7 +423,7 @@ async function initializeRoot(requestedRoot, layout, installAssets = runtimeAsse
     const markerText = existing[markerIndex];
     const matches = (entry, index) => existing[index]?.equals(Buffer.from(entry.content)) ?? false;
     const assetsMatch = assetEntries.every(matches);
-    if (markerText !== undefined && parseMarker(markerText.toString("utf8")) === version && assetsMatch) {
+    if (markerText !== undefined && parseMarker(markerText.toString("utf8")) === version && assetsMatch && !configUpdate) {
         if (layout.controlIgnore ?? !layout.preserveAllLegacy)
             await ensureProjectLunaControlIgnore(root);
         return {
@@ -449,6 +491,18 @@ async function initializeRoot(requestedRoot, layout, installAssets = runtimeAsse
                 });
             }
         }
+        if (configUpdate) {
+            const { entry, previous } = configUpdate;
+            const parent = dirname(entry.relativePath).replaceAll("\\", "/");
+            if (parent !== ".")
+                await ensureDirectory(root, parent, createdDirectories);
+            if (previous === undefined)
+                await createFile(resolve(root, entry.relativePath), entry.content, createdFiles);
+            else
+                await overwriteFileSafely(root, entry.relativePath, entry.content, () => {
+                    modifiedFiles.push({ relativePath: entry.relativePath, content: previous });
+                });
+        }
         for (const { asset } of removableLegacyFiles) {
             const state = await readableOwnedLegacyFile(root, asset);
             if (!Buffer.isBuffer(state)) {
@@ -478,7 +532,7 @@ async function initializeRoot(requestedRoot, layout, installAssets = runtimeAsse
     return {
         status: "installed",
         version,
-        installedPaths: entries.map(({ relativePath }) => relativePath),
+        installedPaths: [...entries.map(({ relativePath }) => relativePath), ...(configUpdate ? [configUpdate.entry.relativePath] : [])],
         preservedLegacyPaths,
     };
 }
@@ -502,7 +556,7 @@ export async function resolveGlobalConfigRoot(env = process.env, home = homedir(
         return resolve(env.XDG_CONFIG_HOME, "opencode");
     return resolve(home, ".config", "opencode");
 }
-/** Installs the packaged runtime into one existing project without changing user settings. */
+/** Installs the packaged runtime into one existing project, preserving unrelated user settings. */
 async function profileInstallation(id, global) {
     if (!Object.hasOwn(RUNTIME_PROFILES, id))
         throw new ProjectInitializationError("invalid-project", "Unknown runtime profile.");
@@ -515,7 +569,7 @@ async function profileInstallation(id, global) {
     return { layout: { ...(global ? GLOBAL_LAYOUT : PROJECT_LAYOUT),
             markerPath: global ? profile.markerFile : `${OPEN_CODE_DIRECTORY}/${profile.markerFile}`,
             preserveAllLegacy: false, controlIgnore: false, legacyAssets: V010_ROLE_NAME_LEGACY_ASSETS,
-            renamedTargets: ["agent/dog-operator.md", "agent/dogs-coordinator.md"] }, assets: module.runtimeAssets };
+            renamedTargets: ["agent/dog-operator.md", "agent/dogs-coordinator.md"], configureV010: true }, assets: module.runtimeAssets };
 }
 export async function initializeProject(projectRoot = process.cwd(), profile = "stable") {
     const install = await profileInstallation(profile, false);

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>;
@@ -60,6 +66,8 @@ export declare class OperatorMissionRuntime {
     update(root: string, change: (state: OperatorMission) => void): Promise<OperatorMission>;
     task(state: OperatorMission): OperatorTask;
     admit(root: string, callID: string, args: Record<string, unknown>): Promise<OperatorMission>;
+    /** Reopen only the exact dispatch whose native Task has a terminal record after a server restart. */
+    reconcileFinishedDispatch(root: string, missionID: string, callID: string): Promise<OperatorMission>;
     claim(root: string, child: string, prompt: string): Promise<string>;
     brief(state: OperatorMission): string;
 }

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);
@@ -144,6 +199,15 @@ export class OperatorMissionRuntime {
             state.submission = null;
         });
     }
+    /** Reopen only the exact dispatch whose native Task has a terminal record after a server restart. */
+    reconcileFinishedDispatch(root, missionID, callID) {
+        return this.update(root, state => {
+            if (state.id !== missionID || state.callID !== callID || !state.dispatchOpen ||
+                ["cancelled", "completed"].includes(state.phase))
+                throw new Error("mission-dispatch-reconciliation-stale");
+            state.dispatchOpen = false;
+        });
+    }
     async claim(root, child, prompt) {
         const state = await this.update(root, state => {
             if (state.phase !== "running" || !state.dispatchOpen || !state.callID ||

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/index.d.ts

@@ -1,3 +1,4 @@
+export { default } from "./plugin/v2.js";
 export { lintHandoff } from "./core/validate-semantics.js";
 export { validateWorktreeParallelContract } from "./core/validate-worktree-parallel.js";
 export { LUNA_FABRIC_CONTRACT_VERSION, admitLunaFabric, } from "./core/luna-fabric-contract.js";

package/dist/index.js

@@ -1,3 +1,5 @@
+// OpenCode V2 loads the package root named in `plugins`; keep the public named API intact.
+export { default } from "./plugin/v2.js";
 export { lintHandoff } from "./core/validate-semantics.js";
 export { validateWorktreeParallelContract } from "./core/validate-worktree-parallel.js";
 export { LUNA_FABRIC_CONTRACT_VERSION, admitLunaFabric, } from "./core/luna-fabric-contract.js";

package/dist/plugin/index.js

@@ -13,6 +13,7 @@ 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";
@@ -1609,6 +1610,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 +1763,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 +7824,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/opencode.d.ts

@@ -1,14 +1,14 @@
 /**
- * Dedicated import entry point for OpenCode plugin wrappers.
+ * OpenCode V2's package loader resolves the `./plugin` export. Expose its
+ * default definition here as well as the named V1 factory used by wrappers.
  *
- * OpenCode configuration lists the package name in the `plugin` array:
- * `"plugin": ["sortie-dogs"]`. Files such as `.opencode/plugins/*.ts` use
+ * OpenCode configuration lists the package name in the `plugins` array:
+ * `"plugins": ["sortie-dogs"]`. V1 wrappers can still use
  * `import { SortieDogsPlugin } from "sortie-dogs/plugin"`.
  *
- * OpenCode treats every runtime export of a loaded plugin module as a plugin factory and calls
- * each one with the plugin input. A non-factory runtime export therefore fails the whole module
- * load and silently disables the plugin. This entry exposes the factory and nothing else; every
- * other runtime symbol stays on the package root.
+ * OpenCode V2 requires a default definition with an id and setup or effect function.
+ * Keep other runtime symbols on the package root rather than this shared entry.
  */
 export { SortieDogsV010Plugin as SortieDogsPlugin } from "./profiled.js";
+export { default } from "./v2.js";
 export type { OpenCodeEvent, OpenCodeHooks, OpenCodePlugin, OpenCodePluginInput, SortieDogsPluginOptions, } from "./index.js";

package/dist/plugin/opencode.js

@@ -1,13 +1,13 @@
 /**
- * Dedicated import entry point for OpenCode plugin wrappers.
+ * OpenCode V2's package loader resolves the `./plugin` export. Expose its
+ * default definition here as well as the named V1 factory used by wrappers.
  *
- * OpenCode configuration lists the package name in the `plugin` array:
- * `"plugin": ["sortie-dogs"]`. Files such as `.opencode/plugins/*.ts` use
+ * OpenCode configuration lists the package name in the `plugins` array:
+ * `"plugins": ["sortie-dogs"]`. V1 wrappers can still use
  * `import { SortieDogsPlugin } from "sortie-dogs/plugin"`.
  *
- * OpenCode treats every runtime export of a loaded plugin module as a plugin factory and calls
- * each one with the plugin input. A non-factory runtime export therefore fails the whole module
- * load and silently disables the plugin. This entry exposes the factory and nothing else; every
- * other runtime symbol stays on the package root.
+ * OpenCode V2 requires a default definition with an id and setup or effect function.
+ * Keep other runtime symbols on the package root rather than this shared entry.
  */
 export { SortieDogsV010Plugin as SortieDogsPlugin } from "./profiled.js";
+export { default } from "./v2.js";

package/dist/plugin/profiled.js

@@ -376,6 +376,35 @@ export function createProfiledPlugin(profile, assetVersion) {
                 throw new Error("mission-controller-required");
             return { root, mission };
         }
+        async function reconcileMissionDispatch(root) {
+            const mission = await missions.read(root);
+            if (!mission?.dispatchOpen || !mission.callID || ["cancelled", "completed"].includes(mission.phase) ||
+                taskOwners.has(mission.callID))
+                return mission;
+            const history = await messages(root);
+            const finished = history.flatMap(message => Array.isArray(message.parts) ? message.parts : []).filter(part => record(part) && part.type === "tool" && part.tool === "task" && part.callID === mission.callID &&
+                record(part.state) && ["completed", "error"].includes(String(part.state.status)) &&
+                record(part.state.input) && part.state.input.subagent_type === profileAgent(profile, "dog-operator") &&
+                (part.state.input.task_id === undefined || part.state.input.task_id === mission.coordinator) &&
+                (mission.coordinator !== null || (part.state.input.prompt === missions.task(mission).prompt &&
+                    part.state.input.task_id === undefined)));
+            if (finished.length !== 1)
+                return mission;
+            if (mission.coordinator !== null) {
+                const who = await identity(mission.coordinator);
+                if (who.parent !== root || who.role !== "dog-operator")
+                    return mission;
+            }
+            return missions.reconcileFinishedDispatch(root, mission.id, mission.callID);
+        }
+        function missionDispatchPacket(mission, run) {
+            const packet = missionPacket(mission, run);
+            if (!mission.dispatchOpen && ["open", "running"].includes(mission.phase)) {
+                return { ...packet, task: missions.task(mission),
+                    next_action: "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." };
+            }
+            return packet;
+        }
         async function restorePriorAcceptance(root, state) {
             const succeeded = [...state.units].reverse().find(unit => unit.status === "succeeded");
             const current = succeeded === undefined ? undefined : {
@@ -608,12 +637,17 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const root = await rootFor(context.sessionID);
                 if (!root)
                     throw new Error("operator-grant-invalid");
+                const activeMission = await reconcileMissionDispatch(root);
+                if (activeMission && context.sessionID === root && !activeMission.dispatchOpen &&
+                    ["open", "running"].includes(activeMission.phase)) {
+                    return JSON.stringify({ ...missionDispatchPacket(activeMission, await operators.read(root)), budget: await control.currentBudget(root) });
+                }
                 const result = await operators.next(root, context.sessionID);
                 const mission = await missions.read(root);
                 if (mission && !["cancelled", "completed"].includes(mission.phase)) {
                     if (record(result) && record(result.task))
                         return JSON.stringify(result);
-                    return JSON.stringify({ ...missionPacket(mission, await operators.required(root)), budget: await control.currentBudget(root) });
+                    return JSON.stringify({ ...missionDispatchPacket(mission, await operators.required(root)), budget: await control.currentBudget(root) });
                 }
                 if (context.sessionID === root && record(result) && record(result.task)) {
                     const state = await operators.required(root);
@@ -652,9 +686,9 @@ export function createProfiledPlugin(profile, assetVersion) {
         tools[status] = { description: "Read the durable root-owned operator outcome and host budget counters (max_units, consumed_units, reserved_units, remaining_units) without claiming acceptance or retrying work. An investigating proposal returns its exact short Task reference only before a Task has been admitted; an existing admission never yields a redispatch Task.",
             args: {}, execute: async (_args, context) => {
                 const root = await rootFor(context.sessionID);
-                const mission = root ? await missions.read(root) : undefined;
+                const mission = root && context.sessionID === root ? await reconcileMissionDispatch(root) : root ? await missions.read(root) : undefined;
                 if (mission && (context.sessionID === root || context.sessionID === mission.coordinator)) {
-                    return JSON.stringify({ ...missionPacket(mission, await operators.read(root)), budget: await control.currentBudget(root) });
+                    return JSON.stringify({ ...missionDispatchPacket(mission, await operators.read(root)), budget: await control.currentBudget(root) });
                 }
                 await requireRoot(context.sessionID);
                 const state = await operators.read(context.sessionID);
@@ -1083,9 +1117,12 @@ export function createProfiledPlugin(profile, assetVersion) {
         tools[startMission] = { description: "Operator: save a few one-line requirements/negative constraints. The original user message, IDs and ownership are captured automatically. Dispatch the returned Coordinator task immediately, or use plan_units for a simple single-unit Fast-lane task.",
             args: { requirements: { ...stringList, minItems: 1, maxItems: 64 } }, execute: async (args, context) => {
                 await requireRoot(context.sessionID);
+                await reconcileMissionDispatch(context.sessionID);
                 const mission = await missions.start(context.sessionID, args.requirements);
-                return JSON.stringify({ mission_id: mission.id, requirements: mission.requirements, task: missions.task(mission),
-                    next_action: "Nontrivial: dispatch task now. Simple single-unit work with known scope/check: call plan_units directly. Do not create a proposal or ask for plan approval." });
+                return JSON.stringify(mission.dispatchOpen
+                    ? missionDispatchPacket(mission, await operators.read(context.sessionID))
+                    : { mission_id: mission.id, requirements: mission.requirements, task: missions.task(mission),
+                        next_action: "Nontrivial: dispatch task now. Simple single-unit work with known scope/check: call plan_units directly. Do not create a proposal or ask for plan approval." });
             } };
         async function declareMissionUnits(root, actor, mission, raw, reason) {
             const plan = missionPlan(mission, raw);
@@ -1102,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);
@@ -1112,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));
         }
@@ -1498,6 +1536,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 if (request.tool === "task" && args.subagent_type === profileAgent(profile, "dog-operator") &&
                     mission && !["completed", "cancelled"].includes(mission.phase)) {
                     await requireRoot(request.sessionID);
+                    await reconcileMissionDispatch(root);
                     await missions.admit(root, request.callID, args);
                     taskOwners.set(request.callID, { root, actor: request.sessionID, operator: false, mission: true });
                     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.12.3",
+  "version": "0.12.5",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",
@@ -72,7 +72,8 @@
   },
   "dependencies": {
     "ajv": "^8.17.1",
-    "ajv-formats": "^3.0.1"
+    "ajv-formats": "^3.0.1",
+    "jsonc-parser": "^3.3.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",