@inneranimalmedia/agentsam-sdk 2.6.1 → 2.6.3

package/test/cli/mcp-client.test.mjs

@@ -0,0 +1,245 @@
+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 {
+  MCP_PRESETS,
+  deleteMcpServer,
+  fetchExternalClientRegistry,
+  fetchMcpServerCatalog,
+  getClientConfigPath,
+  getClientRegistryCachePath,
+  getServerCatalogCachePath,
+  getSessionToolReceipts,
+  inspectClientAdapter,
+  isClientRegistered,
+  listKnownServers,
+  listMcpServers,
+  listRegisteredClients,
+  readMcpServer,
+  recordToolReceipt,
+  removeServerFromClient,
+  resolveServerPreset,
+  summarizeToolReceipts,
+  syncServerToClient,
+  writeMcpServer,
+} from '../../src/mcp/index.js';
+import { runMcp } from '../../src/commands/mcp.js';
+
+function tempHome() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-mcp-test-'));
+}
+
+test('MCP authority store manages servers under ~/.agentsam/mcp with safe permissions', () => {
+  const home = tempHome();
+  const config = {
+    url: 'https://mcp.inneranimalmedia.com/mcp',
+    auth: { type: 'bearer', token: 'iam_token_abc' },
+    clients: ['cursor', 'claude'],
+  };
+
+  const written = writeMcpServer('inneranimalmedia', config, { home });
+  assert.equal(written.name, 'inneranimalmedia');
+  assert.equal(written.url, 'https://mcp.inneranimalmedia.com/mcp');
+
+  const read = readMcpServer('inneranimalmedia', { home });
+  assert.equal(read.name, 'inneranimalmedia');
+  assert.equal(read.auth.token, 'iam_token_abc');
+  assert.deepEqual(read.clients, ['cursor', 'claude']);
+
+  const list = listMcpServers({ home });
+  assert.equal(list.length, 1);
+  assert.equal(list[0].name, 'inneranimalmedia');
+
+  const deleted = deleteMcpServer('inneranimalmedia', { home });
+  assert.equal(deleted, true);
+  assert.equal(readMcpServer('inneranimalmedia', { home }), null);
+});
+
+test('MCP external client registry recognizes chatgpt, claude, cursor and respects is_active', async () => {
+  const home = tempHome();
+
+  // Baseline seed / cached client list
+  const clients = listRegisteredClients({ home });
+  const keys = clients.map((c) => c.client_key);
+  assert.ok(keys.includes('chatgpt'), 'ChatGPT is recognized in the external client registry');
+  assert.ok(keys.includes('cursor'), 'Cursor is recognized in the external client registry');
+  assert.ok(keys.includes('claude'), 'Claude is recognized in the external client registry');
+  assert.ok(keys.includes('agentsam'), 'AgentSam is recognized in the external client registry');
+
+  assert.equal(isClientRegistered('chatgpt', { home }), true);
+  assert.equal(isClientRegistered('cursor', { home }), true);
+  assert.equal(isClientRegistered('nonexistent_client_xyz', { home }), false);
+
+  // Cache path is created upon writing
+  const cachePath = getClientRegistryCachePath({ home });
+  assert.equal(cachePath.endsWith('client-registry-cache.json'), true);
+});
+
+test('MCP client adapters materialize Cursor, Claude, and ChatGPT configurations cleanly', () => {
+  const home = tempHome();
+  const serverConfig = {
+    url: 'https://mcp.inneranimalmedia.com/mcp',
+    auth: { type: 'bearer', token: 'oauth_cursor_123' },
+  };
+
+  // Pre-seed an existing server in Cursor config to ensure no clobbering
+  const cursorConfigPath = getClientConfigPath('cursor', { home });
+  fs.mkdirSync(path.dirname(cursorConfigPath), { recursive: true });
+  fs.writeFileSync(
+    cursorConfigPath,
+    JSON.stringify({ mcpServers: { other_server: { url: 'http://localhost:8080' } } })
+  );
+
+  // Sync to Cursor
+  const cursorResult = syncServerToClient('cursor', 'inneranimalmedia', serverConfig, { home });
+  assert.equal(cursorResult.synced, true);
+
+  const cursorContent = JSON.parse(fs.readFileSync(cursorConfigPath, 'utf8'));
+  assert.ok(cursorContent.mcpServers.other_server, 'Preserved other server in Cursor config');
+  assert.equal(cursorContent.mcpServers.inneranimalmedia.url, 'https://mcp.inneranimalmedia.com/mcp');
+  assert.equal(cursorContent.mcpServers.inneranimalmedia.headers.Authorization, 'Bearer oauth_cursor_123');
+  assert.equal(cursorContent.mcpServers.inneranimalmedia.headers.Accept, 'application/json, text/event-stream');
+
+  // Inspect Cursor adapter
+  const inspection = inspectClientAdapter('cursor', 'inneranimalmedia', { home });
+  assert.equal(inspection.configured, true);
+  assert.equal(inspection.present, true);
+
+  // Sync to Claude
+  const claudeResult = syncServerToClient('claude', 'inneranimalmedia', serverConfig, { home });
+  assert.equal(claudeResult.synced, true);
+  const claudeConfigPath = getClientConfigPath('claude', { home });
+  const claudeContent = JSON.parse(fs.readFileSync(claudeConfigPath, 'utf8'));
+  assert.equal(claudeContent.mcpServers.inneranimalmedia.url, 'https://mcp.inneranimalmedia.com/mcp');
+
+  // Sync to ChatGPT
+  const chatgptResult = syncServerToClient('chatgpt', 'inneranimalmedia', serverConfig, { home });
+  assert.equal(chatgptResult.synced, true);
+  const chatgptConfigPath = getClientConfigPath('chatgpt', { home });
+  assert.ok(fs.existsSync(chatgptConfigPath));
+  const chatgptContent = JSON.parse(fs.readFileSync(chatgptConfigPath, 'utf8'));
+  assert.equal(chatgptContent.name, 'inneranimalmedia');
+  assert.equal(chatgptContent.server_url, 'https://mcp.inneranimalmedia.com/mcp');
+  assert.equal(chatgptContent.schema, 'agentsam.mcp.client-adapter.chatgpt.v1');
+
+  // Sync to AgentSam family adapter (~/.agentsam/mcp.json)
+  const agentsamResult = syncServerToClient('agentsam', 'inneranimalmedia', serverConfig, { home });
+  assert.equal(agentsamResult.synced, true);
+  const agentsamConfigPath = getClientConfigPath('agentsam', { home });
+  assert.equal(agentsamConfigPath, path.join(home, '.agentsam', 'mcp.json'));
+  assert.ok(fs.existsSync(agentsamConfigPath));
+  const agentsamContent = JSON.parse(fs.readFileSync(agentsamConfigPath, 'utf8'));
+  assert.equal(agentsamContent.mcpServers.inneranimalmedia.url, 'https://mcp.inneranimalmedia.com/mcp');
+  assert.equal(agentsamContent.mcpServers.inneranimalmedia.headers.Authorization, 'Bearer oauth_cursor_123');
+
+  // Remove from Cursor
+  const removeResult = removeServerFromClient('cursor', 'inneranimalmedia', { home });
+  assert.equal(removeResult.removed, true);
+  const postRemove = JSON.parse(fs.readFileSync(cursorConfigPath, 'utf8'));
+  assert.equal(postRemove.mcpServers.inneranimalmedia, undefined);
+  assert.ok(postRemove.mcpServers.other_server, 'Still preserved other server');
+
+  // Remove from AgentSam family adapter
+  const removeAgentsam = removeServerFromClient('agentsam', 'inneranimalmedia', { home });
+  assert.equal(removeAgentsam.removed, true);
+  const postRemoveAgentsam = JSON.parse(fs.readFileSync(agentsamConfigPath, 'utf8'));
+  assert.equal(postRemoveAgentsam.mcpServers.inneranimalmedia, undefined);
+
+  // Remove from ChatGPT
+  const removeChatgpt = removeServerFromClient('chatgpt', 'inneranimalmedia', { home });
+  assert.equal(removeChatgpt.removed, true);
+  assert.equal(fs.existsSync(chatgptConfigPath), false);
+});
+
+test('MCP server catalog resolves real registered servers with live health metrics', () => {
+  const home = tempHome();
+  const catalog = listKnownServers({ home });
+  assert.ok(catalog.length >= 8);
+
+  // Cloudflare API server from D1
+  const cfApi = resolveServerPreset('cloudflare-api', { home });
+  assert.ok(cfApi);
+  assert.equal(cfApi.url, 'https://mcp.cloudflare.com/mcp');
+  assert.equal(cfApi.health_status, 'degraded');
+  assert.equal(cfApi.avg_latency_ms, 9);
+
+  // InnerAnimalMedia Main MCP from D1
+  const iam = resolveServerPreset('inneranimalmedia', { home });
+  assert.ok(iam);
+  assert.equal(iam.health_status, 'healthy');
+  assert.equal(iam.avg_latency_ms, 443);
+});
+
+test('MCP telemetry logs tool receipts and computes accurate summaries', () => {
+  const home = tempHome();
+
+  recordToolReceipt({ tool_key: 'github_read', source_client: 'cursor', duration_ms: 120 }, { home });
+  recordToolReceipt({ tool_key: 'mcp:d1_query', source_client: 'cursor_mcp', duration_ms: 45 }, { home });
+  recordToolReceipt({ tool_key: 'terminal_exec', source_client: 'agentsam', duration_ms: 800 }, { home });
+  recordToolReceipt({ tool_key: 'mcp:tool_broken', error_code: 'TIMEOUT', duration_ms: 5000 }, { home });
+
+  const receipts = getSessionToolReceipts({ home });
+  assert.equal(receipts.length, 4);
+
+  const summary = summarizeToolReceipts(receipts);
+  assert.equal(summary.tool_call_count, 4);
+  assert.equal(summary.mcp_call_count, 2);
+  assert.equal(summary.github_call_count, 1);
+  assert.equal(summary.d1_call_count, 1);
+  assert.equal(summary.terminal_call_count, 1);
+  assert.equal(summary.failure_count, 1);
+  assert.equal(summary.success_count, 3);
+});
+
+test('agentsam mcp CLI handles add, list, status, doctor, and remove end-to-end', async () => {
+  const home = tempHome();
+  const logs = [];
+  const write = (str) => logs.push(str);
+
+  // Test --help output surfaces chatgpt and known catalog servers
+  await runMcp(['--help'], { home, write });
+  const helpText = logs.join('\n');
+  assert.ok(helpText.includes('chatgpt'), 'Help text displays ChatGPT as a recognized client');
+  assert.ok(helpText.includes('cloudflare-api'), 'Help text displays cloudflare-api preset');
+  logs.length = 0;
+
+  // Add inneranimalmedia preset for chatgpt client
+  const addRes = await runMcp(
+    ['add', 'inneranimalmedia', '--client', 'chatgpt', '--token', 'test_tok_777', '--json'],
+    { home, write }
+  );
+  assert.equal(addRes.ok, true);
+  assert.equal(addRes.server.name, 'inneranimalmedia');
+  assert.equal(addRes.server.auth.token, 'test_tok_777');
+  assert.equal(addRes.syncedAdapters[0].client, 'chatgpt');
+
+  // List
+  const listRes = await runMcp(['list', '--json'], { home, write });
+  assert.equal(listRes.length, 1);
+  assert.equal(listRes[0].name, 'inneranimalmedia');
+
+  // List catalog
+  const catalogRes = await runMcp(['list', '--catalog', '--json'], { home, write });
+  assert.ok(catalogRes.length >= 8);
+
+  // Status
+  const statusRes = await runMcp(['status', 'inneranimalmedia', '--json'], { home, write });
+  assert.equal(statusRes.name, 'inneranimalmedia');
+  assert.equal(statusRes.hasAuth, true);
+
+  // Doctor includes catalog health data
+  const doctorRes = await runMcp(['doctor', 'inneranimalmedia', '--json'], { home, write });
+  assert.equal(doctorRes.name, 'inneranimalmedia');
+  assert.equal(doctorRes.authConfigured, true);
+  assert.equal(doctorRes.catalogHealth?.health_status, 'healthy');
+
+  // Remove
+  const removeRes = await runMcp(['remove', 'inneranimalmedia', '--client', 'all', '--json'], { home, write });
+  assert.equal(removeRes.deletedAuthority, true);
+
+  const emptyList = await runMcp(['list', '--json'], { home, write });
+  assert.equal(emptyList.length, 0);
+});

package/test/cli/runtime-ui.test.mjs

@@ -1,10 +1,12 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { createInlineActivity } from '../../src/ui/cli/activity.js';
-import { renderCliFooter } from '../../src/ui/cli/footer.js';
+import { createInlineActivity, INTERRUPT_HINT, renderShimmer } from '../../src/ui/cli/activity.js';
+import { renderCliFooter, renderDiffPreview } from '../../src/ui/cli/footer.js';
 import { createCliRuntimePresenter, normalizeRuntimeEventEnvelope, RUNTIME_EVENT_ENVELOPE_SCHEMA } from '../../src/ui/cli/runtime-events.js';
 import { renderWaitingInput } from '../../src/ui/cli/waiting.js';
 
+const stripAnsi = (text) => String(text || '').replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
+
 test('CLI footer reports unknown context honestly', () => {
   const text = renderCliFooter({
     model: 'claude-test',
@@ -19,6 +21,71 @@ test('CLI footer reports unknown context honestly', () => {
   assert.match(text, /cache 2k/);
 });
 
+test('CLI footer shows project identity, branch, and shortcut hints', () => {
+  const text = stripAnsi(renderCliFooter({
+    project: 'agentsam-sdk',
+    cwd: '/Users/sam/agentsam-sdk',
+    branch: 'feat/cli-interactive-presence',
+    model: 'claude-test',
+  }));
+  assert.match(text, /agentsam-sdk/);
+  assert.match(text, /feat\/cli-interactive-presence/);
+  assert.match(text, /ctrl-c to cancel/);
+  assert.match(text, /\/ commands/);
+});
+
+test('diff preview colors hunks and keeps NO_COLOR output readable', () => {
+  const diff = [
+    'diff --git a/src/ui/cli/footer.js b/src/ui/cli/footer.js',
+    '--- a/src/ui/cli/footer.js',
+    '+++ b/src/ui/cli/footer.js',
+    '@@ -1,3 +1,4 @@',
+    ' import pc from \'picocolors\';',
+    '-const old = 1;',
+    '+const next = 2;',
+    ' keep',
+  ].join('\n');
+  const colored = renderDiffPreview(diff, { color: true });
+  assert.match(colored, /\x1b\[/);
+  assert.match(stripAnsi(colored), /\+const next = 2;/);
+  const plain = renderDiffPreview(diff, { color: false });
+  assert.doesNotMatch(plain, /\x1b\[/);
+  assert.match(plain, /-const old = 1;/);
+  assert.equal(stripAnsi(renderDiffPreview('', { color: false })).trim(), 'no changes');
+});
+
+test('inline activity shows elapsed time and ctrl-c cancel hint', () => {
+  let output = '';
+  let now = 0;
+  let tick = null;
+  const activity = createInlineActivity({
+    write: (value) => { output += value; },
+    interactive: true,
+    env: { NO_COLOR: '1' },
+    now: () => now,
+    setInterval: (fn) => { tick = fn; return 1; },
+    clearInterval() {},
+  });
+  activity.start('Working');
+  now = 1500;
+  tick();
+  const clean = stripAnsi(output);
+  assert.match(clean, /Working/);
+  assert.match(clean, /1\.5s/);
+  assert.match(clean, new RegExp(INTERRUPT_HINT.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+  activity.clear();
+});
+
+test('shimmer uses color when allowed and stays plain under NO_COLOR', () => {
+  const colored = renderShimmer('Working', 4, { env: { COLORTERM: 'truecolor' } });
+  assert.match(colored, /\x1b\[38;2;/);
+  assert.match(stripAnsi(colored), /Working/);
+  const fallback = renderShimmer('Working', 4, { env: { TERM: 'xterm-256color' } });
+  assert.match(fallback, /\x1b\[38;5;/);
+  const plain = renderShimmer('Working', 4, { env: { NO_COLOR: '1', COLORTERM: 'truecolor' } });
+  assert.equal(plain, 'Working');
+});
+
 test('runtime event envelope is the single standalone/platform producer contract', () => {
   const envelope = normalizeRuntimeEventEnvelope({
     schema_version: 1,

package/test/cli/status-actions.test.mjs

@@ -0,0 +1,88 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  buildStatusActionPlan,
+  formatStatusNextSteps,
+} from '../../src/status/actions.js';
+import { renderLocalStatus } from '../../src/ui/ansi.js';
+
+test('healthy Cloudflare deployment wins over localhost', () => {
+  const runtime = {
+    ready: true,
+    checks: {
+      account: true,
+      models: true,
+      terminal: true,
+      cloudflare: true,
+    },
+    local: {
+      deployTarget: 'cloudflare',
+      api: {
+        online: false,
+        url: 'http://127.0.0.1:8787/api/health',
+      },
+      db: {
+        ready: true,
+        exists: true,
+      },
+    },
+    cloudflare: {
+      configured: true,
+      worker_name: 'agentsam-sdk',
+      health: {
+        ok: true,
+        status: 200,
+        url: 'https://agentsam.inneranimalmedia.com/health',
+      },
+    },
+  };
+
+  const plan = buildStatusActionPlan(runtime);
+  const text = formatStatusNextSteps(plan);
+
+  assert.match(plan.headline, /Live project healthy/);
+  assert.ok(plan.actions.some((action) =>
+    action.command === 'https://agentsam.inneranimalmedia.com'
+  ));
+  assert.ok(plan.actions.some((action) =>
+    action.command === 'agentsam cloudflare status'
+  ));
+  assert.doesNotMatch(text, /npm run dev/);
+  assert.match(text, /open https:\/\/agentsam\.inneranimalmedia\.com/);
+});
+
+test('compact local card prefers live deployment', () => {
+  const text = renderLocalStatus({
+    configured: true,
+    project: 'agentsam-sdk',
+    lane: 'custom',
+    agent: 'default',
+    git: {
+      branch: 'main',
+      revision: 'abcdef123456',
+      dirty: false,
+    },
+    db: {
+      ready: true,
+      tables: [],
+    },
+    api: {
+      online: false,
+      url: 'http://127.0.0.1:8787/api/health',
+    },
+    pty: {
+      online: true,
+      url: 'http://127.0.0.1:3099/health',
+    },
+    deployTarget: 'cloudflare',
+    live: {
+      online: true,
+      url: 'https://agentsam.inneranimalmedia.com/health',
+    },
+  });
+
+  assert.match(text, /● live/);
+  assert.match(text, /open https:\/\/agentsam\.inneranimalmedia\.com/);
+  assert.match(text, /agentsam cloudflare status/);
+  assert.doesNotMatch(text, /npm run dev/);
+});

package/test/cli/wireframes-go-registry.test.mjs

@@ -0,0 +1,54 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { renderArchitectureExplorer, renderOperationInspector, drawBox } from '../../src/ui/wireframes.js';
+import { buildGoProductRegistrySql } from '../../src/go/registry.js';
+
+test('architecture explorer is boxed reasoning scenery', () => {
+  const view = renderArchitectureExplorer({
+    repo: 'agentsam-sdk',
+    focus: { package: 'protocol', owns: 'wire contracts', runtime: 'none', imported_by: 'client', files: '.proto' },
+  });
+  assert.match(view, /┌/);
+  assert.match(view, /package: protocol/);
+  assert.match(view, /DEPENDENCY MAP/);
+  assert.match(view, /\[contracts\]/);
+});
+
+test('operation inspector shows intent timeline', () => {
+  const view = renderOperationInspector({
+    operation: 'model.export',
+    op_id: 'op_01H',
+    active_index: 2,
+    step: { name: 'converter', artifact: 'GLB' },
+    receipt: { 'input document revision': 84, 'output artifact hash': 'abc' },
+  });
+  assert.match(view, /model\.export/);
+  assert.match(view, /intent/);
+  assert.match(view, /converter/);
+  assert.match(view, /GLB/);
+  assert.match(view, /input document revision/);
+});
+
+test('drawBox pads visible ANSI width', () => {
+  const box = drawBox(['hello'], { width: 20, title: 't' });
+  assert.match(box, /┌/);
+  assert.match(box, /└/);
+});
+
+test('buildGoProductRegistrySql upserts product + relationships without inventing tables', () => {
+  const sql = buildGoProductRegistrySql({
+    product: 'agentsam-go-worker',
+    status: 'wired',
+    url: 'https://agentsam-go-worker.example.workers.dev',
+    commit: 'abc123',
+    health: 'healthy',
+  });
+  assert.match(sql, /INSERT INTO agentsam_products/);
+  assert.match(sql, /ON CONFLICT\(slug\) DO UPDATE/);
+  assert.match(sql, /INSERT INTO asset_relationships/);
+  assert.match(sql, /sourced_from/);
+  assert.match(sql, /runs_on/);
+  assert.match(sql, /deployed_as/);
+  assert.doesNotMatch(sql, /CREATE TABLE/);
+  assert.doesNotMatch(sql, /account_id/);
+});

package/test/cloudflare-connector.test.mjs

@@ -29,8 +29,7 @@ describe('cloudflare connector routes', () => {
   it('returns 503 on start when only fixture credentials exist', async () => {
     const env = {
       CLOUDFLARE_OAUTH_CLIENT_ID: 'sillynotreal',
-      CLOUDFLARE_OAUTH_CLIENT_SECRET: 'sillynotreal-secret',
-      sessions: new Map([['sess_1', 'user-sam']]),
+      fixtureSessions: new Map([['sess_1', 'user-sam']]),
     };
     const res = await handleCloudflareConnectionRequest(
       req('https://agentsam.inneranimalmedia.com/api/connections/cloudflare/start', {
@@ -47,8 +46,7 @@ describe('cloudflare connector routes', () => {
   it('status stays safe and does not treat fixture as production configured', async () => {
     const env = {
       CLOUDFLARE_OAUTH_CLIENT_ID: 'sillynotreal',
-      CLOUDFLARE_OAUTH_CLIENT_SECRET: 'sillynotreal-secret',
-      sessions: new Map([['sess_1', 'user-sam']]),
+      fixtureSessions: new Map([['sess_1', 'user-sam']]),
     };
     const res = await handleCloudflareConnectionRequest(
       req('https://agentsam.inneranimalmedia.com/api/connections/cloudflare', {
@@ -65,7 +63,7 @@ describe('cloudflare connector routes', () => {
   });
 
   it('rejects owner_id in the JSON body', async () => {
-    const env = { sessions: new Map([['sess_1', 'user-sam']]) };
+    const env = { fixtureSessions: new Map([['sess_1', 'user-sam']]) };
     const res = await handleCloudflareConnectionRequest(
       req('https://agentsam.inneranimalmedia.com/api/connections/cloudflare/disconnect', {
         method: 'POST',
@@ -82,7 +80,6 @@ describe('cloudflare connector routes', () => {
   it('rejects callback without a stored oauth state', async () => {
     const env = {
       CLOUDFLARE_OAUTH_CLIENT_ID: 'real-client-id',
-      CLOUDFLARE_OAUTH_CLIENT_SECRET: 'real-client-secret-value',
       oauthState: new Map(),
     };
     const res = await handleCloudflareConnectionRequest(

package/test/cloudflare-runtime.test.mjs

@@ -10,10 +10,17 @@ function tempRoot() { return fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-cf-
 
 test('Cloudflare native command catalog exposes bounded read operations and never an auth-token secret read', () => {
   const ids = listWranglerNativeCommands().map((row) => row.id);
-  assert.deepEqual(ids, ['whoami', 'deployments.list', 'versions.list', 'types.check', 'queues.list']);
+  assert.deepEqual(ids, ['whoami', 'deployments.list', 'versions.list', 'versions.view', 'types.check', 'queues.list', 'tunnel.list', 'tunnel.info']);
   assert.ok(!ids.some((id) => id.includes('token') || id.includes('secret') || id === 'deploy'));
 });
 
+test('Wrangler version view requires an exact version and keeps secret values unavailable', () => {
+  const root = tempRoot();
+  const plan = buildWranglerInvocation('versions.view', { cwd: root, name: 'demo', version_id: 'ver_123' });
+  assert.deepEqual(plan.args, ['versions', 'view', 'ver_123', '--json', '--name', 'demo']);
+  assert.throws(() => buildWranglerInvocation('versions.view', { cwd: root, name: 'demo' }), /version_id_required/);
+});
+
 test('Wrangler native invocation is argv-based and cwd/config scoped', () => {
   const root = tempRoot();
   fs.writeFileSync(path.join(root, 'wrangler.jsonc'), '{}');

package/test/context.test.mjs

@@ -115,6 +115,21 @@ test('AgentSam instructions compile in stable then repository-specific precedenc
   assert.ok(compiled.content.indexOf('base law') < compiled.content.indexOf('local law'));
 });
 
+test('compatibility shims are not compiled into AgentSam instruction authority', t => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-instruction-shims-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  fs.mkdirSync(path.join(root, '.git'));
+  fs.writeFileSync(path.join(root, 'AGENTSAM.md'), '# Stable\ncanonical only\n');
+  fs.writeFileSync(path.join(root, 'AGENTS.md'), 'shim should not become policy\n');
+  fs.writeFileSync(path.join(root, 'CLAUDE.md'), 'claude shim should not become policy\n');
+  const compiled = compileAgentInstructions(root);
+  assert.equal(compiled.sources.length, 1);
+  assert.equal(compiled.sources[0].filename, 'AGENTSAM.md');
+  assert.match(compiled.content, /canonical only/);
+  assert.doesNotMatch(compiled.content, /shim should not become policy/);
+  assert.doesNotMatch(compiled.content, /claude shim should not become policy/);
+});
+
 test('project context loads bounded compiled AgentSam instructions', t => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-context-rules-'));
   t.after(() => fs.rmSync(root, { recursive: true, force: true }));

package/test/error-diagnostics.test.mjs

@@ -16,6 +16,15 @@ import { createOpenAIResponsesAdapter } from '../src/providers/openai-responses.
 
 function response(status, body, headers = {}) { return new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json', ...headers } }); }
 
+
+test('public errors subpath preserves canonical and legacy diagnostic APIs', async () => {
+  const errors = await import('@inneranimalmedia/agentsam-sdk/errors');
+  assert.equal(typeof errors.createErrorEnvelope, 'function');
+  assert.equal(typeof errors.classifyCloudflareFailure, 'function');
+  assert.equal(typeof errors.classifyOpenAIError, 'function');
+  assert.equal(typeof errors.diagnosticFromError, 'function');
+});
+
 test('OpenAI diagnostics preserve machine code, request id, retry metadata and redact secrets', () => {
   const error = createOpenAIHttpError({
     status: 429,