sortie-dogs 0.9.0 → 0.9.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.9.0](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.0)
+Release: [v0.9.1](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.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.75-sequential-acceptance-parent-v1";
+export declare const RUNTIME_ASSET_VERSION = "0.3.76-goal-control-report-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.76-goal-control-report-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/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;
@@ -1520,9 +1522,20 @@ export const SortieDogsPlugin = async (input, options) => {
         }
         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 (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"
@@ -1535,93 +1548,167 @@ export const SortieDogsPlugin = async (input, options) => {
             rootAcceptanceContinuity.delete(sessionID);
         return { outcome, goal, receipt };
     }
-    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 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;
-        const declaredFingerprint = explicitFingerprint ?? acceptance?.fingerprint;
-        if (declaredFingerprint === undefined || !/^sha256:[a-f0-9]{64}$/u.test(declaredFingerprint) ||
-            declaredFingerprint === state.acceptance_fingerprint)
+        }
+        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 +1718,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 +1826,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) {
@@ -5160,7 +5259,13 @@ export const SortieDogsPlugin = async (input, options) => {
                 : 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");
+                textOutput.text = replaceDoneTerminalStatus(textOutput.text, "status: IN_PROGRESS\ngoal_control: accepted criteria remain unproved");
+            }
+            if (runOutcome !== "DONE" && terminal?.receipt?.status === "succeeded") {
+                textOutput.text = replaceTerminalStatus(textOutput.text, "status: DONE");
+            }
+            if (runOutcome !== undefined && isCoordinatorSession(textInput.sessionID)) {
+                textOutput.text = sanitizeTerminalReport(textOutput.text);
             }
             if ((isCoordinatorSession(textInput.sessionID) || await recoverCoordinatorRoot(textInput.sessionID)) &&
                 runOutcome !== undefined) {
@@ -6004,6 +6109,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 +6123,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 {};

package/dist/plugin/run-metrics.js

@@ -18,14 +18,20 @@ export function createSortieResult(receipt, goal, metrics, asOf = receipt.ended_
     const hostMetric = (value) => value === undefined
         ? unavailable(metrics === undefined ? "host-metrics-unavailable" : "incomplete-host-coverage")
         : available(value, "host-reported");
-    const failed = receipt.stop_reason === "external_dependency" || receipt.stop_reason === "persistence_unavailable";
+    const missionStatus = receipt.status === "succeeded"
+        ? "COMPLETED"
+        : receipt.stop_reason === "awaiting_user"
+            ? "USER_DECISION"
+            : receipt.stop_reason === "external_dependency" || receipt.stop_reason === "persistence_unavailable"
+                ? "EXTERNAL_BLOCKER"
+                : "INTERRUPTED";
     return {
         schema_version: "0.1",
         result_id: [receipt.goal_id, receipt.terminal_revision],
         accounting_phase: "pre-terminal",
         as_of: asOf,
         mission: {
-            status: receipt.status === "succeeded" ? "COMPLETED" : failed ? "FAILED" : "STOPPED",
+            status: missionStatus,
             stop_reason: receipt.stop_reason,
         },
         speed: {
@@ -105,11 +111,11 @@ function assistantMessages(value) {
     });
 }
 function conclusionStatusAlias(line) {
-    const match = /^([✅⛔❓])[ \t]+conclusion:\s*status:\s*(DONE|BLOCKED|NEED_DECISION)\b/iu.exec(line);
+    const match = /^(✅|⚠️|⛔|❓)[ \t]+conclusion:\s*status:\s*(DONE|INTERRUPTED|BLOCKED|NEED_DECISION)\b/iu.exec(line);
     const outcome = match?.[2]?.toUpperCase();
-    if (outcome !== "DONE" && outcome !== "BLOCKED" && outcome !== "NEED_DECISION")
+    if (outcome !== "DONE" && outcome !== "INTERRUPTED" && outcome !== "BLOCKED" && outcome !== "NEED_DECISION")
         return undefined;
-    const expectedIcon = outcome === "DONE" ? "✅" : outcome === "BLOCKED" ? "⛔" : "❓";
+    const expectedIcon = outcome === "DONE" ? "✅" : outcome === "INTERRUPTED" ? "⚠️" : outcome === "BLOCKED" ? "⛔" : "❓";
     return match?.[1] === expectedIcon ? outcome : undefined;
 }
 export async function collectRunMetrics(client, rootSessionID, directory, now = Date.now(), window) {
@@ -287,18 +293,22 @@ function duration(milliseconds) {
     return `${minutes}m ${String(seconds % 60).padStart(2, "0")}s`;
 }
 function metricText(metric, render) {
-    return metric.availability === "available" ? render(metric.value) : `unavailable (${metric.reason})`;
+    return metric.availability === "available" ? render(metric.value) : "計測不可";
 }
 export function formatSortieResult(result) {
     const criteria = metricText(result.proof.criteria, (entries) => {
         const passing = entries.filter(({ status }) => status === "PASS").length;
-        return `${passing}/${entries.length} criteria`;
+        return `${passing}/${entries.length}`;
     });
+    const achievement = result.mission.status === "COMPLETED" ? "完了"
+        : result.mission.status === "INTERRUPTED" ? "中断（未完了）"
+            : result.mission.status === "EXTERNAL_BLOCKER" ? "外部要因で未完了"
+                : "ユーザー判断待ち（未完了）";
     return [
         "**Sortie Result**",
-        `**Speed:** goal ${metricText(result.speed.goal_wall_ms, duration)} · worker ${metricText(result.speed.worker_execution_ms, duration)} · compression ${metricText(result.speed.execution_compression, (value) => `${value.toFixed(2)}x`)}`,
-        `**Cost:** ${metricText(result.cost.total_tokens, (value) => `${value.toLocaleString("en-US")} tokens`)} · ${metricText(result.cost.cost_usd, (value) => `$${value.toFixed(4)}`)} · ${result.accounting_phase}`,
-        `**Proof:** ${result.proof.overall} · ${result.mission.status.toLowerCase()} (${result.mission.stop_reason}) · ${criteria} · ${result.proof.evidence_refs.length} evidence ref${result.proof.evidence_refs.length === 1 ? "" : "s"}`,
+        `**Speed:** 全体 ${metricText(result.speed.goal_wall_ms, duration)} · worker ${metricText(result.speed.worker_execution_ms, duration)}`,
+        `**Cost:** ${metricText(result.cost.total_tokens, (value) => `${value.toLocaleString("ja-JP")}トークン`)} · ${metricText(result.cost.cost_usd, (value) => `$${value.toFixed(4)}`)}`,
+        `**達成:** ${achievement} · acceptance ${criteria}`,
     ].join("\n");
 }
 export function formatRunMetrics(metrics) {
@@ -337,15 +347,16 @@ function terminalCheckpoint(text) {
         return undefined;
     const checkpoint = (() => {
         const { index, line } = first;
-        const normalized = /^status:\s*(DONE|BLOCKED|NEED_DECISION)\b/iu.exec(line)?.[1]?.toUpperCase();
-        const explicit = normalized === "DONE" || normalized === "BLOCKED" || normalized === "NEED_DECISION"
+        const normalized = /^status:\s*(DONE|INTERRUPTED|BLOCKED|NEED_DECISION)\b/iu.exec(line)?.[1]?.toUpperCase();
+        const explicit = normalized === "DONE" || normalized === "INTERRUPTED" || normalized === "BLOCKED" || normalized === "NEED_DECISION"
             ? normalized
             : undefined;
         const outcome = explicit ?? conclusionStatusAlias(line) ??
             (/^✅[ \t]+\*\*DONE\*\*/u.test(line) ? "DONE" :
-                /^⛔[ \t]+\*\*BLOCKED\*\*/u.test(line) ? "BLOCKED" :
-                    /^❓[ \t]+\*\*NEED_DECISION\*\*/u.test(line) ? "NEED_DECISION" : undefined);
-        return outcome === "DONE" || outcome === "BLOCKED" || outcome === "NEED_DECISION"
+                /^⚠️[ \t]+\*\*INTERRUPTED\*\*/u.test(line) ? "INTERRUPTED" :
+                    /^⛔[ \t]+\*\*BLOCKED\*\*/u.test(line) ? "BLOCKED" :
+                        /^❓[ \t]+\*\*NEED_DECISION\*\*/u.test(line) ? "NEED_DECISION" : undefined);
+        return outcome === "DONE" || outcome === "INTERRUPTED" || outcome === "BLOCKED" || outcome === "NEED_DECISION"
             ? { index, outcome }
             : undefined;
     })();
@@ -365,25 +376,49 @@ export function terminalRunOutcome(text) {
         ? "BLOCKED"
         : undefined;
 }
-export function insertRunMetrics(text, metrics) {
+export function replaceTerminalStatus(text, replacement) {
     const checkpoint = terminalCheckpoint(text);
-    if (checkpoint?.outcome !== "DONE")
-        return text;
-    if (topLevelLines(text).some(({ index, line }) => index > checkpoint.index && /^\*\*Run:\*\*/u.test(line)))
+    if (checkpoint === undefined)
         return text;
     const newline = text.includes("\r\n") ? "\r\n" : "\n";
     const lines = text.split(/\r?\n/u);
+    lines.splice(checkpoint.index, 1, ...replacement.split(/\r?\n/u));
+    return lines.join(newline);
+}
+export function replaceDoneTerminalStatus(text, replacement) {
+    return terminalCheckpoint(text)?.outcome === "DONE" ? replaceTerminalStatus(text, replacement) : text;
+}
+export function sanitizeTerminalReport(text) {
+    const newline = text.includes("\r\n") ? "\r\n" : "\n";
+    const internal = /\b(?:evidence_refs?|manifest|raw|raw_status|reason_code|goal_control|TRUE_BLOCKER)\s*:|\bEvidence\b/iu;
+    return text.replace(/^[ \t]*(`{3,}|~{3,})[^\r\n]*\r?\n([\s\S]*?)^[ \t]*\1[ \t]*$/gimu, (block, _fence, body) => internal.test(body) ? "" : block)
+        .replace(/<details\b[^>]*>[\s\S]*?<\/details>/giu, "")
+        .split(/\r?\n/u)
+        .filter((line) => !/^\s*(?:(?:#{1,6}\s*)?\**Evidence\**\s*:|(?:TRUE_BLOCKER|goal_control|evidence_refs?|reason_code|raw|raw_status|manifest)\s*:)/iu.test(line))
+        .join(newline)
+        .trimEnd();
+}
+export function insertRunMetrics(text, metrics) {
+    const visible = sanitizeTerminalReport(text);
+    const checkpoint = terminalCheckpoint(visible);
+    if (checkpoint?.outcome !== "DONE")
+        return visible;
+    if (topLevelLines(visible).some(({ index, line }) => index > checkpoint.index && /^\*\*Run:\*\*/u.test(line)))
+        return visible;
+    const newline = visible.includes("\r\n") ? "\r\n" : "\n";
+    const lines = visible.split(/\r?\n/u);
     lines.splice(checkpoint.index + 1, 0, "", formatRunMetrics(metrics));
     return lines.join(newline);
 }
 export function insertSortieResult(text, result) {
-    const checkpoint = terminalCheckpoint(text);
+    const visible = sanitizeTerminalReport(text);
+    const checkpoint = terminalCheckpoint(visible);
     if (checkpoint === undefined)
-        return text;
-    if (topLevelLines(text).some(({ index, line }) => index > checkpoint.index && /^\*\*Sortie Result\*\*/u.test(line)))
-        return text;
-    const newline = text.includes("\r\n") ? "\r\n" : "\n";
-    const lines = text.split(/\r?\n/u);
+        return visible;
+    if (topLevelLines(visible).some(({ index, line }) => index > checkpoint.index && /^\*\*Sortie Result\*\*/u.test(line)))
+        return visible;
+    const newline = visible.includes("\r\n") ? "\r\n" : "\n";
+    const lines = visible.split(/\r?\n/u);
     lines.splice(checkpoint.index + 1, 0, "", formatSortieResult(result));
     return lines.join(newline);
 }