sortie-dogs 0.12.7 → 0.12.8

package/dist/asset-version.d.ts

@@ -3,5 +3,5 @@
  * 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.12.7-review-convergence-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.8-mission-lineage-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,4 +3,4 @@
  * 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.12.7-review-convergence-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.8-mission-lineage-v1";

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

@@ -75,6 +75,8 @@ export declare class OperatorMissionRuntime {
     capture(root: string, request: MissionRequest): Promise<void>;
     start(root: string, requirements: unknown): Promise<OperatorMission>;
     update(root: string, change: (state: OperatorMission) => void): Promise<OperatorMission>;
+    /** Keep a cancelled same-turn run's host-accepted criteria ahead of new mission text. */
+    carryForward(root: string, missionID: string, acceptance: readonly string[]): 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. */

package/dist/core/operator-mission.js

@@ -58,7 +58,7 @@ export class OperatorMissionRuntime {
     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)
+            !["open", "running", "submitted", "cancelled"].includes(state.phase) || state.requests.length === 0)
             return state;
         const directory = join(this.projectRoot, this.profile.stateDirectory, "missions");
         let entries;
@@ -75,13 +75,18 @@ export class OperatorMissionRuntime {
         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 &&
+            if (previous?.root === root && previous.phase === "cancelled" &&
+                (previous.runID !== null || previous.supersededRunID !== undefined) &&
+                (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;
+        if (matches.length === 1) {
+            const predecessor = matches[0].runID ?? matches[0].supersededRunID;
+            if (predecessor && (matches[0].runID !== null || await this.archivedRun(root, predecessor))) {
+                state.supersededRunID = predecessor;
+            }
+        }
         return state;
     }
     /** Find exactly one archived cancelled mission that owned this run; ambiguity never grants recovery. */
@@ -178,8 +183,10 @@ export class OperatorMissionRuntime {
             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,
-                ...(previous?.phase === "cancelled" && previous.runID !== null && request.id !== previous.requests[0]?.id
-                    ? { supersededRunID: previous.runID } : {}) };
+                ...(previous?.phase === "cancelled" &&
+                    (previous.runID === null || request.id !== previous.requests[0]?.id) &&
+                    (previous.runID ?? previous.supersededRunID)
+                    ? { supersededRunID: (previous.runID ?? previous.supersededRunID) } : {}) };
             await this.save(this.file(root), state);
             return state;
         });
@@ -194,6 +201,23 @@ export class OperatorMissionRuntime {
             return state;
         });
     }
+    /** Keep a cancelled same-turn run's host-accepted criteria ahead of new mission text. */
+    carryForward(root, missionID, acceptance) {
+        return this.update(root, state => {
+            if (state.id !== missionID || state.supersededRunID !== undefined || state.runID !== null ||
+                !["open", "running"].includes(state.phase) || (state.dispatchOpen && state.coordinator === null) ||
+                acceptance.length === 0 || acceptance.some(text => typeof text !== "string" || !text.trim())) {
+                throw new Error("mission-acceptance-carry-forward-unavailable");
+            }
+            const existing = state.requirements.map(item => item.text);
+            if (acceptance.every((text, index) => existing[index] === text))
+                return;
+            const additions = existing.filter(text => !acceptance.includes(text));
+            if (acceptance.length + additions.length > 64)
+                throw new Error("mission-requirements-limit: carried acceptance and additions exceed 64");
+            state.requirements = [...acceptance, ...additions].map((text, index) => ({ id: `R${index + 1}`, text }));
+        });
+    }
     task(state) {
         return { subagent_type: profileAgent(this.profile, "dog-operator"), description: state.requirements[0].text.slice(0, 100),
             prompt: `${MISSION_REFERENCE}${JSON.stringify({ r: state.root, m: state.id, h: digest(JSON.stringify(state.requirements)) })}`,

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

@@ -245,7 +245,7 @@ export declare class OperatorRuntime {
     prepareMission(root: string, raw: unknown, dispatcher?: {
         sessionID: string;
         callID: string;
-    }, supersededRunID?: string): Promise<OperatorState>;
+    }, supersededRunID?: string, terminalChildren?: readonly string[]): Promise<OperatorState>;
     retireMissionRun(root: string): Promise<void>;
     private prepareOnce;
     operatorTask(state: OperatorState): OperatorTask;

package/dist/core/operator-runtime.js

@@ -678,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, supersededRunID) {
-        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, supersededRunID }));
+    prepareMission(root, raw, dispatcher, supersededRunID, terminalChildren = []) {
+        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, supersededRunID, terminalChildren }));
     }
     retireMissionRun(root) {
         return this.serial(root, async () => {
@@ -727,9 +727,15 @@ export class OperatorRuntime {
             previous.phase === "cancelled";
         if (mission?.supersededRunID !== undefined && !superseding)
             throw new Error("mission-superseded-run-mismatch");
+        const terminalChildren = mission?.terminalChildren ?? [];
+        const cancelledChildren = previous?.units.flatMap(unit => unit.status === "cancelled" && unit.childSessionID !== null
+            ? [unit.childSessionID] : []) ?? [];
         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"))) {
+            terminalChildren.length !== cancelledChildren.length || new Set(terminalChildren).size !== terminalChildren.length ||
+            cancelledChildren.some(id => !terminalChildren.includes(id)) || previous.units.some(unit => !["pending", "cancelled"].includes(unit.status) || unit.evidence.length > 0 || unit.resultClass !== null ||
+            unit.repairValidation !== null || (unit.status === "pending" && (unit.callID !== null || unit.childSessionID !== null)) ||
+            (unit.status === "cancelled" && (unit.childSessionID === null || unit.callID === null))))) {
             throw new Error("mission-superseded-run-has-work: reconcile prior workers and evidence before changing acceptance");
         }
         if (plan.git_lifecycle !== undefined) {
@@ -743,6 +749,14 @@ export class OperatorRuntime {
         // 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 = !superseding && previous?.phase === "cancelled" ? previous : undefined;
+        if (parent?.decision === "explicit-cancellation") {
+            const cancelled = parent.units.flatMap(unit => unit.status === "cancelled" && unit.childSessionID !== null
+                ? [unit.childSessionID] : []);
+            if (cancelled.length > 0 && (new Set(terminalChildren).size !== terminalChildren.length ||
+                cancelled.some(id => !terminalChildren.includes(id)))) {
+                throw new Error("mission-cancelled-run-worker-not-terminal");
+            }
+        }
         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.

package/dist/plugin/profiled.d.ts

@@ -1,3 +1,4 @@
+import { type OperatorState } from "../core/operator-runtime.js";
 import { type RuntimeProfile } from "../core/runtime-profile.js";
 import { type OpenCodePlugin } from "./index.js";
 import { type CatalogModel } from "./model-routing.js";
@@ -20,6 +21,13 @@ export declare function previewModelCatalog(routes?: readonly {
     readonly model: string;
     readonly variant: string;
 }[], base?: readonly CatalogModel[]): readonly CatalogModel[];
+/** Native V2 termination and lineage are required before a cancelled Worker loses its old acceptance. */
+export declare function terminalCancelledMissionChildren(profile: RuntimeProfile, root: string, previous: OperatorState, budget: {
+    reserved_units: number;
+} | null, host: {
+    get(id: string): Promise<unknown>;
+    children(id: string): Promise<unknown>;
+}): Promise<string[]>;
 /** One transport namespace around the existing MkII engine; no second write gate or acceptance engine. */
 export declare function createProfiledPlugin(profile: RuntimeProfile, assetVersion: string): OpenCodePlugin;
 export declare const SortieDogsV010Plugin: OpenCodePlugin;

package/dist/plugin/profiled.js

@@ -82,6 +82,34 @@ export function previewModelCatalog(routes = PREVIEW_ROUTES, base = BUILT_IN_MOD
 }
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 const payload = (value) => record(value) && "data" in value ? value.data : value;
+/** Native V2 termination and lineage are required before a cancelled Worker loses its old acceptance. */
+export async function terminalCancelledMissionChildren(profile, root, previous, budget, host) {
+    if (!budget || budget.reserved_units !== 0)
+        throw new Error("mission-superseded-run-reservations-pending");
+    const oldWorkers = previous.units.flatMap(unit => unit.childSessionID === null ? [] : [unit.childSessionID]);
+    if (oldWorkers.length === 0)
+        return [];
+    const coordinatorID = previous.operatorSessionID;
+    const coordinator = coordinatorID && await host.get(coordinatorID);
+    if (coordinatorID === null || !record(coordinator) || coordinator.parentID !== root ||
+        canonicalAgent(profile, coordinator.agent) !== "dog-operator" || coordinator.outcome !== "interrupted") {
+        throw new Error("mission-superseded-coordinator-not-terminal");
+    }
+    const children = await host.children(coordinatorID);
+    if (!Array.isArray(children) || children.length !== oldWorkers.length ||
+        children.some(child => !record(child) || !oldWorkers.includes(child.id))) {
+        throw new Error("mission-superseded-worker-lineage-unproven");
+    }
+    for (const id of oldWorkers) {
+        const worker = await host.get(id), descendants = await host.children(id);
+        if (!record(worker) || worker.parentID !== coordinatorID ||
+            !["dog-worker", "dog-luna-worker"].includes(canonicalAgent(profile, worker.agent) ?? "") ||
+            worker.outcome !== "interrupted" || !Array.isArray(descendants) || descendants.length !== 0) {
+            throw new Error("mission-superseded-worker-not-terminal");
+        }
+    }
+    return oldWorkers;
+}
 const RUNTIME_PROFILE_SESSION_INACTIVE = "runtime-profile-session-inactive: non-profile agents retain native read, edit, patch, shell, and task tools; continue directly without Sortie profile tools";
 const fallbackOptionalSchema = (schema) => record(schema) && schema.type === "string" && typeof schema.optional !== "function"
     ? { ...schema, "x-sortie-optional": true }
@@ -406,6 +434,19 @@ export function createProfiledPlugin(profile, assetVersion) {
             }
             return packet;
         }
+        async function retainCancelledMissionAcceptance(root, mission, prior) {
+            const previous = prior ?? await operators.read(root);
+            if (previous?.phase !== "cancelled" || mission.supersededRunID !== undefined || mission.runID !== null)
+                return mission;
+            // A different original user request needs the explicit, host-proven supersession path.
+            // Only the same source can retain a cancelled run's acceptance as a prefix.
+            if (previous.sourceRefs[0] !== `user:${mission.requests[0]?.id}` ||
+                !previous.sourceRefs.every(ref => mission.requests.some(request => ref === `user:${request.id}`))) {
+                throw new Error("mission-cancelled-source-unproven");
+            }
+            return previous.acceptance.every((text, index) => mission.requirements[index]?.text === text)
+                ? mission : missions.carryForward(root, mission.id, previous.acceptance);
+        }
         async function restorePriorAcceptance(root, state) {
             const succeeded = [...state.units].reverse().find(unit => unit.status === "succeeded");
             const current = succeeded === undefined ? undefined : {
@@ -1115,21 +1156,24 @@ export function createProfiledPlugin(profile, assetVersion) {
             } };
         const startMission = `${profile.toolPrefix}start_mission`, planUnits = `${profile.toolPrefix}plan_units`, reviewMission = `${profile.toolPrefix}review_mission`, submitMission = `${profile.toolPrefix}submit_mission`, completeMission = `${profile.toolPrefix}complete_mission`, expandUnit = `${profile.toolPrefix}expand_unit`;
         const stringList = { type: "array", items: { type: "string" } };
-        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.",
+        tools[startMission] = { description: "Operator: save a few one-line requirements/negative constraints. The original user message, IDs and ownership are captured automatically. A cancelled same-turn run's accepted criteria are restored from host state in their exact order before dispatch. 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.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." });
+                return serializeDispatchTransition(context.sessionID, async () => {
+                    await reconcileMissionDispatch(context.sessionID);
+                    const mission = await retainCancelledMissionAcceptance(context.sessionID, await missions.start(context.sessionID, args.requirements));
+                    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 previous = await operators.read(root);
+            mission = await retainCancelledMissionAcceptance(root, mission, previous);
             const plan = missionPlan(mission, raw);
             if (actor === root && (mission.coordinator !== null || plan.units.length !== 1))
                 throw new Error("mission-coordinator-required: dispatch the returned Coordinator task");
-            const previous = await operators.read(root);
             const same = previous?.planHash === createHash("sha256").update(JSON.stringify(plan)).digest("hex");
             if (previous && !["completed", "cancelled"].includes(previous.phase) && !same) {
                 if (!reason?.trim())
@@ -1139,8 +1183,19 @@ export function createProfiledPlugin(profile, assetVersion) {
             const budget = await control.currentBudget(root);
             if (budget && budget.remaining_units < plan.units.length && !same)
                 throw new Error("mission-budget-exhausted: report the required cumulative extension to Operator");
+            // Cancellation marks the durable units before interrupting their native sessions. A cancelled
+            // status alone therefore cannot prove the old Worker stopped or its reservation settled.
+            const cancelledPredecessor = previous?.phase === "cancelled" &&
+                (mission.supersededRunID === previous.runID ||
+                    (mission.supersededRunID === undefined && previous.decision === "explicit-cancellation" &&
+                        previous.units.some(unit => unit.status === "cancelled" && unit.childSessionID !== null)));
+            const terminalChildren = cancelledPredecessor
+                ? await terminalCancelledMissionChildren(profile, root, previous, budget, {
+                    get: async (id) => payload(await session("get", { path: { id }, query: { directory: input.directory } })),
+                    children: async (id) => payload(await session("children", { path: { id }, query: { directory: input.directory } })),
+                }) : [];
             const state = await operators.prepareMission(root, plan, actor === root ? undefined
-                : { sessionID: actor, callID: mission.callID }, mission.supersededRunID);
+                : { sessionID: actor, callID: mission.callID }, mission.supersededRunID, terminalChildren);
             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);
@@ -1860,8 +1915,20 @@ export function createProfiledPlugin(profile, assetVersion) {
             },
             "experimental.chat.system.transform": async (request, output) => {
                 const root = await rootFor(request.sessionID) ?? await proposalPromptRoot(request.sessionID);
-                if (!root)
+                if (!root) {
+                    const who = await identity(request.sessionID);
+                    if (who.parent === undefined && who.role === undefined &&
+                        (await missions.read(request.sessionID))?.phase === "cancelled") {
+                        // OpenCode retains the same conversation when the user switches agents. A prior
+                        // INTERRUPTED report describes only its Sortie run; it cannot revoke Build's
+                        // native tools or turn a new independent request into a cancelled mission.
+                        (output.system ??= []).push("SORTIE_PROFILE_INACTIVE: This is a non-Sortie agent. " +
+                            "Any earlier INTERRUPTED mission or cancelled operator run in this session is historical state of the Sortie profile, " +
+                            "not a restriction on this agent's current user request. Use the current agent's native tools for independent work. " +
+                            "Do not revive, overwrite or claim completion of that historical Sortie run.");
+                    }
                     return;
+                }
                 await core["experimental.chat.system.transform"]?.(request, output);
                 (output.system ??= []).push(`SORTIE_RUNTIME_PROFILE ${profile.id}; marker ${assetVersion}. ` +
                     `Shared MkII protocol role names are logical: ${protocolMap}. Use only ${profile.toolPrefix} tools for this profile. ` +

package/dist/plugin/v2.js

@@ -63,13 +63,14 @@ function legacyMessage(value, session, agent) {
     if (!record(value) || typeof value.id !== "string" || typeof value.type !== "string")
         return undefined;
     const id = value.id;
+    const originalAgent = record(value.metadata) ? string(value.metadata.agent) ?? agent : agent;
     if (value.type === "user") {
-        return { info: { id, sessionID: session, role: "user", agent, time: value.time },
+        return { info: { id, sessionID: session, role: "user", agent: originalAgent, time: value.time },
             parts: [{ id: `${id}-text`, sessionID: session, messageID: id, type: "text", text: String(value.text ?? "") }] };
     }
     if (value.type !== "assistant") {
         if (value.type === "synthetic")
-            return { info: { id, sessionID: session, role: "user", agent, time: value.time },
+            return { info: { id, sessionID: session, role: "user", agent: originalAgent, time: value.time },
                 parts: [{ id: `${id}-text`, sessionID: session, messageID: id, type: "text", text: String(value.text ?? ""), synthetic: true }] };
         return undefined;
     }

package/package.json

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