@indemn/cli 1.7.4 → 1.7.5

package/test/mcp/darwin-fixes.test.ts

@@ -11,6 +11,7 @@ import { join } from 'path';
 
 const ORG = 'aaaaaaaaaaaaaaaaaaaaaaaa';
 const AGENT = 'bbbbbbbbbbbbbbbbbbbbbbbb';
+const agentFound = on('GET', `/v2/bots/${AGENT}`, { json: { success: true, data: [{ _id: AGENT, name: 'Bot' }] } });  // named in approvals
 const approve = () => ({ action: 'accept' as const, content: { confirm: true } });
 const ok = (data: unknown) => ({ json: { success: true, data } });
 
@@ -30,7 +31,7 @@ describe('Darwin E2E fixes', () => {
     const { calls } = recordFetch([
       on('GET', '/knowledge-bases/kb1', ok({ _id: 'kb1', name: 'Roadside' })),
       on('POST', '/knowledge-bases/kb1/import', ok({ status: 'started', message: 'file import has been initiated' })),
-    ]);
+     agentFound]);
     p = await pair();
     const text = JSON.stringify({ type: 'file', sources: [{ url: 'https://store.test/org/1790869827796.txt', name: 'Battery jump starts.txt' }] });
     const res = await p.call('import_kb', { kb_id: 'kb1', data: text });
@@ -48,7 +49,7 @@ describe('Darwin E2E fixes', () => {
     const { calls } = recordFetch([
       on('GET', '/tickets/t1', ok({ _id: 't1', ticket_ref: 'TKT-1', notes: 'Old note' })),
       on('PUT', '/tickets/t1', ok({ _id: 't1', notes: 'Old note\nChecked with towing partner.', status: 'in_progress' })),
-    ]);
+     agentFound]);
     p = await pair();
     const res = await p.call('update_ticket', { ticket_id: 't1', status: 'in_progress', note: 'Checked with towing partner.' });
     expect(res.isError).toBe(false);
@@ -56,7 +57,7 @@ describe('Darwin E2E fixes', () => {
   });
 
   it('eval_gate_verdict judges against 80% when no threshold is given', async () => {
-    recordFetch([on('GET', '/api/v1/runs/r1', { json: { run_id: 'r1', status: 'completed', total: 3, passed: 1 } })]);
+    recordFetch([on('GET', '/api/v1/runs/r1', { json: { run_id: 'r1', status: 'completed', total: 3, passed: 1 } }), agentFound]);
     p = await pair();
     const res = await p.call('eval_gate_verdict', { run_id: 'r1' });
     expect(res.body.data).toMatchObject({ finished: true, pass: false, min_pass_rate: 0.8 });
@@ -64,7 +65,7 @@ describe('Darwin E2E fixes', () => {
   });
 
   it('add_holiday fills the type and the closed message the server requires', async () => {
-    const { calls } = recordFetch([on('PATCH', '/configurations/holidays', ok({ saved: true }))]);
+    const { calls } = recordFetch([on('PATCH', '/configurations/holidays', ok({ saved: true })), agentFound]);
     p = await pair();
     const res = await p.call('add_holiday', { date: '2026-12-31', name: "New Year's Eve" });
     expect(res.isError).toBe(false);
@@ -80,7 +81,7 @@ describe('Darwin E2E fixes', () => {
     recordFetch([
       on('GET', '/ai-studio/v2/bots', ok([{ _id: AGENT, name: 'Rudra-voice-3', channels: ['VOICE'], connected_phone: '+12562897334' }, { _id: 'c', name: 'Web', channels: ['WEB'] }])),
       on('GET', '/voice/configurations/numbers', ok([{ phoneNumber: '+18664857140', friendlyName: '(866) 485-7140', type: 'tollfree' }])),
-    ]);
+     agentFound]);
     p = await pair();
     const res = await p.call('list_agent_numbers');
     expect(res.body.data).toEqual([
@@ -96,9 +97,9 @@ describe('Darwin E2E fixes', () => {
       on('POST', `/bots/${AGENT}/functions/f1/parameters`, ok([{ _id: 'p1', name: 'zip_code', type: 'string', is_required: true }])),
       on('PUT', `/bots/${AGENT}/functions/f1`, ok({ _id: 'f1', name: 'Weather', type: 'rest_api' })),
       on('POST', `/bots/${AGENT}/functions`, ok({ _id: 'f1', name: 'Weather', type: 'rest_api' })),
-    ]);
+     agentFound]);
     p = await pair();
-    const res = await p.call('create_function', {
+    const res = await p.call('create_function', { confirm: true,
       agent_id: AGENT, type: 'rest_api', name: 'Weather', url: 'https://httpbin.org/get?zip={{zip_code}}', method: 'GET',
       parameters: [{ name: 'zip_code', type: 'string', description: 'ZIP code', required: true }],
     });
@@ -108,7 +109,7 @@ describe('Darwin E2E fixes', () => {
   });
 
   it('keeps the server\'s reason on a 403 instead of "Access denied"', async () => {
-    recordFetch([on('GET', '/tickets', { status: 403, json: { success: false, error: 'Tickets are not enabled for this organization.' } })]);
+    recordFetch([on('GET', '/tickets', { status: 403, json: { success: false, error: 'Tickets are not enabled for this organization.' } }), agentFound]);
     p = await pair();
     const res = await p.call('list_tickets');
     expect(res.isError).toBe(true);
@@ -119,7 +120,7 @@ describe('Darwin E2E fixes', () => {
     const { calls } = recordFetch([
       on('GET', '/configurations', ok({ businessHoursConfig: { businessHoursEnabled: false } })),
       on('PATCH', '/configurations/business-hours', ok({ success: true })),
-    ]);
+     agentFound]);
     p = await pair();
     const hours = [1, 2, 3, 4, 5].map((day) => ({ day, slots: [{ start: '08:00', end: '18:00' }] }));
     const res = await p.call('set_business_hours', { hours: JSON.stringify(hours) });
@@ -137,7 +138,7 @@ describe('Darwin E2E fixes', () => {
       on('GET', `/ai-studio/v2/bots/${AGENT}`, ok([{ _id: AGENT, name: 'Voice Test Agent' }])),
       on('GET', '/evaluator-configs', { json: { items: [{ config_id: 'c1' }] } }),
       on('POST', '/api/v1/evaluate-transcript', { json: { success: true, score: 0.9 } }),
-    ]);
+     agentFound]);
     p = await pair();
     const baseline = [{ sender: 'user', text: 'Hi' }, { sender: 'agent', text: 'Hello' }, { sender: 'system', text: 'ended' }];
     const same = await p.call('evaluate_transcript', { agent_id: AGENT, baseline_transcript: baseline, replay_transcript: baseline });
@@ -153,7 +154,7 @@ describe('Darwin E2E fixes', () => {
   it('list_kb_data leaves the chunks out unless asked', async () => {
     recordFetch([on('GET', '/knowledge-bases/kb1/data-source', ok({
       dataSources: [{ _id: 's1', type: 'text', question: 'Do you tow motorcycles?', answer: 'Yes', trained: true, chunks: [{ text: 'x' }], chunks_text: ['x'] }], total: 1, page: 1, pages: 1,
-    }))]);
+    })), agentFound]);
     p = await pair();
     const slim = await p.call('list_kb_data', { kb_id: 'kb1' });
     expect(slim.body.data.dataSources[0]).toEqual({ _id: 's1', type: 'text', question: 'Do you tow motorcycles?', answer: 'Yes', trained: true });
@@ -169,7 +170,7 @@ describe('Darwin E2E fixes', () => {
       on('GET', '/files/signed-url', (c) => (c.url.includes('filename=org%2F1790869575391.csv') || c.url.includes('filename=org/1790869575391.csv')
         ? { json: { success: true, data: { signedUrl: 'https://indemn-dev-attachments.s3.us-east-1.amazonaws.com/org/1790869575391.csv?X-Amz-Signature=abc' } } }
         : { status: 404, json: { success: false } })),
-    ]);
+     agentFound]);
     p = await pair();
     const res = await p.call('export_kb', { kb_id: 'kb1' });
     expect(res.body.data.download_url).toContain('X-Amz-Signature=abc');
@@ -184,7 +185,7 @@ describe('Darwin E2E fixes', () => {
       on('GET', `/ai-studio/v2/bots/${AGENT}`, ok([{ _id: AGENT, name: 'Darwin QA Agent', description: 'Roadside help, short answers.' }])),
       on('POST', '/ai-studio/v2/bots/clone', ok({ new_agent_id: COPY, new_agent_name: 'Darwin QA Clone', new_kb_ids: [] })),
       on('PUT', `/ai-studio/bots/${COPY}`, ok({ _id: COPY, name: 'Darwin QA Clone', description: 'Roadside help, short answers.' })),
-    ]);
+     agentFound]);
     p = await pair();
     const res = await p.call('clone_agent', { agent_id: AGENT, name: 'Darwin QA Clone' });
     expect(res.isError).toBe(false);
@@ -196,7 +197,7 @@ describe('Darwin E2E fixes', () => {
       on('GET', '/knowledge-bases/kb1/data-source', ok({ dataSources: [{ _id: 's1', question: 'How late can I buy a policy?', answer: 'Up to 14 days before.' }], total: 1, page: 1, pages: 1 })),
       on('GET', '/knowledge-bases/kb1', ok({ _id: 'kb1', name: 'Darwin KB Test' })),
       on('PUT', '/knowledge-bases/kb1/data-source/s1', ok({ _id: 's1', question: 'How late can I buy a policy?', answer: 'Up to 7 days before.' })),
-    ]);
+     agentFound]);
     p = await pair();
     const res = await p.call('update_kb_data', { kb_id: 'kb1', source_id: 's1', answer: 'Up to 7 days before.' });
     expect(res.isError).toBe(false);
@@ -209,7 +210,7 @@ describe('Darwin E2E fixes', () => {
     recordFetch([
       on('GET', '/audit-logs', ok([{ _id: 'a1', id_user: 'u1', action: 'update', resource_type: 'bot', resource_display: 'Darwin QA Agent', createdAt: '2026-10-01T10:00:00Z' }, { _id: 'a2', id_user: 'u9', action: 'create', createdAt: '2026-10-01T09:00:00Z' }])),
       on('GET', '/projects-users', ok({ projectUsers: [{ role: 'owner', status: 'active', id_user: { _id: 'u1', email: 'ana@acme.com', firstname: 'Ana', lastname: 'Diaz' }, id_project: { name: 'default' } }] })),
-    ]);
+     agentFound]);
     p = await pair();
     const res = await p.call('list_audit_logs', {});
     expect(res.isError).toBe(false);
@@ -221,7 +222,7 @@ describe('Darwin E2E fixes', () => {
     const { calls } = recordFetch([
       on('GET', `/ai-studio/v2/bots/${AGENT}`, ok([{ _id: AGENT, name: 'Darwin QA Agent' }])),
       on('GET', '/projects-users', ok({ projectUsers: [{ role: 'admin', status: 'active', id_user: { _id: 'cccccccccccccccccccccccc', email: 'ana@acme.com', firstname: 'Ana', lastname: 'Diaz' }, id_project: { name: 'default' } }] })),
-    ]);
+     agentFound]);
     p = await pair(() => ({ action: 'decline' as const }));
     await p.call('transfer_agent_owner', { agent_id: AGENT, owner_id: 'cccccccccccccccccccccccc' });
     expect(calls.filter((c) => c.method !== 'GET')).toHaveLength(0); // declined: nothing transferred
@@ -236,7 +237,7 @@ describe('Darwin E2E fixes', () => {
         { _id: 'f1', type: 'file', source: signed, status: 'success', source_details: { file_name: 'Battery jump starts.txt' } },
         { _id: 'u1', type: 'url', source: 'https://www.indemn.ai/?ref=1', status: 'success' },
       ] })),
-    ]);
+     agentFound]);
     p = await pair(() => ({ action: 'decline' as const }));
     await p.call('delete_kb_data', { kb_id: 'kb1', source_id: 'f1' });
     expect(p.questions[0].message).toContain('"Battery jump starts.txt"');

package/test/mcp/registry.test.ts

@@ -166,4 +166,15 @@ describe('registry', () => {
     expect(handler).not.toHaveBeenCalled();
     await pair.close();
   });
+
+  it('on a host without approval forms, confirm: true is taken only for a change already shown as a dry run', async () => {
+    const { guardDestructive } = await import('../../src/mcp/registry.js');
+    const server = new McpServer({ name: 't', version: '0' });
+    const first = await guardDestructive(server, 'delete_agent', { agent_id: 'a1', confirm: true }, 'Delete a1');
+    expect(first.proceed).toBe(false);  // straight to confirm: shown as a dry run instead
+    const again = await guardDestructive(server, 'delete_agent', { confirm: true, agent_id: 'a1' }, 'Delete a1');
+    expect(again).toEqual({ proceed: true, byPerson: false });
+    const other = await guardDestructive(server, 'delete_agent', { agent_id: 'a2', confirm: true }, 'Delete a2');
+    expect(other.proceed).toBe(false);  // a different change needs its own dry run
+  });
 });

package/test/mcp/shaping.test.ts

@@ -32,6 +32,24 @@ describe('result shaping', () => {
     await pair.close();
   });
 
+  it('a page trimmed to fit never skips items: it says more exist and where to continue with a smaller limit', async () => {
+    const pair = await connectPair((server) => {
+      const reg = createRegistry(server, { context: () => ({ environment: 'dev' }), meta });
+      reg.tool('many', 'x', {}, async () => ok(Array.from({ length: 120 }, (i) => ({ i, pad: 'x'.repeat(4_000) }))));
+    });
+    for (const page of [1, 3]) {  // a middle page and the last one
+      const res = await pair.call('many', { page });
+      const data = res.body.data;
+      expect(data.truncated).toBe(true);
+      expect(data.has_more).toBe(true);  // items of this page were left out, even on the last page
+      const keep = data.returned as number;
+      const from = Math.floor(((page - 1) * 50) / keep) + 1;  // the page holding this page's first item at limit `keep`
+      expect(data.next).toContain(`limit ${keep}`);
+      expect(data.next).toContain(`page ${from}`);
+    }
+    await pair.close();
+  });
+
   it('refuses a paged tool that brings its own limit (it would never page)', async () => {
     await connectPair((server) => {
       const reg = createRegistry(server, { context: () => ({ environment: 'dev' }), meta });

package/test/mcp/tools-snapshot.test.ts

@@ -24,6 +24,10 @@ describe('MCP tool list', () => {
     for (const name of ['whoami', 'list_organizations', 'eval_quality_metrics']) {
       expect(props(name), name).not.toContain('org_id');
     }
+    // Writes that change what customers get or reach outside ask first on every host (a dry run, then confirm).
+    for (const name of ['delete_agent', 'create_function', 'test_function', 'add_kb_data', 'scrape_url', 'upload_kb_file']) {
+      expect(props(name), name).toContain('confirm');
+    }
     // Test items and rubric rules have declared fields (Gemini cannot fill open objects).
     const itemsOf = (name: string, field: string) => ((tools.find((t) => t.name === name)!.inputSchema as { properties: Record<string, { items?: { properties?: object } }> }).properties[field].items?.properties ?? {});
     // ... and no nested objects: Gemini writes constructors for them that Google rejects.

package/test/sdk/auth.test.ts

@@ -4,7 +4,7 @@ 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 { login, logout, whoami } from '../../src/sdk/auth.js';
+import { customHosts, login, logout, whoami } from '../../src/sdk/auth.js';
 import { IndemnClient } from '../../src/sdk/client.js';
 
 const A = { _id: 'aaaaaaaaaaaaaaaaaaaaaaaa', name: 'QA A' };
@@ -30,7 +30,8 @@ describe('token-first login', () => {
     expect(result.orgs).toEqual([{ id: A._id, name: 'QA A' }, { id: B._id, name: 'QA B' }]);
 
     const saved = JSON.parse(readFileSync(join(home.dir, '.indemn', 'config.json'), 'utf8'));
-    expect(saved.session).toMatchObject({ token, refresh_token: 'r1' });
+    expect(saved.session).toMatchObject({ token });
+    expect(saved.session).not.toHaveProperty('refresh_token');  // nothing that outlives logout stays on disk
     expect(saved.orgs).toHaveLength(2);
     expect(saved).not.toHaveProperty('api_key');
     expect(saved).not.toHaveProperty('org_id');
@@ -67,4 +68,12 @@ describe('token-first login', () => {
     expect(text).not.toContain(token);
     expect(text).not.toContain('r1');
   });
+
+  it("whoami lists only the hosts that are not the platform's defaults", () => {
+    const defaults = { copilot: 'https://devcopilot.indemn.ai/api', evaluations: 'https://devevaluations.indemn.ai', middleware: 'https://devproxy.indemn.ai', platform: 'https://devplatform.indemn.ai/api/v1' };
+    expect(customHosts({ environment: 'dev', hosts: defaults })).toEqual([]);
+    expect(customHosts({ environment: 'dev', hosts: { ...defaults, copilot: 'http://localhost:3000/api', platform: 'http://localhost:8013/api/v1' } }))
+      .toEqual([['Copilot', 'http://localhost:3000/api'], ['V2 platform', 'http://localhost:8013/api/v1']]);
+  });
 });
+

package/test/sdk/client.test.ts

@@ -77,4 +77,17 @@ describe('IndemnClient request path', () => {
     expect(out).toContain('200');
     expect(out).not.toContain(DEV_KEY);
   });
+
+  it("sends the session only to Indemn's hosts or this machine", async () => {
+    vi.stubEnv('INDEMN_COPILOT_URL', 'https://evil.example.com/api');
+    expect(() => new IndemnClient()).toThrow(/only to Indemn/);
+    vi.stubEnv('INDEMN_COPILOT_URL', 'http://devcopilot.indemn.ai/api');  // not https
+    expect(() => new IndemnClient()).toThrow(/only to Indemn/);
+    vi.stubEnv('INDEMN_COPILOT_URL', 'http://localhost:3000/api');
+    expect(() => new IndemnClient()).not.toThrow();
+    vi.stubEnv('INDEMN_COPILOT_URL', 'https://devcopilot.indemn.ai/api');
+    const { jarvisSocketUrl } = await import('../../src/sdk/jarvis-chat.js');
+    vi.stubEnv('INDEMN_PLATFORM_WS_URL', 'wss://evil.example.com/ws');
+    expect(() => jarvisSocketUrl(new IndemnClient())).toThrow(/only to Indemn/);
+  });
 });

package/test/sdk/config-change.test.ts

@@ -138,5 +138,5 @@ describe('configuration changes', () => {
     const ok = await pair.call('set_prompt', { agent_id: AGENT, prompt: 'new', confirm: true, confirm_published: true });
     expect(ok.body.data.changed).toEqual(['system_prompt']);
     await pair.close();
-  });
+  }, 15_000);  // each status read waits for the unreachable V2 platform, and a change is previewed before it is confirmed
 });

package/test/sdk/kb-upload.test.ts

@@ -47,4 +47,25 @@ describe('adding a document to a knowledge base', () => {
     await expect(new KBSDK(new IndemnClient()).uploadFile('kb1', big)).rejects.toThrow(/limit is 10 MB/);
     expect(calls).toHaveLength(0);
   });
+
+  it('never uploads a file from a hidden folder such as ~/.indemn (the session lives there)', async () => {
+    const { calls } = recordFetch();
+    const secret = join(home.dir, '.indemn', 'config.json');
+    await expect(new KBSDK(new IndemnClient()).uploadFile('kb1', secret)).rejects.toThrow(/never sent/);
+    const { FunctionsSDK } = await import('../../src/sdk/functions.js');
+    await expect(new FunctionsSDK(new IndemnClient()).generateFromDoc('a1', { filePath: secret })).rejects.toThrow(/never sent/);
+    expect(calls).toHaveLength(0);
+  });
+
+  it('refuses only secret places, not every folder whose name starts with a dot', async () => {
+    const { uploadable } = await import('../../src/core/runtime.js');
+    const { mkdirSync } = await import('node:fs');
+    const at = (...parts: string[]) => { const f = join(home.dir, ...parts); mkdirSync(join(f, '..'), { recursive: true }); writeFileSync(f, 'x'); return f; };
+    expect(() => uploadable(at('repo', '.claude', 'worktrees', 'w1', 'Report.pdf'))).not.toThrow();  // a Claude Code worktree
+    expect(() => uploadable(at('.local', 'share', 'docs', 'faq.txt'))).not.toThrow();
+    expect(() => uploadable(at('.ssh', 'id_rsa'))).toThrow(/never sent/);
+    expect(() => uploadable(at('.aws', 'credentials'))).toThrow(/never sent/);
+    expect(() => uploadable(at('repo', '.env'))).toThrow(/never sent/);  // a dotfile, wherever it is
+  });
 });
+

package/test/sdk/orgs.test.ts

@@ -22,6 +22,24 @@ describe('OrgsSDK', () => {
     expect(IndemnClient.loadConfig()?.orgs).toEqual([{ id: A, name: 'QA A' }]);
   });
 
+  it('acts in an org joined since login: looked up once, then saved', async () => {
+    const C = 'cccccccccccccccccccccccc';
+    IndemnClient.saveConfig({ orgs: [{ id: A, name: 'QA A' }] });
+    const { calls } = recordFetch([on('GET', '/organization', { json: { success: true, userOrganizations: [{ _id: A, name: 'QA A' }, { _id: C, name: 'QA C' }] } })]);
+    await expect(new IndemnClient().resolveOrg(C)).resolves.toMatchObject({ id: C, name: 'QA C', source: 'flag' });
+    expect(IndemnClient.loadConfig()?.orgs).toEqual([{ id: A, name: 'QA A' }, { id: C, name: 'QA C' }]);
+    await new IndemnClient().resolveOrg(C);
+    expect(calls).toHaveLength(1);
+    await expect(new IndemnClient().resolveOrg('dddddddddddddddddddddddd')).rejects.toThrow('Your orgs: QA A (aaaaaaaaaaaaaaaaaaaaaaaa), QA C (cccccccccccccccccccccccc).');
+  });
+
+  it('an empty answer from copilot never replaces the orgs saved at login', async () => {
+    IndemnClient.saveConfig({ orgs: [{ id: A, name: 'QA A' }] });
+    recordFetch([on('GET', '/organization', { json: { success: true, userOrganizations: [] } })]);
+    await expect(new IndemnClient().resolveOrg('cccccccccccccccccccccccc')).rejects.toThrow('not a member of org cccccccccccccccccccccccc');
+    expect(IndemnClient.loadConfig()?.orgs).toEqual([{ id: A, name: 'QA A' }]);
+  });
+
   it('lists members once per person with only safe fields', async () => {
     const user = { _id: 'u9', email: 'x@y.z', firstname: 'Ada', lastname: 'L', password: 'hash' };
     recordFetch([on('GET', `/organization/${A}/projects-users`, {

package/test/sdk/renewal.test.ts

@@ -16,7 +16,7 @@ function login(token: string, refresh = 'r1') {
   });
 }
 
-describe('session renewal', () => {
+describe('a saved login: 24 hours, never renewed, no refresh token kept', () => {
   let home: ReturnType<typeof useTempHome>;
   beforeEach(() => { cleanEnv(); home = useTempHome(); setAskers({}); });
   afterEach(() => home.cleanup());
@@ -30,54 +30,6 @@ describe('session renewal', () => {
     expect(calls[0].headers.authorization).toBe(`JWT ${token}`);
   });
 
-  it('renews silently under an hour of life, revokes the old token, then sends the request', async () => {
-    const old = jwtExpiringIn(30 * 60_000);
-    const fresh = jwtExpiringIn(24 * 3_600_000, { jti: 'new' });
-    login(old);
-    const { calls } = recordFetch([
-      on('POST', 'securetoken.googleapis.com', { json: { id_token: 'id2', refresh_token: 'r2' } }),
-      on('POST', '/auth/firebase/signin', { json: { success: true, token: `JWT ${fresh}`, user: { _id: 'u1' } } }),
-      on('POST', '/auth/firebase/logout', { json: { success: true } }),
-    ]);
-    await new IndemnClient().copilotGet(BOTS);
-    expect(calls.map((c) => `${c.method} ${new URL(c.url).pathname}`)).toEqual([
-      'POST /v1/token',
-      'POST /api/auth/firebase/signin',
-      'POST /api/auth/firebase/logout',
-      `GET /api${BOTS}`,
-    ]);
-    expect(calls[2].headers.authorization).toBe(`JWT ${old}`);
-    expect(calls[3].headers.authorization).toBe(`JWT ${fresh}`);
-    expect(IndemnClient.loadConfig()?.session).toMatchObject({ token: fresh, refresh_token: 'r2' });
-  });
-
-  it('with MFA and nobody to ask, stops with exit 3 and never sends the request', async () => {
-    login(jwtExpiringIn(10 * 60_000));
-    const { calls } = recordFetch([
-      on('POST', 'securetoken', { json: { id_token: 'id2', refresh_token: 'r2' } }),
-      on('POST', '/auth/firebase/signin', { json: { success: true, requiresMfa: true, mfaSessionId: 's1' } }),
-    ]);
-    const err = await new IndemnClient().copilotGet(BOTS).catch((e) => e);
-    expect(err).toBeInstanceOf(SessionExpiredError);
-    expect(err.exitCode).toBe(3);
-    expect(calls.some((c) => c.url.includes('/ai-studio/'))).toBe(false);
-  });
-
-  it('with MFA and a way to ask, asks once and continues', async () => {
-    login(jwtExpiringIn(10 * 60_000));
-    const ask = vi.fn(async () => '123456');
-    setAskers({ mfaCode: ask });
-    const fresh = jwtExpiringIn(24 * 3_600_000);
-    recordFetch([
-      on('POST', 'securetoken', { json: { id_token: 'id2', refresh_token: 'r2' } }),
-      on('POST', '/auth/firebase/signin', { json: { success: true, requiresMfa: true, mfaSessionId: 's1' } }),
-      on('POST', '/auth/firebase/mfa/verify', { json: { success: true, token: `JWT ${fresh}`, user: { _id: 'u1' } } }),
-    ]);
-    await new IndemnClient().copilotGet(BOTS);
-    expect(ask).toHaveBeenCalledTimes(1);
-    expect(IndemnClient.loadConfig()?.session?.token).toBe(fresh);
-  });
-
   it('re-reads the saved login on every request', async () => {
     login(jwtExpiringIn(5 * 3_600_000, { n: 1 }));
     const { calls } = recordFetch();
@@ -89,27 +41,54 @@ describe('session renewal', () => {
     expect(calls[1].headers.authorization).toBe(`JWT ${second}`);
   });
 
-  it('on a 401 renews once and retries once; a second 401 means log in again', async () => {
-    login(jwtExpiringIn(5 * 3_600_000));
-    let gets = 0;
-    const { calls } = recordFetch([
-      on('GET', '/ai-studio/', () => (++gets === 1 ? { status: 401, text: 'revoked' } : { json: { success: true, data: [] } })),
-      on('POST', 'securetoken', { json: { id_token: 'id2', refresh_token: 'r2' } }),
-      on('POST', '/auth/firebase/signin', { json: { success: true, token: `JWT ${jwtExpiringIn(24 * 3_600_000)}`, user: { _id: 'u1' } } }),
-    ]);
-    await expect(new IndemnClient().copilotGet(BOTS)).resolves.toEqual([]);
-    expect(calls.filter((c) => c.url.includes('/ai-studio/'))).toHaveLength(2);
+  it('a login that has ended stops with log in again, without sending anything', async () => {
+    IndemnClient.saveConfig({ environment: 'dev', user_id: 'u1', email: 'qa@indemn.ai', session: { token: jwtExpiringIn(-60_000), expires_at: new Date(Date.now() - 60_000).toISOString() }, orgs: [{ id: ORG, name: 'QA A' }] });
+    const { calls } = recordFetch();
+    await expect(new IndemnClient().copilotGet(BOTS)).rejects.toThrow(/Run `indemn login`/);
+    expect(calls).toHaveLength(0);
+  });
 
-    recordFetch([
-      on('GET', '/ai-studio/', { status: 401, text: 'revoked' }),
-      on('POST', 'securetoken', { json: { id_token: 'id3', refresh_token: 'r3' } }),
-      on('POST', '/auth/firebase/signin', { json: { success: true, token: `JWT ${jwtExpiringIn(24 * 3_600_000)}`, user: { _id: 'u1' } } }),
-    ]);
+  it('a login near its end is used as is: nothing renews it', async () => {
+    login(jwtExpiringIn(30 * 60_000));
+    const { calls } = recordFetch();
+    await new IndemnClient().copilotGet(BOTS);
+    expect(calls.map((c) => new URL(c.url).pathname)).toEqual([`/api${BOTS}`]);  // no Google token call, no new sign-in
+  });
+
+  it('a 401 means log in again: no silent renewal', async () => {
+    login(jwtExpiringIn(5 * 3_600_000));
+    const { calls } = recordFetch([on('GET', '/ai-studio/', { status: 401, text: 'revoked' })]);
     await expect(new IndemnClient().copilotGet(BOTS)).rejects.toBeInstanceOf(SessionExpiredError);
+    expect(calls.some((c) => c.url.includes('securetoken') || c.url.includes('/auth/firebase/'))).toBe(false);
+  });
+
+  it('a refresh token saved by an earlier version is deleted on first use', async () => {
+    login(jwtExpiringIn(5 * 3_600_000), 'r-old');
+    recordFetch();
+    await new IndemnClient().copilotGet(BOTS);
+    expect(IndemnClient.loadConfig()?.session?.refresh_token).toBeUndefined();
+    expect(IndemnClient.loadConfig()?.session?.token).toBeTruthy();
   });
 
   it('with no login at all, exits 3', async () => {
     recordFetch();
     await expect(new IndemnClient().copilotGet(BOTS)).rejects.toMatchObject({ exitCode: 3 });
   });
+
+  it("a host's session (Darwin) that ends or is rejected says to sign in to Copilot again, not indemn login", async () => {
+    vi.stubEnv('INDEMN_TOKEN', jwtExpiringIn(5 * 3_600_000));
+    vi.stubEnv('INDEMN_ENV', 'dev');
+    vi.stubEnv('INDEMN_ORG_ID', ORG);
+    recordFetch([on('GET', '/ai-studio/', { status: 401, text: 'revoked' })]);
+    const rejected = await new IndemnClient().copilotGet(BOTS).catch((e) => e);
+    expect(rejected).toBeInstanceOf(SessionExpiredError);
+    expect(rejected.message).toMatch(/Sign in to Copilot again/);
+    expect(rejected.message).not.toMatch(/indemn login/);
+
+    vi.stubEnv('INDEMN_TOKEN', jwtExpiringIn(-60_000));  // its 24 hours are over
+    const { calls } = recordFetch();
+    await expect(new IndemnClient().copilotGet(BOTS)).rejects.toThrow(/Sign in to Copilot again/);
+    expect(calls).toHaveLength(0);
+  });
 });
+

package/test/sdk/session.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 import { on, recordFetch } from '../helpers/fetch-recorder.js';
 import { fakeJwt, jwtExpiringIn } from '../helpers/jwt.js';
-import { exchangeIdToken, needsRenewal, refreshIdToken, tokenExpiry } from '../../src/sdk/session.js';
+import { exchangeIdToken, tokenExpiry } from '../../src/sdk/session.js';
 import { FIREBASE_CONFIGS } from '../../src/sdk/auth.js';
 import { SessionExpiredError } from '../../src/core/runtime.js';
 
@@ -11,28 +11,6 @@ describe('token expiry', () => {
     expect(tokenExpiry(fakeJwt({}))).toBeNull();
   });
 
-  it('renews under one hour of life, not with five hours, never without an expiry', () => {
-    expect(needsRenewal({ token: jwtExpiringIn(30 * 60_000) })).toBe(true);
-    expect(needsRenewal({ token: jwtExpiringIn(5 * 3_600_000) })).toBe(false);
-    expect(needsRenewal({ token: fakeJwt({}) })).toBe(false);
-    expect(needsRenewal({ token: fakeJwt({}), expires_at: new Date(Date.now() - 1000).toISOString() })).toBe(true);
-  });
-});
-
-describe('refreshIdToken', () => {
-  it('posts the refresh token to Google with the environment web key', async () => {
-    const { calls } = recordFetch([on('POST', 'securetoken.googleapis.com', { json: { id_token: 'id2', refresh_token: 'r2' } })]);
-    await expect(refreshIdToken('dev', 'r1')).resolves.toEqual({ idToken: 'id2', refreshToken: 'r2' });
-    expect(calls[0].url).toBe(`https://securetoken.googleapis.com/v1/token?key=${FIREBASE_CONFIGS.dev.apiKey}`);
-    expect(calls[0].body).toBe('grant_type=refresh_token&refresh_token=r1');
-  });
-
-  it('turns a rejected refresh token into a log-in-again error', async () => {
-    recordFetch([on('POST', 'securetoken', { status: 400, json: { error: { message: 'TOKEN_EXPIRED' } } })]);
-    const err = await refreshIdToken('production', 'dead').catch((e) => e);
-    expect(err).toBeInstanceOf(SessionExpiredError);
-    expect(err.exitCode).toBe(3);
-  });
 });
 
 describe('exchangeIdToken', () => {

package/test/sdk/skills.test.ts

@@ -13,6 +13,7 @@ import { registerTools } from '../../src/mcp/tools.js';
 
 const ORG = 'aaaaaaaaaaaaaaaaaaaaaaaa';
 const AGENT = '111111111111111111111111';
+const agentFound = on('GET', `/v2/bots/${AGENT}`, { json: { success: true, data: [{ _id: AGENT, name: 'Bot' }] } });  // named in approvals
 
 describe('skill names', () => {
   it('reduces spelling variants of the FAQ retriever to one key, like copilot', () => {
@@ -64,9 +65,9 @@ describe('skills SDK and tools', () => {
       on('GET', `/bots/${AGENT}/functions`, { json: { success: true, data: [{ _id: 'f1', type: 'rest_api',
         configurationSchema: { endpoint: 'https://x/date', method: 'POST', payload: '{"date_str":"{{event_date}}","n":"{{other}}"}', authorization: { type: 'no-auth' } } }] } }),
       on('POST', '/functions/f1/test-rest-api', { json: { statusCode: 200, response: { valid: true } } }),
-    ]);
+     agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
-    await pair.call('test_function', { agent_id: AGENT, function_id: 'f1', params: { event_date: '2027-06-12' } });
+    await pair.call('test_function', { confirm: true, agent_id: AGENT, function_id: 'f1', params: { event_date: '2027-06-12' } });
     expect(calls.find((c) => c.url.endsWith('/test-rest-api'))?.body).toEqual({ endpoint: 'https://x/date', method: 'POST',
       payload: '{"date_str":"2027-06-12","n":"{{other}}"}', authorization: { type: 'no-auth' } });
     await pair.close();
@@ -78,7 +79,7 @@ describe('skills SDK and tools', () => {
     const { calls } = recordFetch([
       on('GET', '/functions/f1/parameters', { json: { success: true, data: [saved] } }),
       on('POST', '/functions/f1/parameters', { json: { success: true, data: [saved] } }),
-    ]);
+     agentFound]);
     const sdk = new FunctionsSDK(new IndemnClient());
     await sdk.addParameter(AGENT, 'f1', { name: 'coverage', type: 'string', required: true, allowedValues: ['Liability', 'Both'] });
     const posts = () => calls.filter((c) => c.method === 'POST').map((c) => (c.body as unknown[])[0]);
@@ -100,7 +101,7 @@ describe('skills SDK and tools', () => {
   });
 
   it('bulk-creates with the body copilot expects', async () => {
-    const { calls } = recordFetch([on('POST', '/functions/bulk-create', { json: { success: true, data: [{ _id: 'f1' }] } })]);
+    const { calls } = recordFetch([on('POST', '/functions/bulk-create', { json: { success: true, data: [{ _id: 'f1' }] } }), agentFound]);
     await new FunctionsSDK(new IndemnClient()).bulkCreate(AGENT, [{ type: 'rest_api', name: 'quote', description: 'q' }]);
     expect(calls[0].body).toEqual({ functions: [{ type: 'rest_api', name: 'quote', description: 'q' }] });
   });
@@ -116,31 +117,32 @@ describe('skills SDK and tools', () => {
       on('GET', `/bots/${AGENT}/functions`, { json: { success: true, data: [{ _id: 'f1', type: 'rest_api', description: 'Checks a date',
         configurationSchema: { endpoint: 'https://x/date', method: 'POST', authorization: { type: 'bearer-token', token: 't' } } }] } }),
       on('PUT', `/bots/${AGENT}/functions/f1`, { json: { success: true, data: { _id: 'f1' } } }),
-    ]);
+      on('GET', `/v1-agents/${AGENT}`, { json: { id: AGENT, lifecycle: 'prototype' } }),  // not live: no approval asked
+    , agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
-    await pair.call('create_function', { agent_id: AGENT, type: 'rest_api', name: 'validate_date', description: 'Checks a date', url: 'https://x/date', method: 'post', payload: { date_str: '{{event_date}}' } });
+    await pair.call('create_function', { confirm: true, agent_id: AGENT, type: 'rest_api', name: 'validate_date', description: 'Checks a date', url: 'https://x/date', method: 'post', payload: { date_str: '{{event_date}}' } });
     expect(calls.find((c) => c.method === 'POST')?.body).toEqual({ type: 'rest_api', name: 'validate_date', description: 'Checks a date' });
     expect(calls.filter((c) => c.method === 'PUT')[0].body).toEqual({ type: 'rest_api', description: 'Checks a date',
       configurationSchema: { endpoint: 'https://x/date', method: 'POST', payload: '{"date_str":"{{event_date}}"}', authorization: { type: 'no-auth' }, craftResponse: true } });
     await pair.call('update_function', { agent_id: AGENT, function_id: 'f1', response_field: 'data.valid' });
     expect(calls.filter((c) => c.method === 'PUT')[1].body).toEqual({ type: 'rest_api', description: 'Checks a date',
       configurationSchema: { endpoint: 'https://x/date', method: 'POST', authorization: { type: 'bearer-token', token: 't' }, responseField: 'data.valid' } });
-    await pair.call('create_function', { agent_id: AGENT, type: 'rest_api', name: 'said', url: 'https://x/a', method: 'GET', output_instructions: 'Your quote is {{response.total}}.' });
+    await pair.call('create_function', { confirm: true, agent_id: AGENT, type: 'rest_api', name: 'said', url: 'https://x/a', method: 'GET', output_instructions: 'Your quote is {{response.total}}.' });
     expect(calls.filter((c) => c.method === 'PUT')[2].body.configurationSchema).toMatchObject({ outputInstructions: 'Your quote is {{response.total}}.' });
     expect(calls.filter((c) => c.method === 'PUT')[2].body.configurationSchema.craftResponse).toBeUndefined();
-    const missing = await pair.call('create_function', { agent_id: AGENT, type: 'rest_api', name: 'no_url' });
+    const missing = await pair.call('create_function', { confirm: true, agent_id: AGENT, type: 'rest_api', name: 'no_url' });
     expect(missing.isError).toBe(true);
     await pair.close();
-  });
+  }, 30_000);  // four skill changes, each previewed before it is confirmed
 
   it('MCP skill tools take typed REST auth and JSON text for free-form objects (as Gemini sends them)', async () => {
     const NEW = 'fn-new';
     const { calls } = recordFetch([
       on('POST', `/ai-studio/bots/${AGENT}/functions`, { json: { success: true, data: { _id: NEW, type: 'rest_api', name: 'get_quote' } } }),
       on('PUT', `/functions/${NEW}`, { json: { success: true, data: {} } }),
-    ]);
+     agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
-    const res = await pair.call('create_function', {
+    const res = await pair.call('create_function', { confirm: true,
       agent_id: AGENT, type: 'rest_api', name: 'get_quote', url: 'https://api.example.com/quote', method: 'POST',
       auth_type: 'bearer-token', auth_token: 'abc', auth_key: '', auth_username: '',
       payload: '{"event_date": "{{event_date}}", "guests": {{guests}}}',
@@ -160,9 +162,9 @@ describe('skills SDK and tools', () => {
       on('GET', `/v2/bots/${AGENT}`, { json: [{ _id: AGENT, name: 'Bot' }] }),
       on('GET', `/ai-studio/bots/${AGENT}/functions`, { json: { success: true, data: [existing] } }),
       on('DELETE', '/functions/f1', { json: { success: true } }),
-    ]);
+     agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
-    const dup = await pair.call('create_function', { agent_id: AGENT, type: 'rest_api', name: 'Get_Quote', url: 'https://y', method: 'POST' });
+    const dup = await pair.call('create_function', { confirm: true, agent_id: AGENT, type: 'rest_api', name: 'Get_Quote', url: 'https://y', method: 'POST' });
     expect(dup.isError).toBe(true);
     expect(String(dup.body)).toMatch(/already has a skill named "Get_Quote" \(function_id f1\)\. Change it with update_function/);
     expect(calls.some((c) => c.method === 'POST')).toBe(false);
@@ -180,20 +182,20 @@ describe('skills SDK and tools', () => {
       on('POST', `/ai-studio/bots/${AGENT}/functions`, { json: { success: true, data: { _id: 'fx', type: 'rest_api', name: 'quote' } } }),
       on('PUT', '/functions/fx', { status: 500, json: { error: 'Payload must be a valid JSON string.' } }),
       on('DELETE', '/functions/fx', { json: { success: true } }),
-    ]);
+     agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
-    const bad = await pair.call('create_function', { agent_id: AGENT, type: 'rest_api', name: 'quote', url: 'https://x', method: 'POST', payload: '{"a": 1,}' });
+    const bad = await pair.call('create_function', { confirm: true, agent_id: AGENT, type: 'rest_api', name: 'quote', url: 'https://x', method: 'POST', payload: '{"a": 1,}' });
     expect(bad.isError).toBe(true);
     expect(String(bad.body)).toMatch(/request body is not valid JSON.*Nothing was saved/);
     expect(calls.some((c) => c.method === 'POST')).toBe(false);
-    const refused = await pair.call('create_function', { agent_id: AGENT, type: 'rest_api', name: 'quote', url: 'https://x', method: 'POST' });
+    const refused = await pair.call('create_function', { confirm: true, agent_id: AGENT, type: 'rest_api', name: 'quote', url: 'https://x', method: 'POST' });
     expect(String(refused.body)).toMatch(/Nothing was saved: the skill's configuration was refused/);
     expect(calls.filter((c) => c.method === 'DELETE').map((c) => c.url)).toEqual([expect.stringContaining('/functions/fx')]);
     await pair.close();
   });
 
   it('MCP import_functions warns that everything is replaced and waits for confirmation', async () => {
-    const { calls } = recordFetch([on('GET', `/v2/bots/${AGENT}`, { json: [{ _id: AGENT, name: 'Bot' }] })]);
+    const { calls } = recordFetch([on('GET', `/v2/bots/${AGENT}`, { json: [{ _id: AGENT, name: 'Bot' }] }), agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
     const res = await pair.call('import_functions', { agent_id: AGENT, url: 'https://x/skills.json' });
     expect(res.body).toMatchObject({ dry_run: true });
@@ -212,7 +214,7 @@ describe('skills SDK and tools', () => {
       on('PUT', `/bots/${AGENT}/functions/f1`, { json: { success: true, data: { _id: 'f1' } } }),
       on('PUT', `/bots/${AGENT}`, { json: { success: true, data: { _id: AGENT } } }),
       on('PATCH', `/bots/${AGENT}`, { json: { success: true, data: { _id: AGENT } } }),
-    ]);
+     agentFound]);
     const pair = await connectPair((server) => { registerTools(server, new IndemnClient()); });
     const writes = () => calls.filter((c) => c.method === 'PUT' || c.method === 'PATCH').length;