@indemn/cli 1.5.0 → 1.7.0

package/src/cli/kb.ts

@@ -1,4 +1,8 @@
 import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
+import { confirmOrExit } from './link.js';
+import { CliError } from '../core/runtime.js';
+import chalk from 'chalk';
 import ora from 'ora';
 import { IndemnClient } from '../sdk/client.js';
 import { KBSDK } from '../sdk/kb.js';
@@ -138,22 +142,24 @@ export function registerKBCommands(program: Command): void {
 
   kb.command('delete')
     .argument('<kb-id>', 'Knowledge base ID')
-    .description('Delete a knowledge base')
-    .action(async (kbId: string) => {
+    .option('--dry-run', 'Show what would be deleted and stop')
+    .option('--yes', 'Do not ask for confirmation')
+    .description('Delete a knowledge base and all its sources (unlink it from agents first)')
+    .action(async (kbId: string, options) => {
       try {
-        const confirmed = await confirm(`Delete knowledge base ${kbId}? This cannot be undone.`);
-        if (!confirmed) {
-          console.log('Cancelled.');
-          return;
-        }
-
         const client = new IndemnClient();
         const sdk = new KBSDK(client);
+        const target = await sdk.getKB(kbId) as unknown as { name?: string; totalDataSourceCount?: number; aiAgents?: Array<{ name?: string }> };
+        const agents = (target.aiAgents ?? []).map((a) => a.name).filter(Boolean);
+        console.log(`Would delete "${target.name ?? kbId}" with ${target.totalDataSourceCount ?? '?'} source(s).`);
+        if (agents.length) {
+          throw new CliError(`It is linked to ${agents.join(', ')}. Unlink it first: indemn kb unlink <agent-id> ${kbId}`);
+        }
+        if (options.dryRun) return;
+        await confirmOrExit(`Delete knowledge base "${target.name ?? kbId}"? Its vectors are removed too.`, Boolean(options.yes));
         const spinner = ora('Deleting knowledge base...').start();
-
         await sdk.deleteKB(kbId);
         spinner.stop();
-
         printSuccess(`Knowledge base ${kbId} deleted.`);
       } catch (err) {
         printError(err);
@@ -289,13 +295,10 @@ export function registerKBCommands(program: Command): void {
     .argument('<kb-id>', 'Knowledge base ID')
     .argument('<source-id>', 'Data source ID')
     .description('Delete a data source')
-    .action(async (kbId: string, sourceId: string) => {
+    .option('--yes', 'Do not ask for confirmation')
+    .action(async (kbId: string, sourceId: string, options) => {
       try {
-        const confirmed = await confirm(`Delete data source ${sourceId}? This cannot be undone.`);
-        if (!confirmed) {
-          console.log('Cancelled.');
-          return;
-        }
+        await confirmOrExit(`Delete data source ${sourceId} from knowledge base ${kbId}? Its vectors are removed too.`, Boolean(options.yes));
 
         const client = new IndemnClient();
         const sdk = new KBSDK(client);
@@ -311,6 +314,102 @@ export function registerKBCommands(program: Command): void {
       }
     });
 
+  data.command('chunks')
+    .argument('<kb-id>', 'Knowledge base ID')
+    .argument('<source-id>', 'Data source ID')
+    .option('--json', 'Output as JSON')
+    .description('Show the text chunks the agent actually retrieves from a source')
+    .action(async (kbId: string, sourceId: string, options) => {
+      try {
+        const res = await new KBSDK(new IndemnClient()).chunks(kbId, sourceId);
+        if (options.json) { printJson(res); return; }
+        console.log(chalk.bold(`${res.source ?? sourceId}`) + chalk.dim(`  ${res.status ?? ''} · ${res.chunks.length} chunk(s)`));
+        res.chunks.forEach((c, i) => console.log(`${chalk.dim(`#${i + 1}`)} ${c}\n`));
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  data.command('reimport')
+    .argument('<kb-id>', 'Knowledge base ID')
+    .argument('<source-id>', 'URL data source ID')
+    .option('--js-script <file>', 'Script to run on each page before reading it')
+    .option('--yes', 'Do not ask for confirmation')
+    .description('Crawl a URL source again after the website changed (runs in the background; see `kb status`)')
+    .action(async (kbId: string, sourceId: string, options) => {
+      try {
+        await confirmOrExit(`Re-crawl source ${sourceId}? Its chunks are replaced when the crawl finishes.`, Boolean(options.yes));
+        const js = options.jsScript ? readFileSync(options.jsScript, 'utf8') : undefined;
+        await new KBSDK(new IndemnClient()).reimport(kbId, sourceId, js);
+        printSuccess(`Re-import started. Follow it with: indemn kb status ${kbId}`);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  kb.command('status')
+    .argument('<kb-id>', 'Knowledge base ID')
+    .option('--json', 'Output as JSON')
+    .description('Progress of website crawls and file imports')
+    .action(async (kbId: string, options) => {
+      try {
+        const rows = await new KBSDK(new IndemnClient()).scrapeStatus(kbId);
+        if (options.json) { printJson(rows); return; }
+        if (!rows.length) { console.log('No website or file sources yet.'); return; }
+        console.log(formatTable(['Source', 'Status', 'Job', 'Error'], rows.map((r) => [r.source ?? '', r.status ?? '', r.job_status ?? '', r.error ?? ''])));
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  kb.command('gaps')
+    .option('--agent <id>', 'Only questions asked to this agent')
+    .option('--kb <id>', 'Only questions for this knowledge base')
+    .option('--themes', 'Group into themes instead of listing questions')
+    .option('--days <n>', 'With --themes: look back this many days')
+    .option('--include-test', 'Include questions from test conversations')
+    .option('--page <n>', 'Page, starting at 0', '0')
+    .option('--limit <n>', 'Rows per page (at most 100)', '20')
+    .option('--json', 'Output as JSON')
+    .description('Questions the agents could not answer: what to add to the knowledge base next')
+    .action(async (options) => {
+      try {
+        const sdk = new KBSDK(new IndemnClient());
+        if (options.themes) {
+          printJson(await sdk.gapClusters({ days: options.days ? Number(options.days) : undefined, page: Number(options.page), limit: Number(options.limit) }));
+          return;
+        }
+        const res = await sdk.gaps({ agentId: options.agent, kbId: options.kb, includeTest: options.includeTest, page: Number(options.page), limit: Number(options.limit) }) as { responses?: Array<Record<string, unknown>>; total?: number };
+        if (options.json) { printJson(res); return; }
+        const rows = res.responses ?? [];
+        if (!rows.length) { console.log('No unanswered questions.'); return; }
+        console.log(formatTable(['Question', 'Status', 'Channel'], rows.map((r) => [String(r.user_query ?? '').slice(0, 80), String(r.status ?? ''), String(r.channel ?? '')])));
+        console.log(chalk.dim(`${res.total ?? rows.length} in total.`));
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  kb.command('check')
+    .argument('<question>', 'A question a customer might ask')
+    .option('--json', 'Output as JSON')
+    .description('Could the org\'s knowledge answer this? Shows the best matching chunks')
+    .action(async (question: string, options) => {
+      try {
+        const res = await new KBSDK(new IndemnClient()).check(question);
+        if (options.json) { printJson(res); return; }
+        console.log(res.answerable ? chalk.green(`Answerable (score ${res.top_score})`) : chalk.yellow(`Not answerable (best score ${res.top_score ?? 0})`));
+        for (const src of (res.sources ?? []).slice(0, 3) as Array<{ text?: string; score?: number }>) console.log(chalk.dim(`- (${src.score}) ${String(src.text ?? '').slice(0, 200)}`));
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
   // Link/unlink commands
   kb.command('link')
     .argument('<agent-id>', 'Agent ID')
@@ -336,8 +435,10 @@ export function registerKBCommands(program: Command): void {
     .argument('<agent-id>', 'Agent ID')
     .argument('<kb-id>', 'Knowledge base ID')
     .description('Unlink a knowledge base from an agent')
-    .action(async (agentId: string, kbId: string) => {
+    .option('--yes', 'Do not ask for confirmation')
+    .action(async (agentId: string, kbId: string, options) => {
       try {
+        await confirmOrExit(`Unlink knowledge base ${kbId} from agent ${agentId}? The agent stops using it immediately.`, Boolean(options.yes));
         const client = new IndemnClient();
         const sdk = new KBSDK(client);
         const spinner = ora('Unlinking knowledge base...').start();
@@ -376,8 +477,10 @@ export function registerKBCommands(program: Command): void {
     .argument('<kb-id>', 'Knowledge base ID')
     .description('Import QNA pairs from a JSON file into a knowledge base')
     .requiredOption('--file <path>', 'Path to JSON file with array of {question, answer} pairs')
+    .option('--yes', 'Do not ask for confirmation')
     .action(async (kbId: string, options) => {
       try {
+        await confirmOrExit(`Import into knowledge base ${kbId}? The agent starts answering from the new content once processed.`, Boolean(options.yes));
         const fs = await import('fs');
         const filePath = options.file as string;
 

package/src/cli/link.ts

@@ -0,0 +1,117 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { existsSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { IndemnClient } from '../sdk/client.js';
+import { runWithOrg } from '../core/scope.js';
+import { CliError, EXIT, isNonInteractive } from '../core/runtime.js';
+import { findLinkFile, LINK_RELATIVE_PATH } from '../core/org-resolver.js';
+import { confirm, printError, printSuccess } from './utils/output.js';
+
+export interface LinkResult {
+  path: string;
+  org_id: string;
+  org_name?: string;
+  environment: string;
+  agents: string[];
+}
+
+/**
+ * Pin `dir` to one org (and optionally a list of its agents). Every agent is
+ * checked against copilot first; nothing is written unless all pass.
+ */
+export async function writeLink(opts: { dir: string; orgFlag?: string; agents: string[] }): Promise<LinkResult> {
+  const dir = resolve(opts.dir);
+  const real = (path: string) => { try { return realpathSync(path); } catch { return resolve(path); } };
+  const homes = new Set([real(homedir()), real(process.env.HOME ?? homedir())]);
+  if (homes.has(real(dir))) {
+    throw new CliError('Refusing to link your home folder: every folder under it would be pinned. Run this inside a project folder.');
+  }
+  // Relinking may change the org, so the existing link must not decide it.
+  const client = new IndemnClient({ ignoreLink: true });
+  const org = await client.resolveOrg(opts.orgFlag);
+  const memberships = await client.memberships().catch(() => []);
+  const orgName = org.name ?? memberships.find((o) => o.id === org.id)?.name;
+
+  await runWithOrg(org.id, async () => {
+    for (const agentId of opts.agents) {
+      try {
+        await client.copilotGet(`/organization/:org_id/ai-studio/v2/bots/${agentId}`);
+      } catch (err) {
+        const why = err instanceof Error ? err.message : String(err);
+        throw new CliError(`Agent ${agentId} is not reachable in org ${orgName ?? org.id} (${why}). Nothing was linked.`);
+      }
+    }
+  });
+
+  const path = join(dir, LINK_RELATIVE_PATH);
+  const content = {
+    org_id: org.id,
+    org_name: orgName,
+    environment: client.getEnvironment(),
+    agents: opts.agents,
+    linked_at: new Date().toISOString(),
+  };
+  mkdirSync(join(dir, '.indemn'), { recursive: true });
+  writeFileSync(path, JSON.stringify(content, null, 2) + '\n');
+  return { path, org_id: org.id, org_name: orgName, environment: content.environment, agents: opts.agents };
+}
+
+export function registerLinkCommands(program: Command): void {
+  program
+    .command('link')
+    .description('Pin this folder to one org (and optionally its agents); commands here then never touch another org')
+    .argument('[agent-ids...]', 'Agents allowed from this folder (empty: any agent of the org)')
+    .option('--json', 'Output as JSON')
+    .action(async (agentIds: string[], options, cmd: Command) => {
+      try {
+        const result = await writeLink({ dir: process.cwd(), orgFlag: cmd.optsWithGlobals().org, agents: agentIds });
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+        printSuccess(`Linked ${process.cwd()} to ${result.org_name ?? result.org_id} on ${result.environment}.`);
+        console.log(chalk.dim(`  File:   ${result.path}`));
+        console.log(chalk.dim(`  Agents: ${result.agents.length ? result.agents.join(', ') : 'any agent in this org'}`));
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('unlink')
+    .description('Remove the org link from this folder')
+    .action(() => {
+      try {
+        const here = join(process.cwd(), LINK_RELATIVE_PATH);
+        if (existsSync(here)) {
+          rmSync(here);
+          printSuccess(`Removed ${here}.`);
+          return;
+        }
+        const inherited = findLinkFile();
+        if (inherited) {
+          throw new CliError(`This folder has no link of its own; it inherits ${inherited.path}. Run \`indemn unlink\` in that folder.`);
+        }
+        console.log('This folder is not linked.');
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+}
+
+/** Ask before pinning; non-interactive callers must pass --yes. */
+export async function confirmOrExit(question: string, yes: boolean): Promise<void> {
+  if (yes) return;
+  if (isNonInteractive()) {
+    printError(new CliError(`${question} Re-run with --yes to confirm.`, EXIT.NEEDS_INPUT));
+    process.exit(EXIT.NEEDS_INPUT);
+  }
+  if (!(await confirm(question))) {
+    console.log('Cancelled.');
+    process.exit(0);
+  }
+}

package/src/cli/org.ts

@@ -2,75 +2,69 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
 import { IndemnClient } from '../sdk/client.js';
-import { printError, printJson } from './utils/output.js';
+import { OrgsSDK } from '../sdk/orgs.js';
+import { getAskers, setAskers } from '../core/scope.js';
+import type { OrgContext } from '../sdk/client.js';
+import { confirmOrExit, writeLink } from './link.js';
+import { formatTable, printError, printJson, printSuccess } from './utils/output.js';
+
+const HOW: Record<OrgContext['source'], string> = {
+  flag: 'from --org',
+  env: 'from INDEMN_ORG_ID',
+  link: 'linked folder',
+  single: 'your only org',
+  asked: 'chosen',
+};
 
 export function registerOrgCommands(program: Command): void {
-  const org = program.command('org').description('Manage organizations');
+  const org = program.command('org').description('Organizations you belong to');
 
   org
     .command('list')
-    .description('List organizations you have access to')
+    .description('List organizations you belong to')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
       try {
         const client = new IndemnClient();
         const spinner = ora('Fetching organizations...').start();
-
-        // Get all project memberships
-        const res = await fetch(client.getHosts().copilot + '/projects', {
-          headers: {
-            'Authorization': `Bearer ${client.getApiKey()}`,
-            'Content-Type': 'application/json',
-          },
-        });
-        if (!res.ok) throw new Error(`Failed to fetch projects (${res.status})`);
-        const memberships = await res.json() as Array<{ id_organization?: string }>;
-
-        // Get unique org IDs
-        const orgIds = [...new Set(memberships.map(m => m.id_organization).filter(Boolean))] as string[];
-
-        // Fetch org details
-        const orgs: Array<{ _id: string; name: string; active: boolean }> = [];
-        for (const orgId of orgIds) {
-          try {
-            const orgRes = await fetch(client.getHosts().copilot + '/organization/' + orgId, {
-              headers: {
-                'Authorization': `Bearer ${client.getApiKey()}`,
-                'Content-Type': 'application/json',
-              },
-            });
-            if (orgRes.ok) {
-              const data = await orgRes.json() as { organization: { _id: string; name: string; active: boolean } };
-              orgs.push(data.organization);
-            }
-          } catch {
-            // Skip orgs we can't fetch
-          }
-        }
-
+        const orgs = await new OrgsSDK(client).listOrganizations();
         spinner.stop();
+        const linked = client.getLink()?.org_id;
 
         if (options.json) {
-          printJson(orgs.map(o => ({ id: o._id, name: o.name, active: o.active })));
+          printJson(orgs.map((o) => ({ ...o, linked_here: o.id === linked })));
           return;
         }
-
-        const currentOrgId = client.getOrgId();
-
-        // Opportunistically sync the cached org_name while we have fresh data.
-        const activeOrg = orgs.find(o => o._id === currentOrgId);
-        if (activeOrg) {
-          IndemnClient.saveConfig({ org_name: activeOrg.name });
+        if (orgs.length === 0) {
+          console.log('You are not a member of any organization on this platform.');
+          return;
         }
+        const rows = orgs
+          .sort((a, b) => a.name.localeCompare(b.name))
+          .map((o) => [o.id, o.name + (o.id === linked ? chalk.green(' (linked here)') : '')]);
+        console.log(formatTable(['ID', 'Name'], rows));
+        console.log(chalk.dim(`${orgs.length} organizations on ${client.getEnvironment()}. Pick one per command with --org <id>, or pin a folder with \`indemn link\`.`));
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
 
-        console.log(chalk.bold('Organizations'));
-        console.log('');
-        for (const o of orgs.sort((a, b) => a.name.localeCompare(b.name))) {
-          const marker = o._id === currentOrgId ? chalk.green(' (active)') : '';
-          console.log(`  ${o._id}  ${o.name}${marker}`);
+  org
+    .command('current')
+    .description('Show which org commands in this folder act on, and why (never asks)')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        setAskers({ ...getAskers(), chooseOrg: undefined });
+        const client = new IndemnClient();
+        const resolved = await client.resolveOrg();
+        const out = { id: resolved.id, name: resolved.name, source: resolved.source, link: resolved.link?.path, environment: client.getEnvironment() };
+        if (options.json) {
+          printJson(out);
+          return;
         }
-        console.log('');
-        console.log(chalk.dim(`${orgs.length} organizations. Switch with: indemn org switch <id>`));
+        console.log(`${out.name ?? '(unnamed org)'}  ${chalk.dim(out.id)}  ${chalk.dim(`${HOW[resolved.source]}${out.link ? `: ${out.link}` : ''} · ${out.environment}`)}`);
       } catch (err) {
         printError(err);
         process.exit(1);
@@ -78,34 +72,46 @@ export function registerOrgCommands(program: Command): void {
     });
 
   org
-    .command('switch')
-    .description('Switch active organization')
-    .argument('<org-id>', 'Organization ID to switch to')
-    .action(async (orgId: string) => {
+    .command('members')
+    .description('List owners, admins and agents of the org')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
       try {
         const client = new IndemnClient();
-        const spinner = ora('Switching organization...').start();
-
-        // Verify the user has access to this org
-        const orgRes = await fetch(client.getHosts().copilot + '/organization/' + orgId, {
-          headers: {
-            'Authorization': `Bearer ${client.getApiKey()}`,
-            'Content-Type': 'application/json',
-          },
-        });
-
-        if (!orgRes.ok) {
-          spinner.fail('Organization not found or you don\'t have access.');
-          process.exit(1);
+        const members = await new OrgsSDK(client).listMembers();
+        if (options.json) {
+          printJson(members);
+          return;
         }
+        if (members.length === 0) {
+          console.log('No owners, admins or agents found in this org.');
+          return;
+        }
+        console.log(formatTable(
+          ['Email', 'Name', 'Role', 'Status', 'Projects'],
+          members.map((m) => [m.email ?? '', m.name ?? '', m.role ?? '', m.status ?? '', m.projects.join(', ')]),
+        ));
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
 
-        const data = await orgRes.json() as { organization: { _id: string; name: string } };
-        const orgName = data.organization.name;
-
-        // Update config — cache both org_id and org_name so the banner can render without a lookup.
-        IndemnClient.saveConfig({ org_id: orgId, org_name: orgName });
-
-        spinner.succeed(`Switched to ${orgName} (${orgId})`);
+  org
+    .command('switch')
+    .description('Pin this folder to an org (there is no global default org any more)')
+    .argument('<org-id>', 'Organization ID')
+    .option('--yes', 'Do not ask for confirmation')
+    .action(async (orgId: string, options) => {
+      try {
+        const client = new IndemnClient({ ignoreLink: true });
+        const orgs = await client.memberships();
+        const target = orgs.find((o) => o.id === orgId);
+        if (!target) throw new Error(`You are not a member of ${orgId} on ${client.getEnvironment()}. See \`indemn org list\`.`);
+        console.log(chalk.dim('The CLI no longer keeps one default org. Commands use --org, the folder link, or ask.'));
+        await confirmOrExit(`Pin ${process.cwd()} to ${target.name}?`, Boolean(options.yes));
+        const result = await writeLink({ dir: process.cwd(), orgFlag: orgId, agents: [] });
+        printSuccess(`Linked ${process.cwd()} to ${result.org_name ?? result.org_id}. File: ${result.path}`);
       } catch (err) {
         printError(err);
         process.exit(1);

package/src/cli/platform.ts

@@ -0,0 +1,128 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync } from 'node:fs';
+import { IndemnClient } from '../sdk/client.js';
+import { PlatformSDK, type PlatformResource } from '../sdk/platform.js';
+import { jarvisChat } from '../sdk/jarvis-chat.js';
+import { CliError, EXIT } from '../core/runtime.js';
+import { confirmOrExit } from './link.js';
+import { printError, printJson, printSuccess } from './utils/output.js';
+
+function run(fn: () => Promise<void>): Promise<void> {
+  return fn().catch((err) => {
+    printError(err);
+    process.exit(1);
+  });
+}
+const sdk = () => new PlatformSDK(new IndemnClient());
+const readJson = (path: string) => JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown>;
+
+const RESOURCES: Array<{ cmd: string; resource: PlatformResource; writable: boolean; what: string }> = [
+  { cmd: 'agents', resource: 'agents', writable: true, what: 'V2 agents built from templates' },
+  { cmd: 'templates', resource: 'templates', writable: true, what: 'V2 agent templates (graphs)' },
+  { cmd: 'components', resource: 'components', writable: false, what: 'building blocks of templates (shared catalog, read-only)' },
+  { cmd: 'connectors', resource: 'connectors', writable: false, what: 'actions agents can call (shared catalog, read-only)' },
+  { cmd: 'bindings', resource: 'connector-bindings', writable: true, what: 'connector credentials and settings of the org' },
+  { cmd: 'scenarios', resource: 'scenarios', writable: true, what: 'scripted conversations for simulations' },
+];
+
+export function registerPlatformCommands(program: Command): void {
+  const platform = program.command('platform').description('The V2 platform (Darwin): V2 agents, templates, connectors, scenarios, simulations');
+
+  for (const r of RESOURCES) {
+    const g = platform.command(r.cmd).description(r.what);
+    g.command('list').option('--agent <id>', 'Only for this agent (scenarios)').action((options) => run(async () => {
+      printJson(await sdk().list(r.resource, options.agent ? { agent_id: options.agent } : undefined));
+    }));
+    g.command('get').argument('<id>').action((id: string) => run(async () => printJson(await sdk().get(r.resource, id))));
+    if (!r.writable) continue;
+    g.command('create').requiredOption('--file <path>', 'JSON body').option('--yes', 'Do not ask for confirmation').action((options) => run(async () => {
+      const body = readJson(options.file);
+      await confirmOrExit(`Create ${r.cmd.replace(/s$/, '')} "${String(body.name ?? body.connector_id ?? '')}" on the V2 platform?`, Boolean(options.yes));
+      printJson(await sdk().create(r.resource, body));
+    }));
+    g.command('update').argument('<id>').requiredOption('--file <path>', 'JSON with the fields to change').option('--yes', 'Do not ask for confirmation').action((id: string, options) => run(async () => {
+      const body = readJson(options.file);
+      await confirmOrExit(`Change ${r.cmd.replace(/s$/, '')} ${id} (${Object.keys(body).join(', ')})?`, Boolean(options.yes));
+      printJson(await sdk().update(r.resource, id, body));
+    }));
+    g.command('delete').argument('<id>').option('--yes', 'Do not ask for confirmation').action((id: string, options) => run(async () => {
+      await confirmOrExit(`Delete ${r.cmd.replace(/s$/, '')} ${id} from the V2 platform?`, Boolean(options.yes));
+      await sdk().remove(r.resource, id);
+      printSuccess(`Deleted ${id}.`);
+    }));
+  }
+
+  platform.commands.find((c) => c.name() === 'templates')!.command('validate').argument('<id>').description('Check the template graph').action((id: string) => run(async () => {
+    const res = await sdk().validateTemplate(id);
+    printJson(res);
+    if (!res.valid) process.exit(1);
+  }));
+  platform.commands.find((c) => c.name() === 'connectors')!.command('test').argument('<id>').requiredOption('--input <file>', 'JSON input')
+    .description('Validate input against the connector and preview the request (does not call it)')
+    .action((id: string, options) => run(async () => printJson(await sdk().testConnector(id, readJson(options.input)))));
+
+  const sims = platform.command('simulations').description('Run scenarios against a V2 agent');
+  sims.command('run').requiredOption('--agent <id>', 'V2 agent').option('--scenarios <ids>', 'Comma-separated scenario ids (default: all of the agent)')
+    .option('--wait', 'Wait for the result').option('--yes', 'Do not ask for confirmation')
+    .action((options) => run(async () => {
+      await confirmOrExit(`Run simulations for agent ${options.agent}? They use paid model calls.`, Boolean(options.yes));
+      const s = sdk();
+      const job = await s.runSimulation(options.agent, options.scenarios ? options.scenarios.split(',') : []) as { job_id: string };
+      if (!options.wait) { printJson(job); return; }
+      for (;;) {
+        const j = await s.simulationJob(job.job_id) as { status: string; result_id?: string };
+        if (j.status === 'completed' || j.status === 'failed') {
+          printJson(j.result_id ? await s.simulationResults({ resultId: j.result_id }) : j);
+          if (j.status === 'failed') process.exit(1);
+          return;
+        }
+        await new Promise((r) => setTimeout(r, 5_000));
+      }
+    }));
+  sims.command('jobs').option('--agent <id>').option('--status <status>').action((options) => run(async () => printJson(await sdk().simulationJobs({ agentId: options.agent, status: options.status }))));
+  sims.command('results').option('--agent <id>').option('--id <result-id>').option('--limit <n>', 'At most this many', '10')
+    .action((options) => run(async () => printJson(await sdk().simulationResults({ agentId: options.agent, resultId: options.id, limit: Number(options.limit) }))));
+
+  platform.command('org-evaluations').description('Which agents have a baseline evaluation, and which are stale').action(() => run(async () => printJson(await sdk().orgEvaluations())));
+
+  const jarvis = program.command('jarvis').description('Jarvis, the agent-building assistant of the V2 platform');
+  const jobs = jarvis.command('jobs').description('Background Jarvis jobs');
+  jobs.command('create')
+    .requiredOption('--bots <ids>', 'Comma-separated agent ids (1 to 50) to generate baseline evaluations for')
+    .option('--wait', 'Wait until the job completes')
+    .option('--yes', 'Do not ask for confirmation')
+    .action((options) => run(async () => {
+      const ids = String(options.bots).split(',').map((s: string) => s.trim()).filter(Boolean);
+      await confirmOrExit(`Ask Jarvis to generate baseline evaluations (rubric and test set) for ${ids.length} agent(s)? It uses paid model calls.`, Boolean(options.yes));
+      const s = sdk();
+      const job = await s.createJarvisJob(ids);
+      if (!options.wait) { printJson(job); return; }
+      const done = await s.waitForJarvisJob(job.job_id, { onProgress: (j) => process.stderr.write(chalk.dim(`  ${j.status} ${j.progress?.completed ?? 0}/${j.progress?.total ?? ids.length}\n`)) });
+      printJson(done);
+      if ((done.progress?.results ?? []).some((r) => !r.success)) process.exit(1);
+    }));
+  jobs.command('list').option('--status <status>').action((options) => run(async () => printJson(await sdk().jarvisJobs(options.status))));
+  jobs.command('get').argument('<job-id>').action((id: string) => run(async () => printJson(await sdk().jarvisJob(id))));
+
+  jarvis.command('chat')
+    .argument('<message>', 'What to ask Jarvis')
+    .option('--conversation <id>', 'Continue a conversation (id printed after each reply)')
+    .option('--agent <v1-agent-id>', 'The V1 agent this is about (as when Jarvis is opened from its page)')
+    .option('--yes', 'Do not ask for confirmation')
+    .option('--json', 'Print { conversation_id, reply, tools } as JSON')
+    .description('One turn with Jarvis. Jarvis can create and change templates, agents and connectors, so this asks first')
+    .action((message: string, options) => run(async () => {
+      if (!message.trim()) throw new CliError('Give a message.', EXIT.NEEDS_INPUT);
+      await confirmOrExit('Send this to Jarvis? It may create or change templates, agents or connectors in the org.', Boolean(options.yes));
+      const res = await jarvisChat(new IndemnClient(), message, {
+        conversationId: options.conversation,
+        context: options.agent ? { federation_bot_id: options.agent } : undefined,
+        onText: options.json ? undefined : (t) => process.stdout.write(t),
+        onTool: options.json ? undefined : (t) => process.stderr.write(chalk.dim(`\n  [${t.name}: ${t.status}]\n`)),
+      });
+      if (options.json) { printJson(res); return; }
+      process.stdout.write('\n');
+      console.log(chalk.dim(`Conversation ${res.conversation_id}. Continue with --conversation ${res.conversation_id}.`));
+    }));
+}