@indemn/cli 1.6.0 → 1.7.1

package/src/sdk/types.ts

@@ -6,14 +6,52 @@ export interface EnvironmentHosts {
   copilot: string;
   evaluations: string;
   middleware: string;
+  /** Darwin, the V2 platform API (Jarvis, V2 agents, role-checked V1 agent changes). */
+  platform?: string;
+}
+
+/** The copilot session the CLI keeps after login. Same token the dashboard uses. */
+export interface StoredSession {
+  /** copilot JWT, without the "JWT " prefix. */
+  token: string;
+  /** ISO time the token stops working, from its `exp` claim. */
+  expires_at?: string;
+  /** Firebase refresh token: lets the CLI get a new session without a password. */
+  refresh_token?: string;
+}
+
+export interface OrgSummary {
+  id: string;
+  name: string;
+}
+
+/** The copilot session the CLI keeps after login. Same token the dashboard uses. */
+export interface StoredSession {
+  /** copilot JWT, without the "JWT " prefix. */
+  token: string;
+  /** ISO time the token stops working, from its `exp` claim. */
+  expires_at?: string;
+  /** Firebase refresh token: lets the CLI get a new session without a password. */
+  refresh_token?: string;
+}
+
+export interface OrgSummary {
+  id: string;
+  name: string;
 }
 
 export interface IndemnConfig {
-  api_key: string;
-  org_id: string;
-  org_name?: string;
-  user_id: string;
   environment: Environment;
+  user_id: string;
+  email?: string;
+  session?: StoredSession;
+  /** Orgs the user belonged to at login (refreshed by `indemn org list`). Never the org a command uses. */
+  orgs?: OrgSummary[];
+  /** Legacy: saved by logins before token-first auth. Honoured until the next login. */
+  api_key?: string;
+  /** Legacy default org from before per-action orgs. Ignored. */
+  org_id?: string;
+  org_name?: string;
   hosts: Record<Environment, EnvironmentHosts>;
 }
 
@@ -116,6 +154,11 @@ export interface FunctionParameter {
   type: string;
   description?: string;
   is_required?: boolean;
+  /** Fixed choices (copilot calls them enums; shown to the customer as buttons). */
+  enums?: Array<{ title?: string; payload?: string; type?: string; url?: string }>;
+  isEnumsEnabled?: boolean;
+  question_title?: string;
+  descriptionOps?: unknown;
 }
 
 export interface CreateFunctionInput {
@@ -232,20 +275,32 @@ export interface CreateRubricInput {
 }
 
 export interface TestItem {
-  type: 'single_turn' | 'scenario' | 'voice_simulation';
+  item_id?: string;
+  type: 'single_turn' | 'scenario' | 'voice_simulation' | 'transcript';
   name: string;
+  /** single_turn: message; scenario: persona, initial_message, max_turns; voice_simulation adds caller fields (goal, phone, scripted_user_responses, tool_execution, ...). */
   inputs: {
     message?: string;
     persona?: string;
     initial_message?: string;
     max_turns?: number;
+    [key: string]: unknown;
   };
   expected: {
     success_criteria: string[];
     expected_outcome?: string;
+    tool_present?: string[];
+    tool_absent?: string[];
+    handoff_to?: string;
+    assertions?: Array<Record<string, unknown>>;
+    knowledge_base?: Record<string, unknown>;
+    voice?: Record<string, unknown>;
+    [key: string]: unknown;
   };
   tags?: string[];
-  priority?: 'high' | 'medium' | 'low';
+  priority?: string;
+  acceptance_id?: string;
+  section?: string;
 }
 
 export interface TestSet {
@@ -279,6 +334,11 @@ export interface EvaluationTriggerInput {
   component_ids?: string[];
   conversation_ids?: string[];
   mode?: string;
+  /** Transcript mode only: conversations created from this ISO date (inclusive)... */
+  date_from?: string;
+  /** ...to this ISO date (exclusive). */
+  date_to?: string;
+  webhook_url?: string;
 }
 
 export interface EvaluationTriggerResponse {
@@ -300,6 +360,10 @@ export interface EvaluationRun {
   completed?: number;
   passed?: number;
   failed?: number;
+  /** Infrastructure errors, not agent failures. */
+  errors?: number;
+  not_evaluated?: number;
+  latency?: { count?: number; avg_ms?: number; p50_ms?: number; p95_ms?: number; max_ms?: number };
   concurrency?: number;
   started_at?: string;
   completed_at?: string;
@@ -354,3 +418,21 @@ export interface UserMessage {
   session_id: string;
   is_user_message_sent: boolean;
 }
+
+// Organization types
+
+export interface OrgMember {
+  user_id: string;
+  email?: string;
+  name?: string;
+  role?: string;
+  status?: string;
+  projects: string[];
+}
+
+export interface Channel {
+  _id: string;
+  name: string;
+  type?: string;
+  description?: string;
+}

package/src/sdk/voice.ts

@@ -0,0 +1,262 @@
+import { randomBytes } from 'node:crypto';
+import type { IndemnClient } from './client.js';
+import { AgentsSDK } from './agents.js';
+import { CliError, EXIT } from '../core/runtime.js';
+
+export interface VoiceSettingsInput {
+  provider: string;
+  voice_id: string;
+  name: string;
+  gender: string;
+  language: string;
+  countryCode: string;
+  model?: string;
+  settings?: { speed?: number };
+  public_owner_id?: string;
+}
+
+interface PhoneConfig {
+  _id?: string;
+  phoneNumber?: string;
+  friendlyName?: string;
+  modelSettings?: Record<string, unknown>;
+  is_active?: boolean;
+  [key: string]: unknown;
+}
+
+/** A number offered for sale (Twilio's record, as voice-service returns it). */
+export interface AvailableNumber {
+  phoneNumber?: string;
+  friendlyName?: string;
+  locality?: string;
+  region?: string;
+  postalCode?: string;
+  isoCountry?: string;
+  capabilities?: Record<string, boolean>;
+  [key: string]: unknown;
+}
+
+const SEARCH_COUNTRIES = ['US', 'CA', 'GB', 'AU'];
+
+/** +E.164 from what a person typed: "(331) 204-4919" or "331 204 4919" in the US/Canada, or "+44 20 ...". */
+export function toE164(input: string, country = 'US'): string {
+  const digits = input.replace(/\D/g, '');
+  if (input.trim().startsWith('+')) return `+${digits}`;
+  if ((country === 'US' || country === 'CA') && digits.length === 10) return `+1${digits}`;
+  return `+${digits}`;
+}
+
+/** A Twilio-shaped call id, as the dashboard's web call sends it. */
+function callSid(): string {
+  return 'CA' + randomBytes(16).toString('hex').toUpperCase();
+}
+
+/**
+ * Voices, voice models, phone numbers and voice previews of agents.
+ * Several copilot voice routes do not check that the agent belongs to the
+ * caller's org, so every agent-level call here checks that first.
+ */
+export class VoiceSDK {
+  /**
+   * Numbers this session detached, by org and number, with their saved details. copilot's
+   * owned-numbers list can come back empty (its cached org id does not match the query), and a
+   * number just detached from an agent of the org is owned: re-attaching it never buys.
+   */
+  private detached = new Map<string, PhoneConfig>();
+
+  constructor(private client: IndemnClient) {}
+
+  private async assertAgent(agentId: string): Promise<void> {
+    const agent = await new AgentsSDK(this.client).getAgent(agentId).catch(() => undefined);
+    if (!agent) throw new CliError(`Agent ${agentId} is not in the organization this command acts on.`);
+  }
+
+  /** Voices of a TTS provider (cartesia default, or elevenlabs), filterable. */
+  listVoices(opts: { provider?: string; language?: string; gender?: string; q?: string; limit?: number; cursor?: string } = {}): Promise<{ data?: unknown[]; has_more?: boolean; next_page?: unknown }> {
+    const q: Record<string, string> = { provider: opts.provider ?? 'cartesia', limit: String(opts.limit ?? 50) };
+    if (opts.language) q.language = opts.language;
+    if (opts.gender) q.gender = opts.gender;
+    if (opts.q) q.q = opts.q;
+    if (opts.cursor) q.starting_after = opts.cursor;
+    return this.client.copilotGet('/voices', q);
+  }
+
+  /** Allowed filter values (languages, genders, accents) of a provider. */
+  voiceFilters(provider: string): Promise<unknown> {
+    return this.client.copilotGet(`/voices/settings/${provider}`, { service: 'tts' });
+  }
+
+  /**
+   * Speech sample of a voice (audio bytes). The platform only speaks Cartesia voices; for ElevenLabs the
+   * voice's own preview recording is used, as in the dashboard (it cannot say custom text).
+   */
+  async playVoice(voiceId: string, text?: string, speed?: number, opts: { provider?: string; name?: string; language?: string } = {}): Promise<{ contentType: string; data: Buffer }> {
+    if (opts.provider === 'elevenlabs') {
+      const found = await this.listVoices({ provider: 'elevenlabs', q: opts.name ?? voiceId, limit: 50 }) as { data?: Array<{ voice_id?: string; preview_url?: string }> };
+      const url = found.data?.find((v) => v.voice_id === voiceId)?.preview_url;
+      if (!url) throw new CliError(`No preview recording found for ElevenLabs voice ${opts.name ?? voiceId}.`);
+      const res = await fetch(url);
+      if (!res.ok) throw new CliError(`Could not download the preview of ${opts.name ?? voiceId} (${res.status}).`);
+      return { contentType: res.headers.get('content-type') ?? 'audio/mpeg', data: Buffer.from(await res.arrayBuffer()) };
+    }
+    return this.client.copilotBinary('POST', '/voices/play', { voice_id: voiceId, ...(text ? { text } : {}), ...(speed ? { speed } : {}), ...(opts.language ? { language: opts.language } : {}) });
+  }
+
+  /** Speech-to-text or text-to-speech provider and model catalog. */
+  voiceModels(kind: 'stt' | 'tts'): Promise<unknown[]> {
+    return this.client.copilotGet('/organization/:org_id/ai-studio/voice-models', { kind });
+  }
+
+  /** Phone numbers attached to an agent, with their voice settings. */
+  async agentNumbers(agentId: string): Promise<PhoneConfig[]> {
+    await this.assertAgent(agentId);
+    return this.client.copilotGet<PhoneConfig[]>(`/organization/:org_id/ai-studio/bots/${agentId}/configurations/voice/numbers`);
+  }
+
+  /** The agent's voice settings. Voice settings live on its phone number, so an agent without one has none. */
+  async getAgentVoice(agentId: string): Promise<Record<string, unknown>> {
+    const numbers = await this.agentNumbers(agentId);
+    if (!numbers.length) throw new CliError(`Agent ${agentId} has no phone number, so it has no voice settings yet. Attach one with \`indemn agents numbers attach\`.`, EXIT.NEEDS_INPUT);
+    return (numbers[0].modelSettings ?? {}) as Record<string, unknown>;
+  }
+
+  /**
+   * Set the text-to-speech voice of an agent. voice-service replaces the saved voice settings whole, so a
+   * speed that is not given keeps the saved one (the dashboard always sends it).
+   */
+  async setAgentVoice(agentId: string, input: VoiceSettingsInput & Record<string, unknown>): Promise<unknown> {
+    const current = await this.getAgentVoice(agentId) as { tts?: { settings?: { speed?: number } } }; // fails clearly when there is no number
+    const body = { ...input, countryCode: input.countryCode.toLowerCase(), settings: { ...(current.tts?.settings ?? {}), ...(input.settings ?? {}) } };
+    return this.client.copilotPost(`/organization/:org_id/ai-studio/bots/${agentId}/voices`, body);
+  }
+
+  /** Set the speech-to-text transcriber (provider, model, language, key terms) of an agent, as the dashboard does. */
+  async setAgentTranscriber(agentId: string, stt: { provider: string; model: string; language: string; keyterms?: string[] }): Promise<unknown> {
+    await this.getAgentVoice(agentId); // fails clearly when there is no number
+    const keyterms = (stt.keyterms ?? []).map((k) => k.trim()).filter(Boolean);
+    if (keyterms.length > 50 || keyterms.some((k) => k.length > 100)) throw new CliError('Up to 50 key terms of at most 100 characters each.', EXIT.NEEDS_INPUT);
+    return this.client.copilotPost(`/organization/:org_id/ai-studio/bots/${agentId}/voices`, {
+      stt: { provider: stt.provider, model: stt.model, language: stt.language, config: { keyterm: keyterms } },
+    });
+  }
+
+  /** Numbers the org owns (is_active: attached to some agent). */
+  orgNumbers(): Promise<PhoneConfig[]> {
+    return this.client.copilotGet('/organization/:org_id/voice/configurations/numbers');
+  }
+
+  /**
+   * Attach a number the org already owns. Never buys one: copilot would buy a
+   * Twilio number for an unknown number, which costs money, so unknown numbers
+   * are refused here. Re-attaching resets the number's voice settings.
+   */
+  async attachNumber(agentId: string, phoneNumber: string, type = 'local'): Promise<unknown> {
+    const agent = await new AgentsSDK(this.client).getAgent(agentId).catch(() => undefined);
+    if (!agent) throw new CliError(`Agent ${agentId} is not in the organization this command acts on.`);
+    const channels = ((agent.channels as unknown[] | undefined) ?? []).map((c) => String(typeof c === 'string' ? c : (c as { type?: unknown }).type ?? '').toUpperCase());
+    if (!channels.includes('VOICE')) throw new CliError(`"${agent.name}" does not answer the phone (no VOICE channel), so a number would not reach it.`);
+    const existing = await this.agentNumbers(agentId);
+    if (existing.length) throw new CliError(`"${agent.name}" already has ${existing[0].phoneNumber}. Detach it first; an agent has one number.`);
+    const key = `${await this.client.currentOrgId()}:${phoneNumber}`;
+    const owned = (await this.orgNumbers()).find((n) => n.phoneNumber === phoneNumber) ?? this.detached.get(key);
+    if (!owned) {
+      throw new CliError(`${phoneNumber} is not a number this org owns. Buying numbers is not available from the CLI; buy it in the dashboard first.`);
+    }
+    if (owned.is_active) throw new CliError(`${phoneNumber} is already attached to an agent. Detach it there first.`);
+    // copilot overwrites the number's details with what it is sent: send the saved ones back.
+    const result = await this.client.copilotPost(`/organization/:org_id/ai-studio/bots/${agentId}/configurations/voice/numbers`, {
+      type: typeof owned.type === 'string' ? owned.type : type, phoneNumber,
+      ...(owned.friendlyName ? { friendlyName: owned.friendlyName } : {}),
+      ...(owned.additionalDetails ? { payload: owned.additionalDetails } : {}),
+    });
+    this.detached.delete(key);
+    return result;
+  }
+
+  /**
+   * Numbers available to buy, as the dashboard's "Pick a new phone number" lists them (Twilio through
+   * voice-service). Free: nothing is bought. `contains` narrows to numbers containing those digits.
+   */
+  async searchNumbers(opts: { areaCode?: string; contains?: string; country?: string; tollFree?: boolean; limit?: number } = {}): Promise<AvailableNumber[]> {
+    const country = (opts.country ?? 'US').toUpperCase();
+    if (!SEARCH_COUNTRIES.includes(country)) throw new CliError(`Numbers can be searched in ${SEARCH_COUNTRIES.join(', ')}.`, EXIT.NEEDS_INPUT);
+    const limit = Math.min(Math.max(opts.limit ?? 5, 1), 20);
+    const q: Record<string, string> = { countryCode: country, limit: String(limit) };
+    if (opts.areaCode) q.areaCode = opts.areaCode.replace(/\D/g, '').slice(0, 3);
+    if (opts.contains) q.pattern = opts.contains.replace(/\D/g, '');
+    const rows = await this.client.copilotGet<AvailableNumber[]>(`/organization/:org_id/voice/configurations/numbers/${opts.tollFree ? 'toll-free' : 'local'}`, q);
+    return (rows ?? []).slice(0, limit);
+  }
+
+  /** The agent's phone number with its location and a summary of its voice settings. */
+  async numberDetails(agentId: string): Promise<Record<string, unknown>> {
+    const [num] = await this.agentNumbers(agentId);
+    if (!num) throw new CliError(`Agent ${agentId} has no phone number. Find one with \`indemn agents numbers search\`.`, EXIT.NEEDS_INPUT);
+    const d = (num.additionalDetails ?? {}) as AvailableNumber;
+    const m = (num.modelSettings ?? {}) as { tts?: { provider?: string; name?: string; settings?: { speed?: number } }; stt?: { provider?: string; model?: string; language?: string } };
+    return {
+      phone_number: num.phoneNumber, name: num.friendlyName, type: num.type, country: num.isoCountry ?? d.isoCountry,
+      locality: d.locality, region: d.region, test_number: Boolean(num.isTestNumber),
+      voice: m.tts ? { provider: m.tts.provider, name: m.tts.name, speed: m.tts.settings?.speed } : undefined,
+      transcriber: m.stt ? { provider: m.stt.provider, model: m.stt.model, language: m.stt.language } : undefined,
+    };
+  }
+
+  /**
+   * Buy a number and attach it to a voice agent, as the dashboard's "Pick a new phone number" does:
+   * copilot buys it from Twilio through voice-service. The org pays for it every month and it cannot be
+   * undone from here, so callers must have a person's confirmation of this exact number. The number is
+   * looked up again first so the purchase uses Twilio's current record.
+   */
+  async buyNumber(agentId: string, number: string, opts: { country?: string; tollFree?: boolean } = {}): Promise<{ phone_number: string; name?: string; locality?: string; region?: string; agent: string }> {
+    const country = (opts.country ?? 'US').toUpperCase();
+    const phoneNumber = toE164(number, country);
+    const agent = await new AgentsSDK(this.client).getAgent(agentId).catch(() => undefined);
+    if (!agent) throw new CliError(`Agent ${agentId} is not in the organization this command acts on.`);
+    const channels = ((agent.channels as unknown[] | undefined) ?? []).map((c) => String(typeof c === 'string' ? c : (c as { type?: unknown }).type ?? '').toUpperCase());
+    if (!channels.includes('VOICE')) throw new CliError(`"${agent.name}" does not answer the phone (no VOICE channel), so a number would not reach it. Nothing was bought.`);
+    const existing = await this.agentNumbers(agentId);
+    if (existing.length) throw new CliError(`"${agent.name}" already has ${existing[0].phoneNumber}. Nothing was bought.`);
+    if ((await this.orgNumbers()).some((o) => o.phoneNumber === phoneNumber)) {
+      throw new CliError(`The org already owns ${phoneNumber}; attach it with \`indemn agents numbers attach\` instead of buying it. Nothing was bought.`);
+    }
+    const digits = phoneNumber.replace(/\D/g, '');
+    const offered = await this.searchNumbers({ country, tollFree: opts.tollFree, contains: digits.slice(-7), limit: 20,
+      ...((country === 'US' || country === 'CA') && !opts.tollFree ? { areaCode: digits.slice(1, 4) } : {}) });
+    const pick = offered.find((o) => o.phoneNumber === phoneNumber);
+    if (!pick) throw new CliError(`${phoneNumber} is no longer available. Search again with \`indemn agents numbers search\`. Nothing was bought.`);
+    await this.client.copilotPost(`/organization/:org_id/ai-studio/bots/${agentId}/configurations/voice/numbers`, {
+      type: opts.tollFree ? 'toll-free' : 'local', friendlyName: pick.friendlyName ?? phoneNumber, phoneNumber, payload: pick,
+    });
+    return { phone_number: phoneNumber, name: pick.friendlyName, locality: pick.locality, region: pick.region, agent: agent.name };
+  }
+
+  /** Detach a number from an agent; the org keeps owning it. */
+  async detachNumber(agentId: string, phoneNumber: string): Promise<unknown> {
+    const attached = await this.agentNumbers(agentId);
+    const number = attached.find((n) => n.phoneNumber === phoneNumber);
+    if (!number) throw new CliError(`${phoneNumber} is not attached to agent ${agentId}.`);
+    const result = await this.client.copilotRequestRaw('DELETE', `/organization/:org_id/ai-studio/bots/${agentId}/configurations/voice/numbers`, { phoneNumber });
+    // Kept so it can be attached to another agent (moved), whatever the owned-numbers list says.
+    this.detached.set(`${await this.client.currentOrgId()}:${phoneNumber}`, { ...number, is_active: false });
+    return result;
+  }
+
+  /**
+   * A test voice call in the browser: a LiveKit room joined with the same
+   * attributes as the dashboard's web call, always marked as a test.
+   */
+  async voicePreview(agentId: string): Promise<{ server_url: string; room_name: string; token: string; join_url: string }> {
+    // The call service finds the agent by its phone number: without one the agent never joins the room.
+    const numbers = await this.agentNumbers(agentId);
+    if (!numbers.length) throw new CliError(`Agent ${agentId} has no phone number, so it cannot take a test call. Attach one with \`indemn agents numbers attach\`.`, EXIT.NEEDS_INPUT);
+    const res = await this.client.copilotPost<{ token: string; server_url: string; room_name: string }>('/livekit/token', {
+      bot_id: agentId,
+      user_attributes: { 'sip.twilio.callSid': callSid(), isTestMode: 'true', ...(numbers[0].phoneNumber ? { 'sip.trunkPhoneNumber': numbers[0].phoneNumber } : {}) },
+    });
+    const join = new URL('https://meet.livekit.io/custom');
+    join.searchParams.set('liveKitUrl', res.server_url);
+    join.searchParams.set('token', res.token);
+    return { ...res, join_url: join.toString() };
+  }
+}

package/test/cli/entry.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const root = new URL('../..', import.meta.url).pathname;
+
+function cli(...args: string[]) {
+  const env = { ...process.env, HOME: mkdtempSync(join(tmpdir(), 'indemn-entry-')), NODE_NO_WARNINGS: '1' };
+  delete env.CLAUDECODE;
+  return spawnSync(process.execPath, ['--import', 'tsx', join(root, 'src/cli/index.ts'), ...args], { cwd: root, env, encoding: 'utf8', timeout: 60_000 });
+}
+
+describe('CLI entry point', () => {
+  it('starts and lists every command group', () => {
+    const res = cli('--help');
+    expect(res.stderr).toBe('');
+    expect(res.status).toBe(0);
+    for (const group of ['login', 'agents', 'skills', 'kb', 'config', 'chat', 'conversations', 'org', 'link', 'channels', 'voices', 'distributions', 'templates', 'analytics', 'audit', 'tickets', 'billing', 'campaigns', 'platform', 'jarvis', 'eval', 'init', 'mcp']) {
+      expect(res.stdout, group).toMatch(new RegExp(`\\n  ${group}\\b`));
+    }
+  }, 60_000);
+
+  it('prints the package version', () => {
+    const res = cli('--version');
+    expect(res.stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+  }, 60_000);
+
+  it('has org config and agent voice subcommands attached to their groups', () => {
+    expect(cli('org', '--help').stdout).toMatch(/\n  config\b/);
+    expect(cli('agents', '--help').stdout).toMatch(/\n  voice\b/);
+  }, 60_000);
+});

package/test/cli/init.test.ts

@@ -0,0 +1,66 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { initProject, permissionBlock, MCP_SERVER_ENTRY } from '../../src/cli/init.js';
+import { TOOL_META } from '../../src/mcp/tool-meta.js';
+
+const packageRoot = new URL('../..', import.meta.url).pathname;
+
+describe('indemn init', () => {
+  let dir: string;
+  beforeEach(() => { dir = mkdtempSync(join(tmpdir(), 'indemn-init-')); });
+  afterEach(() => rmSync(dir, { recursive: true, force: true }));
+
+  it('installs skills and rules, adds the MCP server and a permission block', () => {
+    const r = initProject(dir, { packageRoot });
+    expect(r).toMatchObject({ mcp: 'added', permissions: 'added' });
+    expect(existsSync(join(dir, '.claude', 'skills', 'agent-builder', 'SKILL.md'))).toBe(true);
+    expect(existsSync(join(dir, '.claude', 'skills', 'evaluations', 'SKILL.md'))).toBe(true);
+    expect(readFileSync(join(dir, '.claude', 'rules', 'indemn.md'), 'utf8')).toContain('test conversation');
+    expect(JSON.parse(readFileSync(join(dir, '.mcp.json'), 'utf8'))).toEqual({ mcpServers: { indemn: MCP_SERVER_ENTRY } });
+    const perms = JSON.parse(readFileSync(join(dir, '.claude', 'settings.json'), 'utf8')).permissions;
+    expect(perms.allow).toContain('mcp__indemn__list_agents');
+    expect(perms.ask).toContain('mcp__indemn__delete_agent');
+    expect(perms.ask).toContain('mcp__indemn__run_evaluation');
+    expect(perms.allow).not.toContain('mcp__indemn__delete_agent');
+  });
+
+  it('merges into existing files and never loosens a rule the user set', () => {
+    writeFileSync(join(dir, '.mcp.json'), JSON.stringify({ mcpServers: { other: { command: 'x' } } }));
+    mkdirSync(join(dir, '.claude'));
+    writeFileSync(join(dir, '.claude', 'settings.json'), JSON.stringify({ model: 'opus', permissions: { deny: ['mcp__indemn__list_agents'], allow: ['Bash(ls)'] } }));
+    const r = initProject(dir, { packageRoot });
+    expect(r.permissions).toBe('merged');
+    expect(Object.keys(JSON.parse(readFileSync(join(dir, '.mcp.json'), 'utf8')).mcpServers)).toEqual(['other', 'indemn']);
+    const settings = JSON.parse(readFileSync(join(dir, '.claude', 'settings.json'), 'utf8'));
+    expect(settings.model).toBe('opus');
+    expect(settings.permissions.deny).toEqual(['mcp__indemn__list_agents']);
+    expect(settings.permissions.allow).toContain('Bash(ls)');
+    expect(settings.permissions.allow).not.toContain('mcp__indemn__list_agents');
+  });
+
+  it('classifies every tool: guarded or destructive tools ask', () => {
+    const { allow, ask } = permissionBlock();
+    expect(allow.length + ask.length).toBe(Object.keys(TOOL_META).length);
+    for (const [name, meta] of Object.entries(TOOL_META)) {
+      if (meta.guard || meta.annotations.destructiveHint) expect(ask, name).toContain(`mcp__indemn__${name}`);
+    }
+  });
+});
+
+describe('versions and skills', () => {
+  it('uses one version everywhere', () => {
+    const pkg = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8')).version;
+    expect(JSON.parse(readFileSync(join(packageRoot, '.claude-plugin', 'plugin.json'), 'utf8')).version).toBe(pkg);
+    const market = JSON.parse(readFileSync(join(packageRoot, '.claude-plugin', 'marketplace.json'), 'utf8'));
+    expect(market.version).toBe(pkg);
+    expect(market.plugins.every((p: { version: string }) => p.version === pkg)).toBe(true);
+  });
+
+  it('keeps every SKILL.md under 500 lines', () => {
+    for (const skill of ['agent-builder', 'evaluations']) {
+      expect(readFileSync(join(packageRoot, 'skills', skill, 'SKILL.md'), 'utf8').split('\n').length, skill).toBeLessThanOrEqual(500);
+    }
+  });
+});

package/test/cli/link.test.ts

@@ -0,0 +1,57 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { existsSync, mkdirSync, readFileSync, symlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { on, recordFetch } from '../helpers/fetch-recorder.js';
+import { cleanEnv, useTempHome } from '../helpers/config-home.js';
+import { jwtExpiringIn } from '../helpers/jwt.js';
+import { IndemnClient } from '../../src/sdk/client.js';
+import { confirmOrExit, writeLink } from '../../src/cli/link.js';
+
+const A = 'aaaaaaaaaaaaaaaaaaaaaaaa';
+const MINE = '111111111111111111111111';
+const FOREIGN = '999999999999999999999999';
+
+describe('indemn link', () => {
+  let home: ReturnType<typeof useTempHome>;
+  let project: string;
+  beforeEach(() => {
+    cleanEnv();
+    home = useTempHome();
+    project = join(home.dir, 'project');
+    mkdirSync(project);
+    IndemnClient.saveConfig({ environment: 'dev', user_id: 'u1', session: { token: jwtExpiringIn(5 * 3_600_000) }, orgs: [{ id: A, name: 'QA A' }] });
+  });
+  afterEach(() => home.cleanup());
+
+  it('writes the link only after every agent is found in the org', async () => {
+    recordFetch([on('GET', `/bots/${MINE}`, { json: { success: true, data: [{ _id: MINE }] } })]);
+    const result = await writeLink({ dir: project, orgFlag: A, agents: [MINE] });
+    const saved = JSON.parse(readFileSync(result.path, 'utf8'));
+    expect(saved).toMatchObject({ org_id: A, org_name: 'QA A', environment: 'dev', agents: [MINE] });
+  });
+
+  it('writes nothing when one agent is not in the org', async () => {
+    recordFetch([
+      on('GET', `/bots/${MINE}`, { json: { success: true, data: [{ _id: MINE }] } }),
+      on('GET', `/bots/${FOREIGN}`, { status: 404, text: 'not found' }),
+    ]);
+    await expect(writeLink({ dir: project, orgFlag: A, agents: [MINE, FOREIGN] })).rejects.toThrow(/Agent 9+ is not reachable.*Nothing was linked/);
+    expect(existsSync(join(project, '.indemn', 'project.json'))).toBe(false);
+  });
+
+  it('refuses to link the home folder, also when reached through a symlink', async () => {
+    recordFetch();
+    await expect(writeLink({ dir: home.dir, orgFlag: A, agents: [] })).rejects.toThrow(/home folder/);
+    const alias = join(home.dir, 'project', 'alias-to-home');
+    symlinkSync(home.dir, alias);
+    await expect(writeLink({ dir: alias, orgFlag: A, agents: [] })).rejects.toThrow(/home folder/);
+  });
+
+  it('org switch without --yes in a non-interactive shell exits 2', async () => {
+    vi.stubEnv('CLAUDECODE', '1');
+    const exit = vi.spyOn(process, 'exit').mockImplementation(((code: number) => { throw new Error(`exit ${code}`); }) as never);
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    await expect(confirmOrExit('Pin this folder?', false)).rejects.toThrow('exit 2');
+    expect(exit).toHaveBeenCalledWith(2);
+  });
+});

package/test/core/org-resolver.test.ts

@@ -0,0 +1,92 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { findLinkFile, resolveOrg, type LinkFile, type OrgChoice } from '../../src/core/org-resolver.js';
+import { CliError, NeedsInputError } from '../../src/core/runtime.js';
+
+const A: OrgChoice = { id: 'aaaaaaaaaaaaaaaaaaaaaaaa', name: 'Org A' };
+const B: OrgChoice = { id: 'bbbbbbbbbbbbbbbbbbbbbbbb', name: 'Org B' };
+const link = (over: Partial<LinkFile> = {}): LinkFile => ({ org_id: A.id, environment: 'dev', agents: [], path: '/p/.indemn/project.json', ...over });
+
+describe('resolveOrg precedence', () => {
+  const base = { environment: 'dev' as const, link: null };
+
+  it.each([
+    ['flag', { flag: B.id }, B.id],
+    ['env', { envOrg: B.id }, B.id],
+  ])('%s decides without looking up memberships', async (source, extra, id) => {
+    const memberships = vi.fn();
+    await expect(resolveOrg({ ...base, ...extra, memberships })).resolves.toMatchObject({ id, source });
+    expect(memberships).not.toHaveBeenCalled();
+  });
+
+  it('a linked folder decides without looking up memberships', async () => {
+    const memberships = vi.fn();
+    await expect(resolveOrg({ ...base, link: link(), memberships })).resolves.toMatchObject({ id: A.id, source: 'link' });
+    expect(memberships).not.toHaveBeenCalled();
+  });
+
+  it('uses the only membership without asking', async () => {
+    const ask = vi.fn();
+    await expect(resolveOrg({ ...base, memberships: async () => [A], ask })).resolves.toMatchObject({ id: A.id, source: 'single' });
+    expect(ask).not.toHaveBeenCalled();
+  });
+
+  it('asks when there are several', async () => {
+    const ask = vi.fn(async () => B.id);
+    await expect(resolveOrg({ ...base, memberships: async () => [A, B], ask })).resolves.toMatchObject({ id: B.id, source: 'asked' });
+    expect(ask).toHaveBeenCalledWith([A, B]);
+  });
+
+  it('needs input when there are several and nobody can be asked', async () => {
+    const err = await resolveOrg({ ...base, memberships: async () => [A, B] }).catch((e) => e);
+    expect(err).toBeInstanceOf(NeedsInputError);
+    expect(err.choices).toEqual([{ id: A.id, label: 'Org A' }, { id: B.id, label: 'Org B' }]);
+  });
+
+  it('fails clearly with no membership', async () => {
+    await expect(resolveOrg({ ...base, memberships: async () => [] })).rejects.toThrow(/not a member of any organization/);
+  });
+
+  it('refuses a flag that contradicts the linked folder, naming the file', async () => {
+    await expect(resolveOrg({ ...base, flag: B.id, link: link(), memberships: vi.fn() })).rejects.toThrow('/p/.indemn/project.json');
+  });
+
+  it('refuses a link made on the other platform', async () => {
+    const err = await resolveOrg({ ...base, link: link({ environment: 'production' }), memberships: vi.fn() }).catch((e) => e);
+    expect(err).toBeInstanceOf(CliError);
+    expect(err.message).toMatch(/linked to production/);
+  });
+});
+
+describe('findLinkFile', () => {
+  const dirs: string[] = [];
+  afterEach(() => dirs.splice(0).forEach((d) => rmSync(d, { recursive: true, force: true })));
+
+  function project(content: string): string {
+    const root = mkdtempSync(join(tmpdir(), 'indemn-link-'));
+    dirs.push(root);
+    mkdirSync(join(root, '.indemn'));
+    writeFileSync(join(root, '.indemn', 'project.json'), content);
+    const nested = join(root, 'a', 'b');
+    mkdirSync(nested, { recursive: true });
+    return nested;
+  }
+
+  it('finds the file two levels up', () => {
+    const nested = project(JSON.stringify({ org_id: A.id, environment: 'dev', agents: ['x'] }));
+    expect(findLinkFile(nested)).toMatchObject({ org_id: A.id, environment: 'dev', agents: ['x'] });
+  });
+
+  it('names a malformed file', () => {
+    const nested = project('{nope');
+    expect(() => findLinkFile(nested)).toThrow(/Cannot read .*project\.json/);
+  });
+
+  it('returns null when nothing is linked', () => {
+    const root = mkdtempSync(join(tmpdir(), 'indemn-nolink-'));
+    dirs.push(root);
+    expect(findLinkFile(root)).toBeNull();
+  });
+});