sortie-dogs 0.12.13 → 0.12.15

package/dist/asset-version.d.ts

@@ -3,5 +3,5 @@
  * installed project marker without importing every asset body.
  */
 export declare const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export declare const V010_RUNTIME_ASSET_VERSION = "0.12.13-mission-cold-recovery-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.15-review-lineage-model-gauges-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,4 +3,4 @@
  * installed project marker without importing every asset body.
  */
 export const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export const V010_RUNTIME_ASSET_VERSION = "0.12.13-mission-cold-recovery-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.15-review-lineage-model-gauges-v1";

package/dist/core/operator-mission.d.ts

@@ -46,6 +46,8 @@ export interface OperatorMission {
         verdict: "pending" | "PASS" | "findings" | "evidence-gaps" | "skipped-low-risk";
         result?: string;
         child?: string;
+        /** Completed, independent initial review for this mission, not merely an inherited child ID. */
+        initialPrompt?: string;
         /** Reviews on this mission that found only missing evidence; bounded by MISSION_EVIDENCE_GAP_REVIEW_LIMIT. */
         evidenceGapReviews?: number;
     };

package/dist/core/operator-mission.js

@@ -358,6 +358,8 @@ export function missionPacket(mission, run) {
         ...(run ? { run_id: run.runID, status: run.phase, decision: run.decision,
             units: run.units.map(unit => ({ id: unit.unit.id, title: unit.unit.title, status: unit.status,
                 child_session_id: unit.childSessionID, result_class: unit.resultClass, evidence: unit.evidence,
+                handoff_path: unit.handoffPath, operation_manifest_path: unit.manifestPath,
+                scope_read: unit.unit.read, scope_write: unit.unit.write, validation: unit.unit.validation,
                 ...(unit.dispatchDenial ? { dispatch_denial: unit.dispatchDenial } : {}) })) } : {}),
         next_action: mission.phase === "completed" ? "Mission completed. Report the accepted result and retained review gaps; no further dispatch or completion call is needed."
             : mission.phase === "submitted" && mission.submission?.status === "ready"

package/dist/core/operator-runtime.d.ts

@@ -340,6 +340,8 @@ export declare class OperatorRuntime {
     completionGoalFingerprint(state: OperatorState): Promise<string>;
     verifyContinuityControls(state: OperatorState): Promise<void>;
     packet(state: OperatorState): unknown;
+    /** Reconstruct the admitted child's instructions without trusting a lossy conversation summary. */
+    workerContext(root: string, child: string): Promise<string | undefined>;
     continuationCheckpoint(root: string): Promise<string | undefined>;
     private verifyControls;
     /** Follow only the host's authorized parent-link repair; keep the durable control pin in sync. */

package/dist/core/operator-runtime.js

@@ -1919,6 +1919,26 @@ export class OperatorRuntime {
             throw new Error("operator-packet-too-large-no-evidence-truncated");
         return packet;
     }
+    /** Reconstruct the admitted child's instructions without trusting a lossy conversation summary. */
+    async workerContext(root, child) {
+        const state = await this.read(root);
+        if (!state || state.phase !== "running")
+            return undefined;
+        const unit = state.units.find(item => item.childSessionID === child && item.status === "running");
+        if (!unit)
+            return undefined;
+        // Keep this prefix stable across reads/edits: changing counters belong in status/tool results.
+        return `SORTIE_WORKER_CONTEXT\n${JSON.stringify({ root_session_id: root, run_id: state.runID,
+            unit_id: unit.unit.id, task_id: /^task_id: (.+)$/m.exec(unit.task.prompt)?.[1],
+            project_root: this.projectRoot, handoff_path: unit.handoffPath, operation_manifest: unit.manifestPath,
+            objective: unit.unit.objective, read: unit.unit.read, write: unit.unit.write,
+            validation: unit.unit.validation, acceptance: state.acceptance,
+            ...(unit.repairValidation === null ? {} : { validation_only: true }),
+        })}\nThis is the durable assignment for this same Worker, including after compaction or reload. ` +
+            "A missing path in a summary does not mean the handoff is missing. Read the retained handoff/manifest and inspect the actual diff and outputs before claiming no edits or replaying work. " +
+            `Use ${this.profile.toolPrefix}operator_status for observed validation and remaining work; do not repeat successful checks for an unchanged candidate. ` +
+            "This context is an assignment, not proof of execution or acceptance.";
+    }
     async continuationCheckpoint(root) {
         const state = await this.read(root);
         const cancelledRemediation = state?.phase === "cancelled" &&

package/dist/plugin/mission-progress.d.ts

@@ -1,5 +1,6 @@
-/** Display-only native Task progress. Never prompts a model or changes execution ownership. */
 type Sink = (value: Record<string, unknown>) => Promise<void>;
 export declare function bindMissionProgress(root: string, sink: Sink): () => void;
 export declare function publishMissionProgress(root: string, value: Record<string, unknown>): Promise<void>;
+/** Read durable transitions even when settlement ran in a different/reloaded plugin instance. */
+export declare function missionProgressReader(directory: string, root: string, callID: string): () => Promise<Record<string, unknown> | undefined>;
 export {};

package/dist/plugin/mission-progress.js

@@ -1,3 +1,7 @@
+/** Display-only native Task progress. Never prompts a model or changes execution ownership. */
+import { OperatorMissionRuntime } from "../core/operator-mission.js";
+import { OperatorRuntime } from "../core/operator-runtime.js";
+import { V010_RUNTIME_PROFILE } from "../core/runtime-profile.js";
 const sinks = new Map();
 export function bindMissionProgress(root, sink) {
     sinks.set(root, sink);
@@ -7,3 +11,27 @@ export function bindMissionProgress(root, sink) {
 export async function publishMissionProgress(root, value) {
     await sinks.get(root)?.(value).catch(() => undefined);
 }
+/** Read durable transitions even when settlement ran in a different/reloaded plugin instance. */
+export function missionProgressReader(directory, root, callID) {
+    const missions = new OperatorMissionRuntime(directory, V010_RUNTIME_PROFILE);
+    return async () => {
+        const mission = await missions.read(root);
+        if (!mission || mission.callID !== callID)
+            return undefined;
+        // OperatorRuntime caches its own writes; a display observer must read a fresh disk snapshot.
+        const run = await new OperatorRuntime(directory, V010_RUNTIME_PROFILE).read(root);
+        const units = run?.runID === mission.runID ? run.units : [];
+        const running = units.find(unit => unit.status === "running");
+        const last = mission.progress.at(-1);
+        const status = running ? "running" : last?.status ?? mission.phase;
+        const title = running?.unit.title ?? last?.title ?? mission.requirements[0]?.text ?? "Coordinator";
+        return { description: `🐾 ${status}: ${title}`, sortie_progress: {
+                mission_id: mission.id, phase: mission.phase, unit: running ? `${run.runID}/${running.unit.id}` : last?.unit ?? null,
+                title, status, child_session_id: running?.childSessionID ?? null,
+                completed_units: units.filter(unit => unit.status === "succeeded").length,
+                failed_units: units.filter(unit => unit.status === "failed").length,
+                historical_failed_attempts: mission.progress.filter(unit => unit.status === "failed").length,
+                accepted: mission.phase === "completed",
+            } };
+    };
+}

package/dist/plugin/mission-review.d.ts

@@ -1,6 +1,8 @@
 import type { OperatorState } from "../core/operator-runtime.js";
 import { type OperatorMission } from "../core/operator-mission.js";
 import { type RuntimeProfile } from "../core/runtime-profile.js";
+/** A child ID alone cannot establish the initial phase after a restart or failed dispatch. */
+export declare function initialMissionReviewPrompt(mission: OperatorMission, prompts: readonly string[]): string | undefined;
 /** Recover from native completion records, never from the pending review's inherited child ID. */
 export declare function completedMissionReviewPrompts(mission: OperatorMission | undefined, profile: RuntimeProfile, root: string, requestedPrompt: string, host: {
     get(id: string): Promise<unknown>;

package/dist/plugin/mission-review.js

@@ -12,11 +12,21 @@ import { normalizeManifestScope } from "../core/path.js";
 import { declaredArtifacts } from "./declared-artifacts.js";
 const exec = promisify(execFile);
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/** A child ID alone cannot establish the initial phase after a restart or failed dispatch. */
+export function initialMissionReviewPrompt(mission, prompts) {
+    return [mission.review?.initialPrompt, ...prompts].find(prompt => typeof prompt === "string" &&
+        prompt.startsWith(`candidate_id: ${mission.id}\n`) && /^review_phase: initial$/mu.test(prompt) &&
+        /^canonical_validation_exit: 0$/mu.test(prompt));
+}
 /** Recover from native completion records, never from the pending review's inherited child ID. */
 export async function completedMissionReviewPrompts(mission, profile, root, requestedPrompt, host) {
     if (!mission || mission.root !== root || !mission.coordinator || ["completed", "cancelled"].includes(mission.phase) ||
         mission.review?.task?.prompt !== requestedPrompt)
         return [];
+    // The completion hook has already bound this prompt to a real independent Reviewer child.
+    // Avoid a second V2 history read when its page/list API is temporarily unavailable.
+    if (initialMissionReviewPrompt(mission, []))
+        return [mission.review.initialPrompt];
     const coordinator = await host.get(mission.coordinator);
     if (!record(coordinator) || coordinator.parentID !== root || canonicalAgent(profile, coordinator.agent) !== "dog-operator")
         return [];

package/dist/plugin/profiled.js

@@ -14,7 +14,7 @@ import { normalizeCommand } from "./gate.js";
 import { normalizeRelativePath } from "../core/path.js";
 import { MISSION_EVIDENCE_GAP_REVIEW_LIMIT, OperatorMissionRuntime, missionPacket, missionPlan, missionReviewAccepted, missionReviewTask, missionReviewTraces, missionReviewVerdict } from "../core/operator-mission.js";
 import { publishMissionProgress } from "./mission-progress.js";
-import { completedMissionReviewPrompts, missionReviewSource } from "./mission-review.js";
+import { completedMissionReviewPrompts, initialMissionReviewPrompt, missionReviewSource } from "./mission-review.js";
 import { missionLocations, missionLocationPacket } from "./mission-location.js";
 import { SOURCE_REVIEW_RISK_TAGS } from "../core/consultation.js";
 import { createHash } from "node:crypto";
@@ -184,6 +184,10 @@ export function createProfiledPlugin(profile, assetVersion) {
             const result = payload(await session("messages", { path: { id }, query: { directory: input.directory } }));
             return Array.isArray(result) ? result.filter(record) : [];
         }
+        async function reviewMessages(id) {
+            const result = payload(await session(typeof nativeSession?.reviewMessages === "function" ? "reviewMessages" : "messages", { path: { id }, query: { directory: input.directory } }));
+            return Array.isArray(result) ? result.filter(record) : [];
+        }
         async function identity(id) {
             const info = payload(await session("get", { path: { id }, query: { directory: input.directory } }));
             const parent = record(info) && typeof info.parentID === "string" ? info.parentID : undefined;
@@ -334,7 +338,7 @@ export function createProfiledPlugin(profile, assetVersion) {
             },
             completedReviewPrompts: async (root, prompt) => completedMissionReviewPrompts(await missions.read(root), profile, root, prompt, {
                 get: async (id) => payload(await session("get", { path: { id }, query: { directory: input.directory } })),
-                messages,
+                messages: reviewMessages,
             }),
             requiresExplicitAcceptance: async (root) => {
                 const mission = await missions.read(root);
@@ -1418,7 +1422,17 @@ export function createProfiledPlugin(profile, assetVersion) {
                         next_action: missionReviewAccepted(mission.review) ? "Review is already recorded for this unchanged candidate. Submit ready with any remaining gaps; do not repeat review."
                             : "Review is already recorded for this unchanged candidate. Address its findings or supply new evidence through traces; do not repeat the same review." });
                 }
-                const phase = mission.review?.child ? "verification" : "initial";
+                // An old child can belong to a previous run, while the fast-lane is reset on a new
+                // turn. Generate verification only when a completed initial review is recoverable;
+                // otherwise generate an admissible initial review instead of trapping the Coordinator.
+                const prior = mission.review?.task?.prompt;
+                const completed = risk.length > 0 && prior && mission.review?.child && !mission.review.initialPrompt
+                    ? await completedMissionReviewPrompts(mission, profile, root, prior, {
+                        get: async (id) => payload(await session("get", { path: { id }, query: { directory: input.directory } })),
+                        messages: reviewMessages,
+                    }).catch(() => []) : [];
+                const initialPrompt = initialMissionReviewPrompt(mission, completed);
+                const phase = initialPrompt ? "verification" : "initial";
                 const task = risk.length === 0 ? null : { subagent_type: profileAgent(profile, "dog-reviewer"),
                     description: `🔎 ${run.units[0].unit.title}`, prompt: [
                         `candidate_id: ${mission.id}`, `review_phase: ${phase}`, "canonical_validation_exit: 0", `risk_tags: [${risk.join(", ")}]`,
@@ -1434,6 +1448,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const reviewed = await missions.update(root, item => {
                     item.review = { runID: run.runID, risk: risk, source: source.fingerprint, requestFingerprint,
                         task, verdict: task ? "pending" : "skipped-low-risk", ...(mission.review?.child ? { child: mission.review.child } : {}),
+                        ...(initialPrompt ? { initialPrompt } : {}),
                         ...(mission.review?.evidenceGapReviews ? { evidenceGapReviews: mission.review.evidenceGapReviews } : {}) };
                 });
                 return JSON.stringify(task ? { status: "review-required", task: missionReviewTask(reviewed) } : { status: "skipped-low-risk" });
@@ -1982,6 +1997,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                                 if (mission.review.verdict === "evidence-gaps")
                                     mission.review.evidenceGapReviews = (mission.review.evidenceGapReviews ?? 0) + 1;
                                 mission.review.child = child;
+                                if (independent && last && child && mission.review.task?.prompt.startsWith(`candidate_id: ${mission.id}\nreview_phase: initial\n`)) {
+                                    mission.review.initialPrompt = mission.review.task.prompt;
+                                }
                             }
                         });
                         if (reviewed.review?.verdict === "evidence-gaps" && typeof output.output === "string") {
@@ -2112,6 +2130,11 @@ export function createProfiledPlugin(profile, assetVersion) {
                 (output.system ??= []).push(`SORTIE_RUNTIME_PROFILE ${profile.id}; marker ${assetVersion}. ` +
                     `Shared MkII protocol role names are logical: ${protocolMap}. Use only ${profile.toolPrefix} tools for this profile. ` +
                     "Never rewrite user acceptance or evidence to rename protocol roles. Final acceptance belongs only to the root coordinator.");
+                if ((await identity(request.sessionID)).role === "dog-worker") {
+                    const context = await operators.workerContext(root, request.sessionID);
+                    if (context)
+                        (output.system ??= []).push(context);
+                }
                 const proposal = await proposals.read(root);
                 if (proposal?.phase !== "approved" && proposal?.proposal_session_id === request.sessionID) {
                     // Only immutable identity and the frozen budget caps belong here. Consumed counters move with
@@ -2166,6 +2189,12 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const root = await rootFor(request.sessionID);
                 if (!root)
                     return;
+                if ((await identity(request.sessionID)).role === "dog-worker") {
+                    const context = await operators.workerContext(root, request.sessionID);
+                    if (context)
+                        (output.context ??= []).push(context +
+                            " Preserve the actual edits, tool outcomes and next action in the summary; do not replace them with an empty-work claim.");
+                }
                 if ((await identity(request.sessionID)).role === "dog-operator") {
                     const mission = await missions.read(root);
                     if (mission?.coordinator === request.sessionID) {

package/dist/plugin/run-metrics.js

@@ -206,8 +206,38 @@ export async function collectRunMetrics(client, rootSessionID, directory, now =
     for (const id of ids) {
         try {
             const messages = assistantMessages(await session.messages.call(session, { path: { id }, query: { directory } }));
-            if (messages === undefined)
-                return undefined;
+            if (messages === undefined) {
+                messagesComplete = false;
+                continue;
+            }
+            if (!hierarchyComplete && session.get !== undefined) {
+                // Some V2 plugin facades cannot list children. Recover recorded native dispatches
+                // during this same history pass, without rerunning work or discarding parent usage.
+                const recorded = new Set();
+                for (const message of messages)
+                    for (const raw of Array.isArray(message.parts) ? message.parts : []) {
+                        const part = record(raw), state = record(part?.state), metadata = record(state?.metadata);
+                        if (part?.type !== "tool" || part.tool !== "task")
+                            continue;
+                        const input = record(state?.input);
+                        for (const child of [metadata?.sessionId, metadata?.sessionID, input?.task_id]) {
+                            if (typeof child === "string" && child && !visited.has(child))
+                                recorded.add(child);
+                        }
+                    }
+                for (const child of recorded) {
+                    if (ids.length >= MAX_SESSIONS)
+                        break;
+                    try {
+                        const info = record(unwrap(await session.get.call(session, { path: { id: child }, query: { directory } })));
+                        if (info?.parentID !== id)
+                            continue;
+                        visited.add(child);
+                        ids.push(child);
+                    }
+                    catch { /* Keep this partial display; unobserved usage is never zero-filled. */ }
+                }
+            }
             const observed = observeDebriefSession(id, id === rootSessionID, messages, window === undefined ? undefined : { start: windowStart, end: windowEnd });
             observedSessions.push(observed);
             for (const message of messages) {
@@ -257,9 +287,9 @@ export async function collectRunMetrics(client, rootSessionID, directory, now =
                     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;
+                    const modelUsage = observed.modelUsage[modelKey] ??= { tokens: 0, uncachedInputTokens: 0, cacheReadTokens: 0,
+                        cacheWriteTokens: 0, cost: 0, costAvailable: true, estimatedCost: 0, pricedRequests: 0, unpricedRequests: 0 };
                     if (tokens !== undefined) {
-                        const modelUsage = observed.modelUsage[modelKey] ?? { tokens: 0, uncachedInputTokens: 0, cacheReadTokens: 0,
-                            cacheWriteTokens: 0, cost: 0, costAvailable: true, estimatedCost: 0, pricedRequests: 0, unpricedRequests: 0 };
                         modelUsage.tokens += tokens.total;
                         modelUsage.uncachedInputTokens += tokens.input;
                         modelUsage.cacheReadTokens += tokens.cacheRead;
@@ -289,29 +319,31 @@ export async function collectRunMetrics(client, rootSessionID, directory, now =
                         role.cacheReadTokens += tokens.cacheRead;
                         role.cacheWriteTokens += tokens.cacheWrite;
                     }
-                    else
+                    else {
                         tokensAvailable = false;
+                        modelUsage.unpricedRequests = (modelUsage.unpricedRequests ?? 0) + 1;
+                    }
                     const usageInfo = record(usage.value.info) ?? usage.value;
                     const reportedCost = number(usageInfo.cost) ?? number(usage.value.cost);
                     if (reportedCost === undefined) {
                         costAvailable = false;
                         role.costAvailable = false;
-                        if (tokens !== undefined)
-                            observed.modelUsage[modelKey].costAvailable = false;
+                        modelUsage.costAvailable = false;
                     }
                     else {
                         cost += reportedCost;
                         role.cost += reportedCost;
-                        if (tokens !== undefined)
-                            observed.modelUsage[modelKey].cost += reportedCost;
+                        modelUsage.cost += reportedCost;
                     }
                 }
             }
         }
         catch {
-            return undefined;
+            messagesComplete = false;
         }
     }
+    if (observedSessions.length === 0)
+        return undefined;
     let created;
     if (session.get !== undefined) {
         try {
@@ -388,6 +420,10 @@ export function formatSortieResult(result, presentation = {}) {
     const estimatedCost = estimate === undefined ? "計測不可"
         : estimate.pricedRequests === 0 ? "未換算"
             : `$${estimate.usd.toFixed(4)}${estimate.unpricedRequests > 0 ? "（一部未換算）" : ""}`;
+    const measuredTokens = result.debrief?.mixCoverage?.observedTokens;
+    const tokenText = result.cost.total_tokens.availability === "unavailable" && measuredTokens !== undefined && measuredTokens > 0
+        ? `${measuredTokens.toLocaleString("ja-JP")} tokens（観測分）`
+        : metricText(result.cost.total_tokens, (value) => `${value.toLocaleString("ja-JP")} tokens`);
     const body = [
         "🐾 SORTIE DOGS — 帰還報告",
         result.result_id[0],
@@ -411,7 +447,7 @@ export function formatSortieResult(result, presentation = {}) {
         displayText(presentation.next),
         "",
         "🪙 COST / PACK",
-        `使用量        ${metricText(result.cost.total_tokens, (value) => `${value.toLocaleString("ja-JP")} tokens`)}`,
+        `使用量        ${tokenText}`,
         `予測費用      ${estimatedCost} ※予測概算`,
         "",
         ...renderDebrief(result.debrief),

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

@@ -58,6 +58,11 @@ export interface Debrief {
         };
         readonly hostCostZero?: boolean;
     }[] | null;
+    /** Shares use observed tokens; incomplete history must not erase known model usage. */
+    readonly mixCoverage?: {
+        readonly complete: boolean;
+        readonly observedTokens: number;
+    };
     readonly estimatedCost?: {
         readonly usd: number;
         readonly pricedRequests: number;

package/dist/plugin/sortie-debrief.js

@@ -157,18 +157,22 @@ export function buildDebrief(receipt, contract, observation, records) {
         (session.spans.length > 0 || Object.keys(session.models).length > 0));
     const counts = new Map(), totals = new Map();
     const modelUsage = new Map();
-    let usageComplete = observation.complete;
+    let usageComplete = true;
     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);
-                const observed = session.modelUsage?.[model];
+            const observed = session.modelUsage?.[model];
+            // A missing request leaves models[model] null. The independent accumulator still
+            // contains real usage from this model's other requests, including older snapshots.
+            const measured = tokens ?? observed?.tokens;
+            if (measured !== undefined) {
+                if (measured > 0)
+                    totals.set(model, (totals.get(model) ?? 0) + measured);
                 const aggregate = modelUsage.get(model) ?? { uncachedInputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0,
                     cost: 0, costAvailable: true, estimatedCost: 0, pricedRequests: 0, unpricedRequests: 0,
                     pricingComplete: true, complete: true };
-                if (observed === undefined || observed.tokens !== tokens)
+                if (observed === undefined || observed.tokens !== measured)
                     aggregate.complete = false;
                 else {
                     aggregate.uncachedInputTokens += observed.uncachedInputTokens;
@@ -284,13 +288,14 @@ export function buildDebrief(receipt, contract, observation, records) {
         session.mutations.some((edit) => edit.end > entry.at))).at(-1);
     const packComplete = observation.complete && sessions.every(session => session.root || session.timingComplete || Object.keys(session.models).length > 0);
     return { pack: packComplete ? [...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]) => {
+        mix: total > 0 ? [...totals].sort(([a], [b]) => a.localeCompare(b)).map(([model, tokens]) => {
             const usage = modelUsage.get(model);
             return { model, tokens, percent: tokens / total * 100,
                 ...(usage?.complete ? { inputCache: { uncachedInputTokens: usage.uncachedInputTokens,
                         cacheReadTokens: usage.cacheReadTokens, cacheWriteTokens: usage.cacheWriteTokens } } : {}),
                 ...(usage?.complete && usage.costAvailable && tokens > 0 && usage.cost === 0 ? { hostCostZero: true } : {}) };
         }) : null,
+        mixCoverage: { complete: observation.complete && usageComplete, observedTokens: total },
         ...(pricing.complete && pricing.pricedRequests + pricing.unpricedRequests > 0 ? { estimatedCost: {
                 usd: pricing.usd, pricedRequests: pricing.pricedRequests, unpricedRequests: pricing.unpricedRequests
             } } : {}),
@@ -337,13 +342,15 @@ export function renderDebrief(debrief) {
         : value === "WAIVED" ? "免除" : "未記録";
     const counts = new Map(packVisible.map((entry) => [entry.model, entry.count]));
     return [
-        ...(mix === null ? ["モデル内訳    usage未取得"] : visible.map((entry) => {
+        `モデル内訳    ${mix === null ? "usage未取得" : debrief?.mixCoverage?.complete === false
+            ? "観測済みtoken比率（一部未取得）" : "token比率"}`,
+        ...visible.map((entry) => {
             const count = counts.get(entry.model);
             const input = entry.inputCache === undefined ? 0 : entry.inputCache.uncachedInputTokens +
                 entry.inputCache.cacheReadTokens + entry.inputCache.cacheWriteTokens;
             const cache = entry.inputCache === undefined || input === 0 ? "未取得" : `${(entry.inputCache.cacheReadTokens / input * 100).toFixed(0)}%`;
             return `🐕 ${label(entry.model)} ${gauge(entry.percent)} ${entry.percent.toFixed(1)}% ${entry.tokens.toLocaleString("ja-JP")} tokens${count === undefined ? "" : ` ×${count}`} ↺${cache}${entry.hostCostZero ? "†" : ""}`;
-        })),
+        }),
         ...(visible.some((entry) => entry.hostCostZero) ? ["   †host費用0計上あり（無料・全体価格の評価ではありません）"] : []),
         `⚡ 実行重複率 ${debrief?.overlap !== undefined && debrief.overlap.wallMilliseconds > 0
             ? `${(debrief.overlap.workerMilliseconds / debrief.overlap.wallMilliseconds).toFixed(2)}×`

package/dist/plugin/v2-session-history.d.ts

@@ -1,3 +1,4 @@
-import type { SessionListInput } from "@opencode/client";
-/** V2's plugin context can omit session.list even though the public client exposes it. */
+import type { SessionListInput, MessageListInput } from "@opencode/client";
 export declare function owningServiceSessionList(): (input: SessionListInput) => Promise<unknown>;
+/** Read-only paginated history for reviews older than V2's bounded session.context window. */
+export declare function owningServiceMessageList(): (input: MessageListInput) => Promise<unknown>;

package/dist/plugin/v2-session-history.js

@@ -1,23 +1,33 @@
 /** V2's plugin context can omit session.list even though the public client exposes it. */
-export function owningServiceSessionList() {
+function owningServiceClient() {
     let pending;
-    async function connect() {
-        const [{ Service }, { OpenCode }] = await Promise.all([import("@opencode/client/service"), import("@opencode/client")]);
-        // Discovery is read-only: never start, stop, or replace the user's server. A private server
-        // must not silently read the shared server's database, even if both contain the same IDs.
-        const endpoint = await Service.discover();
-        if (!endpoint)
-            throw new Error("v2-history-owning-service-unavailable");
-        const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) });
-        const info = await client.server.info({ signal: AbortSignal.timeout(10_000) });
-        if (info.pid !== process.pid)
-            throw new Error("v2-history-owning-service-unavailable");
-        return client;
-    }
-    return async (input) => {
-        const current = pending ??= connect();
-        const client = await current.catch(error => { if (pending === current)
+    return async () => {
+        const current = pending ??= (async () => {
+            const [{ Service }, { OpenCode }] = await Promise.all([import("@opencode/client/service"), import("@opencode/client")]);
+            // Discovery is read-only: never start, stop, or replace the user's server. A private server
+            // must not silently read the shared server's database, even if both contain the same IDs.
+            const endpoint = await Service.discover();
+            if (!endpoint)
+                throw new Error("v2-history-owning-service-unavailable");
+            const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) });
+            const info = await client.server.info({ signal: AbortSignal.timeout(10_000) });
+            if (info.pid !== process.pid)
+                throw new Error("v2-history-owning-service-unavailable");
+            return client;
+        })();
+        return current.catch(error => { if (pending === current)
             pending = undefined; throw error; });
+    };
+}
+export function owningServiceSessionList() {
+    const connect = owningServiceClient();
+    return async (input) => {
+        const client = await connect();
         return client.session.list(input, { signal: AbortSignal.timeout(10_000) });
     };
 }
+/** Read-only paginated history for reviews older than V2's bounded session.context window. */
+export function owningServiceMessageList() {
+    const connect = owningServiceClient();
+    return async (input) => (await connect()).message.list(input, { signal: AbortSignal.timeout(10_000) });
+}

package/dist/plugin/v2.js

@@ -1,6 +1,6 @@
 import { SortieDogsV010Plugin } from "./profiled.js";
-import { bindMissionProgress } from "./mission-progress.js";
-import { owningServiceSessionList } from "./v2-session-history.js";
+import { bindMissionProgress, missionProgressReader } from "./mission-progress.js";
+import { owningServiceMessageList, owningServiceSessionList } from "./v2-session-history.js";
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { V010_RUNTIME_ASSET_VERSION } from "../asset-version.js";
@@ -100,10 +100,11 @@ function legacyMessage(value, session, agent) {
             return converted === undefined ? [] : [converted];
         }) };
 }
-async function legacyMessages(context, id) {
+async function legacyMessages(context, id, paginated) {
+    const list = paginated ?? (context.message ? (input) => context.message.list(input) : undefined);
     const [info, history] = await Promise.all([
         context.session.get({ sessionID: id }).catch(() => undefined),
-        context.message ? nativePages(cursor => context.message.list({ sessionID: id, limit: 100, ...(cursor ? { cursor } : { order: "asc" }) }))
+        list ? nativePages(cursor => list({ sessionID: id, limit: 100, ...(cursor ? { cursor } : { order: "asc" }) }))
             : context.session.context({ sessionID: id }),
     ]);
     const agent = record(info) ? string(info.agent) : undefined;
@@ -133,6 +134,7 @@ async function nativePages(fetch) {
 function legacyClient(context) {
     const directory = context.location.directory;
     const list = owningServiceSessionList();
+    const reviewList = owningServiceMessageList();
     const session = {
         get: async (request) => {
             const id = sessionID(request);
@@ -142,6 +144,10 @@ function legacyClient(context) {
             const id = sessionID(request);
             return { data: id === undefined ? [] : await legacyMessages(context, id) };
         },
+        reviewMessages: async (request) => {
+            const id = sessionID(request);
+            return { data: id === undefined ? [] : await legacyMessages(context, id, context.message ? input => context.message.list(input) : reviewList) };
+        },
         message: async (request) => {
             const id = sessionID(request), wanted = messageID(request);
             return { data: id === undefined || wanted === undefined ? undefined
@@ -332,18 +338,50 @@ async function registerV2Hooks(context, hooks) {
                     return execute(value, execution);
                 const report = execution.progress;
                 let metadata = {};
-                const unbind = bindMissionProgress(String(execution.sessionID), async (progress) => {
-                    metadata = { ...metadata, ...progress };
-                    await report(metadata);
-                });
+                let pending = Promise.resolve();
+                const update = (update) => {
+                    metadata = { ...metadata, ...update };
+                    const snapshot = { ...metadata };
+                    pending = pending.catch(() => undefined).then(() => report(snapshot));
+                    return pending;
+                };
+                const unbind = bindMissionProgress(String(execution.sessionID), update);
+                const readProgress = missionProgressReader(context.location.directory, String(execution.sessionID), String(execution.id));
+                let previous = "", reading;
+                const refresh = () => {
+                    if (reading)
+                        return reading;
+                    reading = (async () => {
+                        try {
+                            const progress = await readProgress(), key = JSON.stringify(progress);
+                            if (progress && key !== previous) {
+                                await update(progress);
+                                previous = key;
+                            }
+                        }
+                        catch (error) {
+                            console.warn("[sortie-dogs-v010] mission progress unavailable", error instanceof Error ? error.message : "unknown");
+                        }
+                    })().finally(() => { reading = undefined; });
+                    return reading;
+                };
+                // The native executor is a stable snapshot. Poll only local durable state, not models or
+                // session status APIs; this also recovers progress after another plugin instance settles work.
+                const timer = setInterval(() => { void refresh(); }, 1000);
+                timer.unref();
                 try {
-                    return await execute(value, { ...execution, progress: async (update) => {
-                            metadata = { ...metadata, ...update };
-                            await report(metadata);
-                        } });
+                    await refresh();
+                    const result = await execute(value, { ...execution, progress: update });
+                    await refresh();
+                    await pending.catch(() => undefined);
+                    // Native completion replaces metadata, so retain our display fields alongside its own.
+                    return { ...result, metadata: { ...metadata, ...(record(result.metadata) ? result.metadata : {}) } };
                 }
                 finally {
+                    clearInterval(timer);
                     unbind();
+                    await reading;
+                    await pending.catch(() => undefined);
                 }
             };
         });

package/dist/runtime-mission-assets.js

@@ -117,6 +117,11 @@ You are Coordinator. Own most of the practical work and dispatch within the save
 Read/search and confirmation shell commands are available; source edits belong to Worker. Do not edit
 through shell. There is no proposal/approval/contract-repair round trip in this route.
 
+For release/benchmark work, resolve the package from its release receipt and hash, not a matching version
+or filename. Record the runner's own revision separately. Before repairing infrastructure on an old branch,
+check current main for an existing fix; preserve local edits and use a current-main worktree when needed.
+Report setup/route failures as such, with observed inference count, instead of calling runner exits a score.
+
 Investigate only enough to start the first useful Worker. Prefer a targeted read/reproduction over a broad
 inventory or speculative full design. Call ${profile.toolPrefix}plan_units with concise units:
 title, objective, read/write file or directory scopes, validation commands, optionally requirement_ids.

package/package.json

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