sortie-dogs 0.9.3 → 0.9.5

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.3](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.3)
+Release: [v0.9.5](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.5)
 
 ## 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.80-review-evidence-v1";
+export declare const RUNTIME_ASSET_VERSION = "0.3.81-mission-debrief-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.80-review-evidence-v1";
+export const RUNTIME_ASSET_VERSION = "0.3.81-mission-debrief-v1";

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

@@ -1,4 +1,5 @@
 import type { ValidationOutcome } from "./validation-budget.js";
+import type { GoalReport } from "./goal-report.js";
 export declare const GOAL_BOUND_SCHEMA_VERSION: "0.1";
 export declare const GOAL_BOUND_METADATA_KEY: "sortie-dogs.goal-bound/v1";
 export type GoalDeliveryMode = "planning-only" | "mvp-first" | "repair-first" | "controlled-change";
@@ -177,6 +178,10 @@ export type GoalFlightEvent = (GoalEventBase & {
     readonly kind: "goal.terminal";
     readonly goal_id: string;
     readonly receipt: GoalTerminalReceipt;
+}) | (GoalEventBase & {
+    readonly kind: "goal.reported";
+    readonly goal_id: string;
+    readonly report: GoalReport;
 });
 export interface GoalFlightEventRecord {
     readonly sequence: number;

package/dist/core/goal-bound.js

@@ -111,6 +111,10 @@ export function reduceGoalFlight(records) {
         requireState(record.sequence === index + 1 && record.previous_hash === previous && HASH.test(record.event_hash), "invalid", "Goal ledger chain is malformed.");
         previous = record.event_hash;
         const event = record.event;
+        // Optional presentation records never participate in execution replay. Writers validate them;
+        // older/newer telemetry definitions must not prevent an existing goal from resuming.
+        if (event.kind === "goal.reported")
+            continue;
         requireState(instant(event.at), "invalid", "Goal event timestamp is invalid.");
         if (event.kind === "goal.accepted") {
             requireState(state.goal_id === null || state.phase === "terminal", "transition", "An active goal already owns this root.");
@@ -134,13 +138,16 @@ export function reduceGoalFlight(records) {
         else if (event.kind === "goal.revised") {
             requireState(state.phase !== "terminal" && event.revision === state.revision + 1 && event.scope_epoch === state.scope_epoch + 1 &&
                 HASH.test(event.acceptance_fingerprint) && event.budget.max_units >= state.consumed_units &&
+                event.budget.max_units >= state.validation_budget.consumed &&
                 validAcceptanceContract(event.acceptance_contract), "transition", "Scope revision is stale or resets consumed budget.");
             state = { ...state, revision: event.revision, scope_epoch: event.scope_epoch,
                 acceptance_fingerprint: event.acceptance_fingerprint, latest_user_message_id: event.origin_user_message_id,
                 selected_agent: event.selected_agent, delivery: event.delivery, budget: event.budget,
+                validation_budget: { ...state.validation_budget,
+                    limit: state.validation_budget.limit === null ? null : event.budget.max_units },
                 acceptance_contract: event.acceptance_contract,
                 session_ids: addUnique(state.session_ids, event.session_id), phase: "active", stop_reason: null,
-                tickets: [] };
+                receipt: null, tickets: [] };
         }
         else if (event.kind === "ticket.issued") {
             requireState(state.phase === "active" && event.revision === state.revision && event.scope_epoch === state.scope_epoch &&

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

@@ -0,0 +1,18 @@
+/** Optional, bounded telemetry retained with the existing terminal goal ledger, never an authority input. */
+export interface GoalReport {
+    readonly definition: "pre-terminal-host-tokens/v1";
+    readonly terminal_key: string;
+    readonly tokens: number | null;
+    readonly models: readonly {
+        readonly model: string;
+        readonly tokens: number;
+    }[] | null;
+    readonly first_pass_eligible: boolean;
+    readonly traits: readonly ("pack-tactics" | "recovery" | "clean-sweep")[];
+    readonly overlap?: {
+        readonly definition: "worker-span-union/v1";
+        readonly worker_ms: number;
+        readonly wall_ms: number;
+    };
+}
+export declare function validGoalReport(value: unknown): value is GoalReport;

package/dist/core/goal-report.js

@@ -0,0 +1,21 @@
+export function validGoalReport(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const item = value;
+    const amount = (n) => typeof n === "number" && Number.isSafeInteger(n) && n >= 0;
+    const duration = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0;
+    const overlap = item.overlap;
+    return Object.keys(item).every((key) => ["definition", "terminal_key", "tokens", "models", "first_pass_eligible", "traits", "overlap"].includes(key)) &&
+        item.definition === "pre-terminal-host-tokens/v1" && /^sha256:[a-f0-9]{64}$/u.test(item.terminal_key) &&
+        (item.tokens === null || amount(item.tokens)) && typeof item.first_pass_eligible === "boolean" &&
+        Array.isArray(item.traits) && item.traits.length <= 3 && new Set(item.traits).size === item.traits.length &&
+        item.traits.every((trait) => ["pack-tactics", "recovery", "clean-sweep"].includes(trait)) &&
+        (overlap === undefined || overlap !== null && typeof overlap === "object" &&
+            Object.keys(overlap).every((key) => ["definition", "worker_ms", "wall_ms"].includes(key)) && overlap.definition === "worker-span-union/v1" &&
+            duration(overlap.worker_ms) && duration(overlap.wall_ms) && overlap.worker_ms >= overlap.wall_ms) &&
+        (item.models === null || Array.isArray(item.models) && item.models.length <= 128 &&
+            new Set(item.models.map((entry) => entry?.model)).size === item.models.length &&
+            item.models.every((entry) => entry !== null && typeof entry === "object" && Object.keys(entry).every((key) => key === "model" || key === "tokens") &&
+                typeof entry.model === "string" && entry.model.length > 0 && entry.model.length <= 512 && amount(entry.tokens)) &&
+            item.tokens !== null && item.models.reduce((sum, entry) => sum + entry.tokens, 0) === item.tokens);
+}

package/dist/core/run-flight-ledger.d.ts

@@ -366,6 +366,11 @@ export declare class RunFlightLedger {
     static open(filePath: string, evidence: RunFlightEvidenceAccess): Promise<RunFlightLedger>;
     /** Root goal checkpoints share this owner and lock/write discipline without inventing a Git run. */
     static openGoal(filePath: string): Promise<RunFlightLedger>;
+    /** Read-only Career inventory: validates one existing goal ledger without opening another store. */
+    static readGoalFile(filePath: string): Promise<{
+        readonly records: readonly GoalFlightEventRecord[];
+        readonly state: GoalFlightState;
+    }>;
     read(): Promise<{
         readonly records: readonly RunFlightEventRecord[];
         readonly state: RunFlightState;

package/dist/core/run-flight-ledger.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { LUNA_FABRIC_MAX_ACTIVE } from "./luna-fabric-scheduler.js";
 import { normalizeRelativePath } from "./path.js";
 import { CHILD_TERMINAL_EVIDENCE_FIELDS, isChildTerminalIdentity, reconcileChildTerminal, sameChildTerminalIdentity } from "./child-terminal-reconciliation.js";
-import { GOAL_BOUND_SCHEMA_VERSION, GoalBoundError, reduceGoalFlight } from "./goal-bound.js";
+import { GOAL_BOUND_SCHEMA_VERSION, GoalBoundError, reduceGoalFlight, goalFingerprint } from "./goal-bound.js";
 export const RUN_FLIGHT_LEDGER_SCHEMA_VERSION = "0.1";
 export const MAX_RUN_FLIGHT_EVENTS = 2048;
 export const MAX_RUN_FLIGHT_LEDGER_BYTES = 1024 * 1024;
@@ -657,6 +657,10 @@ export class RunFlightLedger {
         await ledger.readGoal();
         return ledger;
     }
+    /** Read-only Career inventory: validates one existing goal ledger without opening another store. */
+    static async readGoalFile(filePath) {
+        return new RunFlightLedger(filePath, undefined, true).readGoal();
+    }
     async read() {
         if (this.#goalMode)
             throw new RunFlightLedgerError("invalid", "Goal ledger requires readGoal().");
@@ -820,6 +824,18 @@ export class RunFlightLedger {
             throw new RunFlightLedgerError("conflict", "Ledger lock remained busy.");
         try {
             const records = await this.#readGoalRecords();
+            if (event.kind === "goal.reported" && records.some(({ event: stored }) => stored.kind === "goal.reported" &&
+                stored.goal_id === event.goal_id && stored.report?.terminal_key === event.report.terminal_key)) {
+                return reduceGoalFlight(records);
+            }
+            if (event.kind === "goal.reported") {
+                const { validGoalReport } = await import("./goal-report.js");
+                const state = reduceGoalFlight(records);
+                if (state.receipt === null || event.goal_id !== state.goal_id || !validGoalReport(event.report) ||
+                    event.report.terminal_key !== goalFingerprint(state.receipt)) {
+                    throw new RunFlightLedgerError("invalid", "Report is not bound to the current terminal receipt.");
+                }
+            }
             const sequence = records.length + 1;
             const previousHash = records.at(-1)?.event_hash ?? null;
             const record = { sequence, previous_hash: previousHash,

package/dist/plugin/fast-lane.d.ts

@@ -4,6 +4,15 @@ export declare class FastLaneDeniedError extends Error {
     readonly code: FastLaneDenialCode;
     constructor(code: FastLaneDenialCode);
 }
+export interface WorkerAccounting {
+    readonly totalWorkerDispatches: number;
+    readonly workerDispatches: number;
+    readonly workerInFlight: boolean;
+    readonly workerResumeUsed: boolean;
+    readonly workerResumeSessionID?: string;
+    readonly workerResumeTaskID?: string;
+    readonly workerTaskID?: string;
+}
 export interface FastLaneToolOptions {
     readonly readonlyDiagnosisAuthorized?: boolean;
     readonly consultationFallbackAuthorized?: boolean;
@@ -25,5 +34,8 @@ export declare class FastLaneController {
     continuationQueued(sessionID: string): void;
     authorizeRecoverableWorkerResume(sessionID: string, taskID: string, childSessionID: string): boolean;
     workerCompleted(sessionID: string): void;
+    /** Snapshot worker accounting so a later denial in the same dispatch cannot leak the slot. */
+    snapshotWorkerAccounting(sessionID: string): WorkerAccounting | undefined;
+    restoreWorkerAccounting(sessionID: string, snapshot: WorkerAccounting | undefined): void;
     beforeTool(sessionID: string, tool: string, args: unknown, options?: FastLaneToolOptions): string | undefined;
 }

package/dist/plugin/fast-lane.js

@@ -199,6 +199,32 @@ export class FastLaneController {
         if (state !== undefined)
             state.workerInFlight = false;
     }
+    /** Snapshot worker accounting so a later denial in the same dispatch cannot leak the slot. */
+    snapshotWorkerAccounting(sessionID) {
+        const state = this.sessions.get(sessionID);
+        if (state === undefined)
+            return undefined;
+        return { totalWorkerDispatches: state.totalWorkerDispatches, workerDispatches: state.workerDispatches,
+            workerInFlight: state.workerInFlight, workerResumeUsed: state.workerResumeUsed,
+            workerResumeSessionID: state.workerResumeSessionID, workerResumeTaskID: state.workerResumeTaskID,
+            workerTaskID: state.workerTaskID };
+    }
+    restoreWorkerAccounting(sessionID, snapshot) {
+        const state = this.sessions.get(sessionID);
+        if (state === undefined || snapshot === undefined)
+            return;
+        state.totalWorkerDispatches = snapshot.totalWorkerDispatches;
+        state.workerDispatches = snapshot.workerDispatches;
+        state.workerInFlight = snapshot.workerInFlight;
+        state.workerResumeUsed = snapshot.workerResumeUsed;
+        for (const [key, value] of Object.entries({ workerResumeSessionID: snapshot.workerResumeSessionID,
+            workerResumeTaskID: snapshot.workerResumeTaskID, workerTaskID: snapshot.workerTaskID })) {
+            if (value === undefined)
+                delete state[key];
+            else
+                state[key] = value;
+        }
+    }
     beforeTool(sessionID, tool, args, options = {}) {
         const state = this.sessions.get(sessionID);
         if (state === undefined) {

package/dist/plugin/index.js

@@ -45,7 +45,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, replaceDoneTerminalStatus, replaceTerminalStatus, sanitizeTerminalReport, terminalRunOutcome } from "./run-metrics.js";
+import { collectRunMetrics, createSortieResult, createGoalReport, 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 };
@@ -1127,15 +1127,18 @@ export const SortieDogsPlugin = async (input, options) => {
     const parallelAcceptanceContinuity = new Map();
     const goalRootSessions = new Map();
     const goalLedgers = new Map();
+    const goalLedgerFiles = new Map();
+    const goalLedgerDirectories = new Set();
     const goalReservations = new Map();
     const hostGoalExecutions = new Map();
+    const goalValidationDefects = new Set();
     const goalDeclarationAuthority = new Map();
     const pendingRealGoalTurns = new Map();
     const pendingGoalRecoveries = new Map();
     const scheduledGoalRecoveries = new Map();
     const globalConfig = await readOptionalGlobalConfig();
     const sessionOperationMetrics = new Map();
-    function appLogInfo(message, sessionID, extra) {
+    function appLogInfo(message, sessionID, extra, level = "info") {
         const app = input.client?.app;
         const log = app?.log;
         if (log === undefined)
@@ -1144,7 +1147,7 @@ export const SortieDogsPlugin = async (input, options) => {
             const result = log.call(app, {
                 body: {
                     service: "sortie-dogs",
-                    level: "info",
+                    level,
                     message,
                     extra: { sessionID: sessionID.slice(0, 128), ...extra },
                 },
@@ -1242,15 +1245,22 @@ export const SortieDogsPlugin = async (input, options) => {
         const key = createHash("sha256").update(root).digest("hex");
         const projectRoot = resolve(input.worktree ?? input.directory);
         const legacyPath = join(projectRoot, ".sortie-dogs", "run-flight", `${key}.json`);
+        goalLedgerDirectories.add(dirname(legacyPath));
         const opened = (async () => {
+            const legacyExists = await stat(legacyPath).then((value) => value.isFile()).catch(() => false);
+            const leaseRoot = legacyExists ? await durableScopeRoot(projectRoot).catch(() => undefined) : await durableScopeRoot(projectRoot);
+            if (leaseRoot !== undefined)
+                goalLedgerDirectories.add(join(dirname(leaseRoot), "run-flight"));
             // Existing roots remain on their original owner so an in-flight pre-upgrade goal is not forked.
-            if (await stat(legacyPath).then((value) => value.isFile()).catch(() => false)) {
+            if (legacyExists) {
+                goalLedgerFiles.set(root, legacyPath);
                 return await RunFlightLedger.openGoal(legacyPath);
             }
-            const leaseRoot = await durableScopeRoot(projectRoot);
             const filePath = leaseRoot === undefined
                 ? legacyPath
                 : join(dirname(leaseRoot), "run-flight", `${key}.json`);
+            goalLedgerFiles.set(root, filePath);
+            goalLedgerDirectories.add(dirname(filePath));
             return await RunFlightLedger.openGoal(filePath);
         })();
         goalLedgers.set(root, opened);
@@ -1362,8 +1372,12 @@ export const SortieDogsPlugin = async (input, options) => {
             const unitID = authorization.taskID;
             const unitBound = unitID !== undefined && goal.outstanding_reservations.some((reservation) => reservation.unit_id === unitID && reservation.session_id === identity.parentID);
             const criteria = goal.acceptance_contract?.criteria.filter((criterion) => criterion.validation_command === rawCommand && criterion.expected_outcome === "pass") ?? [];
+            const denyValidation = (reason) => {
+                goalValidationDefects.add(toolInput.sessionID);
+                return new Error(`SORTIE_VALIDATION_BUDGET_DENIED: ${reason}`);
+            };
             if (!unitBound)
-                throw new Error("SORTIE_VALIDATION_BUDGET_DENIED: requirement-unbound");
+                throw denyValidation("requirement-unbound");
             // Exact generation and formatting checks may support acceptance without proving a criterion.
             if (criteria.length === 0)
                 return;
@@ -1377,10 +1391,10 @@ export const SortieDogsPlugin = async (input, options) => {
                 reservation = await ledger.reserveValidation(request, goal.budget?.max_units ?? 1);
             }
             catch (error) {
-                throw new Error(`SORTIE_VALIDATION_BUDGET_DENIED: authority-unavailable:${error instanceof Error ? error.name : "unknown"}`);
+                throw denyValidation(`authority-unavailable:${error instanceof Error ? error.name : "unknown"}`);
             }
             if (reservation.decision !== "ALLOW" || reservation.reservation_id === null) {
-                throw new Error(`SORTIE_VALIDATION_BUDGET_DENIED: ${reservation.reason}`);
+                throw denyValidation(reservation.reason);
             }
             validation = { ledger, request, reservation: reservation.reservation_id };
         }
@@ -1615,11 +1629,12 @@ export const SortieDogsPlugin = async (input, options) => {
                 : "external_dependency";
             receipt = await terminalGoal(sessionID, reason, "stopped").catch(() => undefined);
         }
-        if (receipt !== undefined)
-            goal = await currentGoal(sessionID).catch(() => goal);
+        const snapshot = receipt === undefined ? undefined : await goalLedger(sessionID).then((ledger) => ledger.readGoal()).catch(() => undefined);
+        if (snapshot !== undefined)
+            goal = snapshot.state;
         if (receipt !== undefined)
             rootAcceptanceContinuity.delete(sessionID);
-        return { outcome, goal, receipt, delivery };
+        return { outcome, goal, receipt, delivery, records: snapshot?.records };
     }
     function goalDeclarationContract(prompt) {
         const lines = prompt.split(/\r?\n/u);
@@ -1768,27 +1783,29 @@ export const SortieDogsPlugin = async (input, options) => {
             throw new HandoffDeniedError("contract-invalid", "<goal-declaration>", { defects: validated.defects });
         }
         const declaration = validated.declaration;
+        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;
+        const declaredTime = Number(handoffValue(entries, ["goal_budget_time_ms"]));
+        const declaredCost = Number(handoffValue(entries, ["goal_budget_cost_usd"]));
+        const timeBudget = Number.isFinite(declaredTime) && declaredTime > 0 ? declaredTime : state.budget?.time_ms ?? null;
+        const costBudget = Number.isFinite(declaredCost) && declaredCost > 0 ? declaredCost : state.budget?.cost_usd ?? null;
+        const budgetChanged = maxUnits !== state.budget?.max_units || timeBudget !== state.budget?.time_ms ||
+            costBudget !== state.budget?.cost_usd;
         const authority = goalDeclarationAuthority.get(sessionID);
         if (authority === undefined || authority !== state.latest_user_message_id) {
-            if (declaration.fingerprint !== state.acceptance_fingerprint) {
+            if (declaration.fingerprint !== state.acceptance_fingerprint || budgetChanged) {
                 throw new HandoffDeniedError("contract-invalid", "<goal-declaration>", { defects: [
                         contractDefect("contract", "/goal_acceptance_fingerprint", "goal_revision_unauthorized"),
                     ] });
             }
             return state;
         }
-        if (declaration.fingerprint === state.acceptance_fingerprint &&
+        if (!budgetChanged && 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;
-        const declaredTime = Number(handoffValue(entries, ["goal_budget_time_ms"]));
-        const declaredCost = Number(handoffValue(entries, ["goal_budget_cost_usd"]));
-        const timeBudget = Number.isFinite(declaredTime) && declaredTime > 0 ? declaredTime : state.budget?.time_ms ?? null;
-        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: declaration.fingerprint, origin_user_message_id: state.latest_user_message_id,
@@ -1904,7 +1921,11 @@ export const SortieDogsPlugin = async (input, options) => {
             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 failedAcceptanceExecution = [...hostGoalExecutions.values()].some((execution) => execution.root === reservation.root && execution.sessionID === childSessionID &&
+            execution.endedAt !== undefined && Date.parse(execution.startedAt) >= reservation.started - 1000 &&
+            execution.outcome === "fail");
+        const processDefect = !failedAcceptanceExecution && (childSessionID === undefined || hostBindingDefect ||
+            goalValidationDefects.has(childSessionID));
         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) }),
@@ -1913,6 +1934,7 @@ export const SortieDogsPlugin = async (input, options) => {
             progress_fingerprint: progress ? goalFingerprint(acceptedEvidence) : null,
             evidence: acceptedEvidence, elapsed_ms: Math.max(0, Date.now() - reservation.started), cost_usd: null });
         if (childSessionID !== undefined) {
+            goalValidationDefects.delete(childSessionID);
             for (const [executionCallID, execution] of hostGoalExecutions) {
                 if (execution.root === reservation.root && execution.sessionID === childSessionID)
                     hostGoalExecutions.delete(executionCallID);
@@ -4118,7 +4140,7 @@ export const SortieDogsPlugin = async (input, options) => {
         const remedies = {
             "session-inactive": {
                 recoverable: true,
-                remedy: "Freshly redispatch this worker with prompt text containing role, project_root, source_manifest or operation_manifest, and acceptance or validation fields; a bare resume or file read cannot activate the session.",
+                remedy: "Freshly redispatch through dog-coordinator's admitted dog-worker Task, with prompt text containing role, project_root, source_manifest or operation_manifest, and acceptance or validation fields. A standalone build/fixer Task is not a registered Sortie worker; copying these fields, a bare resume, or a file read cannot activate it. Preserve explicit agent selection and resolve any existing goal stop before using the Sortie workflow; do not repeat the same standalone redispatch or reset its ledger to bypass a stop.",
             },
             "session-expired": {
                 recoverable: true,
@@ -4659,6 +4681,7 @@ export const SortieDogsPlugin = async (input, options) => {
         clearSessionLinks(sessionID);
     }
     function evictSession(sessionID) {
+        goalValidationDefects.delete(sessionID);
         activeSessions.delete(sessionID);
         sessionOperationMetrics.delete(sessionID);
         rootAcceptanceContinuity.delete(sessionID);
@@ -5354,13 +5377,33 @@ export const SortieDogsPlugin = async (input, options) => {
                     startedAt: terminal.receipt.started_at,
                     endedAt: terminal.receipt.ended_at,
                 }).catch(() => undefined));
-                const sortieResult = terminal?.receipt === undefined || terminal.goal === undefined
+                let sortieResult = terminal?.receipt === undefined || terminal.goal === undefined
                     ? undefined
-                    : createSortieResult(terminal.receipt, terminal.goal, metrics, new Date().toISOString());
+                    : createSortieResult(terminal.receipt, terminal.goal, metrics, new Date().toISOString(), terminal.records);
+                if (sortieResult !== undefined && terminal?.receipt !== undefined && terminal.records !== undefined) {
+                    try {
+                        const ledger = await goalLedger(textInput.sessionID);
+                        const report = createGoalReport(sortieResult, terminal.receipt);
+                        let records = terminal.records;
+                        if (!records.some(({ event }) => event.kind === "goal.reported" && event.report?.terminal_key === report.terminal_key)) {
+                            await ledger.appendGoal({ kind: "goal.reported", at: new Date().toISOString(), goal_id: terminal.receipt.goal_id, report });
+                            records = (await ledger.readGoal()).records;
+                        }
+                        const currentPath = goalLedgerFiles.get(goalRoot(textInput.sessionID));
+                        if (currentPath !== undefined) {
+                            const { collectCareer } = await import("./sortie-career.js");
+                            sortieResult = { ...sortieResult, career: await collectCareer([...goalLedgerDirectories], currentPath, records, (path) => RunFlightLedger.readGoalFile(path)) };
+                        }
+                    }
+                    catch {
+                        appLogInfo("run-metrics.career-unavailable", textInput.sessionID, { outcome: runOutcome }, "warn");
+                    }
+                }
                 if (sortieResult !== undefined)
                     textOutput.text = insertSortieResult(textOutput.text, sortieResult);
                 else if (metrics !== undefined && runOutcome === "DONE")
                     textOutput.text = insertRunMetrics(textOutput.text, metrics);
+                const { debrief: _debriefObservation, ...metricSummary } = metrics ?? {};
                 appLogInfo("run-metrics.snapshot", textInput.sessionID, {
                     available: metrics !== undefined,
                     outcome: runOutcome,
@@ -5371,7 +5414,7 @@ export const SortieDogsPlugin = async (input, options) => {
                         resultProof: sortieResult.proof.overall,
                         accountingPhase: sortieResult.accounting_phase,
                     }),
-                    ...(metrics ?? {}),
+                    ...metricSummary,
                     ...operationMetricsSnapshot(textInput.sessionID),
                 });
             }
@@ -5705,6 +5748,16 @@ export const SortieDogsPlugin = async (input, options) => {
         */
         "tool.execute.after": async (toolInput, output) => {
             await recordHostGoalEnd(toolInput, output);
+            // A completed host question is a new user-interaction boundary, just like chat input.
+            // It authorizes one subsequent typed declaration; it does not itself grant budget or clear a stop.
+            if (toolInput.tool === "question" && toolInput.sessionID !== undefined &&
+                isCoordinatorSession(toolInput.sessionID) && typeof output.output === "string" &&
+                output.output.trim().length > 0 && output.status !== "error" && output.status !== "cancelled") {
+                const goal = await currentGoal(toolInput.sessionID);
+                if (goal.phase !== "terminal" && goal.latest_user_message_id !== null) {
+                    goalDeclarationAuthority.set(toolInput.sessionID, goal.latest_user_message_id);
+                }
+            }
             diagnosisChildren.get(toolInput.sessionID ?? "")?.tools.delete(toolInput.callID ?? "");
             const diagnosisCandidate = toolInput.tool === "task" ? diagnosisCalls.get(toolInput.callID ?? "") : undefined;
             const diagnosis = diagnosisCandidate?.context.ownerRoot === toolInput.sessionID ? diagnosisCandidate : undefined;
@@ -6231,45 +6284,54 @@ export const SortieDogsPlugin = async (input, options) => {
                     // 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 : "");
                 }
+                // Accounting is provisional until this dispatch is fully admitted. A later denial such as a
+                // budget stop must release the serial slot, or no worker could be dispatched or resumed again.
+                const workerAccounting = fastLane.snapshotWorkerAccounting(toolInput.sessionID);
                 const resumedWorkerSessionID = fastLane.beforeTool(toolInput.sessionID, toolInput.tool, output.args, {
                     readonlyDiagnosisAuthorized: readonlyDiagnosis,
                     consultationFallbackAuthorized,
                     parallelWorkerAlreadyBound,
                     parallelWorkerAuthorized,
                 });
-                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 : "");
-                }
-                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);
+                try {
+                    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 : "");
                     }
-                }
-                if (resumedWorkerSessionID !== undefined) {
-                    const recoverableParallel = parallelRecoverableChildren.get(resumedWorkerSessionID);
-                    if (recoverableParallel !== undefined) {
-                        parallelCalls.set(toolInput.callID, recoverableParallel);
-                        parallelRecoverableChildren.delete(resumedWorkerSessionID);
+                    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);
+                        }
                     }
-                    recoverableWorkerChildren.delete(resumedWorkerSessionID);
-                }
-                if (toolInput.tool === "task" && taskRole !== undefined && IMPLEMENTATION_AGENTS.has(taskRole)) {
-                    if (readonlyDiagnosis && isRecord(output.args))
-                        await claimDiagnosisTask(toolInput.sessionID, toolInput.callID, output.args, true);
-                    bootstrapRequired = false;
-                    bootstrapCompleted = true;
-                    bootstrapIdleWarnings.delete(toolInput.sessionID);
-                    beginCoordinatorTask(toolInput.sessionID, toolInput.callID);
-                    if (reservedParallelDescriptor !== undefined) {
-                        parallelCalls.set(toolInput.callID, {
-                            ownerRoot: toolInput.sessionID,
-                            descriptor: reservedParallelDescriptor,
-                            completionCallID: toolInput.callID,
-                        });
+                    if (resumedWorkerSessionID !== undefined) {
+                        const recoverableParallel = parallelRecoverableChildren.get(resumedWorkerSessionID);
+                        if (recoverableParallel !== undefined) {
+                            parallelCalls.set(toolInput.callID, recoverableParallel);
+                            parallelRecoverableChildren.delete(resumedWorkerSessionID);
+                        }
+                        recoverableWorkerChildren.delete(resumedWorkerSessionID);
                     }
+                    if (toolInput.tool === "task" && taskRole !== undefined && IMPLEMENTATION_AGENTS.has(taskRole)) {
+                        if (readonlyDiagnosis && isRecord(output.args))
+                            await claimDiagnosisTask(toolInput.sessionID, toolInput.callID, output.args, true);
+                        bootstrapRequired = false;
+                        bootstrapCompleted = true;
+                        bootstrapIdleWarnings.delete(toolInput.sessionID);
+                        beginCoordinatorTask(toolInput.sessionID, toolInput.callID);
+                        if (reservedParallelDescriptor !== undefined) {
+                            parallelCalls.set(toolInput.callID, {
+                                ownerRoot: toolInput.sessionID,
+                                descriptor: reservedParallelDescriptor,
+                                completionCallID: toolInput.callID,
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    fastLane.restoreWorkerAccounting(toolInput.sessionID, workerAccounting);
+                    throw error;
                 }
                 return;
             }

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

@@ -1,4 +1,7 @@
-import type { GoalFlightState, GoalTerminalReceipt } from "../core/goal-bound.js";
+import type { GoalFlightState, GoalTerminalReceipt, GoalFlightEventRecord } from "../core/goal-bound.js";
+import { type Debrief, type DebriefObservation } from "./sortie-debrief.ts";
+import type { GoalReport } from "../core/goal-report.ts";
+import { type SortieCareer } from "./sortie-career.ts";
 export interface RunMetricsClient {
     readonly session?: {
         readonly get?: (request: {
@@ -44,6 +47,8 @@ export interface RunMetrics {
     readonly sessions: number | undefined;
     readonly cacheRatio: number | undefined;
     readonly roles: Readonly<Record<string, RunRoleMetrics>> | undefined;
+    /** Optional for compatibility with older host snapshots. Collected in the existing history pass. */
+    readonly debrief?: DebriefObservation;
 }
 export interface RunRoleMetrics {
     readonly tokens: number;
@@ -72,6 +77,8 @@ export interface SortieResult {
     readonly result_id: readonly [goalID: string, terminalRevision: number];
     readonly accounting_phase: "pre-terminal";
     readonly as_of: string;
+    readonly debrief?: Debrief;
+    readonly career?: SortieCareer;
     readonly mission: {
         readonly status: "COMPLETED" | "INTERRUPTED" | "EXTERNAL_BLOCKER" | "USER_DECISION";
         readonly stop_reason: GoalTerminalReceipt["stop_reason"];
@@ -102,7 +109,7 @@ 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 declare function createSortieResult(receipt: GoalTerminalReceipt, goal: SortieGoalSnapshot, metrics: RunMetrics | undefined, asOf?: string, records?: readonly GoalFlightEventRecord[]): SortieResult;
 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;
@@ -114,4 +121,5 @@ export declare function replaceDoneTerminalStatus(text: string, replacement: str
 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 declare function createGoalReport(result: SortieResult, receipt: GoalTerminalReceipt): GoalReport;
 export {};