@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.4

package/src/commands/goap.js

@@ -0,0 +1,176 @@
+import {
+  readGoapState,
+  listGoapTickets,
+  createGoapGoal,
+  switchGoapGoal,
+  closeGoapGoal,
+  renderGoapStatus,
+  renderGoapList,
+  renderGoapGoal,
+  renderGoapWhy,
+  renderGoapPlan,
+} from '../../packages/agentsam-repository/src/goap.js';
+import { readAccountSession } from '../lib/account-session.js';
+
+function parseArgs(args = []) {
+  const flags = { _: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--json') {
+      flags.json = true;
+    } else if (a.startsWith('--priority=')) {
+      flags.priority = a.slice('--priority='.length);
+    } else if (a === '--priority' || a === '-p') {
+      flags.priority = args[++i];
+    } else if (a.startsWith('--subsystem=')) {
+      flags.subsystem = a.slice('--subsystem='.length);
+    } else if (a === '--subsystem' || a === '-s') {
+      flags.subsystem = args[++i];
+    } else if (a.startsWith('--status=')) {
+      flags.status = a.slice('--status='.length);
+    } else if (a === '--status') {
+      flags.status = args[++i];
+    } else if (a.startsWith('--reason=')) {
+      flags.reason = a.slice('--reason='.length);
+    } else if (a === '--reason' || a === '-r') {
+      flags.reason = args[++i];
+    } else if (a.startsWith('--limit=')) {
+      flags.limit = parseInt(a.slice('--limit='.length), 10);
+    } else if (a === '--limit' || a === '-n') {
+      flags.limit = parseInt(args[++i], 10);
+    } else if (a.startsWith('--desc=') || a.startsWith('--description=')) {
+      flags.description = a.slice(a.indexOf('=') + 1);
+    } else if (a === '--desc' || a === '--description') {
+      flags.description = args[++i];
+    } else if (a.startsWith('--account=')) {
+      flags.accountId = a.slice('--account='.length);
+    } else if (a === '--account') {
+      flags.accountId = args[++i];
+    } else if (!a.startsWith('-')) {
+      flags._.push(a);
+    }
+  }
+  return flags;
+}
+
+/**
+ * Handle agentsam goap [status|goal|why|plan|list|new|switch|close] command.
+ */
+export async function runGoap(subcommand = 'status', options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const sub = String(subcommand || 'status').trim().toLowerCase();
+  const flags = parseArgs(options.args || []);
+  const jsonMode = Boolean(options.json || flags.json);
+  const accountId = flags.accountId || readAccountSession({ home: options.home })?.account_id || null;
+
+  if (sub === 'list' || sub === 'ls') {
+    const res = await listGoapTickets({ cwd, accountId, limit: flags.limit || 20 });
+    if (!res.ok) {
+      console.error(`Error listing GOAP tickets: ${res.error || 'unknown error'}`);
+      return;
+    }
+    if (jsonMode) {
+      console.log(JSON.stringify(res, null, 2));
+      return;
+    }
+    console.log(renderGoapList(res));
+    return;
+  }
+
+  if (sub === 'new' || sub === 'create') {
+    const title = flags._.join(' ').trim();
+    if (!title) {
+      console.error('Error: Ticket title is required.\nUsage: agentsam goap new "<title>" [--priority P1] [--subsystem sys]');
+      return;
+    }
+    const res = await createGoapGoal({
+      cwd,
+      accountId,
+      title,
+      priority: flags.priority || 'P2',
+      subsystem: flags.subsystem || 'agent-runtime',
+      description: flags.description || null,
+    });
+    if (!res.ok) {
+      console.error(`Error creating GOAP goal: ${res.error || 'unknown error'}`);
+      return;
+    }
+    if (jsonMode) {
+      console.log(JSON.stringify(res, null, 2));
+      return;
+    }
+    console.log(`Successfully created and activated GOAP goal: ${res.ticketId}`);
+    console.log(`  Title:     ${res.title}`);
+    console.log(`  Priority:  ${res.priority} [Subsystem: ${res.subsystem}]`);
+    console.log(`  Agent Run: ${res.agentRunId}`);
+    return;
+  }
+
+  if (sub === 'switch' || sub === 'select') {
+    const ticketId = flags._[0]?.trim();
+    if (!ticketId) {
+      console.error('Error: Ticket ID is required.\nUsage: agentsam goap switch <ticket_id>');
+      return;
+    }
+    const res = await switchGoapGoal({ cwd, accountId, ticketId });
+    if (!res.ok) {
+      console.error(`Error switching GOAP goal: ${res.error || 'unknown error'}`);
+      return;
+    }
+    if (jsonMode) {
+      console.log(JSON.stringify(res, null, 2));
+      return;
+    }
+    console.log(`Successfully switched active GOAP goal to: ${res.ticketId}`);
+    return;
+  }
+
+  if (sub === 'close') {
+    const ticketId = flags._[0]?.trim() || null;
+    const res = await closeGoapGoal({
+      cwd,
+      accountId,
+      ticketId,
+      status: flags.status || 'shipped',
+      statusReason: flags.reason || null,
+    });
+    if (!res.ok) {
+      console.error(`Error closing GOAP goal: ${res.error || 'unknown error'}`);
+      return;
+    }
+    if (jsonMode) {
+      console.log(JSON.stringify(res, null, 2));
+      return;
+    }
+    console.log(`Successfully closed GOAP goal: ${res.ticketId} [Status: ${res.status}]`);
+    if (res.linkedCommit) console.log(`  Linked Commit: ${res.linkedCommit.slice(0, 10)}`);
+    return;
+  }
+
+  const state = await readGoapState({ cwd, accountId });
+  if (!state.ok) {
+    console.error(`Error reading GOAP state: ${state.error || 'unknown error'}`);
+    return;
+  }
+
+  if (jsonMode) {
+    console.log(JSON.stringify(state, null, 2));
+    return;
+  }
+
+  switch (sub) {
+    case 'goal':
+      console.log(renderGoapGoal(state));
+      break;
+    case 'why':
+      console.log(renderGoapWhy(state));
+      break;
+    case 'plan':
+      console.log(renderGoapPlan(state));
+      break;
+    case 'status':
+    default:
+      console.log(renderGoapStatus(state));
+      break;
+  }
+}

package/src/commands/identity-init.js

@@ -9,6 +9,7 @@ function parseArgs(argv) {
     projectName: '',
     brandName: '',
     logoUrl: '',
+    provider: 'inneranimalmedia',
     yes: false,
     cwd: process.cwd(),
   };
@@ -18,6 +19,7 @@ function parseArgs(argv) {
     else if (arg === '--name') opts.projectName = argv[++i] || '';
     else if (arg === '--brand') opts.brandName = argv[++i] || '';
     else if (arg === '--logo-url') opts.logoUrl = argv[++i] || '';
+    else if (arg === '--provider') opts.provider = argv[++i] || opts.provider;
     else if (arg === '--cwd') opts.cwd = argv[++i] || opts.cwd;
   }
   return opts;
@@ -26,7 +28,14 @@ function parseArgs(argv) {
 export async function runIdentityInit(argv = []) {
   const opts = parseArgs(argv);
   if (!opts.projectName) {
-    console.error('\n  Usage: agentsam identity init --name <project> [--brand "App Name"] [--logo-url /logo.svg]\n');
+    console.error('\n  Usage: agentsam identity init --name <project> [--brand "App Name"] [--logo-url /logo.svg] [--provider inneranimalmedia|google|github|gcp|email|cloudflare]\n');
+    process.exit(1);
+  }
+
+  const { getIdentityProviderTemplate, writeFeatureSelections } = await import('../features/resolve.js');
+  const provider = getIdentityProviderTemplate(opts.provider);
+  if (!provider) {
+    console.error(`\n  ✗ Unknown provider template: ${opts.provider}\n`);
     process.exit(1);
   }
 
@@ -41,15 +50,30 @@ export async function runIdentityInit(argv = []) {
     brandName: opts.brandName || opts.projectName,
     logoUrl: opts.logoUrl || '/brand/logo.svg',
     sdkVersion: pkg.version,
+    provider: provider.id,
   });
 
   await writeFileTree(targetDir, files);
 
+  writeFeatureSelections(targetDir, {
+    schema_version: 2,
+    features: {
+      auth: {
+        selected: true,
+        capabilities: ['identity.init'],
+        provider_template: provider.id,
+        selected_at: new Date().toISOString(),
+      },
+    },
+  });
+
   console.log(`
   Identity app scaffold ready
   ───────────────────────────
-  Path:   ${targetDir}
-  Layout: app/frontend · backend/src · migrations/
+  Path:     ${targetDir}
+  Provider: ${provider.id} (${provider.kind})
+  Schema:   d1 · auth_users, auth_sessions, account_identities, … (see agentsam identity schema)
+  Layout:   app/frontend · backend/src · migrations/
 
   Next:
     cd ${opts.projectName}

package/src/commands/identity-protocol.js

@@ -0,0 +1,195 @@
+import {
+  formatResourcesSummary,
+  getIdentityProviderTemplate,
+  listSchemaProfiles,
+  loadIdentityProviders,
+  loadIdentityResources,
+  loadSchemaProfile,
+  resolveAuthFeature,
+  writeFeaturesResolved,
+} from '../features/resolve.js';
+
+function parseArgs(argv = []) {
+  const opts = {
+    cwd: process.cwd(),
+    json: false,
+    provider: '',
+    schemaProfile: '',
+    positionals: [],
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--json') opts.json = true;
+    else if (arg === '--cwd') opts.cwd = argv[++i] || opts.cwd;
+    else if (arg === '--provider') opts.provider = argv[++i] || '';
+    else if (arg === '--schema' || arg === '--schema-profile') opts.schemaProfile = argv[++i] || '';
+    else if (!arg.startsWith('-')) opts.positionals.push(arg);
+  }
+  return opts;
+}
+
+function writeJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+export async function runIdentityProviders(argv = []) {
+  const opts = parseArgs(argv);
+  const providers = loadIdentityProviders();
+  if (opts.json) {
+    writeJson({ ok: true, providers });
+    return providers;
+  }
+  console.log('\nIdentity provider templates\n');
+  for (const row of providers) {
+    const status = row.status ? ` · ${row.status}` : '';
+    console.log(`  ${row.id.padEnd(18)} ${String(row.kind || '').padEnd(10)} ${row.title || ''}${status}`);
+  }
+  console.log('');
+  return providers;
+}
+
+export async function runIdentityPlan(argv = []) {
+  const opts = parseArgs(argv);
+  const providerId = opts.provider || opts.positionals[0] || 'inneranimalmedia';
+  const provider = getIdentityProviderTemplate(providerId);
+  if (!provider) throw new Error(`unknown_provider_template:${providerId}`);
+
+  const selection = {
+    selected: true,
+    capabilities: ['identity.init'],
+    provider_template: provider.id,
+  };
+  const resolved = resolveAuthFeature(selection);
+  const resources = resolved.resources;
+  const tableNames = (resources.tables || []).map((t) => t.name).join(', ');
+  const migrations = (resources.migration_sources || []).join('\n             ');
+  const plan = {
+    ok: true,
+    command: 'identity.plan',
+    provider: resolved.provider,
+    resources,
+    next: [
+      'agentsam add auth',
+      `agentsam identity init --provider ${provider.id}`,
+      'agentsam identity schema',
+    ],
+  };
+
+  if (opts.json) {
+    writeJson(plan);
+    return plan;
+  }
+
+  console.log(`
+Identity plan
+─────────────
+Provider:    ${resolved.provider.id} (${resolved.provider.kind}) · ${resolved.provider.status || ''}
+Engine:      ${resources.engine}
+Migrations:  ${migrations}
+Tables:      ${tableNames}
+
+Next:
+  agentsam add auth
+  agentsam identity init --provider ${provider.id}
+  agentsam identity schema
+`);
+  return plan;
+}
+
+export async function runIdentitySchema(argv = []) {
+  const opts = parseArgs(argv);
+  const id = opts.schemaProfile || opts.positionals[0] || '';
+
+  if (!id) {
+    const resources = loadIdentityResources();
+    if (opts.json) {
+      writeJson({ ok: true, resources, also: listSchemaProfiles().filter((r) => r.id === 'better-auth-postgres') });
+      return resources;
+    }
+    if (!resources) {
+      console.error('\n  ✗ identity resources.json missing\n');
+      process.exit(1);
+    }
+    console.log(`
+Identity resources (packages/identity · oauth-login-portal)
+──────────────────────────────────────────────────────────
+Engine:      ${resources.engine}
+Migrations:`);
+    for (const src of resources.migration_sources || []) {
+      console.log(`  ${src}`);
+    }
+    console.log('Tables:');
+    for (const table of resources.tables || []) {
+      const owner = table.owner_column ? ` · owner ${table.owner_column}` : '';
+      const sensitive = table.sensitive ? ' · sensitive' : '';
+      console.log(`  ${table.name.padEnd(24)} ${table.purpose || ''}${owner}${sensitive}`);
+    }
+    console.log('');
+    return resources;
+  }
+
+  const profile = loadSchemaProfile(id);
+  if (!profile) throw new Error(`unknown_resources:${id}`);
+  if (opts.json) {
+    writeJson(profile);
+    return profile;
+  }
+
+  if (profile.tables) {
+    console.log(`
+Resources: ${profile.feature || profile.id || id}
+Engine:    ${profile.engine}
+`);
+    for (const src of profile.migration_sources || (profile.source ? [profile.source] : [])) {
+      console.log(`  migration  ${src}`);
+    }
+    console.log('');
+    for (const table of profile.tables || []) {
+      const owner = table.owner_column ? ` · owner ${table.owner_column}` : '';
+      const sensitive = table.sensitive ? ' · sensitive' : '';
+      console.log(`  ${String(table.name || '').padEnd(24)} ${table.purpose || ''}${owner}${sensitive}`);
+    }
+    console.log('');
+  } else {
+    console.log(`
+${profile.id || id}
+Engine:  ${profile.engine}
+Source:  ${profile.source || '(n/a)'}
+${profile.note ? `Note:    ${profile.note}\n` : ''}`);
+  }
+  return profile;
+}
+
+export async function runIdentityResolve(argv = []) {
+  const opts = parseArgs(argv);
+  const { path: outPath, snapshot } = writeFeaturesResolved(opts.cwd);
+  if (opts.json) {
+    writeJson({ ok: true, path: outPath, snapshot });
+    return snapshot;
+  }
+  console.log(`\nResolved features → ${outPath}\n`);
+  for (const [id, feature] of Object.entries(snapshot.features || {})) {
+    const provider = feature.provider_template || feature.provider?.id || '—';
+    if (feature.resources) {
+      console.log(`  ${id.padEnd(16)} provider=${provider} ${formatResourcesSummary(feature.resources)}`);
+    } else {
+      console.log(`  ${id.padEnd(16)} provider=${provider}`);
+    }
+  }
+  console.log('');
+  return snapshot;
+}
+
+export function printIdentityHelp() {
+  console.error(`
+  Usage:
+    agentsam identity preview [--open] [--port 8791]
+    agentsam identity init --name <project> [--brand "Name"] [--provider inneranimalmedia]
+    agentsam identity providers [--json]
+    agentsam identity plan --provider <id> [--json]
+    agentsam identity schema [--json]
+    agentsam identity resolve [--cwd PATH] [--json]
+`);
+}
+
+export { resolveAuthFeature };

package/src/commands/interaction-clack.js

@@ -0,0 +1,115 @@
+/**
+ * Present AgentSamInteraction via Clack (or plain write fallback).
+ * Hosts (shell, Local Studio, Tauri) can swap the prompt impls.
+ */
+
+import { confirm, isCancel, select, text } from '@clack/prompts';
+
+/**
+ * @param {import('../skills/interaction.js').AgentSamInteraction} interaction
+ * @param {{
+ *   write?: (s: string) => void,
+ *   interactive?: boolean,
+ *   selectImpl?: typeof select,
+ *   confirmImpl?: typeof confirm,
+ *   textImpl?: typeof text,
+ * }} [options]
+ * @returns {Promise<{ action: string|null, value: string|null, cancelled: boolean }>}
+ */
+export async function presentAgentSamInteraction(interaction, options = {}) {
+  const write = options.write || ((s) => process.stdout.write(s));
+  const interactive =
+    options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const prompt = interaction?.prompt;
+
+  if (!prompt?.message) {
+    return { action: null, value: null, cancelled: false };
+  }
+
+  for (const line of String(prompt.message).split('\n')) {
+    write(`  ${line}\n`);
+  }
+
+  if (!interactive) {
+    return { action: null, value: null, cancelled: false };
+  }
+
+  const status = interaction.status;
+
+  if (status === 'needs_input' && prompt.kind === 'select' && Array.isArray(prompt.options) && prompt.options.length) {
+    const answer = await (options.selectImpl || select)({
+      message: prompt.title || 'Choose',
+      options: prompt.options.map((opt) => ({
+        value: opt.value,
+        label: opt.label,
+        hint: opt.description,
+      })),
+    });
+    if (isCancel(answer)) return { action: null, value: null, cancelled: true };
+    return { action: String(answer), value: String(answer), cancelled: false };
+  }
+
+  if (status === 'needs_input' && prompt.kind === 'text') {
+    const answer = await (options.textImpl || text)({
+      message: prompt.title || prompt.message,
+    });
+    if (isCancel(answer)) return { action: null, value: null, cancelled: true };
+    return { action: 'text', value: String(answer), cancelled: false };
+  }
+
+  if (status === 'needs_approval' || (status === 'needs_input' && prompt.kind === 'confirm')) {
+    const answer = await (options.confirmImpl || confirm)({
+      message: prompt.title || prompt.message,
+    });
+    if (isCancel(answer)) return { action: null, value: null, cancelled: true };
+    return { action: answer ? 'confirm' : 'cancel', value: answer ? 'yes' : 'no', cancelled: false };
+  }
+
+  if (
+    (status === 'blocked' || status === 'needs_input') &&
+    Array.isArray(prompt.actions) &&
+    prompt.actions.length
+  ) {
+    const answer = await (options.selectImpl || select)({
+      message: prompt.title || 'Next',
+      options: prompt.actions.map((a) => ({ value: a.id, label: a.label })),
+    });
+    if (isCancel(answer)) return { action: null, value: null, cancelled: true };
+    return { action: String(answer), value: String(answer), cancelled: false };
+  }
+
+  return { action: null, value: null, cancelled: false };
+}
+
+/**
+ * Map shell skill interaction choices to follow-up CLI actions.
+ */
+export async function handleSkillInteractionChoice(choice, state = {}) {
+  const write = state.write || ((s) => process.stdout.write(s));
+  const { runSkill } = await import('./skill.js');
+  if (!choice || choice.cancelled) return null;
+  if (choice.action === 'create' || choice.value === 'create') {
+    const id = 'my-first-skill';
+    write(`\n  Running: agentsam skill create ${id}\n\n`);
+    return runSkill(['create', id], { write, home: state.home, env: state.env });
+  }
+  if (typeof choice.value === 'string' && choice.value.startsWith('create:')) {
+    const id = choice.value.slice('create:'.length) || 'my-first-skill';
+    write(`\n  Running: agentsam skill create ${id}\n\n`);
+    return runSkill(['create', id], { write, home: state.home, env: state.env });
+  }
+  if (typeof choice.action === 'string' && choice.action.startsWith('create:')) {
+    const id = choice.action.slice('create:'.length) || 'my-first-skill';
+    write(`\n  Running: agentsam skill create ${id}\n\n`);
+    return runSkill(['create', id], { write, home: state.home, env: state.env });
+  }
+  if (choice.action === 'install' || choice.value === 'install') {
+    write('\n  Next: agentsam skill install ./path-to-skill  (or @scope/pkg)\n\n');
+    return null;
+  }
+  if (choice.action === 'list' || choice.value === 'list') {
+    return runSkill(['list'], { write, home: state.home, env: state.env });
+  }
+  // create with prefilled id handled above
+  return null;
+}

package/src/commands/knowledge.js

@@ -11,7 +11,7 @@ import { CONFIG_PATH, repositoryRoot, initRepository, readConfig, defaultConfig,
 import { openSqliteStore } from '../knowledge/stores/sqlite.js';
 import { openPostgresStore } from '../knowledge/stores/postgres.js';
 import { planIndex, runIndex, retrieve } from '../knowledge/engine.js';
-import { createGeminiEmbedder } from '../knowledge/providers/gemini.js';
+import { createProviderRegistry } from '../../packages/agentsam-knowledge/src/providers/index.js';
 import { compareObservations } from '../knowledge/evolution.js';
 import { ensureProjectManifest, getProjectName, getRepositoryId, portableRepositoryIdFromGit, tryReadProjectConfig } from '../lib/project-config.js';
 import { ensureProjectRules } from '../lib/project-rules.js';
@@ -24,7 +24,18 @@ const localPath = root => path.join(root, '.agentsam', 'knowledge', 'index.sqlit
 async function openStore(root, config, readOnly = false) {
   return config.storage.driver === 'sqlite' ? openSqliteStore(localPath(root), { readOnly }) : openPostgresStore(process.env[config.storage.connection_env]);
 }
-function provider() { return createGeminiEmbedder({ apiKey: process.env.GEMINI_API_KEY }); }
+function provider(profile) {
+  if (profile?.provider === 'none') throw new Error('Embedding is disabled for this profile. Configure an explicit provider with `agentsam autorag configure --provider … --semantic`.');
+  const adapter = createProviderRegistry().get(profile?.provider);
+  return {
+    validate: input => adapter.validate(input),
+    async embed(text, input, context) {
+      return context?.kind === 'query'
+        ? adapter.embedQuery(text, input, context)
+        : (await adapter.embedDocuments([text], input, context))[0];
+    },
+  };
+}
 function resolveKnowledgeConfig(root) {
   const filename = path.join(root, CONFIG_PATH);
   if (fs.existsSync(filename)) return readConfig(root);
@@ -51,7 +62,14 @@ export async function runRepositoryInit(argv) {
     if (projectRepositoryId && existingKnowledge.repository_id !== projectRepositoryId) {
       throw new Error(`repository_identity_mismatch: project=${projectRepositoryId} knowledge=${existingKnowledge.repository_id}`);
     }
-    throw new Error(`${CONFIG_PATH} already exists; edit it to change scope/profile. Existing configuration was preserved.`);
+    show({
+      root,
+      config: CONFIG_PATH,
+      storage: existingKnowledge.storage?.driver || 'sqlite',
+      status: 'already_initialized',
+      note: `${CONFIG_PATH} already exists; existing configuration was preserved.`,
+    });
+    return;
   }
   let include = opts.include, exclude = opts.exclude, target = opts.target, dimensions = opts.dimensions;
   if (!opts.yes) {
@@ -91,7 +109,7 @@ export async function runKnowledge(argv) {
     else if (command === 'run') {
       // Lazy adapter creation means a fully cached --embed run needs no API key.
       let adapter;
-      const embedder = { embed: (...args) => (adapter ??= provider()).embed(...args) };
+      const embedder = { validate: (...args) => (adapter ??= provider(config.embedding)).validate(...args), embed: (...args) => (adapter ??= provider(config.embedding)).embed(...args) };
       show(await runIndex({ root, config, store, embed: opts.embed, embedder, maxInputs: Number(opts['max-inputs'] ?? 100), maxCharacters: Number(opts['max-characters'] ?? 200000) }));
     } else if (command === 'history') show((await store?.history(scopeKey(config)) || []).map(g => ({ id: g.id, created_at: g.created_at, git: g.git, ...g.receipt })));
     else {
@@ -102,11 +120,52 @@ export async function runKnowledge(argv) {
   } finally { await store?.close(); }
 }
 
+export async function runKnowledgeSearch({
+  cwd = process.cwd(),
+  query = '',
+  text = '',
+  semantic = false,
+  topK = 8,
+  tokenBudget = 6000,
+  generationId = null,
+} = {}) {
+  const q = String(query || text || '').trim();
+  const root = repositoryRoot(cwd);
+  const sqliteFile = localPath(root);
+  const config = resolveKnowledgeConfig(root);
+  if (config.storage.driver === 'sqlite' && !fs.existsSync(sqliteFile)) {
+    return {
+      queryId: 'none',
+      query: { text: q, top_k: topK, token_budget: tokenBudget },
+      hits: [],
+      diagnostics: {
+        indexed: false,
+        message: 'Knowledge store not initialized. Run `agentsam index run` to build repository index.',
+      },
+    };
+  }
+  const store = await openStore(root, config, true);
+  try {
+    return await retrieve({
+      store,
+      config,
+      text: q,
+      semantic: Boolean(semantic),
+      embedder: semantic ? provider(config.embedding) : null,
+      topK: Number(topK || 8),
+      tokenBudget: Number(tokenBudget || 6000),
+      generationId,
+    });
+  } finally {
+    await store?.close();
+  }
+}
+
 export async function runSearch(argv) {
   const { values: opts, positionals } = flags(argv, { semantic: { type: 'boolean' }, 'top-k': { type: 'string' }, 'token-budget': { type: 'string' }, generation: { type: 'string' } });
   if (opts.help) { console.log('agentsam search "query" [--cwd PATH] [--semantic] [--top-k 8] [--token-budget 6000] [--generation ID]'); return; }
   const root = repositoryRoot(opts.cwd), config = resolveKnowledgeConfig(root), store = await openStore(root, config, true);
-  try { show(await retrieve({ store, config, text: positionals.join(' '), semantic: opts.semantic, embedder: opts.semantic ? provider() : null, topK: Number(opts['top-k'] || 8), tokenBudget: Number(opts['token-budget'] || 6000), generationId: opts.generation })); }
+  try { show(await retrieve({ store, config, text: positionals.join(' '), semantic: opts.semantic, embedder: opts.semantic ? provider(config.embedding) : null, topK: Number(opts['top-k'] || 8), tokenBudget: Number(opts['token-budget'] || 6000), generationId: opts.generation })); }
   finally { await store?.close(); }
 }