@indemn/cli 1.7.4 → 1.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indemn/cli",
-  "version": "1.7.4",
+  "version": "1.7.5",
   "description": "CLI, MCP server, and plugin for managing Indemn AI agents",
   "type": "module",
   "main": "./dist/sdk/index.js",

package/src/cli/auth.ts

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import * as readline from 'readline';
 import { Writable } from 'node:stream';
-import { login, logout, whoami, type WhoAmI } from '../sdk/auth.js';
+import { customHosts, login, logout, whoami, type WhoAmI } from '../sdk/auth.js';
 import { findLinkFile } from '../core/org-resolver.js';
 import { getOrgFlag } from '../core/scope.js';
 import { SessionExpiredError } from '../core/runtime.js';
@@ -103,7 +103,7 @@ export function registerAuthCommands(program: Command): void {
           });
           spinner.succeed(`Logged in as ${result.email} on ${result.environment}`);
           if (result.expiresAt) {
-            console.log(chalk.dim(`  Session valid until ${new Date(result.expiresAt).toLocaleString()}; it renews itself.`));
+            console.log(chalk.dim(`  Session valid until ${new Date(result.expiresAt).toLocaleString()}; run \`indemn login\` again after that.`));
           }
           if (result.orgs.length === 0) {
             console.log(chalk.yellow('  You are not a member of any organization yet. Ask an admin to add you.'));
@@ -164,16 +164,19 @@ export function registerAuthCommands(program: Command): void {
         if (info.email) console.log(`  User:        ${info.email}`);
         console.log(`  Credential:  ${describeCredential(info)}`);
         if (info.sessionExpiresAt) {
-          console.log(`  Session:     valid until ${new Date(info.sessionExpiresAt).toLocaleString()} (renews itself)`);
+          console.log(`  Session:     valid until ${new Date(info.sessionExpiresAt).toLocaleString()} (then \`indemn login\`)`);
         }
         console.log(`  Org here:    ${describeOrgRule(info)}`);
         if (info.orgs.length) {
           console.log(`  Orgs:`);
           for (const o of info.orgs) console.log(`    ${o.id}  ${o.name}`);
         }
-        console.log(`  Copilot:     ${info.hosts.copilot}`);
-        console.log(`  Evaluations: ${info.hosts.evaluations}`);
-        console.log(`  Middleware:  ${info.hosts.middleware}`);
+        // The servers only when one is not the platform's default: the usual ones are noise.
+        const custom = customHosts(info);
+        if (custom.length) {
+          console.log(`  Custom hosts (not the ${info.environment} defaults):`);
+          for (const [label, url] of custom) console.log(`    ${label.padEnd(12)} ${url}`);
+        }
       } catch (err) {
         printError(err);
         process.exit(1);

package/src/cli/eval.ts

@@ -78,11 +78,15 @@ export function registerEvalCommands(program: Command): void {
 
         const items = (testSet as { items?: unknown[] }).items?.length ?? 0;
         const count = input.mode === 'transcript' ? 'real conversations' : `${input.limit ? Math.min(input.limit, items) : items} item(s)`;
+        const minPassRate = options.minPassRate !== undefined ? Number(options.minPassRate) : undefined;
+        const maxP95Ms = options.maxP95Ms !== undefined ? Number(options.maxP95Ms) : undefined;
+        if (minPassRate !== undefined && !(minPassRate >= 0 && minPassRate <= 1)) throw new CliError('--min-pass-rate is a fraction from 0 to 1 (0.9 means 90%).', EXIT.NEEDS_INPUT);
+        if (maxP95Ms !== undefined && !(maxP95Ms >= 0)) throw new CliError('--max-p95-ms is a number of milliseconds, 0 or more.', EXIT.NEEDS_INPUT);
         await confirmOrExit(`Run an evaluation of agent ${agentId} on ${count} with concurrency ${input.concurrency ?? 1}? It uses paid model calls and cannot be cancelled.`, Boolean(options.yes));
 
         const gate: GateOptions = {
-          minPassRate: options.minPassRate !== undefined ? Number(options.minPassRate) : undefined,
-          maxP95Ms: options.maxP95Ms !== undefined ? Number(options.maxP95Ms) : undefined,
+          minPassRate,
+          maxP95Ms,
           errorPolicy: options.errorPolicy === 'warn' ? 'warn' : 'block',
           failOnError: Boolean(options.failOnError),
         };

package/src/cli/index.ts

@@ -21,7 +21,7 @@ import { registerBillingCommands } from './billing.js';
 import { registerCampaignCommands } from './campaigns.js';
 import { registerPlatformCommands } from './platform.js';
 import { registerInitCommand } from './init.js';
-import { askMfaInTerminal, askOrgInTerminal, installBanner } from './utils/output.js';
+import { askOrgInTerminal, installBanner } from './utils/output.js';
 import { setAskers, setOrgFlag } from '../core/scope.js';
 import { cliVersion, isNonInteractive } from '../core/runtime.js';
 
@@ -71,7 +71,7 @@ program.hook('preAction', async (thisCommand, actionCommand) => {
 
   // Ask in the terminal only when a person can answer; agents and CI get exit code 2 instead.
   if (fullCommandName(actionCommand) !== 'mcp serve' && !isNonInteractive()) {
-    setAskers({ chooseOrg: askOrgInTerminal, mfaCode: askMfaInTerminal });
+    setAskers({ chooseOrg: askOrgInTerminal });
   }
 
   // Banner suppression: global flag, env var, command opts-out, or JSON output mode.

package/src/cli/init.ts

@@ -1,4 +1,5 @@
 import { Command } from 'commander';
+import { cliVersion } from '../core/runtime.js';
 import chalk from 'chalk';
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
@@ -8,7 +9,9 @@ import { IndemnClient } from '../sdk/client.js';
 import { findLinkFile } from '../core/org-resolver.js';
 import { printError, printSuccess } from './utils/output.js';
 
-export const MCP_SERVER_ENTRY = { command: 'npx', args: ['-y', '@indemn/cli', 'mcp', 'serve'] };
+// Pinned to this CLI's own version: an unpinned npx entry runs whatever is newest on npm at each start.
+const PACKAGE = `@indemn/cli@${cliVersion()}`;
+export const MCP_SERVER_ENTRY = { command: 'npx', args: ['-y', PACKAGE, 'mcp', 'serve'] };
 
 /** Claude Code permission rules: read-only tools run without asking, anything that changes the platform asks every time. */
 export function permissionBlock(): { allow: string[]; ask: string[] } {
@@ -49,7 +52,7 @@ The \`indemn\` CLI and its MCP server manage Indemn AI agents. Run \`indemn whoa
 export interface InitReport {
   skills: string;
   rules: string;
-  mcp: 'added' | 'kept' | 'skipped';
+  mcp: 'added' | 'updated' | 'kept' | 'skipped';
   permissions: 'added' | 'merged' | 'skipped';
 }
 
@@ -76,12 +79,17 @@ export function initProject(cwd: string, opts: { force?: boolean; mcp?: boolean;
     const path = join(cwd, '.mcp.json');
     const cfg = readJson(path);
     cfg.mcpServers = cfg.mcpServers ?? {};
-    if (cfg.mcpServers.indemn) {
+    // An npx @indemn/cli entry (any version) moves to this version, so the server matches the skills just installed;
+    // only the package's version changes (an --org, env and the rest stay). Any other entry is the user's own and is kept.
+    const had = cfg.mcpServers.indemn;
+    const at = had?.command === 'npx' && Array.isArray(had.args) ? had.args.findIndex((a: unknown) => typeof a === 'string' && /^@indemn\/cli(@|$)/.test(a)) : -1;
+    if (had && (at < 0 || had.args[at] === PACKAGE)) {
       mcp = 'kept';
     } else {
-      cfg.mcpServers.indemn = MCP_SERVER_ENTRY;
+      if (had) had.args[at] = PACKAGE;
+      else cfg.mcpServers.indemn = MCP_SERVER_ENTRY;
       writeFileSync(path, JSON.stringify(cfg, null, 2) + '\n');
-      mcp = 'added';
+      mcp = had ? 'updated' : 'added';
     }
   }
 
@@ -141,7 +149,7 @@ export function registerInitCommand(program: Command): void {
         printSuccess('Indemn CLI set up for Claude Code:');
         console.log(`  Skills:      ${r.skills}`);
         console.log(`  Rules:       ${r.rules}`);
-        console.log(`  MCP server:  ${r.mcp === 'added' ? 'added to .mcp.json' : r.mcp === 'kept' ? 'already in .mcp.json (kept)' : 'skipped'}`);
+        console.log(`  MCP server:  ${{ added: 'added to .mcp.json', updated: `updated to ${cliVersion()} in .mcp.json`, kept: 'already in .mcp.json (kept)', skipped: 'skipped' }[r.mcp]}`);
         console.log(`  Permissions: ${r.permissions === 'skipped' ? 'skipped' : `${r.permissions} in .claude/settings.json (reads allowed, changes ask)`}`);
         const login = IndemnClient.loadConfig();
         if (!login) console.log(chalk.yellow('Next: run `indemn login --env dev` (or production).'));

package/src/cli/utils/output.ts

@@ -80,10 +80,6 @@ export async function askOrgInTerminal(choices: OrgChoice[]): Promise<string | u
   return choices.find((c) => c.id === answer)?.id;
 }
 
-export async function askMfaInTerminal(): Promise<string> {
-  process.stderr.write(chalk.yellow('Your session needs renewing and your account uses MFA. A code was emailed to you.\n'));
-  return askLine('MFA code: ');
-}
 
 export async function confirm(message: string): Promise<boolean> {
   const rl = readline.createInterface({

package/src/cli/voice.ts

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 import { writeFileSync } from 'node:fs';
 import { IndemnClient } from '../sdk/client.js';
 import { VoiceSDK, toE164 } from '../sdk/voice.js';
-import { CliError, EXIT } from '../core/runtime.js';
+import { CliError, EXIT, isNonInteractive } from '../core/runtime.js';
 import { confirmOrExit } from './link.js';
 import { formatTable, printError, printJson, printSuccess } from './utils/output.js';
 
@@ -175,6 +175,8 @@ export function registerVoiceCommands(program: Command): void {
     .description('Buy an available number and attach it to a voice agent (costs money every month)')
     .action((agentId: string, number: string, options) => run(async () => {
       const phone = toE164(number, String(options.country).toUpperCase());
+      // As the MCP tool: no purchase without a person (an AI host, CI or a script cannot answer for one).
+      if (isNonInteractive()) throw new CliError('Buying a number costs money every month: run this yourself at a terminal.', EXIT.NEEDS_INPUT);
       if (options.yes && !options.confirmPurchase) throw new CliError('Buying a number costs money: pass --confirm-purchase with --yes, or run without --yes to be asked.', EXIT.NEEDS_INPUT);
       await confirmOrExit(`Buy ${phone} and attach it to agent ${agentId}? The org pays for it every month, and it cannot be undone from the CLI.`, Boolean(options.yes));
       const res = await new VoiceSDK(new IndemnClient()).buyNumber(agentId, number, { country: options.country, tollFree: Boolean(options.tollFree) });

package/src/core/org-resolver.ts

@@ -72,6 +72,10 @@ export async function resolveOrg(input: {
   link: LinkFile | null;
   environment: Environment;
   memberships: () => Promise<OrgChoice[]>;
+  /** The orgs saved at `indemn login` (none for a key or a host's session): an explicit org is checked against them. */
+  known?: OrgChoice[];
+  /** The orgs as they are now, for an explicit org missing from `known` (one joined since login). */
+  refresh?: () => Promise<OrgChoice[]>;
   ask?: (choices: OrgChoice[]) => Promise<string | undefined>;
 }): Promise<ResolvedOrg> {
   const { link } = input;
@@ -91,6 +95,20 @@ export async function resolveOrg(input: {
         EXIT.NEEDS_INPUT,
       );
     }
+    // Checked against the orgs saved at login (no request), so a typo names them rather than a bare "Access denied".
+    // One missing from them is looked up again (an org joined since login). Without them (an API key, a host's
+    // session), or when the look-up fails, copilot's own check decides, as before.
+    const known = input.known ?? [];
+    if (known.length && !known.some((o) => o.id === explicit)) {
+      const orgs = input.refresh ? await input.refresh().catch(() => undefined) : known;
+      if (orgs && !orgs.some((o) => o.id === explicit)) {
+        throw new CliError(
+          `You are not a member of org ${explicit}` +
+            (orgs.length ? `. Your orgs: ${orgs.map((o) => `${o.name} (${o.id})`).join(', ')}.` : ', or of any organization on this platform.'),
+          EXIT.NEEDS_INPUT,
+        );
+      }
+    }
     return { id: explicit, source: input.flag ? 'flag' : 'env', link };
   }
 

package/src/core/runtime.ts

@@ -1,3 +1,6 @@
+import { realpathSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join, sep } from 'node:path';
 import { createRequire } from 'node:module';
 
 /** Process exit codes. Scripts and agents branch on these. */
@@ -71,3 +74,46 @@ export function cliVersion(): string {
 
 /** How long a question to a person (through an MCP host) may stay open. The MCP default of 60 s is too short to read a diff. */
 export const PERSON_TIMEOUT_MS = 10 * 60_000;
+
+/** Only Indemn's own hosts (https/wss on indemn.ai), or this machine for local development, ever get the session. */
+export function indemnHost(url: string, name: string): string {
+  let u: URL;
+  try {
+    u = new URL(url);
+  } catch {
+    throw new CliError(`${name} is not a valid URL: ${url}`);
+  }
+  const local = ['localhost', '127.0.0.1', '[::1]'].includes(u.hostname);
+  const indemn = (u.protocol === 'https:' || u.protocol === 'wss:') && (u.hostname === 'indemn.ai' || u.hostname.endsWith('.indemn.ai'));
+  if (local || indemn) return url;
+  throw new CliError(`${name} points to ${u.protocol}//${u.host}: the CLI sends your session only to Indemn's hosts (https://*.indemn.ai) or localhost.`);
+}
+
+// Where secrets live in the home folder: the CLI's own session and the usual credential folders.
+const SECRET_DIRS = ['.indemn', '.ssh', '.aws', '.azure', '.gnupg', '.docker', '.kube', '.config'];
+
+/** A file the CLI may send off the machine: never a dotfile (.env, .npmrc…), one in a secret folder above, or /proc. */
+export function uploadable(filePath: string): string {
+  const real = realpathSync(filePath);
+  let home = homedir();
+  try { home = realpathSync(home); } catch { /* as given */ }
+  if (real.startsWith('/proc/') || basename(real).startsWith('.') || SECRET_DIRS.some((dir) => real.startsWith(join(home, dir) + sep))) {
+    throw new CliError(`Refusing to upload ${filePath}: dotfiles and secret folders (such as ~/.indemn, ~/.ssh, ~/.aws) are never sent.`);
+  }
+  return real;
+}
+
+/**
+ * Write a report. A path the caller chose must be a new file of the report's own type (never over an existing
+ * file); the default name in the current folder is replaced, as before.
+ */
+export function writeReport(filePath: string, data: string | Uint8Array, ext: '.md' | '.pdf', chosen: boolean): void {
+  if (chosen && !filePath.toLowerCase().endsWith(ext)) throw new CliError(`This report is a ${ext} file: give an output path ending in ${ext}.`);
+  try {
+    writeFileSync(filePath, data, { flag: chosen ? 'wx' : 'w' });
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'EEXIST') throw new CliError(`${filePath} already exists; nothing was replaced. Choose another output path.`);
+    throw err;
+  }
+}
+

package/src/core/scope.ts

@@ -35,7 +35,6 @@ export interface FormField {
 
 export interface Askers {
   chooseOrg?: (choices: OrgChoice[]) => Promise<string | undefined>;
-  mfaCode?: () => Promise<string>;
   /** Ask for several text fields at once; undefined when declined or nobody can answer. */
   form?: (message: string, fields: FormField[]) => Promise<Record<string, string> | undefined>;
 }

package/src/mcp/registry.ts

@@ -40,7 +40,14 @@ function fit(body: { context: ResultContext; data: unknown }): CallToolResult {
   const hint = 'Result was too large. Ask for less: use limit/page, a filter, or response_format "concise".';
   const list = Array.isArray(body.data) ? body.data : (body.data as { items?: unknown[] } | null)?.items;
   if (Array.isArray(list)) {
-    const shaped = (keep: number) => ({ context: body.context, data: { items: list.slice(0, keep), returned: keep, total: list.length, truncated: true, hint } });
+    // A page keeps its page, limit, total, has_more and next: only its items are trimmed.
+    const page = Array.isArray(body.data) ? {} : (body.data as Record<string, unknown>);
+    // A trimmed page left items out: it is never "complete", and the way on starts where this page did, at a
+    // limit that fits (no item skipped; a few may come again).
+    const rest = (keep: number) => typeof page.page === 'number' && typeof page.limit === 'number'
+      ? { has_more: true, next: `Only ${keep} of this page's ${list.length} items fit: call again with limit ${Math.max(keep, 1)} and page ${Math.floor(((page.page - 1) * page.limit) / Math.max(keep, 1)) + 1}, then the pages after it.` }
+      : {};
+    const shaped = (keep: number) => ({ context: body.context, data: { total: list.length, ...page, items: list.slice(0, keep), returned: keep, truncated: true, ...rest(keep), hint } });
     let keep = list.length;
     while (keep > 0 && JSON.stringify(shaped(keep)).length > MAX_RESULT_CHARS) keep = Math.floor(keep * 0.7);
     return text(shaped(keep));
@@ -92,6 +99,12 @@ export function fitForm(text: string, maxLines = 8, maxLine = 140): string {
   return cut ? `${shown.join('\n')}\n(Shortened to fit; ask to see the full change before approving.)` : text;
 }
 
+// Dry runs shown to the caller, by tool and arguments: on a host without approval forms, `confirm: true` is taken
+// only for a change that was previewed first (the model cannot approve a change nobody was shown).
+const previewed = new Set<string>();
+const previewKey = (toolName: string, args: Args) =>
+  `${toolName}:${JSON.stringify(Object.keys(args).filter((k) => k !== 'confirm').sort().map((k) => [k, args[k]]))}`;
+
 export async function guardDestructive(
   server: McpServer,
   toolName: string,
@@ -120,7 +133,9 @@ export async function guardDestructive(
       return { proceed: false, result: text({ cancelled: true, action: toolName, would: preview, reason: 'The approval form could not be shown, so nothing was changed. Tell the person; they can ask again.' }) };
     }
   }
-  if (args.confirm === true) return { proceed: true, byPerson: false };
+  const key = previewKey(toolName, args);
+  if (args.confirm === true && previewed.delete(key)) return { proceed: true, byPerson: false };
+  previewed.add(key);
   return {
     proceed: false,
     result: text({

package/src/mcp/server.ts

@@ -3,13 +3,13 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { IndemnClient } from '../sdk/client.js';
 import { registerTools } from './tools.js';
 import { setAskers, type Askers } from '../core/scope.js';
-import { cliVersion, SessionExpiredError, PERSON_TIMEOUT_MS } from '../core/runtime.js';
+import { cliVersion, PERSON_TIMEOUT_MS } from '../core/runtime.js';
 
 /**
  * Questions the CLI may need answered during a tool call, asked through the
  * host (Claude Code shows a dialog). Stdin carries the MCP protocol, so the
  * terminal is never used. Without elicitation: the org question becomes a
- * needs_input result, and an MFA renewal asks the person to log in again.
+ * needs_input result.
  */
 export function mcpAskers(server: McpServer): Askers {
   const canAsk = () => Boolean(server.server.getClientCapabilities()?.elicitation);
@@ -55,23 +55,6 @@ export function mcpAskers(server: McpServer): Askers {
         return undefined;
       }
     },
-    mfaCode: async () => {
-      if (!canAsk()) {
-        throw new SessionExpiredError('The session needs renewing and your account uses MFA. Run `indemn login` in a terminal, then retry.');
-      }
-      const answer = await ask({
-        message: 'Your Indemn session needs renewing. Enter the MFA code that was just emailed to you.',
-        requestedSchema: {
-          type: 'object',
-          properties: { code: { type: 'string', title: 'MFA code', description: '6 digits', minLength: 6, maxLength: 6 } },
-          required: ['code'],
-        },
-      });
-      if (answer.action !== 'accept' || typeof answer.content?.code !== 'string') {
-        throw new SessionExpiredError('MFA code not entered. Run `indemn login` in a terminal, then retry.');
-      }
-      return answer.content.code;
-    },
   };
 }
 

package/src/mcp/tool-meta.ts

@@ -76,10 +76,10 @@ export const TOOL_META: Record<string, ToolMeta> = {
 
   // Skills (the CLI still calls them functions)
   list_functions: { ...read('List skills'), paginate: true },
-  create_function: write('Create skill'),
+  create_function: { ...write('Create skill'), guard: true, describe: (a) => `This will add skill "${a.name}" to agent ${a.agent_id}; the agent can use it at once.` },
   update_function: { ...write('Update skill', { idempotentHint: true }), guard: true, describe: (a) => `This will change skill ${a.function_id} of agent ${a.agent_id}.` },
   delete_function: { ...destroy('Delete skill'), guard: true, describe: (a) => `This will delete skill ${a.function_id} from agent ${a.agent_id}.` },
-  test_function: write('Test skill', { openWorldHint: true }),
+  test_function: { ...write('Test skill', { openWorldHint: true }), guard: true, describe: (a) => `This will call the real endpoint of skill ${a.function_id} on agent ${a.agent_id}.` },
   export_functions: read('Export skills'),
   import_functions: {
     ...destroy('Import skills, replacing existing ones', { openWorldHint: true }),
@@ -107,9 +107,9 @@ export const TOOL_META: Record<string, ToolMeta> = {
   update_knowledge_base: write('Update knowledge base', { idempotentHint: true }),
   delete_knowledge_base: { ...destroy('Delete knowledge base'), guard: true, describe: (a) => `This will delete knowledge base ${a.kb_id} with all its sources and vectors.` },
   list_kb_data: read('List knowledge base entries'),
-  add_kb_data: write('Add knowledge base entry'),
-  scrape_url: write('Scrape a website into a knowledge base', { openWorldHint: true }),
-  upload_kb_file: write('Upload file to knowledge base'),
+  add_kb_data: { ...write('Add knowledge base entry'), guard: true, describe: (a) => `This will add an entry to knowledge base ${a.kb_id}; agents using it answer from it at once.` },
+  scrape_url: { ...write('Scrape a website into a knowledge base', { openWorldHint: true }), guard: true, describe: (a) => `This will crawl ${a.url} into knowledge base ${a.kb_id}; agents using it answer from it once it is imported.` },
+  upload_kb_file: { ...write('Upload file to knowledge base'), guard: true, describe: (a) => `This will upload ${a.file_path} into knowledge base ${a.kb_id}; agents using it answer from it once it is imported.` },
   update_kb_data: {
     ...write('Update knowledge base entry', { idempotentHint: true }),
     guard: true,

package/src/mcp/tools.ts

@@ -385,7 +385,7 @@ export function registerTools(server: McpServer, client: IndemnClient): Registry
   );
 
   // Lifecycle lives on the V2 platform; "unknown" when it cannot be read (treated as published: mayBeLive).
-  const lifecycleOf = (id: string) => new AgentInsightsSDK(client).detail(id).then((d) => d.lifecycle ?? 'prototype', () => 'unknown');
+  const lifecycleOf = (id: string) => new AgentInsightsSDK(client).detail(id).then((d) => d.lifecycle ?? 'unknown', () => 'unknown');
   // A change to an agent that may be live asks first; the approval names the fields, never their values (skill auth).
   const liveChange = (what: string, skip: string[]) => ({
     guardWhen: async (a: Record<string, unknown>) => mayBeLive(await lifecycleOf(String(a.agent_id))),

package/src/report/export.ts

@@ -1,6 +1,7 @@
 // Shared export logic used by both CLI commands and MCP tools
 import * as fs from 'fs';
 import * as path from 'path';
+import { writeReport } from '../core/runtime.js';
 import { IndemnClient } from '../sdk/client.js';
 import { EvalSDK } from '../sdk/eval.js';
 import { RubricsSDK } from '../sdk/rubrics.js';
@@ -45,7 +46,7 @@ export async function exportEvalMarkdown(
   const defaultFilename = `Indemn_Evaluation_${cleanName}_${cleanDate}.md`;
 
   const resolvedPath = path.resolve(outputPath || defaultFilename);
-  fs.writeFileSync(resolvedPath, markdown);
+  writeReport(resolvedPath, markdown, '.md', Boolean(outputPath));
 
   return {
     file_path: resolvedPath,

package/src/report/generate.tsx

@@ -1,5 +1,6 @@
 // PDF rendering driver — generates agent card and eval report PDFs
 import { renderToBuffer } from '@react-pdf/renderer';
+import { writeReport } from '../core/runtime.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { AgentCardDocument } from './agent-card/document.js';
@@ -18,7 +19,7 @@ export async function generateAgentCardPDF(data: AgentCardData, outputPath?: str
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const buffer = await renderToBuffer(<AgentCardDocument data={data} /> as any);
   const resolvedPath = path.resolve(filename);
-  fs.writeFileSync(resolvedPath, buffer);
+  writeReport(resolvedPath, buffer, '.pdf', Boolean(outputPath));
   return resolvedPath;
 }
 
@@ -28,7 +29,7 @@ export async function generateEvalReportPDF(data: EvalReportData, outputPath?: s
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const buffer = await renderToBuffer(<EvalReportDocument data={data} /> as any);
   const resolvedPath = path.resolve(filename);
-  fs.writeFileSync(resolvedPath, buffer);
+  writeReport(resolvedPath, buffer, '.pdf', Boolean(outputPath));
   return resolvedPath;
 }
 

package/src/sdk/auth.ts

@@ -46,15 +46,15 @@ export interface LoginResult {
 }
 
 /**
- * Log in and keep the copilot session token, the same one the dashboard uses.
- * No API key is created. The Firebase refresh token is kept so the session
- * can renew itself.
+ * Log in and keep the copilot session token, the same one the dashboard uses (24 hours).
+ * No API key is created, and the Firebase refresh token is not kept: nothing that
+ * outlives logout stays on disk, so access comes back only through `indemn login`.
  */
 export async function login(email: string, password: string, env: Environment = 'dev', opts?: {
   mfaCodePrompt?: () => Promise<string>;
   firebaseSignIn?: FirebaseSignIn;
 }): Promise<LoginResult> {
-  const { idToken, refreshToken } = await (opts?.firebaseSignIn ?? firebaseSignIn)(email, password, env);
+  const { idToken } = await (opts?.firebaseSignIn ?? firebaseSignIn)(email, password, env);
 
   const unauth = new IndemnClient({ environment: env });
   const session = await exchangeIdToken(
@@ -68,7 +68,7 @@ export async function login(email: string, password: string, env: Environment =
   const res = await authed.copilotGet<{ userOrganizations?: Array<{ _id: string; name: string }> }>('/organization');
   const orgs = (res.userOrganizations ?? []).map((o) => ({ id: String(o._id), name: o.name }));
 
-  const stored = toStoredSession(session.token, refreshToken);
+  const stored = toStoredSession(session.token);
   IndemnClient.clearConfig();
   IndemnClient.saveConfig({
     environment: env,
@@ -128,3 +128,13 @@ export function whoami(): WhoAmI | null {
     hosts: client.getHosts(),
   };
 }
+
+/** The hosts that are not the environment's defaults (set by an env var or the saved config): all whoami lists. */
+export function customHosts(info: { environment: Environment; hosts: EnvironmentHosts }): Array<[string, string]> {
+  const labels: Record<keyof EnvironmentHosts, string> = { copilot: 'Copilot', evaluations: 'Evaluations', middleware: 'Middleware', platform: 'V2 platform' };
+  const defaults = DEFAULT_HOSTS[info.environment];
+  return (Object.keys(labels) as Array<keyof EnvironmentHosts>)
+    .filter((key) => info.hosts[key] && info.hosts[key] !== defaults[key])
+    .map((key) => [labels[key], String(info.hosts[key])]);
+}
+

package/src/sdk/chat.ts

@@ -87,6 +87,7 @@ export class ChatSession extends EventEmitter {
       this.socket.on('connect_error', (err: Error) => {
         clearTimeout(timeout);
         reject(new Error(`Connection failed: ${err.message}`));
+        void this.disconnect({ end: false });  // no retries in the background, each opening another conversation
       });
 
       this.socket.on('disconnect', (reason: string) => {