@sage-protocol/cli 0.4.0 → 0.4.2

package/dist/cli/services/mcp/sage-tool-registry.js

@@ -0,0 +1,322 @@
+// Central registry of core Sage MCP tools grouped by capability.
+// This is used by suggest_sage_tools to provide lightweight routing
+// and avoids hard-coding tool metadata in multiple places.
+//
+// Weight philosophy:
+// - 1.0: Standard tools (general purpose)
+// - 0.9: Primarily "list/browse" tools (lower-action, exploratory)
+// - 1.1–1.2: High-value "action" tools that accomplish concrete tasks
+
+const TOOL_REGISTRY = {
+  // ───────────── Prompt workspace tools ─────────────
+  search_prompts: {
+    category: 'prompt_workspace',
+    keywords: ['search', 'find', 'prompt', 'query', 'look', 'locate', 'discover'],
+    negativeKeywords: ['create', 'new', 'publish', 'delete'],
+    description: 'Search prompts across local workspace and on-chain libraries.',
+    whenToUse: 'Use when you need to find existing prompts by keyword, tag, or content.',
+    requiredParams: ['query'],
+    optionalParams: ['source', 'subdao', 'tags', 'includeContent'],
+    weight: 1.0,
+  },
+  list_prompts: {
+    category: 'prompt_workspace',
+    keywords: ['list', 'browse', 'prompt', 'workspace', 'skill', 'snippet'],
+    negativeKeywords: ['search', 'publish'],
+    description: 'List prompts, skills, or snippets from workspace and/or libraries. Use kind filter for skills.',
+    whenToUse: 'Use when you want to browse prompts. Filter by kind (prompt/skill/snippet) to see specific types.',
+    requiredParams: [],
+    optionalParams: ['source', 'library', 'limit', 'kind', 'publishable'],
+    weight: 0.9,
+  },
+  get_prompt: {
+    category: 'prompt_workspace',
+    keywords: ['get', 'inspect', 'view', 'prompt', 'details'],
+    negativeKeywords: ['search', 'list'],
+    description: 'Retrieve a specific prompt by key, including its content.',
+    whenToUse: 'Use when you already know the prompt key and want full details for editing or reuse.',
+    requiredParams: ['key'],
+    optionalParams: ['library'],
+    weight: 1.0,
+  },
+  quick_create_prompt: {
+    category: 'prompt_workspace',
+    keywords: ['create', 'new', 'write', 'add', 'draft', 'prompt'],
+    negativeKeywords: ['find', 'search', 'list'],
+    description: 'Create a new prompt with automatic library handling.',
+    whenToUse: 'Use when starting fresh with a new prompt idea.',
+    requiredParams: ['name', 'content'],
+    optionalParams: ['library', 'description', 'tags'],
+    weight: 1.2,
+  },
+  quick_iterate_prompt: {
+    category: 'prompt_workspace',
+    keywords: ['edit', 'update', 'improve', 'iterate', 'refine'],
+    negativeKeywords: ['create', 'search'],
+    description: 'Modify an existing prompt in-place, keeping history in the workspace.',
+    whenToUse: 'Use when you want to refine or adjust an existing prompt.',
+    requiredParams: ['key', 'content'],
+    optionalParams: ['library', 'description'],
+    weight: 1.1,
+  },
+  test_prompt: {
+    category: 'prompt_workspace',
+    keywords: ['test', 'render', 'evaluate', 'prompt', 'variables'],
+    negativeKeywords: ['search', 'list'],
+    description: 'Test a prompt by filling in ${variable} placeholders and viewing the rendered result.',
+    whenToUse: 'Use when you want to verify prompt behavior and variable substitution.',
+    requiredParams: ['key'],
+    optionalParams: ['library', 'variables'],
+    weight: 1.0,
+  },
+  quick_test_prompt: {
+    category: 'prompt_workspace',
+    keywords: ['test', 'quick', 'run', 'prompt', 'variables'],
+    negativeKeywords: ['search', 'list'],
+    description: 'Alias for test_prompt. Quickly test a prompt with variables.',
+    whenToUse: 'Use when you want a shortcut to test_prompt for fast validation.',
+    requiredParams: ['key'],
+    optionalParams: ['variables'],
+    weight: 1.0,
+  },
+  // NOTE: list_workspace_skills removed - use list_prompts({ kind: 'skill' })
+  improve_prompt: {
+    category: 'prompt_workspace',
+    keywords: ['improve', 'refine', 'quality', 'analyze', 'prompt'],
+    negativeKeywords: ['create', 'publish'],
+    description: 'Analyze an existing prompt and suggest improvement areas and interview questions.',
+    whenToUse: 'Use when you have a working prompt and want structured suggestions for improvement.',
+    requiredParams: ['key'],
+    optionalParams: ['library', 'depth', 'focus'],
+    weight: 1.0,
+  },
+  rename_prompt: {
+    category: 'prompt_workspace',
+    keywords: ['rename', 'key', 'name', 'prompt'],
+    negativeKeywords: ['search'],
+    description: 'Rename a prompt key and/or display name while preserving content.',
+    whenToUse: 'Use when you need to change the identifier or display name of an existing prompt.',
+    requiredParams: ['key'],
+    optionalParams: ['newKey', 'name'],
+    weight: 0.9,
+  },
+  // NOTE: get_workspace_skill removed - use get_prompt({ key })
+
+  // ───────────── Persona / metaprompt tools ─────────────
+  list_persona_templates: {
+    category: 'persona',
+    keywords: ['persona', 'template', 'list', 'browse', 'metaprompt'],
+    negativeKeywords: [],
+    description: 'List available persona templates (coding assistant, governance helper, etc.).',
+    whenToUse: 'Use when you are deciding what kind of assistant/persona to design.',
+    requiredParams: [],
+    optionalParams: [],
+    weight: 1.0,
+  },
+  run_persona_interview: {
+    category: 'persona',
+    keywords: ['persona', 'interview', 'one-shot', 'create', 'system prompt'],
+    negativeKeywords: ['stepwise', 'stateful'],
+    description: 'Build a persona/system prompt in one shot from provided answers.',
+    whenToUse: 'Use when you already have answers for the persona slots and just need a system prompt.',
+    requiredParams: ['template', 'answers'],
+    optionalParams: ['save', 'saveKey'],
+    weight: 1.2,
+  },
+  persona_interview_step: {
+    category: 'persona',
+    keywords: ['persona', 'interview', 'step', 'slot', 'stateful'],
+    negativeKeywords: ['one-shot'],
+    description: 'Advance a stateful persona interview by one step, returning slot metadata.',
+    whenToUse: 'Use when you want the host LLM to run a multi-turn interview over persona slots.',
+    requiredParams: [],
+    optionalParams: ['template', 'stateToken', 'answer'],
+    weight: 1.1,
+  },
+  save_metaprompt: {
+    category: 'persona',
+    keywords: ['metaprompt', 'save', 'store', 'persona'],
+    negativeKeywords: [],
+    description: 'Save a metaprompt/persona definition into the Sage workspace.',
+    whenToUse: 'Use when you want to persist a finalized persona or system prompt.',
+    requiredParams: ['title', 'body'],
+    optionalParams: ['summary', 'tags', 'appendAgentsFile'],
+    weight: 1.0,
+  },
+  get_metaprompt: {
+    category: 'persona',
+    keywords: ['metaprompt', 'persona', 'load', 'get'],
+    negativeKeywords: [],
+    description: 'Load an existing metaprompt/persona by slug.',
+    whenToUse: 'Use when you want to reuse or inspect a previously saved persona.',
+    requiredParams: ['slug'],
+    optionalParams: [],
+    weight: 1.0,
+  },
+
+  // ───────────── Library / manifest tools ─────────────
+  list_libraries: {
+    category: 'libraries',
+    keywords: ['library', 'libraries', 'list', 'browse', 'manifest'],
+    negativeKeywords: [],
+    description: 'List available prompt libraries from local workspace or on-chain.',
+    whenToUse: 'Use when you want to see which libraries/manifests are available.',
+    requiredParams: [],
+    optionalParams: ['source', 'subdao', 'limit'],
+    weight: 1.0,
+  },
+  get_prompts_from_manifest: {
+    category: 'libraries',
+    keywords: ['manifest', 'library', 'prompt', 'list', 'get'],
+    negativeKeywords: [],
+    description: 'Get all prompts from a specific manifest by CID.',
+    whenToUse: 'Use when you have a manifest CID and want to inspect its prompts.',
+    requiredParams: ['manifestCid'],
+    optionalParams: ['includeContent'],
+    weight: 1.0,
+  },
+  list_templates: {
+    category: 'libraries',
+    keywords: ['template', 'list', 'browse', 'prompt'],
+    negativeKeywords: [],
+    description: 'List available prompt templates for quick creation.',
+    whenToUse: 'Use when you want to see reusable prompt templates (not personas).',
+    requiredParams: [],
+    optionalParams: ['category', 'search'],
+    weight: 0.9,
+  },
+  create_from_template: {
+    category: 'libraries',
+    keywords: ['template', 'create', 'new', 'prompt'],
+    negativeKeywords: [],
+    description: 'Create a new prompt from a template and save into a library.',
+    whenToUse: 'Use when you want to quickly scaffold a prompt from an existing template.',
+    requiredParams: ['template', 'customize'],
+    optionalParams: ['library', 'name'],
+    weight: 1.1,
+  },
+  get_prompt_content: {
+    category: 'libraries',
+    keywords: ['get', 'prompt', 'content', 'ipfs', 'cid'],
+    negativeKeywords: ['search'],
+    description: 'Fetch full prompt content from IPFS by CID.',
+    whenToUse: 'Use when you have an IPFS CID and need the underlying prompt content.',
+    requiredParams: ['cid'],
+    optionalParams: [],
+    weight: 1.0,
+  },
+
+  // ───────────── Governance tools ─────────────
+  publish_manifest_flow: {
+    category: 'governance',
+    keywords: ['publish', 'manifest', 'dao', 'subdao', 'governance'],
+    negativeKeywords: [],
+    description: 'Prepare a manifest for on-chain publishing and generate CLI commands.',
+    whenToUse: 'Use when you are ready to publish a library/manifest to a DAO.',
+    requiredParams: ['manifest'],
+    optionalParams: ['subdao', 'description', 'dry_run'],
+    weight: 1.2,
+  },
+  list_proposals: {
+    category: 'governance',
+    keywords: ['proposal', 'governance', 'list', 'dao', 'subdao'],
+    negativeKeywords: [],
+    description: 'List active governance proposals for a specific DAO.',
+    whenToUse: 'Use when you want to inspect or track current governance proposals.',
+    requiredParams: [],
+    optionalParams: ['state', 'subdao', 'limit'],
+    weight: 1.0,
+  },
+  suggest_subdaos_for_library: {
+    category: 'governance',
+    keywords: ['subdao', 'suggest', 'library', 'publish', 'dao'],
+    negativeKeywords: [],
+    description: 'Suggest suitable DAOs for publishing a given library manifest.',
+    whenToUse: 'Use when you have a library and want advice on where to publish it.',
+    requiredParams: ['library'],
+    optionalParams: ['limit'],
+    weight: 1.0,
+  },
+  generate_publishing_commands: {
+    category: 'governance',
+    keywords: ['publish', 'commands', 'cli', 'dao', 'subdao'],
+    negativeKeywords: [],
+    description: 'Generate CLI commands for validating, uploading, and proposing a manifest.',
+    whenToUse: 'Use after selecting a DAO to get concrete CLI commands for publishing.',
+    requiredParams: ['library'],
+    optionalParams: ['target'],
+    weight: 1.0,
+  },
+
+  // ───────────── Treasury / DAO tools ─────────────
+  list_subdaos: {
+    category: 'treasury',
+    keywords: ['subdao', 'dao', 'list', 'treasury', 'governance'],
+    negativeKeywords: [],
+    description: 'List all available DAOs in the Sage Protocol.',
+    whenToUse: 'Use when you want an overview of existing DAOs and treasuries.',
+    requiredParams: [],
+    optionalParams: ['limit'],
+    weight: 0.9,
+  },
+  list_subdao_libraries: {
+    category: 'treasury',
+    keywords: ['subdao', 'library', 'libraries', 'list'],
+    negativeKeywords: [],
+    description: 'List libraries associated with a specific DAO.',
+    whenToUse: 'Use when you want to see what libraries a DAO currently governs.',
+    requiredParams: ['subdao'],
+    optionalParams: [],
+    weight: 1.0,
+  },
+
+  // ───────────── Discovery / helper tools ─────────────
+  get_project_context: {
+    category: 'discovery',
+    keywords: ['project', 'context', 'workspace', 'config', 'subdao', 'registry'],
+    negativeKeywords: [],
+    description: 'Get context about the current Sage project (root, DAO, artifact counts, etc).',
+    whenToUse: 'Use at session start to understand the project, or before tool selection to check workspace state.',
+    requiredParams: [],
+    optionalParams: [],
+    weight: 1.1,
+  },
+  trending_prompts: {
+    category: 'discovery',
+    keywords: ['trending', 'popular', 'recent', 'discover', 'prompt'],
+    negativeKeywords: ['create'],
+    description: 'List trending prompts from recent LibraryRegistry updates.',
+    whenToUse: 'Use when you want to discover popular or recently active prompts.',
+    requiredParams: [],
+    optionalParams: ['decayMinutes', 'limit'],
+    weight: 0.9,
+  },
+  help: {
+    category: 'discovery',
+    keywords: ['help', 'usage', 'docs', 'explain'],
+    negativeKeywords: [],
+    description: 'Get help on how to use Sage MCP tools and workflows.',
+    whenToUse: 'Use when you need guidance on which Sage tools to use or how to call them.',
+    requiredParams: [],
+    optionalParams: ['topic'],
+    weight: 0.9,
+  },
+};
+
+function getToolsForCategory(category) {
+  return Object.entries(TOOL_REGISTRY)
+    .filter(([, meta]) => meta.category === category)
+    .map(([name, meta]) => ({ name, ...meta }));
+}
+
+function getToolMeta(name) {
+  const meta = TOOL_REGISTRY[name];
+  if (!meta) return null;
+  return { name, ...meta };
+}
+
+module.exports = {
+  TOOL_REGISTRY,
+  getToolsForCategory,
+  getToolMeta,
+};

package/dist/cli/services/mcp/tool-args-validator.js

@@ -5,6 +5,24 @@ function createToolArgsValidator({ zodModule } = {}) {
   }
 
   const schemas = {
+    suggest_sage_tools: Z.object({
+      goal: Z.string().min(1).max(1000),
+      stage: Z.enum([
+        'prompt_workspace',
+        'persona',
+        'libraries',
+        'governance',
+        'treasury',
+        'discovery',
+      ]).optional(),
+      context: Z.object({
+        hasWorkspace: Z.boolean().optional(),
+        hasWallet: Z.boolean().optional(),
+        currentTask: Z.string().max(200).optional(),
+      }).optional(),
+      limit: Z.number().int().min(1).max(10).optional().default(5),
+      includeAlternatives: Z.boolean().optional().default(false),
+    }),
     search_prompts: Z.object({
       query: Z.string().max(256).optional().default(''),
       source: Z.enum(['local', 'onchain', 'all']).optional().default('all'),
@@ -26,6 +44,18 @@ function createToolArgsValidator({ zodModule } = {}) {
       page: Z.number().int().min(1).max(100).optional().default(1),
       pageSize: Z.number().int().min(1).max(50).optional().default(10),
     }),
+    list_prompts: Z.object({
+      source: Z.enum(['local', 'workspace', 'onchain', 'all']).optional().default('local'),
+      library: Z.string().max(200).optional().default(''),
+      limit: Z.number().int().min(1).max(100).optional().default(20),
+      kind: Z.enum(['prompt', 'skill', 'snippet']).optional(),
+      publishable: Z.boolean().optional(),
+    }),
+    get_prompt: Z.object({
+      key: Z.string().min(1).max(200),
+      library: Z.string().max(200).optional().default(''),
+    }),
+    get_project_context: Z.object({}),
     get_prompt_content: Z.object({ cid: Z.string().min(10).max(200) }),
     trending_prompts: Z.object({
       limit: Z.number().int().min(1).max(50).optional().default(10),
@@ -38,6 +68,19 @@ function createToolArgsValidator({ zodModule } = {}) {
       model: Z.string().max(100).optional(),
       interviewStyle: Z.string().max(200).optional(),
     }),
+    list_persona_templates: Z.object({}),
+    run_persona_interview: Z.object({
+      template: Z.string().min(1).max(200),
+      answers: Z.record(Z.any()),
+      save: Z.boolean().optional().default(false),
+      saveKey: Z.string().min(1).max(200).optional(),
+    }),
+    persona_interview_step: Z.object({
+      // template is required on first call, optional when stateToken is provided
+      template: Z.string().min(1).max(200).optional().default('custom'),
+      stateToken: Z.string().max(16000).optional(), // increased for slots + answers
+      answer: Z.string().max(8000).optional(),
+    }),
     save_metaprompt: Z.object({
       title: Z.string().min(1).max(200),
       summary: Z.string().max(500).optional().default(''),

package/dist/cli/services/metaprompt/anthropic-client.js

@@ -0,0 +1,87 @@
+let Anthropic;
+try {
+  // Lazy / guarded require so OpenAI-only setups don't crash on import
+  // eslint-disable-next-line global-require
+  Anthropic = require('@anthropic-ai/sdk');
+} catch (err) {
+  // Defer error until someone actually tries to construct the client
+  Anthropic = null;
+}
+
+/**
+ * Client for interacting with Anthropic's Claude API.
+ * Follows the ModelClient interface.
+ */
+class AnthropicClient {
+  /**
+   * @param {object} config
+   * @param {string} config.apiKey
+   * @param {string} [config.model]
+   * @param {number} [config.temperature]
+   */
+  constructor({ apiKey, model, temperature }) {
+    if (!Anthropic) {
+      throw new Error('Anthropic SDK not installed. Please add @anthropic-ai/sdk or configure a different provider.');
+    }
+    this.apiKey = apiKey;
+    this.model = model || 'claude-sonnet-4-20250514';
+    this.temperature = temperature ?? 0.7;
+    
+    this.client = new Anthropic({
+      apiKey: this.apiKey,
+    });
+  }
+
+  /**
+   * Stream chat completion.
+   * @param {Array<{role:string, content:string}>} messages
+   * @param {(token:string) => void} [onToken] Callback for each token
+   * @returns {Promise<string>} Full response text
+   */
+  async streamChat(messages, onToken) {
+    // Convert 'developer' role to 'system' property, as Anthropic handles system prompts separately
+    const systemMessage = messages.find(m => m.role === 'system' || m.role === 'developer');
+    const userAssistantMessages = messages.filter(m => m.role !== 'system' && m.role !== 'developer');
+
+    const stream = await this.client.messages.create({
+      model: this.model,
+      system: systemMessage ? systemMessage.content : undefined,
+      messages: userAssistantMessages,
+      max_tokens: 4096,
+      temperature: this.temperature,
+      stream: true,
+    });
+
+    let fullText = '';
+    for await (const chunk of stream) {
+      if (chunk.type === 'content_block_delta' && chunk.delta.type === 'text_delta') {
+        const content = chunk.delta.text;
+        fullText += content;
+        if (onToken) onToken(content);
+      }
+    }
+    return fullText;
+  }
+
+  /**
+   * Non-streaming chat completion.
+   * @param {Array<{role:string, content:string}>} messages
+   * @returns {Promise<string>} Full response text
+   */
+  async complete(messages) {
+    const systemMessage = messages.find(m => m.role === 'system' || m.role === 'developer');
+    const userAssistantMessages = messages.filter(m => m.role !== 'system' && m.role !== 'developer');
+
+    const response = await this.client.messages.create({
+      model: this.model,
+      system: systemMessage ? systemMessage.content : undefined,
+      messages: userAssistantMessages,
+      max_tokens: 4096,
+      temperature: this.temperature,
+    });
+
+    return response.content[0].text || '';
+  }
+}
+
+module.exports = AnthropicClient;

package/dist/cli/services/metaprompt/interview-driver.js

@@ -0,0 +1,161 @@
+const { createModelClient } = require('./model-client');
+const SlotPlanner = require('./slot-planner');
+const PromptBuilder = require('./prompt-builder');
+
+class InterviewDriver {
+  /**
+   * @param {object} config CLI config object
+   * @param {object} [options]
+   * @param {string} [options.templateKey]
+   * @param {string} [options.initialDescription]
+   * @param {string} [options.provider]
+   * @param {string} [options.model]
+   * @param {string} [options.apiKey]
+   */
+  constructor(config, options = {}) {
+    this.config = config;
+    this.client = createModelClient(config, {
+      provider: options.provider,
+      model: options.model,
+      apiKey: options.apiKey,
+    });
+    this.planner = new SlotPlanner(config, {
+      client: this.client,
+      provider: options.provider,
+      model: options.model,
+      apiKey: options.apiKey,
+    });
+    this.builder = new PromptBuilder();
+    
+    this.templateKey = options.templateKey || 'custom';
+    this.initialDescription = options.initialDescription || '';
+    this.transcript = [];
+    this.slots = []; // The plan
+    this.answers = {}; // The state of filled slots
+    this.isDone = false;
+  }
+  /**
+   * Initialize the driver. Call this before using getNextQuestion().
+   * @param {object} [precomputedState] Optional pre-existing state to restore
+   * @param {Array} [precomputedState.slots] Pre-computed slots (skips LLM planning)
+   * @param {object} [precomputedState.answers] Pre-filled answers
+   * @param {Array} [precomputedState.transcript] Prior transcript
+   */
+  async init(precomputedState = null) {
+    // If we have precomputed state, restore it (skip expensive LLM planning)
+    if (precomputedState && precomputedState.slots && precomputedState.slots.length > 0) {
+      this.slots = precomputedState.slots;
+      this.answers = precomputedState.answers || {};
+      this.transcript = precomputedState.transcript || [];
+      return;
+    }
+
+    // 1. Generate Plan (uses LLM for custom templates, static for built-ins)
+    this.slots = await this.planner.planSlots(this.templateKey, this.initialDescription);
+
+    // 2. Check if initialDescription fills any slots immediately (One-shot extraction)
+    if (this.initialDescription) {
+      await this.#extractFromText(this.initialDescription);
+    }
+  }
+
+  async getNextQuestion() {
+    if (this.isDone) return null;
+
+    // 1. Find highest priority slot that is required and empty
+    const nextSlot = this.slots.find(s => s.required && !this.answers[s.key]);
+    
+    if (!nextSlot) {
+      // All required slots filled. Check optional high priority?
+      const optionalSlot = this.slots.find(s => !this.answers[s.key] && s.priority <= 2);
+      if (optionalSlot) {
+        return await this.#generateQuestion(optionalSlot);
+      }
+      
+      // If we are here, we are effectively done with the structured part.
+      this.isDone = true;
+      return null;
+    }
+
+    return await this.#generateQuestion(nextSlot);
+  }
+
+  async processAnswer(answer) {
+    this.transcript.push({ role: 'user', content: answer });
+    await this.#extractFromText(answer); // Extract whatever we can from the answer
+  }
+
+  generateSystemPrompt() {
+    return this.builder.buildSystemPrompt(this.templateKey, this.slots, this.answers);
+  }
+
+  // --- Private Helpers ---
+
+  async #generateQuestion(slot) {
+    const systemPrompt = `
+You are an expert interviewer. Your goal is to extract specific information from the user to build an AI persona.
+Current Target: "${slot.label}" (${slot.description})
+Context So Far: ${JSON.stringify(this.answers)}
+
+Generate a single, clear, friendly question to ask the user for this information.
+Do not preface it with "Question:" or similar. Just ask.
+`;
+    const messages = [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: 'Ask the question.' }
+    ];
+    
+    const question = await this.client.complete(messages);
+    this.transcript.push({ role: 'assistant', content: question });
+    return question;
+  }
+
+  async #extractFromText(text) {
+    // Use LLM to map text to slots
+    // We send the schema + current answers + text
+    // Use JSON.stringify for the text to handle quotes, braces, and special chars safely
+    const emptySlots = this.slots.filter(s => !this.answers[s.key]);
+    if (emptySlots.length === 0) return;
+
+    const systemPrompt = `
+You are a data extraction engine.
+Slots Schema: ${JSON.stringify(emptySlots)}
+(Only extract for empty slots, but update existing if new info is better).
+
+Input Text: ${JSON.stringify(text)}
+
+Return a JSON object where keys match the slot keys and values are the extracted information.
+If no information is found for a slot, omit the key.
+CRITICAL: Return ONLY a valid JSON object, no markdown, no explanation.
+`;
+
+    const messages = [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: 'Extract data from the input text.' }
+    ];
+
+    try {
+      const response = await this.client.complete(messages);
+      // Try to find a JSON object in the response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) return;
+
+      const updates = JSON.parse(jsonMatch[0]);
+
+      // Update state
+      for (const [key, val] of Object.entries(updates)) {
+        if (val && (typeof val === 'string' || typeof val === 'object')) {
+          this.answers[key] = typeof val === 'object' ? JSON.stringify(val) : val;
+        }
+      }
+    } catch (e) {
+      // Silent fail - extraction is best-effort
+      if (process.env.SAGE_VERBOSE) {
+        console.warn('Extraction failed:', e.message);
+      }
+    }
+  }
+}
+
+module.exports = InterviewDriver;
+

package/dist/cli/services/metaprompt/model-client.js

@@ -0,0 +1,49 @@
+const OpenAIClient = require('./openai-client');
+const AnthropicClient = require('./anthropic-client');
+
+/**
+ * Factory to create the appropriate ModelClient based on available keys.
+ * @param {object} config The config object (from require('../../config'))
+ * @param {object} [overrides] Optional overrides for testing or CLI flags
+ * @param {string} [overrides.provider] 'openai' | 'anthropic'
+ * @param {string} [overrides.model]
+ * @param {string} [overrides.apiKey]
+ * @returns {OpenAIClient|AnthropicClient}
+ */
+function createModelClient(config, overrides = {}) {
+  // 1. Explicit override
+  if (overrides.provider && overrides.apiKey) {
+    if (overrides.provider === 'anthropic') {
+      return new AnthropicClient({ apiKey: overrides.apiKey, model: overrides.model });
+    }
+    if (overrides.provider === 'openai') {
+      return new OpenAIClient({ apiKey: overrides.apiKey, model: overrides.model });
+    }
+  }
+
+  // 2. Config-based resolution
+  const aiConfig = config.readAIConfig();
+  
+  // Prefer explicit provider override if key is in config
+  if (overrides.provider === 'anthropic' && aiConfig.anthropicApiKey) {
+    return new AnthropicClient({ apiKey: aiConfig.anthropicApiKey, model: overrides.model });
+  }
+  if (overrides.provider === 'openai' && aiConfig.openaiApiKey) {
+    return new OpenAIClient({ apiKey: aiConfig.openaiApiKey, model: overrides.model });
+  }
+
+  // 3. Default preference: Anthropic > OpenAI
+  if (aiConfig.anthropicApiKey) {
+    return new AnthropicClient({ apiKey: aiConfig.anthropicApiKey, model: overrides.model });
+  }
+  if (aiConfig.openaiApiKey) {
+    return new OpenAIClient({ apiKey: aiConfig.openaiApiKey, model: overrides.model });
+  }
+
+  throw new Error(
+    'No AI keys found. Please run `sage config ai set --provider anthropic --key <sk-ant-...>` or set ANTHROPIC_API_KEY.'
+  );
+}
+
+module.exports = { createModelClient };
+