sortie-dogs 0.6.1 → 0.7.0

package/README.md

@@ -1,9 +1,13 @@
 # Sortie-dogs
 
-**Give OpenCode a task; get a bounded, validated implementation loop instead of an open-ended agent run.**
-
-> **Project status: Experimental / unsupported.** No stability, compatibility,
-> or support guarantees are provided. Mk2A2 remains the canonical internal workflow.
+**Give OpenCode a task; get a bounded, validated implementation loop instead of an open-ended agent run.**
+
+Sortie-dogs is an execution harness for OpenCode, applying harness-engineering
+principles through mechanical write boundaries, validation, review, and bounded
+orchestration.
+
+> **Project status: Beta.** Stable in regular use. As a pre-1.0 release,
+> configuration and runtime assets may still change between releases.
 
 [![npm](https://img.shields.io/npm/v/sortie-dogs)](https://www.npmjs.com/package/sortie-dogs)
 [![license](https://img.shields.io/npm/l/sortie-dogs)](LICENSE)
@@ -20,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.6.1](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.6.1)
+Release: [v0.7.0](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.7.0)
 
 ## 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.50-observability-reflection-v1";
+export declare const RUNTIME_ASSET_VERSION = "0.3.51-state-observability-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.50-observability-reflection-v1";
+export const RUNTIME_ASSET_VERSION = "0.3.51-state-observability-v1";

package/dist/core/retained-state.d.ts

@@ -0,0 +1,54 @@
+export declare const RETAINED_STATE_EXTENSION: "sortie-dogs/retained-state";
+export declare const RETAINED_STATE_SCHEMA_VERSION: "0.1";
+export declare const RETAINED_STATE_AUTHORITY: "shadow";
+export declare const MAX_RETAINED_STATE_BYTES: number;
+export declare const MAX_RETAINED_STATE_ITEMS = 12;
+export declare const MAX_RETAINED_STATE_WARNINGS = 8;
+export interface RetainedValidationAttempt {
+    readonly command: string;
+    readonly exit: number | null;
+    readonly fingerprint: string;
+}
+export interface NextEvidenceDecision {
+    readonly schema_version: "0.1";
+    readonly authority: "shadow";
+    readonly gap_id: string;
+    readonly blocked_acceptance: string;
+    readonly question: string;
+    readonly expected_discrimination: string;
+    readonly action: string;
+    readonly stop_condition: string;
+}
+export interface AdmissionReceipt {
+    readonly evidence_id: string;
+    readonly source_agent: string;
+    readonly source_revision: string;
+    readonly evidence_fingerprint: string;
+    readonly supports: readonly string[];
+    readonly contradicts: readonly string[];
+    readonly freshness_basis: string;
+    readonly status: "recorded" | "recorded_with_warnings";
+    readonly warnings: readonly string[];
+}
+export interface RetainedStateCapsule {
+    readonly schema_version: "0.1";
+    readonly authority: "shadow";
+    readonly task_id: string;
+    readonly acceptance_fingerprint: string;
+    readonly source_manifest: "none" | readonly string[];
+    readonly operation_manifest: "none" | string;
+    readonly validation_history: readonly RetainedValidationAttempt[];
+    readonly blockers: readonly string[];
+    readonly next_action: string;
+    readonly next_evidence_decision?: NextEvidenceDecision;
+    readonly admissions?: readonly AdmissionReceipt[];
+}
+export interface RetainedStateWarning {
+    readonly code: "malformed" | "oversize" | "optional_invalid";
+    readonly message: string;
+}
+export interface RetainedStateInspection {
+    readonly capsule: RetainedStateCapsule | undefined;
+    readonly warnings: readonly RetainedStateWarning[];
+}
+export declare function inspectRetainedStateCapsule(handoff: unknown): RetainedStateInspection;

package/dist/core/retained-state.js

@@ -0,0 +1,81 @@
+export const RETAINED_STATE_EXTENSION = "sortie-dogs/retained-state";
+export const RETAINED_STATE_SCHEMA_VERSION = "0.1";
+export const RETAINED_STATE_AUTHORITY = "shadow";
+export const MAX_RETAINED_STATE_BYTES = 16 * 1024;
+export const MAX_RETAINED_STATE_ITEMS = 12;
+export const MAX_RETAINED_STATE_WARNINGS = 8;
+const MAX_SHORT = 256;
+const MAX_TEXT = 1000;
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isText = (value, max = MAX_TEXT) => typeof value === "string" && value.length > 0 && value.length <= max;
+const isBoundedList = (value, max = MAX_RETAINED_STATE_ITEMS) => Array.isArray(value) && value.length <= max;
+const isSourceManifest = (value) => value === "none" || (isBoundedList(value) && value.length === new Set(value).size && value.every((item) => isText(item, 512)));
+function validAttempt(value) {
+    const exit = isObject(value) ? value.exit : undefined;
+    return isObject(value) && isText(value.command, 1000) && (exit === null || (typeof exit === "number" && Number.isInteger(exit) && exit >= -1 && exit <= 255)) && isText(value.fingerprint, MAX_SHORT);
+}
+function validDecision(value) {
+    return isObject(value) && value.schema_version === "0.1" && value.authority === "shadow" &&
+        isText(value.gap_id, MAX_SHORT) && isText(value.blocked_acceptance) && isText(value.question) &&
+        isText(value.expected_discrimination) && isText(value.action) && isText(value.stop_condition);
+}
+function validAdmission(value) {
+    return isObject(value) && isText(value.evidence_id, MAX_SHORT) && isText(value.source_agent, MAX_SHORT) &&
+        isText(value.source_revision, MAX_SHORT) && isText(value.evidence_fingerprint, MAX_SHORT) &&
+        isBoundedList(value.supports) && value.supports.every((item) => isText(item, MAX_SHORT)) &&
+        isBoundedList(value.contradicts) && value.contradicts.every((item) => isText(item, MAX_SHORT)) &&
+        isText(value.freshness_basis) && (value.status === "recorded" || value.status === "recorded_with_warnings") &&
+        isBoundedList(value.warnings, MAX_RETAINED_STATE_WARNINGS) && value.warnings.every((item) => isText(item, MAX_SHORT));
+}
+export function inspectRetainedStateCapsule(handoff) {
+    if (!isObject(handoff) || !isObject(handoff.ext) || !(RETAINED_STATE_EXTENSION in handoff.ext)) {
+        return { capsule: undefined, warnings: [] };
+    }
+    const raw = handoff.ext[RETAINED_STATE_EXTENSION];
+    let bytes;
+    try {
+        bytes = new TextEncoder().encode(JSON.stringify(raw)).byteLength;
+    }
+    catch {
+        return { capsule: undefined, warnings: [{ code: "malformed", message: "Retained state was ignored because it is malformed." }] };
+    }
+    if (bytes > MAX_RETAINED_STATE_BYTES)
+        return { capsule: undefined, warnings: [{ code: "oversize", message: "Retained state was ignored because it exceeds its bound." }] };
+    if (!isObject(raw) || raw.schema_version !== "0.1" || raw.authority !== "shadow" || !isText(raw.task_id, MAX_SHORT) ||
+        !isText(raw.acceptance_fingerprint, MAX_SHORT) || !isSourceManifest(raw.source_manifest) ||
+        !(raw.operation_manifest === "none" || isText(raw.operation_manifest, 512)) ||
+        !isBoundedList(raw.validation_history) || !raw.validation_history.every(validAttempt) ||
+        !isBoundedList(raw.blockers) || !raw.blockers.every((item) => isText(item)) || !isText(raw.next_action)) {
+        return { capsule: undefined, warnings: [{ code: "malformed", message: "Retained state was ignored because it is malformed." }] };
+    }
+    const capsule = {
+        schema_version: "0.1",
+        authority: "shadow",
+        task_id: raw.task_id,
+        acceptance_fingerprint: raw.acceptance_fingerprint,
+        source_manifest: structuredClone(raw.source_manifest),
+        operation_manifest: raw.operation_manifest,
+        validation_history: structuredClone(raw.validation_history),
+        blockers: structuredClone(raw.blockers),
+        next_action: raw.next_action,
+    };
+    const warnings = [];
+    if ("next_evidence_decision" in raw) {
+        if (validDecision(raw.next_evidence_decision))
+            capsule.next_evidence_decision = structuredClone(raw.next_evidence_decision);
+        else
+            warnings.push({ code: "optional_invalid", message: "An optional retained-state decision was ignored." });
+    }
+    if ("admissions" in raw) {
+        if (isBoundedList(raw.admissions)) {
+            const validAdmissions = raw.admissions.filter(validAdmission);
+            if (validAdmissions.length > 0 || raw.admissions.length === 0)
+                capsule.admissions = structuredClone(validAdmissions);
+            if (validAdmissions.length !== raw.admissions.length)
+                warnings.push({ code: "optional_invalid", message: "Invalid retained-state admission receipts were ignored." });
+        }
+        else
+            warnings.push({ code: "optional_invalid", message: "Optional retained-state admission receipts were ignored." });
+    }
+    return { capsule, warnings };
+}

package/dist/index.d.ts

@@ -19,3 +19,5 @@ export type { HandoffDenialReason, OpenCodeEvent, OpenCodeHooks, OpenCodePlugin,
 export { CONSULTATION_CAPABILITIES, CONSULTATION_ROLE_POLICY, MAX_REVIEW_ARTIFACT_BYTES, SOURCE_REVIEW_RISK_TAGS, STRATEGY_TRIGGERS, evaluateReviewAvailability, evaluateReviewGate, evaluateSourceReviewRequirement, isSourceReviewRiskTag, requiresSourceReview, shouldConsultStrategy, validateReviewArtifact, validateReviewVerdict, } from "./core/consultation.js";
 export type { ConsultationAdapter, ConsultationCapability, ConsultationRequest, ConsultationResult, ReviewArtifact, ReviewAvailability, ReviewFinding, ReviewFindingSeverity, ReviewGateInput, ReviewGateResult, ReviewVerdict, ReviewVerdictKind, SourceReviewConsultationRequest, SourceReviewConsultationResult, SourceReviewRequirement, SourceReviewRequirementInput, SourceReviewRiskTag, StrategyConsultationRequest, StrategyConsultationResult, StrategyTrigger, StrategyTriggerInput, UnavailableConsultationResult, ValidationResult, } from "./core/consultation.js";
 export type * from "./core/types.js";
+export { inspectRetainedStateCapsule, MAX_RETAINED_STATE_BYTES, MAX_RETAINED_STATE_ITEMS, MAX_RETAINED_STATE_WARNINGS, RETAINED_STATE_AUTHORITY, RETAINED_STATE_EXTENSION, RETAINED_STATE_SCHEMA_VERSION, } from "./core/retained-state.js";
+export type { AdmissionReceipt, NextEvidenceDecision, RetainedStateCapsule, RetainedStateInspection, RetainedStateWarning, RetainedValidationAttempt, } from "./core/retained-state.js";

package/dist/index.js

@@ -15,3 +15,4 @@ export { SortieDogsPlugin } from "./plugin/index.js";
  */
 export { HandoffDeniedError, InvalidModelTargetError, ModelRoutingDeniedError, isExplicitTaskHandoff, } from "./plugin/index.js";
 export { CONSULTATION_CAPABILITIES, CONSULTATION_ROLE_POLICY, MAX_REVIEW_ARTIFACT_BYTES, SOURCE_REVIEW_RISK_TAGS, STRATEGY_TRIGGERS, evaluateReviewAvailability, evaluateReviewGate, evaluateSourceReviewRequirement, isSourceReviewRiskTag, requiresSourceReview, shouldConsultStrategy, validateReviewArtifact, validateReviewVerdict, } from "./core/consultation.js";
+export { inspectRetainedStateCapsule, MAX_RETAINED_STATE_BYTES, MAX_RETAINED_STATE_ITEMS, MAX_RETAINED_STATE_WARNINGS, RETAINED_STATE_AUTHORITY, RETAINED_STATE_EXTENSION, RETAINED_STATE_SCHEMA_VERSION, } from "./core/retained-state.js";

package/dist/plugin/continuation.js

@@ -403,7 +403,12 @@ export function createContinuationHooks(client, directory, policySource, timings
         const entries = [];
         for (const { index, line } of topLevelProtocolLines(text)) {
             const explicit = /^status:\s*(DONE|BLOCKED|NEED_DECISION)\b/iu.exec(line)?.[1]?.toUpperCase();
-            const status = explicit ??
+            const aliasMatch = /^([✅⛔❓])[ \t]+conclusion:\s*status:\s*(DONE|BLOCKED|NEED_DECISION)\b/iu.exec(line);
+            const aliasStatus = aliasMatch?.[2]?.toUpperCase();
+            const alias = aliasStatus === "DONE" && aliasMatch?.[1] === "✅" ? "DONE" :
+                aliasStatus === "BLOCKED" && aliasMatch?.[1] === "⛔" ? "BLOCKED" :
+                    aliasStatus === "NEED_DECISION" && aliasMatch?.[1] === "❓" ? "NEED_DECISION" : undefined;
+            const status = explicit ?? alias ??
                 (/^✅[ \t]+\*\*DONE\*\*/u.test(line) ? "DONE" :
                     /^⛔[ \t]+\*\*BLOCKED\*\*/u.test(line) ? "BLOCKED" :
                         /^❓[ \t]+\*\*NEED_DECISION\*\*/u.test(line) ? "NEED_DECISION" : undefined);
@@ -413,15 +418,21 @@ export function createContinuationHooks(client, directory, policySource, timings
         }
         return entries;
     }
+    function firstCheckpoint(text) {
+        const firstLine = topLevelProtocolLines(text).find(({ line }) => line.trim().length > 0);
+        return firstLine === undefined
+            ? undefined
+            : checkpointEntries(text).find(({ index }) => index === firstLine.index);
+    }
     function checkpointStatus(text) {
-        return checkpointEntries(text).at(-1)?.status;
+        return firstCheckpoint(text)?.status;
     }
     function terminalCheckpoint(text) {
         const status = checkpointStatus(text);
         return status === "DONE" || status === "NEED_DECISION" || (status === "BLOCKED" && trueBlockerReport(text));
     }
     function trueBlockerReport(text) {
-        const checkpoint = checkpointEntries(text).at(-1);
+        const checkpoint = firstCheckpoint(text);
         if (checkpoint?.status !== "BLOCKED")
             return false;
         return topLevelProtocolLines(text).some(({ line, index }) => index > checkpoint.index &&
@@ -472,7 +483,7 @@ export function createContinuationHooks(client, directory, policySource, timings
     function observeRecoveryReport(state, report) {
         if (state.recoveryObservedRevision === state.turnRevision)
             return state.recoveryRepeatCount;
-        const checkpoint = checkpointEntries(report).at(-1);
+        const checkpoint = firstCheckpoint(report);
         const checkpointLine = checkpoint === undefined
             ? undefined
             : topLevelProtocolLines(report).find(({ index }) => index === checkpoint.index)?.line;

package/dist/plugin/index.js

@@ -18,7 +18,7 @@ import { BACKLOG_DRAIN_CAPABILITY, FastLaneController } from "./fast-lane.js";
 import { createModelRoutingHook, } from "./model-routing-hook.js";
 import { createTaskResultRepairHook, lastAssistantText, markConsultationFallbackRetry, taskChildSessionID, } from "./task-result-repair.js";
 import { configRoot, nearestPackageVersion, REFLECTION_POLICY, reflectionEnabled, ReflectionError, ReflectionStore } from "../reflection/index.js";
-import { collectRunMetrics, insertRunMetrics, isDoneTerminalText } from "./run-metrics.js";
+import { collectRunMetrics, insertRunMetrics, 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 };
@@ -854,6 +854,13 @@ export const SortieDogsPlugin = async (input, options) => {
                 bootstrapControlState: { count: 0, elapsedMilliseconds: 0 },
                 collectRunMetrics: { count: 0, elapsedMilliseconds: 0 },
             },
+            compactionPolicy: {
+                count: 0,
+                contextInputBytes: 0,
+                contextOutputBytes: 0,
+                promptInputBytes: 0,
+                promptOutputBytes: 0,
+            },
         };
         sessionOperationMetrics.set(sessionID, created);
         return created;
@@ -870,7 +877,9 @@ export const SortieDogsPlugin = async (input, options) => {
         }
     }
     function operationMetricsSnapshot(sessionID) {
-        const operations = sessionOperationMetrics.get(sessionID)?.operations;
+        const measurements = sessionOperationMetrics.get(sessionID);
+        const operations = measurements?.operations;
+        const compaction = measurements?.compactionPolicy;
         return {
             hostSessionIdentityCount: operations?.hostSessionIdentity.count ?? 0,
             hostSessionIdentityElapsedMilliseconds: Math.round(operations?.hostSessionIdentity.elapsedMilliseconds ?? 0),
@@ -878,8 +887,19 @@ export const SortieDogsPlugin = async (input, options) => {
             bootstrapControlStateElapsedMilliseconds: Math.round(operations?.bootstrapControlState.elapsedMilliseconds ?? 0),
             collectRunMetricsCount: operations?.collectRunMetrics.count ?? 0,
             collectRunMetricsElapsedMilliseconds: Math.round(operations?.collectRunMetrics.elapsedMilliseconds ?? 0),
+            compactionPolicyCount: compaction?.count ?? 0,
+            compactionContextInputBytes: compaction?.contextInputBytes ?? 0,
+            compactionContextOutputBytes: compaction?.contextOutputBytes ?? 0,
+            compactionPromptInputBytes: compaction?.promptInputBytes ?? 0,
+            compactionPromptOutputBytes: compaction?.promptOutputBytes ?? 0,
         };
     }
+    function utf8Bytes(value) {
+        return value === undefined ? 0 : Buffer.byteLength(value, "utf8");
+    }
+    function contextBytes(value) {
+        return value?.reduce((total, entry) => total + utf8Bytes(entry), 0) ?? 0;
+    }
     // Project config read is required discovery for its opt-in; no reflection storage/version read
     // occurs unless that resolved config enables reflection. It stays isolated from write-gate load.
     try {
@@ -2988,20 +3008,40 @@ export const SortieDogsPlugin = async (input, options) => {
                     .replaceAll(CONTINUATION_MARKER, "")
                     .trimEnd();
             }
+            const runOutcome = terminalRunOutcome(textOutput.text);
             if ((isCoordinatorSession(textInput.sessionID) || await recoverCoordinatorRoot(textInput.sessionID)) &&
-                isDoneTerminalText(textOutput.text)) {
+                runOutcome !== undefined) {
                 const metrics = await measureSessionOperation(textInput.sessionID, "collectRunMetrics", () => collectRunMetrics(input.client, textInput.sessionID, input.directory).catch(() => undefined));
-                if (metrics !== undefined)
+                if (metrics !== undefined && runOutcome === "DONE")
                     textOutput.text = insertRunMetrics(textOutput.text, metrics);
                 appLogInfo("run-metrics.snapshot", textInput.sessionID, {
                     available: metrics !== undefined,
+                    outcome: runOutcome,
+                    runtimeAssetVersion: RUNTIME_ASSET_VERSION,
+                    ...(metrics ?? {}),
                     ...operationMetricsSnapshot(textInput.sessionID),
                 });
             }
             await completeContinuationText(textInput.sessionID, textOutput.text, false);
         },
         "experimental.session.compacting": async (compactInput, compactOutput) => {
+            const before = {
+                context: contextBytes(compactOutput.context),
+                prompt: utf8Bytes(compactOutput.prompt),
+            };
             await continuation.sessionCompacting(compactInput, compactOutput);
+            const after = {
+                context: contextBytes(compactOutput.context),
+                prompt: utf8Bytes(compactOutput.prompt),
+            };
+            if (before.context !== after.context || before.prompt !== after.prompt) {
+                const measurement = operationMetricsFor(compactInput.sessionID).compactionPolicy;
+                measurement.count += 1;
+                measurement.contextInputBytes += before.context;
+                measurement.contextOutputBytes += after.context;
+                measurement.promptInputBytes += before.prompt;
+                measurement.promptOutputBytes += after.prompt;
+            }
         },
         "experimental.compaction.autocontinue": async (autoInput, autoOutput) => {
             await continuation.compactionAutoContinue(autoInput, autoOutput);

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

@@ -29,12 +29,31 @@ export interface RunMetricsClient {
 export interface RunMetrics {
     readonly durationMilliseconds: number | undefined;
     readonly tokens: number | undefined;
+    readonly inputTokens: number | undefined;
+    readonly outputTokens: number | undefined;
+    readonly reasoningTokens: number | undefined;
+    readonly cacheReadTokens: number | undefined;
+    readonly cacheWriteTokens: number | undefined;
     readonly cost: number | undefined;
     readonly steps: number | undefined;
     readonly sessions: number | undefined;
     readonly cacheRatio: number | undefined;
+    readonly roles: Readonly<Record<string, RunRoleMetrics>> | undefined;
 }
+export interface RunRoleMetrics {
+    readonly tokens: number;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly reasoningTokens: number;
+    readonly cacheReadTokens: number;
+    readonly cacheWriteTokens: number;
+    readonly cost: number | undefined;
+    readonly steps: number;
+    readonly cacheRatio: number | undefined;
+}
+export type RunTerminalOutcome = "DONE" | "BLOCKED" | "NEED_DECISION";
 export declare function collectRunMetrics(client: RunMetricsClient | undefined, rootSessionID: string, directory?: string, now?: number): Promise<RunMetrics | undefined>;
 export declare function formatRunMetrics(metrics: RunMetrics): string;
 export declare function isDoneTerminalText(text: string): boolean;
+export declare function terminalRunOutcome(text: string): RunTerminalOutcome | undefined;
 export declare function insertRunMetrics(text: string, metrics: RunMetrics): string;

package/dist/plugin/run-metrics.js

@@ -22,7 +22,19 @@ function messageTokens(message) {
     const cacheWrite = number(cache?.write) ?? number(tokens.cacheWrite) ?? number(tokens.cache_write);
     if (input === undefined || output === undefined || reasoning === undefined || cacheRead === undefined || cacheWrite === undefined)
         return undefined;
-    return [input + output + reasoning + cacheRead + cacheWrite, cacheRead];
+    return {
+        total: input + output + reasoning + cacheRead + cacheWrite,
+        input,
+        output,
+        reasoning,
+        cacheRead,
+        cacheWrite,
+    };
+}
+function messageAgent(message) {
+    const info = record(message.info) ?? message;
+    const agent = info.agent ?? message.agent;
+    return typeof agent === "string" && agent.trim().length > 0 ? agent.slice(0, 128) : "unknown";
 }
 function assistantMessages(value) {
     const payload = unwrap(value);
@@ -34,6 +46,14 @@ function assistantMessages(value) {
         return item !== undefined && (info?.role ?? item.role) === "assistant";
     });
 }
+function conclusionStatusAlias(line) {
+    const match = /^([✅⛔❓])[ \t]+conclusion:\s*status:\s*(DONE|BLOCKED|NEED_DECISION)\b/iu.exec(line);
+    const outcome = match?.[2]?.toUpperCase();
+    if (outcome !== "DONE" && outcome !== "BLOCKED" && outcome !== "NEED_DECISION")
+        return undefined;
+    const expectedIcon = outcome === "DONE" ? "✅" : outcome === "BLOCKED" ? "⛔" : "❓";
+    return match?.[1] === expectedIcon ? outcome : undefined;
+}
 export async function collectRunMetrics(client, rootSessionID, directory, now = Date.now()) {
     const session = client?.session;
     if (session?.messages === undefined)
@@ -74,12 +94,17 @@ export async function collectRunMetrics(client, rootSessionID, directory, now =
         hierarchyComplete = false;
     const uniqueMessages = new Set();
     let totalTokens = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let reasoningTokens = 0;
     let cacheRead = 0;
+    let cacheWrite = 0;
     let tokensAvailable = true;
     let messagesComplete = true;
     let steps = 0;
     let cost = 0;
     let costAvailable = true;
+    const roleMetrics = new Map();
     for (const id of ids) {
         try {
             const messages = assistantMessages(await session.messages.call(session, { path: { id }, query: { directory } }));
@@ -99,18 +124,46 @@ export async function collectRunMetrics(client, rootSessionID, directory, now =
                     continue;
                 uniqueMessages.add(messageID);
                 steps += 1;
+                const agent = messageAgent(message);
+                const role = roleMetrics.get(agent) ?? {
+                    tokens: 0,
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    reasoningTokens: 0,
+                    cacheReadTokens: 0,
+                    cacheWriteTokens: 0,
+                    cost: 0,
+                    costAvailable: true,
+                    steps: 0,
+                };
+                role.steps += 1;
+                roleMetrics.set(agent, role);
                 const tokens = messageTokens(message);
                 if (tokens !== undefined) {
-                    totalTokens += tokens[0];
-                    cacheRead += tokens[1];
+                    totalTokens += tokens.total;
+                    inputTokens += tokens.input;
+                    outputTokens += tokens.output;
+                    reasoningTokens += tokens.reasoning;
+                    cacheRead += tokens.cacheRead;
+                    cacheWrite += tokens.cacheWrite;
+                    role.tokens += tokens.total;
+                    role.inputTokens += tokens.input;
+                    role.outputTokens += tokens.output;
+                    role.reasoningTokens += tokens.reasoning;
+                    role.cacheReadTokens += tokens.cacheRead;
+                    role.cacheWriteTokens += tokens.cacheWrite;
                 }
                 else
                     tokensAvailable = false;
                 const reportedCost = number(info.cost) ?? number(message.cost);
-                if (reportedCost === undefined)
+                if (reportedCost === undefined) {
                     costAvailable = false;
-                else
+                    role.costAvailable = false;
+                }
+                else {
                     cost += reportedCost;
+                    role.cost += reportedCost;
+                }
             }
         }
         catch {
@@ -129,10 +182,28 @@ export async function collectRunMetrics(client, rootSessionID, directory, now =
     return {
         durationMilliseconds: created === undefined ? undefined : Math.max(0, now - created),
         tokens: hierarchyComplete && messagesComplete && tokensAvailable ? totalTokens : undefined,
+        inputTokens: hierarchyComplete && messagesComplete && tokensAvailable ? inputTokens : undefined,
+        outputTokens: hierarchyComplete && messagesComplete && tokensAvailable ? outputTokens : undefined,
+        reasoningTokens: hierarchyComplete && messagesComplete && tokensAvailable ? reasoningTokens : undefined,
+        cacheReadTokens: hierarchyComplete && messagesComplete && tokensAvailable ? cacheRead : undefined,
+        cacheWriteTokens: hierarchyComplete && messagesComplete && tokensAvailable ? cacheWrite : undefined,
         cost: hierarchyComplete && messagesComplete && costAvailable ? cost : undefined,
         steps: hierarchyComplete && messagesComplete ? steps : undefined,
         sessions: hierarchyComplete ? ids.length : undefined,
         cacheRatio: hierarchyComplete && messagesComplete && tokensAvailable && totalTokens > 0 ? cacheRead / totalTokens : undefined,
+        roles: hierarchyComplete && messagesComplete && tokensAvailable
+            ? Object.fromEntries([...roleMetrics].map(([agent, role]) => [agent, {
+                    tokens: role.tokens,
+                    inputTokens: role.inputTokens,
+                    outputTokens: role.outputTokens,
+                    reasoningTokens: role.reasoningTokens,
+                    cacheReadTokens: role.cacheReadTokens,
+                    cacheWriteTokens: role.cacheWriteTokens,
+                    cost: role.costAvailable ? role.cost : undefined,
+                    steps: role.steps,
+                    cacheRatio: role.tokens > 0 ? role.cacheReadTokens / role.tokens : undefined,
+                }]))
+            : undefined,
     };
 }
 function duration(milliseconds) {
@@ -151,19 +222,69 @@ export function formatRunMetrics(metrics) {
     const cache = metrics.cacheRatio === undefined ? "cache ratio unavailable" : `${(metrics.cacheRatio * 100).toFixed(1)}% cache ratio`;
     return `**Run:** pre-terminal host snapshot · ${elapsed} · ${tokens} · ${cost} · ${steps} · ${sessions} · ${cache}`;
 }
+function topLevelLines(text) {
+    const lines = [];
+    let fence;
+    for (const [index, line] of text.split(/\r?\n/u).entries()) {
+        if (fence === undefined) {
+            const opener = /^[ \t]*(`{3,}|~{3,})/u.exec(line)?.[1];
+            if (opener === undefined) {
+                if (!/^[ \t]*>/u.test(line))
+                    lines.push({ index, line });
+                continue;
+            }
+            fence = { character: opener[0], length: opener.length };
+            continue;
+        }
+        const closer = /^[ \t]*(`{3,}|~{3,})[ \t]*$/u.exec(line)?.[1];
+        if (closer?.[0] === fence.character && closer.length >= fence.length)
+            fence = undefined;
+    }
+    return lines;
+}
+function terminalCheckpoint(text) {
+    const lines = topLevelLines(text);
+    const first = lines.find(({ line }) => line.trim().length > 0);
+    if (first === undefined)
+        return undefined;
+    const checkpoint = (() => {
+        const { index, line } = first;
+        const normalized = /^status:\s*(DONE|BLOCKED|NEED_DECISION)\b/iu.exec(line)?.[1]?.toUpperCase();
+        const explicit = normalized === "DONE" || normalized === "BLOCKED" || normalized === "NEED_DECISION"
+            ? normalized
+            : undefined;
+        const outcome = explicit ?? conclusionStatusAlias(line) ??
+            (/^✅[ \t]+\*\*DONE\*\*/u.test(line) ? "DONE" :
+                /^⛔[ \t]+\*\*BLOCKED\*\*/u.test(line) ? "BLOCKED" :
+                    /^❓[ \t]+\*\*NEED_DECISION\*\*/u.test(line) ? "NEED_DECISION" : undefined);
+        return outcome === "DONE" || outcome === "BLOCKED" || outcome === "NEED_DECISION"
+            ? { index, outcome }
+            : undefined;
+    })();
+    return checkpoint;
+}
 export function isDoneTerminalText(text) {
-    const first = text.split(/\r?\n/u).find((line) => line.trim().length > 0) ?? "";
-    return /^✅\s+\*\*DONE\*\*(?:\s|$)/u.test(first) || /^status:\s*DONE(?:\s|$)/u.test(first);
+    return terminalCheckpoint(text)?.outcome === "DONE";
+}
+export function terminalRunOutcome(text) {
+    const checkpoint = terminalCheckpoint(text);
+    if (checkpoint === undefined)
+        return undefined;
+    if (checkpoint.outcome !== "BLOCKED")
+        return checkpoint.outcome;
+    return topLevelLines(text).some(({ index, line }) => index > checkpoint.index &&
+        /^TRUE_BLOCKER\s*:\s*(?:external|user-decision)\s*:\s*\S.*$/u.test(line))
+        ? "BLOCKED"
+        : undefined;
 }
 export function insertRunMetrics(text, metrics) {
-    if (/\*\*Run:\*\*/u.test(text) || !isDoneTerminalText(text))
+    const checkpoint = terminalCheckpoint(text);
+    if (checkpoint?.outcome !== "DONE")
         return text;
-    const newline = text.includes("\r\n") ? "\r\n" : "\n";
-    const statusStart = text.search(/^(?:✅\s+\*\*DONE\*\*|status:\s*DONE).*$/mu);
-    if (statusStart < 0)
+    if (topLevelLines(text).some(({ index, line }) => index > checkpoint.index && /^\*\*Run:\*\*/u.test(line)))
         return text;
-    const statusEnd = text.indexOf(newline, statusStart);
-    if (statusEnd < 0)
-        return `${text}${newline}${newline}${formatRunMetrics(metrics)}`;
-    return `${text.slice(0, statusEnd + newline.length)}${newline}${formatRunMetrics(metrics)}${newline}${text.slice(statusEnd + newline.length)}`;
+    const newline = text.includes("\r\n") ? "\r\n" : "\n";
+    const lines = text.split(/\r?\n/u);
+    lines.splice(checkpoint.index + 1, 0, "", formatRunMetrics(metrics));
+    return lines.join(newline);
 }