sortie-dogs 0.9.4 → 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.4](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.4)
+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/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;

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

package/dist/plugin/run-metrics.js

@@ -1,3 +1,6 @@
+import { buildDebrief, renderDebrief, observeDebriefSession } from "./sortie-debrief.js";
+import { goalFingerprint } from "../core/goal-bound.js";
+import { renderCareer } from "./sortie-career.js";
 const unavailable = (reason) => ({ availability: "unavailable", value: null, reason });
 const available = (value, provenance) => ({ availability: "available", value, provenance });
 function elapsedBetween(start, end) {
@@ -6,7 +9,7 @@ function elapsedBetween(start, end) {
     return Number.isFinite(started) && Number.isFinite(ended) && ended >= started ? ended - started : undefined;
 }
 /** Builds a pure terminal snapshot from the durable goal receipt and already-observed host metrics. */
-export function createSortieResult(receipt, goal, metrics, asOf = receipt.ended_at) {
+export function createSortieResult(receipt, goal, metrics, asOf = receipt.ended_at, records) {
     const goalWall = elapsedBetween(receipt.started_at, receipt.ended_at);
     const firstVerifiable = receipt.milestone_at === null
         ? undefined
@@ -25,11 +28,13 @@ export function createSortieResult(receipt, goal, metrics, asOf = receipt.ended_
             : receipt.stop_reason === "external_dependency" || receipt.stop_reason === "persistence_unavailable"
                 ? "EXTERNAL_BLOCKER"
                 : "INTERRUPTED";
+    const debrief = buildDebrief(receipt, goal.acceptance_contract, metrics?.debrief, records);
     return {
         schema_version: "0.1",
         result_id: [receipt.goal_id, receipt.terminal_revision],
         accounting_phase: "pre-terminal",
         as_of: asOf,
+        debrief,
         mission: {
             status: missionStatus,
             stop_reason: receipt.stop_reason,
@@ -39,7 +44,9 @@ export function createSortieResult(receipt, goal, metrics, asOf = receipt.ended_
             worker_execution_ms: goal.consumed_time_ms === null
                 ? unavailable("goal-usage-unavailable")
                 : available(goal.consumed_time_ms, "goal-ledger"),
-            execution_compression: unavailable("worker-overlap-unavailable"),
+            execution_compression: debrief.overlap !== undefined && debrief.overlap.wallMilliseconds > 0
+                ? available(debrief.overlap.workerMilliseconds / debrief.overlap.wallMilliseconds, "host-reported")
+                : unavailable("worker-overlap-unavailable"),
             first_verifiable_ms: firstVerifiable === undefined
                 ? unavailable("milestone-unavailable")
                 : available(firstVerifiable, "goal-receipt"),
@@ -194,11 +201,14 @@ export async function collectRunMetrics(client, rootSessionID, directory, now =
     let cost = 0;
     let costAvailable = true;
     const roleMetrics = new Map();
+    const observedSessions = [];
     for (const id of ids) {
         try {
             const messages = assistantMessages(await session.messages.call(session, { path: { id }, query: { directory } }));
             if (messages === undefined)
                 return undefined;
+            const observed = observeDebriefSession(id, id === rootSessionID, messages, window === undefined ? undefined : { start: windowStart, end: windowEnd });
+            observedSessions.push(observed);
             for (const message of messages) {
                 const info = record(message.info) ?? message;
                 const time = record(info.time) ?? record(message.time);
@@ -240,6 +250,12 @@ export async function collectRunMetrics(client, rootSessionID, directory, now =
                 roleMetrics.set(agent, role);
                 for (const usage of fresh) {
                     const tokens = messageTokens(usage.value);
+                    const modelInfo = record(usage.value.info) ?? usage.value;
+                    const provider = modelInfo.providerID ?? info.providerID;
+                    const model = modelInfo.modelID ?? info.modelID;
+                    const modelKey = typeof provider === "string" && typeof model === "string" ? `${provider}/${model}` : "未分類";
+                    observed.models[modelKey] = tokens === undefined || observed.models[modelKey] === null ? null
+                        : (observed.models[modelKey] ?? 0) + tokens.total;
                     if (tokens !== undefined) {
                         totalTokens += tokens.total;
                         inputTokens += tokens.input;
@@ -309,6 +325,8 @@ export async function collectRunMetrics(client, rootSessionID, directory, now =
                     cacheRatio: role.tokens > 0 ? role.cacheReadTokens / role.tokens : undefined,
                 }]))
             : undefined,
+        debrief: { complete: hierarchyComplete && messagesComplete, sessions: observedSessions,
+            window: window === undefined ? undefined : { start: windowStart, end: windowEnd } },
     };
 }
 function duration(milliseconds) {
@@ -331,11 +349,14 @@ export function formatSortieResult(result) {
             : result.mission.status === "EXTERNAL_BLOCKER" ? "外部要因で未完了"
                 : "ユーザー判断待ち（未完了）";
     return [
-        "**Sortie Result**",
-        `**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");
+        "**🐾 SORTIE DOGS — 帰還報告**",
+        `**⚡ 時間:** ${metricText(result.speed.goal_wall_ms, duration)}`,
+        `**🪙 使用量:** ${metricText(result.cost.total_tokens, (value) => `${value.toLocaleString("ja-JP")} tokens`)} · host推定額 ${metricText(result.cost.cost_usd, (value) => `$${value.toFixed(4)}`)}（実課金換算なし）`,
+        ...renderDebrief(result.debrief),
+        `**🛡 達成:** ${achievement} · 達成条件 ${criteria}`,
+        "*最終応答生成前の計測*",
+        ...renderCareer(result.career),
+    ].join("\n\n");
 }
 export function formatRunMetrics(metrics) {
     const elapsed = metrics.durationMilliseconds === undefined ? "duration unavailable" : `${duration(metrics.durationMilliseconds)} wall-clock`;
@@ -441,10 +462,39 @@ export function insertSortieResult(text, result) {
     const checkpoint = terminalCheckpoint(visible);
     if (checkpoint === undefined)
         return visible;
-    if (topLevelLines(visible).some(({ index, line }) => index > checkpoint.index && /^\*\*Sortie Result\*\*/u.test(line)))
-        return visible;
+    // A title in model text is not trusted evidence. Replace existing cards, including legacy cards.
     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);
+    const cardLines = new Set(topLevelLines(visible).filter(({ index, line }) => index > checkpoint.index &&
+        /^(?:\*\*(?:Sortie Result|🐾 SORTIE DOGS — 帰還報告|📜 PACK RECORD|↳\*\*|(?:Speed|Cost|達成|⚡ 時間|🪙 使用量|🐕 出撃隊|モデル別token内訳|実行重複率|🛡 達成|確認|🏅 今回の戦績|戦績|初回完遂|累積使用量|累積モデル|累積時間|累積実行重複率|保存範囲|🎖 隊の称号):)|\*最終応答生成前の計測\*)/u.test(line)).map(({ index }) => index));
+    const cleaned = lines.filter((_, index) => !cardLines.has(index));
+    while (cleaned[checkpoint.index + 1] === "")
+        cleaned.splice(checkpoint.index + 1, 1);
+    let card;
+    try {
+        card = formatSortieResult(result);
+    }
+    catch {
+        card = "**🐾 SORTIE DOGS — 帰還報告**\n**確認:** 表示集計を取得できません。任務結果は先頭の状態を参照。";
+    }
+    cleaned.splice(checkpoint.index + 1, 0, "", card, "");
+    return cleaned.join(newline).trimEnd();
+}
+export function createGoalReport(result, receipt) {
+    const tokens = result.cost.total_tokens.availability === "available" && Number.isSafeInteger(result.cost.total_tokens.value)
+        ? result.cost.total_tokens.value : null;
+    const mix = result.debrief?.mix;
+    const traits = [];
+    if (result.debrief?.traits.includes("連携作戦"))
+        traits.push("pack-tactics");
+    if (result.debrief?.traits.includes("修正から復帰"))
+        traits.push("recovery");
+    if (result.debrief?.traits.includes("一発完遂"))
+        traits.push("clean-sweep");
+    return { definition: "pre-terminal-host-tokens/v1", terminal_key: goalFingerprint(receipt), tokens,
+        models: mix != null && mix.length <= 128 && mix.every((entry) => entry.model.length <= 512) &&
+            mix.reduce((sum, entry) => sum + entry.tokens, 0) === tokens ? mix.map(({ model, tokens }) => ({ model, tokens })) : null,
+        first_pass_eligible: result.debrief?.firstPassEligible === true, traits,
+        ...(result.debrief?.overlap === undefined ? {} : { overlap: { definition: "worker-span-union/v1",
+                worker_ms: result.debrief.overlap.workerMilliseconds, wall_ms: result.debrief.overlap.wallMilliseconds } }) };
 }

package/dist/plugin/sortie-career.d.ts

@@ -0,0 +1,55 @@
+import { type GoalFlightEventRecord } from "../core/goal-bound.ts";
+export interface CareerCoverage {
+    readonly files: number;
+    readonly included: number;
+    readonly unavailable: number;
+    readonly truncated: boolean;
+}
+export interface SortieCareer {
+    readonly scope: "retained-project-goals";
+    readonly since: string | null;
+    readonly coverage: CareerCoverage;
+    readonly goals: number;
+    readonly completed: number;
+    readonly interrupted: number;
+    readonly external: number;
+    readonly decision: number;
+    readonly active: number;
+    readonly telemetryCovered: number;
+    readonly firstPass: {
+        readonly count: number;
+        readonly eligible: number;
+    };
+    readonly recoveries: number;
+    readonly tokens: {
+        readonly sum: number;
+        readonly covered: number;
+    };
+    readonly models: readonly {
+        readonly model: string;
+        readonly tokens: number;
+    }[];
+    readonly modelCovered: number;
+    readonly workerTime: {
+        readonly sum: number;
+        readonly covered: number;
+    };
+    readonly goalWall: {
+        readonly sum: number;
+        readonly covered: number;
+    };
+    readonly overlap: {
+        readonly worker: number;
+        readonly wall: number;
+        readonly covered: number;
+        readonly ratio: number | null;
+    };
+    readonly titles: readonly string[];
+}
+/** Rebuild from retained source records; no cache survives deletion, retention, or reset. */
+export declare function summarizeCareer(histories: readonly (readonly GoalFlightEventRecord[])[], coverage: CareerCoverage): SortieCareer;
+/** One bounded, read-only scan at terminal time. Current records are reused, not fetched again. */
+export declare function collectCareer(directories: readonly string[], currentPath: string, current: readonly GoalFlightEventRecord[], read: (path: string) => Promise<{
+    readonly records: readonly GoalFlightEventRecord[];
+}>, maxFiles?: number): Promise<SortieCareer>;
+export declare function renderCareer(career: SortieCareer | undefined): string[];

package/dist/plugin/sortie-career.js

@@ -0,0 +1,144 @@
+import { readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { goalFingerprint } from "../core/goal-bound.js";
+import { validGoalReport } from "../core/goal-report.js";
+/** Rebuild from retained source records; no cache survives deletion, retention, or reset. */
+export function summarizeCareer(histories, coverage) {
+    const unique = new Map();
+    for (const history of histories)
+        for (const record of history)
+            unique.set(record.event_hash, record);
+    const events = [...unique.values()].sort((a, b) => Date.parse(a.event.at) - Date.parse(b.event.at) || a.sequence - b.sequence);
+    const goals = new Map();
+    for (const { event } of events) {
+        if (!goals.has(event.goal_id) && event.kind !== "goal.accepted")
+            continue;
+        const goal = goals.get(event.goal_id) ?? { since: null, receipt: null, reports: new Map(), units: new Map() };
+        goals.set(event.goal_id, goal);
+        if (event.kind === "goal.accepted")
+            goal.since ??= event.at;
+        if (event.kind === "goal.terminal")
+            goal.receipt = event.receipt;
+        if (event.kind === "goal.user-continued" || event.kind === "goal.revised")
+            goal.receipt = null;
+        if (event.kind === "unit.settled")
+            goal.units.set(event.reservation_id, event.elapsed_ms);
+        if (event.kind === "goal.reported" && validGoalReport(event.report))
+            goal.reports.set(event.report.terminal_key, event.report);
+    }
+    let completed = 0, interrupted = 0, external = 0, decision = 0, active = 0, telemetryCovered = 0, recoveries = 0;
+    const firstPass = { count: 0, eligible: 0 }, tokens = { sum: 0, covered: 0 }, workerTime = { sum: 0, covered: 0 }, goalWall = { sum: 0, covered: 0 };
+    const models = new Map();
+    const overlap = { worker: 0, wall: 0, covered: 0, ratio: null };
+    let modelCovered = 0, packTactics = false;
+    for (const goal of goals.values()) {
+        const receipt = goal.receipt;
+        if (receipt === null) {
+            active++;
+            continue;
+        }
+        if (receipt.status === "succeeded")
+            completed++;
+        else if (receipt.stop_reason === "external_dependency" || receipt.stop_reason === "persistence_unavailable")
+            external++;
+        else if (receipt.stop_reason === "awaiting_user")
+            decision++;
+        else
+            interrupted++;
+        const elapsed = Date.parse(receipt.ended_at) - Date.parse(receipt.started_at);
+        if (Number.isFinite(elapsed) && elapsed >= 0) {
+            goalWall.sum += elapsed;
+            goalWall.covered++;
+        }
+        if ([...goal.units.values()].every((value) => value !== null && Number.isFinite(value) && value >= 0)) {
+            workerTime.sum += [...goal.units.values()].reduce((sum, value) => sum + (value ?? 0), 0);
+            workerTime.covered++;
+        }
+        const report = goal.reports.get(goalFingerprint(receipt));
+        if (report === undefined)
+            continue;
+        telemetryCovered++;
+        if (report.overlap !== undefined) {
+            overlap.worker += report.overlap.worker_ms;
+            overlap.wall += report.overlap.wall_ms;
+            overlap.covered++;
+        }
+        if (report.first_pass_eligible && receipt.status === "succeeded") {
+            firstPass.eligible++;
+            if (report.traits.includes("clean-sweep"))
+                firstPass.count++;
+        }
+        if (report.traits.includes("recovery") && receipt.status === "succeeded")
+            recoveries++;
+        if (report.traits.includes("pack-tactics"))
+            packTactics = true;
+        if (report.tokens !== null) {
+            tokens.sum += report.tokens;
+            tokens.covered++;
+        }
+        if (report.models !== null) {
+            modelCovered++;
+            for (const entry of report.models)
+                models.set(entry.model, (models.get(entry.model) ?? 0) + entry.tokens);
+        }
+    }
+    const dates = [...goals.values()].flatMap((goal) => goal.since === null ? [] : [goal.since]).sort((a, b) => Date.parse(a) - Date.parse(b));
+    if (overlap.wall > 0)
+        overlap.ratio = overlap.worker / overlap.wall;
+    return { scope: "retained-project-goals", since: dates[0] ?? null, coverage, goals: goals.size,
+        completed, interrupted, external, decision, active, telemetryCovered, firstPass, recoveries, tokens,
+        models: [...models].sort(([a], [b]) => a.localeCompare(b)).map(([model, tokens]) => ({ model, tokens })), modelCovered,
+        workerTime, goalWall, overlap, titles: [
+            ...(completed > 0 ? ["任務完遂の隊"] : []), ...(packTactics ? ["連携の隊"] : []),
+            ...(recoveries > 0 ? ["復帰の隊"] : []), ...(firstPass.count > 0 ? ["一発完遂の隊"] : []),
+        ] };
+}
+/** One bounded, read-only scan at terminal time. Current records are reused, not fetched again. */
+export async function collectCareer(directories, currentPath, current, read, maxFiles = 64) {
+    const paths = new Set();
+    let unavailable = 0;
+    for (const directory of new Set(directories)) {
+        try {
+            for (const entry of await readdir(directory, { withFileTypes: true })) {
+                if (entry.isFile() && /^[a-f0-9]{64}\.json$/u.test(entry.name))
+                    paths.add(resolve(join(directory, entry.name)));
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                unavailable++;
+        }
+    }
+    paths.delete(resolve(currentPath));
+    const selected = [...paths].sort().slice(0, Math.max(0, maxFiles - 1));
+    const histories = [current];
+    for (const path of selected) {
+        try {
+            histories.push((await read(path)).records);
+        }
+        catch {
+            unavailable++;
+        }
+    }
+    return summarizeCareer(histories, { files: paths.size + 1, included: histories.length, unavailable, truncated: selected.length < paths.size });
+}
+export function renderCareer(career) {
+    if (career === undefined)
+        return ["**📜 PACK RECORD:** 保存履歴を取得できません"];
+    const terminal = career.goals - career.active;
+    const firstPass = career.firstPass.eligible === 0 ? "計測不可（対象0件）" : `${career.firstPass.count}/${career.firstPass.eligible}件`;
+    const minutes = (metric) => metric.covered === 0 ? "計測不可" : `${(metric.sum / 60000).toFixed(1)}分（${metric.covered}/${terminal}任務）`;
+    const models = [...career.models].sort((a, b) => b.tokens - a.tokens || a.model.localeCompare(b.model));
+    const modelText = models.slice(0, 4).map((entry) => `${entry.model.replace(/[\\`*_{}\[\]()<>!|\r\n]/gu, "").slice(0, 120)} ${entry.tokens.toLocaleString("ja-JP")}`).join(" · ");
+    return [
+        "**📜 PACK RECORD — 記録済み戦績**",
+        `**戦績:** 完了 ${career.completed} · 中断 ${career.interrupted} · 外部待機 ${career.external} · 指示待ち ${career.decision} · 進行中 ${career.active}`,
+        `**初回完遂:** ${firstPass} · 復帰 ${career.recoveries}件（計測記録 ${career.telemetryCovered}/${terminal}任務）`,
+        `**累積使用量:** ${career.tokens.covered === 0 ? "計測不可" : `${career.tokens.sum.toLocaleString("ja-JP")} tokens`}（計測 ${career.tokens.covered}/${terminal}任務）`,
+        `**累積モデル:** ${career.modelCovered === 0 ? "計測不可" : modelText || "出力なし"}${models.length > 4 ? " · ほか" : ""}（token計測 ${career.modelCovered}/${terminal}任務）`,
+        `**累積時間:** worker ${minutes(career.workerTime)} · goal期間合計 ${minutes(career.goalWall)}（待機含む・同時刻重複あり）`,
+        `**累積実行重複率:** ${career.overlap.ratio === null ? "計測不可" : `${career.overlap.ratio.toFixed(2)}×`}（総和の比・${career.overlap.covered}/${terminal}任務・速度倍率ではありません）`,
+        `**保存範囲:** ${career.since?.slice(0, 10) ?? "開始日不明"}以降の現存履歴 · ${career.coverage.included}/${career.coverage.files}ファイル${career.coverage.unavailable || career.coverage.truncated ? " · 部分集計" : ""} · 生涯戦績ではありません`,
+        ...(career.titles.length ? [`**🎖 隊の称号:** ${career.titles.join(" · ")}`] : []),
+    ];
+}

package/dist/plugin/sortie-debrief.d.ts

@@ -0,0 +1,54 @@
+import type { GoalAcceptanceContract, GoalTerminalReceipt, GoalFlightEventRecord } from "../core/goal-bound.js";
+type Span = {
+    start: number;
+    end: number;
+};
+type Check = Span & {
+    command: string;
+    passed: boolean;
+};
+export interface DebriefSession {
+    readonly id: string;
+    readonly root: boolean;
+    readonly spans: Span[];
+    readonly checks: Check[];
+    readonly mutations: Span[];
+    readonly models: Record<string, number | null>;
+    readonly reviews: Array<{
+        at: number;
+        status: "PASS" | "FAIL" | "WAIVED";
+    }>;
+    readonly tasks: string[];
+    complete: boolean;
+    timingComplete: boolean;
+    failed: boolean;
+}
+export interface DebriefObservation {
+    readonly complete: boolean;
+    readonly sessions: readonly DebriefSession[];
+    readonly window: Span | undefined;
+}
+export interface Debrief {
+    readonly pack: readonly {
+        readonly model: string;
+        readonly count: number;
+    }[] | null;
+    readonly mix: readonly {
+        readonly model: string;
+        readonly tokens: number;
+        readonly percent: number;
+    }[] | null;
+    readonly validation: "PASS" | "FAIL" | "未確認";
+    readonly review: "PASS" | "FAIL" | "WAIVED" | "未確認";
+    readonly traits: readonly ("連携作戦" | "修正から復帰" | "一発完遂")[];
+    readonly firstPassEligible?: boolean;
+    readonly overlap?: {
+        readonly workerMilliseconds: number;
+        readonly wallMilliseconds: number;
+    };
+}
+/** Extract only bounded typed metadata during the existing host history traversal. No conversation text survives. */
+export declare function observeDebriefSession(id: string, root: boolean, messages: readonly Record<string, unknown>[], window?: Span): DebriefSession;
+export declare function buildDebrief(receipt: GoalTerminalReceipt, contract: GoalAcceptanceContract | null, observation: DebriefObservation | undefined, records?: readonly GoalFlightEventRecord[]): Debrief;
+export declare function renderDebrief(debrief: Debrief | undefined): string[];
+export {};

package/dist/plugin/sortie-debrief.js

@@ -0,0 +1,251 @@
+import { createHash } from "node:crypto";
+import { DEDICATED_WORKER_ROLES, LUNA_FABRIC_WORKER_ROLE } from "./model-routing.js";
+const object = (value) => value !== null && typeof value === "object" ? value : undefined;
+const timeValue = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+const fingerprint = (value) => createHash("sha256").update(value).digest("hex");
+const workerRoles = new Set([...DEDICATED_WORKER_ROLES, LUNA_FABRIC_WORKER_ROLE]);
+function unionDuration(spans) {
+    let end = -1, total = 0;
+    for (const span of [...spans].sort((a, b) => a.start - b.start)) {
+        total += Math.max(0, span.end - Math.max(span.start, end));
+        end = Math.max(end, span.end);
+    }
+    return total;
+}
+const within = (span, window) => span.start <= span.end && (window === undefined || span.start >= window.start && span.end <= window.end);
+const spanOf = (value) => {
+    const time = object(value);
+    const start = timeValue(time?.start ?? time?.created), end = timeValue(time?.end ?? time?.completed);
+    return start === undefined || end === undefined || end < start ? undefined : { start, end };
+};
+/** Extract only bounded typed metadata during the existing host history traversal. No conversation text survives. */
+export function observeDebriefSession(id, root, messages, window) {
+    const session = { id, root, spans: [], checks: [], mutations: [], models: {}, reviews: [], tasks: [], complete: true, timingComplete: true, failed: false };
+    const calls = new Set();
+    for (const message of messages) {
+        const info = object(message.info) ?? message;
+        const time = info.time ?? message.time;
+        // The root's in-flight terminal answer is intentionally outside pre-terminal accounting.
+        if (root && object(time) !== undefined && timeValue(object(time)?.completed) === undefined)
+            continue;
+        const span = spanOf(time);
+        if (span === undefined) {
+            session.complete = false;
+            session.timingComplete = false;
+            continue;
+        }
+        if (!within(span, window)) {
+            if (window !== undefined && span.start < window.end && span.end > window.start) {
+                session.complete = false;
+                session.timingComplete = false;
+            }
+            continue;
+        }
+        session.spans.push(span);
+        if (info.error !== undefined)
+            session.failed = true;
+        for (const raw of Array.isArray(message.parts) ? message.parts : []) {
+            const part = object(raw);
+            if (part?.type !== "tool")
+                continue;
+            const call = typeof part.callID === "string" ? part.callID : typeof part.id === "string" ? part.id : undefined;
+            if (call === undefined) {
+                session.complete = false;
+                continue;
+            }
+            if (calls.has(call))
+                continue;
+            calls.add(call);
+            const state = object(part.state);
+            const interval = spanOf(state?.time);
+            if (state?.status !== "completed" || interval === undefined) {
+                session.failed = true;
+                session.complete = false;
+                continue;
+            }
+            if (!within(interval, window)) {
+                session.complete = false;
+                continue;
+            }
+            const tool = typeof part.tool === "string" ? part.tool.toLowerCase() : "";
+            const args = object(state.input);
+            if (tool.startsWith("sortie_") && typeof state.output === "string" && state.output.length <= 32768) {
+                try {
+                    if (object(JSON.parse(state.output))?.status === "denied")
+                        session.failed = true;
+                }
+                catch { /* Non-JSON output cannot prove a clean controller operation. */
+                    session.complete = false;
+                }
+            }
+            if (tool === "task") {
+                const metadata = object(state.metadata);
+                const child = metadata?.sessionId ?? metadata?.sessionID;
+                if (typeof args?.subagent_type !== "string")
+                    session.complete = false;
+                else if (workerRoles.has(args.subagent_type)) {
+                    if (typeof child === "string")
+                        session.tasks.push(child);
+                    else
+                        session.complete = false;
+                }
+            }
+            if (["edit", "write", "apply_patch"].includes(tool)) {
+                const metadata = object(state.metadata);
+                const changed = typeof metadata?.diff === "string" && /^[+-](?![+-])/mu.test(metadata.diff) ||
+                    Array.isArray(metadata?.files) && metadata.files.some((file) => {
+                        const entry = object(file);
+                        return typeof entry?.diff === "string" && /^[+-](?![+-])/mu.test(entry.diff);
+                    });
+                if (changed)
+                    session.mutations.push(interval);
+                else
+                    session.complete = false;
+            }
+            if (tool === "bash" && typeof args?.command === "string") {
+                const metadata = object(state.metadata);
+                const exit = metadata?.exit ?? metadata?.exitCode;
+                if (typeof exit === "number" && Number.isInteger(exit)) {
+                    session.checks.push({ ...interval, command: fingerprint(args.command), passed: exit === 0 });
+                    if (exit !== 0)
+                        session.failed = true;
+                }
+                else
+                    session.complete = false;
+            }
+            // Only accepted controller outputs prove a review. Reviewer prose and tool input cannot do so.
+            if (tool === "sortie_accept_luna_fabric_candidate" && typeof state.output === "string" && state.output.length <= 32768) {
+                try {
+                    const output = object(JSON.parse(state.output));
+                    const fabric = object(output?.fabric);
+                    const review = object(fabric?.review);
+                    if (output?.status === "accepted" && review?.status === "pass")
+                        session.reviews.push({ at: interval.end, status: "PASS" });
+                    else if (output?.status === "accepted" && review?.status === "skip")
+                        session.reviews.push({ at: interval.end, status: "WAIVED" });
+                    else if (output?.status === "rejected" && review?.status === "fail")
+                        session.reviews.push({ at: interval.end, status: "FAIL" });
+                }
+                catch { /* Unknown evidence stays unknown. */ }
+            }
+        }
+        if (session.spans.length > 4096 || calls.size > 4096) {
+            session.complete = false;
+            session.timingComplete = false;
+            break;
+        }
+    }
+    return session;
+}
+export function buildDebrief(receipt, contract, observation, records) {
+    const empty = { pack: null, mix: null, validation: "未確認", review: "未確認", traits: [] };
+    if (observation === undefined)
+        return empty;
+    const sessions = observation.sessions;
+    const complete = observation.complete && sessions.every((session) => session.complete);
+    const timingComplete = observation.complete && sessions.every((session) => session.timingComplete);
+    const children = sessions.filter((session) => !session.root && session.spans.length > 0);
+    const counts = new Map(), totals = new Map();
+    let usageComplete = timingComplete;
+    for (const session of sessions) {
+        for (const [model, tokens] of Object.entries(session.models)) {
+            if (tokens === null || model === "未分類")
+                usageComplete = false;
+            else
+                totals.set(model, (totals.get(model) ?? 0) + tokens);
+        }
+    }
+    for (const session of children) {
+        const models = Object.keys(session.models);
+        const label = models.length === 0 ? "未分類" : models.length === 1 ? models[0] : "混成";
+        counts.set(label, (counts.get(label) ?? 0) + 1);
+    }
+    const total = [...totals.values()].reduce((sum, tokens) => sum + tokens, 0);
+    const commands = new Set(contract?.criteria.flatMap((criterion) => criterion.validation_command === undefined ? [] : [fingerprint(criterion.validation_command)]));
+    const checks = sessions.flatMap((session) => session.checks.filter((check) => commands.has(check.command))).sort((a, b) => a.end - b.end);
+    const latest = new Map();
+    for (const check of checks)
+        latest.set(check.command, check);
+    const validation = [...latest.values()].some((check) => !check.passed) ? "FAIL"
+        : complete && commands.size > 0 && latest.size === commands.size ? "PASS" : "未確認";
+    const reviews = sessions.flatMap((session) => session.reviews).sort((a, b) => a.at - b.at);
+    const traits = [];
+    const spans = children.flatMap((session) => session.spans.filter((span) => span.end > span.start)
+        .map((span) => ({ ...span, session: session.id }))).sort((a, b) => a.start - b.start);
+    let furthest;
+    for (const span of spans) {
+        if (furthest !== undefined && span.session !== furthest.session && span.start < furthest.end) {
+            traits.push("連携作戦");
+            break;
+        }
+        if (furthest === undefined || span.end > furthest.end)
+            furthest = span;
+    }
+    // Same child and exact declared validator: never combine a sibling's failure with another candidate's success.
+    const recovered = children.some((session) => {
+        const failures = new Map();
+        const mutations = [...session.mutations].sort((a, b) => a.end - b.end);
+        let index = 0, lastEditStart = -1;
+        for (const check of [...session.checks].sort((a, b) => a.start - b.start)) {
+            while (index < mutations.length && mutations[index].end <= check.start) {
+                lastEditStart = Math.max(lastEditStart, mutations[index++].start);
+            }
+            if (!commands.has(check.command))
+                continue;
+            if (!check.passed)
+                failures.set(check.command, check.end);
+            else if (failures.has(check.command) && lastEditStart >= failures.get(check.command))
+                return true;
+        }
+        return false;
+    });
+    if (complete && receipt.status === "succeeded" && validation === "PASS" && recovered)
+        traits.push("修正から復帰");
+    // Only the complete, terminal-matched goal ledger can prove absence of retries; old/missing ledgers cannot.
+    const events = records?.filter(({ event }) => event.goal_id === receipt.goal_id && event.kind !== "goal.reported").map(({ event }) => event);
+    const reserved = events?.filter((event) => event.kind === "dispatch.reserved") ?? [];
+    const settled = events?.filter((event) => event.kind === "unit.settled") ?? [];
+    const tasks = sessions.flatMap((session) => session.tasks);
+    const terminal = events?.at(-1);
+    const fullLedger = events?.[0]?.kind === "goal.accepted" && terminal?.kind === "goal.terminal" &&
+        terminal.receipt.terminal_revision === receipt.terminal_revision && terminal.receipt.status === receipt.status;
+    const firstPassEligible = complete && fullLedger && receipt.status === "succeeded" && commands.size > 0 &&
+        validation === "PASS" && reserved.length > 0 && reserved.length === settled.length && tasks.length === reserved.length;
+    if (firstPassEligible &&
+        reserved.length === settled.length && tasks.length === reserved.length && new Set(tasks).size === tasks.length &&
+        settled.every((event) => event.disposition === "succeeded" && event.result_class === "acceptance") &&
+        !events?.some((event) => event.kind === "goal.replanned" || event.kind === "goal.user-continued" || event.kind === "goal.revised" ||
+            (event.kind === "validation.admission" && event.decision === "DENY") || (event.kind === "validation.settled" && event.outcome !== "passed")) &&
+        sessions.every((session) => !session.failed && new Set(session.checks.map((check) => check.command)).size === session.checks.length))
+        traits.push("一発完遂");
+    return { pack: timingComplete ? [...counts].sort(([a], [b]) => a.localeCompare(b)).map(([model, count]) => ({ model, count })) : null,
+        mix: usageComplete && total > 0 ? [...totals].sort(([a], [b]) => a.localeCompare(b)).map(([model, tokens]) => ({ model, tokens, percent: tokens / total * 100 })) : null,
+        validation, review: complete ? reviews.filter((review) => !sessions.some((session) => session.mutations.some((edit) => edit.end > review.at))).at(-1)?.status ?? "未確認" : "未確認", traits, firstPassEligible,
+        ...(timingComplete ? { overlap: { workerMilliseconds: children.reduce((sum, child) => sum + unionDuration(child.spans), 0),
+                wallMilliseconds: unionDuration(spans) } } : {}) };
+}
+const label = (text) => text.replace(/[\r\n\t]/gu, " ").replace(/[\\`*_{}\[\]()<>!|]/gu, "").slice(0, 120);
+export function renderDebrief(debrief) {
+    const pack = debrief?.pack == null ? null : [...debrief.pack].sort((a, b) => b.count - a.count || a.model.localeCompare(b.model));
+    const packVisible = pack?.slice(0, 4) ?? [];
+    if (pack !== null && pack.length > 4)
+        packVisible.push({ model: "その他", count: pack.slice(4).reduce((sum, entry) => sum + entry.count, 0) });
+    const mix = debrief?.mix == null ? null : [...debrief.mix].sort((a, b) => b.tokens - a.tokens || a.model.localeCompare(b.model));
+    const visible = mix?.slice(0, 4) ?? [];
+    if (mix !== null && mix.length > 4)
+        visible.push({ model: "その他", tokens: mix.slice(4).reduce((sum, entry) => sum + entry.tokens, 0),
+            percent: mix.slice(4).reduce((sum, entry) => sum + entry.percent, 0) });
+    const bars = (percent) => {
+        const filled = Math.max(0, Math.min(10, Math.round(percent / 10)));
+        return "█".repeat(filled) + "░".repeat(10 - filled);
+    };
+    return [
+        `**🐕 出撃隊:** ${pack === null ? "計測不可" : pack.length === 0 ? "出撃なし" : packVisible.map((entry) => `${label(entry.model)} ×${entry.count}`).join(" · ")}`,
+        `**モデル別token内訳:** ${mix === null ? "計測不可" : ""}`,
+        ...visible.map((entry) => `**↳** ${label(entry.model)} \`${bars(entry.percent)}\` ${entry.percent.toFixed(1)}%`),
+        `**実行重複率:** ${debrief?.overlap !== undefined && debrief.overlap.wallMilliseconds > 0
+            ? `${(debrief.overlap.workerMilliseconds / debrief.overlap.wallMilliseconds).toFixed(2)}×（worker区間・速度倍率ではありません）` : "計測不可"}`,
+        `**確認:** 対象検証 ${debrief?.validation ?? "未確認"} · 直近Review ${debrief?.review === "WAIVED" ? "免除" : debrief?.review ?? "未確認"}`,
+        ...(debrief?.traits.length ? [`**🏅 今回の戦績:** ${debrief.traits.join(" · ")}`] : []),
+    ];
+}

package/dist/runtime-assets.d.ts

@@ -7,7 +7,7 @@ export interface RuntimeAsset {
 }
 export declare const runtimeAssets: readonly [{
     readonly name: "dog-coordinator";
-    readonly version: "0.3.80-review-evidence-v1";
+    readonly version: "0.3.81-mission-debrief-v1";
     readonly installPath: "agent/dog-coordinator.md";
     readonly content: `---
 description: Canonical MkII coordinator packaged by Sortie-dogs
@@ -1402,8 +1402,14 @@ END_COMMIT_SCOPE_FIXTURE
 At each checkpoint and terminal return, preserve concise proof internally. The user-facing terminal
 return MUST begin with its conclusion: no plan, progress, assessment, Evidence heading, or preamble.
 Use exactly one of DONE, INTERRUPTED, BLOCKED, or NEED_DECISION with one status emoji and a short
-Japanese conclusion. Then render Japanese \u5909\u66F4\u70B9, \u78BA\u8A8D\u7D50\u679C, and \u6B21 paragraphs without bullets or extra
-emoji. The plugin injects measured Speed, Cost, and \u9054\u6210 paragraphs. Do not estimate or fabricate them.
+Japanese conclusion. Then render Japanese \u5909\u66F4\u70B9, \u78BA\u8A8D\u7D50\u679C, and \u6B21 paragraphs without bullets or decorative
+emoji. The plugin injects measured Speed, Cost, and \u9054\u6210 paragraphs in a Japanese mission debrief card,
+with one fixed icon per section, observed pack/model usage, validation/review, and evidence-backed traits.
+Its Markdown token bars and PACK RECORD summarize retained project goals, with coverage and team titles;
+they never imply lifetime history, XP, levels, unmeasured savings, or a leaderboard rank.
+Never write the card, its metrics, or its badges yourself. Do not estimate or fabricate them.
+Use \u4EFB\u52D9\u5B8C\u4E86 for DONE, \u4E2D\u65AD\u5E30\u9084\uFF08\u672A\u5B8C\u4E86\uFF09 for INTERRUPTED, \u5916\u90E8\u8981\u56E0\u3067\u5F85\u6A5F\uFF08\u672A\u5B8C\u4E86\uFF09 for BLOCKED,
+and \u6307\u793A\u5F85\u3061\uFF08\u672A\u5B8C\u4E86\uFF09 for NEED_DECISION; preserve the machine status token and first-line checkpoint.
 Never render a user-facing Evidence heading, <details> block, evidence reference, internal reason code,
 ledger key, or raw status. Keep ordered command/exit/fingerprint history, manifests, evidence refs,
 review proof, and terminal receipt append-only in their internal typed ledger and host logs. A concise
@@ -1423,10 +1429,10 @@ TERMINAL_STATUS_SEMANTICS_FIXTURE
 END_TERMINAL_STATUS_SEMANTICS_FIXTURE
 
 RUNTIME_ASSET_VERSION_SYNC_FIXTURE
-    runtime_version: 0.3.80-review-evidence-v1
+    runtime_version: 0.3.81-mission-debrief-v1
     shared_marker: src/asset-version.ts
-    packaged_expectation: test/plugin-loader.test.ts uses 0.3.80-review-evidence-v1
-    initialize_expectation: test/initialize.test.ts uses 0.3.80-review-evidence-v1
+    packaged_expectation: test/plugin-loader.test.ts uses 0.3.81-mission-debrief-v1
+    initialize_expectation: test/initialize.test.ts uses 0.3.81-mission-debrief-v1
     rule: runtime asset versions, shared marker, packaged expectation, and initialize expectation change together
 END_RUNTIME_ASSET_VERSION_SYNC_FIXTURE
 
@@ -1449,32 +1455,32 @@ END_INTERNAL_TERMINAL_PROOF_FIXTURE
 `;
 }, {
     readonly name: "dog-worker";
-    readonly version: "0.3.80-review-evidence-v1";
+    readonly version: "0.3.81-mission-debrief-v1";
     readonly installPath: "agent/dog-worker.md";
     readonly content: string;
 }, {
     readonly name: "dog-luna-worker";
-    readonly version: "0.3.80-review-evidence-v1";
+    readonly version: "0.3.81-mission-debrief-v1";
     readonly installPath: "agent/dog-luna-worker.md";
     readonly content: string;
 }, {
     readonly name: "dog-scout";
-    readonly version: "0.3.80-review-evidence-v1";
+    readonly version: "0.3.81-mission-debrief-v1";
     readonly installPath: "agent/dog-scout.md";
     readonly content: "---\ndescription: Bounded evidence scout for dog-coordinator\nmode: subagent\nsteps: 8\npermission:\n  bash: deny\n  webfetch: deny\n  task: deny\n  question: deny\n  glob: deny\n  grep: deny\n  edit: deny\n  list: deny\n  write: deny\n  patch: deny\ntools:\n  bash: false\n  webfetch: false\n  task: false\n  question: false\n  glob: false\n  grep: false\n  edit: false\n  list: false\n  write: false\n  patch: false\n---\n# dog-scout\n\nAccept one concrete missing_evidence_code: manifest, validation, or owner-risk. Accept only an\nexplicit absolute project_root and a known_paths list of at most four paths from dog-coordinator.\nResolve only that evidence key from those paths under project_root; never resolve a path against the\nsession directory. Use Read only, with at most 120 lines and no more than one read per supplied path.\nDo not resolve a second key, explore, invoke another tool, retry, edit, stage, commit, or become user-facing.\n\nWhen project_root is missing, or a supplied path does not resolve under it, or a resolved path is\nunreadable, report that dispatch defect as the facts for the requested key and name the exact paths.\nDo not retry, guess another root, or answer from an unread path.\n\nReturn exactly one concise JSON object of at most 800 characters with exactly these keys:\nmissing_evidence_code, facts, evidence_paths, risks. Use no Markdown, code fence, commentary, or raw log. Return it only\nto dog-coordinator. Write the facts and risks prose in the language the dispatch uses for its own\nprose; keep the keys, paths, commands, and identifiers verbatim.\n";
 }, {
     readonly name: "dog-reviewer";
-    readonly version: "0.3.80-review-evidence-v1";
+    readonly version: "0.3.81-mission-debrief-v1";
     readonly installPath: "agent/dog-reviewer.md";
     readonly content: "---\ndescription: Independent source reviewer for dog-coordinator\nmode: subagent\npermission:\n  bash: deny\n  webfetch: deny\n  task: deny\n  question: deny\n  glob: deny\n  grep: deny\n  edit: deny\n  list: deny\n  write: deny\n  patch: deny\n  read: deny\ntools:\n  bash: false\n  webfetch: false\n  task: false\n  question: false\n  glob: false\n  grep: false\n  edit: false\n  list: false\n  write: false\n  patch: false\n  read: false\n---\n# dog-reviewer\n\nAccept only one bounded SourceReview request from dog-coordinator after canonical\nvalidation for one high-risk candidate. Review only the supplied acceptance criteria, exact\nmanifest, changedLogicSummary, supplied changed-code excerpts, and validation evidence. Confirm every acceptance item explicitly\nmaps to at least one changedLogicSummary entry and assess that changed logic against the mapped\nacceptance item. Missing or incomplete coverage is a concrete finding, never PASS.\nRequire one indexed acceptance[i] -> changedLogicSummary[j] mapping line per acceptance item and\nreject a missing index or unequal mapping count before assessing the changed logic.\nDo not request raw logs or full source files, review low-risk candidates, expand scope, or dispatch\nanother agent.\nTreat those supplied fields as the complete bounded SourceReview artifact; use only that artifact and invoke no tools.\nDo not infer that a branch or exemption is absent from source because a prose summary omits it.\nIf the supplied excerpts do not establish a claim, report an evidence gap and request the exact\nbranch/helper excerpt in the next artifact; do not prescribe a source fix for an unproven defect.\n\nReturn one concise PASS or concrete-finding response only to dog-coordinator before the\ncoordinator commit. Write every finding, evidence, and required-fix sentence in the language the\nsupplied artifact uses for its own prose, one statement per line, and keep verdict values,\nidentifiers, paths, and commands verbatim. Do not implement, remediate, resolve blockers, edit,\nstage, commit, or become user-facing. Remain host-routed: do not require or identify a provider, vendor, model, variant,\nor transport.\n";
 }, {
     readonly name: "dog-advisor";
-    readonly version: "0.3.80-review-evidence-v1";
+    readonly version: "0.3.81-mission-debrief-v1";
     readonly installPath: "agent/dog-advisor.md";
     readonly content: "---\ndescription: Focused technical advisor for dog-coordinator\nmode: subagent\npermission:\n  bash: deny\n  webfetch: deny\n  task: deny\n  question: deny\n  glob: deny\n  grep: deny\n  edit: deny\n  list: deny\n  write: deny\n  patch: deny\n  read: deny\ntools:\n  bash: false\n  webfetch: false\n  task: false\n  question: false\n  glob: false\n  grep: false\n  edit: false\n  list: false\n  write: false\n  patch: false\n  read: false\n---\n# dog-advisor\n\nAccept only one bounded Strategy request from dog-coordinator for one candidate and one focused\nquestion. Use only the supplied acceptance criteria, exact manifest, constraints, and concise\nevidence. Do not request raw logs or full source files, expand scope, or dispatch another agent.\nTreat those supplied fields as the complete bounded Strategy artifact; use only that artifact and invoke no tools.\nReject every SourceReview request and return the rejection only to dog-coordinator; SourceReview is\ndog-reviewer-only work.\n\nReturn concise options and one recommendation only to dog-coordinator. Write every option,\nrecommendation, and consideration in the language the supplied request uses for its own prose, one\nstatement per line, and keep identifiers, paths, and commands verbatim. Do not perform\nSourceReview, implement, remediate, resolve blockers, edit, stage, commit, or become user-facing.\nImplementation remains dog-worker work. Remain host-routed: do not require or identify a\nprovider, vendor, model, variant, or transport.\n";
 }, {
     readonly name: "sortie";
-    readonly version: "0.3.80-review-evidence-v1";
+    readonly version: "0.3.81-mission-debrief-v1";
     readonly installPath: "command/sortie.md";
     readonly content: "---\ndescription: Start the canonical Sortie-dogs MkII workflow\nagent: dog-coordinator\n---\nRequest: $ARGUMENTS\n\n1. If $ARGUMENTS is empty, request task context and stop; give project init guidance first.\n2. Do not preflight installed runtime assets. The plugin reports version skew without adding model\n   turns; proceed from task evidence and project instructions.\n3. On restart or re-entry, reconstruct context from project-local durable artifacts and the\n   latest bounded handoff or checkpoint. Preserve both manifests and ordered validation history;\n   resume the same task through dog-coordinator with only the required delta.\n4. Otherwise transfer request and project context to dog-coordinator. Frontmatter is the single coordinator\n   transfer; never route a worker to the user.\n";
 }];

package/dist/runtime-assets.js

@@ -1,5 +1,5 @@
 import { GOAL_DECLARATION_FORMAT } from "./core/goal-declaration-format.js";
-const ASSET_VERSION = "0.3.80-review-evidence-v1";
+const ASSET_VERSION = "0.3.81-mission-debrief-v1";
 // Kept local so source-mode CLI execution does not load the plugin graph.
 const BACKLOG_DRAIN_CAPABILITY = "sortie_enable_backlog_drain";
 const PARALLEL_PREPARE_CAPABILITY = "sortie_prepare_parallel_dispatch";
@@ -1609,8 +1609,14 @@ END_COMMIT_SCOPE_FIXTURE
 At each checkpoint and terminal return, preserve concise proof internally. The user-facing terminal
 return MUST begin with its conclusion: no plan, progress, assessment, Evidence heading, or preamble.
 Use exactly one of DONE, INTERRUPTED, BLOCKED, or NEED_DECISION with one status emoji and a short
-Japanese conclusion. Then render Japanese 変更点, 確認結果, and 次 paragraphs without bullets or extra
-emoji. The plugin injects measured Speed, Cost, and 達成 paragraphs. Do not estimate or fabricate them.
+Japanese conclusion. Then render Japanese 変更点, 確認結果, and 次 paragraphs without bullets or decorative
+emoji. The plugin injects measured Speed, Cost, and 達成 paragraphs in a Japanese mission debrief card,
+with one fixed icon per section, observed pack/model usage, validation/review, and evidence-backed traits.
+Its Markdown token bars and PACK RECORD summarize retained project goals, with coverage and team titles;
+they never imply lifetime history, XP, levels, unmeasured savings, or a leaderboard rank.
+Never write the card, its metrics, or its badges yourself. Do not estimate or fabricate them.
+Use 任務完了 for DONE, 中断帰還（未完了） for INTERRUPTED, 外部要因で待機（未完了） for BLOCKED,
+and 指示待ち（未完了） for NEED_DECISION; preserve the machine status token and first-line checkpoint.
 Never render a user-facing Evidence heading, <details> block, evidence reference, internal reason code,
 ledger key, or raw status. Keep ordered command/exit/fingerprint history, manifests, evidence refs,
 review proof, and terminal receipt append-only in their internal typed ledger and host logs. A concise

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",