@inneranimalmedia/agentsam-sdk 2.4.1 → 2.5.0

package/src/ui/boot.js

@@ -0,0 +1,56 @@
+import path from 'node:path';
+import pc from 'picocolors';
+
+const FRAMES = ['◔', '◑', '◕', '●'];
+const CLEAR_LINE = '\x1b[2K';
+const HIDE_CURSOR = '\x1b[?25l';
+const SHOW_CURSOR = '\x1b[?25h';
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function compactHome(value) {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  if (home && value.startsWith(home)) return `~${value.slice(home.length)}`;
+  return value;
+}
+
+export function renderBootSummary({ identity, preferences }) {
+  const branch = identity.branch ? ` · ${pc.cyan(identity.branch)}` : '';
+  const model = preferences.modelPreference && preferences.modelPreference !== 'auto'
+    ? preferences.modelPreference
+    : 'auto';
+  const runtime = preferences.runtime || 'local';
+  const terminal = preferences.terminal || path.basename(process.env.SHELL || '') || 'shell';
+  return [
+    '',
+    `  ${pc.bold('Agent Sam')}  ${pc.green('●')}`,
+    `  ${pc.cyan(identity.project)}${branch} · ${pc.white(model)}`,
+    `  ${pc.dim(compactHome(identity.root))}`,
+    `  ${pc.green('✓')} ${pc.dim(runtime)} · ${pc.dim(terminal)} · ready`,
+    '',
+  ].join('\n');
+}
+
+export async function runBootScene({ identity, preferences, animate = true, write = process.stdout.write.bind(process.stdout) }) {
+  const interactive = Boolean(animate && process.stdout.isTTY);
+  if (!interactive) {
+    write(renderBootSummary({ identity, preferences }));
+    return;
+  }
+
+  write(HIDE_CURSOR);
+  try {
+    write(`\n  ${pc.bold('Agent Sam')}\n  ${pc.cyan(identity.project)}${identity.branch ? ` · ${pc.cyan(identity.branch)}` : ''}\n\n`);
+    const checks = ['project', 'runtime', 'model'];
+    for (const label of checks) {
+      for (let i = 0; i < FRAMES.length; i += 1) {
+        write(`\r${CLEAR_LINE}  ${pc.cyan(FRAMES[i])} ${pc.dim(`checking ${label}`)}`);
+        await sleep(i === FRAMES.length - 1 ? 45 : 55);
+      }
+      write(`\r${CLEAR_LINE}  ${pc.green('✓')} ${pc.dim(label)}\n`);
+    }
+    write(`\n  ${pc.green('●')} ${pc.bold('ready')}  ${pc.dim(compactHome(identity.root))}\n\n`);
+  } finally {
+    write(SHOW_CURSOR);
+  }
+}

package/src/ui/merkle/render.js

@@ -79,6 +79,7 @@ export function renderSummary(result, { inspect = false, color = false } = {}) {
   const { tree, diff } = result;
   const lines = [paint(`Agent Sam · ${safeText(result.title)}`, '1;36', color), `  path:  ${safeText(tree.rootPath)}`,
     `  files: ${tree.stats.files}  links: ${tree.stats.symlinks}  bytes: ${tree.stats.bytes}`, `  root:  ${tree.rootHash}`];
+  if (tree.semantic) lines.push(`  meta:  ${tree.semantic.rootHash}  (${tree.semantic.classifier.format}/v${tree.semantic.classifier.version})`);
   if (result.output) lines.push(`  saved: ${safeText(result.output)}`);
   if (diff) {
     lines.push(`  ${diff.equal ? 'MATCH' : 'CHANGED'}  ` + Object.entries(diff.stats).map(([key, value]) => `${value} ${key}`).join(' · '));

package/src/ui/runtime-activity.js

@@ -0,0 +1,192 @@
+import pc from 'picocolors';
+
+const CLEAR_LINE = '\x1b[2K';
+const HIDE_CURSOR = '\x1b[?25l';
+const SHOW_CURSOR = '\x1b[?25h';
+const SPINNER = ['◔', '◑', '◕', '●'];
+const PANEL_WIDTH = 34;
+const PANEL_INNER = PANEL_WIDTH - 2;
+const PANEL_LINES = 5;
+
+const THINK_FRAMES = [
+  ['  ·     ·', '     ○', '  ·     ·'],
+  ['  ✦     ·', '    (○)', '  ·     ✦'],
+  ['  ·     ✦', '    (●)', '  ✦     ·'],
+  ['    ✦', '   ( ◯ )', '    ✦'],
+  ['  ✦     ✦', '    (●)', '  ✦     ✦'],
+  ['  ·     ✦', '    (○)', '  ✦     ·'],
+];
+
+function elapsedLabel(ms) {
+  if (ms < 1000) return `${Math.max(0, Math.round(ms))}ms`;
+  return `${(ms / 1000).toFixed(ms < 10000 ? 1 : 0)}s`;
+}
+
+function truncate(value, max) {
+  const text = String(value || '');
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 1))}…`;
+}
+
+function center(value, width) {
+  const text = truncate(value, width);
+  const left = Math.max(0, Math.floor((width - text.length) / 2));
+  const right = Math.max(0, width - text.length - left);
+  return `${' '.repeat(left)}${text}${' '.repeat(right)}`;
+}
+
+function titledBorder(title, width, left, right) {
+  const label = ` ${title} `;
+  const fill = Math.max(0, width - left.length - right.length - label.length);
+  return `${left}${label}${'─'.repeat(fill)}${right}`;
+}
+
+function subtitledBorder(subtitle, width, left, right) {
+  const label = ` ${truncate(subtitle, width - 4)} `;
+  const fill = Math.max(0, width - left.length - right.length - label.length);
+  return `${left}${label}${'─'.repeat(fill)}${right}`;
+}
+
+export function canAnimateTerminal({ stdout = process.stdout, env = process.env } = {}) {
+  if (!stdout?.isTTY) return false;
+  if (String(env.TERM || '').toLowerCase() === 'dumb') return false;
+  if (String(env.CI || '').trim()) return false;
+  return true;
+}
+
+export function renderRuntimeActivityFrame({
+  label = 'Agent Sam',
+  phase = 'thinking',
+  tick = 0,
+  elapsedMs = 0,
+} = {}) {
+  const frame = SPINNER[Math.abs(Number(tick) || 0) % SPINNER.length];
+  return `  ${pc.cyan(frame)} ${pc.bold(label)} ${pc.dim(`· ${phase}`)} ${pc.dim(`· ${elapsedLabel(elapsedMs)}`)}`;
+}
+
+export function renderRuntimeActivityPanel({
+  label = 'Agent Sam',
+  phase = 'thinking',
+  tick = 0,
+  elapsedMs = 0,
+  status = 'active',
+  locality = 'working locally',
+} = {}) {
+  const frame = THINK_FRAMES[Math.abs(Number(tick) || 0) % THINK_FRAMES.length];
+  const border = status === 'success' ? pc.green : status === 'error' ? pc.red : pc.cyan;
+  const body = status === 'error' ? pc.red : pc.cyan;
+  const title = titledBorder(label, PANEL_WIDTH, '╭─', '╮');
+  const subtitle = status === 'active'
+    ? `${phase} · ${locality}`
+    : `${phase} · ${elapsedLabel(elapsedMs)}`;
+  return [
+    border(title),
+    `${border('│')}${body(center(frame[0], PANEL_INNER))}${border('│')}`,
+    `${border('│')}${body(center(frame[1], PANEL_INNER))}${border('│')}`,
+    `${border('│')}${body(center(frame[2], PANEL_INNER))}${border('│')}`,
+    border(subtitledBorder(subtitle, PANEL_WIDTH, '╰─', '╯')),
+  ].join('\n');
+}
+
+export function renderRuntimeActivityResult({
+  label = 'Agent Sam',
+  status = 'success',
+  phase = status === 'success' ? 'done' : 'failed',
+  elapsedMs = 0,
+} = {}) {
+  const ok = status === 'success';
+  const symbol = ok ? pc.green('✓') : pc.red('✗');
+  return `  ${symbol} ${pc.bold(label)} ${pc.dim(`· ${phase}`)} ${pc.dim(`· ${elapsedLabel(elapsedMs)}`)}`;
+}
+
+/**
+ * Live terminal activity for product runtime operations.
+ *
+ * This is shipped product UI, not a preview renderer. It remains quiet in pipes/CI,
+ * and only uses cursor redraw when stdout is an interactive terminal.
+ */
+export function createRuntimeActivity(options = {}) {
+  const write = options.write || process.stdout.write.bind(process.stdout);
+  const now = options.now || (() => Date.now());
+  const setTimer = options.setInterval || globalThis.setInterval;
+  const clearTimer = options.clearInterval || globalThis.clearInterval;
+  const interactive = options.interactive ?? canAnimateTerminal(options);
+  const intervalMs = Math.max(40, Number(options.intervalMs) || 90);
+  const label = String(options.label || 'Agent Sam');
+  const locality = String(options.locality || 'working locally');
+
+  let phase = String(options.phase || 'thinking');
+  let startedAt = 0;
+  let tick = 0;
+  let timer = null;
+  let started = false;
+  let finished = false;
+  let drawn = false;
+
+  const writePanel = (status = 'active') => {
+    if (!interactive || !started) return;
+    const elapsedMs = Math.max(0, now() - startedAt);
+    if (drawn) write(`\x1b[${PANEL_LINES}A`);
+    const panel = renderRuntimeActivityPanel({ label, phase, tick, elapsedMs, status, locality });
+    for (const line of panel.split('\n')) write(`\r${CLEAR_LINE}${line}\n`);
+    drawn = true;
+    tick += 1;
+  };
+
+  const draw = () => {
+    if (finished) return;
+    writePanel('active');
+  };
+
+  const start = (nextPhase = phase) => {
+    if (started || finished) return;
+    phase = String(nextPhase || phase);
+    started = true;
+    startedAt = now();
+    if (!interactive) return;
+    write(HIDE_CURSOR);
+    draw();
+    timer = setTimer(draw, intervalMs);
+  };
+
+  const update = (nextPhase) => {
+    if (nextPhase) phase = String(nextPhase);
+    if (!started) start(phase);
+    draw();
+  };
+
+  const finish = ({ status = 'success', resultPhase } = {}) => {
+    if (finished) return;
+    if (timer) clearTimer(timer);
+    timer = null;
+    phase = resultPhase || (status === 'success' ? 'done' : 'failed');
+    if (interactive && started) {
+      writePanel(status === 'success' ? 'success' : 'error');
+      write(SHOW_CURSOR);
+    }
+    finished = true;
+  };
+
+  return {
+    get interactive() { return interactive; },
+    start,
+    update,
+    succeed(phaseName = 'done') { finish({ status: 'success', resultPhase: phaseName }); },
+    fail(phaseName = 'failed') { finish({ status: 'error', resultPhase: phaseName }); },
+    stop() { finish({ status: 'success', resultPhase: 'done' }); },
+  };
+}
+
+/**
+ * Maps portable runtime events onto the customer terminal without making the renderer
+ * the authority for execution. Hosts may feed richer telemetry into the same seam.
+ */
+export function phaseForRuntimeEvent(event = {}) {
+  const type = String(event.type || '');
+  if (type === 'model.started' || type === 'model.delta') return 'thinking';
+  if (type === 'tool.started') return event.tool ? `using ${event.tool}` : 'using tool';
+  if (type === 'context.compaction.started') return 'tidying context';
+  if (type === 'context.compaction.completed') return 'context ready';
+  if (type === 'run.started') return 'working';
+  return null;
+}

package/src/ui/theme.js

@@ -1,15 +1,15 @@
 /**
  * @file src/ui/theme.js
- * @description IAM Terminal Theme System — single source of truth for
- * per-lane color identity. Used by:
- *   - xterm.js panels in XTermShell.tsx (pass theme object to Terminal constructor)
- *   - CLI ANSI output in agentsam-sdk (import ANSI constants)
- *   - Splash/HUD renders in both contexts
+ * @description Agent Sam terminal theme system — portable color and semantic
+ * status tokens for native ANSI output and browser/xterm consumers.
  *
- * Lane identity:
- *   LOCAL   → amber  (samsmac tunnel, darwin)
- *   CLOUD   → teal   (GCP platform_vm, iam-pty)
- *   SANDBOX → purple (CF container, isolated exec)
+ * Lane identity is intentionally provider-neutral:
+ *   LOCAL   → amber  (the user's current machine / real shell)
+ *   REMOTE  → teal   (a connected remote runtime, provider chosen by the host)
+ *   SANDBOX → purple (an isolated/disposable runtime, provider chosen by the host)
+ *
+ * Infrastructure names, domains, machine names, and account-specific routing
+ * never belong in this SDK theme. Hosts may supply their own runtime labels.
  *
  * No dependencies. ESM + CJS compatible (conditional exports in package.json).
  */
@@ -31,7 +31,7 @@ export const PALETTE = {
   ghost:       '#aaaaaa',
   white:       '#e8e8e8',
 
-  // LOCAL lane — amber/gold (samsmac, darwin_arm64)
+  // LOCAL lane — amber/gold (current machine / real shell)
   amber900:    '#0d0900',
   amber800:    '#1a1200',
   amber700:    '#2d1f00',
@@ -43,7 +43,7 @@ export const PALETTE = {
   amber100:    '#fde68a',
   amber050:    '#fef3c7',
 
-  // CLOUD lane — teal/cyan (GCP, iam-pty, platform_vm)
+  // REMOTE lane — teal/cyan (provider-neutral connected runtime)
   teal900:     '#000d0b',
   teal800:     '#001a17',
   teal700:     '#002e28',
@@ -55,7 +55,7 @@ export const PALETTE = {
   teal100:     '#99f6e4',
   teal050:     '#ccfbf1',
 
-  // SANDBOX lane — purple (CF container, isolated build exec)
+  // SANDBOX lane — purple (provider-neutral isolated runtime)
   purple900:   '#06020d',
   purple800:   '#0d0520',
   purple700:   '#1e0a3d',
@@ -130,26 +130,26 @@ const makeLane = ({ bg, bgSubtle, primary, secondary, dim, accent, name, label,
 });
 
 // ─────────────────────────────────────────────────────────────────────────────
-// THE THREE LANES
+// PORTABLE EXECUTION LANES
 // ─────────────────────────────────────────────────────────────────────────────
 
 export const LOCAL = makeLane({
   name: 'local', label: 'Local', icon: '◈',
-  tunnelHint: 'samsmac → localpty.inneranimalmedia.com',
+  tunnelHint: 'current machine · real shell',
   bg: '#0d0900', bgSubtle: '#1a1200',
   primary: '#f59e0b', secondary: '#fbbf24', dim: '#78450a', accent: '#22d3c8',
 });
 
 export const CLOUD = makeLane({
-  name: 'cloud', label: 'Cloud', icon: '●',
-  tunnelHint: 'inneranimalmedia → terminal.inneranimalmedia.com (GCP iam-tunnel)',
+  name: 'remote', label: 'Remote', icon: '●',
+  tunnelHint: 'connected remote runtime',
   bg: '#000d0b', bgSubtle: '#001a17',
   primary: '#22d3c8', secondary: '#5eead4', dim: '#065f52', accent: '#f59e0b',
 });
 
 export const SANDBOX = makeLane({
   name: 'sandbox', label: 'Sandbox', icon: '◌',
-  tunnelHint: 'CF Container → MY_CONTAINER DO (inneranimalmedia)',
+  tunnelHint: 'isolated disposable runtime',
   bg: '#06020d', bgSubtle: '#0d0520',
   primary: '#a78bfa', secondary: '#c4b5fd', dim: '#4c1d95', accent: '#22d3c8',
 });
@@ -173,11 +173,12 @@ export function getLaneTheme(targetType) {
 
 /**
  * Get lane theme by name string (for SDK CLI use).
- * @param {'local'|'cloud'|'sandbox'|string} name
+ * @param {'local'|'remote'|'cloud'|'sandbox'|string} name
  */
 export function getLaneThemeByName(name) {
   switch (name?.toLowerCase()) {
     case 'local':   return LOCAL;
+    case 'remote':
     case 'cloud':   return CLOUD;
     case 'sandbox': return SANDBOX;
     default:        return CLOUD;

package/test/app-building-skills.test.mjs

@@ -0,0 +1,61 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { getSkill, listSkills, loadSkill } from '../src/skills/index.js';
+
+const root = path.resolve(import.meta.dirname, '..');
+const cli = path.join(root, 'src', 'cli.js');
+
+test('application fundamentals and progression guard are portable registered skills', () => {
+  const ids = new Set(listSkills().map((skill) => skill.id));
+  assert.ok(ids.has('agentsam-app-fundamentals'));
+  assert.ok(ids.has('agentsam-progression-guard'));
+  assert.equal(getSkill('quick-bytes')?.id, 'agentsam-app-fundamentals');
+  assert.equal(getSkill('no-regress')?.id, 'agentsam-progression-guard');
+
+  const fundamentals = loadSkill('quick-bytes', { references: true });
+  assert.equal(fundamentals.references.length, 2);
+  assert.match(fundamentals.instructions, /Credentialed-destination card/);
+  assert.match(fundamentals.instructions, /AST/);
+  assert.match(fundamentals.instructions, /Merkle/);
+  assert.match(fundamentals.instructions, /Firewall\/WAF/);
+  assert.match(fundamentals.references[0].content, /OAuth redirect mental model/);
+  assert.match(fundamentals.references[1].content, /The codebase is a graph/);
+
+  const guard = loadSkill('no-regress', { references: true });
+  assert.equal(guard.references.length, 2);
+  assert.match(guard.instructions, /failed candidate must not advance the last-known-good baseline/);
+  assert.match(guard.instructions, /agentsam deploy-receipt capture/);
+  assert.match(guard.references[0].content, /Gate 6 — postdeploy/);
+  assert.match(guard.references[1].content, /Ingress versus egress hooks/);
+});
+
+test('skills CLI lists compact cards and loads quick reminders by alias', () => {
+  const listed = spawnSync(process.execPath, [cli, 'skills', '--json'], { cwd: root, encoding: 'utf8' });
+  assert.equal(listed.status, 0, listed.stderr);
+  const catalog = JSON.parse(listed.stdout);
+  assert.ok(catalog.some((skill) => skill.id === 'agentsam-app-fundamentals'));
+  assert.ok(catalog.some((skill) => skill.id === 'agentsam-progression-guard'));
+
+  const loaded = spawnSync(process.execPath, [cli, 'skills', 'quick-bytes'], { cwd: root, encoding: 'utf8' });
+  assert.equal(loaded.status, 0, loaded.stderr);
+  assert.match(loaded.stdout, /# AgentSam Application Fundamentals/);
+  assert.doesNotMatch(loaded.stdout, /# Trust, Credentials, and Credentialed Destinations/);
+
+  const full = spawnSync(process.execPath, [cli, 'skills', 'no-regress', '--references'], { cwd: root, encoding: 'utf8' });
+  assert.equal(full.status, 0, full.stderr);
+  assert.match(full.stdout, /# AgentSam Progression Guard/);
+  assert.match(full.stdout, /# Checkpoint Chain/);
+  assert.match(full.stdout, /# Hooks and Operational I\/O/);
+});
+
+test('portable npm package still owns all skill files', () => {
+  const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+  assert.ok(pkg.files.includes('skills'));
+  for (const rel of [
+    'skills/agentsam-app-fundamentals/SKILL.md',
+    'skills/agentsam-progression-guard/SKILL.md',
+  ]) assert.equal(fs.existsSync(path.join(root, rel)), true, `${rel} must exist`);
+});

package/test/apps-scaffold-contract.test.mjs

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const productApps = ['local-studio', 'cad-creator', 'client-cms-editor'];
+const at = (...parts) => path.join(root, ...parts);
+const exists = (...parts) => fs.existsSync(at(...parts));
+
+function packageJson(...parts) {
+  return JSON.parse(fs.readFileSync(at(...parts, 'package.json'), 'utf8'));
+}
+
+test('product apps are self-contained npm workspace roots with one lockfile', () => {
+  for (const app of productApps) {
+    const base = ['apps', app];
+    assert.ok(exists(...base, 'package.json'), `${app}: root package.json`);
+    assert.ok(exists(...base, 'package-lock.json'), `${app}: root package-lock.json`);
+    assert.ok(exists(...base, 'frontend', 'package.json'), `${app}: frontend package`);
+    assert.ok(exists(...base, 'backend', 'package.json'), `${app}: backend package`);
+    assert.equal(exists(...base, 'frontend', 'package-lock.json'), false, `${app}: no frontend lockfile`);
+    assert.equal(exists(...base, 'backend', 'package-lock.json'), false, `${app}: no backend lockfile`);
+
+    const pkg = packageJson(...base);
+    assert.deepEqual(pkg.workspaces, ['frontend', 'backend', 'shared/*'], `${app}: canonical workspace list`);
+  }
+});
+
+test('every product app owns its Cloudflare boundary under backend/', () => {
+  for (const app of productApps) {
+    const base = ['apps', app, 'backend'];
+    assert.ok(exists(...base, 'worker', 'index.js'), `${app}: backend/worker/index.js`);
+    assert.ok(exists(...base, 'wrangler.jsonc'), `${app}: backend/wrangler.jsonc`);
+    const wrangler = fs.readFileSync(at(...base, 'wrangler.jsonc'), 'utf8');
+    assert.match(wrangler, /"main"\s*:\s*"worker\/index\.js"/, `${app}: wrangler main`);
+  }
+});
+
+test('SDK root is package tooling only and does not own an app Worker', () => {
+  assert.equal(exists('wrangler.jsonc'), false);
+  assert.equal(exists('worker', 'index.js'), false);
+  assert.equal(exists('scripts', 'with-cloudflare-env.sh'), false);
+
+  const rootPkg = packageJson();
+  for (const workspace of rootPkg.workspaces || []) {
+    assert.equal(workspace.startsWith('apps/'), false, `root workspace must not absorb app workspace: ${workspace}`);
+  }
+});
+
+test('Local Studio retired donor-era duplicate deployment configs', () => {
+  for (const file of ['wrangler.ui.toml', 'wrangler.workmode.toml', 'wrangler.toml.example']) {
+    assert.equal(exists('apps', 'local-studio', 'backend', file), false, `retire ${file}`);
+  }
+});

package/test/capabilities.test.mjs

@@ -6,6 +6,7 @@ import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { getCapability, getCapabilityManifest, repositorySnapshot } from '../src/capabilities/index.js';
 import { getPreset, resolvePreset } from '../src/presets/index.js';
+import { scanTrustBoundary } from '../src/security/trust-boundary.js';
 
 const CLI = path.resolve('src/cli.js');
 
@@ -51,11 +52,51 @@ test('repository.snapshot composes deterministic evidence and content addressing
   assert.equal(one.snapshot_id, two.snapshot_id);
   assert.equal(one.repository.revision_sha, git(root, ['rev-parse', 'HEAD']));
   assert.ok(one.tree.merkle_root);
+  assert.match(one.tree.metadata_root, /^sha256:[a-f0-9]{64}$/);
+  assert.equal(one.tree.manifest.format, 'agentsam-merkle');
+  assert.equal(one.tree.manifest.version, 1);
+  assert.equal(one.tree.manifest.hash_algorithm, 'sha256');
+  assert.match(one.tree.manifest.policy_hash, /^sha256:[a-f0-9]{64}$/);
+  assert.equal(one.tree.classifier.format, 'agentsam-filemeta');
+  assert.equal(one.tree.classifier.version, 1);
+  const source = one.tree.files.find((entry) => entry.path === 'src/index.js');
+  assert.equal(source.mode, 420);
+  assert.equal(source.system, 'snapshot-fixture');
+  assert.equal(source.language, 'javascript');
+  assert.deepEqual(source.symbols, ['value']);
+  assert.equal(one.analysis.trust_boundary.analyzer, 'agentsam-execution-boundary');
+  assert.equal(one.analysis.trust_boundary.metadata_root, one.tree.metadata_root);
+  assert.equal(one.analysis.trust_boundary.complete, true);
+  assert.equal(one.analysis.trust_boundary.status, 'clean');
   assert.ok(one.intelligence.summary.file_count >= 2);
   assert.equal(one.packages[0].name, 'snapshot-fixture');
   assert.equal(one.knowledge.configured, false);
 });
 
+test('repository inspection and security scan share one Git-ignore/Merkle trust authority', async t => {
+  const root = fixture();
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  fs.mkdirSync(path.join(root, 'frontend'));
+  fs.mkdirSync(path.join(root, 'backend'));
+  fs.mkdirSync(path.join(root, 'ignored'));
+  fs.writeFileSync(path.join(root, 'frontend', 'client.ts'), "import { secretValue } from '../backend/secrets.ts';\nexport const value = secretValue;\n");
+  fs.writeFileSync(path.join(root, 'backend', 'secrets.ts'), "export const secretValue = process.env.API_KEY;\n");
+  fs.writeFileSync(path.join(root, 'ignored', 'noise.ts'), "import fs from 'node:fs'; export const x = process.env.PRIVATE_TOKEN + String(fs);\n");
+  fs.writeFileSync(path.join(root, '.gitignore'), 'ignored/\n');
+
+  const snapshot = await repositorySnapshot({ cwd: root, churnDays: 30 });
+  const boundary = await scanTrustBoundary(root);
+  assert.equal(snapshot.tree.metadata_root, boundary.metadata_root);
+  assert.equal(snapshot.tree.merkle_root, boundary.merkle_root);
+  assert.equal(snapshot.analysis.trust_boundary.status, 'action-required');
+  assert.deepEqual(
+    snapshot.analysis.trust_boundary.findings.map((item) => [item.kind, item.source, item.target]),
+    boundary.findings.map((item) => [item.kind, item.source, item.target]),
+  );
+  assert.equal(snapshot.tree.paths.some((value) => value.startsWith('ignored/')), false);
+  assert.equal(boundary.findings.some((item) => item.source.startsWith('ignored/')), false);
+});
+
 test('product UX creates a preset project, adds a feature, and inspects before first commit', t => {
   const parent = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-product-'));
   t.after(() => fs.rmSync(parent, { recursive: true, force: true }));
@@ -65,10 +106,15 @@ test('product UX creates a preset project, adds a feature, and inspects before f
   });
   const project = path.join(parent, 'demo');
   const config = JSON.parse(fs.readFileSync(path.join(project, '.agentsam', 'config.json'), 'utf8'));
-  assert.equal(config.preset, 'cms');
-  assert.equal(config.lane, 'cms');
-  assert.deepEqual(config.features, ['cms', 'knowledge']);
-  assert.ok(config.capabilities.includes('repository.snapshot'));
+  assert.equal(config.schema_version, 2);
+  assert.equal(config.project.name, 'demo');
+  assert.equal(config.product.preset, 'cms');
+  assert.deepEqual(config.product.features, ['cms', 'knowledge']);
+  assert.ok(config.product.capabilities.includes('repository.snapshot'));
+  assert.match(config.repository.id, /^local:[0-9a-f-]{36}$/);
+  assert.equal(config.defaults.runtime, 'local');
+  assert.equal(config.defaults.model, 'auto');
+  assert.equal(fs.existsSync(path.join(project, 'agentsam.config.js')), false);
 
   execFileSync(process.execPath, [CLI, 'add', 'knowledge', '--cwd', project, '--json'], { stdio: 'pipe' });
   const features = JSON.parse(fs.readFileSync(path.join(project, '.agentsam', 'features.json'), 'utf8'));
@@ -79,6 +125,9 @@ test('product UX creates a preset project, adds a feature, and inspects before f
     stdio: ['ignore', 'pipe', 'pipe'],
   }));
   assert.equal(snapshot.capability, 'repository.snapshot');
+  assert.equal(snapshot.repository.repository_id, config.repository.id);
+  assert.equal(snapshot.repository.identity_source, 'project-config');
   assert.equal(snapshot.repository.revision_sha, null);
   assert.ok(snapshot.tree.stats.files > 0);
+  assert.ok(snapshot.analysis?.trust_boundary);
 });

package/test/cli-preferences.test.mjs

@@ -0,0 +1,25 @@
+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 { CLI_PREFERENCES_SCHEMA, detectCliProject, readCliPreferences, writeCliPreferences } from '../src/lib/cli-preferences.js';
+import { renderBootSummary } from '../src/ui/boot.js';
+
+test('CLI preferences are project-local and explicitly non-authoritative for routing', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-cli-prefs-'));
+  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'demo-project' }));
+  const written = writeCliPreferences(root, { runtime: 'sandbox', terminal: 'zsh', modelPreference: 'ollama:qwen2.5-coder' });
+  assert.equal(written.schemaVersion, CLI_PREFERENCES_SCHEMA);
+  assert.equal(written.modelAuthority, 'preference-only');
+  assert.deepEqual(readCliPreferences(root), written);
+
+  const identity = detectCliProject(root);
+  assert.equal(identity.project, 'demo-project');
+  assert.equal(identity.root, root);
+
+  const summary = renderBootSummary({ identity, preferences: written });
+  assert.match(summary, /Agent Sam/);
+  assert.match(summary, /demo-project/);
+  assert.match(summary, /qwen2\.5-coder/);
+});