@inneranimalmedia/agentsam-sdk 2.6.3 → 2.6.4

package/src/ui/cli/help.js

@@ -1,87 +1,19 @@
 import pc from 'picocolors';
 import { isCancel, select } from '@clack/prompts';
 import pkg from '../../../package.json' with { type: 'json' };
-
-const HELP_TOPICS = Object.freeze([
-  {
-    id: 'start',
-    label: 'Start / resume',
-    summary: 'Enter Agent Sam, resume work, inspect identity, and choose a model.',
-    rows: [
-      ['agentsam', 'Enter the interactive Agent Sam experience'],
-      ['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 providers', 'Configure and verify machine provider credentials'],
-      ['agentsam env init <provider>', 'Low-level provider profile compatibility command'],
-    ],
-  },
-  {
-    id: 'work',
-    label: 'Build / inspect',
-    summary: 'Repository intelligence and normal project work.',
-    rows: [
-      ['agentsam inspect', 'Bounded repository index / authority view'],
-      ['agentsam index', 'Incremental AST and optional embeddings'],
-      ['agentsam search "query"', 'Search indexed code/text'],
-      ['agentsam repo snapshot', 'Git composition/churn snapshot'],
-      ['agentsam security', 'Dependency and trust-boundary scan'],
-      ['agentsam merkle', 'Integrity snapshots and comparisons'],
-    ],
-  },
-  {
-    id: 'runtime',
-    label: 'Runtime / terminal',
-    summary: 'Local, remote, sandbox, and deployment controls.',
-    rows: [
-      ['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', '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'],
-    ],
-  },
-  {
-    id: 'inside',
-    label: 'Inside Agent Sam',
-    summary: 'Commands available while the interactive session is running.',
-    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', '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'],
-    ],
-  },
-  {
-    id: 'create',
-    label: 'Create / extend',
-    summary: 'Scaffold and add reusable capabilities.',
-    rows: [
-      ['agentsam create <name> --preset <preset>', 'Create a new AgentSam project'],
-      ['agentsam add <capability>', 'Add a supported capability'],
-      ['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'],
-    ],
-  },
-]);
+import {
+  CLI_COMMAND_CATALOG,
+  CLI_HELP_TOPICS,
+  getCliCommand,
+  listCliCommands,
+  printAssistTip,
+} from '../../cli/command-catalog.js';
+import { SLASH_COMMANDS } from '../../lib/slash-commands.js';
 
 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'],
+  ['ingest', 'work'], ['codebaseindex', 'work'], ['codebase-index', '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'],
@@ -92,44 +24,66 @@ function clean(value) {
   return value == null ? '' : String(value).trim().toLowerCase();
 }
 
+function commandsForTopic(topicId) {
+  return listCliCommands({ topic: topicId }).map((entry) => {
+    const aliases = (entry.aliases || []).filter((a) => !a.startsWith('-')).slice(0, 2);
+    const name = aliases.length ? `agentsam ${entry.id}|${aliases.join('|')}` : `agentsam ${entry.id}`;
+    const tip = entry.skill ? ` · skill ${entry.skill}` : '';
+    return [name, `${entry.summary}${tip}`];
+  });
+}
+
 function padRows(rows) {
-  const width = Math.min(42, Math.max(...rows.map(([command]) => command.length), 0));
+  const width = Math.min(52, Math.max(...rows.map(([command]) => command.length), 0));
   return rows.map(([command, description]) => '    ' + pc.cyan(command.padEnd(width)) + '  ' + pc.dim(description));
 }
 
 export function resolveHelpTopic(value) {
   const query = clean(value);
   if (!query) return null;
-  const direct = HELP_TOPICS.find((topic) => topic.id === query || clean(topic.label) === query);
-  if (direct) return direct;
+  const direct = CLI_HELP_TOPICS.find((topic) => topic.id === query || clean(topic.label) === query);
+  if (direct) {
+    return { ...direct, rows: commandsForTopic(direct.id) };
+  }
   const alias = TOPIC_ALIASES.get(query);
-  if (alias) return HELP_TOPICS.find((topic) => topic.id === alias) || null;
-  return HELP_TOPICS.find((topic) =>
-    topic.rows.some(([command, description]) => clean(command).includes(query) || clean(description).includes(query))) || null;
+  if (alias) {
+    const topic = CLI_HELP_TOPICS.find((t) => t.id === alias);
+    return topic ? { ...topic, rows: commandsForTopic(topic.id) } : null;
+  }
+  const command = getCliCommand(query);
+  if (command) {
+    const topic = CLI_HELP_TOPICS.find((t) => t.id === command.topic);
+    return topic ? { ...topic, rows: commandsForTopic(topic.id) } : null;
+  }
+  return CLI_HELP_TOPICS.map((topic) => ({ ...topic, rows: commandsForTopic(topic.id) }))
+    .find((topic) => topic.rows.some(([cmd, description]) => clean(cmd).includes(query) || clean(description).includes(query))) || null;
 }
 
 export function renderHelpOverview(version, options = {}) {
+  const common = listCliCommands({ common: true });
   const lines = [
     '',
     '  ' + pc.bold('Agent Sam') + ' ' + pc.dim('v' + version),
-    '  ' + pc.dim('Type normally to work with Agent Sam. Use help only when you need the map.'),
+    '  ' + pc.dim('SAM = Systematic Autonomous Machinery · help is generated from the command catalog.'),
     '',
     '  ' + pc.bold('Start'),
     '    ' + pc.cyan('agentsam') + '                         ' + pc.dim('enter the interactive experience'),
     '    ' + pc.cyan('agentsam resume') + '                  ' + pc.dim('continue saved work'),
-    '    ' + pc.cyan('agentsam help <topic>') + '            ' + pc.dim('focused help'),
+    '    ' + pc.cyan('agentsam help <topic>') + '            ' + pc.dim('focused help from catalog'),
+    '    ' + pc.cyan('agentsam skills <id>') + '             ' + pc.dim('load how-to skill instructions'),
     '',
     '  ' + pc.bold('Common'),
-    '    ' + pc.cyan('agentsam inspect') + '                 ' + pc.dim('understand this repository'),
-    '    ' + pc.cyan('agentsam models') + '                  ' + pc.dim('see account-visible models'),
-    '    ' + pc.cyan('agentsam status') + '                  ' + pc.dim('check project/runtime health'),
-    '    ' + pc.cyan('agentsam security') + '                ' + pc.dim('scan dependency + trust boundaries'),
-    '    ' + pc.cyan('agentsam deploy') + '                  ' + pc.dim('graduate intentionally'),
-    '',
-    '  ' + pc.dim('Inside Agent Sam: press / for the command picker. Ask the selected model for natural-language help at any time.'),
   ];
+  for (const entry of common) {
+    lines.push('    ' + pc.cyan(('agentsam ' + entry.id).padEnd(34)) + '  ' + pc.dim(entry.summary));
+  }
+  lines.push(
+    '',
+    '  ' + pc.dim('Every command prints: tip: use skill <id>  — machine baseline for in-CLI guidance.'),
+    '  ' + pc.dim('Inside Agent Sam: press / for the command picker.'),
+  );
   if (options.showTopics !== false) {
-    lines.push('', '  ' + pc.dim('Topics: ' + HELP_TOPICS.map((topic) => topic.id).join(' · ') + ' · all'));
+    lines.push('', '  ' + pc.dim('Topics: ' + CLI_HELP_TOPICS.map((topic) => topic.id).join(' · ') + ' · all · skills'));
   }
   lines.push('');
   return lines.join('\n');
@@ -137,21 +91,37 @@ export function renderHelpOverview(version, options = {}) {
 
 export function renderHelpTopic(topic, version) {
   if (!topic) return renderHelpOverview(version);
+  const skillHint = topic.rows?.[0]?.[1]?.includes('skill')
+    ? ''
+    : '';
   return [
     '',
     '  ' + pc.bold('Agent Sam') + ' ' + pc.dim('v' + version) + ' ' + pc.dim('·') + ' ' + pc.bold(topic.label),
     '  ' + pc.dim(topic.summary),
     '',
-    ...padRows(topic.rows),
+    ...padRows(topic.rows || []),
     '',
-    '  ' + pc.dim('Tip: run agentsam help for the map, or agentsam to return to the interactive experience.'),
+    '  ' + pc.dim('Tip: agentsam skills <id> loads how-to instructions for that command’s skill.'),
+    skillHint,
     '',
   ].join('\n');
 }
 
 export function renderAllHelp(version) {
   const lines = [renderHelpOverview(version, { showTopics: false })];
-  for (const topic of HELP_TOPICS) lines.push(renderHelpTopic(topic, version));
+  for (const topic of CLI_HELP_TOPICS) {
+    lines.push(renderHelpTopic({ ...topic, rows: commandsForTopic(topic.id) }, version));
+  }
+  lines.push(
+    '',
+    '  ' + pc.bold('Inside shell (slash)'),
+    ...padRows(SLASH_COMMANDS.slice(0, 16).map((row) => [row.cmd, row.description])),
+    '    ' + pc.dim(`… ${SLASH_COMMANDS.length} slash commands total · /help inside the shell`),
+    '',
+    '  ' + pc.bold('Catalog'),
+    '    ' + pc.dim(`${CLI_COMMAND_CATALOG.length} top-level commands · source: src/cli/command-catalog.js`),
+    '',
+  );
   return lines.join('');
 }
 
@@ -160,11 +130,27 @@ export async function runHelp(argv = [], options = {}) {
   const write = options.write || ((value) => process.stdout.write(value));
   const args = argv.filter((arg) => arg !== '--interactive');
 
+  printAssistTip('help', { write: (s) => process.stderr.write(s) });
+
   if (args.includes('--all') || args.some((arg) => clean(arg) === 'all')) {
     write(renderAllHelp(version));
     return;
   }
 
+  if (args.some((arg) => clean(arg) === 'skills' || clean(arg) === 'skill')) {
+    write([
+      '',
+      '  ' + pc.bold('Skills') + ' ' + pc.dim('· how-to instructions per surface'),
+      '    ' + pc.cyan('agentsam skills') + '                      ' + pc.dim('list portable skills'),
+      '    ' + pc.cyan('agentsam skills <id>') + '               ' + pc.dim('print skill instructions'),
+      '    ' + pc.cyan('agentsam skills <id> --references') + '  ' + pc.dim('include reference docs'),
+      '',
+      '  ' + pc.dim('Every CLI command tip points at a skill id — that is the machine baseline.'),
+      '',
+    ].join('\n'));
+    return;
+  }
+
   const topicArg = args.find((arg) => !arg.startsWith('-'));
   if (topicArg) {
     const topic = resolveHelpTopic(topicArg);
@@ -184,18 +170,25 @@ export async function runHelp(argv = [], options = {}) {
   }
 
   const choice = await select({
-    message: 'Agent Sam help',
+    message: 'Agent Sam help (catalog-driven)',
     options: [
-      ...HELP_TOPICS.map((topic) => ({ value: topic.id, label: topic.label, hint: topic.summary })),
-      { value: 'all', label: 'All commands', hint: 'Print the complete deterministic help map' },
+      ...CLI_HELP_TOPICS.map((topic) => ({ value: topic.id, label: topic.label, hint: topic.summary })),
+      { value: 'skills', label: 'Skills', hint: 'How-to instructions loaded via agentsam skills' },
+      { value: 'all', label: 'All commands', hint: 'Print the complete catalog map' },
       { value: 'exit', label: 'Back', hint: 'Return without printing more help' },
     ],
   });
   if (isCancel(choice) || choice === 'exit') return;
   if (choice === 'all') write(renderAllHelp(version));
-  else write(renderHelpTopic(resolveHelpTopic(choice), version));
+  else if (choice === 'skills') {
+    write([
+      '',
+      '  Run ' + pc.cyan('agentsam skills') + ' to list, or ' + pc.cyan('agentsam skills agentsam-codebaseindex') + ' for ingest how-to.',
+      '',
+    ].join('\n'));
+  } else write(renderHelpTopic(resolveHelpTopic(choice), version));
 }
 
 export function listHelpTopics() {
-  return HELP_TOPICS.map((topic) => ({ id: topic.id, label: topic.label, summary: topic.summary }));
+  return CLI_HELP_TOPICS.map((topic) => ({ id: topic.id, label: topic.label, summary: topic.summary }));
 }

package/test/cli/api-key-env-whoami.test.mjs

@@ -0,0 +1,129 @@
+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 { runEnv } from '../../src/commands/env.js';
+import { ensureAgentEnvLoader, renderEnvShellExports, setProviderCredential } from '../../src/lib/provider-credentials.js';
+import { runApiKey } from '../../src/commands/api-key.js';
+import { collectWhoami } from '../../src/commands/whoami.js';
+
+function tmpHome() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-env-api-'));
+}
+
+test('load-agent-env.sh delegates to agentsam env shell (no plaintext secrets)', () => {
+  const home = tmpHome();
+  const loader = ensureAgentEnvLoader({ home });
+  const source = fs.readFileSync(loader, 'utf8');
+  assert.match(source, /agentsam env shell --profile default/);
+  assert.doesNotMatch(source, /export AGENTSAM_API_KEY=/);
+  assert.doesNotMatch(source, /env\.d\//);
+});
+
+test('env boot-line prints source load-agent-env without provider args', async () => {
+  const home = tmpHome();
+  const result = await runEnv(['boot-line'], { home, write: () => {} });
+  assert.equal(result.command, 'source ~/.agentsam/load-agent-env.sh');
+});
+
+test('env shell emits exports from vault without requiring ambient AGENTSAM_API_KEY', async () => {
+  const home = tmpHome();
+  setProviderCredential('inneranimalmedia', 'aak_testsecretvalue1234567890abcdef', {
+    home,
+    disableOsStore: true,
+  });
+  const result = await runEnv(['shell', '--profile', 'default'], {
+    home,
+    env: {},
+    write: () => {},
+  });
+  assert.match(result.script, /export AGENTSAM_API_KEY=/);
+  assert.ok(result.providers.includes('inneranimalmedia'));
+});
+
+test('renderEnvShellExports prefers vault over empty ambient env', () => {
+  const home = tmpHome();
+  setProviderCredential('cursor', 'cursor_test_key_value_xxxxxxxx', {
+    home,
+    disableOsStore: true,
+  });
+  const result = renderEnvShellExports({ home, env: {}, profile: 'default' });
+  assert.ok(result.providers.includes('cursor'));
+  assert.match(result.script, /export CURSOR_API_KEY=/);
+});
+
+test('api-key create stores secret via host mint response', async () => {
+  const home = tmpHome();
+  const result = await runApiKey(['create', '--name', 'Test Mac', '--store', 'vault', '--activate'], {
+    home,
+    env: {},
+    disableOsStore: true,
+    authorityLoader: async () => ({ value: 'oauth_session_token', kind: 'browser_oauth', source: 'test' }),
+    postJsonImpl: async () => ({
+      ok: true,
+      credential: { id: 'aakcred_1', name: 'Test Mac', prefix: 'aak_abc…', scopes: ['account:read'] },
+      secret_once: 'aak_mintedsecretvalue1234567890abcd',
+    }),
+    write: () => {},
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.activated, true);
+  assert.equal(result.credential.prefix, 'aak_abc…');
+});
+
+test('whoami surfaces tokenPermissions and authType from context', async () => {
+  const home = tmpHome();
+  const status = await collectWhoami({
+    home,
+    env: {},
+    authorityLoader: async () => ({ value: 'aak_presented', kind: 'api_key', source: 'environment' }),
+    contextLoader: async () => ({
+      user_id: 'au_1',
+      account_id: 'acct_1',
+      email: 'dev@example.test',
+      auth_type: 'api_key',
+      tokenPermissions: ['account:read', 'repository:read', 'models:invoke'],
+      credential: {
+        id: 'aakcred_1',
+        name: 'Sams-iMac',
+        prefix: 'aak_7fm…',
+        environment: 'development',
+        status: 'active',
+      },
+      cloudflare: { ok: true },
+      byok: {},
+      terminal: { available: false, instances: [], connections: [] },
+    }),
+  });
+  assert.equal(status.loggedIn, true);
+  assert.equal(status.authType, 'api_key');
+  assert.deepEqual(status.tokenPermissions, ['account:read', 'repository:read', 'models:invoke']);
+  assert.equal(status.credential.name, 'Sams-iMac');
+  assert.doesNotMatch(JSON.stringify(status), /aak_presented/);
+});
+
+test('repository does not normalize AGENTSAM_DEFAULT_APP', () => {
+  const root = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../..');
+  const hits = [];
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist') continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (/\.(js|mjs|ts|tsx|sh|json|md)$/.test(entry.name)) {
+        const text = fs.readFileSync(full, 'utf8');
+        // Allow docs that explicitly forbid the variable.
+        if (/AGENTSAM_DEFAULT_APP/.test(text) && !/no AGENTSAM_DEFAULT_APP|not normalize AGENTSAM_DEFAULT_APP|Remove.*AGENTSAM_DEFAULT_APP|doesNotMatch.*AGENTSAM_DEFAULT_APP|APP_SELECTOR=/.test(text)) {
+          if (/process\.env\.AGENTSAM_DEFAULT_APP|AGENTSAM_DEFAULT_APP\s*\|\||\$\{AGENTSAM_DEFAULT_APP/.test(text)) {
+            hits.push(full);
+          }
+        }
+      }
+    }
+  }
+  walk(path.join(root, 'src'));
+  walk(path.join(root, 'scripts'));
+  walk(path.join(root, 'apps/local-studio/backend'));
+  assert.deepEqual(hits, []);
+});

package/test/cli/codebaseindex-plan-ux.test.mjs

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import {
+  createCodebaseindexJobGraph,
+  advanceJobGraph,
+  freezePlanJobGraph,
+  formatJobGraphHuman,
+} from '../../src/indexing/ingest/job-graph.js';
+import { classifyTopLevel } from '../../src/indexing/ingest/inventory.js';
+
+describe('codebaseindex job graph plan freeze', () => {
+  it('does not leave → run pointer after plan.dry_run', () => {
+    let g = createCodebaseindexJobGraph();
+    g = advanceJobGraph(g, 'plan.dry_run');
+    assert.equal(g.nodes.find((n) => n.status === 'run')?.id, 'ast.parse');
+    g = freezePlanJobGraph(g, { skipEmbedding: true });
+    assert.equal(g.status, 'planned');
+    assert.equal(g.nodes.filter((n) => n.status === 'run').length, 0);
+    assert.equal(g.nodes.find((n) => n.id === 'embedding.generate')?.status, 'skipped');
+    const text = formatJobGraphHuman(g, { planOnly: true });
+    assert.match(text, /PLANNED FOR RUN/);
+    assert.match(text, /○ ast\.parse/);
+    assert.doesNotMatch(text, /→/);
+  });
+});
+
+describe('inventory path categories', () => {
+  it('classifies source vs dependencies vs generated', () => {
+    assert.equal(classifyTopLevel('src'), 'source');
+    assert.equal(classifyTopLevel('apps'), 'source');
+    assert.equal(classifyTopLevel('docs'), 'docs');
+    assert.equal(classifyTopLevel('node_modules'), 'dependencies');
+    assert.equal(classifyTopLevel('dist'), 'dependencies');
+    assert.equal(classifyTopLevel('generated'), 'generated');
+    assert.equal(classifyTopLevel('.agentsam'), 'config');
+  });
+});

package/test/cli/go.test.mjs

@@ -9,6 +9,11 @@ import { runGo } from '../../src/commands/go.js';
 
 const SDK_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
 
+
+function tempStateRoot() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-go-test-state-'));
+}
+
 test('discoverGoRuntime finds agentsam-go-worker without inventing a sibling', () => {
   const discovery = discoverGoRuntime(SDK_ROOT);
   assert.equal(discovery.go.ok, true);
@@ -30,30 +35,75 @@ test('ensureProductContract refuses missing product roots instead of scaffolding
 test('buildGoProduct emits build receipt after go test/vet/build', () => {
   const discovery = discoverGoRuntime(SDK_ROOT);
   const productRoot = resolveProductRoot(discovery);
+  const stateRoot = tempStateRoot();
   const result = buildGoProduct({
     productRoot,
     runtimeRoot: discovery.runtime.runtimeRoot,
     repositoryRoot: discovery.repository_root,
+    stateRoot,
   });
   assert.equal(result.receipt.schema, 'agentsam.go-build-receipt.v1');
   assert.equal(result.tests.ok, true);
   assert.equal(result.vet.ok, true);
   assert.ok(result.build.binary);
+  assert.match(result.receipt.artifact.digest, /^sha256:[a-f0-9]{64}$/);
+  assert.equal(result.receipt.tests.runtime_probe, true);
+  assert.match(result.receipt.source.identity, /^git:[a-f0-9]{40}$/);
+  assert.equal(result.probe.checks.source_identity, true);
+  assert.equal(result.probe.checks.source_commit, true);
+  assert.equal(result.probe.checks.error_envelope, true);
+  assert.equal(result.probe.checks.clean_shutdown, true);
   assert.ok(fs.existsSync(result.receiptPath));
 });
 
+test('agentsam go build --json exposes only portable build paths', async () => {
+  const stateRoot = tempStateRoot();
+  const chunks = [];
+
+  const result = await runGo(
+    ['build', '--json'],
+    {
+      write: (value) => chunks.push(String(value)),
+      stateRoot,
+    },
+  );
+
+  assert.ok(path.isAbsolute(result.receiptPath), 'internal execution keeps absolute receipt path');
+  assert.ok(path.isAbsolute(result.build.binary), 'internal execution keeps absolute binary path');
+
+  const output = chunks.join('');
+  const parsed = JSON.parse(output);
+
+  assert.equal(path.isAbsolute(parsed.receiptPath), false);
+  assert.equal(path.isAbsolute(parsed.build.binary), false);
+  assert.equal(path.isAbsolute(parsed.receipt.runtime.module_root), false);
+  assert.equal(Object.hasOwn(parsed.probe || {}, 'origin'), false);
+  assert.equal(Object.hasOwn(parsed.receipt?.probe || {}, 'origin'), false);
+  assert.equal(output.includes(SDK_ROOT), false);
+});
+
 test('agentsam go --cloudflare agentsam-go-worker --skip-deploy is idempotent', async () => {
+  const stateRoot = tempStateRoot();
   const chunks = [];
   const write = (v) => chunks.push(String(v));
-  const first = await runGo(['--cloudflare', 'agentsam-go-worker', '--skip-deploy', '--json'], { write });
+  const first = await runGo(
+    ['--cloudflare', 'agentsam-go-worker', '--skip-deploy', '--json'],
+    { write, stateRoot },
+  );
   assert.equal(first.ok, true);
   assert.equal(first.product, 'agentsam-go-worker');
   assert.equal(first.scaffold_changes_required, false);
+  assert.equal(first.mode, 'self_host');
+  assert.equal(first.deploy.registry.reason, 'self_host_registry_isolated');
 
   const chunks2 = [];
-  const second = await runGo(['--cloudflare', 'agentsam-go-worker', '--skip-deploy', '--json'], {
-    write: (v) => chunks2.push(String(v)),
-  });
+  const second = await runGo(
+    ['--cloudflare', 'agentsam-go-worker', '--skip-deploy', '--json'],
+    {
+      write: (v) => chunks2.push(String(v)),
+      stateRoot,
+    },
+  );
   assert.equal(second.ok, true);
   assert.equal(second.existing_product, true);
   assert.equal(second.scaffold_changes_required, false);
@@ -62,8 +112,15 @@ test('agentsam go --cloudflare agentsam-go-worker --skip-deploy is idempotent',
 });
 
 test('agentsam go status --json reports discovery', async () => {
+  const stateRoot = tempStateRoot();
   const chunks = [];
-  const result = await runGo(['status', '--json'], { write: (v) => chunks.push(String(v)) });
+  const result = await runGo(
+    ['status', '--json'],
+    {
+      write: (v) => chunks.push(String(v)),
+      stateRoot,
+    },
+  );
   assert.equal(result.ok, true);
   assert.ok(result.discovery.go.ok);
   const parsed = JSON.parse(chunks.join(''));

package/test/cli/skill-npm-and-env.test.mjs

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import test from 'node:test';
+import { resolveNpmSkillPackage } from '../../src/commands/skill.js';
+import { installSkillFromPath } from '../../src/skills/index.js';
+import { runEnv } from '../../src/commands/env.js';
+
+function tmpHome() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-finish-'));
+}
+
+test('resolveNpmSkillPackage extracts agentsam.skill.json via npm pack', (t) => {
+  // Build a tiny local package and pack it by path (no registry).
+  const pkgRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-npm-skill-'));
+  fs.writeFileSync(
+    path.join(pkgRoot, 'package.json'),
+    JSON.stringify({ name: 'tmp-agentsam-skill-fixture', version: '0.0.0', private: true }),
+  );
+  fs.writeFileSync(
+    path.join(pkgRoot, 'agentsam.skill.json'),
+    JSON.stringify({
+      schema: 'agentsam.skill.v1',
+      id: 'npm-fixture',
+      name: 'NPM Fixture',
+      slash: { suggested: '/npm-fixture' },
+      instructions: { source: 'inline', inline: '# npm fixture' },
+      execution: { mode: 'turn' },
+    }),
+  );
+  const resolved = resolveNpmSkillPackage(pkgRoot, { spawnSyncImpl: spawnSync });
+  assert.ok(fs.existsSync(path.join(resolved, 'agentsam.skill.json')));
+
+  const home = tmpHome();
+  const installed = installSkillFromPath(resolved, { home });
+  assert.equal(installed.id, 'npm-fixture');
+  assert.equal(installed.trigger, '/npm-fixture');
+});
+
+test('env boot-line prints source load-agent-env command', async () => {
+  const home = tmpHome();
+  const lines = [];
+  const result = await runEnv(['boot-line', 'cursor', 'inneranimalmedia'], {
+    home,
+    write: (t) => lines.push(t),
+  });
+  assert.equal(result.command, 'source ~/.agentsam/load-agent-env.sh');
+  assert.ok(lines.join('').includes('load-agent-env.sh'));
+  assert.ok(lines.join('').includes('agentsam env shell'));
+});