@inneranimalmedia/agentsam-sdk 2.4.1 → 2.6.0

package/test/release-hygiene.test.mjs

@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+
+const root = path.resolve(import.meta.dirname, '..');
+const read = (rel) => fs.readFileSync(path.join(root, rel), 'utf8');
+
+test('2.6 release metadata and public terminal vocabulary are aligned', () => {
+  const pkg = JSON.parse(read('package.json'));
+  const manifest = read('agentsam.yaml');
+  const readme = read('README.md');
+
+  assert.equal(pkg.version, '2.6.0');
+  assert.match(manifest, /target_version: "2.6.0"/);
+  assert.match(manifest, /state: release_candidate/);
+  assert.match(manifest, /current_latest: "2.5.0"/);
+  assert.doesNotMatch(manifest, /^\s*- tui\s*$/m);
+  assert.doesNotMatch(readme, /agentsam tui|CLI\/TUI/);
+});
+
+test('dead branded splash paths are gone and UI preview stays dev-only', () => {
+  for (const rel of ['src/ui/splash.js', 'src/ui/splash-xterm.js', 'src/commands/tui.js']) {
+    assert.equal(fs.existsSync(path.join(root, rel)), false, `${rel} should not ship`);
+  }
+  for (const rel of ['scripts/internal/ui-preview-runner.mjs', 'scripts/internal/ansi-ui-preview.mjs']) {
+    assert.equal(fs.existsSync(path.join(root, rel)), true, `${rel} should remain available to contributors`);
+  }
+  assert.equal(fs.existsSync(path.join(root, 'src/ui/runtime-activity.js')), true, 'automatic runtime activity must ship with the product CLI');
+
+  const pkg = JSON.parse(read('package.json'));
+  assert.ok(pkg.files.includes('skills'));
+  assert.equal(pkg.files.includes('scripts'), false, 'internal preview scripts must not be published');
+});

package/test/repository-snapshot-view.test.mjs

@@ -0,0 +1,112 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  buildRepositorySnapshotFacets,
+  projectRepositorySnapshot,
+  repositoryFileMatches,
+} from '../src/capabilities/repository-snapshot-view.js';
+
+function snapshot() {
+  return {
+    schema_version: 1,
+    capability: 'repository.snapshot',
+    snapshot_id: 'rsnap_0123456789abcdef01234567',
+    created_at: '2026-09-11T00:00:00.000Z',
+    content_hash: `sha256:${'1'.repeat(64)}`,
+    repository: { full_name: 'SamPrimeaux/agentsam-sdk', branch: 'main', revision_sha: 'abc123', dirty: false },
+    tree: {
+      merkle_root: `sha256:${'2'.repeat(64)}`,
+      metadata_root: `sha256:${'3'.repeat(64)}`,
+      manifest: { format: 'agentsam-merkle', version: 1, hash_algorithm: 'sha256', policy_hash: `sha256:${'4'.repeat(64)}` },
+      classifier: { format: 'agentsam-filemeta', version: 1, source: 'path+package+ast' },
+      stats: { files: 4, directories: 3, symlinks: 0, bytes: 1000 },
+      semantic_stats: { entries: 4, files: 4, packages: 2, ast_indexed: 4 },
+      paths: ['packages/identity/src/core/accounts.js', 'packages/identity/src/oauth/login.js', 'apps/cms/src/editor.tsx', 'apps/cms/src/assets.ts'],
+      files: [
+        {
+          path: 'packages/identity/src/core/accounts.js', type: 'file', size: 213, mode: 420, hash: `sha256:${'a'.repeat(64)}`,
+          package: '@inneranimalmedia/agentsam-sdk-identity', package_root: 'packages/identity', system: 'identity',
+          category: 'accounts', layer: 'core', kind: 'source', language: 'javascript', role: 'business-logic', execution_domain: 'unknown',
+          tags: ['account-scoped', 'authentication'], symbols: ['accountLinkingNotConfigured'], imports: [],
+        },
+        {
+          path: 'packages/identity/src/oauth/login.js', type: 'file', size: 300, mode: 420, hash: `sha256:${'b'.repeat(64)}`,
+          package: '@inneranimalmedia/agentsam-sdk-identity', package_root: 'packages/identity', system: 'identity',
+          category: 'login', layer: 'oauth', kind: 'source', language: 'javascript', role: 'business-logic', execution_domain: 'unknown',
+          tags: ['authentication'], symbols: ['login'], imports: ['./accounts.js'],
+        },
+        {
+          path: 'apps/cms/src/editor.tsx', type: 'file', size: 250, mode: 420, hash: `sha256:${'c'.repeat(64)}`,
+          package: '@inneranimalmedia/cms', package_root: 'apps/cms', system: 'cms-frontend', category: 'editor', layer: 'ui',
+          kind: 'source', language: 'typescript', role: 'ui', execution_domain: 'browser', tags: ['cms'], symbols: ['CmsEditor'], imports: ['react'],
+        },
+        {
+          path: 'apps/cms/src/assets.ts', type: 'file', size: 237, mode: 420, hash: `sha256:${'d'.repeat(64)}`,
+          package: '@inneranimalmedia/cms', package_root: 'apps/cms', system: 'cms-frontend', category: 'assets', layer: 'data',
+          kind: 'source', language: 'typescript', role: 'business-logic', execution_domain: 'browser', tags: ['cms', 'assets'], symbols: ['loadAsset'], imports: [],
+        },
+      ],
+    },
+    intelligence: { summary: { file_count: 4 } },
+    packages: [], knowledge: { configured: false },
+    analysis: {
+      trust_boundary: {
+        schema_version: 1, analyzer: 'agentsam-execution-boundary', metadata_root: `sha256:${'3'.repeat(64)}`,
+        complete: true, status: 'action-required', ok: false, browser_roots: 2, browser_reachable_files: 2, ast_files: 4,
+        findings: [{ kind: 'browser-server-import', severity: 'high', source: 'apps/cms/src/editor.tsx', target: 'server/secrets.ts', repair: { action: 'move-server-call-behind-api-boundary' } }],
+      },
+    },
+    deploy: null,
+  };
+}
+
+test('repository snapshot index is bounded and preserves the three canonical identities', () => {
+  const full = snapshot();
+  const view = projectRepositorySnapshot(full, { view: 'index' });
+  assert.equal(view.snapshot_id, full.snapshot_id);
+  assert.equal(view.content_hash, full.content_hash);
+  assert.equal(view.tree.merkle_root, full.tree.merkle_root);
+  assert.equal(view.tree.metadata_root, full.tree.metadata_root);
+  assert.equal(view.tree.manifest.policy_hash, full.tree.manifest.policy_hash);
+  assert.equal(view.files, undefined);
+  assert.equal(view.projection.matched, 4);
+  assert.match(view.projection.projection_hash, /^sha256:[a-f0-9]{64}$/);
+  assert.equal(view.tree.paths, undefined);
+  assert.equal(view.tree.files, undefined);
+  assert.equal(view.analysis.trust_boundary.status, 'action-required');
+  assert.equal(view.analysis.trust_boundary.finding_count, 1);
+  assert.equal(view.analysis.trust_boundary.findings[0].repair_action, 'move-server-call-behind-api-boundary');
+});
+
+test('repository snapshot files view filters semantics before bounding output', () => {
+  const full = snapshot();
+  const view = projectRepositorySnapshot(full, {
+    view: 'files',
+    filters: { system: ['identity'], tag: ['authentication'], category: ['accounts'], execution_domain: ['unknown'] },
+    limit: 1,
+  });
+  assert.equal(view.projection.matched, 1);
+  assert.equal(view.projection.returned, 1);
+  assert.equal(view.projection.truncated, false);
+  assert.deepEqual(view.files.map((entry) => entry.path), ['packages/identity/src/core/accounts.js']);
+  assert.equal(view.files[0].hash, undefined);
+  assert.equal(view.files[0].mode, undefined);
+});
+
+test('path globs, AST selectors, and facet counts are deterministic', () => {
+  const full = snapshot();
+  const files = full.tree.files;
+  assert.equal(repositoryFileMatches(files[2], { path: ['apps/cms/**'], symbol: ['CmsEditor'] }), true);
+  assert.equal(repositoryFileMatches(files[2], { import: ['react'], language: ['javascript'] }), false);
+  const facets = buildRepositorySnapshotFacets(files);
+  assert.deepEqual(facets.systems.slice(0, 2), [
+    { value: 'cms-frontend', count: 2 },
+    { value: 'identity', count: 2 },
+  ]);
+  assert.deepEqual(facets.tags.find((row) => row.value === 'authentication'), { value: 'authentication', count: 2 });
+  assert.deepEqual(facets.execution_domains, [
+    { value: 'browser', count: 2 },
+    { value: 'unknown', count: 2 },
+  ]);
+  assert.equal(repositoryFileMatches(files[2], { execution_domain: ['browser'] }), true);
+});

package/test/responses-runner.test.mjs

@@ -0,0 +1,148 @@
+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 }; }
+
+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.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/runtime-activity.test.mjs

@@ -0,0 +1,98 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  canAnimateTerminal,
+  createRuntimeActivity,
+  phaseForRuntimeEvent,
+  renderRuntimeActivityFrame,
+  renderRuntimeActivityPanel,
+  renderRuntimeActivityResult,
+} from '../src/ui/runtime-activity.js';
+import { runLocalAgent } from '../src/commands/shell.js';
+
+test('runtime activity is automatic only in a real interactive terminal', () => {
+  assert.equal(canAnimateTerminal({ stdout: { isTTY: true }, env: { TERM: 'xterm-256color' } }), true);
+  assert.equal(canAnimateTerminal({ stdout: { isTTY: false }, env: { TERM: 'xterm-256color' } }), false);
+  assert.equal(canAnimateTerminal({ stdout: { isTTY: true }, env: { TERM: 'dumb' } }), false);
+  assert.equal(canAnimateTerminal({ stdout: { isTTY: true }, env: { TERM: 'xterm-256color', CI: '1' } }), false);
+});
+
+test('runtime renderer exposes thinking, tool, and context phases without product renderer vocabulary', () => {
+  assert.match(renderRuntimeActivityFrame({ phase: 'thinking', tick: 1, elapsedMs: 1250 }), /Agent Sam/);
+  assert.match(renderRuntimeActivityFrame({ phase: 'thinking', tick: 1, elapsedMs: 1250 }), /thinking/);
+  const panel = renderRuntimeActivityPanel({ phase: 'thinking', tick: 2, elapsedMs: 1250 });
+  assert.match(panel, /Agent Sam/);
+  assert.match(panel, /thinking · working locally/);
+  assert.match(panel, /\(●\)/);
+  assert.equal(panel.split('\n').length, 5);
+  assert.match(renderRuntimeActivityResult({ phase: 'done', elapsedMs: 1250 }), /done/);
+  assert.equal(phaseForRuntimeEvent({ type: 'model.started' }), 'thinking');
+  assert.equal(phaseForRuntimeEvent({ type: 'tool.started', tool: 'git.status' }), 'using git.status');
+  assert.equal(phaseForRuntimeEvent({ type: 'context.compaction.started' }), 'tidying context');
+});
+
+test('runtime activity redraws automatically and restores the cursor', () => {
+  let output = '';
+  let clock = 0;
+  let intervalFn = null;
+  const activity = createRuntimeActivity({
+    write: (text) => { output += text; },
+    interactive: true,
+    now: () => clock,
+    setInterval: (fn) => { intervalFn = fn; return 7; },
+    clearInterval: () => {},
+  });
+
+  activity.start('thinking');
+  clock = 320;
+  intervalFn();
+  activity.update('using repository.snapshot');
+  clock = 840;
+  activity.succeed('done');
+
+  assert.match(output, /thinking/);
+  assert.match(output, /using repository\.snapshot/);
+  assert.match(output, /done/);
+  assert.match(output, /\x1b\[\?25l/);
+  assert.match(output, /\x1b\[\?25h/);
+});
+
+test('/agent starts and completes product activity around the real request', async () => {
+  const phases = [];
+  let output = '';
+  const activity = {
+    start: (phase) => phases.push(`start:${phase}`),
+    succeed: (phase) => phases.push(`success:${phase}`),
+    fail: (phase) => phases.push(`fail:${phase}`),
+  };
+  const fetchImpl = async () => ({
+    ok: true,
+    status: 200,
+    async text() { return JSON.stringify({ ok: true, answer: 'ready' }); },
+  });
+
+  await runLocalAgent('inspect this repo', (text) => { output += text; }, { fetchImpl, activity, interactive: true });
+  assert.deepEqual(phases, ['start:thinking', 'success:done']);
+  assert.match(output, /"answer": "ready"/);
+});
+
+
+test('/agent restores product activity when the response body fails', async () => {
+  const phases = [];
+  const activity = {
+    start: (phase) => phases.push(`start:${phase}`),
+    succeed: (phase) => phases.push(`success:${phase}`),
+    fail: (phase) => phases.push(`fail:${phase}`),
+  };
+  const fetchImpl = async () => ({
+    ok: true,
+    status: 200,
+    async text() { throw new Error('body interrupted'); },
+  });
+
+  await assert.rejects(
+    runLocalAgent('inspect this repo', () => {}, { fetchImpl, activity, interactive: true }),
+    /response could not be read: body interrupted/,
+  );
+  assert.deepEqual(phases, ['start:thinking', 'fail:response error']);
+});

package/test/sdk-worker-contract.test.mjs

@@ -0,0 +1,68 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import test from 'node:test';
+
+const read = (relative) => fs.readFileSync(new URL(`../${relative}`, import.meta.url), 'utf8');
+const exists = (relative) => fs.existsSync(new URL(`../${relative}`, import.meta.url));
+
+const wrangler = read('apps/local-studio/backend/wrangler.jsonc');
+const providers = read('apps/local-studio/shared/agentsam/src/model-providers.ts');
+const runtime = read('apps/local-studio/backend/server/lib/cloudflare-runtime.ts');
+const worker = read('apps/local-studio/backend/worker/index.js');
+
+test('Local Studio backend is the only agentsam-sdk Cloudflare application owner', () => {
+  assert.equal(exists('wrangler.jsonc'), false);
+  assert.equal(exists('worker/index.js'), false);
+  assert.equal(exists('scripts/with-cloudflare-env.sh'), false);
+  assert.ok(exists('apps/local-studio/backend/worker/index.js'));
+  assert.equal(exists('apps/local-studio/backend/wrangler.ui.toml'), false);
+  assert.equal(exists('apps/local-studio/backend/wrangler.workmode.toml'), false);
+  assert.ok(exists('apps/local-studio/backend/wrangler.jsonc'));
+});
+
+test('agentsam-sdk Worker uses the backend Worker entry, custom domain only, and canonical bindings', () => {
+  assert.match(wrangler, /"name"\s*:\s*"agentsam-sdk"/);
+  assert.match(wrangler, /"main"\s*:\s*"worker\/index\.js"/);
+  assert.match(wrangler, /"directory"\s*:\s*"\.\.\/\.output\/public"/);
+  assert.match(wrangler, /"workers_dev"\s*:\s*false/);
+  assert.match(wrangler, /"pattern"\s*:\s*"agentsam\.inneranimalmedia\.com"/);
+  assert.match(wrangler, /"binding"\s*:\s*"DB"/);
+  assert.match(wrangler, /"database_name"\s*:\s*"inneranimalmedia-business"/);
+  assert.match(wrangler, /"binding"\s*:\s*"WEBSITE_ASSETS"/);
+  assert.match(wrangler, /"bucket_name"\s*:\s*"agentsam-os-blueprint-content"/);
+  assert.match(wrangler, /"binding"\s*:\s*"AGENTSAM_WAI"/);
+  assert.match(wrangler, /"binding"\s*:\s*"EXECOS"/);
+  assert.match(wrangler, /"service"\s*:\s*"execos"/);
+  assert.match(wrangler, /"binding"\s*:\s*"PTY_SERVICE"/);
+  assert.match(wrangler, /"service_id"\s*:\s*"019db639-7c70-7071-8ef3-32ec0392a9ff"/);
+  assert.match(wrangler, /"IAM_ORIGIN"\s*:\s*"https:\/\/inneranimalmedia\.com"/);
+  assert.doesNotMatch(wrangler, /AGENTSAM_WORKER_ROLE/);
+  assert.doesNotMatch(wrangler, /"OLLAMA_BASE_URL"\s*:/);
+  assert.doesNotMatch(wrangler, /workers\.dev/);
+});
+
+test('canonical Worker preserves vault routes and delegates app traffic to Nitro', () => {
+  assert.match(worker, /url\.pathname\.startsWith\("\/api\/vault\/"\)/);
+  assert.match(worker, /\/api\/vault\/secrets/);
+  assert.match(worker, /\/api\/vault\/unwrap/);
+  assert.match(worker, /return nitroWorker\.fetch\(request, env, context\)/);
+});
+
+test('model providers include Grok independently from Grok gate authentication', () => {
+  for (const id of ['grok', 'openai', 'gemini', 'workers-ai', 'ollama']) {
+    assert.match(providers, new RegExp(`id: ["']${id}["']`));
+  }
+  assert.match(providers, /credential: "XAI_API_KEY"/);
+  assert.match(providers, /binding: "AGENTSAM_WAI"/);
+  assert.match(providers, /binding: "EXECOS"/);
+});
+
+test('Ollama uses local loopback behind ExecOS with a portable explicit cwd', () => {
+  assert.match(runtime, /baseUrl: "http:\/\/127\.0\.0\.1:11434"/);
+  assert.match(runtime, /target: "local"/);
+  assert.match(runtime, /x-bridge-key/);
+  assert.match(runtime, /return explicit \|\| "\/"/);
+  assert.match(runtime, /JSON\.stringify\(\{ command, target: "local", cwd \}\)/);
+  assert.match(runtime, /public_base_url: false/);
+  assert.doesNotMatch(runtime, /ollama\.inneranimalmedia\.com/);
+});

package/test/security.test.mjs

@@ -181,3 +181,49 @@ test('a missing transitive dependency cannot pass as complete coverage', async t
   assert.equal(report.complete,false);
   assert.ok(report.issues.some(issue=>issue.includes('Missing locked dependency edge')));
 });
+
+test('security scan includes AST/Merkle trust-boundary contradictions and mechanical repair evidence', async t => {
+  const f = fixture(t);
+  fs.mkdirSync(path.join(f.root, 'frontend'), { recursive: true });
+  fs.mkdirSync(path.join(f.root, 'backend'), { recursive: true });
+  fs.writeFileSync(path.join(f.root, 'frontend', 'client.ts'), [
+    "import { secretValue } from '../backend/secrets.ts';",
+    "export const value = secretValue;",
+  ].join('\n'));
+  fs.writeFileSync(path.join(f.root, 'backend', 'secrets.ts'), [
+    "export const secretValue = process.env.API_KEY;",
+  ].join('\n'));
+
+  const report = await scanProjectSecurity({ projectRoot: f.root, fetch: empty });
+  assert.equal(report.complete, true);
+  assert.equal(report.ok, false);
+  assert.equal(report.status, 'action-required');
+  assert.match(report.trust_boundary.merkle_root, /^sha256:/);
+  assert.match(report.trust_boundary.metadata_root, /^sha256:/);
+  const finding = report.trust_boundary.findings.find((item) => item.kind === 'browser-server-import');
+  assert.ok(finding);
+  assert.equal(finding.source, 'frontend/client.ts');
+  assert.equal(finding.target, 'backend/secrets.ts');
+  assert.equal(finding.repair.action, 'move-server-call-behind-api-boundary');
+  assert.equal(reportExitCode(report), 1);
+  const text = formatSecurityReport(report);
+  assert.match(text, /Trust boundary/);
+  assert.match(text, /frontend\/client\.ts/);
+  assert.match(text, /move-server-call-behind-api-boundary/);
+});
+
+test('browser env and server-runtime imports are derived from syntax rather than folder names alone', async t => {
+  const f = fixture(t);
+  fs.mkdirSync(path.join(f.root, 'frontend', 'src'), { recursive: true });
+  fs.writeFileSync(path.join(f.root, 'frontend', 'src', 'client.ts'), [
+    "import fs from 'node:fs';",
+    "export const leaked = import.meta.env.VITE_API_KEY;",
+    "export const privateValue = process.env.INTERNAL_TOKEN;",
+    "export const exists = Boolean(fs);",
+  ].join('\n'));
+  const report = await scanProjectSecurity({ projectRoot: f.root, fetch: empty });
+  const kinds = new Set(report.trust_boundary.findings.map((item) => item.kind));
+  assert.ok(kinds.has('browser-server-runtime-import'));
+  assert.ok(kinds.has('browser-public-secret-name'));
+  assert.ok(kinds.has('browser-private-env-access'));
+});

package/test/shell.test.mjs

@@ -4,7 +4,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import test from 'node:test';
-import { dispatchShellLine, renderShellCatalog, tokenizeShellLine } from '../src/commands/shell.js';
+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);
 
@@ -14,47 +15,80 @@ test('shell tokenizer preserves Windows paths and quoted arguments', () => {
   assert.deepEqual(tokenizeShellLine('/agent "inspect this repo"'), ['/agent', 'inspect this repo']);
 });
 
-test('shell catalog advertises commands that the REPL owns', () => {
+test('interactive prompt derives username and cwd instead of hardcoding Agent Sam identity', () => {
+  const env = { USER: 'alice', HOME: '/Users/alice' };
+  assert.equal(renderShellPrompt('/Users/alice/code/demo', env), 'alice ~/code/demo > ');
+  assert.equal(renderShellPrompt('/Users/alice', env), 'alice ~ > ');
+  assert.equal(renderShellPrompt('/tmp/demo', env), 'alice /tmp/demo > ');
+});
+
+test('shell catalog only advertises implemented core controls', () => {
   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', '/reasoning', '/fast', '/flex', '/standard', '/context', '/cf', '/diff', '/clear', '/exit']) {
+    assert.match(catalog, new RegExp(command.replace('/', '\\/')));
+  }
+  assert.match(catalog, /scrollable command picker/);
 });
 
-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/);
-
   output = '';
-  result = await dispatchShellLine('/pwd', state);
-  assert.equal(result.handled, true);
+  await dispatchShellLine('/', state);
+  assert.match(output, /Agent Sam Terminal/);
+  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('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, /\/model/);
   assert.match(result.stdout, /\/exit/);
 });

package/test/skills.test.mjs

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { getSkill, listSkills, loadSkill } from '../src/skills/index.js';
+
+test('portable skill registry exposes AgentSam Jr Dev by id and alias', () => {
+  const listed = listSkills();
+  assert.ok(listed.some((skill) => skill.id === 'agentsam-jr-dev'));
+
+  assert.equal(getSkill('agentsam_jr_dev')?.id, 'agentsam-jr-dev');
+  assert.equal(getSkill('jr-dev')?.id, 'agentsam-jr-dev');
+});
+
+test('AgentSam Jr Dev loads compact instructions and references on demand', () => {
+  const compact = loadSkill('agentsam-jr-dev');
+  assert.match(compact.instructions, /# AgentSam Jr Dev/);
+  assert.equal('references' in compact, false);
+
+  const full = loadSkill('agentsam_jr_dev', { references: true });
+  assert.equal(full.references.length, 2);
+  assert.match(full.references[0].content, /## HTTP/);
+  assert.match(full.references[1].content, /# Real Application Logic/);
+});