sortie-dogs 0.9.0 → 0.9.2

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.0](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.0)
+Release: [v0.9.2](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.2)
 
 ## 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.75-sequential-acceptance-parent-v1";
+export declare const RUNTIME_ASSET_VERSION = "0.3.77-terminal-delivery-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.75-sequential-acceptance-parent-v1";
+export const RUNTIME_ASSET_VERSION = "0.3.77-terminal-delivery-v1";

package/dist/core/goal-bound.d.ts

@@ -143,6 +143,8 @@ export type GoalFlightEvent = (GoalEventBase & {
     readonly goal_id: string;
     readonly unit_id: string;
     readonly disposition: "succeeded" | "failed" | "cancelled";
+    /** Missing on pre-v0.9.1 ledgers and therefore interpreted as an acceptance result. */
+    readonly result_class?: "acceptance" | "process-defect" | "interrupted";
     readonly progress_fingerprint: string | null;
     readonly evidence: readonly GoalEvidence[];
     readonly elapsed_ms: number | null;

package/dist/core/goal-bound.js

@@ -178,7 +178,11 @@ export function reduceGoalFlight(records) {
                 .filter((criterionID) => !state.satisfied_criteria.includes(criterionID));
             const progress = newCriteria.length > 0;
             requireState(event.progress_fingerprint === (progress ? goalFingerprint(event.evidence) : null), "evidence", "Progress fingerprint does not represent newly accepted evidence.");
-            const nextNoProgress = progress ? 0 : state.no_progress_results + 1;
+            const acceptanceFailure = event.disposition === "failed" &&
+                (event.result_class === undefined || event.result_class === "acceptance");
+            const nextNoProgress = progress ? 0 : acceptanceFailure
+                ? state.no_progress_results + 1
+                : state.no_progress_results;
             const elapsed = state.consumed_time_ms === null || event.elapsed_ms === null ? null : state.consumed_time_ms + event.elapsed_ms;
             const cost = state.consumed_cost_usd === null || event.cost_usd === null ? null : state.consumed_cost_usd + event.cost_usd;
             state = { ...state, consumed_units: state.consumed_units + 1, consumed_time_ms: elapsed, consumed_cost_usd: cost,

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

@@ -36,7 +36,7 @@ import { TerminalRescueRuntime } from "../core/terminal-rescue-runtime.js";
 import { OpenCodeTerminalRescueHost } from "./terminal-rescue-host.js";
 import { AdaptiveRemediationRuntime, AdaptiveRunFlightLineage } from "../core/adaptive-remediation-runtime.js";
 import { DEFAULT_ADAPTIVE_REMEDIATION_MODEL, GitAdaptiveRemediationHost, OpenCodeAdaptiveRemediationProvider } from "./adaptive-remediation-host.js";
-import { collectRunMetrics, createSortieResult, insertRunMetrics, insertSortieResult, terminalRunOutcome } from "./run-metrics.js";
+import { collectRunMetrics, createSortieResult, insertRunMetrics, insertSortieResult, replaceDoneTerminalStatus, replaceTerminalStatus, sanitizeTerminalReport, terminalRunOutcome } from "./run-metrics.js";
 const INPUT_LIMITS = { config: 64 * 1024, manifest: 512 * 1024, handoff: 2 * 1024 * 1024, parallel: 512 * 1024 };
 const INSPECTION_CACHE = { maximum: 256, ttlMilliseconds: 30 * 60 * 1000 };
 const ACTIVE_SESSION_CACHE = { maximum: 256, ttlMilliseconds: 30 * 60 * 1000 };
@@ -619,6 +619,8 @@ const LABELLED_VALUE = /^[\t ]*(?:[-*][\t ]+)?[^\r\n:=]{1,64}[\t ]*[=:][\t ]*(.*
 function roleTokenValues(text) {
     const values = [];
     for (const line of text.split(/\r?\n/u)) {
+        if (/^[\t ]*(?:[-*][\t ]+)?(?:delivery_intent|goal_[a-z0-9_]+)[\t ]*[=:]/iu.test(line))
+            continue;
         const match = LABELLED_VALUE.exec(line);
         if (match === null)
             continue;
@@ -1516,13 +1518,56 @@ 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;
-        if (receipt === undefined && outcome === "DONE") {
+        const proved = goal?.acceptance_contract !== null && goal?.acceptance_contract !== undefined &&
+            goal.acceptance_contract.criteria.every(({ criterion_id }) => goal.satisfied_criteria.includes(criterion_id));
+        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") {
+            receipt = await terminalGoal(sessionID, "completed", "succeeded").catch(() => undefined);
+        }
+        else if (receipt === undefined && outcome === "INTERRUPTED") {
+            receipt = await terminalGoal(sessionID, "stopped", "stopped").catch(() => undefined);
+        }
+        else if (receipt === undefined && outcome === "NEED_DECISION") {
+            receipt = await terminalGoal(sessionID, "awaiting_user", "stopped").catch(() => undefined);
+        }
         else if (receipt === undefined && outcome === "BLOCKED") {
             const reason = /(^|\n)TRUE_BLOCKER\s*:\s*user-decision\s*:/iu.test(text)
                 ? "awaiting_user"
@@ -1533,95 +1578,169 @@ 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 declaredDelivery(prompt) {
-        const entries = handoffEntries(prompt);
-        const explicit = handoffValue(entries, ["delivery_mode"]);
-        if (explicit === "planning-only" || explicit === "mvp-first" || explicit === "repair-first" || explicit === "controlled-change")
-            return explicit;
-        const intent = handoffValue(entries, ["delivery_intent"]);
-        const declared = intent === "design" || intent === "registration" || intent === "repair" || intent === "controlled-change"
-            ? intent : "implementation";
-        return selectGoalDelivery({ declared_intent: declared,
-            requested_usable_path_established: handoffValue(entries, ["usable_path_established"]) === "true",
-            irreversible_or_major_scope: handoffValue(entries, ["controlled_change"]) === "true" });
-    }
-    function declaredGoalContract(prompt) {
+    function goalDeclarationContract(prompt) {
         const lines = prompt.split(/\r?\n/u);
         const criterionStarts = lines.flatMap((line, index) => /^\s*goal_criterion_id\s*:/u.test(line) ? [index] : []);
-        if (criterionStarts.length > 1) {
-            const validation = handoffValue(handoffEntries(prompt), ["validation"]);
-            const contracts = criterionStarts.map((start, index) => declaredGoalContract(lines.slice(start, criterionStarts[index + 1]).join("\n") +
-                (validation === undefined ? "" : `\nvalidation: ${validation}`)));
-            if (contracts.some((contract) => contract === null))
-                return null;
-            const criteria = contracts.flatMap((contract) => contract.criteria);
-            return new Set(criteria.map((criterion) => criterion.criterion_id)).size === criteria.length
-                ? { criteria } : null;
+        if (criterionStarts.length === 0) {
+            return { defects: [contractDefect("contract", "/goal_acceptance/criteria", "goal_criteria_missing")] };
         }
-        const entries = handoffEntries(prompt);
+        const validation = handoffValue(handoffEntries(prompt), ["validation"]);
         const required = ["goal_criterion_id", "goal_target", "goal_entrypoint", "goal_workload",
             "goal_oracle_coverage", "goal_build_boundary", "goal_source", "goal_candidate", "goal_fixture",
             "goal_proof_scope", "goal_expected_outcome"];
-        const values = Object.fromEntries(required.map((key) => [key, handoffValue(entries, [key])]));
-        if (required.some((key) => key !== "goal_oracle_coverage" && values[key] === undefined))
-            return null;
-        let oracleCoverage;
-        try {
-            const parsed = values.goal_oracle_coverage === undefined
-                ? taskAcceptanceCriteria(prompt, "goal_oracle_coverage") : JSON.parse(values.goal_oracle_coverage);
-            if (!Array.isArray(parsed) || !parsed.every((value) => typeof value === "string" && value.length > 0))
-                return null;
-            oracleCoverage = parsed;
+        const criteria = [];
+        const defects = [];
+        for (const [criterionIndex, start] of criterionStarts.entries()) {
+            const block = lines.slice(start, criterionStarts[criterionIndex + 1]).join("\n") +
+                (validation === undefined ? "" : `\nvalidation: ${validation}`);
+            const entries = handoffEntries(block);
+            const values = Object.fromEntries(required.map((key) => [key, handoffValue(entries, [key])]));
+            const pointer = (field) => `/goal_acceptance/criteria/${criterionIndex}/${field}`;
+            for (const key of required) {
+                if (key !== "goal_oracle_coverage" && values[key] === undefined) {
+                    defects.push(contractDefect("contract", pointer(key), "goal_field_missing"));
+                }
+            }
+            const inlineOracle = values.goal_oracle_coverage;
+            let oracleCoverage;
+            try {
+                const parsed = inlineOracle === undefined
+                    ? taskAcceptanceCriteria(block, "goal_oracle_coverage")
+                    : JSON.parse(inlineOracle);
+                if (Array.isArray(parsed) && parsed.length > 0 && parsed.every((value) => typeof value === "string" && value.length > 0 && value.length <= 512) &&
+                    new Set(parsed).size === parsed.length)
+                    oracleCoverage = parsed;
+            }
+            catch { /* concrete defect below */ }
+            if (oracleCoverage === undefined) {
+                defects.push(contractDefect("contract", pointer("goal_oracle_coverage"), inlineOracle === undefined ? "goal_field_missing_or_malformed" : "goal_oracle_coverage_invalid"));
+            }
+            const buildBoundary = values.goal_build_boundary;
+            const proofScope = values.goal_proof_scope;
+            const expectedOutcome = values.goal_expected_outcome;
+            const sourceBinding = handoffValue(entries, ["goal_source_binding"]);
+            const candidateBinding = handoffValue(entries, ["goal_candidate_binding"]);
+            if (buildBoundary !== undefined && buildBoundary !== "included" && buildBoundary !== "excluded" && buildBoundary !== "not-applicable") {
+                defects.push(contractDefect("contract", pointer("goal_build_boundary"), "goal_build_boundary_invalid"));
+            }
+            if (proofScope !== undefined && proofScope !== "requested-full" && proofScope !== "document-deliverable" && proofScope !== "expected-negative") {
+                defects.push(contractDefect("contract", pointer("goal_proof_scope"), "goal_proof_scope_invalid"));
+            }
+            if (expectedOutcome !== undefined && expectedOutcome !== "pass" && expectedOutcome !== "fail") {
+                defects.push(contractDefect("contract", pointer("goal_expected_outcome"), "goal_expected_outcome_invalid"));
+            }
+            if (sourceBinding !== undefined && sourceBinding !== "declared" && sourceBinding !== "current-protected") {
+                defects.push(contractDefect("contract", pointer("goal_source_binding"), "goal_source_binding_invalid"));
+            }
+            if (candidateBinding !== undefined && candidateBinding !== "declared" && candidateBinding !== "current-protected") {
+                defects.push(contractDefect("contract", pointer("goal_candidate_binding"), "goal_candidate_binding_invalid"));
+            }
+            const declaredValidation = handoffValue(entries, ["validation"]);
+            const structuredCommands = declaredValidation?.startsWith("{") && declaredValidation.endsWith("}")
+                ? [...declaredValidation.matchAll(/(?:\{|,)\s*command\s*:\s*([^,}]+)/gu)] : [];
+            const validationCommand = handoffValue(entries, ["goal_validation_command"]) ??
+                (structuredCommands.length === 1 ? unquoteValue(structuredCommands[0][1].trim()) : undefined);
+            if (validationCommand === undefined || normalizeCommand(validationCommand).length === 0) {
+                defects.push(contractDefect("contract", pointer("goal_validation_command"), "goal_validation_command_missing"));
+            }
+            if (defects.some((defect) => defect.includes(`/criteria/${criterionIndex}/`)))
+                continue;
+            criteria.push({ criterion_id: values.goal_criterion_id, target: values.goal_target,
+                entrypoint: values.goal_entrypoint, workload: values.goal_workload, oracle_coverage: oracleCoverage,
+                build_boundary: buildBoundary,
+                source: values.goal_source, candidate: values.goal_candidate,
+                source_binding: (sourceBinding ?? "declared"),
+                candidate_binding: (candidateBinding ?? "declared"),
+                validation_command: normalizeCommand(validationCommand), fixture: values.goal_fixture,
+                proof_scope: proofScope,
+                expected_outcome: expectedOutcome });
+        }
+        const duplicateIDs = criteria.map(({ criterion_id }) => criterion_id)
+            .filter((id, index, all) => all.indexOf(id) !== index);
+        if (duplicateIDs.length > 0) {
+            defects.push(contractDefect("contract", "/goal_acceptance/criteria", "goal_criterion_id_duplicate"));
+        }
+        return defects.length === 0 ? { contract: { criteria }, defects } : { defects };
+    }
+    function validateGoalDeclaration(prompt) {
+        const entries = handoffEntries(prompt);
+        const defects = [];
+        const fingerprint = handoffValue(entries, ["goal_acceptance_fingerprint"]);
+        if (fingerprint === undefined)
+            defects.push(contractDefect("contract", "/goal_acceptance_fingerprint", "goal_fingerprint_missing"));
+        else if (!/^sha256:[a-f0-9]{64}$/u.test(fingerprint)) {
+            defects.push(contractDefect("contract", "/goal_acceptance_fingerprint", "goal_fingerprint_format"));
         }
-        catch {
-            return null;
-        }
-        const buildBoundary = values.goal_build_boundary;
-        const proofScope = values.goal_proof_scope;
-        const expectedOutcome = values.goal_expected_outcome;
-        const sourceBinding = handoffValue(entries, ["goal_source_binding"]);
-        const candidateBinding = handoffValue(entries, ["goal_candidate_binding"]);
-        const declaredValidation = handoffValue(entries, ["validation"]);
-        const structuredCommands = declaredValidation?.startsWith("{") && declaredValidation.endsWith("}")
-            ? [...declaredValidation.matchAll(/(?:\{|,)\s*command\s*:\s*([^,}]+)/gu)] : [];
-        const validationCommand = handoffValue(entries, ["goal_validation_command"]) ??
-            (structuredCommands.length === 1 ? unquoteValue(structuredCommands[0][1].trim()) : undefined);
-        if (buildBoundary !== "included" && buildBoundary !== "excluded" && buildBoundary !== "not-applicable")
-            return null;
-        if (proofScope !== "requested-full" && proofScope !== "document-deliverable" && proofScope !== "expected-negative")
-            return null;
-        if (expectedOutcome !== "pass" && expectedOutcome !== "fail")
-            return null;
-        if (sourceBinding !== undefined && sourceBinding !== "declared" && sourceBinding !== "current-protected")
-            return null;
-        if (candidateBinding !== undefined && candidateBinding !== "declared" && candidateBinding !== "current-protected")
-            return null;
-        return { criteria: [{ criterion_id: values.goal_criterion_id, target: values.goal_target,
-                    entrypoint: values.goal_entrypoint, workload: values.goal_workload, oracle_coverage: oracleCoverage,
-                    build_boundary: buildBoundary, source: values.goal_source, candidate: values.goal_candidate,
-                    source_binding: sourceBinding ?? "declared", candidate_binding: candidateBinding ?? "declared",
-                    ...(validationCommand === undefined ? {} : { validation_command: normalizeCommand(validationCommand) }),
-                    fixture: values.goal_fixture, proof_scope: proofScope, expected_outcome: expectedOutcome }] };
-    }
-    async function bindGoalDeclaration(sessionID, prompt, acceptance) {
+        const intent = handoffValue(entries, ["delivery_intent"]);
+        const intents = ["design", "registration", "implementation", "repair", "controlled-change"];
+        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"];
+        if (mode !== undefined && !modes.includes(mode)) {
+            defects.push(contractDefect("contract", "/delivery_mode", "delivery_mode_invalid"));
+        }
+        const usable = handoffValue(entries, ["usable_path_established"]);
+        const controlled = handoffValue(entries, ["controlled_change"]);
+        for (const [field, value] of [["usable_path_established", usable], ["controlled_change", controlled]]) {
+            if (value === undefined)
+                defects.push(contractDefect("contract", `/${field}`, "goal_boolean_missing"));
+            else if (value !== "true" && value !== "false")
+                defects.push(contractDefect("contract", `/${field}`, "goal_boolean_invalid"));
+        }
+        const contract = goalDeclarationContract(prompt);
+        defects.push(...contract.defects);
+        if (defects.length > 0 || fingerprint === undefined || intent === undefined || contract.contract === undefined)
+            return { defects };
+        const delivery = mode ?? selectGoalDelivery({
+            declared_intent: intent, requested_usable_path_established: usable === "true",
+            irreversible_or_major_scope: controlled === "true",
+        });
+        return { declaration: { fingerprint, delivery, contract: contract.contract }, defects };
+    }
+    async function bindGoalDeclaration(sessionID, prompt) {
         const ledger = await goalLedger(sessionID);
         let state = (await ledger.readGoal()).state;
         if (state.goal_id === null || state.origin_user_message_id === null)
             return undefined;
-        const authority = goalDeclarationAuthority.get(sessionID);
-        if (authority === undefined || authority !== state.latest_user_message_id)
-            return state;
-        goalDeclarationAuthority.delete(sessionID);
         const entries = handoffEntries(prompt);
-        const explicitFingerprint = handoffValue(entries, ["goal_acceptance_fingerprint"]);
-        if (state.acceptance_contract !== null && explicitFingerprint === undefined)
+        const typedDeclarationPresent = prompt.split(/\r?\n/u).some((line) => /^\s*(?:goal_[a-z0-9_]+|delivery_intent|delivery_mode|usable_path_established|controlled_change)\s*:/iu.test(line));
+        // Accepted goals may retain their existing declaration on later units, but the first worker
+        // handoff and every handoff containing declaration fields must be complete.
+        if (!typedDeclarationPresent) {
+            if (state.acceptance_contract === null && goalDeclarationAuthority.get(sessionID) === state.latest_user_message_id) {
+                throw new HandoffDeniedError("contract-invalid", "<goal-declaration>", {
+                    defects: validateGoalDeclaration(prompt).defects,
+                });
+            }
+            if (goalDeclarationAuthority.get(sessionID) === state.latest_user_message_id)
+                goalDeclarationAuthority.delete(sessionID);
             return state;
-        const declaredFingerprint = explicitFingerprint ?? acceptance?.fingerprint;
-        if (declaredFingerprint === undefined || !/^sha256:[a-f0-9]{64}$/u.test(declaredFingerprint) ||
-            declaredFingerprint === state.acceptance_fingerprint)
+        }
+        const validated = validateGoalDeclaration(prompt);
+        if (validated.declaration === undefined) {
+            throw new HandoffDeniedError("contract-invalid", "<goal-declaration>", { defects: validated.defects });
+        }
+        const declaration = validated.declaration;
+        const authority = goalDeclarationAuthority.get(sessionID);
+        if (authority === undefined || authority !== state.latest_user_message_id) {
+            if (declaration.fingerprint !== state.acceptance_fingerprint) {
+                throw new HandoffDeniedError("contract-invalid", "<goal-declaration>", { defects: [
+                        contractDefect("contract", "/goal_acceptance_fingerprint", "goal_revision_unauthorized"),
+                    ] });
+            }
+            return state;
+        }
+        if (declaration.fingerprint === state.acceptance_fingerprint &&
+            goalFingerprint(declaration.contract) === goalFingerprint(state.acceptance_contract)) {
+            goalDeclarationAuthority.delete(sessionID);
             return state;
+        }
         const units = Number(handoffValue(entries, ["goal_budget_units"]));
         const maxUnits = Number.isSafeInteger(units) && units >= state.consumed_units && units > 0
             ? units : state.budget?.max_units ?? 32;
@@ -1631,21 +1750,25 @@ export const SortieDogsPlugin = async (input, options) => {
         const costBudget = Number.isFinite(declaredCost) && declaredCost > 0 ? declaredCost : state.budget?.cost_usd ?? null;
         state = await ledger.appendGoal({ kind: "goal.revised", at: new Date().toISOString(), goal_id: state.goal_id,
             revision: state.revision + 1, scope_epoch: state.scope_epoch + 1,
-            acceptance_fingerprint: declaredFingerprint, origin_user_message_id: state.latest_user_message_id,
+            acceptance_fingerprint: declaration.fingerprint, origin_user_message_id: state.latest_user_message_id,
             session_id: sessionID, selected_agent: state.selected_agent ?? COORDINATOR_AGENT,
-            delivery: declaredDelivery(prompt), budget: { max_units: maxUnits,
+            delivery: declaration.delivery, budget: { max_units: maxUnits,
                 time_ms: timeBudget, cost_usd: costBudget,
                 source: Number.isSafeInteger(units) ? "accepted-plan" : state.budget?.source ?? "policy-default" },
-            acceptance_contract: declaredGoalContract(prompt) });
+            acceptance_contract: declaration.contract });
+        goalDeclarationAuthority.delete(sessionID);
         return state;
     }
-    async function reserveGoalDispatch(sessionID, callID, prompt, acceptance) {
+    async function reserveGoalDispatch(sessionID, callID, prompt) {
         if (goalReservations.has(callID))
             return;
         const ledger = await goalLedger(sessionID);
-        let state = await bindGoalDeclaration(sessionID, prompt, acceptance) ?? (await ledger.readGoal()).state;
+        let state = await bindGoalDeclaration(sessionID, prompt) ?? (await ledger.readGoal()).state;
         if (state.goal_id === null)
             return; // Legacy already-authorized roots may settle without inventing authority.
+        if (state.phase === "terminal" || state.receipt !== null) {
+            throw new Error("SORTIE_GOAL_CONTROL_DENIED: terminal");
+        }
         if (state.replan_required) {
             if (state.replan_used) {
                 await terminalGoal(sessionID, "stop_no_progress", "stopped");
@@ -1735,10 +1858,18 @@ export const SortieDogsPlugin = async (input, options) => {
             entry.execution.units.includes(reservation.unitID));
         const newEvidence = acceptedEvidence.filter((entry) => entry.measurement.criterion_ids.some((criterionID) => !state.satisfied_criteria.includes(criterionID)));
         const progress = newEvidence.length > 0;
+        const metadata = isRecord(output.metadata) ? output.metadata : undefined;
+        const interrupted = metadata?.status === "cancel" || metadata?.status === "cancelled" ||
+            output.status === "cancel" || output.status === "cancelled";
+        const hostBindingDefect = childSessionID !== undefined && [...(bindingDenials.get(reservation.root)?.values() ?? [])]
+            .some((candidateDenials) => [...candidateDenials.values()].includes(childSessionID));
+        const processDefect = childSessionID === undefined || hostBindingDefect;
+        const resultClass = progress ? "acceptance" : interrupted ? "interrupted" : processDefect ? "process-defect" : "acceptance";
         await ledger.appendGoal({ kind: "unit.settled", at: new Date().toISOString(),
             reservation_id: reservation.reservationID, receipt_id: goalFingerprint({ call_id: callID, output: outputText.slice(0, 2048) }),
             goal_id: state.goal_id, unit_id: reservation.unitID,
-            disposition: progress ? "succeeded" : "failed", progress_fingerprint: progress ? goalFingerprint(acceptedEvidence) : null,
+            disposition: progress ? "succeeded" : interrupted ? "cancelled" : "failed", result_class: resultClass,
+            progress_fingerprint: progress ? goalFingerprint(acceptedEvidence) : null,
             evidence: acceptedEvidence, elapsed_ms: Math.max(0, Date.now() - reservation.started), cost_usd: null });
         if (childSessionID !== undefined) {
             for (const [executionCallID, execution] of hostGoalExecutions) {
@@ -3070,6 +3201,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 });
@@ -5158,9 +5292,20 @@ 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 = textOutput.text.replace(/(^|\n)status:\s*DONE\b/iu, "$1status: IN_PROGRESS\ngoal_control: accepted criteria remain unproved");
+            if (runOutcome === "DONE" && terminal !== undefined && (terminal.delivery === "running" ||
+                (terminal.receipt === undefined && terminal.goal !== undefined && terminal.goal.acceptance_contract !== 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?.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);
             }
             if ((isCoordinatorSession(textInput.sessionID) || await recoverCoordinatorRoot(textInput.sessionID)) &&
                 runOutcome !== undefined) {
@@ -6004,6 +6149,12 @@ export const SortieDogsPlugin = async (input, options) => {
                     fastLane.enableParallelDispatch(toolInput.sessionID, boundSnapshot.max_workers, counts.dispatched - currentContribution, counts.running - currentContribution, counts.total);
                     parallelWorkerAuthorized = true;
                 }
+                if (toolInput.tool === "task" && taskRole !== undefined && IMPLEMENTATION_AGENTS.has(taskRole) &&
+                    isRecord(output.args)) {
+                    // Declaration admission precedes routing state and reservation. A concrete field denial can
+                    // therefore be repaired by a corrected Task call in this same coordinator turn.
+                    await bindGoalDeclaration(toolInput.sessionID, typeof output.args.prompt === "string" ? output.args.prompt : "");
+                }
                 const resumedWorkerSessionID = fastLane.beforeTool(toolInput.sessionID, toolInput.tool, output.args, {
                     readonlyDiagnosisAuthorized: readonlyDiagnosis,
                     consultationFallbackAuthorized,
@@ -6012,7 +6163,7 @@ export const SortieDogsPlugin = async (input, options) => {
                 });
                 if (toolInput.tool === "task" && taskRole !== undefined && IMPLEMENTATION_AGENTS.has(taskRole) &&
                     isRecord(output.args)) {
-                    await reserveGoalDispatch(toolInput.sessionID, toolInput.callID, typeof output.args.prompt === "string" ? output.args.prompt : "", validatedRootAcceptance);
+                    await reserveGoalDispatch(toolInput.sessionID, toolInput.callID, typeof output.args.prompt === "string" ? output.args.prompt : "");
                 }
                 if (validatedRootAcceptance !== undefined && reservedParallelDescriptor === undefined) {
                     rootAcceptanceContinuity.delete(toolInput.sessionID);

package/dist/plugin/run-metrics.d.ts

@@ -73,7 +73,7 @@ export interface SortieResult {
     readonly accounting_phase: "pre-terminal";
     readonly as_of: string;
     readonly mission: {
-        readonly status: "COMPLETED" | "FAILED" | "STOPPED";
+        readonly status: "COMPLETED" | "INTERRUPTED" | "EXTERNAL_BLOCKER" | "USER_DECISION";
         readonly stop_reason: GoalTerminalReceipt["stop_reason"];
     };
     readonly speed: {
@@ -103,12 +103,15 @@ export interface SortieResult {
 type SortieGoalSnapshot = Pick<GoalFlightState, "acceptance_contract" | "consumed_time_ms" | "satisfied_criteria">;
 /** Builds a pure terminal snapshot from the durable goal receipt and already-observed host metrics. */
 export declare function createSortieResult(receipt: GoalTerminalReceipt, goal: SortieGoalSnapshot, metrics: RunMetrics | undefined, asOf?: string): SortieResult;
-export type RunTerminalOutcome = "DONE" | "BLOCKED" | "NEED_DECISION";
+export type RunTerminalOutcome = "DONE" | "INTERRUPTED" | "BLOCKED" | "NEED_DECISION";
 export declare function collectRunMetrics(client: RunMetricsClient | undefined, rootSessionID: string, directory?: string, now?: number, window?: RunMetricsWindow): Promise<RunMetrics | undefined>;
 export declare function formatSortieResult(result: SortieResult): string;
 export declare function formatRunMetrics(metrics: RunMetrics): string;
 export declare function isDoneTerminalText(text: string): boolean;
 export declare function terminalRunOutcome(text: string): RunTerminalOutcome | undefined;
+export declare function replaceTerminalStatus(text: string, replacement: string): string;
+export declare function replaceDoneTerminalStatus(text: string, replacement: string): string;
+export declare function sanitizeTerminalReport(text: string): string;
 export declare function insertRunMetrics(text: string, metrics: RunMetrics): string;
 export declare function insertSortieResult(text: string, result: SortieResult): string;
 export {};