salmon-loop 0.3.2 → 0.5.0

package/dist/core/llm/output-policy.js

@@ -147,6 +147,14 @@ export function emitLlmStreamDelta(params) {
         timestamp,
     });
 }
+/**
+ * Clean up stream state without emitting end events.
+ * Call this when a stream errors and emitLlmStreamEnd won't be reached.
+ */
+export function cleanupLlmStream(streamId) {
+    STREAM_CANONICAL_EMITTERS.delete(streamId);
+    STREAM_SANITIZATION_STATE.delete(streamId);
+}
 export function emitLlmStreamEnd(params) {
     const { emit, policy, kind, step, streamId, finishReason } = params;
     if (!emit)

package/dist/core/llm/redact.js

@@ -1,3 +1,4 @@
+import { isRecord } from '../utils/serialize.js';
 const SECRET_KEY_REGEX = /(api[-_]?key|authorization|token|secret|password|cookie)/i;
 const STRING_SECRET_PATTERNS = [
     {
@@ -17,9 +18,6 @@ const STRING_SECRET_PATTERNS = [
         replacement: '$1=[REDACTED]',
     },
 ];
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
 function truncate(value, max = 500) {
     if (value.length <= max)
         return value;

package/dist/core/llm/retry-utils.js

@@ -1,4 +1,8 @@
+/**
+ * Utility for retrying asynchronous operations with exponential backoff.
+ */
 import { LIMITS } from '../config/limits.js';
+import { getLogger } from '../observability/logger.js';
 const DEFAULT_OPTIONS = {
     maxRetries: LIMITS.retry.api.maxAttempts,
     initialDelayMs: LIMITS.retry.api.initialDelayMs,
@@ -42,8 +46,9 @@ export async function withRetry(fn, options = {}) {
             try {
                 await opts.onRetry({ attempt: attempt + 1, delayMs: effectiveDelay, error });
             }
-            catch {
+            catch (retryHandlerError) {
                 // Ignore onRetry handler failures.
+                getLogger().debug(`[RetryUtils] onRetry handler failed: ${retryHandlerError instanceof Error ? retryHandlerError.message : String(retryHandlerError)}`);
             }
             await new Promise((resolve, reject) => {
                 const timer = setTimeout(() => {
@@ -91,8 +96,9 @@ export async function* withStreamRetry(streamFactory, options = {}) {
             try {
                 await opts.onRetry({ attempt: attempt + 1, delayMs: effectiveDelay, error });
             }
-            catch {
+            catch (retryHandlerError) {
                 // Ignore onRetry handler failures.
+                getLogger().debug(`[RetryUtils] onRetry handler failed (stream): ${retryHandlerError instanceof Error ? retryHandlerError.message : String(retryHandlerError)}`);
             }
             await new Promise((resolve, reject) => {
                 const timer = setTimeout(() => {

package/dist/core/llm/stream-utils.js

@@ -1,3 +1,4 @@
+import { getLogger } from '../observability/logger.js';
 function normalizeToolInput(raw) {
     if (typeof raw !== 'string')
         return raw;
@@ -12,14 +13,15 @@ function normalizeToolInput(raw) {
                 try {
                     parsed = JSON.parse(nested);
                 }
-                catch {
-                    // ignored
+                catch (error) {
+                    getLogger().debug(`[StreamUtils] Failed to parse nested JSON string: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
         }
         return parsed;
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[StreamUtils] Failed to normalize tool input JSON: ${error instanceof Error ? error.message : String(error)}`);
         return raw;
     }
 }

package/dist/core/llm/sub-agent-factory.js

@@ -0,0 +1,51 @@
+import { AiSdkLLM } from './ai-sdk.js';
+import { StubLLM } from './openai.js';
+/**
+ * Model alias → concrete model ID mapping.
+ *
+ * These follow the Anthropic model naming conventions.
+ * Providers that don't support these IDs will fall back to StubLLM.
+ */
+const MODEL_ALIAS_MAP = {
+    haiku: 'claude-3-5-haiku-20241022',
+    sonnet: 'claude-sonnet-4-20250514',
+    opus: 'claude-opus-4-20250514',
+};
+function resolveModelId(alias) {
+    return MODEL_ALIAS_MAP[alias] ?? alias;
+}
+/**
+ * Create a SubAgentLlmFactory that produces model-specific LLM instances
+ * from a base provider configuration.
+ *
+ * The factory reuses the parent provider's connection settings (API key,
+ * base URL, headers) and only overrides the model ID.
+ */
+export function createSubAgentLlmFactory(baseProvider) {
+    return (modelAlias) => {
+        // 'inherit' means use the parent LLM — don't create a new instance.
+        if (!modelAlias || modelAlias === 'inherit')
+            return undefined;
+        const modelId = resolveModelId(modelAlias);
+        if (baseProvider.type === 'openai-compatible' || baseProvider.type === 'openai') {
+            const clientPackage = baseProvider.clientPackage === '@ai-sdk/openai'
+                ? '@ai-sdk/openai'
+                : '@ai-sdk/openai-compatible';
+            if (!baseProvider.api.apiKey) {
+                return new StubLLM();
+            }
+            return new AiSdkLLM({
+                clientPackage,
+                providerName: baseProvider.id,
+                apiKey: baseProvider.api.apiKey,
+                baseUrl: baseProvider.api.baseUrl,
+                modelId,
+                headers: baseProvider.api.headers,
+                timeoutMs: baseProvider.api.timeoutMs,
+                capabilities: baseProvider.capabilities,
+            });
+        }
+        return undefined;
+    };
+}
+//# sourceMappingURL=sub-agent-factory.js.map

package/dist/core/llm/tool-calling-stub.js

@@ -0,0 +1,48 @@
+/**
+ * ToolCallingStubLLM — A deterministic LLM stub that emits tool_calls
+ * to drive the chatWithTools loop in tests and evaluation harnesses.
+ *
+ * Unlike StubLLM (toolCalling: false, no tool_calls), this stub populates
+ * the assistant.tool_calls field so that chatWithTools executes tools and
+ * continues the loop.
+ */
+export class ToolCallingStubLLM {
+    toolCalling = true;
+    turns;
+    callCount = 0;
+    constructor(turns) {
+        this.turns = turns;
+    }
+    getCapabilities() {
+        return {
+            toolCalling: true,
+            responseFormatJsonObject: false,
+            streaming: false,
+        };
+    }
+    async chat(_messages) {
+        const idx = this.callCount;
+        const turn = this.turns[idx] ?? { content: '[stub: no more turns]' };
+        this.callCount++;
+        return {
+            role: 'assistant',
+            content: turn.content ?? '',
+            tool_calls: turn.toolCalls,
+        };
+    }
+    getCallCount() {
+        return this.callCount;
+    }
+    async createPlan(_context, instruction) {
+        return {
+            goal: `Stub plan for: ${instruction}`,
+            files: [],
+            changes: [],
+            verify: 'echo ok',
+        };
+    }
+    async createPatch() {
+        return '';
+    }
+}
+//# sourceMappingURL=tool-calling-stub.js.map

package/dist/core/llm/utils.js

@@ -13,21 +13,32 @@ export function formatContextForPrompt(context, options = {}) {
 export function parsePlanFromLLMContent(content) {
     const trimmed = String(content ?? '').trim();
     if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
-        throw new Error(text.llm.planInvalidJson);
+        const preview = trimmed.slice(0, 80);
+        throw new Error(`${text.llm.planInvalidJson} — Content must start with { and end with }. Got: ${preview}${trimmed.length > 80 ? '…' : ''}`);
     }
     let parsed;
     try {
         parsed = JSON.parse(trimmed);
     }
-    catch {
-        throw new Error(text.llm.planInvalidJson);
+    catch (jsonError) {
+        const errorMsg = jsonError instanceof Error ? jsonError.message : String(jsonError);
+        throw new Error(`${text.llm.planInvalidJson} — JSON parse error: ${errorMsg}`);
     }
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(text.llm.planInvalidJson);
+        throw new Error(`${text.llm.planInvalidJson} — Expected object, got ${Array.isArray(parsed) ? 'array' : typeof parsed}`);
     }
     const plan = parsed;
-    if (!plan.goal || !Array.isArray(plan.files) || !Array.isArray(plan.changes) || !plan.verify) {
-        throw new Error(text.llm.planInvalid);
+    const missingKeys = [];
+    if (!plan.goal)
+        missingKeys.push('goal');
+    if (!Array.isArray(plan.files))
+        missingKeys.push('files (must be array)');
+    if (!Array.isArray(plan.changes))
+        missingKeys.push('changes (must be array)');
+    if (!plan.verify)
+        missingKeys.push('verify');
+    if (missingKeys.length > 0) {
+        throw new Error(`${text.llm.planInvalid} — Missing or invalid keys: ${missingKeys.join(', ')}`);
     }
     return plan;
 }

package/dist/core/mcp/bridge/prompt-command-provider.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { isRecord } from '../../utils/serialize.js';
 import { jsonSchemaToZod } from '../schema/json-schema-to-zod.js';
 const SAFE_TOKEN_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
 function normalizeToken(value) {
@@ -16,11 +17,11 @@ function safeToken(value, fallback) {
     return fallback;
 }
 function isPromptOptions(value) {
-    return Boolean(value &&
-        typeof value === 'object' &&
+    return Boolean(isRecord(value) &&
         'serverName' in value &&
         'client' in value &&
-        typeof value.client?.listPrompts === 'function');
+        isRecord(value.client) &&
+        typeof value.client.listPrompts === 'function');
 }
 function buildFallbackSchemaFromArguments(args = []) {
     const shape = {};

package/dist/core/mcp/bridge/resource-context-provider.js

@@ -1,3 +1,4 @@
+import { getLogger } from '../../observability/logger.js';
 import { ResourceCache } from '../cache/resource-cache.js';
 export class ResourceContextProviderError extends Error {
     diagnostic;
@@ -252,7 +253,8 @@ function normalizeText(text, mimeType) {
     try {
         return JSON.stringify(JSON.parse(text), null, 2);
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[ResourceContextProvider] Failed to normalize JSON text: ${error instanceof Error ? error.message : String(error)}`);
         return text;
     }
 }

package/dist/core/mcp/bridge/tool-bridge.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { LIMITS } from '../../config/limits.js';
 import { Phase } from '../../types/runtime.js';
+import { safeStringify } from '../../utils/serialize.js';
 import { classifyMcpTool } from '../policy/classifier.js';
 import { jsonSchemaToZod } from '../schema/json-schema-to-zod.js';
 const MCP_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_.-]*$/;
@@ -111,10 +112,9 @@ export function wrapMcpToolResult(result) {
 }
 export function mcpToolToToolSpec(input) {
     const override = findOverride(input.server.capabilities, input.tool.name);
-    const classification = classifyMcpTool({
-        tool: input.tool,
+    const classification = classifyMcpTool(input.tool, {
         trust: input.server.trust,
-        override,
+        override: override ? { sideEffects: override } : undefined,
     });
     const phase = input.server.capabilities.tools.phases[0] ?? Phase.VERIFY;
     const grantDecision = input.policy.decideTool({
@@ -169,7 +169,7 @@ export async function registerMcpV2Tools(input) {
         if (!catalog)
             continue;
         for (const tool of catalog.tools) {
-            const classification = classifyMcpTool({ tool: tool, trust: server.trust });
+            const classification = classifyMcpTool(tool, { trust: server.trust });
             const decision = input.policy.decideTool({
                 server: server.name,
                 toolName: tool.name,
@@ -267,16 +267,7 @@ function summarizeMcpAuthorization(input, args, riskLevel, sideEffects) {
             : { kind: 'classified', reason: input.classification.reason },
         args,
     };
-    return safeStringify(payload);
-}
-function safeStringify(value, maxLength = 1200) {
-    try {
-        const raw = JSON.stringify(value);
-        return raw.length <= maxLength ? raw : `${raw.slice(0, maxLength)}...`;
-    }
-    catch {
-        return '[Unserializable]';
-    }
+    return safeStringify(payload, { maxLength: 1200 });
 }
 function coerceRecord(input) {
     if (!input || typeof input !== 'object' || Array.isArray(input)) {

package/dist/core/mcp/catalog/discovery.js

@@ -1,3 +1,4 @@
+import { getLogger } from '../../observability/logger.js';
 import { withPromptServer } from './prompt-catalog.js';
 import { withResourceServer, withResourceTemplateServer } from './resource-catalog.js';
 import { withToolServer } from './tool-catalog.js';
@@ -5,7 +6,8 @@ async function safeList(fn, fallback) {
     try {
         return await fn();
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[McpDiscovery] safeList call failed, returning fallback: ${error instanceof Error ? error.message : String(error)}`);
         return fallback;
     }
 }

package/dist/core/mcp/client/connection-manager.js

@@ -2,6 +2,7 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { CallToolResultSchema, PromptListChangedNotificationSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, ResourceUpdatedNotificationSchema, ToolListChangedNotificationSchema, GetPromptResultSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { LIMITS } from '../../config/limits.js';
 import { getLogger } from '../../observability/logger.js';
+import { errorMessage } from '../../utils/error.js';
 import { PACKAGE_VERSION } from '../../version.js';
 import { discoverMcpCatalog } from '../catalog/discovery.js';
 import { McpNotificationRouter } from '../catalog/notification-router.js';
@@ -93,7 +94,7 @@ export class McpConnectionManager {
         }
         catch (error) {
             entry.status = 'degraded';
-            entry.error = error instanceof Error ? error.message : String(error);
+            entry.error = errorMessage(error);
             getLogger().warn(`Failed to connect MCP server ${server.name}: ${entry.error}`);
         }
         return this.view(entry);
@@ -183,7 +184,7 @@ export class McpConnectionManager {
             entry.subscribedResources.add(uri);
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
+            const message = errorMessage(error);
             getLogger().warn(`MCP server ${entry.server.name} resource subscription failed for ${uri}: ${message}`);
         }
     }
@@ -207,8 +208,9 @@ export class McpConnectionManager {
             try {
                 await entry.client.unsubscribeResource({ uri }, { timeout: LIMITS.defaultToolTimeoutMs });
             }
-            catch {
+            catch (error) {
                 // best-effort unsubscribe during shutdown
+                getLogger().debug(`[McpConnectionManager] Failed to unsubscribe resource ${uri}: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
         entry.subscribedResources.clear();
@@ -223,8 +225,9 @@ export class McpConnectionManager {
             }
             await entry.client.close();
         }
-        catch {
+        catch (error) {
             // best-effort shutdown
+            getLogger().debug(`[McpConnectionManager] Error during connection shutdown: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     view(entry) {

package/dist/core/mcp/client/transport-factory.js

@@ -1,6 +1,7 @@
 import { PassThrough } from 'node:stream';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { ReadBuffer, serializeMessage } from '@modelcontextprotocol/sdk/shared/stdio.js';
+import { getLogger } from '../../observability/logger.js';
 import { spawnInteractiveProcess } from '../../runtime/process-runner.js';
 export function buildStrictStdioEnvironment(env) {
     return { ...env };
@@ -81,16 +82,18 @@ export class StrictStdioClientTransport {
         try {
             child.stdin?.end?.();
         }
-        catch {
+        catch (error) {
             // best-effort shutdown
+            getLogger().debug(`[TransportFactory] Error ending stdin: ${error instanceof Error ? error.message : String(error)}`);
         }
         await Promise.race([closePromise, unrefTimeout(2_000)]);
         if (child.exitCode === null) {
             try {
                 child.kill('SIGTERM');
             }
-            catch {
+            catch (error) {
                 // best-effort shutdown
+                getLogger().debug(`[TransportFactory] Error sending SIGTERM: ${error instanceof Error ? error.message : String(error)}`);
             }
             await Promise.race([closePromise, unrefTimeout(2_000)]);
         }
@@ -98,8 +101,9 @@ export class StrictStdioClientTransport {
             try {
                 child.kill('SIGKILL');
             }
-            catch {
+            catch (error) {
                 // best-effort shutdown
+                getLogger().debug(`[TransportFactory] Error sending SIGKILL: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
         this.readBuffer.clear();

package/dist/core/mcp/host/sampling-provider.js

@@ -120,7 +120,7 @@ export class McpSamplingProvider {
             throw new Error('MCP_SAMPLING_TOKEN_LIMIT_EXCEEDED');
         }
         const result = await this.llm.chat([{ role: 'user', content: input.prompt }]);
-        return typeof result === 'string' ? result : String(result?.content ?? '');
+        return typeof result === 'string' ? result : String(result.content ?? '');
     }
     async createMessage(params, options = {}) {
         const sanitizedParams = sanitizeForAudit(params, this.maxDepth);

package/dist/core/mcp/schema/json-schema-to-zod.js

@@ -1,5 +1,6 @@
 import { isDeepStrictEqual } from 'node:util';
 import { z } from 'zod';
+import { isRecord } from '../../utils/serialize.js';
 export function jsonSchemaToZod(jsonSchema) {
     return jsonSchemaToZodWithContext(jsonSchema, jsonSchema);
 }
@@ -499,7 +500,7 @@ function propertyNamesToZod(jsonSchema, rootSchema) {
     return jsonSchemaToZodWithContext(jsonSchema, rootSchema);
 }
 function isPlainObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+    return isRecord(value);
 }
 function isMultipleOf(value, divisor) {
     const quotient = value / divisor;

package/dist/core/memory/relevant-retrieval.js

@@ -77,11 +77,12 @@ export function buildRelevantMemoryCandidates(context) {
             tags: ['rules', 'project'],
         });
     }
-    if (trimToUndefined(knowledge?.user_preferences)) {
+    const userPrefs = trimToUndefined(knowledge?.user_preferences);
+    if (userPrefs) {
         candidates.push({
             path: '.salmonloop/knowledge/user_preferences',
             title: 'User preferences',
-            summary: knowledge.user_preferences,
+            summary: userPrefs,
             tags: ['preferences', 'user'],
         });
     }
@@ -96,11 +97,12 @@ export function buildRelevantMemoryCandidates(context) {
             tags: ['architecture', ...(decision.related_files ?? []).map((file) => file.toLowerCase())],
         });
     }
-    if (trimToUndefined(metadata?.aiInstructions)) {
+    const aiInstructions = trimToUndefined(metadata?.aiInstructions);
+    if (aiInstructions) {
         candidates.push({
             path: '.salmonloop/project/ai-instructions',
             title: 'Project AI instructions',
-            summary: metadata.aiInstructions,
+            summary: aiInstructions,
             tags: ['instructions', 'project'],
         });
     }

package/dist/core/observability/audit-file.js

@@ -28,8 +28,9 @@ async function writeJsonAtomic(targetPath, data) {
     try {
         await rename(tmpPath, targetPath);
     }
-    catch {
+    catch (error) {
         // Retry once with a fresh temp file to reduce transient rename failures.
+        getLogger().debug(`[AuditFile] Atomic rename failed, retrying: ${error instanceof Error ? error.message : String(error)}`);
         const retryTmpPath = path.join(dir, `.${base}.tmp-${process.pid}-${Date.now()}-retry`);
         await writeFile(retryTmpPath, payload);
         await rename(retryTmpPath, targetPath);

package/dist/core/observability/audit-trail.js

@@ -1,3 +1,4 @@
+import { getLogger } from './logger.js';
 const auditTrail = [];
 const auditContext = {};
 const DEFAULT_BUFFER_LIMITS = {
@@ -19,7 +20,8 @@ function estimateEventSize(event) {
     try {
         return Buffer.byteLength(JSON.stringify(event), 'utf-8');
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[AuditTrail] Failed to estimate event size: ${error instanceof Error ? error.message : String(error)}`);
         return 0;
     }
 }

package/dist/core/observability/authorization-decisions.js

@@ -1,3 +1,4 @@
+import { asRecord } from '../utils/serialize.js';
 import { getAuditTrail } from './audit-trail.js';
 function safeString(value) {
     if (typeof value !== 'string')
@@ -23,13 +24,13 @@ export function extractAuthorizationDecisionsFromAuditTrail(auditTrail) {
             continue;
         if (event.action !== 'authorization.decision')
             continue;
-        const details = event.details;
-        if (!details || typeof details !== 'object')
+        if (!event.details || typeof event.details !== 'object')
             continue;
-        const callId = safeString(details.callId);
-        const toolName = safeString(details.toolName);
-        const phase = safeString(details.phase) ?? safeString(event.phase);
-        const outcome = safeString(details.outcome);
+        const d = asRecord(event.details);
+        const callId = safeString(d.callId);
+        const toolName = safeString(d.toolName);
+        const phase = safeString(d.phase) ?? safeString(event.phase);
+        const outcome = safeString(d.outcome);
         if (!callId || !toolName || !phase || !outcome)
             continue;
         decisions.push({
@@ -37,12 +38,12 @@ export function extractAuthorizationDecisionsFromAuditTrail(auditTrail) {
             toolName,
             phase: phase,
             outcome: outcome,
-            source: (safeString(details.source) ?? 'unknown'),
-            reason: safeString(details.reason),
-            ttlMs: safeNumber(details.ttlMs),
-            persist: safeString(details.persist),
-            riskLevel: safeString(details.riskLevel),
-            sideEffects: safeStringArray(details.sideEffects),
+            source: (safeString(d.source) ?? 'unknown'),
+            reason: safeString(d.reason),
+            ttlMs: safeNumber(d.ttlMs),
+            persist: safeString(d.persist),
+            riskLevel: safeString(d.riskLevel),
+            sideEffects: safeStringArray(d.sideEffects),
             timestamp: safeString(event.timestamp) ?? new Date().toISOString(),
         });
     }

package/dist/core/observability/error-mapping.js

@@ -1,4 +1,5 @@
 import { text } from '../../locales/index.js';
+import { isRecord } from '../utils/serialize.js';
 import { getAuditTrail } from './audit-trail.js';
 import { REDACTED_ERROR_TOKEN } from './error-envelope.js';
 function mapLlmCodeToMessage(code) {
@@ -193,7 +194,7 @@ export function mapErrorForAudit(input) {
     };
 }
 function buildLangfuseHttpFailed(details) {
-    const status = typeof details?.status === 'number' ? details.status : undefined;
+    const status = isRecord(details) && typeof details.status === 'number' ? details.status : undefined;
     if (!status)
         return undefined;
     if (status === 401 || status === 403) {

package/dist/core/observability/logger.js

@@ -307,8 +307,9 @@ export class Logger {
             // Only remove from queue if write was successful
             this.logQueue.splice(0, contentToFlush.length);
         }
-        catch {
+        catch (error) {
             // Keep logs in queue for next retry
+            this.debug(`[Logger] Failed to flush logs to file: ${error instanceof Error ? error.message : String(error)}`);
         }
         finally {
             this.isFlushing = false;

package/dist/core/observability/monitor.js

@@ -177,6 +177,30 @@ export class Monitor {
     /**
      * Generate metrics report
      */
+    getStructuredReport() {
+        const durations = [...this.applyBackMetrics.durations].sort((a, b) => a - b);
+        return {
+            checkpoint: {
+                createAttempts: this.checkpointMetrics.createAttempts,
+                createFailures: this.checkpointMetrics.createFailures,
+                createFailureRate: this.getCheckpointCreateFailureRate(),
+                cleanupAttempts: this.checkpointMetrics.cleanupAttempts,
+                cleanupFailures: this.checkpointMetrics.cleanupFailures,
+            },
+            applyBack: {
+                attempts: this.applyBackMetrics.attempts,
+                failures: this.applyBackMetrics.failures,
+                avgDurationMs: this.getApplyBackAvgDuration(),
+                p50DurationMs: durations.length > 0 ? durations[Math.floor(durations.length * 0.5)] : 0,
+                p95DurationMs: durations.length > 0 ? durations[Math.floor(durations.length * 0.95)] : 0,
+            },
+            errors: this.errorHistory.toArray().map((e) => ({
+                type: e.type,
+                message: e.message,
+                timestamp: e.timestamp.toISOString(),
+            })),
+        };
+    }
     getMetricsReport() {
         let report = `\n${text.monitor.metricsTitle}\n`;
         report += `\n${text.monitor.checkpointCreation}\n`;

package/dist/core/observability/run-outcome-reporter.js

@@ -7,6 +7,7 @@ export function buildRunOutcomeReport(result) {
         safeHint: result.safeHint,
         remediationSteps: result.remediationSteps,
         attempts: result.attempts,
+        durationMs: result.durationMs,
         failurePhase: result.failurePhase,
         errorCode: result.errorCode,
         changedFiles: result.changedFiles,

package/dist/core/observability/token-usage.js

@@ -1,3 +1,4 @@
+import { asRecord } from '../utils/serialize.js';
 import { getAuditTrail } from './audit-trail.js';
 function safeFiniteNumber(value) {
     if (typeof value !== 'number' || !Number.isFinite(value))
@@ -12,11 +13,11 @@ export function extractTokenUsageFromAuditTrail(auditTrail) {
             continue;
         if (event.action !== 'llm.usage')
             continue;
-        const details = event.details;
-        if (!details || typeof details !== 'object')
+        if (!event.details || typeof event.details !== 'object')
             continue;
-        const promptTokens = safeFiniteNumber(details.promptTokens);
-        const completionTokens = safeFiniteNumber(details.completionTokens);
+        const d = asRecord(event.details);
+        const promptTokens = safeFiniteNumber(d.promptTokens);
+        const completionTokens = safeFiniteNumber(d.completionTokens);
         if (typeof promptTokens === 'number')
             inputTokens += promptTokens;
         if (typeof completionTokens === 'number')