sortie-dogs 0.9.1 → 0.9.3

package/README.md

@@ -24,7 +24,7 @@ Requirements: Node.js 22.6 or newer, npm, and OpenCode.
 
 Guides: [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md) · [CLI testing](docs/cli-testing.md)
 
-Release: [v0.9.1](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.1)
+Release: [v0.9.3](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.3)
 
 ## Quick start
 

package/dist/asset-version.d.ts

@@ -2,5 +2,5 @@
  * Version of the installable runtime assets. Kept in its own module so the plugin can compare an
  * installed project marker without importing every asset body.
  */
-export declare const RUNTIME_ASSET_VERSION = "0.3.76-goal-control-report-v1";
+export declare const RUNTIME_ASSET_VERSION = "0.3.80-review-evidence-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -2,4 +2,4 @@
  * Version of the installable runtime assets. Kept in its own module so the plugin can compare an
  * installed project marker without importing every asset body.
  */
-export const RUNTIME_ASSET_VERSION = "0.3.76-goal-control-report-v1";
+export const RUNTIME_ASSET_VERSION = "0.3.80-review-evidence-v1";

package/dist/cli/main.js

@@ -1,12 +1,20 @@
 #!/usr/bin/env node
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { open, realpath } from "node:fs/promises";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-const core = await import(`../core/validate-schema.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`);
-const diagnostics = await import(`../core/diagnostics.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`);
-const manifestValidator = await import(`../core/validate-manifest.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`);
-const pathUtils = await import(`../core/path.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`);
-const initializer = await import(`../core/initialize.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`);
+const core = await import(__rewriteRelativeImportExtension(`../core/validate-schema.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`));
+const diagnostics = await import(__rewriteRelativeImportExtension(`../core/diagnostics.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`));
+const manifestValidator = await import(__rewriteRelativeImportExtension(`../core/validate-manifest.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`));
+const pathUtils = await import(__rewriteRelativeImportExtension(`../core/path.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`));
+const initializer = await import(__rewriteRelativeImportExtension(`../core/initialize.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`));
 const LIMITS = {
     handoffBytes: 2 * 1024 * 1024,
     manifestBytes: 512 * 1024,

package/dist/core/diagnostics.js

@@ -1,4 +1,12 @@
-const validateSemantics = await import(`./validate-semantics.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`);
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+const validateSemantics = await import(__rewriteRelativeImportExtension(`./validate-semantics.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`));
 const DEFAULT_SEVERITIES = {
     H001: "error",
     H002: "error",

package/dist/core/goal-declaration-format.d.ts

@@ -0,0 +1,4 @@
+/** Shared planner guidance and admission enums; no inferred acceptance or dispatch authority. */
+export declare const GOAL_DELIVERY_INTENTS: readonly ["design", "registration", "implementation", "repair", "controlled-change"];
+export declare const GOAL_DELIVERY_MODES: readonly ["planning-only", "mvp-first", "repair-first", "controlled-change"];
+export declare const GOAL_DECLARATION_FORMAT: string;

package/dist/core/goal-declaration-format.js

@@ -0,0 +1,33 @@
+/** Shared planner guidance and admission enums; no inferred acceptance or dispatch authority. */
+export const GOAL_DELIVERY_INTENTS = ["design", "registration", "implementation", "repair", "controlled-change"];
+export const GOAL_DELIVERY_MODES = ["planning-only", "mvp-first", "repair-first", "controlled-change"];
+export const GOAL_DECLARATION_FORMAT = `Goal declaration belongs in the Task prompt, not in the handoff JSON or operation manifest.
+delivery_intent must be exactly one of: ${GOAL_DELIVERY_INTENTS.join(" | ")}. Never use prose or a boolean.
+delivery_mode is a separate optional enum: ${GOAL_DELIVERY_MODES.join(" | ")}.
+Use flat key: value lines. Each criterion begins with its own goal_criterion_id: line.
+Repeat the entire flat criterion block for multiple criteria. Do not use goal_criteria, goal_acceptance.criteria,
+YAML object/list wrappers, inline { goal_criterion_id: ... }, or JSON objects for these blocks.
+Replace every placeholder with the accepted task's actual value; preserve its acceptance and validation:
+goal_acceptance_fingerprint: <sha256: followed by exactly 64 lowercase hexadecimal characters>
+delivery_intent: implementation
+delivery_mode: mvp-first
+usable_path_established: false
+controlled_change: false
+goal_budget_units: <accepted positive integer>
+goal_criterion_id: <stable criterion id>
+goal_target: <requested behavior>
+goal_entrypoint: <real entrypoint>
+goal_workload: <requested workload>
+goal_oracle_coverage: ["<actual oracle>"]
+goal_build_boundary: <included | excluded | not-applicable>
+goal_source: <fixed source label>
+goal_candidate: <fixed candidate label>
+goal_source_binding: current-protected
+goal_candidate_binding: current-protected
+goal_fixture: <actual fixture identity>
+goal_proof_scope: requested-full
+goal_expected_outcome: pass
+goal_validation_command: <exact operation manifest validation command>
+The example's implementation/mvp-first selections apply only to an implementation without its usable path;
+select other enum values only from the accepted request. A declaration rejection launches no child.
+Repair the Task prompt's named fields, not unrelated files; retry only with the corrected declaration.`;

package/dist/core/initialize.js

@@ -1,9 +1,17 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { createHash } from "node:crypto";
 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";
-const assets = await import(`../runtime-assets.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`);
+const assets = await import(__rewriteRelativeImportExtension(`../runtime-assets.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`));
 const { runtimeAssets } = assets;
 const OPEN_CODE_DIRECTORY = ".opencode";
 const VERSION_MARKER = `${OPEN_CODE_DIRECTORY}/sortie-dogs.version`;

package/dist/core/validate-manifest.js

@@ -1,4 +1,12 @@
-const pathUtils = await import(`./path.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`);
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+const pathUtils = await import(__rewriteRelativeImportExtension(`./path.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`));
 const MESSAGES = {
     H001_PATH_RELATIVE: "Manifest path must be a valid repository-relative path.",
     H011_VALIDATION_MISSING: "A required manifest validation has not passed.",

package/dist/core/validate-semantics.js

@@ -1,4 +1,12 @@
-const pathUtils = await import(`./path.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`);
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+const pathUtils = await import(__rewriteRelativeImportExtension(`./path.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`));
 const HASH_LENGTHS = {
     sha256: 64,
     sha512: 128,

package/dist/core/worktree-parallel-dispatch.d.ts

@@ -21,7 +21,7 @@ export type ParallelDispatchPrepareResult = {
     readonly reason: "scope-overlap" | "dependency-ambiguous";
 };
 /** Runtime capacity and mapping limits that the pure admission policy cannot observe. */
-export type FabricDispatchSolReason = LunaFabricSolReason | "unit-count-exceeds-capacity" | "concurrent-scope-overlap" | "contract-unmappable";
+export type FabricDispatchSolReason = LunaFabricSolReason | "unit-count-exceeds-capacity" | "concurrent-scope-overlap" | "contract-unmappable" | "target-checked-out";
 export type ParallelDispatchFabricPrepareResult = {
     readonly status: "prepared";
     readonly snapshot: ParallelDispatchSnapshot;
@@ -154,7 +154,7 @@ export declare class ParallelDispatchCoordinator {
     private acquire;
     private git;
     private readRef;
-    private targetCheckedOut;
+    targetCheckedOut(targetRef: string): Promise<boolean>;
     private deleteFabricSourceRefs;
     private ensureCandidateRef;
     private withPrepareAuthority;

package/dist/core/worktree-parallel-dispatch.js

@@ -2705,7 +2705,9 @@ export class ParallelDispatchCoordinator {
                 await rm(temporary, { force: true }).catch(() => undefined);
         }
     }
-    async acquire(scope = STATE_SCOPE, ttlMs = 10 * 60_000) {
+    // Heartbeats retain live ownership. A crashed CLI must not leave a lease whose expiry exceeds
+    // the next CLI's acquisition budget; keep room for mutex acquisition and filesystem latency.
+    async acquire(scope = STATE_SCOPE, ttlMs = Math.floor(LOCK_TIMEOUT_MS / 2)) {
         const deadline = Date.now() + LOCK_TIMEOUT_MS;
         while (true) {
             try {

package/dist/plugin/gate.d.ts

@@ -60,6 +60,8 @@ export declare function isRemoteMutation(tool: string, args: unknown): boolean;
  * same command written with different spacing compares equal.
  */
 export declare function normalizeCommand(command: string): string;
+/** Canonicalize only an exact or unambiguous basename-shortened sequence of declared validations. */
+export declare function canonicalDeclaredValidationSequence(command: string, declared: ReadonlySet<string>): string | undefined;
 /** Unbound sessions may invoke only tools whose complete input is known to be read-only. */
 export declare function isKnownReadOnlyTool(tool: string, args: unknown, additionalReadOnlyTools?: ReadonlySet<string>): boolean;
 /** Canonical scopes let sibling worker bindings reject equal or ancestor ownership. */

package/dist/plugin/gate.js

@@ -797,6 +797,33 @@ export function normalizeCommand(command) {
         ? normalized
         : `${callOperator[2]}${normalized.slice(callOperator[0].length)}`;
 }
+function declaredCommandMatch(segment, declared) {
+    const normalized = normalizeCommand(segment);
+    const exact = declared.filter((command) => normalizeCommand(command) === normalized);
+    if (exact.length === 1)
+        return normalizeCommand(exact[0]);
+    const firstSpace = normalized.indexOf(" ");
+    const executable = firstSpace === -1 ? normalized : normalized.slice(0, firstSpace);
+    const suffix = firstSpace === -1 ? "" : normalized.slice(firstSpace);
+    if (isAbsolute(executable))
+        return undefined;
+    const equivalent = declared.map(normalizeCommand).filter((command) => {
+        const boundary = command.indexOf(" ");
+        const declaredExecutable = boundary === -1 ? command : command.slice(0, boundary);
+        const declaredSuffix = boundary === -1 ? "" : command.slice(boundary);
+        return isAbsolute(declaredExecutable) && basename(declaredExecutable) === executable && declaredSuffix === suffix;
+    });
+    return equivalent.length === 1 ? equivalent[0] : undefined;
+}
+/** Canonicalize only an exact or unambiguous basename-shortened sequence of declared validations. */
+export function canonicalDeclaredValidationSequence(command, declared) {
+    const normalized = normalizeCommand(command);
+    const segments = shellSegments(command, "posix").map((segment) => segment.trim()).filter(Boolean);
+    if (segments.length === 0 || normalized !== segments.map(normalizeCommand).join(" && "))
+        return undefined;
+    const canonical = segments.map((segment) => declaredCommandMatch(segment, [...declared]));
+    return canonical.every((segment) => segment !== undefined) ? canonical.join(" && ") : undefined;
+}
 /** Unbound sessions may invoke only tools whose complete input is known to be read-only. */
 export function isKnownReadOnlyTool(tool, args, additionalReadOnlyTools = new Set()) {
     const name = tool.toLowerCase();

package/dist/plugin/index.js

@@ -1,7 +1,16 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { createHash, randomUUID } from "node:crypto";
-import { lstat, mkdir, open, readFile, readdir, realpath, rm, stat } from "node:fs/promises";
+import { lstat, mkdir, open, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { RUNTIME_ASSET_VERSION } from "../asset-version.js";
+import { GOAL_DECLARATION_FORMAT, GOAL_DELIVERY_INTENTS, GOAL_DELIVERY_MODES } 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 { admitLunaFabric } from "../core/luna-fabric-contract.js";
@@ -19,7 +28,7 @@ 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";
 import { CONTINUATION_CAPABILITY, CONTINUATION_MARKER, ROLLOVER_MARKER, createContinuationHooks, } from "./continuation.js";
-import { WriteDeniedError, canonicalManifestReadScopes, canonicalManifestWriteScopes, createProjectPaths, createWriteGate, describeUnclassifiedCommand, extractWritePaths, bootstrapWritePaths, isGitMutation, isKnownReadOnlyTool, isRemoteMutation, normalizeCommand, resolveProjectRoot, safePath, writeScopesOverlap, } from "./gate.js";
+import { WriteDeniedError, canonicalManifestReadScopes, canonicalManifestWriteScopes, canonicalDeclaredValidationSequence, createProjectPaths, createWriteGate, describeUnclassifiedCommand, extractWritePaths, bootstrapWritePaths, isGitMutation, isKnownReadOnlyTool, isRemoteMutation, normalizeCommand, resolveProjectRoot, safePath, writeScopesOverlap, } from "./gate.js";
 import { BACKLOG_DRAIN_CAPABILITY, FastLaneController } from "./fast-lane.js";
 import { createModelRoutingHook, } from "./model-routing-hook.js";
 import { createTaskResultRepairHook, lastAssistantText, markConsultationFallbackRetry, taskChildSessionID, } from "./task-result-repair.js";
@@ -112,7 +121,8 @@ export class HandoffDeniedError extends Error {
         const defects = normalizeDefects(options?.defects);
         super(`Handoff denied for "${safePath(path)}": handoff and operation manifest contract.` +
             (defects.length === 0 ? "" : ` Defects: ${describeDefects(defects)}.`) +
-            " Correct the registered handoff or its operation manifest, then read the handoff again.", options);
+            (path === "<goal-declaration>" ? ` ${GOAL_DECLARATION_FORMAT}` :
+                " Correct the registered handoff or its operation manifest, then read the handoff again."), options);
         this.name = "HandoffDeniedError";
         this.reason = reason;
         this.defects = defects;
@@ -728,6 +738,30 @@ function taskAcceptanceCriteria(text, key = "acceptance") {
     }
     return values.length === 0 ? undefined : normalizeAcceptanceCriteria(values);
 }
+function canonicalTaskAcceptance(text, criteria) {
+    const lines = text.split(/\r?\n/u);
+    const headers = lines.flatMap((line, index) => /^([\t ]*)acceptance[\t ]*:/iu.exec(line) === null ? [] : [index]);
+    if (headers.length !== 1)
+        return undefined;
+    const index = headers[0];
+    const indent = /^[\t ]*/u.exec(lines[index])[0];
+    const headerIndent = indent.replaceAll("\t", "  ").length;
+    let end = index + 1;
+    if (/^\s*acceptance\s*:\s*$/iu.test(lines[index])) {
+        while (end < lines.length) {
+            const line = lines[end];
+            if (line.trim().length === 0) {
+                end += 1;
+                continue;
+            }
+            if (/^\s*/u.exec(line)[0].replaceAll("\t", "  ").length <= headerIndent)
+                break;
+            end += 1;
+        }
+    }
+    lines.splice(index, end - index, `${indent}acceptance: ${JSON.stringify(criteria)}`);
+    return lines.join("\n");
+}
 function taskContractText(text) {
     const lines = text.split(/\r?\n/u);
     const digestIndexes = lines.flatMap((line, index) => /^\s*context_digest\s*:\s*$/iu.test(line) ? [index] : []);
@@ -1058,7 +1092,7 @@ export const SortieDogsPlugin = async (input, options) => {
         throw new Error("invalid-child-lifecycle-check-wait");
     }
     const pluginModuleName = "@opencode-ai/plugin";
-    const pluginModule = await import(pluginModuleName).catch(() => undefined);
+    const pluginModule = await import(__rewriteRelativeImportExtension(pluginModuleName)).catch(() => undefined);
     const toolCandidate = pluginModule?.tool;
     const toolSchema = typeof toolCandidate === "function"
         ? toolCandidate.schema
@@ -1328,8 +1362,11 @@ export const SortieDogsPlugin = async (input, options) => {
             const unitID = authorization.taskID;
             const unitBound = unitID !== undefined && goal.outstanding_reservations.some((reservation) => reservation.unit_id === unitID && reservation.session_id === identity.parentID);
             const criteria = goal.acceptance_contract?.criteria.filter((criterion) => criterion.validation_command === rawCommand && criterion.expected_outcome === "pass") ?? [];
-            if (!unitBound || criteria.length === 0)
+            if (!unitBound)
                 throw new Error("SORTIE_VALIDATION_BUDGET_DENIED: requirement-unbound");
+            // Exact generation and formatting checks may support acceptance without proving a criterion.
+            if (criteria.length === 0)
+                return;
             const scope = criteria.every((criterion) => criterion.proof_scope === "requested-full") ? "full" : "targeted";
             const request = { run_id: goal.goal_id, operation_id: toolInput.callID,
                 source_snapshot: snapshot.source, candidate: snapshot.candidate, command: [rawCommand], scope,
@@ -1481,6 +1518,10 @@ export const SortieDogsPlugin = async (input, options) => {
             return state.receipt ?? undefined;
         const records = (await ledger.readGoal()).records;
         const settledEvidence = records.flatMap(({ event }) => event.kind === "unit.settled" ? event.evidence : []);
+        if (status === "succeeded" && (state.acceptance_contract === null ||
+            state.acceptance_contract.criteria.length === 0 ||
+            !state.acceptance_contract.criteria.every(({ criterion_id }) => state.satisfied_criteria.includes(criterion_id))))
+            return undefined;
         if (status === "succeeded" && state.acceptance_contract !== null) {
             for (const criterion of state.acceptance_contract.criteria) {
                 if (criterion.source_binding !== "current-protected" && criterion.candidate_binding !== "current-protected")
@@ -1518,13 +1559,45 @@ export const SortieDogsPlugin = async (input, options) => {
     async function terminalGoalFromHostText(sessionID, text) {
         const outcome = terminalRunOutcome(text);
         if (outcome === undefined || !isCoordinatorSession(sessionID)) {
-            return { outcome, goal: undefined, receipt: undefined };
+            return { outcome, goal: undefined, receipt: undefined, delivery: "ready" };
+        }
+        let delivery = "ready";
+        const coordinator = await getParallelCoordinator().catch(() => undefined);
+        let parallel = await coordinator?.snapshot(sessionID).catch(() => undefined);
+        if (parallel !== undefined && !parallel.archived) {
+            await restoreChildLifecycles(sessionID, parallel).catch(() => undefined);
+            const knownCalls = coordinatorTaskCalls.get(sessionID) ?? new Set();
+            const running = parallel.tasks.filter(({ phase }) => phase === "running");
+            if (running.length > 0 && running.every(({ call_id }) => call_id !== null && !knownCalls.has(call_id))) {
+                const status = input.client?.session?.status;
+                const response = status === undefined ? undefined : await status.call(input.client.session, {
+                    query: { directory: input.directory },
+                }).catch(() => undefined);
+                const payload = isRecord(response) && "data" in response ? response.data : response;
+                const statuses = isRecord(payload) ? payload : undefined;
+                const settled = statuses !== undefined && running.every(({ child_session_id }) => {
+                    const observed = child_session_id === null ? undefined : statuses[child_session_id];
+                    return isRecord(observed) && observed.type === "idle";
+                });
+                if (settled)
+                    parallel = await coordinator.reconcile(sessionID, knownCalls, parallel.run_id).catch(() => parallel);
+            }
+            if (parallel !== undefined && !parallel.archived)
+                delivery = "running";
         }
+        if (parallel?.archived === true && parallel.terminal_reason !== "completed")
+            delivery = "failed";
         let goal = await currentGoal(sessionID).catch(() => undefined);
         let receipt = goal?.receipt ?? undefined;
         const proved = goal?.acceptance_contract !== null && goal?.acceptance_contract !== undefined &&
             goal.acceptance_contract.criteria.every(({ criterion_id }) => goal.satisfied_criteria.includes(criterion_id));
-        if (receipt === undefined && proved) {
+        if (delivery === "running") {
+            return { outcome, goal, receipt, delivery };
+        }
+        if (receipt === undefined && delivery === "failed") {
+            receipt = await terminalGoal(sessionID, "stopped", "stopped").catch(() => undefined);
+        }
+        else if (receipt === undefined && proved) {
             receipt = await terminalGoal(sessionID, "completed", "succeeded").catch(() => undefined);
         }
         else if (receipt === undefined && outcome === "DONE") {
@@ -1546,7 +1619,7 @@ export const SortieDogsPlugin = async (input, options) => {
             goal = await currentGoal(sessionID).catch(() => goal);
         if (receipt !== undefined)
             rootAcceptanceContinuity.delete(sessionID);
-        return { outcome, goal, receipt };
+        return { outcome, goal, receipt, delivery };
     }
     function goalDeclarationContract(prompt) {
         const lines = prompt.split(/\r?\n/u);
@@ -1642,14 +1715,14 @@ export const SortieDogsPlugin = async (input, options) => {
             defects.push(contractDefect("contract", "/goal_acceptance_fingerprint", "goal_fingerprint_format"));
         }
         const intent = handoffValue(entries, ["delivery_intent"]);
-        const intents = ["design", "registration", "implementation", "repair", "controlled-change"];
+        const intents = GOAL_DELIVERY_INTENTS;
         if (intent === undefined)
             defects.push(contractDefect("contract", "/delivery_intent", "delivery_intent_missing"));
         else if (!intents.includes(intent)) {
             defects.push(contractDefect("contract", "/delivery_intent", "delivery_intent_invalid"));
         }
         const mode = handoffValue(entries, ["delivery_mode"]);
-        const modes = ["planning-only", "mvp-first", "repair-first", "controlled-change"];
+        const modes = GOAL_DELIVERY_MODES;
         if (mode !== undefined && !modes.includes(mode)) {
             defects.push(contractDefect("contract", "/delivery_mode", "delivery_mode_invalid"));
         }
@@ -3169,6 +3242,9 @@ export const SortieDogsPlugin = async (input, options) => {
                     contract_fingerprint: structuralAdmission.contract_fingerprint, experience: experience.trace });
             }
             const coordinator = await getParallelCoordinator();
+            if (await coordinator.targetCheckedOut(`refs/heads/${structuralAdmission.contract.provenance.target_branch}`)) {
+                return JSON.stringify({ status: "sol-serial", reason: "target-checked-out", experience: experience.trace });
+            }
             const result = await coordinator.prepareFabric(contract, ownerRoot, executionPlanPath === undefined ? undefined : await readJson(resolve(executionPlanPath), INPUT_LIMITS.parallel));
             if (result.status === "sol-serial")
                 return JSON.stringify({ ...result, experience: experience.trace });
@@ -5257,13 +5333,18 @@ export const SortieDogsPlugin = async (input, options) => {
             const terminal = runOutcome === undefined || !isCoordinatorSession(textInput.sessionID)
                 ? undefined
                 : await terminalGoalFromHostText(textInput.sessionID, textOutput.text);
-            if (runOutcome === "DONE" && terminal?.goal !== undefined &&
-                terminal.goal.acceptance_contract !== null && terminal.receipt === undefined) {
-                textOutput.text = replaceDoneTerminalStatus(textOutput.text, "status: IN_PROGRESS\ngoal_control: accepted criteria remain unproved");
+            if (runOutcome === "DONE" && terminal !== undefined && (terminal.delivery === "running" ||
+                (terminal.receipt === undefined && terminal.goal !== undefined && terminal.goal.goal_id !== null))) {
+                textOutput.text = replaceDoneTerminalStatus(textOutput.text, terminal.delivery === "running"
+                    ? "status: IN_PROGRESS — durable delivery active; same sessionでjoinまたはstale reconcileが必要"
+                    : "status: IN_PROGRESS\ngoal_control: accepted criteria remain unproved");
             }
-            if (runOutcome !== "DONE" && terminal?.receipt?.status === "succeeded") {
+            if (runOutcome !== "DONE" && terminal?.delivery === "ready" && terminal.receipt?.status === "succeeded") {
                 textOutput.text = replaceTerminalStatus(textOutput.text, "status: DONE");
             }
+            if (runOutcome === "DONE" && terminal?.delivery === "failed") {
+                textOutput.text = replaceTerminalStatus(textOutput.text, "status: INTERRUPTED — durable delivery failed");
+            }
             if (runOutcome !== undefined && isCoordinatorSession(textInput.sessionID)) {
                 textOutput.text = sanitizeTerminalReport(textOutput.text);
             }
@@ -5815,6 +5896,13 @@ export const SortieDogsPlugin = async (input, options) => {
                 diagnosis.tools.add(toolInput.callID);
                 return;
             }
+            if (isRecord(output.args) && typeof output.args.command === "string") {
+                const authorization = sessionAuthorizations.get(toolInput.sessionID);
+                const canonical = authorization === undefined ? undefined
+                    : canonicalDeclaredValidationSequence(output.args.command, authorization.validationCommands);
+                if (canonical !== undefined)
+                    output.args.command = canonical;
+            }
             await recordHostGoalStart(toolInput, output);
             const coordinatorRoot = isCoordinatorSession(toolInput.sessionID) || await recoverCoordinatorRoot(toolInput.sessionID);
             const readonlyDiagnosis = coordinatorRoot && toolInput.tool === "task" && isRecord(output.args)
@@ -6033,21 +6121,31 @@ export const SortieDogsPlugin = async (input, options) => {
                                 });
                             }
                             if (assetVersionStatus === "current") {
-                                const ledger = identity.acceptanceContinuity;
-                                if (ledger === undefined) {
+                                const inspectedLedger = identity.acceptanceContinuity;
+                                if (inspectedLedger === undefined) {
                                     throw new HandoffDeniedError("contract-invalid", handoffPaths[0], {
                                         defects: [contractDefect("handoff", "/ext/sortie-dogs~1acceptance-continuity", `acceptance_continuity_${identity.acceptanceContinuityError ?? "missing"}`)],
                                     });
                                 }
+                                let ledger = inspectedLedger;
                                 const criteria = taskAcceptanceCriteria(contractPrompt);
                                 if (taskIDs.length !== 1 || taskIDs[0] !== identity.handoffID ||
-                                    ledger.task_id !== identity.handoffID || criteria === undefined ||
-                                    criteria.length !== ledger.criteria.length ||
-                                    criteria.some((criterion, index) => criterion !== ledger.criteria[index])) {
+                                    ledger.task_id !== identity.handoffID) {
                                     throw new HandoffDeniedError("contract-invalid", handoffPaths[0], {
                                         defects: [contractDefect("contract", "/acceptance", "acceptance_continuity_mismatch")],
                                     });
                                 }
+                                if (criteria === undefined || criteria.length !== ledger.criteria.length ||
+                                    criteria.some((criterion, index) => criterion !== ledger.criteria[index])) {
+                                    const canonical = canonicalTaskAcceptance(prompt, ledger.criteria);
+                                    if (canonical === undefined) {
+                                        throw new HandoffDeniedError("contract-invalid", handoffPaths[0], {
+                                            defects: [contractDefect("contract", "/acceptance", "acceptance_continuity_mismatch")],
+                                        });
+                                    }
+                                    output.args.prompt = canonical;
+                                    prompt = canonical;
+                                }
                                 const previous = rootAcceptanceContinuity.get(toolInput.sessionID);
                                 if (previous === undefined) {
                                     if (ledger.parent_fingerprint !== "none" &&
@@ -6069,6 +6167,24 @@ export const SortieDogsPlugin = async (input, options) => {
                                         previous.criteria.every((criterion, index) => criterion === ledger.criteria[index]);
                                     const strictAppend = ledger.criteria.length > previous.criteria.length &&
                                         previous.criteria.every((criterion, index) => criterion === ledger.criteria[index]);
+                                    // Serial parent identity is controller-owned. Repair only an omitted link on
+                                    // an otherwise exact carry-forward/append; explicit conflicting links still fail.
+                                    // Persist it so the worker's Read and later recovery see the same contract.
+                                    if (reservedParallelDescriptor === undefined && ledger.parent_fingerprint === "none" &&
+                                        (exactCarryForward || strictAppend)) {
+                                        const handoff = JSON.parse(await readFile(handoffPaths[0], "utf8"));
+                                        const validated = validateHandoffSchema(handoff);
+                                        const current = validated.ok ? inspectAcceptanceContinuity(validated.value).ledger : undefined;
+                                        if (current === undefined || JSON.stringify(current) !== JSON.stringify(ledger)) {
+                                            throw new HandoffDeniedError("contract-invalid", handoffPaths[0], {
+                                                defects: [contractDefect("handoff", "/ext/sortie-dogs~1acceptance-continuity", "acceptance_parent_continuity_mismatch")],
+                                            });
+                                        }
+                                        ledger = { ...ledger, parent_fingerprint: previous.fingerprint };
+                                        handoff.ext[ACCEPTANCE_CONTINUITY_EXTENSION] = ledger;
+                                        await writeFile(handoffPaths[0], `${JSON.stringify(handoff, null, 2)}\n`);
+                                        await inspect(handoffPaths[0], undefined, { report: true });
+                                    }
                                     if (ledger.parent_fingerprint !== previous.fingerprint || (!exactCarryForward && !strictAppend)) {
                                         throw new HandoffDeniedError("contract-invalid", handoffPaths[0], {
                                             defects: [contractDefect("handoff", "/ext/sortie-dogs~1acceptance-continuity", "acceptance_parent_continuity_mismatch")],
@@ -6215,6 +6331,10 @@ export const SortieDogsPlugin = async (input, options) => {
                 // boundary; unrelated commands continue through the ordinary write gate.
                 if (activeState?.parallel === "valid" && command !== undefined && authorization?.validationCommands.has(command) === true)
                     throw new WriteDeniedError("parallel-validation", "<parallel-unit>");
+                const declaredSequence = command === undefined || authorization === undefined ? undefined
+                    : canonicalDeclaredValidationSequence(command, authorization.validationCommands);
+                if (activeState?.parallel !== "valid" && declaredSequence !== undefined)
+                    return;
                 if (activeState?.parallel === "valid") {
                     const extracted = extractWritePaths(toolInput.tool, output.args);
                     const relativeWrite = extracted.paths.find((path) => !isAbsolute(path));