@animalabs/connectome-host 0.3.5 → 0.3.8

package/src/index.ts

@@ -15,18 +15,23 @@
  *   DATA_DIR            - Data directory for sessions (default: ./data)
  */
 
-import { Membrane, NativeFormatter } from '@animalabs/membrane';
+import {
+  Membrane,
+  NativeFormatter,
+  OpenAIResponsesAPIAdapter,
+  OpenAIResponsesFormatter,
+} from '@animalabs/membrane';
 import { LoggingAnthropicAdapter } from './logging-adapter.js';
+import { CallLedger } from './call-ledger.js';
 import { SettingsModule } from './modules/settings-module.js';
-import { AgentFramework, AutobiographicalStrategy, PassthroughStrategy, WorkspaceModule, type Module, type MountConfig } from '@animalabs/agent-framework';
+import { AgentFramework, WorkspaceModule, resolveTimeZone, type Module, type MountConfig } from '@animalabs/agent-framework';
 import { resolve, join, basename } from 'node:path';
 import { appendFile, mkdir, stat, rename } from 'node:fs/promises';
 import { readFileSync, existsSync } from 'node:fs';
-import { FrontdeskStrategy } from './strategies/frontdesk-strategy.js';
 import { SubagentModule } from './modules/subagent-module.js';
 import { LessonsModule } from './modules/lessons-module.js';
 import { RetrievalModule } from './modules/retrieval-module.js';
-import type { RecipeWorkspaceMount, RecipeStrategy } from './recipe.js';
+import type { RecipeWorkspaceMount } from './recipe.js';
 import { TuiModule } from './modules/tui-module.js';
 import { TimeModule } from './modules/time-module.js';
 import { FleetModule, type FleetModuleConfig } from './modules/fleet-module.js';
@@ -50,6 +55,8 @@ import {
   parseRecipeArg,
 } from './recipe.js';
 import { createBranchState, resetBranchState, handleExport, type BranchState } from './commands.js';
+import { buildFrameworkAgentConfig } from './framework-agent-config.js';
+import { buildFrameworkStrategy } from './framework-strategy.js';
 
 export type { AppContext };
 
@@ -61,15 +68,11 @@ const config = {
   // OAuth/Bearer token (e.g. a Claude subscription token). When set, it takes
   // precedence over the API key so requests never carry both auth schemes.
   authToken: process.env.ANTHROPIC_AUTH_TOKEN,
+  openaiApiKey: process.env.OPENAI_API_KEY,
   model: process.env.MODEL,
   dataDir: process.env.DATA_DIR || './data',
 };
 
-if (!config.apiKey && !config.authToken) {
-  console.error('Missing ANTHROPIC_API_KEY (or ANTHROPIC_AUTH_TOKEN). Set one in .env or environment.');
-  process.exit(1);
-}
-
 // ---------------------------------------------------------------------------
 // AppContext — mutable container for session switching
 // ---------------------------------------------------------------------------
@@ -138,14 +141,16 @@ async function createFramework(
   recipe: Recipe,
   agentName: string,
   settingsModule: SettingsModule,
+  callLedger: CallLedger | null,
 ): Promise<AgentFramework> {
   const model = config.model || recipe.agent.model || 'claude-opus-4-6';
   const modules = recipe.modules ?? {};
+  const timeZone = resolveTimeZone(recipe.agent.timezone);
 
   // -- Build module list --
   // SettingsModule is constructed in main() (before the adapter, so the
   // adapter can read its state for cross-cutting concerns like reasoning).
-  const moduleInstances: Module[] = [new TuiModule(), new TimeModule(), settingsModule];
+  const moduleInstances: Module[] = [new TuiModule(), new TimeModule(timeZone), settingsModule];
 
   // Subagents
   let subagentModule: SubagentModule | null = null;
@@ -169,10 +174,11 @@ async function createFramework(
 
   // Fleet (cross-process child orchestration). Opt-in via recipe.
   if (modules.fleet === true) {
-    moduleInstances.push(new FleetModule());
+    moduleInstances.push(new FleetModule({ timeZone }));
   } else if (modules.fleet && typeof modules.fleet === 'object') {
     const fleetCfg = modules.fleet;
     const fleetModuleConfig: FleetModuleConfig = {};
+    fleetModuleConfig.timeZone = timeZone;
     if (fleetCfg.children) {
       fleetModuleConfig.autoStart = fleetCfg.children.map((c) => {
         const entry: NonNullable<FleetModuleConfig['autoStart']>[number] = {
@@ -310,7 +316,7 @@ async function createFramework(
   // ability to spawn arbitrary commands via mcpl_deploy; see recipe.ts).
   let mcplAdminModule: McplAdminModule | null = null;
   if (modules.mcplAdmin === true) {
-    mcplAdminModule = new McplAdminModule();
+    mcplAdminModule = new McplAdminModule({ timeZone });
     moduleInstances.push(mcplAdminModule);
   }
 
@@ -330,6 +336,7 @@ async function createFramework(
       basicAuth: webuiConfig.basicAuth,
       allowedOrigins: webuiConfig.allowedOrigins,
       observersPath,
+      ...(callLedger ? { callLedger } : {}),
     });
     moduleInstances.push(webUiModule);
     moduleInstances.push(new ObserversModule({ path: observersPath }));
@@ -384,98 +391,70 @@ async function createFramework(
   // Apply the agent overlay (mcpl-servers.agent.json): servers the agent
   // deployed for itself load unconditionally (no recipe opt-in), and
   // tombstones suppress recipe/file servers the agent unloaded.
-  const finalServers = applyAgentOverlay(allServers, DEFAULT_AGENT_OVERLAY_PATH);
+  const finalServers = applyAgentOverlay(allServers, DEFAULT_AGENT_OVERLAY_PATH).map((server) => ({
+    ...server,
+    // Stdio MCPL children inherit a single agent-facing wall clock. Protocol
+    // timestamps remain UTC; only their rendered text uses this setting.
+    env: { ...(server.env ?? {}), AGENT_TIMEZONE: timeZone },
+  }));
 
   // No server augmentation needed — gate is wired via FrameworkConfig.gate
 
   // -- Build strategy --
-  //
-  // Build the options object with typed property access — no
-  // `Record<string, unknown>` cast on `strategyConfig`. Every field we
-  // forward is declared on `RecipeStrategy` (see recipe.ts); a typo in a
-  // recipe (e.g. `l1BudgetTokes`) now fails at recipe validation rather
-  // than silently being a no-op at strategy construction. AutobiographicalStrategy
-  // and FrontdeskStrategy share this option bag today; if strategy-specific
-  // fields are ever added, this should split into per-strategy types.
-  const strategyConfig = recipe.agent.strategy;
-  const strategyType = strategyConfig?.type ?? 'autobiographical';
-  const autobiographicalOpts: Record<string, unknown> = {
-    headWindowTokens: strategyConfig?.headWindowTokens ?? 4000,
-    recentWindowTokens: strategyConfig?.recentWindowTokens ?? 30000,
-    compressionModel: strategyConfig?.compressionModel ?? model,
-    autoTickOnNewMessage: true,
-    maxMessageTokens: strategyConfig?.maxMessageTokens ?? 10000,
-  };
-  // Forward optional tuning fields when set. The key list is typed
-  // against `RecipeStrategy`, so an unknown field name is a compile
-  // error here rather than a silent no-op at runtime.
-  const passthroughKeys: ReadonlyArray<keyof RecipeStrategy> = [
-    'enforceBudget',
-    'maxSpeculativeL1s',
-    'positionedRecallPairs',
-    'recallHeaderTemplate',
-    'targetChunkTokens',
-    'mergeThreshold',
-    'summaryTargetTokens',
-    'l1BudgetTokens',
-    'l2BudgetTokens',
-    'l3BudgetTokens',
-    'toolResultMaxLastN',
-    'toolUseInputMaxTokens',
-    'adaptiveResolution',
-    'kvStableReachTokens',
-    'kvStableQualityGapRatio',
-    'compressionSlackRatio',
-    'overBudgetGraceRatio',
-    'foldingStrategy',
-    'speculativeProduction',
-    'l1HoldbackChunks',
-    'summaryParticipant',
-    'summarySystemPrompt',
-    'summaryUserPrompt',
-    'summaryContextLabel',
-  ];
-  for (const key of passthroughKeys) {
-    const v = strategyConfig?.[key];
-    if (v !== undefined) autobiographicalOpts[key] = v;
-  }
-  // Adaptive resolution (document-based gradual compression) is the intended
-  // default for autobiographical agents. Frontdesk keeps the hierarchical
-  // renderer (its salience-biased L1 selection); it can still opt in via the
-  // recipe. A recipe may set `adaptiveResolution: false` to opt back out.
-  if (strategyType === 'autobiographical' && autobiographicalOpts.adaptiveResolution === undefined) {
-    autobiographicalOpts.adaptiveResolution = true;
-  }
-  const strategy = strategyType === 'passthrough'
-    ? new PassthroughStrategy()
-    : strategyType === 'frontdesk'
-      ? new FrontdeskStrategy(autobiographicalOpts)
-      : new AutobiographicalStrategy(autobiographicalOpts);
+  const strategy = buildFrameworkStrategy(recipe, model, timeZone);
+  const agentConfig = buildFrameworkAgentConfig(recipe, agentName, model, strategy);
 
   // -- Create framework --
   const framework = await AgentFramework.create({
     storePath,
     membrane,
-    agents: [
-      {
-        name: agentName,
-        model,
-        systemPrompt: recipe.agent.systemPrompt,
-        maxTokens: recipe.agent.maxTokens ?? 16384,
-        maxStreamTokens: recipe.agent.maxStreamTokens ?? 150000,
-        contextBudgetTokens: recipe.agent.contextBudgetTokens,
-        ...(recipe.agent.cacheTtl && { cacheTtl: recipe.agent.cacheTtl }),
-        strategy,
-        ...(recipe.agent.thinking && { thinking: recipe.agent.thinking }),
-        ...(recipe.agent.refusalHandling && { refusalHandling: recipe.agent.refusalHandling }),
-      },
-    ],
+    agents: [agentConfig],
     modules: moduleInstances,
     mcplServers: finalServers,
     gate: gateOptions,
+    timeZone,
   });
 
   // Wire post-creation hooks
+  // Compression-quarantine klaxon → the framework's ops-alert channel
+  // (failures.log + ops:alert trace + CONNECTOME_OPS_WEBHOOK). The strategy
+  // re-fires this every alarm interval for as long as ANY chunk is
+  // quarantined: quarantined spans stay raw, the fold floor creeps, and the
+  // picker eventually cannot fit the window — a guaranteed future outage
+  // that must never be a silent state.
+  // Duck-typed on both sides so version skew in either dep degrades to a
+  // no-op (the strategy's own stderr klaxon still fires) instead of a crash.
+  {
+    const alarmCapable = strategy as unknown as {
+      setQuarantineAlarmHandler?: (fn: (status: { count: number; keys: string[] }) => void) => void;
+    };
+    const notify = (framework as unknown as {
+      notifyOps?: (kind: string, agent: string, message: string, data?: Record<string, unknown>) => void;
+    }).notifyOps?.bind(framework);
+    if (alarmCapable.setQuarantineAlarmHandler && notify) {
+      alarmCapable.setQuarantineAlarmHandler((status) => {
+        if (status.count === 0) {
+          // All-clear travels the same channel the alarm did, under a
+          // DISTINCT kind: the alarm kind's 15-min ops cooldown must never
+          // swallow the stand-down (silence after an alarm is ambiguous).
+          notify(
+            'compression-quarantine-clear',
+            agentName,
+            'compression quarantine EMPTY — all debt paid; alarm stands down.',
+            { count: 0 },
+          );
+          return;
+        }
+        notify(
+          'compression-quarantine',
+          agentName,
+          `${status.count} chunk(s) in compression quarantine — spans stay raw and WILL eventually exhaust the context budget. Operator action required (inspect refusing content; branch, pin, or clear).`,
+          { count: status.count, keys: status.keys },
+        );
+      });
+    }
+  }
+
   if (subagentModule) {
     subagentModule.setFramework(framework);
   }
@@ -752,6 +731,16 @@ function countLines(path: string): number {
 
 async function main() {
   const recipe = await resolveRecipe();
+  const provider = recipe.agent.provider ?? 'anthropic';
+
+  if (provider === 'openai-responses' && !config.openaiApiKey) {
+    console.error('Missing OPENAI_API_KEY for recipe provider "openai-responses".');
+    process.exit(1);
+  }
+  if (provider === 'anthropic' && !config.apiKey && !config.authToken) {
+    console.error('Missing ANTHROPIC_API_KEY (or ANTHROPIC_AUTH_TOKEN). Set one in .env or environment.');
+    process.exit(1);
+  }
 
   // SettingsModule constructed early so the adapter can read its state for
   // cross-cutting concerns (currently: reasoning). It's wired into the
@@ -766,22 +755,34 @@ async function main() {
     config.dataDir,
     `llm-calls.${new Date().toISOString().replace(/[:.]/g, '-')}.jsonl`,
   );
+  const callLedger = provider === 'anthropic'
+    ? new CallLedger({
+        dataDir: config.dataDir,
+        defaultTtl: recipe.agent.cacheTtl ?? '5m',
+      })
+    : null;
   // OAuth (subscription) auth wins over API-key auth when both are present.
   // Subscription tokens (sk-ant-oat…) additionally require the oauth beta
   // header on every request.
-  const adapter = new LoggingAnthropicAdapter(
-    {
-      ...(config.authToken
-        ? {
-            authToken: config.authToken,
-            defaultHeaders: { 'anthropic-beta': 'oauth-2025-04-20' },
-          }
-        : { apiKey: config.apiKey! }),
-      baseURL: process.env.ANTHROPIC_BASE_URL || undefined,
-    },
-    llmLogPath,
-    () => settingsModule.getReasoning(),
-  );
+  const adapter = provider === 'openai-responses'
+    ? new OpenAIResponsesAPIAdapter({
+        apiKey: config.openaiApiKey!,
+        baseURL: process.env.OPENAI_BASE_URL || undefined,
+      })
+    : new LoggingAnthropicAdapter(
+        {
+          ...(config.authToken
+            ? {
+                authToken: config.authToken,
+                defaultHeaders: { 'anthropic-beta': 'oauth-2025-04-20' },
+              }
+            : { apiKey: config.apiKey! }),
+          baseURL: process.env.ANTHROPIC_BASE_URL || undefined,
+        },
+        llmLogPath,
+        () => settingsModule.getReasoning(),
+        (record) => callLedger!.record(record),
+      );
 
   // Session management — resolved before Membrane construction so the
   // active session's import-source sidecar can contribute to agent-name
@@ -814,7 +815,9 @@ async function main() {
   const agentName = resolved.name;
 
   const membrane = new Membrane(adapter, {
-    formatter: new NativeFormatter(),
+    formatter: provider === 'openai-responses'
+      ? new OpenAIResponsesFormatter()
+      : new NativeFormatter(),
     // Anchor the assistant role for internal callers that don't set
     // request.assistantParticipant themselves (autobio compression,
     // executeMerge). Mismatch here flips stored assistant turns to
@@ -823,7 +826,7 @@ async function main() {
   });
 
   const storePath = sessionManager.getStorePath(activeSession.id);
-  const framework = await createFramework(membrane, storePath, recipe, agentName, settingsModule);
+  const framework = await createFramework(membrane, storePath, recipe, agentName, settingsModule, callLedger);
 
   // Build app context
   const app: AppContext = {
@@ -844,7 +847,7 @@ async function main() {
       // re-resolution would matter only if recipe.agent.name is absent
       // AND the user switches between imports that used different
       // --agent values; not the canonical flow.
-      this.framework = await createFramework(membrane, newStorePath, recipe, this.agentName, settingsModule);
+      this.framework = await createFramework(membrane, newStorePath, recipe, this.agentName, settingsModule, callLedger);
       this.framework.start();
       this.userMessageCount = 0;
       resetBranchState(this.branchState);
@@ -854,6 +857,28 @@ async function main() {
     },
   };
 
+  // Off-path refusal dragnet → ops alerts (observability M3): refusals on
+  // non-streamed calls (compression/summarizer drains, maintenance) never
+  // reach the framework's own noteRefusal — the 2026-07-15 mythos cascade
+  // started exactly there, silently. Surface them through the same
+  // opsAlert pipeline (failures.log + ops:alert trace + throttled webhook).
+  // Reads app.framework (not the closure) so session switches stay wired;
+  // feature-detects notifyOpsAlert for older framework versions.
+  if (adapter instanceof LoggingAnthropicAdapter) {
+    adapter.onRefusal = (info) => {
+      const fw = app.framework as unknown as {
+        notifyOpsAlert?: (kind: string, agent: string, msg: string, data?: Record<string, unknown>) => void;
+      };
+      fw.notifyOpsAlert?.(
+        'refusal-offpath',
+        app.agentName,
+        `off-path refusal (category=${info.category ?? 'unknown'}) on a ${info.messages}-message ` +
+          `complete() call (~${Math.round(info.inputTokens / 1000)}k tok) — likely compression/summarizer`,
+        { ...info },
+      );
+    };
+  }
+
   framework.start();
   setupSynesthete(app);
   setupMcplStderrLog(app, storePath);

package/src/logging-adapter.ts

@@ -27,11 +27,13 @@ import type {
   StreamCallbacks,
 } from '@animalabs/membrane';
 import { appendFileSync } from 'node:fs';
+import { summarizeCacheControls, type ProviderCallRecord } from './call-ledger.js';
 
 /** Live read of the current reasoning setting. The host wires this to
- *  `SettingsModule.getReasoning()` so toggles via the `settings--reasoning_*`
- *  tools take effect on the next call without restart. */
+ *  `SettingsModule.getReasoning()` so toggles via the `agent_settings` tool's
+ *  reasoning_enabled field take effect on the next call without restart. */
 export type ReasoningGetter = () => { enabled: boolean; budgetTokens: number };
+export type ProviderCallObserver = (record: ProviderCallRecord) => void;
 
 /** Exact first-system-block identity Anthropic requires on subscription
  *  (sk-ant-oat…) OAuth traffic. Verified 2026-07-09: any other first block —
@@ -44,6 +46,7 @@ const OAUTH_SYSTEM_IDENTITY = "You are Claude Code, Anthropic's official CLI for
 export class LoggingAnthropicAdapter extends AnthropicAdapter {
   private readonly logPath: string;
   private readonly getReasoning?: ReasoningGetter;
+  private readonly onCall?: ProviderCallObserver;
   /** True when authenticated with an OAuth/Bearer token instead of an API
    *  key; requests then need the identity block prepended (see above). */
   private readonly oauthMode: boolean;
@@ -52,10 +55,12 @@ export class LoggingAnthropicAdapter extends AnthropicAdapter {
     config: ConstructorParameters<typeof AnthropicAdapter>[0],
     logPath: string,
     getReasoning?: ReasoningGetter,
+    onCall?: ProviderCallObserver,
   ) {
     super(config);
     this.logPath = logPath;
     this.getReasoning = getReasoning;
+    this.onCall = onCall;
     this.oauthMode = Boolean(config?.authToken);
   }
 
@@ -90,7 +95,7 @@ export class LoggingAnthropicAdapter extends AnthropicAdapter {
     // form with: `"thinking.type.enabled" is not supported for this model.
     // Use "thinking.type.adaptive"`. Under adaptive the model sizes its own
     // thinking, so `budgetTokens` is no longer sent (it still shows in
-    // reasoning_status as an informational hint).
+    // agent_settings as an informational hint).
     //
     // membrane's `ProviderRequest` doesn't type a top-level `thinking` field
     // (membrane is 0.5.68 — agent-framework is the package that went 0.6.0;
@@ -115,15 +120,91 @@ export class LoggingAnthropicAdapter extends AnthropicAdapter {
     }
   }
 
-  private requestSummary(request: ProviderRequest): Record<string, unknown> {
+  private requestSummary(request: ProviderRequest, rawRequest?: unknown): Record<string, unknown> {
+    const cache = rawRequest ? summarizeCacheControls(rawRequest) : undefined;
     return {
       model: request.model,
       maxTokens: request.maxTokens,
       messages: request.messages.length,
       tools: request.tools?.length ?? 0,
+      ...(cache ? { cacheBreakpoints: cache.count, cacheTtls: cache.ttls } : {}),
     };
   }
 
+  /**
+   * Off-path refusal dragnet (observability M3). The main inference driver
+   * instruments its own refusals (agent-framework noteRefusal), but that
+   * covers ONLY streamed agent turns. Every other model call in the process
+   * — compression/summarizer drains, maintenance — flows through this
+   * adapter's complete() and previously refused in silence; the 2026-07-15
+   * mythos cascade STARTED there and alerted nowhere. Fired for
+   * kind==='complete' only: agent turns stream, so this never double-reports
+   * a refusal the main driver already escalated.
+   */
+  onRefusal?: (info: {
+    kind: 'complete' | 'stream';
+    category?: string;
+    model: string;
+    messages: number;
+    inputTokens: number;
+  }) => void;
+
+  private observeCall(
+    kind: 'complete' | 'stream',
+    timestamp: string,
+    durationMs: number,
+    request: ProviderRequest,
+    rawRequest: unknown,
+    response?: ProviderResponse,
+    error?: unknown,
+  ): void {
+    const raw0 = (response as { raw?: { stop_reason?: string; stop_details?: { category?: string } } } | undefined)?.raw;
+    if (kind === 'complete' && raw0?.stop_reason === 'refusal' && this.onRefusal) {
+      try {
+        this.onRefusal({
+          kind,
+          category: raw0.stop_details?.category,
+          model: request.model,
+          messages: request.messages.length,
+          inputTokens: response?.usage.inputTokens ?? 0,
+        });
+      } catch { /* observers never affect provider traffic */ }
+    }
+    if (!this.onCall) return;
+    const cache = summarizeCacheControls(rawRequest);
+    const raw = (response as { raw?: Record<string, unknown> } | undefined)?.raw;
+    const rawUsage = raw?.usage as Record<string, unknown> | undefined;
+    const cacheCreation = rawUsage?.cache_creation as Record<string, unknown> | undefined;
+    const finite = (value: unknown): number | undefined =>
+      typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+    const text = (value: unknown): string | undefined =>
+      typeof value === 'string' && value.length > 0 ? value : undefined;
+    try {
+      this.onCall({
+        timestamp,
+        kind,
+        durationMs,
+        model: request.model,
+        messages: request.messages.length,
+        inputTokens: response?.usage.inputTokens ?? 0,
+        outputTokens: response?.usage.outputTokens ?? 0,
+        cacheReadTokens: response?.usage.cacheReadTokens ?? 0,
+        cacheWriteTokens: response?.usage.cacheCreationTokens ?? 0,
+        cacheWrite5mTokens: finite(cacheCreation?.ephemeral_5m_input_tokens),
+        cacheWrite1hTokens: finite(cacheCreation?.ephemeral_1h_input_tokens),
+        cacheWriteBucketsAuthoritative: cacheCreation !== undefined,
+        inferenceGeo: text(rawUsage?.inference_geo) ?? text(raw?.inference_geo),
+        serviceTier: text(rawUsage?.service_tier) ?? text(raw?.service_tier),
+        cacheBreakpoints: cache.count,
+        cacheTtls: cache.ttls,
+        stopReason: response?.stopReason,
+        error: error instanceof Error ? error.message : error ? String(error) : undefined,
+      });
+    } catch {
+      // A dashboard observer is never allowed to affect provider traffic.
+    }
+  }
+
   private refusalRawRequest(response: ProviderResponse, rawRequest: unknown): unknown {
     const raw = (response as { raw?: { stop_reason?: string } }).raw;
     return raw?.stop_reason === 'refusal' ? rawRequest : undefined;
@@ -155,22 +236,28 @@ export class LoggingAnthropicAdapter extends AnthropicAdapter {
     const wrapped = this.captureRawRequest(options, sink);
     try {
       const response = await super.complete(effective, wrapped);
+      const timestamp = new Date().toISOString();
+      const durationMs = Date.now() - t0;
       this.log({
         type: 'call', kind: 'complete',
-        timestamp: new Date().toISOString(), durationMs: Date.now() - t0,
-        requestSummary: this.requestSummary(request),
+        timestamp, durationMs,
+        requestSummary: this.requestSummary(request, sink.rawRequest),
         rawRequest: this.refusalRawRequest(response, sink.rawRequest),
         rawResponse: (response as { raw?: unknown }).raw ?? null,
       });
+      this.observeCall('complete', timestamp, durationMs, request, sink.rawRequest, response);
       return response;
     } catch (err) {
+      const timestamp = new Date().toISOString();
+      const durationMs = Date.now() - t0;
       this.log({
         type: 'error', kind: 'complete',
-        timestamp: new Date().toISOString(), durationMs: Date.now() - t0,
-        requestSummary: this.requestSummary(request),
+        timestamp, durationMs,
+        requestSummary: this.requestSummary(request, sink.rawRequest),
         rawRequest: sink.rawRequest,
         error: err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : String(err),
       });
+      this.observeCall('complete', timestamp, durationMs, request, sink.rawRequest, undefined, err);
       throw err;
     }
   }
@@ -186,22 +273,28 @@ export class LoggingAnthropicAdapter extends AnthropicAdapter {
     const wrapped = this.captureRawRequest(options, sink);
     try {
       const response = await super.stream(effective, callbacks, wrapped);
+      const timestamp = new Date().toISOString();
+      const durationMs = Date.now() - t0;
       this.log({
         type: 'call', kind: 'stream',
-        timestamp: new Date().toISOString(), durationMs: Date.now() - t0,
-        requestSummary: this.requestSummary(request),
+        timestamp, durationMs,
+        requestSummary: this.requestSummary(request, sink.rawRequest),
         rawRequest: this.refusalRawRequest(response, sink.rawRequest),
         rawResponse: (response as { raw?: unknown }).raw ?? null,
       });
+      this.observeCall('stream', timestamp, durationMs, request, sink.rawRequest, response);
       return response;
     } catch (err) {
+      const timestamp = new Date().toISOString();
+      const durationMs = Date.now() - t0;
       this.log({
         type: 'error', kind: 'stream',
-        timestamp: new Date().toISOString(), durationMs: Date.now() - t0,
-        requestSummary: this.requestSummary(request),
+        timestamp, durationMs,
+        requestSummary: this.requestSummary(request, sink.rawRequest),
         rawRequest: sink.rawRequest,
         error: err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : String(err),
       });
+      this.observeCall('stream', timestamp, durationMs, request, sink.rawRequest, undefined, err);
       throw err;
     }
   }

package/src/mcpl-config.ts

@@ -25,6 +25,7 @@ export interface ServerFileEntry {
   disabledFeatureSets?: string[];
   enabledTools?: string[];
   disabledTools?: string[];
+  /** @deprecated One-time migration input for legacy installations. */
   channelSubscription?: 'auto' | 'manual' | string[];
 }