@inneranimalmedia/agentsam-sdk 2.6.1 → 2.6.3

package/src/ui/cli/activity.js

@@ -2,10 +2,60 @@ import pc from 'picocolors';
 
 const CLEAR_LINE = '\x1b[2K';
 const SPINNER = ['◐', '◓', '◑', '◒'];
+export const INTERRUPT_HINT = 'ctrl-c to cancel';
 
 function elapsed(ms) {
   if (ms < 1000) return `${Math.max(0, Math.round(ms))}ms`;
-  return `${(ms / 1000).toFixed(ms < 10_000 ? 1 : 0)}s`;
+  if (ms < 60_000) return `${(ms / 1000).toFixed(ms < 10_000 ? 1 : 0)}s`;
+  const m = Math.floor(ms / 60_000);
+  const s = Math.floor((ms % 60_000) / 1000);
+  return `${m}m ${String(s).padStart(2, '0')}s`;
+}
+
+function count(value) {
+  const n = Number(value || 0);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(n >= 10_000_000 ? 0 : 1)}m`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(n >= 100_000 ? 0 : 1)}k`;
+  return String(Math.round(n));
+}
+
+export function colorAllowed(env = process.env) {
+  if (!env || Object.hasOwn(env, 'NO_COLOR')) return false;
+  if (String(env.FORCE_COLOR || '') === '0') return false;
+  return true;
+}
+
+export function colorDepth(env = process.env) {
+  if (!colorAllowed(env)) return 0;
+  const colorterm = String(env.COLORTERM || '').toLowerCase();
+  if (colorterm.includes('truecolor') || colorterm.includes('24bit')) return 24;
+  if (String(env.TERM || '').includes('direct')) return 24;
+  return 8;
+}
+
+export function renderShimmer(text, tick = 0, options = {}) {
+  const env = options.env || process.env;
+  const source = String(text ?? '');
+  if (!source) return '';
+  const depth = colorDepth(env);
+  if (depth === 0) return source;
+  const chars = [...source];
+  const highlight = Math.max(3, Math.min(6, chars.length));
+  const origin = ((Number(tick) || 0) % (chars.length + highlight)) - highlight;
+  const painted = chars.map((ch, index) => {
+    const dist = index - origin;
+    const t = dist < 0 || dist > highlight ? 0 : 1 - Math.abs((dist / highlight) - 0.5) * 2;
+    if (depth >= 24) {
+      const r = Math.round(34 + t * 180);
+      const g = Math.round(180 + t * 75);
+      const b = Math.round(220 + t * 35);
+      return `\x1b[38;2;${r};${g};${b}m${ch}\x1b[39m`;
+    }
+    const code = t > 0.6 ? 159 : t > 0.2 ? 87 : 37;
+    return `\x1b[38;5;${code}m${ch}\x1b[39m`;
+  }).join('');
+  return `${painted}\x1b[0m`;
 }
 
 export function createInlineActivity(options = {}) {
@@ -15,17 +65,33 @@ export function createInlineActivity(options = {}) {
   const setTimer = options.setInterval || globalThis.setInterval;
   const clearTimer = options.clearInterval || globalThis.clearInterval;
   const intervalMs = Math.max(80, Number(options.intervalMs) || 120);
+  const interruptible = options.interruptible !== false;
+  const env = options.env || process.env;
 
-  let label = String(options.label || 'Thinking');
+  let label = String(options.label || 'Running');
   let startedAt = 0;
   let tick = 0;
   let timer = null;
   let active = false;
+  let tokenTotal = Number(options.tokenTotal) || 0;
+
+  function paint(kind, value) {
+    if (!colorAllowed(env)) return value;
+    if (kind === 'cyan') return pc.cyan(value);
+    if (kind === 'red') return pc.red(value);
+    if (kind === 'green') return pc.green(value);
+    return pc.dim(value);
+  }
 
   function frame() {
     if (!active || !interactive) return;
-    const icon = pc.cyan(SPINNER[tick % SPINNER.length]);
-    write(`\r${CLEAR_LINE}  ${icon} ${label} ${pc.dim('· ' + elapsed(now() - startedAt))}`);
+    const icon = paint('cyan', SPINNER[tick % SPINNER.length]);
+    const parts = [elapsed(now() - startedAt)];
+    const tokens = count(tokenTotal);
+    if (tokens) parts.unshift(`${tokens} tokens`);
+    if (interruptible) parts.push(INTERRUPT_HINT);
+    const paintedLabel = renderShimmer(label, tick, { env });
+    write(`\r${CLEAR_LINE}  ${icon} ${paintedLabel} ${paint('dim', '· ' + parts.join(' · '))}`);
     tick += 1;
   }
 
@@ -43,8 +109,9 @@ export function createInlineActivity(options = {}) {
     }
   }
 
-  function update(nextLabel) {
+  function update(nextLabel, nextTokens) {
     if (nextLabel) label = String(nextLabel);
+    if (Number.isFinite(Number(nextTokens))) tokenTotal = Number(nextTokens);
     if (!active) start(label);
     else frame();
   }
@@ -55,8 +122,9 @@ export function createInlineActivity(options = {}) {
     timer = null;
     const duration = elapsed(now() - startedAt);
     if (interactive) write(`\r${CLEAR_LINE}`);
-    const icon = status === 'error' ? pc.red('✗') : pc.green('✓');
-    write(`  ${icon} ${finalLabel} ${pc.dim('· ' + duration)}\n`);
+    const icon = status === 'error' ? paint('red', '✗') : paint('green', '✓');
+    const tokens = count(tokenTotal);
+    write(`  ${icon} ${finalLabel} ${paint('dim', '· ' + [tokens ? `${tokens} tokens` : null, duration].filter(Boolean).join(' · '))}\n`);
     active = false;
   }
 
@@ -64,6 +132,7 @@ export function createInlineActivity(options = {}) {
     get active() { return active; },
     start,
     update,
+    setTokens(value) { update(null, value); },
     succeed(labelText) { finish('success', labelText || label); },
     fail(labelText) { finish('error', labelText || 'Failed'); },
     clear() {

package/src/ui/cli/footer.js

@@ -21,19 +21,120 @@ function ctxLabel(usage) {
   return `ctx ${Math.min(999, Math.round((active / window) * 100))}%`;
 }
 
+function money(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return null;
+  return `$${n.toFixed(n >= 1 ? 2 : 3)}`;
+}
+
+export const FOOTER_HINTS = '/ commands · @ files · ! shell · ctrl-c to cancel';
+
 export function renderCliFooter(value = {}) {
   const usage = value.usage || value.usageSnapshot || {};
   const cumulative = usage.cumulative || {};
   const model = String(value.model || value.modelLabel || 'model');
+  const provider = String(value.provider || '').trim();
+  const effort = String(value.effort || value.reasoning || '').trim();
   const tier = String(value.tier || '').trim();
+  const projectName = String(value.projectName || value.identity || (value.cwd ? value.project : '') || '').trim();
+  const branch = String(value.branch || value.gitBranch || '').trim();
+  const cwd = String(value.cwd || (!value.projectName && !value.identity ? value.project : '') || '').trim();
+  const action = String(value.action || value.statusLabel || '').trim();
+  const filesEdited = Number(value.filesEdited || value.files_edited || 0);
   const elapsedMs = Number(value.elapsedMs);
-  const parts = [
-    model,
-    ctxLabel(usage),
-    `↑${count(cumulative.input_tokens)} ↓${count(cumulative.output_tokens)}`,
-  ];
-  if (Number(cumulative.cached_input_tokens) > 0) parts.push(`cache ${count(cumulative.cached_input_tokens)}`);
-  if (tier && tier !== 'default') parts.push(tier);
-  if (Number.isFinite(elapsedMs) && elapsedMs >= 0) parts.push(elapsedMs < 60_000 ? `${(elapsedMs / 1000).toFixed(1)}s` : `${Math.floor(elapsedMs / 60_000)}m${Math.floor((elapsedMs % 60_000) / 1000)}s`);
-  return pc.dim('  ' + parts.join(' · '));
+  const cost = money(value.cost ?? cumulative.cost_usd ?? usage.cost_usd);
+
+  const primary = [];
+  if (projectName) primary.push(projectName);
+  if (branch) primary.push(branch);
+  if (cwd) primary.push(cwd.replace(String(process.env.HOME || ''), '~'));
+  if (action) primary.push(action);
+  primary.push([provider, model, effort].filter(Boolean).join(' ') || model);
+  primary.push(ctxLabel(usage));
+  primary.push(`↑${count(cumulative.input_tokens)} ↓${count(cumulative.output_tokens)}`);
+  if (Number(cumulative.cached_input_tokens) > 0) primary.push(`cache ${count(cumulative.cached_input_tokens)}`);
+  if (filesEdited > 0) primary.push(`${filesEdited} files edited`);
+  if (cost) primary.push(cost);
+  if (tier && tier !== 'default') primary.push(tier);
+  if (Number.isFinite(elapsedMs) && elapsedMs >= 0) {
+    primary.push(elapsedMs < 60_000 ? `${(elapsedMs / 1000).toFixed(1)}s` : `${Math.floor(elapsedMs / 60_000)}m${Math.floor((elapsedMs % 60_000) / 1000)}s`);
+  }
+
+  const hints = String(value.hints || FOOTER_HINTS);
+  return [
+    pc.dim('  ' + primary.join(' · ')),
+    pc.dim('  ' + hints),
+  ].join('\n');
+}
+
+export function renderDiffPreview(diffText, options = {}) {
+  const source = String(diffText || '');
+  const color = options.color ?? !Object.hasOwn(process.env, 'NO_COLOR');
+  const paint = (text, style) => {
+    if (!color) return text;
+    const code = style === 'add' ? '32' : style === 'del' ? '31' : style === 'hunk' ? '36' : style === 'meta' ? '1' : '2';
+    return `\x1b[${code}m${text}\x1b[0m`;
+  };
+  if (!source.trim()) return `  ${paint('no changes', 'dim')}\n`;
+  const maxLines = Math.max(20, Number(options.maxLines) || 200);
+  const lines = source.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+  const truncated = lines.length > maxLines;
+  const shown = truncated ? lines.slice(0, maxLines) : lines;
+  const out = shown.map((line) => {
+    if (line.startsWith('diff ') || line.startsWith('index ') || line.startsWith('+++') || line.startsWith('---')) {
+      return `  ${paint(line, 'meta')}`;
+    }
+    if (line.startsWith('@@')) return `  ${paint(line, 'hunk')}`;
+    if (line.startsWith('+')) return `  ${paint(line, 'add')}`;
+    if (line.startsWith('-')) return `  ${paint(line, 'del')}`;
+    return `  ${line}`;
+  });
+  if (truncated) out.push(`  ${paint(`… ${lines.length - maxLines} more lines`, 'dim')}`);
+  return `${out.join('\n')}\n`;
+}
+
+export function renderUsagePanel(value = {}) {
+  const session = value.session || {};
+  const usage = value.usage || value.usageSnapshot || session.usage_snapshot || {};
+  const cumulative = usage.cumulative || session.cumulative_usage || {};
+  const current = usage.current_context || {};
+  const lines = [];
+  const push = (label, text) => lines.push(`  ${pc.dim(label.padEnd(12))} ${text}`);
+
+  lines.push('');
+  lines.push(`  ${pc.bold('AgentSam · Usage')}`);
+  lines.push('');
+  push('session', session.id || session.session_id || 'unknown');
+  push('provider', value.provider || session.provider || (String(session.model_key || '').split(':')[0]) || 'unknown');
+  push('model', value.model || session.model || session.model_key || 'unknown');
+  push('reasoning', value.effort || session.reasoning_effort || 'unknown/unavailable');
+  push('tier', value.tier || session.service_tier || 'unknown/unavailable');
+  lines.push('');
+  const window = Number(current.window_tokens || 0);
+  const active = Number(current.input_tokens || 0);
+  push(
+    'context',
+    window > 0
+      ? `${count(active)} / ${count(window)} · ${Math.round((active / window) * 1000) / 10}%`
+      : active > 0
+        ? `${count(active)} / unknown`
+        : 'unknown/unavailable',
+  );
+  push('input', count(cumulative.input_tokens));
+  push('output', count(cumulative.output_tokens));
+  push('cached', Number(cumulative.cached_input_tokens) > 0 ? count(cumulative.cached_input_tokens) : 'unknown/unavailable');
+  lines.push('');
+  push('cost', money(value.cost ?? cumulative.cost_usd ?? session.total_cost_usd) || 'unknown/unavailable');
+  push('elapsed', value.elapsedLabel || (Number.isFinite(Number(value.elapsedMs)) ? `${Math.round(Number(value.elapsedMs) / 1000)}s` : 'unknown/unavailable'));
+  push('tool calls', value.toolCalls != null ? String(value.toolCalls) : 'unknown/unavailable');
+  push('shell', value.shellCommands != null ? String(value.shellCommands) : 'unknown/unavailable');
+  push('files', value.filesEdited != null ? `${value.filesEdited} edited` : 'unknown/unavailable');
+  push('compactions', value.compactions != null ? String(value.compactions) : 'unknown/unavailable');
+  lines.push('');
+  push('accounting', usage.estimate_kind || value.estimateKind || 'unknown/unavailable');
+  if (session.id || session.session_id) {
+    push('resume', `agentsam resume ${session.id || session.session_id}`);
+  }
+  lines.push('');
+  return lines.join('\n');
 }

package/src/ui/cli/help.js

@@ -12,7 +12,8 @@ const HELP_TOPICS = Object.freeze([
       ['agentsam resume [session]', 'Resume a saved Agent Sam session'],
       ['agentsam whoami', 'Show authenticated account and credential status'],
       ['agentsam models', 'Probe account-visible hosted/local models'],
-      ['agentsam env init <provider>', 'Create a secure local provider profile'],
+      ['agentsam providers', 'Configure and verify machine provider credentials'],
+      ['agentsam env init <provider>', 'Low-level provider profile compatibility command'],
     ],
   },
   {
@@ -33,12 +34,15 @@ const HELP_TOPICS = Object.freeze([
     label: 'Runtime / terminal',
     summary: 'Local, remote, sandbox, and deployment controls.',
     rows: [
-      ['agentsam status', 'Project, Git, DB, API, and PTY status'],
+      ['agentsam status', 'Honest awareness (account, models, terminal, live deploy) · -i menu'],
       ['agentsam start-local', 'Start the local PTY service'],
       ['agentsam connections', 'Inspect available execution connections'],
-      ['agentsam tunnel', 'Expose local PTY only when remote access is wanted'],
+      ['agentsam tunnel', 'List, inspect, and run real Cloudflare Tunnels through Wrangler'],
+      ['agentsam mcp <add|status|doctor|list|remove>', 'Manage MCP connections, server catalogs, and client adapters'],
+      ['agentsam eval <context|live>', 'Deterministic context scoring or live agent evaluation telemetry'],
       ['agentsam deploy', 'Graduate intentionally to cloud infrastructure'],
       ['agentsam cloudflare', 'Wrangler and Cloudflare runtime diagnostics'],
+      ['agentsam go', 'Go runtime discovery, build, Cloudflare container deploy, D1 registry'],
     ],
   },
   {
@@ -48,10 +52,13 @@ const HELP_TOPICS = Object.freeze([
     rows: [
       ['/', 'Open the keyboard command picker'],
       ['/model', 'Choose model, reasoning, and processing tier'],
+      ['/providers', 'Configure and verify machine provider credentials'],
       ['/context', 'Show live context economics'],
       ['/usage', 'Show token/cost/session receipt'],
       ['/settings', 'Change runtime, terminal, and model policy'],
-      ['/status', 'Show project/runtime health'],
+      ['/status', 'Honest project awareness + next-step tips'],
+      ['/connections', 'Inspect live account, terminal, Worker, and Cloudflare connection evidence'],
+      ['/tunnel', 'Choose an existing Cloudflare Tunnel and inspect or run it through Wrangler'],
       ['/help [topic]', 'Show in-session help'],
       ['/exit', 'Return to the host shell'],
     ],
@@ -66,6 +73,7 @@ const HELP_TOPICS = Object.freeze([
       ['agentsam capabilities [id]', 'Inspect capability contracts'],
       ['agentsam skills [id]', 'Inspect packaged skills'],
       ['agentsam identity init', 'Add reusable identity surfaces'],
+      ['agentsam scaffold <cms|worker-api>', 'Generate a Cloudflare starter project'],
       ['agentsam dockerize', 'Build supported container targets'],
     ],
   },
@@ -75,6 +83,7 @@ const TOPIC_ALIASES = new Map([
   ['models', 'start'], ['model', 'start'], ['provider', 'start'], ['providers', 'start'], ['resume', 'start'],
   ['repo', 'work'], ['repository', 'work'], ['inspect', 'work'], ['index', 'work'], ['security', 'work'],
   ['terminal', 'runtime'], ['connections', 'runtime'], ['remote', 'runtime'], ['sandbox', 'runtime'], ['deploy', 'runtime'],
+  ['mcp', 'runtime'], ['eval', 'runtime'],
   ['slash', 'inside'], ['commands', 'inside'], ['session', 'inside'], ['usage', 'inside'], ['context', 'inside'],
   ['create', 'create'], ['scaffold', 'create'], ['capabilities', 'create'], ['skills', 'create'],
 ]);
@@ -151,7 +160,7 @@ export async function runHelp(argv = [], options = {}) {
   const write = options.write || ((value) => process.stdout.write(value));
   const args = argv.filter((arg) => arg !== '--interactive');
 
-  if (args.includes('--all')) {
+  if (args.includes('--all') || args.some((arg) => clean(arg) === 'all')) {
     write(renderAllHelp(version));
     return;
   }

package/src/ui/wireframes.js

@@ -0,0 +1,166 @@
+import pc from 'picocolors';
+
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+export function visibleLength(value) {
+  return String(value ?? '').replace(ANSI_RE, '').length;
+}
+
+export function padVisible(value, width, align = 'left') {
+  const text = String(value ?? '');
+  const len = visibleLength(text);
+  const pad = Math.max(0, width - len);
+  if (align === 'right') return `${' '.repeat(pad)}${text}`;
+  if (align === 'center') {
+    const left = Math.floor(pad / 2);
+    return `${' '.repeat(left)}${text}${' '.repeat(pad - left)}`;
+  }
+  return `${text}${' '.repeat(pad)}`;
+}
+
+export function drawBox(rows, { width = 64, title = '', color = pc.cyan } = {}) {
+  const inner = Math.max(24, width - 2);
+  const titleText = title ? ` ${title} ` : '';
+  const titlePad = Math.max(0, inner - visibleLength(titleText));
+  const lines = [
+    `${color('┌')}${color(titleText)}${color('─'.repeat(titlePad))}${color('┐')}`,
+  ];
+  for (const row of rows) {
+    if (row === '─') {
+      lines.push(`${color('├')}${color('─'.repeat(inner))}${color('┤')}`);
+      continue;
+    }
+    lines.push(`${color('│')}${padVisible(row, inner)}${color('│')}`);
+  }
+  lines.push(`${color('└')}${color('─'.repeat(inner))}${color('┘')}`);
+  return lines.join('\n');
+}
+
+/**
+ * Architecture explorer — reasoning wireframe, not pixels.
+ * Left: tree. Right: package ownership + dependency map.
+ */
+export function renderArchitectureExplorer(input = {}) {
+  const repo = input.repo || 'repository';
+  const git = input.git || { branch: 'main', dirty: false };
+  const tree = input.tree || ['apps/', 'packages/', 'protocol/', 'src/', 'tooling/'];
+  const focus = input.focus || {
+    package: 'protocol',
+    owns: 'wire contracts',
+    runtime: 'none / generated',
+    imported_by: 'client, server, runtime',
+    files: '.proto .ts .rs generated/...',
+  };
+  const deps = input.deps || ['protocol ── client ── app', '            ▲', '            └──── server'];
+  const tabs = input.tabs || ['contracts', 'runtime', 'persistence', 'commands', 'ownership'];
+  const leftW = 18;
+  const rightW = 40;
+  const width = leftW + rightW + 3;
+
+  const header = ` ${repo}  ${git.branch || 'main'} ${git.dirty ? 'dirty' : 'clean'} `;
+  const rows = ['─'];
+  const maxRows = Math.max(tree.length, 6 + deps.length);
+  for (let i = 0; i < maxRows; i += 1) {
+    const left = padVisible(tree[i] ? ` ${tree[i]}` : '', leftW);
+    let right = '';
+    if (i === 0) right = ` package: ${focus.package}`;
+    else if (i === 1) right = ` ${'─'.repeat(Math.min(37, rightW - 2))}`;
+    else if (i === 2) right = ` owns: ${focus.owns}`;
+    else if (i === 3) right = ` runtime: ${focus.runtime}`;
+    else if (i === 4) right = ` imported by: ${focus.imported_by}`;
+    else if (i === 5) right = ' DEPENDENCY MAP';
+    else if (i >= 6 && deps[i - 6]) right = ` ${deps[i - 6]}`;
+    rows.push(`${left}${pc.dim('│')}${padVisible(right, rightW)}`);
+  }
+  rows.push('─');
+  rows.push(` Files: ${focus.files || ''}`);
+  rows.push('─');
+  rows.push(` ${tabs.map((t) => `[${t}]`).join(' ')}`);
+
+  return drawBox(rows, { width, title: header.trim(), color: pc.cyan });
+}
+
+/**
+ * Operation inspector — intent → validate → execute → persist → notify.
+ */
+export function renderOperationInspector(input = {}) {
+  const op = input.operation || 'operation';
+  const opId = input.op_id || 'op_…';
+  const stages = input.stages || ['intent', 'validate', 'execute', 'persist', 'notify'];
+  const actors = input.actors || ['user/agent', 'policy', 'adapter', 'artifact', 'event bus'];
+  const active = Math.max(0, Math.min(stages.length - 1, Number(input.active_index) || 0));
+  const step = input.step || null;
+  const receipt = input.receipt || {};
+
+  const dots = stages.map((_, i) => (i <= active ? pc.green('●') : pc.dim('○'))).join(pc.dim('────────'));
+  const labels = stages.map((s) => padVisible(s, 10)).join(' ');
+  const actorLine = actors.map((a, i) => (i === active ? pc.bold(a) : pc.dim(a))).join(pc.dim('  │  '));
+
+  const rows = [
+    ` Operation: ${pc.bold(op)}  ${pc.dim(opId)}`,
+    '─',
+    ` ${labels}`,
+    ` ${dots}`,
+    ` ${actorLine}`,
+  ];
+  if (step) {
+    rows.push('─');
+    rows.push(` STEP · ${step.name || 'step'}`);
+    if (step.detail) rows.push(` ${pc.dim(step.detail)}`);
+    if (step.artifact) rows.push(` → ${step.artifact}`);
+  }
+  rows.push('─');
+  rows.push(' Receipt:');
+  for (const [key, value] of Object.entries(receipt)) {
+    rows.push(`  ${pc.dim(key + ':')} ${value}`);
+  }
+  return drawBox(rows, { width: 70, title: 'operation inspector', color: pc.magenta });
+}
+
+export function renderGoShipScenery({ product, discovery, deploy, build } = {}) {
+  const arch = renderArchitectureExplorer({
+    repo: 'agentsam-sdk',
+    git: discovery?.git || {},
+    tree: ['apps/', 'packages/', 'protocol/', 'src/go/', 'src/commands/', 'runtime/'],
+    focus: {
+      package: product || 'agentsam-go-worker',
+      owns: 'Go runtime + CF container edge',
+      runtime: 'go/native + worker',
+      imported_by: 'agentsam go, deploy adapter',
+      files: 'main.go wrangler.jsonc Dockerfile contracts/',
+    },
+    deps: [
+      'protocol/go ── src/go ── commands/go',
+      '                 ▲',
+      '                 └──── apps/agentsam-go-worker',
+    ],
+    tabs: ['contracts', 'runtime', 'persistence', 'commands', 'ownership'],
+  });
+
+  const stages = ['intent', 'validate', 'execute', 'persist', 'notify'];
+  let active = 1;
+  if (build?.receipt) active = 2;
+  if (deploy?.deployed || deploy?.skipped_deploy || deploy?.receipt) active = 3;
+  if (deploy?.probes?.ok || deploy?.productPath) active = 4;
+
+  const op = renderOperationInspector({
+    operation: 'go.cloudflare.ship',
+    op_id: product || 'agentsam-go-worker',
+    stages,
+    actors: ['CLI', 'go test', 'container', 'D1/R2 receipts', 'status'],
+    active_index: active,
+    step: {
+      name: 'native Go capability',
+      detail: 'hash + inspect over Worker → Container',
+      artifact: deploy?.url || 'local binary',
+    },
+    receipt: {
+      'source commit': build?.receipt?.source?.commit || discovery?.git?.commit || '—',
+      'build tests': build?.receipt?.tests?.go_test ? 'pass' : '—',
+      'live url': deploy?.url || '—',
+      health: deploy?.receipt?.health || (deploy?.probes?.ok ? 'healthy' : 'pending'),
+    },
+  });
+
+  return `${arch}\n\n${op}`;
+}

package/test/account-session.test.mjs

@@ -3,7 +3,16 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import test from 'node:test';
-import { accountSessionPath, clearAccountSession, readAccountSession, resolveAccountSdkKey, saveAccountSession } from '../src/lib/account-session.js';
+import {
+  accountSessionPath,
+  clearAccountSession,
+  readAccountSession,
+  resolveAccountApiKey,
+  resolveAccountAuth,
+  resolveBrowserSessionCredential,
+  saveAccountSession,
+} from '../src/lib/account-session.js';
+import { resolveAccountAuthority } from '../src/lib/auth.js';
 
 function tempHome(t) {
   const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-account-'));
@@ -11,26 +20,82 @@ function tempHome(t) {
   return home;
 }
 
-test('browser-auth SDK bearer persists in machine-local storage, not project state', t => {
+test('opaque browser login persists in machine-local storage and resolves independently from API keys', t => {
   const home = tempHome(t);
-  const saved = saveAccountSession({ access_token: 'sdk_machine_session', user_id: 'au_test', account_id: 'acct_test', email: 'dev@example.test' }, { home });
+  const saved = saveAccountSession({
+    access_token: 'browser_session_machine_test',
+    user_id: 'au_test',
+    account_id: 'acct_test',
+    email: 'dev@example.test',
+  }, { home });
   assert.equal(saved.user_id, 'au_test');
+
   const filename = accountSessionPath({ home });
   assert.equal(fs.existsSync(filename), true);
   if (process.platform !== 'win32') assert.equal(fs.statSync(filename).mode & 0o077, 0);
 
   const loaded = readAccountSession({ home });
-  assert.equal(loaded.sdk_key, 'sdk_machine_session');
-  const resolved = resolveAccountSdkKey({ env: {}, home });
-  assert.equal(resolved.source, 'agentsam_account_session');
-  assert.equal(resolved.value, 'sdk_machine_session');
+  assert.equal(loaded.access_token, 'browser_session_machine_test');
+  const browser = resolveBrowserSessionCredential({ env: {}, home });
+  assert.equal(browser.source, 'agentsam_browser_oauth');
+  assert.equal(browser.kind, 'browser_oauth');
+  assert.equal(browser.value, 'browser_session_machine_test');
+  assert.equal(resolveAccountApiKey({ env: {}, home }).value, '');
+  assert.equal(resolveAccountAuth({ env: {}, home }).value, 'browser_session_machine_test');
+
   assert.equal(clearAccountSession({ home }), true);
   assert.equal(readAccountSession({ home }), null);
 });
 
-test('explicit/environment SDK bearer remains higher authority than local session fallback', t => {
+test('explicit/environment aak_ API key outranks browser login while legacy SDK env names are ignored', t => {
+  const home = tempHome(t);
+  saveAccountSession({ access_token: 'browser_session_disk' }, { home });
+
+  assert.equal(
+    resolveAccountAuth({ env: { AGENTSAM_API_KEY: 'aak_env_test' }, home }).value,
+    'aak_env_test',
+  );
+  assert.equal(
+    resolveAccountAuth({ env: { AGENTSAM_API_KEY: 'aak_env_test' }, explicit: 'aak_explicit_test', home }).value,
+    'aak_explicit_test',
+  );
+  assert.equal(
+    resolveAccountAuth({ env: { AGENTSAM_SDK_KEY: 'legacy_ignored' }, home }).value,
+    'browser_session_disk',
+  );
+});
+
+test('invalid environment API key cannot shadow a valid browser login', t => {
+  const home = tempHome(t);
+  saveAccountSession({ access_token: 'browser_session_machine_test' }, { home });
+  const resolved = resolveAccountAuth({ env: { AGENTSAM_API_KEY: 'not-an-aak' }, home });
+  assert.equal(resolved.value, 'browser_session_machine_test');
+  assert.equal(resolved.kind, 'browser_oauth');
+  assert.equal(resolved.fallback_error, 'invalid_api_key_prefix');
+});
+
+test('async IAM authority also falls back from invalid environment key to browser OAuth', async t => {
+  const home = tempHome(t);
+  saveAccountSession({ access_token: 'browser_session_machine_test' }, { home });
+  const resolved = await resolveAccountAuthority({ env: { AGENTSAM_API_KEY: 'not-an-aak' }, home });
+  assert.equal(resolved.value, 'browser_session_machine_test');
+  assert.equal(resolved.kind, 'browser_oauth');
+  assert.equal(resolved.fallback_error, 'invalid_api_key_prefix');
+});
+
+test('invalid explicitly supplied API key remains authoritative and fails visibly', t => {
+  const home = tempHome(t);
+  saveAccountSession({ access_token: 'browser_session_machine_test' }, { home });
+  const resolved = resolveAccountAuth({ env: {}, explicit: 'not-an-aak', home });
+  assert.equal(resolved.value, '');
+  assert.equal(resolved.error, 'invalid_api_key_prefix');
+  assert.equal(resolved.source, 'explicit');
+});
+
+test('browser session storage refuses reusable aak_ credentials', t => {
   const home = tempHome(t);
-  saveAccountSession({ access_token: 'sdk_disk' }, { home });
-  assert.equal(resolveAccountSdkKey({ env: { AGENTSAM_SDK_KEY: 'sdk_env' }, home }).value, 'sdk_env');
-  assert.equal(resolveAccountSdkKey({ env: { AGENTSAM_SDK_KEY: 'sdk_env' }, explicit: 'sdk_explicit', home }).value, 'sdk_explicit');
+  assert.throws(
+    () => saveAccountSession({ access_token: 'aak_should_not_be_browser_session' }, { home }),
+    /account_browser_oauth_session_required/,
+  );
 });