@indemn/cli 1.7.3 → 1.7.5

package/src/sdk/client.ts

@@ -1,10 +1,10 @@
 import Conf from 'conf';
 import { chmodSync } from 'node:fs';
-import type { ApiResponse, Environment, EnvironmentHosts, IndemnConfig } from './types.js';
-import { CliError, cliVersion, isDebug, SessionExpiredError } from '../core/runtime.js';
+import type { ApiResponse, Environment, EnvironmentHosts, IndemnConfig, OrgSummary } from './types.js';
+import { CliError, cliVersion, indemnHost, isDebug, SessionExpiredError } from '../core/runtime.js';
 import { copilotAuthHeader, darwinAuthHeader, resolveCredential, type Credential } from './credentials.js';
-import { exchangeIdToken, needsRenewal, refreshIdToken, toStoredSession } from './session.js';
-import { findLinkFile, resolveOrg, type LinkFile, type OrgChoice, type ResolvedOrg } from '../core/org-resolver.js';
+import { tokenExpiry } from './session.js';
+import { findLinkFile, resolveOrg, type LinkFile, type ResolvedOrg } from '../core/org-resolver.js';
 import { emitOrgResolved, getAskers, getOrgFlag, scopedOrg } from '../core/scope.js';
 
 export const DEFAULT_HOSTS: Record<Environment, EnvironmentHosts> = {
@@ -60,7 +60,6 @@ function sleep(ms: number): Promise<void> {
 }
 
 /** One renewal at a time per process, shared by every client. */
-let renewing: Promise<void> | null = null;
 
 export interface OrgContext extends ResolvedOrg {
   name?: string;
@@ -73,7 +72,7 @@ export class IndemnClient {
   private hosts: EnvironmentHosts;
   private resolvedOrg?: Promise<OrgContext>;
   private linkCache?: LinkFile | null;
-  private membershipCache?: OrgChoice[];
+  private membershipCache?: OrgSummary[];
 
   private ignoreLink: boolean;
 
@@ -91,10 +90,10 @@ export class IndemnClient {
     const defaultHosts = DEFAULT_HOSTS[this.environment];
     const configHosts = config?.hosts?.[this.environment];
     this.hosts = {
-      copilot: process.env.INDEMN_COPILOT_URL || configHosts?.copilot || defaultHosts.copilot,
-      evaluations: process.env.INDEMN_EVALS_URL || configHosts?.evaluations || defaultHosts.evaluations,
-      middleware: process.env.INDEMN_MIDDLEWARE_URL || configHosts?.middleware || defaultHosts.middleware,
-      platform: process.env.INDEMN_PLATFORM_URL || configHosts?.platform || defaultHosts.platform,
+      copilot: indemnHost(process.env.INDEMN_COPILOT_URL || configHosts?.copilot || defaultHosts.copilot, 'The copilot host'),
+      evaluations: indemnHost(process.env.INDEMN_EVALS_URL || configHosts?.evaluations || defaultHosts.evaluations, 'The evaluations host'),
+      middleware: indemnHost(process.env.INDEMN_MIDDLEWARE_URL || configHosts?.middleware || defaultHosts.middleware, 'The middleware host'),
+      platform: ((p) => p && indemnHost(p, 'The V2 platform host'))(process.env.INDEMN_PLATFORM_URL || configHosts?.platform || defaultHosts.platform),
     };
   }
 
@@ -108,6 +107,7 @@ export class IndemnClient {
       projectName: 'indemn',
       configName: 'config',
       cwd: `${process.env.HOME}/.indemn`,
+      configFileMode: 0o600,  // owner-only from the first write: it holds the session and refresh token
     });
   }
 
@@ -166,52 +166,34 @@ export class IndemnClient {
   }
 
   /**
-   * Get a fresh copilot session with the saved Firebase refresh token, save
-   * it, and revoke the old one. Accounts with MFA are asked for the emailed
-   * code when a terminal or MCP host can ask; otherwise the person must log in.
+   * The credential for the next request. A saved login lasts its 24 hours and is never renewed (no refresh
+   * token is kept): once it ends, nothing is sent and `indemn login` gives a new one.
    */
-  async renewSession(): Promise<void> {
-    if (renewing) return renewing;
-    renewing = (async () => {
-      const config = IndemnClient.loadConfig();
-      const old = config?.session;
-      if (!config || !old?.refresh_token) {
-        throw new SessionExpiredError('Session expired. Run `indemn login`, then retry.');
-      }
-      const { idToken, refreshToken } = await refreshIdToken(config.environment, old.refresh_token);
-      const { token } = await exchangeIdToken(
-        (path, body, headers) => this.copilotPostUnauth(path, body, headers),
-        idToken,
-        getAskers().mfaCode,
-      );
-      IndemnClient.saveConfig({ session: toStoredSession(token, refreshToken) });
-      try {
-        await this.send('copilot', 'POST', `${this.hosts.copilot}/auth/firebase/logout`, {
-          auth: false,
-          headers: { Authorization: `JWT ${old.token}` },
-        });
-      } catch {
-        // Best effort: the old token expires within the hour anyway.
-      }
-    })().finally(() => {
-      renewing = null;
-    });
-    return renewing;
-  }
-
-  /** The credential for the next request, renewed first when a saved session is about to expire. */
   private async freshCredential(): Promise<Credential> {
-    let cred = this.requireCredential();
+    const cred = this.requireCredential();
     if (cred.kind === 'token' && cred.source === 'config') {
       const session = IndemnClient.loadConfig()?.session;
-      if (session && needsRenewal(session)) {
-        await this.renewSession();
-        cred = this.requireCredential();
+      // A refresh token kept by an earlier version is deleted: nothing that outlives logout stays on disk.
+      if (session?.refresh_token) IndemnClient.saveConfig({ session: { token: session.token, expires_at: session.expires_at } });
+      if (session?.expires_at && new Date(session.expires_at).getTime() <= Date.now()) {
+        throw new SessionExpiredError('Your login has ended (logins last 24 hours). Run `indemn login`, then retry.');
       }
+    } else if (cred.kind === 'token') {
+      // A host's session (Darwin hands over the person's Copilot session): over once its 24 hours are.
+      const expiry = tokenExpiry(cred.token);
+      if (expiry && expiry.getTime() <= Date.now()) throw new SessionExpiredError(this.loginAgain('Your Copilot session has ended.'));
     }
     return cred;
   }
 
+  /** How access comes back once the session has ended: a host's session (Darwin) by signing in to Copilot again. */
+  private loginAgain(what: string): string {
+    const cred = this.getCredential();
+    return cred?.kind === 'token' && cred.source === 'env'
+      ? `${what} Sign in to Copilot again, then retry.`
+      : `${what} Run \`indemn login\`, then retry.`;
+  }
+
   private async authHeader(): Promise<string> {
     return copilotAuthHeader(await this.freshCredential());
   }
@@ -225,16 +207,18 @@ export class IndemnClient {
     return this.linkCache;
   }
 
-  /** Orgs the user belongs to: saved at login, else asked live from copilot. */
-  async memberships(): Promise<OrgChoice[]> {
-    if (this.membershipCache) return this.membershipCache;
+  /** Orgs the user belongs to: saved at login, else (or `live`) asked from copilot; a live answer updates the login's list. */
+  async memberships(opts: { live?: boolean } = {}): Promise<OrgSummary[]> {
+    if (this.membershipCache && !opts.live) return this.membershipCache;
     const cred = this.requireCredential();
     const saved = cred.source === 'config' ? IndemnClient.loadConfig()?.orgs : undefined;
-    if (saved?.length) {
+    if (saved?.length && !opts.live) {
       this.membershipCache = saved;
     } else {
       const res = await this.copilotGet<{ userOrganizations?: Array<{ _id: string; name: string }> }>('/organization');
       this.membershipCache = (res.userOrganizations ?? []).map((o) => ({ id: String(o._id), name: o.name }));
+      // An empty answer never replaces the login's list (the check against it would be off from then on).
+      if (cred.source === 'config' && this.membershipCache.length) IndemnClient.saveConfig({ orgs: this.membershipCache });
     }
     return this.membershipCache;
   }
@@ -251,6 +235,8 @@ export class IndemnClient {
         link: this.getLink(),
         environment: this.environment,
         memberships: () => this.memberships(),
+        known: this.getCredential()?.source === 'config' ? IndemnClient.loadConfig()?.orgs : undefined,
+        refresh: () => this.memberships({ live: true }),
         ask: getAskers().chooseOrg,
       });
       const known = this.membershipCache ?? IndemnClient.loadConfig()?.orgs ?? [];
@@ -286,13 +272,16 @@ export class IndemnClient {
    * In a linked folder with an agent list, refuse any agent that is not on
    * the list before a request leaves the machine.
    */
-  private assertAgentInScope(path: string): void {
+  private assertAgentInScope(path: string, body?: unknown): void {
     const link = this.getLink();
     if (!link || link.agents.length === 0) return;
-    const match = /\/bots\/([a-f0-9]{24})(?:\/|$|\?)/i.exec(path);
-    if (match && !link.agents.includes(match[1])) {
+    // The agent in the path (copilot /bots/<id>, V2 /v1-agents/<id>) and in the body (evaluations, simulations).
+    const b = (body && typeof body === 'object' && !(body instanceof FormData) ? body : {}) as Record<string, unknown>;
+    const ids = [/\/(?:bots|v1-agents)\/([a-f0-9]{24})(?:\/|$|\?)/i.exec(path)?.[1], b.bot_id, b.agent_id, ...(Array.isArray(b.bot_ids) ? b.bot_ids : [])];
+    const outside = ids.find((id): id is string => typeof id === 'string' && /^[a-f0-9]{24}$/i.test(id) && !link.agents.includes(id));
+    if (outside) {
       throw new CliError(
-        `Agent ${match[1]} is not linked in ${link.path}. Linked agents: ${link.agents.join(', ')}. ` +
+        `Agent ${outside} is not linked in ${link.path}. Linked agents: ${link.agents.join(', ')}. ` +
           'Add it with `indemn link` or work from another folder.',
       );
     }
@@ -303,7 +292,6 @@ export class IndemnClient {
     if (path.includes(':org_id')) {
       resolvedPath = path.replace(':org_id', await this.currentOrgId());
     }
-    this.assertAgentInScope(resolvedPath);
     return `${this.hosts.copilot}${resolvedPath}`;
   }
 
@@ -317,6 +305,7 @@ export class IndemnClient {
    * create twice).
    */
   private async send(backend: Backend, method: Method, url: string, opts: SendOptions = {}): Promise<Response> {
+    this.assertAgentInScope(new URL(url).pathname, opts.body);
     const headers: Record<string, string> = {
       'User-Agent': `indemn-cli/${cliVersion()}`,
       'X-Indemn-Client': clientKind,
@@ -373,12 +362,7 @@ export class IndemnClient {
    */
   private async copilotRequest<T>(method: Method, path: string, opts: { body?: unknown; query?: Record<string, string> } = {}): Promise<T> {
     const url = this.withQuery(await this.buildCopilotUrl(path), opts.query);
-    let res = await this.send('copilot', method, url, { body: opts.body });
-    const cred = this.getCredential();
-    if (res.status === 401 && cred?.kind === 'token' && cred.source === 'config') {
-      await this.renewSession();
-      res = await this.send('copilot', method, url, { body: opts.body });
-    }
+    const res = await this.send('copilot', method, url, { body: opts.body });
     return this.handleCopilotResponse<T>(res);
   }
 
@@ -390,7 +374,7 @@ export class IndemnClient {
   /** A copilot request whose answer is a file or audio, returned as bytes. */
   async copilotBinary(method: Method, path: string, body?: unknown): Promise<{ contentType: string; data: Buffer }> {
     const res = await this.send('copilot', method, await this.buildCopilotUrl(path), { body });
-    if (res.status === 401) throw new SessionExpiredError('Authentication failed. Run `indemn login` to re-authenticate.');
+    if (res.status === 401) throw new SessionExpiredError(this.loginAgain('Authentication failed.'));
     if (!res.ok) throw new Error(`API error (${res.status}): ${await res.text()}`);
     return { contentType: res.headers.get('content-type') ?? 'application/octet-stream', data: Buffer.from(await res.arrayBuffer()) };
   }
@@ -426,19 +410,13 @@ export class IndemnClient {
     const base = this.hosts.platform;
     if (!base) throw new CliError('No V2 platform host is configured for this environment.');
     const url = this.withQuery(`${base}${path}`, opts.query);
-    this.assertAgentInScope(path);
     const headersFor = async (): Promise<Record<string, string>> => {
       const headers: Record<string, string> = { Authorization: darwinAuthHeader(await this.freshCredential()) };
       if (opts.orgHeader !== false) headers['X-Organization-Id'] = await this.currentOrgId();
       return headers;
     };
-    let res = await this.send('platform', method, url, { body: opts.body, headers: await headersFor() });
-    const cred = this.getCredential();
-    if (res.status === 401 && cred?.kind === 'token' && cred.source === 'config') {
-      await this.renewSession();
-      res = await this.send('platform', method, url, { body: opts.body, headers: await headersFor() });
-    }
-    if (res.status === 401) throw new SessionExpiredError('The V2 platform rejected the session. Run `indemn login`, then retry.');
+    const res = await this.send('platform', method, url, { body: opts.body, headers: await headersFor() });
+    if (res.status === 401) throw new SessionExpiredError(this.loginAgain('The V2 platform rejected the session.'));
     if (!res.ok) {
       const text = await res.text();
       let detail = text;
@@ -480,7 +458,7 @@ export class IndemnClient {
 
   private async handleCopilotResponse<T>(res: Response): Promise<T> {
     if (res.status === 401) {
-      throw new SessionExpiredError('Authentication failed. Run `indemn login` to re-authenticate.');
+      throw new SessionExpiredError(this.loginAgain('Authentication failed.'));
     }
     if (res.status === 403) {
       // Keep the server's reason: "Tickets are not enabled for this organization." is not a permission problem.

package/src/sdk/config-change.ts

@@ -98,7 +98,7 @@ export async function planConfigChange(client: IndemnClient, agentId: string, ch
   }
   let lifecycle = 'unknown';
   try {
-    lifecycle = (await new AgentInsightsSDK(client).detail(agentId)).lifecycle ?? 'prototype';
+    lifecycle = (await new AgentInsightsSDK(client).detail(agentId)).lifecycle ?? 'unknown';
   } catch {
     // The V2 platform may be unreachable; callers treat "unknown" as published (mayBeLive).
   }

package/src/sdk/conversations.ts

@@ -171,7 +171,7 @@ export class ConversationsSDK {
         if (conversation.isTestMode !== true || conversation.attributes?.isTestMode === false) {
           throw new CliError(
             `Conversation ${requestId} was stored as a live conversation, not a test. Nothing was sent. ` +
-              'Mark it as test with `indemn conversations mark-test` and report this.',
+              'If this CLI started it, mark it as test with `indemn conversations mark-test` and report this.',
           );
         }
         if (org && org !== expectedOrgId) {

package/src/sdk/functions.ts

@@ -1,5 +1,5 @@
 import type { IndemnClient } from './client.js';
-import { CliError } from '../core/runtime.js';
+import { CliError, uploadable } from '../core/runtime.js';
 import { assertSkillNameAllowed } from './skills.js';
 import type { BotFunction, CreateFunctionInput, UpdateFunctionInput, FunctionParameter } from './types.js';
 
@@ -126,7 +126,7 @@ export class FunctionsSDK {
       const { readFileSync } = await import('node:fs');
       const { basename } = await import('node:path');
       const form = new FormData();
-      form.append('file', new Blob([readFileSync(source.filePath)]), basename(source.filePath));
+      form.append('file', new Blob([readFileSync(uploadable(source.filePath))]), basename(source.filePath));
       return this.client.copilotPostForm(path, form);
     }
     return this.client.copilotPost(path, { text: source.text });

package/src/sdk/jarvis-chat.ts

@@ -1,6 +1,6 @@
 import type { IndemnClient } from './client.js';
 import { darwinAuthHeader } from './credentials.js';
-import { CliError } from '../core/runtime.js';
+import { CliError, indemnHost } from '../core/runtime.js';
 
 export interface JarvisToolEvent {
   name: string;
@@ -16,7 +16,7 @@ export interface JarvisReply {
 
 /** wss://<platform host>/ws, derived from the REST base (…/api/v1), or INDEMN_PLATFORM_WS_URL. */
 export function jarvisSocketUrl(client: IndemnClient): string {
-  if (process.env.INDEMN_PLATFORM_WS_URL) return process.env.INDEMN_PLATFORM_WS_URL;
+  if (process.env.INDEMN_PLATFORM_WS_URL) return indemnHost(process.env.INDEMN_PLATFORM_WS_URL, 'INDEMN_PLATFORM_WS_URL');
   const base = client.getHosts().platform;
   if (!base) throw new CliError('No V2 platform host is configured for this environment.');
   const u = new URL(base);

package/src/sdk/kb.ts

@@ -1,5 +1,5 @@
 import type { IndemnClient } from './client.js';
-import { CliError, EXIT } from '../core/runtime.js';
+import { CliError, EXIT, uploadable } from '../core/runtime.js';
 import type {
   KnowledgeBase,
   CreateKBInput,
@@ -88,7 +88,7 @@ export class KBSDK {
     if (selected) {
       try { site = new URL(url).origin; } catch { site = url; }
     }
-    return this.client.copilotPost(
+    const result = await this.client.copilotPost<{ status?: string; message?: string }>(
       `/organization/:org_id/knowledge-bases/${kbId}/import`,
       {
         type: 'url',
@@ -96,6 +96,9 @@ export class KBSDK {
         sources: [{ url: site, crawl_mode: selected ? 'selected' : 'full', selected_urls: selected ? [url] : [], exclude_urls: [], js_script: '' }],
       },
     );
+    // copilot answers a crawl that never started (unreachable url) with success and status "error".
+    assertJobStarted(result, 'Crawl');
+    return result;
   }
 
   /**
@@ -111,6 +114,7 @@ export class KBSDK {
     if (!fs.existsSync(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
+    uploadable(filePath);
     const fileName = path.basename(filePath);
     const ext = path.extname(fileName).slice(1).toLowerCase();
     const allowed = ['pdf', 'docx', 'doc', 'txt', 'csv', 'xls', 'xlsx', 'json'];
@@ -138,7 +142,7 @@ export class KBSDK {
     const fs = await import('fs');
     const path = await import('path');
     const formData = new FormData();
-    formData.append('file', new Blob([fs.readFileSync(filePath)]), path.basename(filePath));
+    formData.append('file', new Blob([fs.readFileSync(uploadable(filePath))]), path.basename(filePath));
     const stored = await this.client.copilotPostForm<{ url?: string; signedUrl?: string; data?: { url?: string; signedUrl?: string } }>(
       '/organization/:org_id/files/upload-org?generateSignedUrl=true',
       formData,
@@ -264,7 +268,7 @@ export class KBSDK {
    * Crawl and file-import status. copilot has no status route, so this reads
    * the KB's non-manual sources and their scrape jobs.
    */
-  async scrapeStatus(kbId: string): Promise<Array<{ id?: string; name?: string; source?: string; status?: string; job_status?: string; error?: string; completed_at?: string }>> {
+  async scrapeStatus(kbId: string): Promise<Array<{ id?: string; name?: string; source?: string; status?: string; job_id?: string; job_status?: string; error?: string; completed_at?: string }>> {
     const kb = await this.getKB(kbId) as unknown as { fileWebSources?: Array<Record<string, any>> };
     return (kb.fileWebSources ?? []).map((s) => ({
       id: s._id ? String(s._id) : undefined,
@@ -272,6 +276,8 @@ export class KBSDK {
       // and keep the link without its signature.
       ...(s.type === 'file' ? { name: s.source_details?.file_name ?? undefined, source: s.source ? String(s.source).split('?')[0] : undefined } : { source: s.source }),
       status: s.status,
+      // The crawl or import that brought the source in (the job id a crawl tool returned as _id).
+      job_id: s.source_details?.id_scrape_request?._id ? String(s.source_details.id_scrape_request._id) : undefined,
       job_status: s.source_details?.id_scrape_request?.status,
       error: s.error_message ?? s.source_details?.id_scrape_request?.message,
       completed_at: s.source_details?.id_scrape_request?.completed_at ?? undefined,

package/src/sdk/orgs.ts

@@ -13,10 +13,7 @@ export class OrgsSDK {
 
   /** Orgs the logged-in person belongs to or created. Also refreshes the list saved at login. */
   async listOrganizations(): Promise<OrgSummary[]> {
-    const res = await this.client.copilotGet<{ userOrganizations?: Array<{ _id: string; name: string }> }>('/organization');
-    const orgs = (res.userOrganizations ?? []).map((o) => ({ id: String(o._id), name: o.name }));
-    if (this.client.getCredential()?.source === 'config') IndemnClient.saveConfig({ orgs });
-    return orgs;
+    return this.client.memberships({ live: true });
   }
 
   /** People with owner, admin or agent roles in the org, one row per person. */

package/src/sdk/session.ts

@@ -2,9 +2,7 @@ import type { Environment, StoredSession } from './types.js';
 
 export type { StoredSession };
 import { SessionExpiredError } from '../core/runtime.js';
-import { FIREBASE_CONFIGS } from './auth.js';
 
-const SECURE_TOKEN_URL = 'https://securetoken.googleapis.com/v1/token';
 
 export type UnauthPost = <T>(path: string, body: unknown, headers?: Record<string, string>) => Promise<T>;
 
@@ -23,28 +21,7 @@ export function tokenExpiry(token: string): Date | null {
 }
 
 /** Renew when less than `windowMs` (default one hour) of life is left. Unknown expiry never renews. */
-export function needsRenewal(session: StoredSession, now: Date = new Date(), windowMs = 60 * 60 * 1000): boolean {
-  const expiry = session.expires_at ? new Date(session.expires_at) : tokenExpiry(session.token);
-  if (!expiry || Number.isNaN(expiry.getTime())) return false;
-  return expiry.getTime() - now.getTime() < windowMs;
-}
 
-/** Trade the Firebase refresh token for a fresh Firebase ID token (Google secure-token API). */
-export async function refreshIdToken(env: Environment, refreshToken: string): Promise<{ idToken: string; refreshToken: string }> {
-  const url = `${SECURE_TOKEN_URL}?key=${encodeURIComponent(FIREBASE_CONFIGS[env].apiKey)}`;
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-    body: new URLSearchParams({ grant_type: 'refresh_token', refresh_token: refreshToken }).toString(),
-  });
-  if (!res.ok) {
-    // Revoked, password changed or account disabled: a real login is the right answer.
-    throw new SessionExpiredError(`Session expired and could not be renewed. ${RELOGIN}`);
-  }
-  const json = await res.json() as { id_token?: string; refresh_token?: string };
-  if (!json.id_token) throw new SessionExpiredError(`Session renewal returned no token. ${RELOGIN}`);
-  return { idToken: json.id_token, refreshToken: json.refresh_token || refreshToken };
-}
 
 function stripScheme(token: string): string {
   return token.replace(/^JWT\s+/i, '');
@@ -84,7 +61,7 @@ export async function exchangeIdToken(
 }
 
 /** Package a copilot token for storage. */
-export function toStoredSession(token: string, refreshToken?: string): StoredSession {
+export function toStoredSession(token: string): StoredSession {
   const expiry = tokenExpiry(token);
-  return { token, expires_at: expiry?.toISOString(), refresh_token: refreshToken };
+  return { token, expires_at: expiry?.toISOString() };
 }

package/src/sdk/test-chat.ts

@@ -78,6 +78,12 @@ export async function openTestChat(
   const firstMessage = opts.sessionId ? undefined : (await new ConfigSDK(client).getConfig(agent._id).catch(() => undefined))?.first_message;
   const customData = firstMessage?.text ? { first_message: firstMessage } : undefined;
 
+  // A conversation named by the caller may be a customer's live one: it is checked before anything is sent to it,
+  // and never ended here.
+  if (opts.sessionId) {
+    if (!projectId) throw new Error(`Agent ${agent._id} has no project; cannot confirm the conversation is a test. Nothing was sent.`);
+    await new ConversationsSDK(client).verifyTestConversation(projectId, opts.sessionId, orgId, { timeoutMs: 0 });
+  }
   const session = new ChatSession(agent._id, client.getHosts().middleware, opts.sessionId, { tester, preview, customData });
   const transcript: string[] = [];
   let receiving = false;
@@ -92,7 +98,7 @@ export async function openTestChat(
     if (!projectId) throw new Error(`Agent ${agent._id} has no project; cannot confirm the conversation is a test. Nothing was sent.`);
     await new ConversationsSDK(client).verifyTestConversation(projectId, sessionId, orgId, { timeoutMs: opts.verifyTimeoutMs });
   } catch (err) {
-    await session.disconnect();
+    await session.disconnect({ end: !opts.sessionId });
     throw err;
   }
   return {
@@ -132,19 +138,23 @@ export async function exchange(
   message: string,
   opts: { greetingWaitMs?: number; timeoutMs?: number; settleMs?: number } = {},
 ): Promise<{ greeting: string; response: string }> {
-  if (!chat.resumed) {
-    await until(() => chat.transcript.length > 0 && !chat.isReceiving(), opts.greetingWaitMs ?? 8_000);
+  const timeoutMs = opts.timeoutMs ?? 60_000;
+  // A new conversation's greeting must be complete first, or it would be taken for the reply.
+  if (!chat.resumed && !(await until(() => chat.transcript.length > 0 && !chat.isReceiving(), opts.greetingWaitMs ?? timeoutMs))) {
+    throw new Error(`The agent's greeting did not finish within ${Math.round((opts.greetingWaitMs ?? timeoutMs) / 1000)} seconds; nothing was sent.`);
   }
   const greeting = chat.transcript.join('\n');
   const start = chat.transcript.length;
+  const deadline = Date.now() + timeoutMs;
   chat.session.send(message);
 
-  const gotReply = await until(() => chat.transcript.length > start && !chat.isReceiving(), opts.timeoutMs ?? 60_000);
-  if (!gotReply) throw new Error(`Agent did not respond within ${Math.round((opts.timeoutMs ?? 60_000) / 1000)} seconds.`);
+  const gotReply = await until(() => chat.transcript.length > start && !chat.isReceiving(), timeoutMs);
+  if (!gotReply) throw new Error(`Agent did not respond within ${Math.round(timeoutMs / 1000)} seconds.`);
   let seen = chat.transcript.length;
   for (;;) {
     await new Promise((resolve) => setTimeout(resolve, opts.settleMs ?? 1_500));
-    if (chat.transcript.length === seen && !chat.isReceiving()) break;
+    // A stream that never finishes ends the wait at the deadline, with what arrived.
+    if ((chat.transcript.length === seen && !chat.isReceiving()) || Date.now() >= deadline) break;
     seen = chat.transcript.length;
   }
   return { greeting, response: chat.transcript.slice(start).join('\n') };

package/test/cli/init.test.ts

@@ -40,6 +40,20 @@ describe('indemn init', () => {
     expect(settings.permissions.allow).not.toContain('mcp__indemn__list_agents');
   });
 
+  it('moves an older Indemn entry in .mcp.json to this version (only the version), and keeps an entry the user wrote', () => {
+    const mcpJson = () => JSON.parse(readFileSync(join(dir, '.mcp.json'), 'utf8')).mcpServers.indemn;
+    const older = { command: 'npx', args: ['-y', '@indemn/cli@1.7.4', '--org', 'org1', 'mcp', 'serve'], env: { INDEMN_ENV: 'dev' } };
+    writeFileSync(join(dir, '.mcp.json'), JSON.stringify({ mcpServers: { indemn: older } }));
+    expect(initProject(dir, { packageRoot }).mcp).toBe('updated');
+    expect(mcpJson()).toEqual({ ...older, args: ['-y', MCP_SERVER_ENTRY.args[1], '--org', 'org1', 'mcp', 'serve'] });
+    expect(initProject(dir, { packageRoot, force: true }).mcp).toBe('kept');
+
+    const own = { command: 'node', args: ['./dist/index.js', 'mcp', 'serve'] };
+    writeFileSync(join(dir, '.mcp.json'), JSON.stringify({ mcpServers: { indemn: own } }));
+    expect(initProject(dir, { packageRoot, force: true }).mcp).toBe('kept');
+    expect(mcpJson()).toEqual(own);
+  });
+
   it('classifies every tool: guarded or destructive tools ask', () => {
     const { allow, ask } = permissionBlock();
     expect(allow.length + ask.length).toBe(Object.keys(TOOL_META).length);

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

@@ -15,10 +15,46 @@ describe('resolveOrg precedence', () => {
   it.each([
     ['flag', { flag: B.id }, B.id],
     ['env', { envOrg: B.id }, B.id],
-  ])('%s decides without looking up memberships', async (source, extra, id) => {
+  ])('%s decides without looking up memberships (checked against the orgs saved at login)', async (source, extra, id) => {
     const memberships = vi.fn();
-    await expect(resolveOrg({ ...base, ...extra, memberships })).resolves.toMatchObject({ id, source });
+    const refresh = vi.fn();
+    await expect(resolveOrg({ ...base, ...extra, memberships, known: [A, B], refresh })).resolves.toMatchObject({ id, source });
     expect(memberships).not.toHaveBeenCalled();
+    expect(refresh).not.toHaveBeenCalled();
+  });
+
+  it('looks again when an explicit org is not among the saved ones (joined since login)', async () => {
+    const C: OrgChoice = { id: 'cccccccccccccccccccccccc', name: 'Org C' };
+    const refresh = vi.fn().mockResolvedValue([A, B, C]);
+    await expect(resolveOrg({ ...base, flag: C.id, memberships: vi.fn(), known: [A, B], refresh })).resolves.toMatchObject({ id: C.id, source: 'flag' });
+    expect(refresh).toHaveBeenCalledOnce();
+  });
+
+  it('names your current orgs when the explicit org is not among them either', async () => {
+    const C: OrgChoice = { id: 'cccccccccccccccccccccccc', name: 'Org C' };
+    const refresh = vi.fn().mockResolvedValue([B, C]);
+    await expect(resolveOrg({ ...base, flag: A.id, memberships: vi.fn(), known: [B], refresh }))
+      .rejects.toThrow(`You are not a member of org ${A.id}. Your orgs: ${B.name} (${B.id}), ${C.name} (${C.id}).`);
+  });
+
+  it('refuses when the orgs looked up again are none at all', async () => {
+    await expect(resolveOrg({ ...base, flag: A.id, memberships: vi.fn(), known: [B], refresh: vi.fn().mockResolvedValue([]) }))
+      .rejects.toThrow(`You are not a member of org ${A.id}, or of any organization on this platform.`);
+  });
+
+  it("leaves the org to copilot's own check when the orgs cannot be looked up", async () => {
+    const refresh = vi.fn().mockRejectedValue(new Error('offline'));
+    await expect(resolveOrg({ ...base, flag: 'cccccccccccccccccccccccc', memberships: vi.fn(), known: [A, B], refresh }))
+      .resolves.toMatchObject({ id: 'cccccccccccccccccccccccc' });
+  });
+
+  it('names your orgs when an explicit org is not one of them (a typo, or another account)', async () => {
+    await expect(resolveOrg({ ...base, flag: 'cccccccccccccccccccccccc', memberships: vi.fn(), known: [A, B] }))
+      .rejects.toThrow(new RegExp(`not a member of org c+.*${A.name} \\(${A.id}\\)`));
+  });
+
+  it("without saved orgs (an API key, a host's session) an explicit org is left to copilot's own check", async () => {
+    await expect(resolveOrg({ ...base, flag: B.id, memberships: vi.fn() })).resolves.toMatchObject({ id: B.id });
   });
 
   it('a linked folder decides without looking up memberships', async () => {

package/test/core/scope.test.ts

@@ -90,4 +90,16 @@ describe('org for each request', () => {
     expect(calls[0].url).toContain(`/organization/${A}/`);
     expect(ask).not.toHaveBeenCalled();
   });
+
+  it('a linked folder also refuses an unlinked agent on the V2 platform and in evaluation calls', async () => {
+    const project = join(home.dir, 'project');
+    mkdirSync(join(project, '.indemn'), { recursive: true });
+    writeFileSync(join(project, '.indemn', 'project.json'), JSON.stringify({ org_id: A, environment: 'dev', agents: [AGENT_1] }));
+    vi.spyOn(process, 'cwd').mockReturnValue(project);
+    const { calls } = recordFetch();
+    const client = new IndemnClient();
+    await expect(client.platformRequest('PATCH', `/v1-agents/${AGENT_2}/lifecycle`, { body: { lifecycle: 'beta' } })).rejects.toThrow(/not linked/);
+    await expect(client.evalsPost('/api/v1/evaluations', { bot_id: AGENT_2 })).rejects.toThrow(/not linked/);
+    expect(calls).toHaveLength(0);
+  });
 });

package/test/helpers/mcp-pair.ts

@@ -27,12 +27,21 @@ export async function connectPair(
   }
   const [a, b] = InMemoryTransport.createLinkedPair();
   await Promise.all([server.connect(a), client.connect(b)]);
-  const call = async (name: string, args: Record<string, unknown> = {}) => {
+  const once = async (name: string, args: Record<string, unknown>) => {
     const res = await client.callTool({ name, arguments: args });
     const content = res.content as Array<{ type: string; text: string }>;
     let parsed: unknown = content[0]?.text;
     try { parsed = JSON.parse(content[0].text); } catch { /* plain text */ }
     return { raw: res, body: parsed as any, isError: Boolean(res.isError) };
   };
+  // As a model on a host without approval forms must: a change is shown as a dry run before `confirm: true`.
+  const call = async (name: string, args: Record<string, unknown> = {}) => {
+    if (args.confirm === true && !opts.elicit) {
+      const { confirm: _confirm, ...rest } = args;
+      const first = await once(name, rest);
+      if (first.body?.dry_run !== true) return first;
+    }
+    return once(name, args);
+  };
   return { server, client, call, questions, close: () => Promise.all([client.close(), server.close()]) };
 }