sortie-dogs 0.5.10 → 0.5.13

package/dist/plugin/index.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { lstat, open, readFile, realpath, rm, stat } from "node:fs/promises";
+import { lstat, mkdir, open, readFile, realpath, rm, stat } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { RUNTIME_ASSET_VERSION } from "../asset-version.js";
 import { normalizeRelativePath, RelativePathError } from "../core/path.js";
@@ -8,6 +8,7 @@ import { produceWorktreeCommitArtifact, recoverWorktreeCommitArtifact, resolveVa
 import { normalizeWorktreeScope } from "../core/worktree-scope.js";
 import { ParallelDispatchCoordinator, ParallelDispatchError, } from "../core/worktree-parallel-dispatch.js";
 import { IntegrationQueueError, WorktreeIntegrationQueue } from "../core/worktree-integration-queue.js";
+import { WorktreeLifecycleError } from "../core/worktree-lifecycle.js";
 import { validateManifest } from "../core/validate-manifest.js";
 import { safeSchemaPointer, validateHandoffSchema, validateOperationManifestSchema, } from "../core/validate-schema.js";
 import { DEFAULT_PLUGIN_OPTIONS, resolvePluginConfiguration, resolvePluginConfigurationSourcesWithGlobal, } from "./config.js";
@@ -32,6 +33,8 @@ const SORTIE_TRIGGER = /^\/sortie(?:\s|$)/;
 const TASK_ROLES = new Set(["implementation", "remediation", "blocker-resolution"]);
 const GIT_POINTER_LIMIT = 4096;
 const PARALLEL_OUTCOME_MARKER = "SORTIE_PARALLEL_OUTCOME";
+const CANONICAL_CONTRACT_DIRECTORY = ".sortie-dogs/contracts";
+const CANONICAL_CONTRACT_HANDOFF = `${CANONICAL_CONTRACT_DIRECTORY}/handoff.json`;
 export const PARALLEL_COMMIT_ARTIFACT_CAPABILITY = "sortie_create_parallel_commit_artifact";
 const CONTRACT_DEFECTS = { limit: 8, pointerCharacters: 120 };
 function contractPointer(pointer) {
@@ -273,7 +276,7 @@ function readEnvironmentConfig() {
 }
 function loadConfigured(config, handoffBase, client) {
     const handoffPaths = config.handoffPaths.map((path) => resolve(handoffBase, path));
-    const handoffRelativePaths = config.handoffPaths.flatMap((path) => {
+    const handoffRelativePaths = [CANONICAL_CONTRACT_HANDOFF, ...config.handoffPaths].flatMap((path) => {
         try {
             return [normalizeRelativePath(path)];
         }
@@ -558,37 +561,6 @@ function taskContractText(text) {
     }
     return text;
 }
-function taskValidationCommand(text) {
-    const values = taskInlineValues(text, ["validation"]);
-    if (values.length === 1) {
-        const value = values[0];
-        const start = /(?:^|[{,])\s*command\s*:\s*/iu.exec(value);
-        if (start !== null) {
-            const remainder = value.slice(start.index + start[0].length);
-            const end = remainder.search(/,\s*diagnostics\s*:/iu);
-            if (end >= 0)
-                return unquoteValue(remainder.slice(0, end).trim());
-        }
-    }
-    const lines = text.split(/\r?\n/u);
-    const header = lines.findIndex((line) => /^\s*validation\s*:\s*$/iu.test(line));
-    if (header < 0)
-        return undefined;
-    const baseIndent = /^\s*/u.exec(lines[header])[0].replaceAll("\t", "  ").length;
-    for (let index = header + 1; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (line.trim().length === 0)
-            continue;
-        const indent = /^\s*/u.exec(line)[0].replaceAll("\t", "  ").length;
-        if (indent <= baseIndent)
-            break;
-        const match = HANDOFF_ENTRY.exec(line);
-        if (match !== null && (match[2] ?? match[3]).toLowerCase() === "command") {
-            return unquoteValue(unwrapMarkdownValue(match[4]));
-        }
-    }
-    return undefined;
-}
 function isBlockTaskHandoff(text) {
     const inline = (keys) => taskInlineValues(text, keys);
     const present = (keys) => inline(keys).length === 1 || taskBlockHasContent(text, keys);
@@ -872,7 +844,6 @@ export const SortieDogsPlugin = async (input, options) => {
     (sessionID) => isCoordinatorSession(sessionID)
         ? { agent: COORDINATOR_AGENT, parentID: undefined }
         : undefined);
-    const normalizedCoordinatorDrifts = new Set();
     const completedCoordinatorMessages = new Set();
     const completedCoordinatorParts = new Set();
     async function ensureLoaded() {
@@ -955,6 +926,7 @@ export const SortieDogsPlugin = async (input, options) => {
     const coordinatorRoots = new Map();
     const bootstrapIdleWarnings = new Set();
     const coordinatorTaskCalls = new Map();
+    const chatTransitions = new Map();
     const reflectionOwnedRoots = new Set();
     const reflectionClosingRoots = new Set();
     const reflectionInFlight = new Map();
@@ -962,6 +934,7 @@ export const SortieDogsPlugin = async (input, options) => {
     const bindingDenials = new Map();
     const expiredSessions = new Set();
     const sessionParents = new Map();
+    const knownChildSessions = new Set();
     const sessionRoots = new Map();
     const sessionTaskIDs = new Map();
     const recoverableWorkerChildren = new Set();
@@ -1024,12 +997,23 @@ export const SortieDogsPlugin = async (input, options) => {
         let manifests = 0;
         let handoffs = 0;
         for (const absolute of absolutes) {
-            if (!await project.contains(absolute) || dirname(absolute) !== project.root)
+            const relativePath = relative(project.root, absolute).replaceAll("\\", "/");
+            const canonical = relativePath.startsWith(`${CANONICAL_CONTRACT_DIRECTORY}/`) &&
+                relativePath.split("/").length === 3;
+            if (!await project.contains(absolute) || (!canonical && dirname(absolute) !== project.root))
                 return false;
             const name = basename(absolute);
-            if (name === "operation-manifest.json" || name.endsWith(".operation-manifest.json"))
+            if (canonical) {
+                if (/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}\.operation-manifest\.json$/u.test(name))
+                    manifests += 1;
+                else if (/^handoff\.[A-Za-z0-9][A-Za-z0-9._-]{0,127}\.json$/u.test(name))
+                    handoffs += 1;
+                else
+                    return false;
+            }
+            else if (name === "operation-manifest.json" || name.endsWith(".operation-manifest.json"))
                 manifests += 1;
-            else if (name === "handoff.json" || (/^handoff[.-].+\.json$/u.test(name)))
+            else if (name === "handoff.json" || /^handoff[.-].+\.json$/u.test(name))
                 handoffs += 1;
             else
                 return false;
@@ -1184,16 +1168,44 @@ export const SortieDogsPlugin = async (input, options) => {
     }
     function parallelControlPaths(descriptor) {
         return {
-            handoff_path: join(descriptor.managed_path, `handoff.${descriptor.task_id}.json`),
-            operation_manifest: join(descriptor.managed_path, `${descriptor.task_id}.operation-manifest.json`),
+            handoff_path: join(descriptor.managed_path, CANONICAL_CONTRACT_DIRECTORY, `handoff.${descriptor.task_id}.json`),
+            operation_manifest: join(descriptor.managed_path, CANONICAL_CONTRACT_DIRECTORY, `${descriptor.task_id}.operation-manifest.json`),
         };
     }
+    async function ensureParallelContractDirectory(canonicalRoot) {
+        let parent = canonicalRoot;
+        for (const segment of [".sortie-dogs", "contracts"]) {
+            const candidate = join(parent, segment);
+            let info = await lstat(candidate).catch((error) => {
+                if (isRecord(error) && error.code === "ENOENT")
+                    return undefined;
+                throw error;
+            });
+            if (info === undefined) {
+                await mkdir(candidate, { mode: 0o700 }).catch((error) => {
+                    if (!isRecord(error) || error.code !== "EEXIST")
+                        throw error;
+                });
+                info = await lstat(candidate);
+            }
+            if (!info.isDirectory() || info.isSymbolicLink() || !samePath(await realpath(candidate), candidate)) {
+                throw new ParallelDispatchError("lifecycle-failed", "Parallel contract directory is not a safe managed-worktree directory.");
+            }
+            parent = candidate;
+        }
+        return parent;
+    }
     async function createParallelControlFiles(descriptor, validationCommands) {
         const canonicalRoot = await realpath(descriptor.managed_path);
         if (!samePath(canonicalRoot, descriptor.managed_path)) {
             throw new ParallelDispatchError("lifecycle-failed", "Managed worktree identity changed before contract creation.");
         }
         const paths = parallelControlPaths(descriptor);
+        const contractDirectory = await ensureParallelContractDirectory(canonicalRoot);
+        const expectedContractDirectory = resolve(canonicalRoot, CANONICAL_CONTRACT_DIRECTORY);
+        if (!samePath(contractDirectory, expectedContractDirectory)) {
+            throw new ParallelDispatchError("lifecycle-failed", "Parallel contract directory escapes the managed worktree.");
+        }
         const manifestValue = {
             version: "0.1.0",
             task_id: descriptor.task_id,
@@ -1207,7 +1219,7 @@ export const SortieDogsPlugin = async (input, options) => {
             id: descriptor.task_id,
             created_at: new Date().toISOString(),
             ext: { "sortie-dogs/write-gate": {
-                    operation_manifest: basename(paths.operation_manifest),
+                    operation_manifest: relative(descriptor.managed_path, paths.operation_manifest).replaceAll("\\", "/"),
                     project_root: descriptor.managed_path,
                 } },
             task: {
@@ -1279,6 +1291,13 @@ export const SortieDogsPlugin = async (input, options) => {
         const validationCommands = loaded?.manifest?.validation ?? [];
         await Promise.all(snapshot.ready.map((descriptor) => createParallelControlFiles(descriptor, validationCommands)));
     }
+    async function restoreActiveParallelControls(snapshot) {
+        await ensureLoaded();
+        const validationCommands = loaded?.manifest?.validation ?? [];
+        await Promise.all(snapshot.tasks
+            .filter(({ phase }) => phase === "pending" || phase === "reserved" || phase === "running")
+            .map(({ descriptor }) => createParallelControlFiles(descriptor, validationCommands)));
+    }
     function boundedParallelSnapshot(snapshot) {
         return {
             run_id: snapshot.run_id,
@@ -1465,10 +1484,18 @@ export const SortieDogsPlugin = async (input, options) => {
                 return JSON.stringify({ status: "denied", reason: "coordinator-root-required" });
             const coordinator = await getParallelCoordinator();
             const active = await coordinator.snapshot(ownerRoot, runID || undefined);
-            const snapshot = await coordinator.cancel(ownerRoot, runID || undefined);
-            if (active !== undefined && snapshot !== undefined) {
+            if (active !== undefined) {
                 await Promise.all(active.tasks.filter(({ phase }) => phase === "pending" || phase === "reserved")
-                    .map(({ descriptor }) => removeParallelControlFiles(descriptor).catch(() => undefined)));
+                    .map(({ descriptor }) => removeParallelControlFiles(descriptor)));
+            }
+            let snapshot;
+            try {
+                snapshot = await coordinator.cancel(ownerRoot, runID || undefined);
+            }
+            catch (error) {
+                if (active !== undefined)
+                    await ensureParallelReadyControls(active);
+                throw error;
             }
             return snapshot === undefined
                 ? JSON.stringify({ status: "absent" })
@@ -1481,6 +1508,54 @@ export const SortieDogsPlugin = async (input, options) => {
             });
         }
     }
+    async function retireParallelWorkflow(sessionID) {
+        if (parallelCoordinator === undefined) {
+            project ??= await createProjectPaths(resolveProjectRoot(input));
+            const gitMarker = await lstat(join(project.root, ".git")).catch((error) => {
+                if (isRecord(error) && error.code === "ENOENT")
+                    return undefined;
+                throw error;
+            });
+            if (gitMarker === undefined)
+                return;
+        }
+        let coordinator = parallelCoordinator;
+        if (coordinator === undefined) {
+            try {
+                coordinator = await getParallelCoordinator();
+            }
+            catch (error) {
+                if (error instanceof WorktreeLifecycleError && error.code === "invalid-repository" &&
+                    error.message === "Repository root is not the primary checkout.")
+                    return;
+                throw error;
+            }
+        }
+        const active = await coordinator.snapshot(sessionID);
+        if (active === undefined || active.archived)
+            return;
+        await Promise.all(active.tasks.map(({ descriptor }) => removeParallelControlFiles(descriptor)));
+        try {
+            await coordinator.cancel(sessionID, active.run_id);
+        }
+        catch (error) {
+            await restoreActiveParallelControls(active);
+            throw error;
+        }
+        await coordinator.reconcile(sessionID, new Set(), active.run_id);
+    }
+    async function serializeChatTransition(sessionID, operation) {
+        const previous = chatTransitions.get(sessionID) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(operation);
+        chatTransitions.set(sessionID, current);
+        try {
+            await current;
+        }
+        finally {
+            if (chatTransitions.get(sessionID) === current)
+                chatTransitions.delete(sessionID);
+        }
+    }
     function abandonSessionLease(sessionID) {
         const authorization = sessionAuthorizations.get(sessionID);
         if (authorization?.lease !== undefined) {
@@ -1489,10 +1564,13 @@ export const SortieDogsPlugin = async (input, options) => {
         }
     }
     async function completeContinuationText(sessionID, text) {
+        const continuationText = fastLane.manualCompactionForbidden(sessionID)
+            ? text.replaceAll(ROLLOVER_MARKER, "").replaceAll(CONTINUATION_MARKER, "").trimEnd()
+            : text;
         await continuation.textComplete({
             sessionID,
             allowCheckpointContinuation: fastLane.backlogContinuationAllowed(sessionID),
-        }, { text });
+        }, { text: continuationText });
         if (fastLane.backlogContinuationAllowed(sessionID) && continuation.blocksTool(sessionID)) {
             fastLane.continuationQueued(sessionID);
         }
@@ -2363,6 +2441,11 @@ export const SortieDogsPlugin = async (input, options) => {
         return await lineageProject.contains(root) ? rootSessionID : undefined;
     }
     function rememberParent(sessionID, parentID) {
+        knownChildSessions.delete(sessionID);
+        knownChildSessions.add(sessionID);
+        while (knownChildSessions.size > ACTIVE_SESSION_CACHE.maximum) {
+            knownChildSessions.delete(knownChildSessions.values().next().value);
+        }
         sessionParents.delete(sessionID);
         sessionParents.set(sessionID, parentID);
     }
@@ -2807,7 +2890,6 @@ export const SortieDogsPlugin = async (input, options) => {
                     .replaceAll(ROLLOVER_MARKER, "")
                     .replaceAll(CONTINUATION_MARKER, "")
                     .trimEnd();
-                return;
             }
             await completeContinuationText(textInput.sessionID, textOutput.text);
         },
@@ -2818,147 +2900,110 @@ export const SortieDogsPlugin = async (input, options) => {
             await continuation.compactionAutoContinue(autoInput, autoOutput);
         },
         "chat.message": async (chatInput, output) => {
-            const parentID = chatParentID(chatInput);
-            const synthetic = output.parts.some((part) => isRecord(part) && part.synthetic === true);
-            if (parentID !== undefined)
-                rememberParent(chatInput.sessionID, parentID);
-            const coordinatorRoot = isCoordinatorSession(chatInput.sessionID);
-            const requestedCoordinator = chatInput.agent === COORDINATOR_AGENT || output.message.agent === COORDINATOR_AGENT;
-            if (requestedCoordinator && !coordinatorRoot) {
-                const explicitChild = parentID !== undefined || sessionParents.has(chatInput.sessionID);
-                const identity = input.client?.session?.get === undefined
-                    ? undefined
-                    : await hostSessionIdentity(chatInput.sessionID);
-                const foreignRoot = identity?.agent !== undefined && identity.agent !== COORDINATOR_AGENT;
-                const foreignHistoryAgent = await hostSessionForeignUserAgent(chatInput.sessionID);
-                const foreignHistory = typeof foreignHistoryAgent === "string" ? true : foreignHistoryAgent;
-                const unverifiableRoot = (input.client?.session?.get !== undefined && (identity === undefined ||
-                    (identity.agent === undefined && input.client?.session?.messages === undefined))) ||
-                    (input.client?.session?.messages !== undefined && foreignHistory === undefined);
-                const currentAgent = !explicitChild && identity?.parentPresent === false
-                    ? typeof foreignHistoryAgent === "string"
-                        ? foreignHistoryAgent
-                        : foreignRoot
-                            ? identity.agent
-                            : undefined
-                    : undefined;
-                if (currentAgent !== undefined) {
-                    const noticePart = output.parts.find((part) => isRecord(part) && part.type === "text");
-                    if (!isRecord(noticePart)) {
-                        throw new Error("SORTIE_FRESH_SESSION_REQUIRED: /sortie requires a fresh root dog-coordinator session; it cannot convert another agent or promote a child");
+            await serializeChatTransition(chatInput.sessionID, async () => {
+                const parentID = chatParentID(chatInput);
+                const synthetic = output.parts.some((part) => isRecord(part) && part.synthetic === true);
+                if (parentID !== undefined)
+                    rememberParent(chatInput.sessionID, parentID);
+                const coordinatorRoot = isCoordinatorSession(chatInput.sessionID);
+                const selectedAgent = chatInput.agent ?? output.message.agent;
+                if (chatInput.agent !== undefined && output.message.agent !== chatInput.agent) {
+                    output.message.agent = chatInput.agent;
+                }
+                const requestedCoordinator = selectedAgent === COORDINATOR_AGENT;
+                if (requestedCoordinator && !coordinatorRoot) {
+                    const explicitChild = parentID !== undefined || knownChildSessions.has(chatInput.sessionID);
+                    const identity = input.client?.session?.get === undefined
+                        ? undefined
+                        : await hostSessionIdentity(chatInput.sessionID);
+                    if (explicitChild || identity?.parentPresent === true) {
+                        throw new Error("SORTIE_FRESH_SESSION_REQUIRED: /sortie cannot promote a child session to a root dog-coordinator");
                     }
-                    chatInput.agent = currentAgent;
-                    output.message.agent = currentAgent;
-                    noticePart.text = "SORTIE_FRESH_SESSION_REQUIRED. Do not perform the requested task or use tools. " +
-                        `Explain only that /sortie must start in a new session because this session belongs to ${currentAgent}.`;
-                    output.parts.splice(0, output.parts.length, noticePart);
-                    await input.client?.tui?.showToast?.({ body: {
-                            title: "Sortie-dogs",
-                            message: `/sortie requires a new session. This session remains ${currentAgent}.`,
-                            variant: "warning",
-                            duration: 8000,
-                        } }).catch(() => undefined);
-                    return;
-                }
-                if (explicitChild || identity?.parentPresent === true ||
-                    foreignHistory || unverifiableRoot) {
-                    throw new Error("SORTIE_FRESH_SESSION_REQUIRED: /sortie requires a fresh root dog-coordinator session; it cannot convert another agent or promote a child");
-                }
-            }
-            const normalizeCoordinatorDrift = coordinatorRoot && !requestedCoordinator;
-            if (normalizeCoordinatorDrift) {
-                /*
-                 * OpenCode can switch both agent and model when the user only intends to hand the root from
-                 * Terra to Sol. Letting that agent drift stand silently discards the coordinator prompt and
-                 * every in-memory continuation guard. Keep the selected model, but make the established root
-                 * role sticky; an actual workflow switch belongs in a new session.
-                 */
-                chatInput.agent = COORDINATOR_AGENT;
-                output.message.agent = COORDINATOR_AGENT;
-                if (!normalizedCoordinatorDrifts.has(chatInput.sessionID)) {
-                    normalizedCoordinatorDrifts.add(chatInput.sessionID);
-                    console.warn(`[sortie-coordinator] normalized agent drift for ${chatInput.sessionID}; selected model preserved`);
-                }
-            }
-            const coordinatorOrigin = parentID === undefined && (requestedCoordinator || normalizeCoordinatorDrift);
-            if (coordinatorOrigin) {
-                fastLane.beginTurn(chatInput.sessionID, synthetic);
-                releaseSessionEnforcement(chatInput.sessionID);
-                await rememberCoordinatorRoot(chatInput.sessionID);
-            }
-            else {
-                if (!synthetic && isCoordinatorSession(chatInput.sessionID)) {
                     fastLane.forget(chatInput.sessionID);
                     abortCoordinatorTasks(chatInput.sessionID);
                     continuation.forgetSession(chatInput.sessionID);
+                    await retireParallelWorkflow(chatInput.sessionID);
                     evictSession(chatInput.sessionID);
                 }
-                const taskText = explicitTaskText(output);
-                if (taskText !== undefined) {
-                    const taskID = handoffValue(handoffEntries(taskText), ["task_id"]);
-                    if (taskID !== undefined)
-                        sessionTaskIDs.set(chatInput.sessionID, unquoteValue(taskID));
-                }
-                let inheritedRoot = taskText === undefined
-                    ? undefined
-                    : await inheritedTaskRoot(chatInput.sessionID, taskText);
-                if (taskText !== undefined && inheritedRoot === undefined) {
-                    await recoverCoordinatorLineage(chatInput.sessionID);
-                    inheritedRoot = await inheritedTaskRoot(chatInput.sessionID, taskText);
-                }
-                if (inheritedRoot !== undefined) {
-                    sessionRoots.set(chatInput.sessionID, inheritedRoot);
-                    activateSession(chatInput.sessionID, parallelTaskMode(taskText));
-                    const descriptor = parallelDescriptor(taskText);
-                    const recordedAgent = chatInput.agent ?? output.message.agent;
-                    const matchingCall = descriptor === undefined ? undefined : [...parallelCalls.values()].find((call) => call.ownerRoot === inheritedRoot && sameParallelDescriptor(call.descriptor, descriptor));
-                    if (descriptor !== undefined && recordedAgent === "dog-worker" && matchingCall !== undefined &&
-                        samePath(taskProjectRoot(taskText) ?? "", descriptor.managed_path) && sessionParents.get(chatInput.sessionID) === inheritedRoot) {
-                        parallelChildBindings.set(chatInput.sessionID, {
-                            ownerRoot: inheritedRoot,
-                            descriptor,
-                            completionCallID: matchingCall.completionCallID,
-                        });
-                        pruneParallelChildMap(parallelChildBindings);
+                const coordinatorOrigin = parentID === undefined && requestedCoordinator;
+                if (coordinatorOrigin) {
+                    fastLane.beginTurn(chatInput.sessionID, synthetic);
+                    releaseSessionEnforcement(chatInput.sessionID);
+                    await rememberCoordinatorRoot(chatInput.sessionID);
+                }
+                else {
+                    if (!synthetic && isCoordinatorSession(chatInput.sessionID)) {
+                        fastLane.forget(chatInput.sessionID);
+                        abortCoordinatorTasks(chatInput.sessionID);
+                        continuation.forgetSession(chatInput.sessionID);
+                        await retireParallelWorkflow(chatInput.sessionID);
+                        evictSession(chatInput.sessionID);
                     }
-                    else {
-                        parallelChildBindings.delete(chatInput.sessionID);
+                    const taskText = explicitTaskText(output);
+                    if (taskText !== undefined) {
+                        const taskID = handoffValue(handoffEntries(taskText), ["task_id"]);
+                        if (taskID !== undefined)
+                            sessionTaskIDs.set(chatInput.sessionID, unquoteValue(taskID));
                     }
+                    let inheritedRoot = taskText === undefined
+                        ? undefined
+                        : await inheritedTaskRoot(chatInput.sessionID, taskText);
+                    if (taskText !== undefined && inheritedRoot === undefined) {
+                        await recoverCoordinatorLineage(chatInput.sessionID);
+                        inheritedRoot = await inheritedTaskRoot(chatInput.sessionID, taskText);
+                    }
+                    if (inheritedRoot !== undefined) {
+                        sessionRoots.set(chatInput.sessionID, inheritedRoot);
+                        activateSession(chatInput.sessionID, parallelTaskMode(taskText));
+                        const descriptor = parallelDescriptor(taskText);
+                        const recordedAgent = chatInput.agent ?? output.message.agent;
+                        const matchingCall = descriptor === undefined ? undefined : [...parallelCalls.values()].find((call) => call.ownerRoot === inheritedRoot && sameParallelDescriptor(call.descriptor, descriptor));
+                        if (descriptor !== undefined && recordedAgent === "dog-worker" && matchingCall !== undefined &&
+                            samePath(taskProjectRoot(taskText) ?? "", descriptor.managed_path) && sessionParents.get(chatInput.sessionID) === inheritedRoot) {
+                            parallelChildBindings.set(chatInput.sessionID, {
+                                ownerRoot: inheritedRoot,
+                                descriptor,
+                                completionCallID: matchingCall.completionCallID,
+                            });
+                            pruneParallelChildMap(parallelChildBindings);
+                        }
+                        else {
+                            parallelChildBindings.delete(chatInput.sessionID);
+                        }
+                    }
+                    else if (activatesSession(chatInput, output)) {
+                        activateSession(chatInput.sessionID, taskText === undefined ? "none" : parallelTaskMode(taskText));
+                    }
+                    touchActiveSession(chatInput.sessionID);
                 }
-                else if (activatesSession(chatInput, output)) {
-                    activateSession(chatInput.sessionID, taskText === undefined ? "none" : parallelTaskMode(taskText));
-                }
-                touchActiveSession(chatInput.sessionID);
-            }
-            /*
-             * Role routing is a dispatch policy, not a write-gate concern. Consultation and evidence roles
-             * never activate the write gate, so gating routing on session activation left every one of
-             * them silently inheriting the caller's model instead of its own configured route.
-             */
-            await ensureLoaded();
-            const consultationFallbackRetry = await reserveConsultationFallbackRetry(chatInput, output);
-            try {
-                const routed = normalizeCoordinatorDrift
-                    ? false
-                    : await loaded?.modelRoutingHook?.(chatInput, output, {
+                /*
+                 * Role routing is a dispatch policy, not a write-gate concern. Consultation and evidence roles
+                 * never activate the write gate, so gating routing on session activation left every one of
+                 * them silently inheriting the caller's model instead of its own configured route.
+                 */
+                await ensureLoaded();
+                const consultationFallbackRetry = await reserveConsultationFallbackRetry(chatInput, output);
+                try {
+                    const routed = await loaded?.modelRoutingHook?.(chatInput, output, {
                         skipPreferred: consultationFallbackRetry !== undefined,
                     });
-                if (consultationFallbackRetry !== undefined && routed === true) {
-                    consultationRetries.set(consultationFallbackRetry.key, {
-                        phase: "consumed",
-                        retryChildSessionID: consultationFallbackRetry.childSessionID,
-                    });
+                    if (consultationFallbackRetry !== undefined && routed === true) {
+                        consultationRetries.set(consultationFallbackRetry.key, {
+                            phase: "consumed",
+                            retryChildSessionID: consultationFallbackRetry.childSessionID,
+                        });
+                    }
                 }
-            }
-            finally {
-                if (consultationFallbackRetry !== undefined &&
-                    consultationRetries.get(consultationFallbackRetry.key)?.phase === "routing") {
-                    consultationRetries.set(consultationFallbackRetry.key, { phase: "pending" });
+                finally {
+                    if (consultationFallbackRetry !== undefined &&
+                        consultationRetries.get(consultationFallbackRetry.key)?.phase === "routing") {
+                        consultationRetries.set(consultationFallbackRetry.key, { phase: "pending" });
+                    }
                 }
-            }
-            if (coordinatorOrigin) {
-                continuation.observeModel(chatInput.sessionID, output.message.model, synthetic);
-            }
+                if (coordinatorOrigin) {
+                    continuation.observeModel(chatInput.sessionID, output.message.model, synthetic);
+                }
+            });
         },
         "experimental.chat.system.transform": async (transformInput, transformOutput) => {
             if (fastLane.terminalInstructionRequired(transformInput.sessionID)) {
@@ -3306,13 +3351,6 @@ export const SortieDogsPlugin = async (input, options) => {
                                 defects: [contractDefect("contract", "/", "dispatch_identity_mismatch")],
                             });
                         }
-                        const validationCommand = taskValidationCommand(contractPrompt);
-                        if (validationCommand !== undefined &&
-                            !identity.validationCommands.has(normalizeCommand(validationCommand))) {
-                            throw new HandoffDeniedError("contract-invalid", handoffPaths[0], {
-                                defects: [contractDefect("contract", "/validation/command", "dispatch_validation_manifest_mismatch")],
-                            });
-                        }
                     }
                 }
                 if (reservedParallelDescriptor !== undefined) {
@@ -3453,7 +3491,6 @@ export const SortieDogsPlugin = async (input, options) => {
                 return;
             const eventPartTime = isRecord(eventPart?.time) ? eventPart.time : undefined;
             if (event.type === "message.part.updated" && isCoordinatorSession(eventSessionID) &&
-                !fastLane.manualCompactionForbidden(eventSessionID) &&
                 eventPart?.type === "text" && typeof eventPart.text === "string" && eventPart.text.trim().length > 0 &&
                 typeof eventPartTime?.end === "number" && typeof eventPart.id === "string" &&
                 typeof eventPart.messageID === "string" &&
@@ -3489,7 +3526,6 @@ export const SortieDogsPlugin = async (input, options) => {
                 return;
             }
             if (event.type === "message.updated" && isCoordinatorSession(eventSessionID) &&
-                !fastLane.manualCompactionForbidden(eventSessionID) &&
                 info?.role === "assistant" && info.agent === COORDINATOR_AGENT && isRecord(info.time) &&
                 typeof info.time.completed === "number" && typeof info.id === "string" &&
                 !completedCoordinatorMessages.has(info.id)) {
@@ -3519,7 +3555,6 @@ export const SortieDogsPlugin = async (input, options) => {
                 return;
             }
             if (event.type === "session.deleted") {
-                normalizedCoordinatorDrifts.delete(eventSessionID);
                 fastLane.forget(eventSessionID);
                 abortCoordinatorTasks(eventSessionID);
                 if (reflectionStore !== undefined && reflectionConfiguration?.layers.run && reflectionOwnedRoots.has(eventSessionID)) {
@@ -3556,6 +3591,7 @@ export const SortieDogsPlugin = async (input, options) => {
                     }
                 }
                 evictSession(eventSessionID);
+                knownChildSessions.delete(eventSessionID);
                 for (const role of [REVIEWER_AGENT, ADVISOR_AGENT]) {
                     const key = consultationRetryKey(eventSessionID, role);
                     consultationRetries.delete(key);