@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.3

package/test/responses-runner.test.mjs

@@ -4,7 +4,9 @@ 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';
+import { buildAgentToolSurface, capabilityFunctionName, resolveCapabilityFallback, runResponsesAgent } from '../src/agent/responses-runner.js';
+import { getModelRecord } from '../src/models/index.js';
+import { CAD_PROJECT_TOOLS } from '../src/lib/cad/project-runtime.js';
 
 function usage(input = 10_000, cumulative = input) {
   return {
@@ -15,18 +17,89 @@ function usage(input = 10_000, cumulative = input) {
 }
 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('runner accepts provider-verified models whose context window is unknown', async t => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-unknown-window-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  fs.mkdirSync(path.join(root, '.git'));
+  fs.writeFileSync(path.join(root, 'package.json'), '{"name":"unknown-window-demo"}');
+
+  const modelRecord = Object.freeze({
+    model_key: 'openai:gpt-5.6-luna',
+    provider: 'openai',
+    provider_model_id: 'gpt-5.6-luna',
+    label: 'gpt-5.6-luna',
+    availability: 'available',
+    availability_source: 'provider_api',
+    context_window: null,
+    context_window_source: 'unknown',
+    max_output_tokens: null,
+    reasoning_efforts: Object.freeze(['auto']),
+    service_tiers: Object.freeze(['default']),
+    capabilities: Object.freeze({ responses: true }),
+    pricing: null,
+    context_policy: null,
+  });
+  const events = [];
+  let instructions = '';
+  const provider = {
+    async create(params) {
+      instructions = params.instructions || '';
+      return {
+        response_id: 'resp_unknown_window',
+        output_text: 'working',
+        actual_service_tier: 'default',
+        tool_calls: [],
+        usage_snapshot: {
+          current_context: { input_tokens: 1200, window_tokens: 0 },
+          cumulative: { input_tokens: 1200, output_tokens: 10, cached_input_tokens: 0, cache_write_tokens: 0, reasoning_tokens: 0 },
+          estimate_kind: 'provider',
+          provider_authoritative: true,
+        },
+        cost: null,
+      };
+    },
+    async continueWithToolOutputs() { throw new Error('unused'); },
+  };
+
+  const result = await runResponsesAgent({
+    provider,
+    capabilityAdapter: createCapabilityAdapter(),
+    cwd: root,
+    prompt: 'inspect this repository',
+    model: modelRecord.model_key,
+    modelRecord,
+    emit: event => events.push(event),
+  });
+
+  assert.equal(result.output_text, 'working');
+  assert.match(instructions, /Project Card: unknown-window-demo/);
+  const localSnapshot = events.find(event => event.type === 'context.snapshot' && event.payload?.estimate_kind === 'local');
+  assert.ok(localSnapshot);
+  assert.equal(localSnapshot.payload.window_tokens, null);
+  assert.equal(localSnapshot.payload.pressure, 'unknown');
+  assert.equal(localSnapshot.payload.resolver_receipt?.fallback_policy, 'bounded_unknown_model_window');
+});
+
 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 expectedNames = [
+    'cloudflare.cpu.profile',
+    'cloudflare.wrangler.native',
+    'knowledge.search',
+    'repository.snapshot',
+    'terminal.exec',
+    ...CAD_PROJECT_TOOLS.map((tool) => tool.name),
+  ].sort();
+  assert.deepEqual(descriptors.map((row) => row.name).sort(), expectedNames);
   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.ok(surface.tools.some((t) => t.name === capabilityFunctionName('repository.snapshot')));
   assert.equal(surface.tools[0].parameters.type, 'object');
-  assert.equal(surface.receipt.catalog_tools, 3);
+  assert.equal(surface.receipt.catalog_tools, descriptors.length);
 });
 
 test('runner owns cwd, executes selected tool, preserves call_id and returns provider-authoritative continuation', async t => {
@@ -48,7 +121,7 @@ test('runner owns cwd, executes selected tool, preserves call_id and returns pro
       assert.equal(params.model, 'gpt-6-astra');
       assert.equal(params.reasoningEffort, 'high');
       assert.equal(params.serviceTier, 'fast');
-      assert.equal(params.tools.length, 1);
+      assert.ok(params.tools.some((t) => t.name === capabilityFunctionName('repository.snapshot')));
       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}' }],
@@ -138,6 +211,38 @@ test('runner compacts before a projected high-context continuation rather than c
   assert.equal(result.compacted_before_turn, true);
 });
 
+test('runner applies a cumulative input guardrail inside tool-heavy turns', async () => {
+  let compactCalls = 0;
+  let resumedInput = null;
+  const capabilityAdapter = createCapabilityAdapter({
+    handlers: { 'repository.snapshot': async () => ({ ok: true, evidence: 'bounded' }) },
+  });
+  const baseModel = getModelRecord('gpt-6-astra');
+  const modelRecord = {
+    ...baseModel,
+    context_policy: {
+      ...baseModel.context_policy,
+      max_cumulative_input_tokens: 30_000,
+    },
+  };
+  const provider = {
+    async create(params) {
+      if (params.input?.[0]?.type === 'compaction') {
+        resumedInput = params.input;
+        return { response_id: 'resp_after_compaction', output_text: 'done', tool_calls: [], usage_snapshot: usage(18_000, 49_000), cost: cost(0.1) };
+      }
+      return { response_id: 'resp_initial', output_text: '', tool_calls: [{ call_id: 'call_1', name: capabilityFunctionName('repository.snapshot'), arguments: '{}' }], usage_snapshot: usage(18_000, 40_000), cost: cost(0.1) };
+    },
+    async continueWithToolOutputs() { throw new Error('must compact before continuation'); },
+    async compact() { compactCalls += 1; return { compaction_id: 'cmp_mid_turn', output: [{ type: 'compaction', encrypted_content: 'opaque' }], usage_delta: { input_tokens: 1_000, output_tokens: 100, cached_input_tokens: 0, cache_write_tokens: 0, reasoning_tokens: 0 }, cost: cost(0.01) }; },
+  };
+  const guarded = await runResponsesAgent({ provider, capabilityAdapter, cwd: process.cwd(), prompt: 'snapshot repository', model: 'gpt-6-astra', modelRecord });
+  assert.equal(guarded.output_text, 'done');
+  assert.equal(compactCalls, 1);
+  assert.ok(resumedInput.some((row) => row.type === 'function_call_output'));
+  assert.equal(guarded.continuation_compactions[0].compaction_id, 'cmp_mid_turn');
+});
+
 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() {} };
@@ -148,3 +253,213 @@ test('runner refuses an oversized initial context and supports an explicit proje
     provider, capabilityAdapter, cwd: process.cwd(), prompt: 'small task', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'fast', maxCallCostUsd: 0.01,
   }), /projected_call_cost_exceeds_budget/);
 });
+
+test('invalid selected tool surface is rejected before paid compaction or inference', async () => {
+  let calls = 0;
+  await assert.rejects(runResponsesAgent({
+    model: 'gpt-6-astra', prompt: 'broken', instructions: '',
+    previousProviderState: { previous_response_id: 'resp_prior' },
+    previousUsageSnapshot: { current_context: { input_tokens: 190000 } },
+    capabilityAdapter: { toolDescriptors: () => [{ name: 'broken', description: 'broken', input_schema: { type: 'object', properties: { value: { $ref: 'https://unknown' } } } }] },
+    provider: { compact: async () => { calls++; }, create: async () => { calls++; }, continueWithToolOutputs: async () => {} },
+  }), /tool_schema_invalid/);
+  assert.equal(calls, 0);
+});
+
+
+// --- run-budget: named modes replace the unexplained literal 8 ---
+
+function multiRoundProvider({ rounds, toolCallName, toolArgs }) {
+  let createCalls = 0;
+  let continueCalls = 0;
+  const argsFor = (n) => toolArgs !== undefined ? toolArgs : JSON.stringify({ step: n });
+  return {
+    async create() {
+      createCalls += 1;
+      const remaining = rounds - continueCalls;
+      if (remaining <= 0) {
+        return { response_id: `resp_${createCalls}`, output_text: 'done', actual_service_tier: 'default', tool_calls: [], usage_snapshot: usage(10_000), cost: cost(0.01) };
+      }
+      return {
+        response_id: 'resp_create',
+        output_text: '', actual_service_tier: 'default',
+        tool_calls: [{ call_id: `call_${continueCalls}`, name: toolCallName, arguments: argsFor(continueCalls) }],
+        usage_snapshot: usage(10_000), cost: cost(0.01),
+      };
+    },
+    async continueWithToolOutputs() {
+      continueCalls += 1;
+      const remaining = rounds - continueCalls;
+      if (remaining <= 0) {
+        return { response_id: `resp_final_${continueCalls}`, output_text: 'done', actual_service_tier: 'default', tool_calls: [], usage_snapshot: usage(10_000), cost: cost(0.01) };
+      }
+      return {
+        response_id: `resp_${continueCalls}`,
+        output_text: '', actual_service_tier: 'default',
+        tool_calls: [{ call_id: `call_${continueCalls}`, name: toolCallName, arguments: argsFor(continueCalls) }],
+        usage_snapshot: usage(10_000), cost: cost(0.01),
+      };
+    },
+    async compact() { throw new Error('should_not_compact'); },
+  };
+}
+
+test('default (quick) run mode preserves the exact previous behavior: stops at round 8', async () => {
+  const capabilityAdapter = createCapabilityAdapter({ handlers: { 'repository.snapshot': async () => ({ ok: true }) } });
+  const provider = multiRoundProvider({ rounds: 50, toolCallName: capabilityFunctionName('repository.snapshot') });
+  await assert.rejects(() => runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'snapshot repository', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+  }), /tool_round_limit_exceeded:8/);
+});
+
+test('an explicit maxToolRounds still overrides any run mode', async () => {
+  const capabilityAdapter = createCapabilityAdapter({ handlers: { 'repository.snapshot': async () => ({ ok: true }) } });
+  const provider = multiRoundProvider({ rounds: 50, toolCallName: capabilityFunctionName('repository.snapshot') });
+  await assert.rejects(() => runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'snapshot repository', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+    runMode: 'agent', maxToolRounds: 3,
+  }), /tool_round_limit_exceeded:3/);
+});
+
+test('agent run mode survives well past the old 8-round ceiling and reports the run-budget receipt', async () => {
+  const capabilityAdapter = createCapabilityAdapter({ handlers: { 'repository.snapshot': async () => ({ ok: true, at: Date.now() }) } });
+  // 15 real tool rounds: strictly more than the old hard-coded 8, proving the
+  // ceiling is gone under agent mode without needing a literal 128-round run.
+  const provider = multiRoundProvider({ rounds: 15, toolCallName: capabilityFunctionName('repository.snapshot') });
+  const result = await runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'snapshot repository', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+    runMode: 'agent',
+  });
+  assert.equal(result.output_text, 'done');
+  assert.equal(result.run_budget.run_mode, 'agent');
+  assert.equal(result.run_budget.max_tool_rounds, 128);
+  assert.equal(result.run_budget.tool_rounds, 15);
+  assert.equal(result.run_budget.tool_calls, 15);
+  assert.ok(Number.isInteger(result.run_budget.elapsed_ms));
+  assert.ok(result.run_budget.elapsed_ms >= 0);
+});
+
+test('multiple tool calls in one provider response count as one round but multiple calls', async () => {
+  const capabilityAdapter = createCapabilityAdapter({ handlers: { 'repository.snapshot': async () => ({ ok: true }) } });
+  const alias = capabilityFunctionName('repository.snapshot');
+  let step = 0;
+  const provider = {
+    async create() {
+      step = 1;
+      return {
+        response_id: 'resp_1', output_text: '', actual_service_tier: 'default',
+        tool_calls: [
+          { call_id: 'a', name: alias, arguments: '{"churnDays":1}' },
+          { call_id: 'b', name: alias, arguments: '{"churnDays":2}' },
+          { call_id: 'c', name: alias, arguments: '{"churnDays":3}' },
+        ],
+        usage_snapshot: usage(10_000), cost: cost(0.01),
+      };
+    },
+    async continueWithToolOutputs() {
+      step = 2;
+      return { response_id: 'resp_2', output_text: 'done', actual_service_tier: 'default', tool_calls: [], usage_snapshot: usage(10_000), cost: cost(0.01) };
+    },
+    async compact() { throw new Error('should_not_compact'); },
+  };
+  const result = await runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'snapshot repository', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+  });
+  assert.equal(step, 2);
+  assert.equal(result.run_budget.tool_rounds, 1);
+  assert.equal(result.run_budget.tool_calls, 3);
+});
+
+test('denial still terminates correctly under any run mode (budget change does not weaken approval gating)', async () => {
+  const capabilityAdapter = createCapabilityAdapter({ handlers: { 'repository.snapshot': async () => { throw new Error('must_not_invoke'); } } });
+  const provider = multiRoundProvider({ rounds: 50, toolCallName: capabilityFunctionName('repository.snapshot') });
+  await assert.rejects(() => runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'snapshot repository', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+    runMode: 'agent',
+    beforeTool: async () => false,
+  }), /tool_execution_not_approved:repository\.snapshot/);
+});
+
+test('repeated identical tool calls trigger no-progress protection independently of the round budget', async () => {
+  const capabilityAdapter = createCapabilityAdapter({ handlers: { 'repository.snapshot': async () => ({ ok: true }) } });
+  // Same capability, same arguments, every single round -- a stuck loop.
+  // Even under the largest budget (long: 512), this must fail fast on
+  // repetition rather than grinding to round 512.
+  const provider = multiRoundProvider({ rounds: 500, toolCallName: capabilityFunctionName('repository.snapshot'), toolArgs: '{"churnDays":7}' });
+  await assert.rejects(() => runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'snapshot repository', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+    runMode: 'long',
+  }), /no_progress_detected:\d+/);
+});
+
+test('varying tool-call arguments across rounds does not trip the no-progress guard', async () => {
+  const capabilityAdapter = createCapabilityAdapter({ handlers: { 'repository.snapshot': async () => ({ ok: true }) } });
+  const alias = capabilityFunctionName('repository.snapshot');
+  let n = 0;
+  const provider = {
+    async create() {
+      n += 1;
+      return { response_id: `r${n}`, output_text: '', actual_service_tier: 'default', tool_calls: [{ call_id: `c${n}`, name: alias, arguments: JSON.stringify({ churnDays: n }) }], usage_snapshot: usage(10_000), cost: cost(0.01) };
+    },
+    async continueWithToolOutputs() {
+      n += 1;
+      if (n > 12) return { response_id: `r${n}`, output_text: 'done', actual_service_tier: 'default', tool_calls: [], usage_snapshot: usage(10_000), cost: cost(0.01) };
+      return { response_id: `r${n}`, output_text: '', actual_service_tier: 'default', tool_calls: [{ call_id: `c${n}`, name: alias, arguments: JSON.stringify({ churnDays: n }) }], usage_snapshot: usage(10_000), cost: cost(0.01) };
+    },
+    async compact() { throw new Error('should_not_compact'); },
+  };
+  const result = await runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'snapshot repository', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+    runMode: 'agent',
+  });
+  assert.equal(result.output_text, 'done');
+  assert.ok(result.run_budget.tool_rounds >= 12);
+});
+
+// --- alias-drift fallback: a real capability not hydrated this round still dispatches ---
+
+test('resolveCapabilityFallback recovers a real, currently-executable capability whose alias was not hydrated this round', () => {
+  const capabilityAdapter = createCapabilityAdapter({ handlers: { 'terminal.exec': async () => ({ ok: true }) } });
+  const alias = capabilityFunctionName('terminal.exec');
+  const resolved = resolveCapabilityFallback(capabilityAdapter, alias);
+  assert.ok(resolved);
+  assert.equal(resolved.capabilityId, 'terminal.exec');
+  assert.equal(resolved.descriptor.name, 'terminal.exec');
+});
+
+test('resolveCapabilityFallback returns null for a genuinely unknown / hallucinated alias', () => {
+  const capabilityAdapter = createCapabilityAdapter();
+  const resolved = resolveCapabilityFallback(capabilityAdapter, 'as_totally_made_up_capability');
+  assert.equal(resolved, null);
+});
+
+test('runner dispatches a tool call whose alias is absent from this turn\'s hydrated tool surface, via fallback resolution', async () => {
+  let invoked = null;
+  const capabilityAdapter = createCapabilityAdapter({
+    handlers: { 'terminal.exec': async (input) => { invoked = input; return { ok: true, ...input }; } },
+  });
+  const alias = capabilityFunctionName('terminal.exec');
+  const provider = {
+    async create() {
+      // Simulate provider-side conversation memory carrying a tool name the
+      // *current* turn's toolSurface didn't offer (see buildAgentToolSurface's
+      // relevance-scored, maxTools-capped selection) -- the exact shape of the
+      // production unrecognized_tool_call:as_terminal_exec failure.
+      return {
+        response_id: 'resp_1', output_text: '', actual_service_tier: 'default',
+        tool_calls: [{ call_id: 'call_1', name: alias, arguments: '{"command":"git","args":["status"]}' }],
+        usage_snapshot: usage(10_000), cost: cost(0.01),
+      };
+    },
+    async continueWithToolOutputs(params) {
+      assert.equal(params.toolOutputs[0].call_id, 'call_1');
+      return { response_id: 'resp_2', output_text: 'done', actual_service_tier: 'default', tool_calls: [], usage_snapshot: usage(10_000), cost: cost(0.01) };
+    },
+    async compact() { throw new Error('should_not_compact'); },
+  };
+  const result = await runResponsesAgent({
+    provider, capabilityAdapter, cwd: process.cwd(), prompt: 'snapshot inspect repository', model: 'gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default',
+  });
+  assert.equal(result.output_text, 'done');
+  assert.equal(invoked.command, 'git');
+});

package/test/shell.test.mjs

@@ -4,7 +4,7 @@ import os from 'node:os';
 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 { dispatchShellLine, installPasteCollapse, renderCollapsedPaste, renderShellCatalog, renderShellPrompt, shouldCollapsePaste, 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);
@@ -57,6 +57,8 @@ test('dispatch handles help, menu fallback, pwd, cd, and exit without falling th
   assert.equal(result.exit, true);
 });
 
+const stripAnsi = (text) => String(text || '').replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
+
 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 = '';
@@ -70,9 +72,13 @@ test('/usage renders the current session receipt without ending the session', as
   };
   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/);
+  const clean = stripAnsi(output);
+  assert.match(clean, /AgentSam · Usage/);
+  assert.match(clean, /input\s+21\.2k/);
+  assert.match(clean, /output\s+219/);
+  assert.match(clean, /cached\s+60\.5k/);
+  assert.match(clean, /cost\s+\$0\.420/);
+  assert.match(clean, /agentsam resume asess_00000000-0000-4000-8000-000000000001/);
 });
 
 test('/logout signs out locally and emits the same resumable usage receipt', async () => {
@@ -114,6 +120,47 @@ test('reasoning and service-tier commands persist only supported controls for an
   assert.match(output, /Flex trades latency/);
 });
 
+test('stale provider snapshots hydrate GPT-6 reasoning controls from the current catalog', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-stale-model-'));
+  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'stale-model-demo' }));
+  writeCliPreferences(root, {
+    trustedDirectory: true,
+    modelPreference: 'openai:gpt-6-luna',
+    reasoningEffort: 'auto',
+    serviceTier: 'default',
+    modelSnapshot: {
+      model_key: 'openai:gpt-6-luna',
+      provider: 'openai',
+      provider_model_id: 'gpt-6-luna',
+      label: 'gpt-6-luna',
+      availability: 'available',
+      availability_source: 'provider_api',
+      context_window: null,
+      context_window_source: 'unknown',
+      max_output_tokens: null,
+      max_output_tokens_source: 'unknown',
+      reasoning_efforts: ['auto'],
+      service_tiers: ['default'],
+      capabilities: { responses: true },
+    },
+  });
+
+  let output = '';
+  const state = { cwd: root, write: (text) => { output += text; }, interactive: false };
+  await dispatchShellLine('/reasoning', state);
+  assert.match(output, /auto \| none \| low \| medium \| high \| xhigh \| max/);
+  assert.match(output, /provider default: medium/);
+
+  output = '';
+  await dispatchShellLine('/reasoning high', state);
+  assert.equal(readCliPreferences(root).reasoningEffort, 'high');
+  assert.match(output, /reasoning → high/);
+
+  output = '';
+  await dispatchShellLine('/context', state);
+  assert.match(output, /1,050,000/);
+});
+
 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' }));
@@ -134,3 +181,101 @@ test('CLI supports a deterministic one-shot slash command for regression tests',
   assert.match(result.stdout, /agentsam help <topic>/);
   assert.match(result.stdout, /command picker/);
 });
+
+test('large pastes collapse into a single confirmation line', () => {
+  const pasted = ['one', 'two', 'three', 'four', 'five', 'six'].join('\n');
+  assert.equal(shouldCollapsePaste('short'), false);
+  assert.equal(shouldCollapsePaste(pasted), true);
+  assert.equal(shouldCollapsePaste('x'.repeat(301)), true);
+  assert.equal(renderCollapsedPaste(pasted), '[Pasted 6 lines — Enter to run, Backspace to clear]');
+
+  const writes = [];
+  const rl = {
+    terminal: true,
+    line: '',
+    cursor: 0,
+    _refreshLine() { writes.push(this.line); },
+    _ttyWrite(s) { this.line += s || ''; this.cursor = this.line.length; },
+  };
+  const restore = installPasteCollapse(rl);
+  rl._ttyWrite(pasted);
+  assert.equal(rl.line, '[Pasted 6 lines — Enter to run, Backspace to clear]');
+  rl._ttyWrite('', { name: 'backspace' });
+  assert.equal(rl.line, '');
+  restore();
+});
+
+test('dispatchShellLine accepts "agentsam <cmd>" and bare common verbs without slash prefix', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-verb-'));
+  let output = '';
+  const state = { cwd: root, write: (text) => { output += text; }, interactive: false };
+
+  const r1 = await dispatchShellLine('agentsam help', state);
+  assert.equal(r1.handled, true);
+  assert.match(output, /Type normally to work with Agent Sam/);
+
+  output = '';
+  const r2 = await dispatchShellLine('help', state);
+  assert.equal(r2.handled, true);
+  assert.match(output, /Type normally to work with Agent Sam/);
+
+  const r3 = await dispatchShellLine('exit', state);
+  assert.equal(r3.exit, true);
+});
+
+test('/compact is discoverable, invokes native compaction, persists exact continuation and usage across resume', async () => {
+  const { SLASH_COMMANDS } = await import('../src/lib/slash-commands.js');
+  const { createLocalSession, loadLocalSession, loadSessionContinuation } = await import('../src/lib/local-sessions.js');
+  const { runResponsesAgent } = await import('../src/agent/responses-runner.js');
+  const { createOpenAIResponsesAdapter } = await import('../src/providers/openai-responses.js');
+  assert.ok(SLASH_COMMANDS.some(row => row.cmd === '/compact'));
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-compact-'));
+  fs.writeFileSync(path.join(root, 'package.json'), '{"name":"compact-test"}');
+  writeCliPreferences(root, { modelPreference: 'openai:gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default' });
+  const session = createLocalSession({ cwd: root, project_root: root, model_key: 'openai:gpt-6-astra', reasoning_effort: 'low', requested_service_tier: 'default', provider_state: { provider: 'openai', previous_response_id: 'resp_prior' }, cumulative_usage: { input_tokens: 10 } });
+  const output = [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: 'Keep the selected architecture' }] }, { type: 'compaction', id: 'cmp_item', encrypted_content: 'opaque+/==exact' }];
+  const oldKey = process.env.OPENAI_API_KEY;
+  process.env.OPENAI_API_KEY = 'fixture-key';
+  let rendered = '', calls = 0;
+  const state = { cwd: root, projectRoot: root, interactive: false, session, write: text => { rendered += text; }, providerFetchImpl: async (url, init) => {
+    calls++;
+    assert.match(url, /responses\/compact$/);
+    assert.equal(JSON.parse(init.body).previous_response_id, 'resp_prior');
+    return { ok: true, status: 200, json: async () => ({ id: 'cmp_test', output, usage: { input_tokens: 1000, output_tokens: 100, input_tokens_details: { cached_tokens: 100 } } }) };
+  } };
+  try { await dispatchShellLine('/compact', state); }
+  finally { if (oldKey === undefined) delete process.env.OPENAI_API_KEY; else process.env.OPENAI_API_KEY = oldKey; }
+  assert.equal(calls, 1);
+  assert.match(rendered, /continuation saved/);
+  const resumed = loadLocalSession(session.id, { projectRoot: root });
+  assert.equal(resumed.cumulative_usage.input_tokens, 1010);
+  assert.equal(resumed.cumulative_usage.cached_input_tokens, 100);
+  assert.ok(resumed.total_cost_usd > 0);
+  assert.equal(resumed.latest_compaction.compaction_id, 'cmp_test');
+  const continuation = loadSessionContinuation(resumed);
+  assert.deepEqual(continuation.compacted_input, output);
+  assert.equal(resumed.provider_state.previous_response_id, undefined);
+  const adapter = createOpenAIResponsesAdapter({ apiKey: 'test', fetchImpl: async (_, init) => {
+    const body = JSON.parse(init.body);
+    assert.deepEqual(body.input.slice(0, output.length), output);
+    assert.equal(body.previous_response_id, undefined);
+    return { ok: true, status: 200, json: async () => ({ id: 'resp_next', output_text: 'done', output: [], usage: { input_tokens: 120, output_tokens: 10 } }) };
+  } });
+  await runResponsesAgent({ provider: adapter, capabilityAdapter: { toolDescriptors: () => [] }, model: 'gpt-6-astra', prompt: 'continue', cwd: root, instructions: '', previousProviderState: continuation, previousUsageSnapshot: resumed.usage_snapshot });
+  rendered = '';
+  await dispatchShellLine('/compact status', state);
+  assert.match(rendered, /180000/);
+  assert.match(rendered, /cmp_test/);
+  await dispatchShellLine('/session', state);
+  assert.match(rendered, /Latest compaction: cmp_test/);
+});
+
+test('/compact fails closed for unsupported provider without an HTTP request', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-compact-unsupported-'));
+  fs.writeFileSync(path.join(root, 'package.json'), '{"name":"unsupported"}');
+  writeCliPreferences(root, { modelPreference: 'gemini:test', modelSnapshot: { provider: 'gemini', model_key: 'gemini:test', provider_model_id: 'test', context_window: 128000, capabilities: {} } });
+  let rendered = '', calls = 0;
+  await dispatchShellLine('/compact', { cwd: root, interactive: false, write: text => { rendered += text; }, providerFetchImpl: async () => { calls++; } });
+  assert.equal(calls, 0);
+  assert.match(rendered, /native_compaction_unavailable:gemini/);
+});

package/test/smoke.mjs

@@ -115,8 +115,8 @@ d1Like.close();
 
 const tunnelPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'src', 'commands', 'tunnel.js');
 const tunnelSrc = fs.readFileSync(tunnelPath, 'utf8');
-assert.ok(tunnelSrc.includes('register-local'));
-assert.ok(tunnelSrc.includes('cloudflared'));
+assert.ok(tunnelSrc.includes('parseWranglerTunnelList'));
+assert.ok(tunnelSrc.includes('wrangler'));
 assert.ok(fs.existsSync(tunnelPath));
 
 console.log('SDK smoke tests passed');

package/test/tools-search.test.mjs

@@ -38,3 +38,36 @@ test('selected schemas hydrate without loading the full tool catalog', () => {
   assert.equal(result.receipt.hydrated_tools, 2);
   assert.ok(result.receipt.schema_chars < 5_000);
 });
+
+
+test('canonical AgentSam tool definitions participate in legacy discovery and hydration', () => {
+  const canonical = {
+    toolKey: 'completeful.order.create',
+    displayName: 'Create Completeful order',
+    description: 'Create a fulfillment order through Completeful.',
+    provider: 'completeful',
+    capabilityKey: 'completeful.order.create',
+    inputSchema: {
+      type: 'object',
+      required: ['shop_id', 'body'],
+      properties: {
+        shop_id: { type: 'string' },
+        body: { type: 'object' },
+      },
+    },
+    outputSchema: { type: 'object' },
+    riskLevel: 'high',
+    sideEffectLevel: 'billable_external_write',
+    idempotencyMode: 'required',
+  };
+
+  const searched = searchToolCards([canonical], 'completeful order');
+  assert.equal(searched.cards[0].tool, 'completeful.order.create');
+  assert.equal(searched.cards[0].category, 'completeful');
+  assert.equal(searched.cards[0].risk, 'high');
+  assert.deepEqual(searched.cards[0].required, ['shop_id', 'body']);
+
+  const hydrated = hydrateToolSchemas([canonical], ['completeful.order.create']);
+  assert.equal(hydrated.tools[0].toolKey, 'completeful.order.create');
+  assert.equal(hydrated.tools[0].inputSchema.type, 'object');
+});

package/test/unit/website-assets-bindings.test.mjs

@@ -0,0 +1,60 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  resolveWebsiteAssets,
+  resolveWorkerStaticAssets,
+  resolveDb,
+  resolveSiteCacheKv,
+  suggestWebsiteAssetsBindingScaffold,
+  websitePublicKey,
+  websitePartialKey,
+  WEBSITE_ASSETS_ROLE,
+} from '../../apps/local-studio/backend/worker/bindings.js';
+
+function r2Stub() {
+  return {
+    get: async () => null,
+    put: async () => {},
+    list: async () => ({ objects: [] }),
+    head: async () => null,
+    createMultipartUpload: async () => ({}),
+  };
+}
+
+function kvStub() {
+  return {
+    get: async () => null,
+    put: async () => {},
+    getWithMetadata: async () => ({ value: null, metadata: null }),
+  };
+}
+
+test('resolveWebsiteAssets prefers canonical name then aliases', () => {
+  const bucket = r2Stub();
+  const a = resolveWebsiteAssets({ SITE_ASSETS: bucket });
+  assert.equal(a.name, 'SITE_ASSETS');
+  assert.equal(a.role, WEBSITE_ASSETS_ROLE);
+
+  const b = resolveWebsiteAssets({ WEBSITE_ASSETS: bucket, SITE_ASSETS: r2Stub() });
+  assert.equal(b.name, 'WEBSITE_ASSETS');
+});
+
+test('resolveWorkerStaticAssets only accepts fetch binding', () => {
+  assert.equal(resolveWorkerStaticAssets({ ASSETS: r2Stub() }), null);
+  const assets = { fetch: async () => new Response('ok') };
+  assert.equal(resolveWorkerStaticAssets({ ASSETS: assets }), assets);
+});
+
+test('resolveDb and site cache aliases', () => {
+  const db = { prepare: () => ({}) };
+  assert.equal(resolveDb({ DATABASE: db }).name, 'DATABASE');
+  assert.equal(resolveSiteCacheKv({ CMS_CACHE: kvStub() }).name, 'CMS_CACHE');
+});
+
+test('key helpers and scaffold', () => {
+  assert.equal(websitePublicKey('agentsam-sdk', 'home/index.html'), 'sites/agentsam-sdk/public/home/index.html');
+  assert.equal(websitePartialKey('agentsam-sdk', 'header'), 'sites/agentsam-sdk/partials/header.html');
+  const tip = suggestWebsiteAssetsBindingScaffold({ detectedBindingName: 'CONTENT' });
+  assert.equal(tip.binding, 'CONTENT');
+  assert.equal(tip.wrangler_snippet.r2_buckets[0].binding, 'CONTENT');
+});