@inneranimalmedia/agentsam-sdk 2.6.5 → 2.6.8

package/test/capabilities.test.mjs

@@ -1,133 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-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');
-
-function git(cwd, args) { return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim(); }
-
-function fixture() {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-capability-'));
-  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'snapshot-fixture', version: '1.0.0', type: 'module' }, null, 2));
-  fs.mkdirSync(path.join(root, 'src'));
-  fs.writeFileSync(path.join(root, 'src', 'index.js'), 'export const value = 1;\n');
-  git(root, ['init', '-q']);
-  git(root, ['config', 'user.email', 'test@example.com']);
-  git(root, ['config', 'user.name', 'AgentSam Test']);
-  git(root, ['add', '.']);
-  git(root, ['commit', '-qm', 'fixture']);
-  return root;
-}
-
-test('capability manifest exposes deterministic primitives without requiring a model', () => {
-  const manifest = getCapabilityManifest();
-  assert.equal(manifest.schema_version, 1);
-  assert.equal(getCapability('repository.snapshot').model_required, false);
-  assert.equal(getCapability('repository.snapshot').side_effects, 'none');
-  assert.equal(getCapability('knowledge.index').deterministic, true);
-});
-
-test('presets resolve to explicit feature/capability selections', () => {
-  assert.equal(getPreset('cms').lane, 'cms');
-  const preset = resolvePreset('prototype');
-  assert.deepEqual(preset.features, ['agent']);
-  assert.throws(() => resolvePreset('nope'), /unknown_preset/);
-});
-
-test('repository.snapshot composes deterministic evidence and content addressing', async t => {
-  const root = fixture();
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const one = await repositorySnapshot({ cwd: root, churnDays: 30 });
-  const two = await repositorySnapshot({ cwd: root, churnDays: 30 });
-  assert.equal(one.capability, 'repository.snapshot');
-  assert.match(one.snapshot_id, /^rsnap_[a-f0-9]{24}$/);
-  assert.match(one.content_hash, /^sha256:[a-f0-9]{64}$/);
-  assert.equal(one.content_hash, two.content_hash);
-  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 }));
-  execFileSync(process.execPath, [CLI, 'create', 'demo', '--preset', 'cms', '--target', 'local'], {
-    cwd: parent,
-    stdio: 'pipe',
-  });
-  const project = path.join(parent, 'demo');
-  const config = JSON.parse(fs.readFileSync(path.join(project, '.agentsam', 'config.json'), 'utf8'));
-  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', 'brand', 'theme']);
-  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'));
-  assert.equal(features.features.knowledge.selected, true);
-
-  const snapshot = JSON.parse(execFileSync(process.execPath, [CLI, 'inspect', '--cwd', project, '--json'], {
-    encoding: 'utf8',
-    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/api-key-env-whoami.test.mjs

@@ -1,129 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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'), 'operational');
-  });
-});

package/test/cli/eval-live.test.mjs

@@ -1,219 +0,0 @@
-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 {
-  finishLiveEvalRun,
-  getLiveEvalStatus,
-  startLiveEvalRun,
-} from '../../src/eval/index.js';
-import { recordToolReceipt } from '../../src/mcp/index.js';
-import { runEval } from '../../src/commands/eval.js';
-
-function tempHome() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-live-eval-test-'));
-}
-
-test('live eval lifecycle: start, track receipts, get status, finish', async () => {
-  const home = tempHome();
-
-  // Initially inactive
-  const initialStatus = getLiveEvalStatus({ home });
-  assert.equal(initialStatus.active, false);
-
-  // Start live eval run
-  const run = startLiveEvalRun(
-    {
-      suite: 'sdk-real-work-20260919',
-      case: 'cad-shell-unification',
-      model: 'Muse Spark 1.3',
-      provider: 'cursor',
-      client: 'cursor',
-      reasoning: 'high',
-    },
-    { home }
-  );
-
-  assert.ok(run.run_id.startsWith('evr_'));
-  assert.equal(run.suite_id, 'sdk-real-work-20260919');
-  assert.equal(run.case_id, 'cad-shell-unification');
-  assert.equal(run.model, 'Muse Spark 1.3');
-
-  // Verify starting again fails
-  assert.throws(() => startLiveEvalRun({}, { home }), /live_eval_run_already_active/);
-
-  // Record tool calls into the live session
-  recordToolReceipt({ tool_key: 'github_read', source_client: 'cursor', duration_ms: 50 }, { home });
-  recordToolReceipt({ tool_key: 'mcp:d1_query', source_client: 'cursor_mcp', duration_ms: 12 }, { home });
-  recordToolReceipt({ tool_key: 'terminal_exec', source_client: 'agentsam', duration_ms: 300 }, { home });
-
-  // Status check reflects active state and tool receipts
-  const activeStatus = getLiveEvalStatus({ home });
-  assert.equal(activeStatus.active, true);
-  assert.equal(activeStatus.receipts_summary.tool_call_count, 3);
-  assert.equal(activeStatus.receipts_summary.mcp_call_count, 1);
-
-  // Finish run
-  const result = await finishLiveEvalRun({ home, gate: 'PASS' });
-  assert.equal(result.evalRunRow.id, run.run_id);
-  assert.equal(result.evalRunRow.passed, 1);
-  assert.equal(result.evalRunRow.tool_calls_attempted, 3);
-  assert.equal(result.evalRunRow.tool_calls_succeeded, 3);
-  assert.equal(result.modelObservationRow.id, `obs_${run.run_id}`);
-  assert.equal(result.modelObservationRow.passed, 1);
-
-  // After finish, status is inactive again
-  const postStatus = getLiveEvalStatus({ home });
-  assert.equal(postStatus.active, false);
-});
-
-test('agentsam eval live CLI commands work end-to-end', async () => {
-  const home = tempHome();
-  const logs = [];
-  const write = (str) => logs.push(str);
-
-  // CLI start
-  const startResult = await runEval(
-    ['live', 'start', '--case', 'errors-v1-reconciliation', '--model', 'Muse Spark 1.3', '--json'],
-    { home, write }
-  );
-  assert.ok(startResult.run_id.startsWith('evr_'));
-
-  // Record receipt
-  recordToolReceipt({ tool_key: 'mcp:eval_query', source_client: 'cursor_mcp', duration_ms: 40 }, { home });
-
-  // CLI status
-  const statusResult = await runEval(['live', 'status', '--json'], { home, write });
-  assert.equal(statusResult.active, true);
-  assert.equal(statusResult.receipts_summary.tool_call_count, 1);
-
-  // CLI finish
-  const finishResult = await runEval(['live', 'finish', '--gate', 'PASS', '--json'], { home, write });
-  assert.equal(finishResult.evalRunRow.passed, 1);
-  assert.equal(finishResult.summary.gate_status, 'PASS');
-
-  // Verify non-JSON output formats cleanly
-  const emptyStatus = await runEval(['live', 'status'], { home, write });
-  assert.equal(emptyStatus.active, false);
-});
-
-test('finishLiveEvalRun archives run locally, generates SQL for both tables, and respects configurable tenant/database', async () => {
-  const home = tempHome();
-  const run = startLiveEvalRun(
-    {
-      case: 'cad-render-eval',
-      model: 'Muse Spark 1.3',
-      tenant: 'test-tenant',
-      workspace: 'cad-workspace',
-      user: 'test-user',
-      database: 'test-database',
-    },
-    { home }
-  );
-
-  assert.equal(run.tenant_id, 'test-tenant');
-  assert.equal(run.workspace_id, 'cad-workspace');
-  assert.equal(run.user_id, 'test-user');
-  assert.equal(run.database, 'test-database');
-
-  const result = await finishLiveEvalRun({ home, gate: 'PASS' });
-
-  // 1. Dual record construction
-  assert.equal(result.evalRunRow.tenant_id, 'test-tenant');
-  assert.equal(result.modelObservationRow.tenant_id, 'test-tenant');
-  assert.equal(result.modelObservationRow.workspace_id, 'cad-workspace');
-  assert.equal(result.modelObservationRow.user_id, 'test-user');
-  assert.equal(result.modelObservationRow.status, 'completed');
-  assert.equal(result.modelObservationRow.passed, 1);
-  assert.equal(result.modelObservationRow.expected_markers_total, 1);
-  assert.equal(typeof result.modelObservationRow.output_chars, 'number');
-
-  // 2. Both tables present in generated D1 SQL
-  assert.ok(result.summary.d1_sql.includes('INSERT OR REPLACE INTO agentsam_eval_runs'));
-  assert.ok(result.summary.d1_sql.includes('INSERT OR REPLACE INTO agentsam_model_eval_observations'));
-
-  // 3. Local archive created
-  const archivedRunPath = path.join(home, '.agentsam', 'eval', 'runs', `${run.run_id}.json`);
-  assert.ok(fs.existsSync(archivedRunPath), 'Archived run file must exist locally');
-  const archived = JSON.parse(fs.readFileSync(archivedRunPath, 'utf8'));
-  assert.equal(archived.evalRunRow.id, run.run_id);
-  assert.equal(archived.modelObservationRow.id, `obs_${run.run_id}`);
-});
-
-test('finishLiveEvalRun preserves active run state and receipts if remote persistence fails without --force', async () => {
-  const home = tempHome();
-  const run = startLiveEvalRun({ case: 'resilience-test' }, { home });
-
-  recordToolReceipt({ tool_key: 'git_status', duration_ms: 20 }, { home });
-
-  // Call finish with remote=true pointing to an unreachable endpoint and wrangler fallback disabled
-  const result = await finishLiveEvalRun({
-    home,
-    remote: true,
-    evalEndpoint: 'http://127.0.0.1:1/nonexistent',
-    wranglerFallback: false,
-    timeoutMs: 100,
-  });
-
-  // Verification: remote failure noted, evidence preserved, active run kept intact
-  assert.equal(result.summary.d1_executed, false);
-  assert.equal(result.summary.state_preserved, true);
-  assert.ok(result.summary.d1_error);
-
-  const activeStatus = getLiveEvalStatus({ home });
-  assert.equal(activeStatus.active, true, 'Active run state must be retained when remote persistence fails');
-  assert.equal(activeStatus.receipts_summary.tool_call_count, 1, 'Tool receipts must be preserved when remote persistence fails');
-
-  // Finish with force: true to finalize and clear active run
-  const forcedResult = await finishLiveEvalRun({
-    home,
-    remote: true,
-    evalEndpoint: 'http://127.0.0.1:1/nonexistent',
-    wranglerFallback: false,
-    timeoutMs: 100,
-    force: true,
-  });
-
-  assert.equal(forcedResult.summary.d1_executed, false);
-  const clearedStatus = getLiveEvalStatus({ home });
-  assert.equal(clearedStatus.active, false, 'Forced finish clears active run');
-});
-
-test('finishLiveEvalRun reuses the configured inneranimalmedia MCP bearer for remote persistence', { concurrency: false }, async () => {
-  const home = tempHome();
-  const mcpDir = path.join(home, '.agentsam', 'mcp');
-  fs.mkdirSync(mcpDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(mcpDir, 'inneranimalmedia.json'),
-    JSON.stringify({ auth: { type: 'bearer', token: 'fixture-eval-token' } }),
-  );
-
-  startLiveEvalRun({ case: 'authenticated-remote-eval' }, { home });
-
-  const originalFetch = globalThis.fetch;
-  let authorization = null;
-  try {
-    globalThis.fetch = async (_url, init = {}) => {
-      authorization = new Headers(init.headers).get('Authorization');
-      return new Response(JSON.stringify({ ok: true }), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    };
-
-    const result = await finishLiveEvalRun({
-      home,
-      remote: true,
-      evalEndpoint: 'https://example.test/api/eval/record',
-      wranglerFallback: false,
-    });
-
-    assert.equal(authorization, 'Bearer fixture-eval-token');
-    assert.equal(result.summary.d1_executed, true);
-    assert.equal(result.summary.persistence_method, 'http_endpoint');
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});

package/test/cli/go.test.mjs

@@ -1,128 +0,0 @@
-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 { fileURLToPath } from 'node:url';
-import { discoverGoRuntime, resolveProductRoot, ensureProductContract, buildGoProduct } from '../../src/go/index.js';
-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);
-  assert.ok(discovery.runtime, 'expected Go runtime');
-  assert.match(discovery.runtime.module, /agentsam-go-worker/);
-  assert.equal(path.basename(discovery.runtime.productRoot), 'agentsam-go-worker');
-  const productRoot = resolveProductRoot(discovery, 'agentsam-go-worker');
-  const contract = ensureProductContract(productRoot);
-  assert.equal(contract.product, 'agentsam-go-worker');
-  assert.equal(contract.existing, true);
-  assert.deepEqual(contract.created, []);
-});
-
-test('ensureProductContract refuses missing product roots instead of scaffolding siblings', () => {
-  const missing = path.join(os.tmpdir(), `agentsam-go-missing-${Date.now()}`);
-  assert.throws(() => ensureProductContract(missing), /product_root_missing/);
-});
-
-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, 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)),
-      stateRoot,
-    },
-  );
-  assert.equal(second.ok, true);
-  assert.equal(second.existing_product, true);
-  assert.equal(second.scaffold_changes_required, false);
-  assert.ok(second.deploy.receiptPath);
-  assert.ok(fs.existsSync(second.deploy.productPath));
-});
-
-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)),
-      stateRoot,
-    },
-  );
-  assert.equal(result.ok, true);
-  assert.ok(result.discovery.go.ok);
-  const parsed = JSON.parse(chunks.join(''));
-  assert.equal(parsed.product, 'agentsam-go-worker');
-});