@soleri/core 8.0.0 → 9.0.0

package/src/curator/curator.ts

@@ -1,6 +1,5 @@
 import type { Vault } from '../vault/vault.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
-import type { CogneeClient } from '../cognee/client.js';
 import type { PersistenceProvider } from '../persistence/types.js';
 import {
   tokenize,
@@ -51,12 +50,10 @@ const DEFAULT_TAG_ALIASES: Array<[string, string]> = [
 
 export class Curator {
   private vault: Vault;
-  private cognee: CogneeClient | undefined;
   private provider: PersistenceProvider;
 
-  constructor(vault: Vault, cognee?: CogneeClient) {
+  constructor(vault: Vault) {
     this.vault = vault;
-    this.cognee = cognee;
     this.provider = vault.getProvider();
     this.initializeTables();
     this.seedDefaultAliases();
@@ -378,8 +375,7 @@ export class Curator {
 
   async detectContradictionsHybrid(threshold?: number): Promise<{
     contradictions: Contradiction[];
-    cogneeAvailable: boolean;
-    method: 'hybrid' | 'tfidf-only';
+    method: 'tfidf-only';
   }> {
     const effectiveThreshold = threshold ?? DEFAULT_CONTRADICTION_THRESHOLD;
     const entries = this.vault.list({ limit: 100000 });
@@ -387,14 +383,12 @@ export class Curator {
     const patterns = entries.filter((e) => e.type === 'pattern');
 
     if (antipatterns.length === 0 || patterns.length === 0) {
-      return { contradictions: [], cogneeAvailable: false, method: 'tfidf-only' };
+      return { contradictions: [], method: 'tfidf-only' };
     }
 
     const vocabulary = this.buildVocabulary(entries);
     const detected: Contradiction[] = [];
 
-    const cogneeAvailable = this.cognee?.isAvailable ?? false;
-
     for (const ap of antipatterns) {
       let candidates: IntelligenceEntry[];
       try {
@@ -410,23 +404,7 @@ export class Curator {
       for (const pattern of candidates) {
         const pText = [pattern.title, pattern.description, pattern.context ?? ''].join(' ');
         const pVec = calculateTfIdf(tokenize(pText), vocabulary);
-        const tfidfScore = cosineSimilarity(apVec, pVec);
-
-        let finalScore = tfidfScore;
-        if (cogneeAvailable && this.cognee) {
-          try {
-            const cogneeResults = await this.cognee.search(`${ap.title} ${pattern.title}`, {
-              limit: 5,
-            });
-            const cogneeScore =
-              cogneeResults.length > 0
-                ? cogneeResults.reduce((sum, r) => sum + r.score, 0) / cogneeResults.length
-                : 0;
-            finalScore = 0.6 * tfidfScore + 0.4 * cogneeScore;
-          } catch {
-            finalScore = tfidfScore;
-          }
-        }
+        const finalScore = cosineSimilarity(apVec, pVec);
 
         if (finalScore >= effectiveThreshold) {
           const result = this.provider.run(
@@ -446,8 +424,7 @@ export class Curator {
 
     return {
       contradictions: detected,
-      cogneeAvailable,
-      method: cogneeAvailable ? 'hybrid' : 'tfidf-only',
+      method: 'tfidf-only',
     };
   }
 

package/src/curator/quality-gate.ts

@@ -97,8 +97,6 @@ export async function evaluateQuality(
 
   try {
     const result = await llm.complete({
-      provider: 'openai',
-      model: 'gpt-4o-mini',
       systemPrompt: 'You are a knowledge quality evaluator. Respond only with JSON.',
       userPrompt: prompt,
       temperature: 0.1,

package/src/domain-packs/index.ts

@@ -11,12 +11,6 @@ export {
 
 export { loadDomainPack, loadDomainPacksFromConfig, resolveDependencies } from './loader.js';
 
-export { installKnowledge, type KnowledgeInstallResult } from './knowledge-installer.js';
-
-export { installSkills, type SkillsInstallResult } from './skills-installer.js';
-
-export { injectDomainRules, removeDomainRules } from './inject-rules.js';
-
 export {
   type PackRuntime,
   type PackProjectContext,

package/src/domain-packs/loader.ts

@@ -18,7 +18,8 @@ export async function loadDomainPack(packageName: string): Promise<DomainPackMan
     mod = await import(packageName);
   } catch (err) {
     throw new Error(
-      `Failed to import domain pack "${packageName}": ${err instanceof Error ? err.message : String(err)}`, { cause: err },
+      `Failed to import domain pack "${packageName}": ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err },
     );
   }
 
@@ -33,10 +34,29 @@ export async function loadDomainPack(packageName: string): Promise<DomainPackMan
     throw new Error(`Domain pack "${packageName}" failed validation: ${result.errors.message}`);
   }
 
-  return {
-    ...result.data,
-    packageName,
-  };
+  const manifest: DomainPackManifest = { ...result.data, packageName };
+
+  // Warn if pack's engine requirement is mismatched
+  try {
+    const pkgJson = await import(`${packageName}/package.json`, { with: { type: 'json' } })
+      .then((m) => m.default)
+      .catch(() => null);
+    const peerCore = pkgJson?.peerDependencies?.['@soleri/core'];
+    if (peerCore) {
+      const requiredMajor = parseInt(peerCore.replace(/[^0-9]/g, ''), 10);
+      const { ENGINE_MAJOR_VERSION } = await import('../engine/module-manifest.js');
+      if (requiredMajor && ENGINE_MAJOR_VERSION && requiredMajor > ENGINE_MAJOR_VERSION) {
+        console.error(
+          `[warn] Domain pack "${packageName}" requires @soleri/core ${peerCore} ` +
+            `but engine is v${ENGINE_MAJOR_VERSION}. Upgrade @soleri/core.`,
+        );
+      }
+    }
+  } catch {
+    // Version check is best-effort — don't block loading
+  }
+
+  return manifest;
 }
 
 /**

package/src/domain-packs/pack-runtime.ts

@@ -14,7 +14,7 @@ import type { Vault } from '../vault/vault.js';
  */
 export interface PackProjectContext {
   id: string;
-  name: string;
+  name?: string;
   path: string;
   colors?: {
     [scale: string]: {
@@ -49,7 +49,7 @@ export interface PackRuntime {
   getProject(projectId: string): PackProjectContext | undefined;
 
   /** List all registered projects */
-  listProjects(): Array<{ id: string; name: string; path: string }>;
+  listProjects(): Array<{ id: string; name?: string; path: string }>;
 
   /** Create a session check (for tool chaining) */
   createCheck(type: string, data: Record<string, unknown>): string;
@@ -70,8 +70,8 @@ export interface PackRuntime {
 export function createPackRuntime(runtime: {
   vault: Vault;
   projectRegistry: {
-    getProject(id: string): PackProjectContext | undefined;
-    listProjects(): Array<{ id: string; name: string; path: string }>;
+    get(id: string): PackProjectContext | null;
+    list(): Array<{ id: string; name?: string; path: string }>;
   };
   sessionStore?: {
     createCheck(type: string, data: Record<string, unknown>): string;
@@ -81,8 +81,8 @@ export function createPackRuntime(runtime: {
 }): PackRuntime {
   return {
     vault: runtime.vault,
-    getProject: (id) => runtime.projectRegistry.getProject(id),
-    listProjects: () => runtime.projectRegistry.listProjects(),
+    getProject: (id) => runtime.projectRegistry.get(id) ?? undefined,
+    listProjects: () => runtime.projectRegistry.list(),
     createCheck: (type, data) => {
       if (!runtime.sessionStore) throw new Error('Session store not available');
       return runtime.sessionStore.createCheck(type, data);

package/src/domain-packs/types.ts

@@ -93,8 +93,14 @@ export interface DomainPack {
   requires?: string[];
   /** Called after pack is installed (one-time setup). */
   onInstall?: (runtime: AgentRuntime) => Promise<void>;
-  /** Called each time the agent starts (runtime initialization). */
-  onActivate?: (runtime: AgentRuntime) => Promise<void>;
+  /**
+   * Called each time the agent starts (runtime initialization).
+   *
+   * Receives `PackRuntime` (narrowed interface with vault, projects, session checks).
+   * The full `AgentRuntime` is passed as second argument for backwards compatibility
+   * but is deprecated — packs should only use `PackRuntime`.
+   */
+  onActivate?: (packRuntime: PackRuntime, runtime?: AgentRuntime) => Promise<void>;
 }
 
 // ---------------------------------------------------------------------------

package/src/engine/bin/soleri-engine.ts

@@ -71,12 +71,13 @@ async function main(): Promise<void> {
     ? resolve((engineConfig.vault as string).replace(/^~/, homedir()))
     : join(homedir(), `.${agentId}`, 'vault.db');
 
-  // 3. Create runtime
+  // 3. Create runtime (with persona from agent.yaml if present)
+  const personaConfig = config.persona as Record<string, unknown> | undefined;
   const runtime = createAgentRuntime({
     agentId,
     vaultPath,
     agentDir,
-    cognee: (engineConfig.cognee as boolean) ?? false,
+    persona: personaConfig as import('../../persona/types.js').PersonaConfig | undefined,
   });
 
   console.error(`${tag} Vault: ${vaultPath}`);
@@ -117,6 +118,14 @@ async function main(): Promise<void> {
   // 6. Seed default playbooks
   seedDefaultPlaybooks(runtime.vault);
 
+  // Log vault stats for first-run visibility
+  const vaultStats = runtime.vault.stats();
+  console.error(
+    `${tag} Vault: ${vaultStats.totalEntries} entries (${Object.entries(vaultStats.byType ?? {})
+      .map(([t, n]) => `${n} ${t}`)
+      .join(', ')})`,
+  );
+
   // 7. Load domain packs
   const packs = (config.packs ?? []) as Array<{ name: string; package: string; version?: string }>;
   const loadedPacks: Array<{ name: string; facades?: Array<{ name: string; ops: unknown[] }> }> =
@@ -129,9 +138,12 @@ async function main(): Promise<void> {
       const manifests = await loadDomainPacksFromConfig(refs);
 
       // Packs activate sequentially — order may matter for dependencies
+      const { createPackRuntime } = await import('../../domain-packs/pack-runtime.js');
+      const narrowedRuntime = createPackRuntime(runtime);
+
       for (const manifest of manifests) {
         if (manifest.onActivate) {
-          await manifest.onActivate(runtime); // eslint-disable-line no-await-in-loop
+          await manifest.onActivate(narrowedRuntime, runtime); // eslint-disable-line no-await-in-loop
         }
         loadedPacks.push(manifest);
         console.error(`${tag} Domain pack: ${manifest.name}`);
@@ -164,21 +176,21 @@ async function main(): Promise<void> {
     version: '1.0.0',
   });
 
-  // 11. Register persona prompt
-  server.prompt('persona', 'Get agent persona and principles', () => ({
+  // 11. Register persona prompt (uses composable persona system)
+  server.prompt('persona', 'Get agent persona and character instructions', () => ({
     messages: [
       {
         role: 'user' as const,
         content: {
           type: 'text' as const,
-          text: `You are ${identity.name}. ${identity.role}.\n\nPrinciples:\n${identity.principles.map((p) => `- ${p}`).join('\n')}\n\nTone: ${identity.tone}`,
+          text: runtime.personaInstructions.instructions,
         },
       },
     ],
   }));
 
   // 12. Register all engine tools
-  const { tools, totalOps } = registerEngine(server, runtime, {
+  const { tools, totalOps, registerTool } = registerEngine(server, runtime, {
     agentId,
     coreOps,
     domains: identity.domains,
@@ -195,6 +207,10 @@ async function main(): Promise<void> {
 
   console.error(`${tag} Registered ${tools.length} tools (${totalOps} ops)`);
 
+  // Enable hot reload for post-boot pack/plugin installation
+  const { setHotRegister } = await import('../../runtime/pack-ops.js');
+  setHotRegister(registerTool);
+
   // 13. Connect stdio transport
   const transport = new StdioServerTransport();
   await server.connect(transport);

package/src/engine/core-ops.ts

@@ -101,26 +101,32 @@ export function createCoreOps(
 
         // Build activation context
         const s = runtime.vault.stats();
+        const persona = runtime.persona;
+        const personaInstructions = runtime.personaInstructions;
         return {
           activated: true,
           agent: {
             id: identity.id,
-            name: identity.name,
+            name: persona.name,
             role: identity.role,
             description: identity.description,
             format: 'filetree',
           },
           persona: {
-            tone: identity.tone,
-            principles: identity.principles,
-            greeting: identity.greeting ?? `Hello! I am ${identity.name}.`,
+            template: persona.template,
+            name: persona.name,
+            culture: persona.culture,
+            voice: persona.voice,
+            traits: persona.traits,
+            quirks: persona.quirks,
+            greeting: personaInstructions.greeting,
+            instructions: personaInstructions.instructions,
           },
           vault: {
             connected: true,
             entries: s.totalEntries,
             domains: Object.keys(s.byDomain),
           },
-          domains: identity.domains,
         };
       },
     },
@@ -162,7 +168,6 @@ export function createCoreOps(
             byType: s.byType,
           },
           engine: {
-            cognee: runtime.cognee !== null && runtime.cognee !== undefined,
             brain: true,
             curator: true,
             planner: true,

package/src/engine/index.ts

@@ -17,3 +17,5 @@ export { registerEngine } from './register-engine.js';
 export type { EngineRegistrationOptions, EngineRegistrationResult } from './register-engine.js';
 export { createCoreOps } from './core-ops.js';
 export type { AgentIdentityConfig } from './core-ops.js';
+export { ENGINE_MODULE_MANIFEST, CORE_KEY_OPS } from './module-manifest.js';
+export type { ModuleManifestEntry } from './module-manifest.js';

package/src/engine/module-manifest.ts

@@ -0,0 +1,99 @@
+/**
+ * Soleri Engine Module Manifest
+ *
+ * Single source of truth for engine module names, descriptions, and key ops.
+ * Used by register-engine.ts at runtime and by @soleri/forge for template generation.
+ *
+ * This file is intentionally dependency-free so it can be imported by any package.
+ */
+
+export interface ModuleManifestEntry {
+  /** Suffix for tool name: {agentId}_{suffix} */
+  suffix: string;
+  /** Human-readable description */
+  description: string;
+  /** Representative ops shown in placeholder tables (max 4) */
+  keyOps: string[];
+  /** If true, module requires a runtime condition to register */
+  conditional?: boolean;
+}
+
+/**
+ * Canonical list of engine modules.
+ * Order here determines order in generated tool tables.
+ */
+export const ENGINE_MODULE_MANIFEST: ModuleManifestEntry[] = [
+  {
+    suffix: 'vault',
+    description: 'Knowledge management — search, CRUD, import/export, intake, archival.',
+    keyOps: ['search_intelligent', 'capture_knowledge', 'capture_quick'],
+  },
+  {
+    suffix: 'plan',
+    description: 'Plan lifecycle — create, approve, execute, reconcile, complete, grading.',
+    keyOps: ['create_plan', 'approve_plan', 'plan_split', 'plan_reconcile'],
+  },
+  {
+    suffix: 'brain',
+    description: 'Learning system — intelligence pipeline, strengths, feedback, sessions.',
+    keyOps: ['recommend', 'strengths', 'feedback'],
+  },
+  {
+    suffix: 'memory',
+    description: 'Session & cross-project memory — capture, search, dedup, promote.',
+    keyOps: ['memory_search', 'memory_capture', 'session_capture'],
+  },
+  {
+    suffix: 'admin',
+    description: 'Infrastructure — health, config, telemetry, tokens, LLM, prompts.',
+    keyOps: ['admin_health', 'admin_tool_list', 'admin_diagnostic'],
+  },
+  {
+    suffix: 'curator',
+    description: 'Quality — duplicate detection, contradictions, grooming, health audit.',
+    keyOps: ['curator_groom', 'curator_status', 'curator_health'],
+  },
+  {
+    suffix: 'loop',
+    description: 'Iterative validation loops — start, iterate, cancel, complete, history.',
+    keyOps: ['loop_start', 'loop_status', 'loop_cancel'],
+  },
+  {
+    suffix: 'orchestrate',
+    description:
+      'Execution orchestration — project registration, playbooks, plan/execute/complete.',
+    keyOps: ['orchestrate_plan', 'orchestrate_execute', 'orchestrate_complete'],
+  },
+  {
+    suffix: 'control',
+    description: 'Agent behavior — identity, intent routing, morphing, guidelines, governance.',
+    keyOps: ['route_intent', 'morph', 'get_behavior_rules'],
+  },
+  {
+    suffix: 'context',
+    description: 'Context analysis — entity extraction, knowledge retrieval, confidence scoring.',
+    keyOps: ['context_extract_entities', 'context_retrieve_knowledge', 'context_analyze'],
+  },
+  {
+    suffix: 'agency',
+    description: 'Proactive intelligence — file watching, pattern surfacing, warnings.',
+    keyOps: ['agency_scan_file', 'agency_surface_patterns', 'agency_warnings'],
+  },
+  {
+    suffix: 'chat',
+    description: 'Chat transport — session management, response chunking, authentication.',
+    keyOps: ['chat_send', 'chat_history', 'chat_session'],
+  },
+  {
+    suffix: 'cognee',
+    description: 'Knowledge graph — Cognee search, sync, export, graph stats.',
+    keyOps: ['cognee_search', 'cognee_add', 'cognee_cognify'],
+    conditional: true,
+  },
+];
+
+/** Core facade ops (always present, not in ENGINE_MODULES) */
+export const CORE_KEY_OPS = ['health', 'identity', 'register', 'activate'];
+
+/** Engine major version — used for compatibility checks against domain packs. */
+export const ENGINE_MAJOR_VERSION = 8;

package/src/engine/register-engine.ts

@@ -32,7 +32,6 @@ import { createCuratorFacadeOps } from '../runtime/facades/curator-facade.js';
 import { createLoopFacadeOps } from '../runtime/facades/loop-facade.js';
 import { createOrchestrateFacadeOps } from '../runtime/facades/orchestrate-facade.js';
 import { createControlFacadeOps } from '../runtime/facades/control-facade.js';
-import { createCogneeFacadeOps } from '../runtime/facades/cognee-facade.js';
 import { createContextFacadeOps } from '../runtime/facades/context-facade.js';
 import { createAgencyFacadeOps } from '../runtime/facades/agency-facade.js';
 import { createChatFacadeOps } from '../runtime/facades/chat-facade.js';
@@ -60,6 +59,12 @@ export interface EngineRegistrationResult {
   tools: string[];
   /** Total op count across all tools */
   totalOps: number;
+  /**
+   * Register a new MCP tool at runtime (hot reload).
+   * Call this after installing a pack or activating a plugin post-boot.
+   * Automatically notifies connected clients via sendToolListChanged().
+   */
+  registerTool: (toolName: string, description: string, ops: OpDefinition[]) => void;
 }
 
 // ─── Module Definition ────────────────────────────────────────────────
@@ -75,7 +80,8 @@ interface ModuleDef {
   condition?: (runtime: AgentRuntime) => boolean;
 }
 
-const ENGINE_MODULES: ModuleDef[] = [
+/** @internal Exported for drift testing — do not use outside engine */
+export const ENGINE_MODULES: ModuleDef[] = [
   {
     suffix: 'vault',
     description: 'Knowledge management — search, CRUD, import/export, intake, archival.',
@@ -137,12 +143,6 @@ const ENGINE_MODULES: ModuleDef[] = [
     description: 'Chat transport — session management, response chunking, authentication.',
     createOps: createChatFacadeOps,
   },
-  {
-    suffix: 'cognee',
-    description: 'Knowledge graph — Cognee search, sync, export, graph stats.',
-    createOps: createCogneeFacadeOps,
-    condition: (rt) => rt.cognee !== null && rt.cognee !== undefined,
-  },
 ];
 
 // ─── Core Registration ────────────────────────────────────────────────
@@ -233,7 +233,19 @@ export function registerEngine(
     }
   }
 
-  return { tools: registeredTools, totalOps };
+  const registerTool = (toolName: string, description: string, ops: OpDefinition[]) => {
+    registerModuleTool(server, toolName, description, ops, authPolicy);
+    registeredTools.push(toolName);
+    totalOps += ops.length;
+    // Notify connected clients that tool list changed
+    try {
+      (server as unknown as { sendToolListChanged?: () => void }).sendToolListChanged?.();
+    } catch {
+      // Server may not support notifications yet — safe to ignore
+    }
+  };
+
+  return { tools: registeredTools, totalOps, registerTool };
 }
 
 // ─── Tool Registration (No Factory) ──────────────────────────────────

package/src/index.ts

@@ -1,5 +1,9 @@
 // ─── Intelligence ────────────────────────────────────────────────────
-export type { IntelligenceEntry, IntelligenceBundle } from './intelligence/types.js';
+export type {
+  IntelligenceEntry,
+  IntelligenceBundle,
+  IntelligenceBundleLink,
+} from './intelligence/types.js';
 export { loadIntelligenceData, loadPacks } from './intelligence/loader.js';
 
 // ─── Vault ───────────────────────────────────────────────────────────
@@ -249,21 +253,6 @@ export type {
   BrowserToolResult,
 } from './chat/index.js';
 
-// ─── Cognee ─────────────────────────────────────────────────────────
-export { CogneeClient } from './cognee/client.js';
-export type {
-  CogneeConfig,
-  CogneeSearchResult,
-  CogneeSearchType,
-  CogneeStatus,
-  CogneeAddResult,
-  CogneeCognifyResult,
-} from './cognee/types.js';
-
-// ─── Cognee Sync ──────────────────────────────────────────────────────
-export { CogneeSyncManager } from './cognee/sync-manager.js';
-export type { SyncOp, SyncStatus, SyncQueueItem, SyncManagerStats } from './cognee/sync-manager.js';
-
 // ─── Intake Pipeline ──────────────────────────────────────────────────
 export { IntakePipeline } from './intake/intake-pipeline.js';
 export { classifyChunk, VALID_TYPES, CLASSIFICATION_PROMPT } from './intake/content-classifier.js';
@@ -489,6 +478,21 @@ export type {
   IntegrityResult,
 } from './health/index.js';
 
+// ─── Persona ──────────────────────────────────────────────────────────
+export type {
+  PersonaConfig,
+  ArchivedPersona,
+  PersonaCreateInput,
+  PersonaSystemInstructions,
+} from './persona/types.js';
+export {
+  ITALIAN_CRAFTSPERSON,
+  PERSONA_TEMPLATES,
+  createDefaultPersona,
+} from './persona/defaults.js';
+export { loadPersona } from './persona/loader.js';
+export { generatePersonaInstructions, getRandomSignoff } from './persona/prompt-generator.js';
+
 // ─── Runtime Factory ────────────────────────────────────────────────
 export { createAgentRuntime } from './runtime/runtime.js';
 export { createSemanticFacades } from './runtime/facades/index.js';
@@ -541,7 +545,6 @@ export type {
 
 // ─── Persistence ───────────────────────────────────────────────────────
 export { SQLitePersistenceProvider } from './persistence/index.js';
-export { PostgresPersistenceProvider, translateSql } from './persistence/index.js';
 export type {
   PersistenceProvider,
   PersistenceParams,

package/src/intake/content-classifier.ts

@@ -60,8 +60,6 @@ export async function classifyChunk(
 ): Promise<ClassifiedItem[]> {
   try {
     const result = await llm.complete({
-      provider: 'openai',
-      model: 'gpt-4o-mini',
       systemPrompt: CLASSIFICATION_PROMPT,
       userPrompt: chunkText,
       maxTokens: 4096,

package/src/intelligence/types.ts

@@ -17,8 +17,16 @@ export interface IntelligenceEntry {
   validUntil?: number; // unix epoch — when entry expires (null = never)
 }
 
+export interface IntelligenceBundleLink {
+  sourceId: string;
+  targetId: string;
+  linkType: 'supports' | 'contradicts' | 'extends' | 'sequences';
+  note?: string;
+}
+
 export interface IntelligenceBundle {
   domain: string;
   version: string;
   entries: IntelligenceEntry[];
+  links?: IntelligenceBundleLink[];
 }

package/src/llm/llm-client.ts

@@ -160,6 +160,8 @@ interface AnthropicClient {
   };
 }
 
+type ResolvedLLMOptions = LLMCallOptions & { model: string; provider: 'openai' | 'anthropic' };
+
 export class LLMClient {
   private openaiKeyPool: KeyPool;
   private anthropicKeyPool: KeyPool;
@@ -181,11 +183,15 @@ export class LLMClient {
 
   async complete(options: LLMCallOptions): Promise<LLMCallResult> {
     const routed = this.router.resolve(options.caller, options.task, options.model);
-    const resolvedOptions = { ...options, model: routed.model, provider: routed.provider };
+    const resolved: ResolvedLLMOptions = {
+      ...options,
+      model: options.model ?? routed.model,
+      provider: options.provider ?? routed.provider,
+    };
 
-    return resolvedOptions.provider === 'anthropic'
-      ? this.callAnthropic(resolvedOptions)
-      : this.callOpenAI(resolvedOptions);
+    return resolved.provider === 'anthropic'
+      ? this.callAnthropic(resolved)
+      : this.callOpenAI(resolved);
   }
 
   isAvailable(): { openai: boolean; anthropic: boolean } {
@@ -203,7 +209,7 @@ export class LLMClient {
   // OPENAI
   // ===========================================================================
 
-  private async callOpenAI(options: LLMCallOptions): Promise<LLMCallResult> {
+  private async callOpenAI(options: ResolvedLLMOptions): Promise<LLMCallResult> {
     const keyPool = this.openaiKeyPool.hasKeys ? this.openaiKeyPool : null;
 
     if (!keyPool) {
@@ -275,7 +281,7 @@ export class LLMClient {
   // ANTHROPIC
   // ===========================================================================
 
-  private async callAnthropic(options: LLMCallOptions): Promise<LLMCallResult> {
+  private async callAnthropic(options: ResolvedLLMOptions): Promise<LLMCallResult> {
     const client = await this.getAnthropicClient();
     if (!client) {
       throw new LLMError('Anthropic API key not configured', { retryable: false });

package/src/llm/oauth-discovery.ts

@@ -43,24 +43,6 @@ export function discoverAnthropicToken(): string | null {
   return token;
 }
 
-/**
- * Clear the cached token (for testing or rotation).
- */
-export function resetTokenCache(): void {
-  cachedToken = null;
-  cacheTimestamp = 0;
-}
-
-/**
- * Get discovery source info (for diagnostics).
- */
-export function getTokenSource(): string {
-  if (process.env.ANTHROPIC_API_KEY) return 'env:ANTHROPIC_API_KEY';
-  if (tryCredentialsFile()) return 'file:credentials';
-  if (tryPlatformKeychain()) return `keychain:${platform()}`;
-  return 'none';
-}
-
 // ─── Discovery Methods ───────────────────────────────────────────────
 
 function tryEnvVar(): string | null {