sortie-dogs 0.9.4 → 0.9.6

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.4](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.4)
+Release: [v0.9.6](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.6)
 
 ## 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";
@@ -112,6 +113,7 @@ export type GoalFlightEvent = (GoalEventBase & {
     readonly delivery: GoalDeliveryMode;
     readonly budget: GoalBudget;
     readonly acceptance_contract: GoalAcceptanceContract | null;
+    readonly reset_no_progress?: boolean;
 }) | (GoalEventBase & {
     readonly kind: "ticket.issued";
     readonly ticket_id: string;
@@ -177,6 +179,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

@@ -106,11 +106,17 @@ function addUnique(values, value) {
 }
 export function reduceGoalFlight(records) {
     let state = initial();
+    let replanRevision = null;
+    let legacyResetRevision = false;
     let previous = null;
     for (const [index, record] of records.entries()) {
         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.");
@@ -122,6 +128,8 @@ export function reduceGoalFlight(records) {
                 latest_user_message_id: event.origin_user_message_id, selected_agent: event.selected_agent,
                 delivery: event.delivery, budget: event.budget, acceptance_contract: event.acceptance_contract, phase: "active",
                 session_ids: [event.origin_session_id] };
+            replanRevision = null;
+            legacyResetRevision = false;
             continue;
         }
         requireState(state.goal_id !== null && event.goal_id === state.goal_id, "transition", "Goal identity mismatch.");
@@ -134,13 +142,22 @@ 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 &&
-                validAcceptanceContract(event.acceptance_contract), "transition", "Scope revision is stale or resets consumed budget.");
+                event.budget.max_units >= state.validation_budget.consumed &&
+                validAcceptanceContract(event.acceptance_contract) &&
+                (event.reset_no_progress === undefined || typeof event.reset_no_progress === "boolean"), "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: [], ...(event.reset_no_progress === true
+                    ? { no_progress_results: 0, replan_required: false, replan_used: false }
+                    : {}) };
+            if (event.reset_no_progress === true)
+                replanRevision = null;
+            legacyResetRevision = event.reset_no_progress === undefined;
         }
         else if (event.kind === "ticket.issued") {
             requireState(state.phase === "active" && event.revision === state.revision && event.scope_epoch === state.scope_epoch &&
@@ -158,6 +175,13 @@ export function reduceGoalFlight(records) {
                 session_ids: addUnique(state.session_ids, event.session_id) };
         }
         else if (event.kind === "dispatch.reserved") {
+            // A short-lived pre-marker runtime reset no-progress on revision but persisted no flag.
+            // A later accepted dispatch proves that reset; older revisions followed by an explicit
+            // replan retain their original semantics.
+            if (legacyResetRevision && state.replan_required && state.replan_used && replanRevision !== null && state.revision > replanRevision) {
+                state = { ...state, no_progress_results: 0, replan_required: false, replan_used: false };
+                replanRevision = null;
+            }
             requireState(state.phase === "active" && !state.replan_required, "transition", "Dispatch requires terminal handling or one bounded replan.");
             requireState(state.budget !== null && state.consumed_units + state.outstanding_reservations.length < state.budget.max_units, "budget", "Goal unit budget exhausted.");
             requireState(state.budget.time_ms === null || (state.consumed_time_ms !== null && state.consumed_time_ms < state.budget.time_ms), "budget", "Goal time budget is exhausted or usage is unknown.");
@@ -215,6 +239,7 @@ export function reduceGoalFlight(records) {
         else if (event.kind === "goal.replanned") {
             requireState(state.phase === "active" && state.replan_required && !state.replan_used && event.revision === state.revision, "transition", "Bounded replan is unavailable.");
             state = { ...state, replan_used: true, replan_required: false, no_progress_results: 0 };
+            replanRevision = event.revision;
         }
         else if (event.kind === "goal.terminal") {
             const allAccepted = state.acceptance_contract !== null && state.acceptance_contract.criteria.every(({ criterion_id }) => state.satisfied_criteria.includes(criterion_id));

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/core/scope-lease-registry.js

@@ -472,13 +472,16 @@ export class ScopeLeaseRegistry {
             await rmdir(this.lockPath).catch(() => undefined);
             return;
         }
-        if (names.length !== 1)
+        const owners = names.filter((name) => OWNER_FILE.test(name));
+        if (owners.length !== 1 || names.length > MAX_TEMP_CLEANUP + 1 ||
+            names.some((name) => name !== owners[0] && !TEMP_FILE.test(name)))
             return;
-        const match = OWNER_FILE.exec(names[0]);
+        const ownerName = owners[0];
+        const match = OWNER_FILE.exec(ownerName);
         if (match === null || !UUID.test(match[1]))
             return;
         const owner = match[1];
-        const ownerPath = join(this.lockPath, names[0]);
+        const ownerPath = join(this.lockPath, ownerName);
         const before = await this.mutexSnapshot(ownerPath);
         if (before === undefined || Date.now() - before.mtimeMs <= this.options.mutexStaleMs || before.content !== owner)
             return;
@@ -490,7 +493,7 @@ export class ScopeLeaseRegistry {
         catch {
             return;
         }
-        const movedOwnerPath = join(quarantine, names[0]);
+        const movedOwnerPath = join(quarantine, ownerName);
         const after = await this.mutexSnapshot(movedOwnerPath);
         if (after === undefined || !this.sameMutexSnapshot(before, after)) {
             // The whole-directory rename already fenced this owner. Keep its quarantine until a later

package/dist/plugin/gate.d.ts

@@ -69,5 +69,5 @@ export declare function canonicalManifestWriteScopes(project: ProjectPaths, mani
 export declare function canonicalManifestReadScopes(project: ProjectPaths, manifest: OperationManifest): Promise<readonly string[]>;
 export declare function writeScopesOverlap(left: readonly string[], right: readonly string[]): boolean;
 export declare function createProjectPaths(rootCandidate: string): Promise<ProjectPaths>;
-export declare function createWriteGate(project: ProjectPaths, value: unknown): Promise<WriteGate>;
+export declare function createWriteGate(project: ProjectPaths, value: unknown, toolDirectory?: string): Promise<WriteGate>;
 export {};

package/dist/plugin/gate.js

@@ -964,7 +964,7 @@ export async function createProjectPaths(rootCandidate) {
         },
     };
 }
-export async function createWriteGate(project, value) {
+export async function createWriteGate(project, value, toolDirectory = project.root) {
     const validated = validateOperationManifestSchema(value);
     if (!validated.ok)
         throw new WriteDeniedError("manifest-unavailable", "<unknown>");
@@ -1189,8 +1189,20 @@ export async function createWriteGate(project, value) {
                 }
                 throw new WriteDeniedError("path-required", "<missing-path>");
             }
-            for (const path of extracted.paths)
-                await checkPath(path);
+            // OpenCode resolves native file-tool paths against its instance directory, not the
+            // manifest root. Check the same destination without rewriting the tool arguments.
+            const nativeFileTool = /^(?:write|edit)(?:$|[_-])/iu.test(_input.tool) || /patch/iu.test(_input.tool);
+            for (const path of extracted.paths) {
+                if (nativeFileTool) {
+                    try {
+                        normalizeManifestPath(path);
+                    }
+                    catch (error) {
+                        throw new WriteDeniedError("project-boundary", path, { cause: error });
+                    }
+                }
+                await checkPath(nativeFileTool ? resolve(toolDirectory, path) : path);
+            }
             if (extracted.gitCommit)
                 await checkCachedSet();
         },

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,
@@ -1796,7 +1813,7 @@ export const SortieDogsPlugin = async (input, options) => {
             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: declaration.contract });
+            acceptance_contract: declaration.contract, reset_no_progress: true });
         goalDeclarationAuthority.delete(sessionID);
         return state;
     }
@@ -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);
@@ -2108,7 +2130,7 @@ export const SortieDogsPlugin = async (input, options) => {
                     throw new WriteDeniedError("manifest-unavailable", "<unknown>");
                 loaded.manifest = validation.value;
                 loaded.manifestFingerprint = inspectionFingerprint(validation.value, undefined);
-                loaded.gate = await createWriteGate(project, validation.value);
+                loaded.gate = await createWriteGate(project, validation.value, input.directory);
                 bootstrapRequired = false;
                 bootstrapCompleted = true;
                 loadFailure = undefined;
@@ -4035,7 +4057,7 @@ export const SortieDogsPlugin = async (input, options) => {
                     });
                 }
                 manifest = manifestValidation.value;
-                authorizationGate = await createWriteGate(candidateProject, manifest);
+                authorizationGate = await createWriteGate(candidateProject, manifest, input.directory);
                 inspectedProjectRoot = candidateProject.root;
             }
             catch (error) {
@@ -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,
@@ -4330,7 +4352,7 @@ export const SortieDogsPlugin = async (input, options) => {
                     idempotent: true,
                 });
             }
-            const gate = await createWriteGate(candidate, validation.value);
+            const gate = await createWriteGate(candidate, validation.value, input.directory);
             const readScopes = await canonicalManifestReadScopes(candidate, validation.value);
             const writeScopes = await canonicalManifestWriteScopes(candidate, validation.value);
             // Keep conflict detection and registration in one JavaScript turn so competing binds fail closed.
@@ -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;
@@ -6354,6 +6407,8 @@ export const SortieDogsPlugin = async (input, options) => {
             }
             catch (error) {
                 activeState?.inFlightCalls.delete(toolInput.callID);
+                if (error instanceof WriteDeniedError)
+                    goalValidationDefects.add(toolInput.sessionID);
                 if (!(error instanceof WriteDeniedError) || error.reason === "repeated-denial")
                     throw error;
                 const signature = denialSignature(toolInput, output, error.reason);

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 {};