@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.3

package/src/commands/models.js

@@ -1,14 +1,24 @@
 import pc from 'picocolors';
+import { isCancel, select } from '@clack/prompts';
 import { probeOllama, resolveOllamaConfig } from './ollama.js';
 import { listModelCatalog } from '../models/index.js';
 import { discoverProviderModels } from '../models/discovery.js';
 import { resolveProviderCredential } from '../lib/provider-credentials.js';
+import { providerChoices, promptAndConfigureProvider } from './providers.js';
+import {
+  WORKERS_AI_CURATED_MODEL_IDS,
+  filterWorkersAiCurated,
+  sanitizeInventoryForClient,
+} from '../models/inventory-core.js';
+
+export { WORKERS_AI_CURATED_MODEL_IDS, filterWorkersAiCurated, sanitizeInventoryForClient };
 
 export const API_PROVIDERS = Object.freeze([
   { id: 'openai', label: 'OpenAI', credential: 'OPENAI_API_KEY' },
   { id: 'anthropic', label: 'Anthropic', credential: 'ANTHROPIC_API_KEY' },
   { id: 'gemini', label: 'Gemini', credential: 'GEMINI_API_KEY' },
   { id: 'grok', label: 'Grok / xAI', credential: 'XAI_API_KEY' },
+  { id: 'cursor', label: 'Cursor', credential: 'CURSOR_API_KEY' },
   { id: 'cloudflare', label: 'Cloudflare', credential: 'CLOUDFLARE_API_TOKEN' },
 ]);
 
@@ -55,18 +65,34 @@ function mergeStaticFallbacks(discovered = []) {
   return out;
 }
 
+/**
+ * Build credential-scoped model inventory.
+ *
+ * @param {object} [options]
+ * @param {Record<string, string>} [options.env]
+ * @param {string} [options.home]
+ * @param {boolean} [options.discoverRemote]
+ * @param {'machine'|'studio_vault'|'mixed'} [options.credentialPlane]
+ * @param {(providerId: string) => Promise<object|null>|object|null} [options.resolveCredential]
+ *   Injected resolver (Studio vault). When omitted, uses machine env.d / process env.
+ * @param {boolean} [options.curateWorkersAi] default true — intersect Cloudflare models with curated allowlist
+ * @param {boolean} [options.includeLocal] default true — probe Ollama (machine plane only by default)
+ */
 export async function collectModelsStatus(options = {}) {
   const env = options.env || process.env;
   const ollamaFetchImpl = options.fetchImpl || fetch;
   const providerFetchImpl = options.providerFetchImpl || fetch;
-  const ollamaConfig = resolveOllamaConfig({}, env);
-  const ollama = await probeOllama(ollamaConfig, ollamaFetchImpl);
-  const credentials = new Map(
-    API_PROVIDERS.map((provider) => [
-      provider.id,
-      resolveProviderCredential(provider.id, { env, home: options.home }),
-    ]),
-  );
+  const credentialPlane = options.credentialPlane || (options.resolveCredential ? 'studio_vault' : 'machine');
+  const includeLocal = options.includeLocal ?? credentialPlane === 'machine';
+  const curateWorkersAi = options.curateWorkersAi !== false;
+
+  const resolveCredential = options.resolveCredential
+    || ((providerId) => resolveProviderCredential(providerId, { env, home: options.home }));
+
+  const credentials = new Map();
+  for (const provider of API_PROVIDERS) {
+    credentials.set(provider.id, await resolveCredential(provider.id));
+  }
 
   const providers = API_PROVIDERS.map((provider) => {
     const credential = credentials.get(provider.id);
@@ -84,10 +110,20 @@ export async function collectModelsStatus(options = {}) {
 
   await Promise.all(API_PROVIDERS.map(async (provider) => {
     const credential = credentials.get(provider.id);
-    const result = shouldDiscover && credential?.configured
+    let result = shouldDiscover && credential?.configured
       ? await discoverProviderModels(provider.id, credential, { fetchImpl: providerFetchImpl })
       : emptyDiscovery();
+    if (provider.id === 'cloudflare' && result.ok && curateWorkersAi) {
+      const curated = filterWorkersAiCurated(result.models || [], { curated: true });
+      result = {
+        ...result,
+        models: curated,
+        returnedModelCount: curated.length,
+        curation: 'agentsam_workers_ai_allowlist',
+      };
+    }
     discovery[provider.id] = providerSummary(result);
+    if (result.curation) discovery[provider.id].curation = result.curation;
     providerModels[provider.id] = result.models || [];
   }));
 
@@ -95,25 +131,42 @@ export async function collectModelsStatus(options = {}) {
   const exactAvailable = discovered.filter((row) => row.availability === 'available');
   const catalogModels = mergeStaticFallbacks(discovered);
 
+  let local = {
+    provider: 'ollama',
+    configured: false,
+    online: false,
+    endpoint: null,
+    chatModel: null,
+    embedModel: null,
+    models: [],
+    error: null,
+  };
+  if (includeLocal) {
+    const ollamaConfig = resolveOllamaConfig({}, env);
+    const ollama = await probeOllama(ollamaConfig, ollamaFetchImpl);
+    local = {
+      provider: 'ollama',
+      configured: ollama.online,
+      online: ollama.online,
+      endpoint: ollama.endpoint,
+      chatModel: ollamaConfig.model,
+      embedModel: ollamaConfig.embedModel,
+      models: ollama.models || [],
+      error: ollama.error || null,
+    };
+  }
+
   return {
     schemaVersion: 'agentsam-model-inventory-v3',
     generatedAt: new Date().toISOString(),
     authority: 'per_credential_provider_discovery',
+    credential_plane: credentialPlane,
     providers,
     discovery,
     providerModels,
     catalogModels,
     availableModels: exactAvailable,
-    local: {
-      provider: 'ollama',
-      configured: ollama.online,
-      online: ollama.online,
-      endpoint: ollama.endpoint,
-      chatModel: ollamaConfig.model,
-      embedModel: ollamaConfig.embedModel,
-      models: ollama.models || [],
-      error: ollama.error || null,
-    },
+    local,
   };
 }
 
@@ -176,6 +229,10 @@ export function renderModelsStatus(status) {
     if (names.length > 30) lines.push(`    ${pc.dim(`… ${names.length - 30} more`)}`);
   }
 
+  const unconfiguredCount = status.providers.filter((p) => !p.configured).length;
+  if (unconfiguredCount > 0) {
+    lines.push(`  ${pc.yellow('Tip:')} Select your preferred provider to continue, or run 'agentsam providers'.`);
+  }
   lines.push('');
   lines.push(`  ${pc.dim('Use /model inside Agent Sam. The picker is built from the models visible to your own connected provider credentials.')}`);
   lines.push('');
@@ -185,7 +242,7 @@ export function renderModelsStatus(status) {
 export async function runModels(argv = [], options = {}) {
   if (argv.some((arg) => arg === '--help' || arg === '-h')) {
     const text = [
-      'agentsam models [--json] [--no-discover]',
+      'agentsam models [--json] [--no-discover] [--setup]',
       '',
       'Probe the provider accounts configured on this machine and list the models visible to those exact credentials.',
       'Context/output limits are taken from provider metadata when available; otherwise Agent Sam reports unknown or a clearly-labeled SDK reference.',
@@ -195,7 +252,7 @@ export async function runModels(argv = [], options = {}) {
     return;
   }
 
-  const allowed = new Set(['--json', '--no-discover']);
+  const allowed = new Set(['--json', '--no-discover', '--setup']);
   const unknown = argv.filter((arg) => !allowed.has(arg));
   if (unknown.length) throw new Error(`unknown models option: ${unknown[0]}`);
 
@@ -204,7 +261,36 @@ export async function runModels(argv = [], options = {}) {
     discoverRemote: !argv.includes('--no-discover'),
   });
   const write = options.write || ((text) => process.stdout.write(text));
-  if (argv.includes('--json')) writeLine(write, JSON.stringify(status, null, 2));
-  else write(renderModelsStatus(status));
+  if (argv.includes('--json')) {
+    writeLine(write, JSON.stringify(status, null, 2));
+    return status;
+  }
+  write(renderModelsStatus(status));
+
+  const allUnconfigured = status.providers.every((p) => !p.configured);
+  const interactive = options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (interactive && (argv.includes('--setup') || allUnconfigured)) {
+    const promptSelect = options.selectImpl || select;
+    const choices = [
+      ...providerChoices(options),
+      { value: '__skip__', label: 'Skip / Continue', hint: 'set up provider credentials later' },
+    ];
+    const choice = await promptSelect({
+      message: 'Tip: Select your preferred provider to continue',
+      options: choices,
+    });
+    if (!isCancel(choice) && choice !== '__skip__') {
+      const result = await promptAndConfigureProvider(choice, options);
+      if (result?.saved) {
+        const updated = await collectModelsStatus({
+          ...options,
+          discoverRemote: !argv.includes('--no-discover'),
+        });
+        write(renderModelsStatus(updated));
+        return updated;
+      }
+    }
+  }
+
   return status;
 }

package/src/commands/plugins.js

@@ -0,0 +1,175 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { AGENTSAM_MCP_PLUGIN_MANIFEST, normalizePluginKey } from '../plugins/index.js';
+import { authenticateViaBrowser } from '../lib/auth.js';
+import { promptToOpenUrl } from '../lib/open-url.js';
+import { readAccountSession, resolveAccountApiKey, saveAccountSession } from '../lib/account-session.js';
+
+const CATALOG = Object.freeze({ 'agentsam-mcp': AGENTSAM_MCP_PLUGIN_MANIFEST });
+const PLUGIN_MIGRATION = '0001_agentsam_plugin_runtime.sql';
+
+function statePath(cwd) { return path.join(path.resolve(cwd), '.agentsam', 'plugins.json'); }
+function readState(cwd) {
+  const filename = statePath(cwd);
+  if (!fs.existsSync(filename)) return { schema_version: 1, plugins: {} };
+  const parsed = JSON.parse(fs.readFileSync(filename, 'utf8'));
+  return { schema_version: 1, plugins: parsed?.plugins || {} };
+}
+
+function installMigration(cwd) {
+  const source = new URL(`../../migrations/d1/${PLUGIN_MIGRATION}`, import.meta.url);
+  const migrationsDir = path.join(path.resolve(cwd), 'migrations', 'd1');
+  const destination = path.join(migrationsDir, PLUGIN_MIGRATION);
+  fs.mkdirSync(migrationsDir, { recursive: true });
+  if (!fs.existsSync(destination)) fs.copyFileSync(source, destination);
+  return path.relative(path.resolve(cwd), destination);
+}
+function parse(argv) {
+  const out = {
+    action: argv[0] || 'list', key: '', cwd: process.cwd(), json: false,
+    origin: process.env.AGENTSAM_ORIGIN || process.env.AGENTSAM_API_ORIGIN || 'https://agentsam.inneranimalmedia.com',
+    timeoutMs: 180_000, noOpen: false,
+  };
+  for (let i = 1; i < argv.length; i += 1) {
+    if (argv[i] === '--cwd') out.cwd = argv[++i] || out.cwd;
+    else if (argv[i] === '--json') out.json = true;
+    else if (argv[i] === '--origin') out.origin = argv[++i] || out.origin;
+    else if (argv[i] === '--timeout') out.timeoutMs = Math.max(1_000, Number(argv[++i]) || out.timeoutMs);
+    else if (argv[i] === '--no-open') out.noOpen = true;
+    else if (!out.key) out.key = argv[i];
+    else throw new Error(`unknown plugins option:${argv[i]}`);
+  }
+  return out;
+}
+
+function writeJson(value) { process.stdout.write(`${JSON.stringify(value, null, 2)}\n`); }
+
+async function resolveCliBearer(opts) {
+  const apiKey = resolveAccountApiKey();
+  if (apiKey.value) return { token: apiKey.value, source: apiKey.source };
+  let session = readAccountSession();
+  if (!session?.access_token) {
+    if (opts.json) writeJson({ ok: false, step: 'account_login_required' });
+    else console.log('\n  No AgentSam account session found. Opening account sign-in first.\n');
+    session = await authenticateViaBrowser();
+    if (!readAccountSession()) saveAccountSession(session);
+  }
+  if (!session?.access_token) throw new Error('account_login_did_not_return_access_token');
+  return { token: session.access_token, source: 'agentsam_browser_oauth' };
+}
+
+async function fetchConnector(opts, token, pathname, init = {}) {
+  const origin = String(opts.origin).replace(/\/$/, '');
+  const headers = new Headers(init.headers || {});
+  headers.set('accept', 'application/json');
+  headers.set('authorization', `Bearer ${token}`);
+  return fetch(`${origin}${pathname}`, { ...init, headers });
+}
+
+async function connectPlugin(opts, key) {
+  if (key !== 'agentsam-mcp') throw new Error(`plugin_connect_not_supported:${key}`);
+  const state = readState(opts.cwd);
+  if (!state.plugins[key]) {
+    state.plugins[key] = { plugin_key: key, installed_at: new Date().toISOString(), manifest: CATALOG[key] };
+    fs.mkdirSync(path.dirname(statePath(opts.cwd)), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(statePath(opts.cwd), `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+    installMigration(opts.cwd);
+    if (!opts.json) console.log(`\n  Installed @${key}.`);
+  }
+
+  const { token } = await resolveCliBearer(opts);
+  const start = await fetchConnector(opts, token, '/api/connections/cloudflare/start');
+  const startBody = await start.json().catch(() => ({}));
+  if (!start.ok || !startBody.authorize_url) {
+    throw new Error(`plugin_connect_start_failed:${startBody.error || start.status}`);
+  }
+
+  if (!opts.json) {
+    console.log('\n  Connect @agentsam-mcp to Cloudflare');
+    console.log('  Your browser will ask you to approve the requested Cloudflare access.');
+  }
+  if (opts.noOpen) {
+    process.stdout.write(`${startBody.authorize_url}\n`);
+  } else {
+    await promptToOpenUrl(startBody.authorize_url, {
+      heading: 'Open Cloudflare authorization:',
+      prompt: 'Press ENTER to open Cloudflare in your browser, or copy the URL above.',
+    });
+  }
+
+  const started = Date.now();
+  let statusBody = {};
+  while (Date.now() - started < opts.timeoutMs) {
+    const status = await fetchConnector(opts, token, '/api/connections/cloudflare');
+    statusBody = await status.json().catch(() => ({}));
+    if (statusBody?.status === 'connected' || statusBody?.connection?.status === 'connected') break;
+    if (!opts.json) process.stdout.write('.');
+    await new Promise((resolve) => setTimeout(resolve, 2_000));
+  }
+  const connected = statusBody?.status === 'connected' || statusBody?.connection?.status === 'connected';
+  const result = {
+    ok: connected,
+    action: 'connect',
+    plugin_key: key,
+    provider: 'cloudflare',
+    status: connected ? 'connected' : (statusBody?.status || 'pending'),
+    cloudflare_account_id: statusBody?.cloudflareAccountId
+      || statusBody?.connection?.cloudflareAccountId
+      || statusBody?.connection?.cloudflare_account_id
+      || null,
+    scopes: statusBody?.scopes || statusBody?.connection?.scopes || [],
+  };
+  if (opts.json) writeJson(result);
+  else console.log(connected ? `\n\n  ✓ Connected @${key}\n` : `\n\n  Authorization is still pending. Run \'agentsam plugins status @${key}\' to check again.\n`);
+  return result;
+}
+
+async function statusPlugin(opts, key) {
+  if (key !== 'agentsam-mcp') throw new Error(`unknown_plugin:${key}`);
+  const { token } = await resolveCliBearer(opts);
+  const response = await fetchConnector(opts, token, '/api/connections/cloudflare');
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(`plugin_status_failed:${body.error || response.status}`);
+  const result = { ok: true, plugin_key: key, provider: 'cloudflare', ...body };
+  if (opts.json) writeJson(result);
+  else console.log(`\n  ${result.status === 'connected' ? '✓' : '○'} @${key}  ${result.status || 'not_configured'}\n`);
+  return result;
+}
+
+export async function runPlugins(argv = []) {
+  const opts = parse(argv);
+  if (opts.action === 'list') {
+    const state = readState(opts.cwd);
+    const rows = Object.values(CATALOG).map((manifest) => ({
+      plugin_key: manifest.plugin_key,
+      display_name: manifest.display_name,
+      description: manifest.description,
+      installed: Boolean(state.plugins[manifest.plugin_key]),
+      tools: manifest.tools.map((tool) => tool.tool_key),
+    }));
+    if (opts.json) process.stdout.write(`${JSON.stringify(rows, null, 2)}\n`);
+    else for (const row of rows) console.log(`  ${row.installed ? '✓' : '○'} @${row.plugin_key.padEnd(16)} ${row.description}`);
+    return rows;
+  }
+  const key = normalizePluginKey(opts.key || 'agentsam-mcp');
+  const manifest = CATALOG[key];
+  if (!manifest) throw new Error(`unknown_plugin:${key}`);
+  if (opts.action === 'connect') return connectPlugin(opts, key);
+  if (opts.action === 'status') return statusPlugin(opts, key);
+  if (opts.action !== 'install' && opts.action !== 'remove') throw new Error(`unknown plugins action:${opts.action}`);
+  const state = readState(opts.cwd);
+  let migration = null;
+  if (opts.action === 'install') {
+    state.plugins[key] = { plugin_key: key, installed_at: new Date().toISOString(), manifest };
+    migration = installMigration(opts.cwd);
+  } else {
+    delete state.plugins[key];
+  }
+  const filename = statePath(opts.cwd);
+  fs.mkdirSync(path.dirname(filename), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(filename, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+  const result = { ok: true, action: opts.action, plugin_key: key, state_file: '.agentsam/plugins.json', migration };
+  if (opts.json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  else console.log(`\n${opts.action === 'install' ? 'Installed' : 'Removed'} @${key}\n  state: ${result.state_file}${migration ? `\n  migration: ${migration}` : ''}\n`);
+  return result;
+}

package/src/commands/preferences.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { cancel, confirm, intro, isCancel, outro, select, text } from '@clack/prompts';
 import { collectModelsStatus } from './models.js';
-import { getModelRecord } from '../models/index.js';
+import { getModelRecord, mergeModelReference } from '../models/index.js';
 import { detectCliProject, readCliPreferences, writeCliPreferences } from '../lib/cli-preferences.js';
 import { readAccountSession } from '../lib/account-session.js';
 
@@ -42,6 +42,7 @@ export function availableShells(env = process.env) {
 export function modelOptions(status) {
   const options = [{ value: 'auto', label: 'Automatic', hint: 'runtime chooses from this credential\'s verified inventory', model: null }];
   for (const model of status.availableModels || []) {
+    if (model.provider === 'openai' && model.capabilities?.agent_runtime !== true) continue;
     const context = Number(model.context_window) > 0 ? ` · ctx ${Math.round(Number(model.context_window) / 1000)}k` : ' · ctx unknown';
     options.push({
       value: model.model_key,
@@ -62,22 +63,36 @@ export function modelOptions(status) {
       },
     });
   }
+  options.push({
+    value: '__configure_provider__',
+    label: '+ Configure an AI Provider',
+    hint: 'Add OpenAI, Anthropic, Gemini, Cursor, or Grok API key',
+    model: null,
+  });
   return options;
 }
 
 function resolvedModel(modelPreference, modelSnapshot) {
-  if (modelSnapshot?.model_key === modelPreference) return modelSnapshot;
+  if (modelSnapshot?.model_key === modelPreference) return mergeModelReference(modelSnapshot);
   return getModelRecord(modelPreference);
 }
 
 function reasoningOptions(modelPreference, modelSnapshot) {
   const record = resolvedModel(modelPreference, modelSnapshot);
   if (!record) return [{ value: 'auto', label: 'Automatic', hint: 'runtime/provider default' }];
-  return record.reasoning_efforts.map((value) => ({
-    value,
-    label: value === 'xhigh' ? 'Extra high' : value === 'max' ? 'Max' : value[0].toUpperCase() + value.slice(1),
-    hint: value === 'low' ? 'lighter reasoning' : value === 'max' ? 'highest supported reasoning depth' : undefined,
-  }));
+  const providerDefault = record.default_reasoning_effort || 'provider default';
+  return [
+    { value: 'auto', label: 'Automatic', hint: 'omit reasoning.effort · provider default ' + providerDefault },
+    ...record.reasoning_efforts.map((value) => ({
+      value,
+      label: value === 'xhigh' ? 'Extra high' : value === 'max' ? 'Max' : value[0].toUpperCase() + value.slice(1),
+      hint: value === record.default_reasoning_effort
+        ? 'provider default'
+        : value === 'low' ? 'lighter reasoning'
+        : value === 'max' ? 'highest supported reasoning depth'
+        : undefined,
+    })),
+  ];
 }
 
 function serviceTierOptions(modelPreference, modelSnapshot) {
@@ -96,8 +111,13 @@ async function promptModelPreferences(identity, existing, options = {}) {
   const models = modelOptions(status);
   const initialModel = models.some((row) => row.value === existing.modelPreference) ? existing.modelPreference : 'auto';
   const modelPreference = stopIfCancelled(await select({ message: 'Model', initialValue: initialModel, options: models.map(({ model, ...row }) => row) }));
+  if (modelPreference === '__configure_provider__') {
+    const { runProviders } = await import('./providers.js');
+    await runProviders([], { interactive: true, ...(options.modelStatusOptions || {}) });
+    return promptModelPreferences(identity, existing, options);
+  }
   const selected = models.find((row) => row.value === modelPreference)?.model || null;
-  const modelSnapshot = selected || (existing.modelSnapshot?.model_key === modelPreference ? existing.modelSnapshot : null);
+  const modelSnapshot = selected || (existing.modelSnapshot?.model_key === modelPreference ? mergeModelReference(existing.modelSnapshot) : null);
 
   const reasoning = reasoningOptions(modelPreference, modelSnapshot);
   const initialReasoning = reasoning.some((row) => row.value === existing.reasoningEffort) ? existing.reasoningEffort : reasoning[0].value;

package/src/commands/product.js

@@ -126,6 +126,18 @@ export async function runCapabilities(argv = []) {
 
 function featureStatePath(cwd) { return path.join(cwd, '.agentsam', 'features.json'); }
 
+function parseAddArgs(argv = []) {
+  const opts = parseCommon(argv);
+  opts.provider = '';
+  opts.schemaProfile = '';
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--provider') opts.provider = argv[++i] || '';
+    else if (arg === '--schema' || arg === '--schema-profile') opts.schemaProfile = argv[++i] || '';
+  }
+  return opts;
+}
+
 export function applyPresetSelection(cwd, preset) {
   const filename = projectConfigPath(cwd);
   if (!fs.existsSync(filename)) throw new Error('not_agentsam_project');
@@ -136,31 +148,62 @@ export function applyPresetSelection(cwd, preset) {
 }
 
 export async function runAdd(argv = []) {
-  const opts = parseCommon(argv);
+  const opts = parseAddArgs(argv);
   const id = opts.positionals[0];
   if (!id || id === '--help') {
     const rows = listAddons();
-    console.log(`agentsam add <${rows.map(x => x.id).join('|')}> [--cwd PATH] [--json]`);
+    console.log(`agentsam add <${rows.map(x => x.id).join('|')}> [--cwd PATH] [--provider <id>] [--schema <profile>] [--json]`);
     return null;
   }
   const addon = getAddon(id);
   if (!addon) throw new Error(`unknown_addon:${id}`);
   const cwd = path.resolve(opts.cwd);
   if (!fs.existsSync(projectConfigPath(cwd))) throw new Error('not_agentsam_project');
-  fs.mkdirSync(path.dirname(featureStatePath(cwd)), { recursive: true });
-  let state = { schema_version: 1, features: {} };
-  if (fs.existsSync(featureStatePath(cwd))) state = JSON.parse(fs.readFileSync(featureStatePath(cwd), 'utf8'));
-  state.features ||= {};
-  state.features[addon.id] = { selected: true, capabilities: addon.capabilities, selected_at: new Date().toISOString() };
-  fs.writeFileSync(featureStatePath(cwd), `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+
+  const { writeFeatureSelections } = await import('../features/resolve.js');
+  let state = { schema_version: 2, features: {} };
+  if (fs.existsSync(featureStatePath(cwd))) {
+    state = JSON.parse(fs.readFileSync(featureStatePath(cwd), 'utf8'));
+    state.schema_version = 2;
+    state.features ||= {};
+  }
+
+  /** @type {Record<string, unknown>} */
+  const entry = {
+    selected: true,
+    capabilities: addon.capabilities,
+    selected_at: new Date().toISOString(),
+  };
+  if (addon.id === 'auth') {
+    const { normalizeProviderTemplateId } = await import('../features/resolve.js');
+    entry.provider_template = normalizeProviderTemplateId(opts.provider) || 'inneranimalmedia';
+    if (opts.schemaProfile) entry.schema_profile = opts.schemaProfile;
+  }
+  state.features[addon.id] = entry;
+
+  const written = writeFeatureSelections(cwd, state);
   if (addon.id === 'deploy-cloudflare') {
     const config = readProjectConfig(cwd);
     setDeployTarget(config, 'cloudflare');
     writeProjectConfig(cwd, config);
   }
-  const result = { ok: true, feature: addon.id, capabilities: addon.capabilities, description: addon.description, state_file: '.agentsam/features.json' };
+  const result = {
+    ok: true,
+    feature: addon.id,
+    capabilities: addon.capabilities,
+    description: addon.description,
+    state_file: '.agentsam/features.json',
+    resolved_file: 'generated/.agentsam/features-resolved.json',
+    provider_template: entry.provider_template || null,
+    schema_profile: entry.schema_profile || null,
+    resources: written.snapshot?.features?.[addon.id]?.resources || null,
+  };
   if (opts.json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-  else console.log(`\nAdded ${addon.id}\n  ${addon.description}\n  state: ${result.state_file}\n`);
+  else {
+    console.log(`\nAdded ${addon.id}\n  ${addon.description}\n  state: ${result.state_file}`);
+    if (entry.provider_template) console.log(`  provider: ${entry.provider_template}`);
+    console.log(`  resolved: ${result.resolved_file}\n`);
+  }
   return result;
 }