@inneranimalmedia/agentsam-sdk 2.5.0 → 2.6.1

package/test/responses-runner.test.mjs

@@ -0,0 +1,150 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import { createCapabilityAdapter } from '../src/agent/capability-adapter.js';
+import { buildAgentToolSurface, capabilityFunctionName, runResponsesAgent } from '../src/agent/responses-runner.js';
+
+function usage(input = 10_000, cumulative = input) {
+  return {
+    current_context: { input_tokens: input, window_tokens: 1_050_000 },
+    cumulative: { input_tokens: cumulative, output_tokens: 100, cached_input_tokens: 0, cache_write_tokens: 0, reasoning_tokens: 0 },
+    estimate_kind: 'provider', provider_authoritative: true,
+  };
+}
+function cost(total = 0.1) { return { total_usd: total, components_usd: { input: total * 0.5, cached_input: total * 0.1, cache_write: total * 0.1, output: total * 0.3 } }; }
+
+test('capability adapter hydrates packaged JSON schemas and tool surface exposes only selected executable schemas', () => {
+  const adapter = createCapabilityAdapter();
+  const descriptors = adapter.toolDescriptors();
+  assert.deepEqual(descriptors.map((row) => row.name).sort(), ['cloudflare.cpu.profile', 'cloudflare.wrangler.native', 'repository.snapshot']);
+  const repository = descriptors.find((row) => row.name === 'repository.snapshot');
+  assert.equal(repository.input_schema.type, 'object');
+  assert.ok(repository.input_schema.properties.cwd);
+  const surface = buildAgentToolSurface(adapter, 'snapshot inspect repository');
+  assert.equal(surface.tools.length, 1);
+  assert.equal(surface.tools[0].name, capabilityFunctionName('repository.snapshot'));
+  assert.equal(surface.tools[0].parameters.type, 'object');
+  assert.equal(surface.receipt.catalog_tools, 3);
+});
+
+test('runner owns cwd, executes selected tool, preserves call_id and returns provider-authoritative continuation', async t => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-runner-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  fs.mkdirSync(path.join(root, '.git'));
+  fs.writeFileSync(path.join(root, 'package.json'), '{"name":"runner-demo"}');
+  let invoked = null;
+  const capabilityAdapter = createCapabilityAdapter({
+    handlers: {
+      'repository.snapshot': async input => {
+        invoked = input;
+        return { ok: true, cwd: input.cwd, evidence: 'x'.repeat(500) };
+      },
+    },
+  });
+  const provider = {
+    async create(params) {
+      assert.equal(params.model, 'gpt-6-astra');
+      assert.equal(params.reasoningEffort, 'high');
+      assert.equal(params.serviceTier, 'fast');
+      assert.equal(params.tools.length, 1);
+      return {
+        response_id: 'resp_1', output_text: '', actual_service_tier: 'fast',
+        tool_calls: [{ call_id: 'call_1', name: capabilityFunctionName('repository.snapshot'), arguments: '{"cwd":"/tmp/attacker","churnDays":7}' }],
+        usage_snapshot: usage(20_000), cost: cost(0.2),
+      };
+    },
+    async continueWithToolOutputs(params) {
+      assert.equal(params.previousResponseId, 'resp_1');
+      assert.equal(params.toolOutputs[0].call_id, 'call_1');
+      assert.match(params.toolOutputs[0].output, /runner-demo|runner-/);
+      return { response_id: 'resp_2', output_text: 'done', actual_service_tier: 'fast', tool_calls: [], usage_snapshot: usage(21_000, 41_000), cost: cost(0.3) };
+    },
+    async compact() { throw new Error('should_not_compact'); },
+  };
+  const events = [];
+  const result = await runResponsesAgent({
+    provider, capabilityAdapter, cwd: root, prompt: 'snapshot inspect repository', model: 'gpt-6-astra', reasoningEffort: 'high', serviceTier: 'fast',
+    emit: event => events.push(event),
+  });
+  assert.equal(invoked.cwd, root);
+  assert.equal(invoked.churnDays, 7);
+  assert.equal(result.output_text, 'done');
+  assert.equal(result.response_id, 'resp_2');
+  assert.equal(result.total_cost_usd, 0.5);
+  assert.equal(result.cost_breakdown_usd.input, 0.25);
+  assert.equal(result.cost_breakdown_usd.output, 0.15);
+  assert.equal(result.continuation.compact_before_next_turn, false);
+  assert.ok(events.some(event => event.type === 'tool.search'));
+  assert.ok(events.some(event => event.type === 'tool.completed'));
+});
+
+test('runtime approval hook can deny a model-triggered tool before execution', async t => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-runner-denied-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  fs.writeFileSync(path.join(root, 'package.json'), '{"name":"denied-demo"}');
+  let invoked = false;
+  const capabilityAdapter = createCapabilityAdapter({
+    handlers: {
+      'repository.snapshot': async () => { invoked = true; return { ok: true }; },
+    },
+  });
+  const provider = {
+    async create() {
+      return {
+        response_id: 'resp_deny', output_text: '', actual_service_tier: 'default',
+        tool_calls: [{ call_id: 'call_deny', name: capabilityFunctionName('repository.snapshot'), arguments: '{}' }],
+        usage_snapshot: usage(10_000), cost: cost(0.01),
+      };
+    },
+    async continueWithToolOutputs() { throw new Error('continuation_should_not_run'); },
+  };
+  await assert.rejects(() => runResponsesAgent({
+    provider, capabilityAdapter, cwd: root, prompt: 'snapshot repository', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+    beforeTool: async request => {
+      assert.equal(request.capability_id, 'repository.snapshot');
+      assert.equal(request.cwd, root);
+      return false;
+    },
+  }), /tool_execution_not_approved:repository\.snapshot/);
+  assert.equal(invoked, false);
+});
+
+test('runner compacts before a projected high-context continuation rather than crossing normal policy blindly', async () => {
+  let compactCalls = 0;
+  let createInput = null;
+  const capabilityAdapter = createCapabilityAdapter();
+  const provider = {
+    async compact(params) {
+      compactCalls += 1;
+      assert.equal(params.previousResponseId, 'resp_old');
+      return { output: [{ type: 'compaction', encrypted_content: 'opaque-small' }] };
+    },
+    async create(params) {
+      createInput = params.input;
+      assert.equal(params.previousResponseId, undefined);
+      return { response_id: 'resp_new', output_text: 'ok', actual_service_tier: 'default', tool_calls: [], usage_snapshot: usage(30_000), cost: cost(0.1) };
+    },
+    async continueWithToolOutputs() { throw new Error('unused'); },
+  };
+  const result = await runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'continue repository work', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+    previousResponseId: 'resp_old', previousUsageSnapshot: usage(179_500),
+  });
+  assert.equal(compactCalls, 1);
+  assert.ok(Array.isArray(createInput));
+  assert.equal(createInput[0].type, 'compaction');
+  assert.equal(result.compacted_before_turn, true);
+});
+
+test('runner refuses an oversized initial context and supports an explicit projected call-cost ceiling', async () => {
+  const capabilityAdapter = createCapabilityAdapter();
+  const provider = { async create() { throw new Error('provider_should_not_run'); }, async continueWithToolOutputs() {}, async compact() {} };
+  await assert.rejects(() => runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'x'.repeat(800_000), model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+  }), /context_preflight_(pricing_threshold|max_normal|compaction_required)/);
+  await assert.rejects(() => runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'small task', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'fast', maxCallCostUsd: 0.01,
+  }), /projected_call_cost_exceeds_budget/);
+});

package/test/shell.test.mjs

@@ -5,6 +5,7 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import test from 'node:test';
 import { dispatchShellLine, renderShellCatalog, renderShellPrompt, tokenizeShellLine } from '../src/commands/shell.js';
+import { readCliPreferences, writeCliPreferences } from '../src/lib/cli-preferences.js';
 
 const repoRoot = path.resolve(new URL('..', import.meta.url).pathname);
 
@@ -21,47 +22,115 @@ test('interactive prompt derives username and cwd instead of hardcoding Agent Sa
   assert.equal(renderShellPrompt('/tmp/demo', env), 'alice /tmp/demo > ');
 });
 
-test('shell catalog advertises commands that the REPL owns', () => {
+test('shell startup stays quiet and points to the picker', () => {
   const catalog = renderShellCatalog();
-  assert.match(catalog, /\/help\s+Show Agent Sam commands/);
-  assert.match(catalog, /\/status\s+Local project/);
-  assert.match(catalog, /\/exit\s+Exit Agent Sam shell/);
+  for (const command of ['/model', '/usage', '/help', '/exit']) {
+    assert.match(catalog, new RegExp(command.replace('/', '\\/')));
+  }
+  assert.match(catalog, /command picker/);
+  assert.match(catalog, /Type normally to work with the selected model/);
+  assert.doesNotMatch(catalog, /Slash commands \(/);
+  assert.doesNotMatch(catalog, /\/reasoning\s+Set reasoning/);
 });
 
-test('dispatch handles help, pwd, cd, and exit without falling through to host shell', async () => {
+test('dispatch handles help, menu fallback, pwd, cd, and exit without falling through to host shell', async () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-'));
   const child = path.join(root, 'child folder');
   fs.mkdirSync(child);
   let output = '';
-  const state = { cwd: root, write: (text) => { output += text; } };
-
+  const state = { cwd: root, write: (text) => { output += text; }, interactive: false };
   let result = await dispatchShellLine('/help', state);
   assert.equal(result.handled, true);
-  assert.equal(result.exit, false);
-  assert.match(output, /Slash commands/);
-
+  assert.match(output, /Type normally to work with Agent Sam/);
+  assert.match(output, /agentsam help <topic>/);
   output = '';
-  result = await dispatchShellLine('/pwd', state);
-  assert.equal(result.handled, true);
+  await dispatchShellLine('/', state);
+  assert.match(output, /command picker/);
+  output = '';
+  await dispatchShellLine('/pwd', state);
   assert.equal(output.trim(), root);
-
   output = '';
-  result = await dispatchShellLine('/cd "child folder"', state);
-  assert.equal(result.handled, true);
+  await dispatchShellLine('/cd "child folder"', state);
   assert.equal(state.cwd, child);
   assert.equal(output.trim(), child);
-
   result = await dispatchShellLine('/exit', state);
   assert.equal(result.exit, true);
 });
 
+test('/usage renders the current session receipt without ending the session', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-usage-'));
+  let output = '';
+  const state = {
+    cwd: root, interactive: false, write: (text) => { output += text; },
+    session: {
+      id: 'asess_00000000-0000-4000-8000-000000000001', title: 'Usage test', model_key: 'openai:gpt-6-astra',
+      cumulative_usage: { input_tokens: 21_244, cached_input_tokens: 60_544, output_tokens: 219 },
+      total_cost_usd: 0.42, cost_breakdown_usd: { input: 0.2, cached_input: 0.02, output: 0.2 },
+    },
+  };
+  const result = await dispatchShellLine('/usage', state);
+  assert.equal(result.exit, false);
+  assert.match(output, /Token usage: total=21,463 input=21,244 \(\+ 60,544 cached\) output=219/);
+  assert.match(output, /Spent: \$0\.4200/);
+  assert.match(output, /agentsam resume asess_00000000-0000-4000-8000-000000000001/);
+});
+
+test('/logout signs out locally and emits the same resumable usage receipt', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-logout-'));
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-home-'));
+  let output = '';
+  const state = {
+    cwd: root, home, interactive: false, write: (text) => { output += text; },
+    session: {
+      id: 'asess_00000000-0000-4000-8000-000000000002', title: 'Logout test', model_key: 'openai:gpt-6-astra',
+      cumulative_usage: { input_tokens: 100, cached_input_tokens: 50, output_tokens: 25 },
+      total_cost_usd: 0.0125, cost_breakdown_usd: { input: 0.005, cached_input: 0.0025, output: 0.005 },
+    },
+  };
+  const result = await dispatchShellLine('/logout', state);
+  assert.equal(result.exit, false);
+  assert.match(output, /No local Agent Sam IAM session was stored/);
+  assert.match(output, /Token usage: total=125 input=100 \(\+ 50 cached\) output=25/);
+  assert.match(output, /Spent: \$0\.0125/);
+  assert.match(output, /agentsam resume asess_00000000-0000-4000-8000-000000000002/);
+});
+
+test('reasoning and service-tier commands persist only supported controls for an exact model', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-model-'));
+  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'model-demo' }));
+  writeCliPreferences(root, { trustedDirectory: true, modelPreference: 'openai:gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default' });
+  let output = '';
+  const state = { cwd: root, write: (text) => { output += text; }, interactive: false };
+  await dispatchShellLine('/reasoning high', state);
+  assert.equal(readCliPreferences(root).reasoningEffort, 'high');
+  await dispatchShellLine('/fast', state);
+  assert.equal(readCliPreferences(root).serviceTier, 'fast');
+  await dispatchShellLine('/flex', state);
+  assert.equal(readCliPreferences(root).serviceTier, 'flex');
+  await dispatchShellLine('/standard', state);
+  assert.equal(readCliPreferences(root).serviceTier, 'default');
+  assert.match(output, /reasoning → high/);
+  assert.match(output, /Fast is a paid latency choice/);
+  assert.match(output, /Flex trades latency/);
+});
+
+test('bare /context shows truthful economics without inventing active token usage', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-context-'));
+  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'context-demo' }));
+  writeCliPreferences(root, { trustedDirectory: true, modelPreference: 'openai:gpt-6-astra', reasoningEffort: 'medium', serviceTier: 'default' });
+  let output = '';
+  await dispatchShellLine('/context', { cwd: root, write: (text) => { output += text; }, interactive: false });
+  assert.match(output, /1,050,000/);
+  assert.match(output, /272,000/);
+  assert.match(output, /180,000/);
+  assert.match(output, /unavailable · no provider\/local usage snapshot yet/);
+  assert.match(output, /Batch is a separate asynchronous execution lane/);
+});
+
 test('CLI supports a deterministic one-shot slash command for regression tests', () => {
-  const result = spawnSync(process.execPath, ['src/cli.js', 'shell', '--command', '/help'], {
-    cwd: repoRoot,
-    encoding: 'utf8',
-  });
+  const result = spawnSync(process.execPath, ['src/cli.js', 'shell', '--command', '/help'], { cwd: repoRoot, encoding: 'utf8' });
   assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, /Agent Sam Terminal/);
-  assert.match(result.stdout, /\/help/);
-  assert.match(result.stdout, /\/exit/);
+  assert.match(result.stdout, /Type normally to work with Agent Sam/);
+  assert.match(result.stdout, /agentsam help <topic>/);
+  assert.match(result.stdout, /command picker/);
 });

package/test/smoke.mjs

@@ -55,9 +55,12 @@ await assert.rejects(() => finalizeInboundOAuth({}, new Request('https://x'), {}
 assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/deploy'));
 assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/db'));
 assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/agent'));
+assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/model'));
+assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/reasoning'));
+assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/fast'));
 assert.deepEqual(
   listSlashCommands({ lane: 'deploy' }).map(({ cmd }) => cmd),
-  ['/help', '/models', '/settings', '/deploy', '/exit'],
+  ['/settings', '/deploy', '/help', '/exit'],
   'deploy lane keeps global shell controls and excludes commands from other lanes',
 );
 

package/test/telemetry.test.mjs

@@ -0,0 +1,79 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentEvent, createUsageSnapshot } from '../src/telemetry/index.js';
+
+test('AgentEvent is compact serializable provider-neutral telemetry', () => {
+  const event = createAgentEvent('context.compaction.completed', { before: 181_000, after: 72_000 }, {
+    runId: 'run_test', sequence: 4, timestamp: '2026-09-12T00:00:00.000Z',
+  });
+  assert.equal(event.type, 'context.compaction.completed');
+  assert.equal(event.run_id, 'run_test');
+  assert.doesNotThrow(() => JSON.stringify(event));
+});
+
+test('current active context and cumulative run usage are different metrics', () => {
+  const usage = createUsageSnapshot({
+    current_context: { input_tokens: 48_000, window_tokens: 1_050_000 },
+    cumulative: { input_tokens: 310_000, output_tokens: 22_000, cached_input_tokens: 120_000, cache_write_tokens: 12_000, reasoning_tokens: 8_000 },
+    estimate_kind: 'provider',
+  });
+  assert.equal(usage.current_context.input_tokens, 48_000);
+  assert.equal(usage.cumulative.input_tokens, 310_000);
+  assert.equal(usage.provider_authoritative, true);
+});
+
+import {
+  createRunReceipt,
+  createUsageReceipt,
+  createApprovalReceipt,
+  createTerminalJobReceipt,
+} from '../src/telemetry/index.js';
+
+test('runtime receipts are account-owned and emit no tenant/workspace/user ownership aliases', () => {
+  const run = createRunReceipt({
+    id: 'arun_1', account_id: 'au_1', mode: 'agent', status: 'running',
+    source_client: 'cli', surface: 'cli', reasoning_effort: 'high', requested_service_tier: 'fast',
+  });
+  assert.equal(run.account_id, 'au_1');
+  assert.equal(run.source_client, 'cli');
+  assert.equal(run.requested_service_tier, 'fast');
+  assert.equal('user_id' in run, false);
+  assert.equal('tenant_id' in run, false);
+  assert.equal('workspace_id' in run, false);
+});
+
+test('usage receipt models exactly one provider call and keeps cache/reasoning economics', () => {
+  const usage = createUsageReceipt({
+    id: 'ue_1', account_id: 'au_1', agent_run_id: 'arun_1', provider: 'openai', model_key: 'gpt-6-astra',
+    model_call_index: 2, provider_request_id: 'resp_1', input_tokens: 1000, cached_input_tokens: 600,
+    cache_write_tokens: 20, output_tokens: 100, reasoning_tokens: 40, cost_usd: 0.12, cost_basis: 'provider',
+  });
+  assert.equal(usage.total_tokens, 1100);
+  assert.equal(usage.cached_input_tokens, 600);
+  assert.equal(usage.reasoning_tokens, 40);
+  assert.equal(usage.model_call_index, 2);
+});
+
+test('approval and terminal receipts preserve lineage without turning D1 into transcript storage', () => {
+  const approval = createApprovalReceipt({
+    id: 'appr_1', account_id: 'au_1', agent_run_id: 'arun_1', tool_call_id: 'call_1', terminal_job_id: 'tjob_1',
+    action_summary: 'Deploy worker', sanitizedInput: { worker: 'api' }, risk_level: 'high',
+  });
+  assert.equal(approval.terminal_job_id, 'tjob_1');
+  assert.match(approval.sanitized_input_json, /worker/);
+
+  const job = createTerminalJobReceipt({
+    id: 'tjob_1', account_id: 'au_1', instance_id: 'tinst_1', connection_id: 'conn_1',
+    execos_run_id: 'xrun_1', status: 'running', idempotency_key: 'idem_1', max_attempts: 1,
+  });
+  assert.equal(job.execos_run_id, 'xrun_1');
+  assert.equal(job.max_attempts, 1);
+  assert.equal('stdout' in job, false);
+  assert.equal('stderr' in job, false);
+  assert.equal('command' in job, false);
+});
+
+test('runtime receipts refuse model-invented account identity', () => {
+  assert.throws(() => createRunReceipt({ id: 'arun_1' }), /account_id is required/);
+  assert.throws(() => createUsageReceipt({ id: 'ue_1', provider: 'openai', model_key: 'gpt-6-astra' }), /account_id is required/);
+});

package/test/terminal/local-pty.mock.test.mjs

@@ -0,0 +1,151 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import { pathToFileURL } from 'node:url';
+import {
+  attachLocalPtySession,
+  ensureNodePtySpawnHelperExecutable,
+  startLocalPtyServer,
+} from '../../src/local-pty/server.js';
+
+function fakeTransports() {
+  const writes = [];
+  const resizes = [];
+  let killed = 0;
+  let dataHandler = null;
+  let exitHandler = null;
+
+  const pty = {
+    spawn(shell, args, options) {
+      assert.equal(Array.isArray(args), true);
+      assert.equal(options.env.AGENTSAM_LOCAL_PTY, '1');
+      return {
+        write(value) { writes.push(value); },
+        resize(cols, rows) { resizes.push([cols, rows]); },
+        kill() { killed += 1; },
+        onData(fn) { dataHandler = fn; },
+        onExit(fn) { exitHandler = fn; },
+      };
+    },
+  };
+
+  class FakeWs extends EventEmitter {
+    OPEN = 1;
+    readyState = 1;
+    sent = [];
+    send(value) { this.sent.push(String(value)); }
+    close() {
+      if (this.readyState !== this.OPEN) return;
+      this.readyState = 3;
+      this.emit('close');
+    }
+  }
+
+  const ws = new FakeWs();
+  return {
+    pty,
+    ws,
+    writes,
+    resizes,
+    killed: () => killed,
+    emitData(value) { dataHandler?.(value); },
+    emitExit() { exitHandler?.(); },
+  };
+}
+
+test('macOS node-pty helper is made executable before runtime import', (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-node-pty-helper-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const libDir = path.join(root, 'lib');
+  const helperDir = path.join(root, 'prebuilds', 'darwin-arm64');
+  fs.mkdirSync(libDir, { recursive: true });
+  fs.mkdirSync(helperDir, { recursive: true });
+  fs.writeFileSync(path.join(libDir, 'index.js'), '');
+  const helper = path.join(helperDir, 'spawn-helper');
+  fs.writeFileSync(helper, 'fake');
+  fs.chmodSync(helper, 0o644);
+
+  const result = ensureNodePtySpawnHelperExecutable({
+    platform: 'darwin',
+    arch: 'arm64',
+    resolveModule: () => pathToFileURL(path.join(libDir, 'index.js')).href,
+  });
+
+  assert.equal(result.checked, true);
+  assert.equal(result.changed, true);
+  assert.equal(result.path, helper);
+  assert.notEqual(fs.statSync(helper).mode & 0o111, 0);
+
+  const second = ensureNodePtySpawnHelperExecutable({
+    platform: 'darwin',
+    arch: 'arm64',
+    resolveModule: () => pathToFileURL(path.join(libDir, 'index.js')).href,
+  });
+  assert.equal(second.changed, false);
+});
+
+test('local PTY wire protocol is release-testable entirely in memory', () => {
+  const transport = fakeTransports();
+  const session = attachLocalPtySession({
+    ws: transport.ws,
+    pty: transport.pty,
+    shell: '/bin/test-shell',
+    cwd: '/tmp/test-project',
+    cols: 80,
+    rows: 24,
+    env: {},
+    sessionId: 'local_test',
+  });
+
+  assert.equal(session.session_id, 'local_test');
+  assert.deepEqual(JSON.parse(transport.ws.sent[0]), {
+    type: 'session_id',
+    session_id: 'local_test',
+  });
+
+  transport.ws.emit('message', Buffer.from(JSON.stringify({ type: 'resize', cols: 120, rows: 40 })));
+  transport.ws.emit('message', Buffer.from(JSON.stringify({ type: 'slash', line: '/pwd' })));
+  transport.ws.emit('message', Buffer.from('raw input'));
+
+  assert.deepEqual(transport.resizes, [[120, 40]]);
+  assert.deepEqual(transport.writes, ['/pwd\r', 'raw input']);
+
+  transport.emitData('terminal output');
+  assert.equal(transport.ws.sent.at(-1), 'terminal output');
+
+  transport.ws.close();
+  assert.equal(transport.killed(), 1);
+
+  // Cleanup is idempotent even when transport error/close paths race.
+  transport.ws.emit('error', new Error('synthetic transport close'));
+  session.cleanup();
+  assert.equal(transport.killed(), 1);
+});
+
+test('local PTY server health check uses an ephemeral local port and no ExecOS tunnel', async () => {
+  const transport = fakeTransports();
+  const server = await startLocalPtyServer({
+    cwd: process.cwd(),
+    host: '127.0.0.1',
+    port: 0,
+    pty: transport.pty,
+  });
+
+  try {
+    const health = await fetch(server.healthUrl);
+    assert.equal(health.status, 200);
+    const body = await health.json();
+    assert.equal(body.ok, true);
+    assert.equal(body.service, 'agentsam-local-pty');
+    assert.equal(body.port, server.port);
+    assert.equal(server.port > 0, true);
+  } finally {
+    await server.close();
+  }
+
+  // No WebSocket session was opened, so the PTY process was never spawned.
+  assert.equal(transport.killed(), 0);
+});

package/test/tools-search.test.mjs

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { getToolCatalog } from '../src/lib/tools.js';
-import { searchToolCards } from '../src/tools/index.js';
+import { hydrateToolSchemas, searchToolCards } from '../src/tools/index.js';
 import { DEFAULT_RESULT_POLICY } from '../src/context/index.js';
 
 test('every built-in SDK tool inherits a bounded result policy', () => {
@@ -25,3 +25,16 @@ test('tools.search returns compact cards rather than full schemas', () => {
   assert.equal('input_schema' in result.cards[0], false);
   assert.ok(result.receipt.chars < 24_000);
 });
+
+test('selected schemas hydrate without loading the full tool catalog', () => {
+  const catalog = Array.from({ length: 50 }, (_, index) => ({
+    name: `tool.${index}`,
+    description: `Capability ${index}`,
+    input_schema: { type: 'object', properties: { value: { type: 'string' }, padding: { description: 'x'.repeat(300) } } },
+  }));
+  const result = hydrateToolSchemas(catalog, ['tool.4', 'tool.22'], { maxTools: 4, maxChars: 5_000 });
+  assert.deepEqual(result.tools.map((tool) => tool.name), ['tool.4', 'tool.22']);
+  assert.equal(result.receipt.catalog_items, 50);
+  assert.equal(result.receipt.hydrated_tools, 2);
+  assert.ok(result.receipt.schema_chars < 5_000);
+});

package/test/whoami-resume.test.mjs

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import { saveAccountSession } from '../src/lib/account-session.js';
+import { createLocalSession } from '../src/lib/local-sessions.js';
+import { collectWhoami } from '../src/commands/whoami.js';
+import { runResume } from '../src/commands/resume.js';
+
+function tempHome(t) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-ux-home-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  return home;
+}
+
+test('whoami validates persisted IAM identity while never returning the SDK or provider secret', async t => {
+  const home = tempHome(t);
+  saveAccountSession({ access_token: 'sdk_do_not_print', user_id: 'au_local' }, { home });
+  const envDir = path.join(home, '.agentsam', 'env.d');
+  fs.mkdirSync(envDir, { recursive: true });
+  const openaiFile = path.join(envDir, 'openai.env');
+  fs.writeFileSync(openaiFile, 'OPENAI_API_KEY=sk-never-print-this\n', { mode: 0o600 });
+  if (process.platform !== 'win32') fs.chmodSync(openaiFile, 0o600);
+
+  const status = await collectWhoami({
+    env: {}, home,
+    contextLoader: async token => {
+      assert.equal(token, 'sdk_do_not_print');
+      return { user_id: 'au_server', account_id: 'acct_server', email: 'dev@example.test', cloudflare: { ok: true }, byok: { openai: { configured: true, masked: 'secret' } } };
+    },
+  });
+  assert.equal(status.authenticated, true);
+  assert.equal(status.identity.account_id, 'acct_server');
+  assert.equal(status.sdk_credential.source, 'agentsam_account_session');
+  assert.equal(status.provider_credentials.find(row => row.provider === 'openai').configured, true);
+  const serialized = JSON.stringify(status);
+  assert.doesNotMatch(serialized, /sdk_do_not_print|sk-never-print-this|masked/);
+});
+
+test('resume restores saved cwd and session through the canonical shell runtime', async t => {
+  const home = tempHome(t);
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-resume-project-'));
+  t.after(() => fs.rmSync(cwd, { recursive: true, force: true }));
+  const session = createLocalSession({ cwd, title: 'Run wrangler whoami', model_key: 'openai:gpt-6-astra' }, { home });
+  let called = null;
+  const restored = await runResume([session.id], {
+    home,
+    write() {},
+    runShellImpl: async (argv, options) => { called = { argv, options }; },
+  });
+  assert.equal(restored.id, session.id);
+  assert.deepEqual(called.argv, []);
+  assert.equal(called.options.cwd, cwd);
+  assert.equal(called.options.session.id, session.id);
+});