sortie-dogs 0.7.0 → 0.7.1

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.7.0](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.7.0)
+Release: [v0.7.1](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.7.1)
 
 ## 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.51-state-observability-v1";
+export declare const RUNTIME_ASSET_VERSION = "0.3.52-acceptance-continuity-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.51-state-observability-v1";
+export const RUNTIME_ASSET_VERSION = "0.3.52-acceptance-continuity-v1";

package/dist/core/acceptance-continuity.d.ts

@@ -0,0 +1,20 @@
+export declare const ACCEPTANCE_CONTINUITY_EXTENSION: "sortie-dogs/acceptance-continuity";
+export declare const ACCEPTANCE_CONTINUITY_SCHEMA_VERSION: "0.1";
+export declare const ACCEPTANCE_CONTINUITY_AUTHORITY: "dispatch";
+export declare const MAX_ACCEPTANCE_CONTINUITY_BYTES: number;
+export declare const MAX_ACCEPTANCE_CRITERIA = 24;
+export interface AcceptanceContinuityLedger {
+    readonly schema_version: "0.1";
+    readonly authority: "dispatch";
+    readonly task_id: string;
+    readonly criteria: readonly string[];
+    readonly fingerprint: string;
+    readonly parent_fingerprint: "none" | string;
+}
+export interface AcceptanceContinuityInspection {
+    readonly ledger: AcceptanceContinuityLedger | undefined;
+    readonly error: "absent" | "malformed" | "oversize" | undefined;
+}
+export declare function normalizeAcceptanceCriteria(criteria: readonly string[]): string[];
+export declare function acceptanceContinuityFingerprint(criteria: readonly string[]): string;
+export declare function inspectAcceptanceContinuity(handoff: unknown): AcceptanceContinuityInspection;

package/dist/core/acceptance-continuity.js

@@ -0,0 +1,61 @@
+import { createHash } from "node:crypto";
+export const ACCEPTANCE_CONTINUITY_EXTENSION = "sortie-dogs/acceptance-continuity";
+export const ACCEPTANCE_CONTINUITY_SCHEMA_VERSION = "0.1";
+export const ACCEPTANCE_CONTINUITY_AUTHORITY = "dispatch";
+export const MAX_ACCEPTANCE_CONTINUITY_BYTES = 32 * 1024;
+export const MAX_ACCEPTANCE_CRITERIA = 24;
+const FINGERPRINT = /^sha256:[0-9a-f]{64}$/u;
+const MAX_TASK_ID = 256;
+const MAX_CRITERION = 2_000;
+function object(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function normalizeAcceptanceCriteria(criteria) {
+    return criteria.map((criterion) => criterion.replace(/\r\n?/gu, "\n").normalize("NFC"));
+}
+export function acceptanceContinuityFingerprint(criteria) {
+    const canonical = JSON.stringify(normalizeAcceptanceCriteria(criteria));
+    return `sha256:${createHash("sha256").update(canonical, "utf8").digest("hex")}`;
+}
+export function inspectAcceptanceContinuity(handoff) {
+    if (!object(handoff) || !object(handoff.ext) || !(ACCEPTANCE_CONTINUITY_EXTENSION in handoff.ext)) {
+        return { ledger: undefined, error: "absent" };
+    }
+    const raw = handoff.ext[ACCEPTANCE_CONTINUITY_EXTENSION];
+    let bytes;
+    try {
+        bytes = new TextEncoder().encode(JSON.stringify(raw)).byteLength;
+    }
+    catch {
+        return { ledger: undefined, error: "malformed" };
+    }
+    if (bytes > MAX_ACCEPTANCE_CONTINUITY_BYTES)
+        return { ledger: undefined, error: "oversize" };
+    if (!object(raw) || Object.keys(raw).some((key) => ![
+        "schema_version", "authority", "task_id", "criteria", "fingerprint", "parent_fingerprint",
+    ].includes(key)) || raw.schema_version !== ACCEPTANCE_CONTINUITY_SCHEMA_VERSION ||
+        raw.authority !== ACCEPTANCE_CONTINUITY_AUTHORITY || typeof raw.task_id !== "string" ||
+        raw.task_id.length === 0 || raw.task_id.length > MAX_TASK_ID || !Array.isArray(raw.criteria) ||
+        raw.criteria.length === 0 || raw.criteria.length > MAX_ACCEPTANCE_CRITERIA ||
+        !raw.criteria.every((criterion) => typeof criterion === "string" && criterion.length > 0 && criterion.length <= MAX_CRITERION) ||
+        new Set(raw.criteria).size !== raw.criteria.length || typeof raw.fingerprint !== "string" ||
+        !FINGERPRINT.test(raw.fingerprint) || !(raw.parent_fingerprint === "none" ||
+        (typeof raw.parent_fingerprint === "string" && FINGERPRINT.test(raw.parent_fingerprint)))) {
+        return { ledger: undefined, error: "malformed" };
+    }
+    const criteria = normalizeAcceptanceCriteria(raw.criteria);
+    if (new Set(criteria).size !== criteria.length || acceptanceContinuityFingerprint(criteria) !== raw.fingerprint) {
+        return { ledger: undefined, error: "malformed" };
+    }
+    return {
+        ledger: {
+            schema_version: ACCEPTANCE_CONTINUITY_SCHEMA_VERSION,
+            authority: ACCEPTANCE_CONTINUITY_AUTHORITY,
+            task_id: raw.task_id,
+            criteria,
+            fingerprint: raw.fingerprint,
+            parent_fingerprint: raw.parent_fingerprint,
+        },
+        error: undefined,
+    };
+}

package/dist/index.d.ts

@@ -19,5 +19,7 @@ export type { HandoffDenialReason, OpenCodeEvent, OpenCodeHooks, OpenCodePlugin,
 export { CONSULTATION_CAPABILITIES, CONSULTATION_ROLE_POLICY, MAX_REVIEW_ARTIFACT_BYTES, SOURCE_REVIEW_RISK_TAGS, STRATEGY_TRIGGERS, evaluateReviewAvailability, evaluateReviewGate, evaluateSourceReviewRequirement, isSourceReviewRiskTag, requiresSourceReview, shouldConsultStrategy, validateReviewArtifact, validateReviewVerdict, } from "./core/consultation.js";
 export type { ConsultationAdapter, ConsultationCapability, ConsultationRequest, ConsultationResult, ReviewArtifact, ReviewAvailability, ReviewFinding, ReviewFindingSeverity, ReviewGateInput, ReviewGateResult, ReviewVerdict, ReviewVerdictKind, SourceReviewConsultationRequest, SourceReviewConsultationResult, SourceReviewRequirement, SourceReviewRequirementInput, SourceReviewRiskTag, StrategyConsultationRequest, StrategyConsultationResult, StrategyTrigger, StrategyTriggerInput, UnavailableConsultationResult, ValidationResult, } from "./core/consultation.js";
 export type * from "./core/types.js";
+export { ACCEPTANCE_CONTINUITY_AUTHORITY, ACCEPTANCE_CONTINUITY_EXTENSION, ACCEPTANCE_CONTINUITY_SCHEMA_VERSION, acceptanceContinuityFingerprint, inspectAcceptanceContinuity, MAX_ACCEPTANCE_CONTINUITY_BYTES, MAX_ACCEPTANCE_CRITERIA, normalizeAcceptanceCriteria, } from "./core/acceptance-continuity.js";
+export type { AcceptanceContinuityInspection, AcceptanceContinuityLedger, } from "./core/acceptance-continuity.js";
 export { inspectRetainedStateCapsule, MAX_RETAINED_STATE_BYTES, MAX_RETAINED_STATE_ITEMS, MAX_RETAINED_STATE_WARNINGS, RETAINED_STATE_AUTHORITY, RETAINED_STATE_EXTENSION, RETAINED_STATE_SCHEMA_VERSION, } from "./core/retained-state.js";
 export type { AdmissionReceipt, NextEvidenceDecision, RetainedStateCapsule, RetainedStateInspection, RetainedStateWarning, RetainedValidationAttempt, } from "./core/retained-state.js";

package/dist/index.js

@@ -15,4 +15,5 @@ export { SortieDogsPlugin } from "./plugin/index.js";
  */
 export { HandoffDeniedError, InvalidModelTargetError, ModelRoutingDeniedError, isExplicitTaskHandoff, } from "./plugin/index.js";
 export { CONSULTATION_CAPABILITIES, CONSULTATION_ROLE_POLICY, MAX_REVIEW_ARTIFACT_BYTES, SOURCE_REVIEW_RISK_TAGS, STRATEGY_TRIGGERS, evaluateReviewAvailability, evaluateReviewGate, evaluateSourceReviewRequirement, isSourceReviewRiskTag, requiresSourceReview, shouldConsultStrategy, validateReviewArtifact, validateReviewVerdict, } from "./core/consultation.js";
+export { ACCEPTANCE_CONTINUITY_AUTHORITY, ACCEPTANCE_CONTINUITY_EXTENSION, ACCEPTANCE_CONTINUITY_SCHEMA_VERSION, acceptanceContinuityFingerprint, inspectAcceptanceContinuity, MAX_ACCEPTANCE_CONTINUITY_BYTES, MAX_ACCEPTANCE_CRITERIA, normalizeAcceptanceCriteria, } from "./core/acceptance-continuity.js";
 export { inspectRetainedStateCapsule, MAX_RETAINED_STATE_BYTES, MAX_RETAINED_STATE_ITEMS, MAX_RETAINED_STATE_WARNINGS, RETAINED_STATE_AUTHORITY, RETAINED_STATE_EXTENSION, RETAINED_STATE_SCHEMA_VERSION, } from "./core/retained-state.js";

package/dist/plugin/continuation.js

@@ -89,25 +89,27 @@ const ROLLOVER_PROMPT = [
     "If a section has nothing, write exactly '- なし'. Never delete a heading.",
     "At most 2 content lines per section. Keep the whole output under 1200 characters.",
     "Copy task identity, manifest paths, commands, exit codes, and counter values character-for-character.",
+    "Never author, shorten, infer, or treat summary text as acceptance authority. Preserve the exact acceptance fingerprint and handoff path; the resumed coordinator rereads that immutable handoff before dispatch.",
+    "The unmet-user-requirements, constraints, candidate queue, blocker, and next-action sections never replace the immutable handoff acceptance ledger.",
     "The coordinator final report immediately before compaction is the newest source of truth. Its outcomes and next action override older context.",
     "Never list a unit as uncommitted or next when that final report says it was committed or completed.",
     "Drop the finished unit's conversation, raw logs, diffs, and tool output.",
-    "Preserve task identity, every accepted fact, both manifests, ordered validation history, batchTarget, batchAttempted, batchCommitted, batchReconciled, inventory fingerprint, bounded candidate queue, pending tracker updates, tracker flush state, blocker state, and the exact next action. If a value is absent, write なし; never guess one.",
+    "Preserve task identity, acceptance fingerprint, exact handoff path, both manifests, ordered validation history, batchTarget, batchAttempted, batchCommitted, batchReconciled, inventory fingerprint, bounded candidate queue, pending tracker updates, tracker flush state, blocker state, and the exact next action. If a value is absent, write なし; never guess one.",
     "Never write credentials, API keys, tokens, personal data, or source code.",
     "Never output an HTML comment.",
     "",
     ROLLOVER_TOKEN,
     "",
     "## 未達のユーザー要求",
-    "- <まだ満たされていない明示要求>",
+    "- <acceptance criteriaを除く、まだ満たされていない明示要求>",
     "",
     "## task identity と制約",
     "- <task_id・候補識別子・project root。該当なしはなし>",
-    "- <守り続ける制約と確定済みの受け入れ基準>",
+    "- <守り続ける非acceptance制約。該当なしはなし>",
     "",
     "## manifest",
-    "- source_manifest: <exact entries または none>",
-    "- operation_manifest: <exact path または none>",
+    "- handoff_path: <exact path または none> / acceptance_fingerprint: <exact fingerprint または none>",
+    "- source_manifest: <exact entries または none> / operation_manifest: <exact path または none>",
     "",
     "## validation履歴",
     "- <command> | exit <code> | <fingerprint>",
@@ -116,7 +118,7 @@ const ROLLOVER_PROMPT = [
     "- batchTarget: <n> / batchAttempted: <n> / batchCommitted: <n> / batchReconciled: <n>",
     "",
     "## tracker batch state",
-    "- inventoryFingerprint: <fingerprint> / candidateQueue: <bounded identity, status, ordering, implementation root, acceptance fingerprint, acceptance hashes, and redacted acceptance digest records>",
+    "- inventoryFingerprint: <fingerprint> / candidateQueue: <bounded identity, status, ordering, implementation root, exact handoff path, and opaque acceptance fingerprint only>",
     "- pendingTrackerUpdates: <terminal outcomes awaiting flush> / flushState: <pending | flushed | reconciliation-required>",
     "",
     "## 未解決blocker",
@@ -127,7 +129,7 @@ const ROLLOVER_PROMPT = [
 ].join("\n");
 const RECOVERY_ROLLOVER_PROMPT = ROLLOVER_PROMPT
     .replace("The coordinator final report immediately before compaction is the newest source of truth. Its outcomes and next action override older context.", "The recovery report overrides only terminal outcomes and batch counters. Preserve unmet user requirements, ordered scope, no-stop constraints, and the exact next unit from the conversation.")
-    .replace("Preserve task identity, every accepted fact, both manifests, ordered validation history, batchTarget, batchAttempted, batchCommitted, batchReconciled, inventory fingerprint, bounded candidate queue, pending tracker updates, tracker flush state, blocker state, and the exact next action. If a value is absent, write なし; never guess one.", "Preserve task identity, every accepted fact, both manifests, ordered validation history, batchTarget, batchAttempted, batchCommitted, batchReconciled, inventory fingerprint, bounded candidate queue, pending tracker updates, tracker flush state, blocker state, unmet ordered scope, and the exact next unit. If a value is absent, write なし; never guess one.");
+    .replace("Preserve task identity, acceptance fingerprint, exact handoff path, both manifests, ordered validation history, batchTarget, batchAttempted, batchCommitted, batchReconciled, inventory fingerprint, bounded candidate queue, pending tracker updates, tracker flush state, blocker state, and the exact next action. If a value is absent, write なし; never guess one.", "Preserve task identity, acceptance fingerprint, exact handoff path, both manifests, ordered validation history, batchTarget, batchAttempted, batchCommitted, batchReconciled, inventory fingerprint, bounded candidate queue, pending tracker updates, tracker flush state, blocker state, unmet ordered scope, and the exact next unit. Never derive acceptance from summary text. If a value is absent, write なし; never guess one.");
 const ROLLOVER_HEADINGS = [
     "## 未達のユーザー要求",
     "## task identity と制約",

package/dist/plugin/index.js

@@ -2,6 +2,8 @@ import { createHash } from "node:crypto";
 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 { 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 { normalizeRelativePath, RelativePathError } from "../core/path.js";
 import { ScopeLeaseError, ScopeLeaseRegistry } from "../core/scope-lease-registry.js";
 import { produceWorktreeCommitArtifact, recoverWorktreeCommitArtifact, resolveValidationExecutable, WorktreeCommitArtifactError, } from "../core/worktree-commit-artifact.js";
@@ -36,6 +38,7 @@ 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`;
+const GENERATED_PARALLEL_ACCEPTANCE = "Complete the prepared parallel descriptor within its declared scope.";
 export const PARALLEL_COMMIT_ARTIFACT_CAPABILITY = "sortie_create_parallel_commit_artifact";
 const CONTRACT_DEFECTS = { limit: 8, pointerCharacters: 120 };
 function contractPointer(pointer) {
@@ -498,7 +501,7 @@ function taskHeaderCount(text, keys) {
 }
 function taskInlineValues(text, keys) {
     const aliases = keys.map((key) => key.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")).join("|");
-    return [...text.matchAll(new RegExp(`^\\s*(?:${aliases})\\s*:\\s*(\\S.*?)\\s*$`, "gimu"))]
+    return [...text.matchAll(new RegExp(`^[\\t ]*(?:${aliases})[\\t ]*:[\\t ]*(\\S.*?)[\\t ]*$`, "gimu"))]
         .map((match) => match[1]);
 }
 function taskBlockHasContent(text, keys) {
@@ -524,6 +527,45 @@ function taskBlockHasContent(text, keys) {
     }
     return false;
 }
+function taskAcceptanceCriteria(text) {
+    const inline = taskInlineValues(text, ["acceptance"]);
+    if (inline.length === 1) {
+        const array = parseStringArray(inline[0]);
+        return normalizeAcceptanceCriteria(array ?? [unquoteValue(inline[0])]);
+    }
+    if (inline.length > 1)
+        return undefined;
+    const lines = text.split(/\r?\n/u);
+    const headers = lines.flatMap((line, index) => {
+        const match = /^(\s*)acceptance\s*:\s*$/iu.exec(line);
+        return match === null ? [] : [{ index, indent: match[1].replaceAll("\t", "  ").length }];
+    });
+    if (headers.length !== 1)
+        return undefined;
+    const values = [];
+    for (let index = headers[0].index + 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 <= headers[0].indent)
+            break;
+        const item = /^\s*-\s+(.+?)\s*$/u.exec(line)?.[1];
+        if (item === undefined)
+            return undefined;
+        let value;
+        try {
+            value = item.startsWith("\"") ? JSON.parse(item) : unquoteValue(item);
+        }
+        catch {
+            return undefined;
+        }
+        if (typeof value !== "string" || value.length === 0)
+            return undefined;
+        values.push(value);
+    }
+    return values.length === 0 ? undefined : normalizeAcceptanceCriteria(values);
+}
 function taskContractText(text) {
     const lines = text.split(/\r?\n/u);
     const digestIndex = lines.findIndex((line) => /^\s*context_digest\s*:\s*$/iu.test(line));
@@ -801,7 +843,9 @@ export const SortieDogsPlugin = async (input, options) => {
     let manifestAbsent = false;
     let bootstrapRequired = false;
     let bootstrapCompleted = false;
-    let assetVersionReported = false;
+    const assetVersionPins = new Map();
+    const rootAcceptanceContinuity = new Map();
+    const parallelAcceptanceContinuity = new Map();
     const globalConfig = await readOptionalGlobalConfig();
     const sessionOperationMetrics = new Map();
     function appLogInfo(message, sessionID, extra) {
@@ -957,7 +1001,6 @@ export const SortieDogsPlugin = async (input, options) => {
         loading = (async () => {
             try {
                 project ??= await createProjectPaths(resolveProjectRoot(input));
-                await reportAssetVersionSkew(project);
                 const projectConfig = await readOptionalProjectConfig(project);
                 const environmentConfig = readEnvironmentConfig();
                 const parsed = resolvePluginConfigurationSourcesWithGlobal(globalConfig, projectConfig, environmentConfig, options);
@@ -998,19 +1041,54 @@ export const SortieDogsPlugin = async (input, options) => {
     }
     /**
      * Installed agents and this plugin implement two halves of one contract. A project that installed
-     * a different asset version is reported once so the mismatch is visible before it shows up as an
-     * unexplained handshake failure. Reporting never blocks: reinstalling is the operator's decision.
+     * a different asset version is sticky for this plugin instance. Reinstalling files cannot update an
+     * already-running coordinator prompt, so worker dispatch remains blocked until a fresh session loads.
      */
-    async function reportAssetVersionSkew(paths) {
-        if (assetVersionReported)
-            return;
-        assetVersionReported = true;
-        const marker = await readFile(paths.absolute(PROJECT_VERSION_MARKER), "utf8").catch(() => undefined);
-        const installed = marker?.trim();
-        if (installed === undefined || installed.length === 0 || installed === RUNTIME_ASSET_VERSION)
-            return;
-        console.warn(`Sortie-dogs: this project installed agent assets ${installed} but the loaded plugin ships ` +
-            `${RUNTIME_ASSET_VERSION}. Run "sortie-dogs init ." to reinstall the matching agents.`);
+    async function readAssetVersionMarker(path) {
+        try {
+            const value = (await readFile(path, "utf8")).trim();
+            return value.length === 0 ? { kind: "corrupt" } : { kind: "present", value };
+        }
+        catch (error) {
+            return isRecord(error) && error.code === "ENOENT" ? { kind: "absent" } : { kind: "corrupt" };
+        }
+    }
+    async function currentAssetVersionStatus(paths) {
+        const local = await readAssetVersionMarker(paths.absolute(PROJECT_VERSION_MARKER));
+        if (local.kind === "corrupt")
+            return "mismatch";
+        if (local.kind === "present")
+            return local.value === RUNTIME_ASSET_VERSION ? "current" : "mismatch";
+        let globalRoot;
+        try {
+            globalRoot = await resolveGlobalConfigRoot();
+        }
+        catch {
+            return "mismatch";
+        }
+        const global = await readAssetVersionMarker(join(globalRoot, "sortie-dogs.version"));
+        if (global.kind === "absent")
+            return "unmarked";
+        return global.kind === "present" && global.value === RUNTIME_ASSET_VERSION ? "current" : "mismatch";
+    }
+    async function pinAssetVersion(sessionID) {
+        const pinned = assetVersionPins.get(sessionID);
+        if (pinned !== undefined)
+            return pinned;
+        project ??= await createProjectPaths(resolveProjectRoot(input));
+        const status = await currentAssetVersionStatus(project);
+        assetVersionPins.set(sessionID, status);
+        while (assetVersionPins.size > ACTIVE_SESSION_CACHE.maximum) {
+            const candidate = assetVersionPins.keys().next().value;
+            if (coordinatorRoots.has(candidate))
+                break;
+            assetVersionPins.delete(candidate);
+        }
+        if (status === "mismatch") {
+            console.warn(`Sortie-dogs: installed agent assets do not match ${RUNTIME_ASSET_VERSION}. ` +
+                "Repair the marker, then start a fresh coordinator session.");
+        }
+        return status;
     }
     /**
      * A project without an operation manifest never opted into the write gate. Enforcing a scope that
@@ -1277,6 +1355,20 @@ export const SortieDogsPlugin = async (input, options) => {
             operation_manifest: join(descriptor.managed_path, CANONICAL_CONTRACT_DIRECTORY, `${descriptor.task_id}.operation-manifest.json`),
         };
     }
+    function parallelAcceptanceKey(descriptor) {
+        return `${descriptor.run_id}\u0000${descriptor.dispatch_id}`;
+    }
+    function generatedParallelAcceptance(descriptor, parent) {
+        const criteria = [...(parent?.criteria ?? []), GENERATED_PARALLEL_ACCEPTANCE];
+        return {
+            schema_version: ACCEPTANCE_CONTINUITY_SCHEMA_VERSION,
+            authority: ACCEPTANCE_CONTINUITY_AUTHORITY,
+            task_id: descriptor.task_id,
+            criteria,
+            fingerprint: acceptanceContinuityFingerprint(criteria),
+            parent_fingerprint: parent?.fingerprint ?? "none",
+        };
+    }
     async function ensureParallelContractDirectory(canonicalRoot) {
         let parent = canonicalRoot;
         for (const segment of [".sortie-dogs", "contracts"]) {
@@ -1300,7 +1392,7 @@ export const SortieDogsPlugin = async (input, options) => {
         }
         return parent;
     }
-    async function createParallelControlFiles(descriptor, validationCommands) {
+    async function createParallelControlFiles(descriptor, validationCommands, parentAcceptance) {
         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.");
@@ -1311,6 +1403,33 @@ export const SortieDogsPlugin = async (input, options) => {
         if (!samePath(contractDirectory, expectedContractDirectory)) {
             throw new ParallelDispatchError("lifecycle-failed", "Parallel contract directory escapes the managed worktree.");
         }
+        const expectedAcceptance = generatedParallelAcceptance(descriptor, parentAcceptance);
+        let acceptance = parallelAcceptanceContinuity.get(parallelAcceptanceKey(descriptor));
+        if (acceptance === undefined) {
+            const existing = await readFile(paths.handoff_path, "utf8").catch(() => undefined);
+            if (existing !== undefined) {
+                try {
+                    const parsed = JSON.parse(existing);
+                    const validated = validateHandoffSchema(parsed);
+                    const inspectedAcceptance = validated.ok ? inspectAcceptanceContinuity(validated.value).ledger : undefined;
+                    if (inspectedAcceptance?.task_id === descriptor.task_id &&
+                        inspectedAcceptance.criteria.at(-1) === GENERATED_PARALLEL_ACCEPTANCE &&
+                        (parentAcceptance === undefined ||
+                            (inspectedAcceptance.fingerprint === expectedAcceptance.fingerprint &&
+                                inspectedAcceptance.parent_fingerprint === expectedAcceptance.parent_fingerprint))) {
+                        acceptance = inspectedAcceptance;
+                    }
+                }
+                catch {
+                    // Exact generated-content comparison below rejects malformed or unrelated existing controls.
+                }
+            }
+        }
+        acceptance ??= expectedAcceptance;
+        parallelAcceptanceContinuity.set(parallelAcceptanceKey(descriptor), acceptance);
+        while (parallelAcceptanceContinuity.size > ACTIVE_SESSION_CACHE.maximum * 3) {
+            parallelAcceptanceContinuity.delete(parallelAcceptanceContinuity.keys().next().value);
+        }
         const manifestValue = {
             version: "0.1.0",
             task_id: descriptor.task_id,
@@ -1323,10 +1442,13 @@ export const SortieDogsPlugin = async (input, options) => {
             profile: "minimal",
             id: descriptor.task_id,
             created_at: new Date().toISOString(),
-            ext: { "sortie-dogs/write-gate": {
+            ext: {
+                "sortie-dogs/write-gate": {
                     operation_manifest: relative(descriptor.managed_path, paths.operation_manifest).replaceAll("\\", "/"),
                     project_root: descriptor.managed_path,
-                } },
+                },
+                [ACCEPTANCE_CONTINUITY_EXTENSION]: acceptance,
+            },
             task: {
                 title: `Parallel task ${descriptor.task_id}`,
                 objective: "Complete the prepared parallel descriptor within its declared scope.",
@@ -1389,12 +1511,14 @@ export const SortieDogsPlugin = async (input, options) => {
             rm(paths.operation_manifest, { force: true }),
         ]);
     }
-    async function ensureParallelReadyControls(snapshot) {
-        if (snapshot.archived || snapshot.cancelled || snapshot.ready.length === 0)
+    async function ensureParallelReadyControls(snapshot, parentAcceptance) {
+        if (snapshot.archived || snapshot.cancelled)
             return;
         await ensureLoaded();
         const validationCommands = loaded?.manifest?.validation ?? [];
-        await Promise.all(snapshot.ready.map((descriptor) => createParallelControlFiles(descriptor, validationCommands)));
+        await Promise.all(snapshot.tasks
+            .filter(({ phase }) => phase === "pending" || phase === "reserved")
+            .map(({ descriptor }) => createParallelControlFiles(descriptor, validationCommands, parentAcceptance)));
     }
     async function restoreActiveParallelControls(snapshot) {
         await ensureLoaded();
@@ -1410,7 +1534,16 @@ export const SortieDogsPlugin = async (input, options) => {
             cancelled: snapshot.cancelled,
             archived: snapshot.archived,
             terminal_reason: snapshot.terminal_reason,
-            ready: snapshot.ready.map((descriptor) => ({ ...descriptor, ...parallelControlPaths(descriptor) })),
+            ready: snapshot.ready.map((descriptor) => {
+                const acceptance = parallelAcceptanceContinuity.get(parallelAcceptanceKey(descriptor));
+                return {
+                    ...descriptor,
+                    ...parallelControlPaths(descriptor),
+                    acceptance: acceptance?.criteria ?? [],
+                    acceptance_fingerprint: acceptance?.fingerprint,
+                    acceptance_parent_fingerprint: acceptance?.parent_fingerprint,
+                };
+            }),
             tasks: snapshot.tasks.map(({ descriptor, worktree_id, phase, call_id, child_session_id, outcome, artifact }) => ({
                 task_id: descriptor.task_id,
                 worktree_id,
@@ -1528,10 +1661,10 @@ export const SortieDogsPlugin = async (input, options) => {
             if (result.status === "serial-fallback")
                 return JSON.stringify(result);
             try {
-                await ensureParallelReadyControls(result.snapshot);
+                await ensureParallelReadyControls(result.snapshot, rootAcceptanceContinuity.get(ownerRoot));
             }
             catch (error) {
-                await Promise.all(result.snapshot.ready.map((descriptor) => removeParallelControlFiles(descriptor).catch(() => undefined)));
+                await Promise.all(result.snapshot.tasks.map(({ descriptor }) => removeParallelControlFiles(descriptor).catch(() => undefined)));
                 await coordinator.cancel(ownerRoot, result.snapshot.run_id).catch(() => undefined);
                 throw error;
             }
@@ -1916,11 +2049,15 @@ export const SortieDogsPlugin = async (input, options) => {
             }
             preparedDirectories.push(...(extraction.createdDirectories ?? []).map((directory) => resolve(inspectedProjectRoot, directory)));
         }
+        const continuity = inspectAcceptanceContinuity(validation.value);
         const identity = {
             explicitWriteGate: extension !== undefined,
+            handoffID: validation.value.id,
             manifestPath,
             projectRoot: inspectedProjectRoot,
             validationCommands: new Set(manifest.validation.map(normalizeCommand)),
+            acceptanceContinuity: continuity.ledger,
+            acceptanceContinuityError: continuity.error,
         };
         if (sessionID === undefined)
             return identity;
@@ -2337,6 +2474,7 @@ export const SortieDogsPlugin = async (input, options) => {
             else {
                 coordinatorRoots.delete(sessionID);
                 explicitCoordinatorModels.delete(sessionID);
+                assetVersionPins.delete(sessionID);
             }
         }
         const limit = ACTIVE_SESSION_CACHE.maximum - (reserveSlot ? 1 : 0);
@@ -2344,6 +2482,7 @@ export const SortieDogsPlugin = async (input, options) => {
             const sessionID = coordinatorRoots.keys().next().value;
             coordinatorRoots.delete(sessionID);
             explicitCoordinatorModels.delete(sessionID);
+            assetVersionPins.delete(sessionID);
         }
     }
     async function rememberCoordinatorRoot(sessionID) {
@@ -2485,6 +2624,7 @@ export const SortieDogsPlugin = async (input, options) => {
     function evictSession(sessionID) {
         activeSessions.delete(sessionID);
         sessionOperationMetrics.delete(sessionID);
+        rootAcceptanceContinuity.delete(sessionID);
         abandonSessionLease(sessionID);
         sessionAuthorizations.delete(sessionID);
         bindingPins.delete(sessionID);
@@ -2494,6 +2634,7 @@ export const SortieDogsPlugin = async (input, options) => {
         }
         expiredSessions.delete(sessionID);
         coordinatorRoots.delete(sessionID);
+        assetVersionPins.delete(sessionID);
         explicitCoordinatorModels.delete(sessionID);
         bindingDenials.delete(sessionID);
         sessionTaskIDs.delete(sessionID);
@@ -2649,6 +2790,24 @@ export const SortieDogsPlugin = async (input, options) => {
             return undefined;
         }
     }
+    function acceptanceParentPrefix(ledger) {
+        if (ledger.parent_fingerprint === "none")
+            return undefined;
+        for (let length = 1; length < ledger.criteria.length; length += 1) {
+            const prefix = ledger.criteria.slice(0, length);
+            if (acceptanceContinuityFingerprint(prefix) === ledger.parent_fingerprint)
+                return prefix;
+        }
+        return undefined;
+    }
+    async function recoverAcceptanceParent(sessionID, ledger, descriptor) {
+        if (descriptor === undefined || acceptanceParentPrefix(ledger) === undefined ||
+            ledger.parent_fingerprint === "none")
+            return false;
+        const snapshot = await (await getParallelCoordinator()).snapshot(sessionID, descriptor.run_id);
+        return snapshot?.tasks.some(({ phase, descriptor: durable }) => (phase === "pending" || phase === "reserved" || phase === "running") &&
+            sameParallelDescriptor(durable, descriptor)) === true;
+    }
     async function assistantMessageText(sessionID, messageID, expectedAgent, partID) {
         const messages = input.client?.session?.messages;
         if (messages === undefined)
@@ -2715,6 +2874,7 @@ export const SortieDogsPlugin = async (input, options) => {
         if (persistedTurn !== undefined && persistedTurn.agent !== COORDINATOR_AGENT)
             return false;
         await rememberCoordinatorRoot(sessionID);
+        await pinAssetVersion(sessionID);
         releaseSessionEnforcement(sessionID);
         fastLane.beginTurn(sessionID, persistedTurn?.synthetic ?? false);
         return true;
@@ -3021,6 +3181,8 @@ export const SortieDogsPlugin = async (input, options) => {
                     ...(metrics ?? {}),
                     ...operationMetricsSnapshot(textInput.sessionID),
                 });
+                if (runOutcome === "DONE")
+                    rootAcceptanceContinuity.delete(textInput.sessionID);
             }
             await completeContinuationText(textInput.sessionID, textOutput.text, false);
         },
@@ -3077,6 +3239,7 @@ export const SortieDogsPlugin = async (input, options) => {
                     fastLane.beginTurn(chatInput.sessionID, synthetic);
                     releaseSessionEnforcement(chatInput.sessionID);
                     await rememberCoordinatorRoot(chatInput.sessionID);
+                    await pinAssetVersion(chatInput.sessionID);
                 }
                 else {
                     if (!synthetic && isCoordinatorSession(chatInput.sessionID)) {
@@ -3400,7 +3563,14 @@ export const SortieDogsPlugin = async (input, options) => {
                 let parallelWorkerAuthorized = false;
                 let parallelWorkerAlreadyBound = false;
                 let reservedParallelDescriptor;
+                let validatedRootAcceptance;
                 if (toolInput.tool === "task" && taskRole === "dog-worker" && isRecord(output.args)) {
+                    await ensureLoaded();
+                    const assetVersionStatus = await pinAssetVersion(toolInput.sessionID);
+                    if (assetVersionStatus === "mismatch") {
+                        throw new Error("SORTIE_FRESH_SESSION_REQUIRED: installed agent assets and the loaded plugin use different contracts; " +
+                            "run sortie-dogs init . and start a fresh coordinator session");
+                    }
                     const prompt = typeof output.args.prompt === "string" ? output.args.prompt : "";
                     const contractPrompt = taskContractText(prompt);
                     reservedParallelDescriptor = parallelDescriptor(prompt);
@@ -3522,6 +3692,49 @@ export const SortieDogsPlugin = async (input, options) => {
                                 defects: [contractDefect("contract", "/", "dispatch_identity_mismatch")],
                             });
                         }
+                        if (assetVersionStatus === "current") {
+                            const ledger = identity.acceptanceContinuity;
+                            if (ledger === undefined) {
+                                throw new HandoffDeniedError("contract-invalid", handoffPaths[0], {
+                                    defects: [contractDefect("handoff", "/ext/sortie-dogs~1acceptance-continuity", `acceptance_continuity_${identity.acceptanceContinuityError ?? "missing"}`)],
+                                });
+                            }
+                            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])) {
+                                throw new HandoffDeniedError("contract-invalid", handoffPaths[0], {
+                                    defects: [contractDefect("contract", "/acceptance", "acceptance_continuity_mismatch")],
+                                });
+                            }
+                            const previous = rootAcceptanceContinuity.get(toolInput.sessionID);
+                            if (previous === undefined) {
+                                if (ledger.parent_fingerprint !== "none" &&
+                                    !await recoverAcceptanceParent(toolInput.sessionID, ledger, reservedParallelDescriptor)) {
+                                    throw new HandoffDeniedError("contract-invalid", handoffPaths[0], {
+                                        defects: [contractDefect("handoff", "/ext/sortie-dogs~1acceptance-continuity", "acceptance_parent_continuity_mismatch")],
+                                    });
+                                }
+                            }
+                            else if (previous.task_id === ledger.task_id && previous.fingerprint === ledger.fingerprint) {
+                                if (ledger.parent_fingerprint !== previous.parent_fingerprint) {
+                                    throw new HandoffDeniedError("contract-invalid", handoffPaths[0], {
+                                        defects: [contractDefect("handoff", "/ext/sortie-dogs~1acceptance-continuity", "acceptance_parent_continuity_mismatch")],
+                                    });
+                                }
+                            }
+                            else {
+                                if (ledger.parent_fingerprint !== previous.fingerprint ||
+                                    ledger.criteria.length <= previous.criteria.length ||
+                                    previous.criteria.some((criterion, index) => criterion !== ledger.criteria[index])) {
+                                    throw new HandoffDeniedError("contract-invalid", handoffPaths[0], {
+                                        defects: [contractDefect("handoff", "/ext/sortie-dogs~1acceptance-continuity", "acceptance_parent_continuity_mismatch")],
+                                    });
+                                }
+                            }
+                            validatedRootAcceptance = ledger;
+                        }
                     }
                 }
                 if (reservedParallelDescriptor !== undefined) {
@@ -3546,6 +3759,13 @@ export const SortieDogsPlugin = async (input, options) => {
                     parallelWorkerAlreadyBound,
                     parallelWorkerAuthorized,
                 });
+                if (validatedRootAcceptance !== undefined && reservedParallelDescriptor === undefined) {
+                    rootAcceptanceContinuity.delete(toolInput.sessionID);
+                    rootAcceptanceContinuity.set(toolInput.sessionID, validatedRootAcceptance);
+                    while (rootAcceptanceContinuity.size > ACTIVE_SESSION_CACHE.maximum) {
+                        rootAcceptanceContinuity.delete(rootAcceptanceContinuity.keys().next().value);
+                    }
+                }
                 if (resumedWorkerSessionID !== undefined) {
                     const recoverableParallel = parallelRecoverableChildren.get(resumedWorkerSessionID);
                     if (recoverableParallel !== undefined) {