@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.3

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/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(); }
 }
 

package/src/commands/mcp.js

@@ -0,0 +1,341 @@
+import {
+  deleteMcpServer,
+  detectInstalledClients,
+  inspectClientAdapter,
+  isClientRegistered,
+  listKnownServers,
+  listMcpServers,
+  listMcpTools,
+  listRegisteredClients,
+  pingMcpServer,
+  readMcpServer,
+  removeServerFromClient,
+  resolveServerPreset,
+  syncServerToClient,
+  writeMcpServer,
+} from '../mcp/index.js';
+
+function clean(value) {
+  return value == null ? '' : String(value).trim();
+}
+
+export function parseMcpArgs(argv = []) {
+  let subcommand = clean(argv[0]);
+  let help = false;
+  if (subcommand === '--help' || subcommand === '-h') {
+    help = true;
+    subcommand = '';
+  }
+  const target = clean(argv[1]);
+  let client = '';
+  let url = '';
+  let token = '';
+  let json = false;
+  let catalog = false;
+
+  for (let i = 1; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--client') client = argv[++i] || '';
+    else if (arg === '--url') url = argv[++i] || '';
+    else if (arg === '--token') token = argv[++i] || '';
+    else if (arg === '--json') json = true;
+    else if (arg === '--catalog' || arg === '--all') catalog = true;
+    else if (arg === '--help' || arg === '-h') help = true;
+  }
+
+  return {
+    subcommand,
+    target: target.startsWith('--') ? '' : target,
+    client: client.toLowerCase(),
+    url,
+    token,
+    json,
+    catalog,
+    help,
+  };
+}
+
+function renderHelp(options = {}) {
+  const clients = listRegisteredClients(options);
+  const servers = listKnownServers(options);
+
+  const presetRows = servers.map((s) => {
+    const key = (s.name || s.server_key || '').padEnd(24);
+    const desc = s.description || s.display_name || s.health_status || '';
+    return `    ${key} ${s.url} (${desc})`;
+  }).join('\n');
+
+  const clientRows = clients.map((c) => {
+    const key = c.client_key.padEnd(24);
+    const note = c.notes || c.display_name;
+    return `    ${key} ${c.display_name} (${note})`;
+  }).join('\n');
+
+  return `
+  AgentSam · MCP Client Management
+
+  Usage:
+    agentsam mcp add <name> [--client <client>|all] [--url <url>] [--token <token>]
+    agentsam mcp list [--catalog|--all] [--json]
+    agentsam mcp status [<name>] [--json]
+    agentsam mcp doctor [<name>] [--json]
+    agentsam mcp remove <name> [--client <client>|all]
+
+  Known server presets:
+${presetRows}
+
+  Recognized client adapters:
+${clientRows}
+`;
+}
+
+export async function runMcp(argv = [], options = {}) {
+  const args = parseMcpArgs(argv);
+  const write = options.write || ((text) => process.stdout.write(text));
+
+  if (args.help || !args.subcommand) {
+    write(renderHelp(options));
+    return null;
+  }
+
+  const { subcommand, target } = args;
+
+  if (subcommand === 'list') {
+    if (args.catalog) {
+      const catalog = listKnownServers(options);
+      if (args.json) {
+        write(JSON.stringify({ catalog }, null, 2) + '\n');
+        return catalog;
+      }
+      write('\n  Known MCP Server Catalog (Registry: agentsam_mcp_servers)\n\n');
+      for (const s of catalog) {
+        write(`  • ${s.name || s.server_key} (${s.display_name || s.name})\n`);
+        write(`      url:       ${s.url}\n`);
+        write(`      auth_type: ${s.auth_type || 'none'}\n`);
+        write(`      health:    ${s.health_status || 'unknown'}${s.avg_latency_ms != null ? ` · ${s.avg_latency_ms}ms` : ''}\n\n`);
+      }
+      return catalog;
+    }
+
+    const servers = listMcpServers(options);
+    if (args.json) {
+      write(JSON.stringify({ servers }, null, 2) + '\n');
+      return servers;
+    }
+    if (servers.length === 0) {
+      write('  No MCP servers configured yet. Add one with: agentsam mcp add inneranimalmedia\n');
+      return servers;
+    }
+    write('\n  Configured MCP Servers (Authority: ~/.agentsam/mcp/)\n\n');
+    for (const s of servers) {
+      write(`  • ${s.name}\n`);
+      write(`      url:     ${s.url}\n`);
+      write(`      clients: ${(s.clients || []).join(', ') || 'none'}\n`);
+      write(`      auth:    ${s.auth?.token ? 'bearer token configured' : 'none'}\n`);
+      write(`      updated: ${s.updated_at || s.created_at || 'unknown'}\n\n`);
+    }
+    return servers;
+  }
+
+  if (subcommand === 'add') {
+    const name = target || 'inneranimalmedia';
+    const preset = resolveServerPreset(name, options);
+    const url = args.url || preset?.url;
+
+    if (!url) {
+      throw new Error(`missing_url: specify --url for custom MCP server "${name}"`);
+    }
+
+    let requestedClients = ['cursor'];
+    if (args.client) {
+      if (args.client === 'all') {
+        const detected = detectInstalledClients(options);
+        requestedClients = detected.length > 0 ? detected : ['cursor', 'claude'];
+      } else {
+        requestedClients = [args.client];
+      }
+    } else if (preset?.defaultClients?.length) {
+      requestedClients = preset.defaultClients;
+    }
+
+    const serverConfig = {
+      name,
+      url,
+      protocol: preset?.protocol || 'sse',
+      auth: args.token ? { type: preset?.auth_type || 'bearer', token: args.token } : null,
+      clients: requestedClients,
+      metadata: preset ? { preset: name, description: preset.description, health_status: preset.health_status } : {},
+    };
+
+    // Store in AgentSam authority
+    const written = writeMcpServer(name, serverConfig, options);
+
+    // Materialize client adapters
+    const syncedAdapters = [];
+    for (const c of requestedClients) {
+      const res = syncServerToClient(c, name, serverConfig, options);
+      syncedAdapters.push(res);
+    }
+
+    // Ping to verify connectivity
+    const ping = await pingMcpServer(serverConfig, options);
+
+    if (args.json) {
+      const payload = { ok: true, server: written, syncedAdapters, ping };
+      write(JSON.stringify(payload, null, 2) + '\n');
+      return payload;
+    }
+
+    write(`\n  ✓ Configured MCP server: ${name}\n`);
+    write(`      Authority:   ~/.agentsam/mcp/${name}.json\n`);
+    write(`      URL:         ${url}\n`);
+    for (const a of syncedAdapters) {
+      write(`      Adapter:     ${a.client} -> ${a.configPath}\n`);
+    }
+    if (ping.ok) {
+      write(`      Ping:        ✓ Connected (${ping.latencyMs}ms)\n`);
+    } else {
+      write(`      Ping:        ⚠ Warning (${ping.error || 'unreachable'})\n`);
+    }
+    write('\n');
+    return { server: written, syncedAdapters, ping };
+  }
+
+  if (subcommand === 'status') {
+    const name = target || 'inneranimalmedia';
+    const server = readMcpServer(name, options);
+    if (!server) {
+      if (args.json) {
+        write(JSON.stringify({ ok: false, error: 'server_not_configured', name }) + '\n');
+        return null;
+      }
+      write(`  MCP server "${name}" is not configured. Run: agentsam mcp add ${name}\n`);
+      return null;
+    }
+
+    const ping = await pingMcpServer(server, options);
+    const clientStatuses = (server.clients || ['cursor']).map((c) =>
+      inspectClientAdapter(c, name, options),
+    );
+
+    const report = {
+      name,
+      url: server.url,
+      ping,
+      clients: clientStatuses,
+      hasAuth: Boolean(server.auth?.token),
+    };
+
+    if (args.json) {
+      write(JSON.stringify(report, null, 2) + '\n');
+      return report;
+    }
+
+    write(`\n  MCP Server Status: ${name}\n`);
+    write(`      URL:       ${server.url}\n`);
+    write(`      Ping:      ${ping.ok ? `✓ Active (${ping.latencyMs}ms)` : `✗ Error: ${ping.error}`}\n`);
+    write(`      Auth:      ${report.hasAuth ? '✓ Bearer token present' : '○ No auth token'}\n`);
+    for (const c of clientStatuses) {
+      write(`      ${c.client}:    ${c.configured ? '✓ Configured' : '○ Not configured'} (${c.path})\n`);
+    }
+    write('\n');
+    return report;
+  }
+
+  if (subcommand === 'doctor') {
+    const name = target || 'inneranimalmedia';
+    const server = readMcpServer(name, options);
+
+    if (!server) {
+      const errPayload = { ok: false, error: 'server_not_configured', name };
+      if (args.json) write(JSON.stringify(errPayload, null, 2) + '\n');
+      else write(`  MCP server "${name}" is not configured.\n`);
+      return errPayload;
+    }
+
+    const preset = resolveServerPreset(name, options);
+    const ping = await pingMcpServer(server, options);
+    const clientStatuses = (server.clients || ['cursor']).map((c) =>
+      inspectClientAdapter(c, name, options),
+    );
+    const toolsProbe = ping.ok ? await listMcpTools(server, options) : { count: 0, tools: [] };
+
+    const detectedClients = detectInstalledClients(options);
+    const diagnostics = {
+      name,
+      authorityPath: `~/.agentsam/mcp/${name}.json`,
+      url: server.url,
+      connectivity: ping.ok ? 'pass' : 'fail',
+      latencyMs: ping.latencyMs,
+      authConfigured: Boolean(server.auth?.token),
+      discoveredTools: toolsProbe.count,
+      clients: clientStatuses,
+      detectedHostClients: detectedClients,
+      catalogHealth: preset ? {
+        health_status: preset.health_status,
+        avg_latency_ms: preset.avg_latency_ms,
+        error_rate: preset.error_rate,
+      } : null,
+    };
+
+    if (args.json) {
+      write(JSON.stringify(diagnostics, null, 2) + '\n');
+      return diagnostics;
+    }
+
+    write(`\n  AgentSam MCP Doctor · ${name}\n\n`);
+    write(`  [1] Authority state:   ✓ Valid (~/.agentsam/mcp/${name}.json)\n`);
+    write(`  [2] Endpoint ping:     ${ping.ok ? `✓ Reachable (${ping.latencyMs}ms)` : `✗ Unreachable (${ping.error})`}\n`);
+    if (preset?.health_status) {
+      write(`  [3] Live health data:  ${preset.health_status} (avg latency: ${preset.avg_latency_ms ?? 0}ms, error rate: ${preset.error_rate ?? 0}%)\n`);
+    }
+    write(`  [4] Auth credential:   ${diagnostics.authConfigured ? '✓ Token configured' : '○ Unauthenticated / public'}\n`);
+    write(`  [5] Tool discovery:    ${toolsProbe.count > 0 ? `✓ Found ${toolsProbe.count} tools` : '○ 0 tools discovered'}\n`);
+    write(`  [6] Client adapters:\n`);
+    for (const c of clientStatuses) {
+      write(`        • ${c.client}: ${c.configured ? '✓ Synced' : '✗ Desynced'} (${c.path})\n`);
+    }
+    write('\n');
+    return diagnostics;
+  }
+
+  if (subcommand === 'remove') {
+    const name = target;
+    if (!name) throw new Error('mcp_server_name_required');
+
+    const server = readMcpServer(name, options);
+    const targetClients = args.client
+      ? (args.client === 'all' ? (server?.clients || ['cursor', 'claude']) : [args.client])
+      : (server?.clients || ['cursor', 'claude']);
+
+    const removedAdapters = [];
+    for (const c of targetClients) {
+      const res = removeServerFromClient(c, name, options);
+      removedAdapters.push(res);
+    }
+
+    let deletedAuthority = false;
+    if (!args.client || args.client === 'all') {
+      deletedAuthority = deleteMcpServer(name, options);
+    }
+
+    const result = { name, removedAdapters, deletedAuthority };
+    if (args.json) {
+      write(JSON.stringify(result, null, 2) + '\n');
+      return result;
+    }
+
+    write(`\n  ✓ Removed MCP server: ${name}\n`);
+    for (const r of removedAdapters) {
+      if (r.removed) write(`      Removed from client adapter: ${r.client} (${r.configPath})\n`);
+    }
+    if (deletedAuthority) {
+      write(`      Deleted authority: ~/.agentsam/mcp/${name}.json\n`);
+    }
+    write('\n');
+    return result;
+  }
+
+  write(`  Unknown mcp subcommand: "${subcommand}". Use "agentsam mcp --help" for guidance.\n`);
+  return null;
+}

package/src/commands/merkle-persist.js

@@ -74,7 +74,9 @@ function parse(args) {
 }
 
 export function resolveMerklePersistenceIdentity(root, options = {}) {
-  const session = options.session ?? readAccountSession(options.sessionOptions || {});
+  const session = Object.hasOwn(options, 'session')
+    ? options.session
+    : readAccountSession(options.sessionOptions || {});
   const accountId = String(session?.account_id || '').trim();
   if (!accountId) throw new Error('agentsam_login_required_for_merkle_persistence');
 

package/src/commands/merkle.js

@@ -51,11 +51,15 @@ function parse(argv) {
     if (arg === '--' && !positionalOnly) { positionalOnly = true; continue; }
     if (positionalOnly || !arg.startsWith('-')) opts.paths.push(arg);
     else if (arg === '--interactive' || arg === '--tui') opts.tui = true;
-    else if (['--json', '--force', '--semantic'].includes(arg)) opts[arg.slice(2)] = true;
-    else if (['--out', '--root', '--include', '--exclude'].includes(arg)) {
+    else if (['--json', '--force', '--semantic', '--persist'].includes(arg)) opts[arg.slice(2)] = true;
+    else if (['--out', '--root', '--include', '--exclude', '--connection-id', '--runtime-lease-id', '--capture-kind', '--wrangler-config'].includes(arg)) {
       const value = args[++i];
       if (!value || value.startsWith('--')) throw new Error(`Missing value for ${arg}`);
       if (['--include', '--exclude'].includes(arg)) opts[arg.slice(2)].push(value);
+      else if (arg === '--connection-id') opts.connectionId = value;
+      else if (arg === '--runtime-lease-id') opts.runtimeLeaseId = value;
+      else if (arg === '--capture-kind') opts.captureKind = value;
+      else if (arg === '--wrangler-config') opts.wranglerConfig = value;
       else opts[arg.slice(2)] = value;
     } else throw new Error(`Unknown option: ${arg}`);
   }
@@ -106,7 +110,18 @@ export async function runMerkle(argv = []) {
       if (opts.command === 'diff') return comparison(opts, progress);
       if (opts.command === 'snapshot') {
         const { snapshot: tree, output } = await saveSnapshot(target, { ...progress, policy: opts.policy, out: opts.out, force: opts.force, semantic: opts.semantic });
-        return { title: 'Merkle snapshot', tree, output };
+        let persisted = null;
+        if (opts.persist || opts.connectionId || opts.runtimeLeaseId) {
+          const persistArgs = [output];
+          if (opts.wranglerConfig) persistArgs.push('--wrangler-config', opts.wranglerConfig);
+          if (opts.captureKind) persistArgs.push('--capture-kind', opts.captureKind);
+          else if (opts.connectionId || opts.runtimeLeaseId) persistArgs.push('--capture-kind', 'agent');
+          if (opts.connectionId) persistArgs.push('--connection-id', opts.connectionId);
+          if (opts.runtimeLeaseId) persistArgs.push('--runtime-lease-id', opts.runtimeLeaseId);
+          if (opts.json) persistArgs.push('--json');
+          persisted = await runMerklePersist(persistArgs);
+        }
+        return { title: 'Merkle snapshot', tree, output, persisted };
       }
       const isSnapshot = ['inspect', 'explore'].includes(opts.command) && !(await fs.stat(target)).isDirectory();
       if (isSnapshot && (opts.include.length || opts.exclude.length)) throw new Error('Snapshot inspection uses saved ignore rules.');