@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.4

package/test/go/build-source-identity.test.mjs

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  repositoryIdFromGitContext,
+} from '../../src/go/build.js';
+
+test('Go build source canonicalizes GitHub repository identity', () => {
+  assert.equal(
+    repositoryIdFromGitContext({
+      remoteHost: 'github.com',
+      repoFullName: 'SamPrimeaux/agentsam-sdk',
+    }),
+    'github:samprimeaux/agentsam-sdk',
+  );
+});
+
+test('Go build source preserves provider-qualified non-GitHub identity', () => {
+  assert.equal(
+    repositoryIdFromGitContext({
+      remoteHost: 'gitlab.example.com',
+      repoFullName: 'Owner/Repo',
+    }),
+    'gitlab.example.com:Owner/Repo',
+  );
+});
+
+test('Go build source returns null when remote identity is unavailable', () => {
+  assert.equal(repositoryIdFromGitContext(null), null);
+  assert.equal(repositoryIdFromGitContext({}), null);
+});

package/test/go/cloudflare-probe.test.mjs

@@ -0,0 +1,317 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+import {
+  deployGoCloudflare,
+  extractWorkersDevUrl,
+  probeGoDeployment,
+  readLatestWranglerDeployment,
+  resolveWranglerIdentity,
+  resolveConfiguredDeploymentUrl,
+} from '../../src/go/cloudflare.js';
+import { buildProductRow } from '../../src/go/receipts.js';
+
+const SDK_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const PRODUCT_ROOT = path.join(SDK_ROOT, 'apps/agentsam-go-worker');
+const EXPECTED_HASH = '2e60bba13dc2bc37d75dd2ce5deb25466f19cb2994e20889388948879875eae9';
+
+
+test('configured custom domain is canonical Go deployment URL', () => {
+  assert.equal(
+    resolveConfiguredDeploymentUrl(PRODUCT_ROOT),
+    'https://runtime.inneranimalmedia.com',
+  );
+});
+
+test('extractWorkersDevUrl parses wrangler output', () => {
+  const url = extractWorkersDevUrl('Published agentsam-go-worker\n  https://agentsam-go-worker.example.workers.dev\n');
+  assert.equal(url, 'https://agentsam-go-worker.example.workers.dev');
+});
+
+test('probeGoDeployment requires edge, source identity, capabilities, deterministic functions and ErrorEnvelope', async () => {
+  const responses = new Map([
+    ['/', { status: 200, body: { ok: true, edge: 'worker', runtime: 'go/native-container', source: 'git:abc123' } }],
+    ['/edge/health', { status: 200, body: { ok: true, edge: 'worker', runtime: 'go/native-container', source: 'git:abc123' } }],
+    ['/health', {
+      status: 200,
+      body: {
+        ok: true,
+        service: 'agentsam-go-worker',
+        runtime: 'go',
+        target: 'cloudflare',
+        build: { source: 'git:abc123', commit: 'abc123' },
+      },
+    }],
+    ['/v1/runtime', {
+      status: 200,
+      body: { schema: 'agentsam.go-runtime.v1', os: 'linux', capabilities: ['hash', 'inspect', 'runtime', 'capabilities'] },
+    }],
+    ['/v1/capabilities', {
+      status: 200,
+      body: { schema: 'agentsam.go-capabilities.v1', capabilities: ['hash', 'inspect', 'runtime', 'capabilities'] },
+    }],
+    ['/v1/hash', { status: 200, body: { hash: EXPECTED_HASH, algorithm: 'sha256' } }],
+    ['/v1/inspect', { status: 200, body: { findings: [{ kind: 'hardcoded_color', value: '#2563eb' }] } }],
+  ]);
+  let inspectCalls = 0;
+  const fetchImpl = async (url) => {
+    const pathname = new URL(url).pathname;
+    if (pathname === '/v1/inspect') {
+      inspectCalls += 1;
+      if (inspectCalls === 2) {
+        return {
+          status: 400,
+          async json() {
+            return {
+              ok: false,
+              schema_version: 1,
+              code: 'INVALID_ARGUMENT',
+              reason: 'input_invalid',
+            };
+          },
+        };
+      }
+    }
+    const row = responses.get(pathname);
+    assert.ok(row, 'unexpected probe path: ' + pathname);
+    return {
+      status: row.status,
+      async json() { return row.body; },
+    };
+  };
+
+  const result = await probeGoDeployment('https://example.workers.dev', {
+    fetchImpl,
+    expectedSource: 'git:abc123',
+    expectedSourceCommit: 'abc123',
+    expectedTarget: 'cloudflare',
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.checks.edge_root, true);
+  assert.equal(result.checks.edge_health, true);
+  assert.equal(result.checks.source_identity, true);
+  assert.equal(result.checks.source_commit, true);
+  assert.equal(result.checks.capabilities, true);
+  assert.equal(result.results.deterministic_hash.ok, true);
+  assert.equal(result.results.deterministic_inspect.ok, true);
+  assert.equal(result.results.malformed_rejected.ok, true);
+});
+
+test('readLatestWranglerDeployment normalizes authoritative deployment/version identity', () => {
+  const spawn = () => ({
+    status: 0,
+    stdout: JSON.stringify([
+      {
+        id: 'dep_old',
+        created_on: '2026-09-24T00:00:00Z',
+        versions: [{ version_id: 'ver_old', percentage: 100 }],
+      },
+      {
+        id: 'dep_new',
+        created_on: '2026-09-25T00:00:00Z',
+        versions: [{ version_id: 'ver_new', percentage: 100 }],
+      },
+    ]),
+    stderr: '',
+  });
+  const result = readLatestWranglerDeployment(PRODUCT_ROOT, 'agentsam-go-worker', { spawn });
+  assert.equal(result.ok, true);
+  assert.equal(result.deployment_id, 'dep_new');
+  assert.equal(result.version_id, 'ver_new');
+});
+
+test('resolveWranglerIdentity fails closed when authentication is unavailable', () => {
+  const spawn = () => ({ status: 1, stdout: '', stderr: 'not logged in' });
+  const result = resolveWranglerIdentity(PRODUCT_ROOT, { spawn });
+  assert.equal(result.ok, false);
+  assert.equal(result.authenticated, false);
+  assert.equal(result.error, 'cloudflare_not_authenticated');
+});
+
+test('resolveWranglerIdentity requires an explicit account when multiple are available', () => {
+  const spawn = () => ({
+    status: 0,
+    stdout: JSON.stringify({
+      loggedIn: true,
+      authType: 'OAuth Token',
+      accounts: [
+        { id: 'acc_a', name: 'Account A', type: 'standard' },
+        { id: 'acc_b', name: 'Account B', type: 'standard' },
+      ],
+    }),
+    stderr: '',
+  });
+  const ambiguous = resolveWranglerIdentity(PRODUCT_ROOT, { spawn });
+  assert.equal(ambiguous.ok, false);
+  assert.equal(ambiguous.error, 'cloudflare_account_ambiguous');
+
+  const selected = resolveWranglerIdentity(PRODUCT_ROOT, {
+    spawn,
+    requestedAccountId: 'acc_b',
+  });
+  assert.equal(selected.ok, true);
+  assert.equal(selected.account.id, 'acc_b');
+});
+
+test('Cloudflare self-host dry run binds the resolved account and never mutates InnerAnimalMedia D1', async () => {
+  const calls = [];
+  const cloudflareIdentity = {
+    ok: true,
+    authenticated: true,
+    auth_type: 'OAuth Token',
+    account: { id: 'acc_user', name: 'User Cloudflare', type: 'standard' },
+    accounts: [{ id: 'acc_user', name: 'User Cloudflare', type: 'standard' }],
+  };
+  const spawn = (command, args = [], options = {}) => {
+    calls.push({ command, args, env: options.env || {} });
+    if (command === 'docker' && args[0] === 'info') {
+      return { status: 0, stdout: 'ok', stderr: '' };
+    }
+    if (args.includes('deploy') && args.includes('--dry-run')) {
+      assert.equal(options.env.CLOUDFLARE_ACCOUNT_ID, 'acc_user');
+      assert.ok(args.includes('AGENTSAM_BUILD_SOURCE:npm:@inneranimalmedia/agentsam-go-worker@0.1.0'));
+      return { status: 0, stdout: 'Total Upload: 1 KiB', stderr: '' };
+    }
+    throw new Error('unexpected spawn: ' + [command, ...args].join(' '));
+  };
+
+  const result = await deployGoCloudflare({
+    productRoot: PRODUCT_ROOT,
+    product: 'agentsam-go-worker',
+    dryRun: true,
+    accountId: 'acc_user',
+    cloudflareIdentity,
+    source: {
+      identity: 'npm:@inneranimalmedia/agentsam-go-worker@0.1.0',
+      commit: null,
+      package_name: '@inneranimalmedia/agentsam-go-worker',
+      package_version: '0.1.0',
+    },
+    builtAt: '2026-09-25T00:00:00.000Z',
+    spawn,
+  });
+
+  assert.equal(result.deployed, false);
+  assert.equal(result.dryRunValidated, true);
+  assert.equal(result.receipt.dry_run, true);
+  assert.equal(result.receipt.skipped_deploy, false);
+  assert.equal(result.receipt.registry_mode, 'self_host_local');
+  assert.equal(result.receipt.cloudflare.account_id, 'acc_user');
+  assert.equal(result.registry.remote, false);
+  assert.equal(result.registry.reason, 'self_host_registry_isolated');
+  assert.ok(calls.some((call) => call.args.includes('deploy') && call.args.includes('--dry-run')));
+});
+
+
+test('buildProductRow stays on agentsam_products projection with deployment identity', () => {
+  const row = buildProductRow({
+    product: 'agentsam-go-worker',
+    repositoryId: 'github:samprimeaux/agentsam-sdk',
+    commit: 'abc',
+    url: 'https://x.workers.dev',
+    health: 'healthy',
+    workerDeploymentId: 'dep_1',
+    workerVersionId: 'ver_1',
+    artifactDigest: 'sha256:binary',
+    containerDigest: 'sha256:image',
+  });
+  assert.equal(row.slug, 'agentsam-go-worker');
+  assert.equal(row.kind, 'service');
+  assert.equal(row.status, 'deployed');
+  assert.equal(row.canonical_path, 'apps/agentsam-go-worker');
+  assert.equal(row.package_name, '@inneranimalmedia/agentsam-go-worker');
+  assert.equal(row.metadata.runtime, 'go');
+  assert.equal(row.metadata.deployment.worker_deployment_id, 'dep_1');
+  assert.equal(row.metadata.deployment.worker_version_id, 'ver_1');
+});
+
+test('source identity produces a source-keyed Container instance', async () => {
+  const { runtimeInstanceKey } = await import('../../apps/agentsam-go-worker/worker/src/identity.js');
+  const first = runtimeInstanceKey('git:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa');
+  const second = runtimeInstanceKey('git:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb');
+  assert.equal(first, 'runtime:git:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa');
+  assert.equal(second, 'runtime:git:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb');
+  assert.notEqual(first, second);
+  assert.equal(runtimeInstanceKey('npm:@inneranimalmedia/agentsam-go-worker@0.1.0'), 'runtime:npm:@inneranimalmedia/agentsam-go-worker@0.1.0');
+});
+
+
+test('validation-only Cloudflare runs do not replace production receipts', async () => {
+  const fs = await import('node:fs');
+  const os = await import('node:os');
+
+  const stateRoot = fs.mkdtempSync(
+    path.join(os.tmpdir(), 'agentsam-go-receipt-isolation-'),
+  );
+
+  const goDir = path.join(stateRoot, '.agentsam', 'go');
+  fs.mkdirSync(goDir, { recursive: true });
+
+  const production = {
+    schema: 'agentsam.deployment-receipt.v1',
+    product: 'agentsam-go-worker',
+    provider: 'cloudflare',
+    url: 'https://runtime.inneranimalmedia.com',
+    health: 'healthy',
+    deployed_at: '2026-09-25T17:05:13.618296Z',
+    worker_deployment_id: 'dep_prod',
+    worker_version_id: 'ver_prod',
+    official_release: true,
+  };
+
+  fs.writeFileSync(
+    path.join(goDir, 'latest.deployment-receipt.json'),
+    JSON.stringify(production, null, 2) + '\n',
+  );
+
+  const cloudflareIdentity = {
+    ok: true,
+    authenticated: true,
+    auth_type: 'OAuth Token',
+    account: { id: 'acc_test', name: 'Test', type: 'standard' },
+    accounts: [{ id: 'acc_test', name: 'Test', type: 'standard' }],
+  };
+
+  const spawn = (command, args = []) => {
+    if (command === 'docker' && args[0] === 'info') {
+      return { status: 0, stdout: 'ok', stderr: '' };
+    }
+    if (args.includes('deploy') && args.includes('--dry-run')) {
+      return { status: 0, stdout: 'dry run', stderr: '' };
+    }
+    throw new Error('unexpected spawn: ' + [command, ...args].join(' '));
+  };
+
+  await deployGoCloudflare({
+    productRoot: PRODUCT_ROOT,
+    stateRoot,
+    product: 'agentsam-go-worker',
+    dryRun: true,
+    accountId: 'acc_test',
+    cloudflareIdentity,
+    source: {
+      identity: 'git:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+      commit: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+      package_name: '@inneranimalmedia/agentsam-go-worker',
+      package_version: '0.1.0',
+    },
+    artifactDigest: 'sha256:artifact',
+    containerDigest: 'sha256:container',
+    spawn,
+  });
+
+  const after = JSON.parse(
+    fs.readFileSync(
+      path.join(goDir, 'latest.deployment-receipt.json'),
+      'utf8',
+    ),
+  );
+
+  assert.deepEqual(after, production);
+  assert.ok(
+    fs.existsSync(
+      path.join(goDir, 'latest.deployment-validation-receipt.json'),
+    ),
+  );
+});

package/test/go/distribution.test.mjs

@@ -0,0 +1,28 @@
+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 {
+  GO_WORKER_PACKAGE,
+  discoverGoRuntime,
+  resolveProductRoot,
+} from '../../src/go/discover.js';
+
+const SDK_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const PRODUCT_ROOT = path.join(SDK_ROOT, 'apps', 'agentsam-go-worker');
+
+test('installed Go Worker package is discovered outside the monorepo', () => {
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-go-distribution-'));
+  const packageRoot = path.join(temp, 'node_modules', ...GO_WORKER_PACKAGE.split('/'));
+  fs.mkdirSync(path.dirname(packageRoot), { recursive: true });
+  fs.symlinkSync(PRODUCT_ROOT, packageRoot, 'dir');
+
+  const discovery = discoverGoRuntime(temp);
+  assert.equal(discovery.schema, 'agentsam.go-discovery.v2');
+  assert.equal(discovery.runtime?.origin, 'installed_package');
+  assert.equal(discovery.distribution?.package_name, GO_WORKER_PACKAGE);
+  assert.equal(discovery.distribution?.package_version, '0.1.0');
+  assert.equal(fs.realpathSync(resolveProductRoot(discovery)), fs.realpathSync(PRODUCT_ROOT));
+});

package/test/integration/ai-access-onboarding.test.mjs

@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import {
+  assessAiAccess,
+  formatAiAccessOnboarding,
+  CF_OAUTH_REQUIRED_REDIRECTS,
+  LOCAL_STUDIO_LOGIN,
+} from '../../src/models/ai-access-onboarding.js';
+import { listModelCatalog } from '../../src/models/catalog.js';
+import { getModelRecord, mergeModelReference, listModelCatalog as listFromIndex } from '../../src/models/index.js';
+
+describe('listModelCatalog import surface', () => {
+  it('is defined from catalog and models/index', () => {
+    assert.equal(typeof listModelCatalog, 'function');
+    assert.equal(typeof listFromIndex, 'function');
+    assert.ok(listModelCatalog().length > 0);
+    assert.equal(typeof getModelRecord, 'function');
+    assert.equal(typeof mergeModelReference, 'function');
+  });
+});
+
+describe('ai access onboarding', () => {
+  it('marks ready when a provider credential is configured', () => {
+    const access = assessAiAccess({
+      inventory: { providers: [{ id: 'openai', configured: true }] },
+      ollama: { online: false, models: [] },
+      options: [{ value: 'none' }],
+    });
+    assert.equal(access.ready, true);
+    assert.equal(access.hasProviderKeys, true);
+  });
+
+  it('marks not ready and formats setup paths', () => {
+    const access = assessAiAccess({
+      inventory: { providers: [{ id: 'openai', configured: false }] },
+      ollama: { online: false, models: [] },
+      options: [{ value: 'none' }],
+    });
+    assert.equal(access.ready, false);
+    const text = formatAiAccessOnboarding(access, { wantCloudAi: true });
+    assert.match(text, /ollama\.com\/download/);
+    assert.match(text, /agentsam providers/);
+    assert.match(text, /api\/oauth\/cloudflare\/start/);
+    assert.ok(CF_OAUTH_REQUIRED_REDIRECTS.some((u) => u.includes('/api/oauth/cloudflare/callback')));
+    assert.match(LOCAL_STUDIO_LOGIN, /next=\/agentsam/);
+  });
+});

package/test/integration/app-command.test.mjs

@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import test from 'node:test';
+import { listAppManifests } from '../../src/commands/app.js';
+
+test('lists agentsam.app.json manifests for product apps', () => {
+  const apps = listAppManifests();
+  const ids = apps.map((row) => row.id).sort();
+  assert.ok(ids.includes('cad-creator'));
+  assert.ok(ids.includes('local-studio'));
+  assert.ok(ids.includes('client-cms-editor'));
+  assert.ok(ids.includes('ecommerce-cms-agentsam'));
+});
+
+
+test('Ecommerce CMS app bin exposes truthful runnable doctor state', () => {
+  const bin = path.resolve('apps/ecommerce-cms-agentsam/bin/agentsam-ecommerce.mjs');
+  const result = spawnSync(process.execPath, [bin, 'doctor', '--json'], {
+    cwd: path.resolve('.'),
+    encoding: 'utf8',
+  });
+
+  assert.equal(result.status, 0, result.stderr);
+  const report = JSON.parse(result.stdout);
+  assert.equal(report.app_id, 'ecommerce-cms-agentsam');
+  assert.equal(report.source.frontend, true);
+  assert.equal(report.runtime.package_json, true);
+  assert.equal(report.runtime.runnable, true);
+  assert.equal(report.manifest_runtime.local_preview, 'ready');
+  assert.equal(report.manifest_runtime.source_scaffold, 'ready');
+  assert.equal(report.contract_consistent, true);
+});
+
+test('Ecommerce CMS app manifest and package agree on executable preview', () => {
+  const manifest = JSON.parse(
+    fs.readFileSync(path.resolve('apps/ecommerce-cms-agentsam/agentsam.app.json'), 'utf8'),
+  );
+  const pkg = JSON.parse(
+    fs.readFileSync(path.resolve('apps/ecommerce-cms-agentsam/package.json'), 'utf8'),
+  );
+  const frontendPkg = JSON.parse(
+    fs.readFileSync(path.resolve('apps/ecommerce-cms-agentsam/frontend/package.json'), 'utf8'),
+  );
+
+  assert.equal(manifest.package, pkg.name);
+  assert.equal(manifest.bin, 'bin/agentsam-ecommerce.mjs');
+  assert.equal(manifest.runtime.local_preview, 'ready');
+  assert.equal(manifest.runtime.source_scaffold, 'ready');
+  assert.equal(manifest.preview.entry, '/admin');
+  assert.equal(manifest.preview.port, 4174);
+  assert.equal(typeof pkg.scripts.preview, 'string');
+  assert.equal(typeof frontendPkg.scripts.preview, 'string');
+});

package/test/integration/cad-discovery.test.mjs

@@ -0,0 +1,158 @@
+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 {
+  discoverOpenScad,
+  openScadStatus,
+  discoverFreeCad,
+  freeCadStatus,
+  meshyStatus,
+  mujocoStatus,
+  discoverAllCadTools,
+  getInstallGuidance,
+} from '../../src/lib/cad/index.js';
+
+function makeFixture(t, name) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), `agentsam-${name}-test-`));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const binary = path.join(root, process.platform === 'win32' ? `${name}.exe` : name);
+  fs.writeFileSync(binary, `fake ${name}\n`);
+  return { root, binary };
+}
+
+test('discoverOpenScad honors explicit binary before env and path', (t) => {
+  const { binary } = makeFixture(t, 'openscad');
+  const result = discoverOpenScad({
+    openscadBin: binary,
+    env: { AGENTSAM_OPENSCAD_BIN: '/nonexistent/bin' },
+  });
+  assert.equal(result.source, 'explicit');
+  assert.equal(result.binary, fs.realpathSync(binary));
+});
+
+test('discoverOpenScad honors AGENTSAM_OPENSCAD_BIN when explicit is not set', (t) => {
+  const { binary } = makeFixture(t, 'openscad');
+  const result = discoverOpenScad({
+    env: { AGENTSAM_OPENSCAD_BIN: binary },
+  });
+  assert.equal(result.source, 'env');
+  assert.equal(result.binary, fs.realpathSync(binary));
+});
+
+test('openScadStatus probes version boundedly and returns deterministic receipt', async (t) => {
+  const { binary } = makeFixture(t, 'openscad');
+  const calls = [];
+  const status = await openScadStatus({
+    openscadBin: binary,
+    runProcessImpl: async (command, args) => {
+      calls.push({ command, args });
+      return { code: 0, stdout: '', stderr: 'OpenSCAD version 2026.04.26\n' };
+    },
+  });
+
+  assert.equal(status.tool, 'openscad');
+  assert.equal(status.available, true);
+  assert.equal(status.version, '2026.04.26');
+  assert.equal(status.execution_lane, 'native');
+  assert.deepEqual(calls[0], { command: fs.realpathSync(binary), args: ['-v'] });
+});
+
+test('discoverFreeCad honors explicit binary and AGENTSAM_FREECAD_BIN', (t) => {
+  const { binary } = makeFixture(t, 'FreeCADCmd');
+  const result = discoverFreeCad({
+    freecadBin: binary,
+    env: { AGENTSAM_FREECAD_BIN: '/nonexistent/path' },
+  });
+  assert.equal(result.source, 'explicit');
+  assert.equal(result.binary, fs.realpathSync(binary));
+
+  const envResult = discoverFreeCad({
+    env: { AGENTSAM_FREECAD_BIN: binary },
+  });
+  assert.equal(envResult.source, 'env');
+  assert.equal(envResult.binary, fs.realpathSync(binary));
+});
+
+test('freeCadStatus probes version and returns deterministic receipt', async (t) => {
+  const { binary } = makeFixture(t, 'FreeCADCmd');
+  const calls = [];
+  const status = await freeCadStatus({
+    freecadBin: binary,
+    runProcessImpl: async (command, args) => {
+      calls.push({ command, args });
+      return { code: 0, stdout: 'FreeCAD 1.1.1 Revision: 20260414 (Git shallow)\n', stderr: '' };
+    },
+  });
+
+  assert.equal(status.tool, 'freecad');
+  assert.equal(status.available, true);
+  assert.equal(status.version, 'FreeCAD 1.1.1 Revision: 20260414 (Git shallow)');
+  assert.equal(status.execution_lane, 'native');
+  assert.deepEqual(calls[0], { command: fs.realpathSync(binary), args: ['--version'] });
+});
+
+test('meshyStatus discovers API key configuration via environment', () => {
+  const noKey = meshyStatus({ env: {} });
+  assert.equal(noKey.available, false);
+  assert.equal(noKey.source, 'none');
+  assert.equal(noKey.execution_lane, 'cloud_byok');
+
+  const withKey = meshyStatus({ env: { MESHY_API_KEY: 'msy_test_secret_key' } });
+  assert.equal(withKey.available, true);
+  assert.equal(withKey.source, 'env');
+  assert.equal(withKey.version, 'v2-api');
+});
+
+test('mujocoStatus returns browser WASM bundled capability', () => {
+  const status = mujocoStatus();
+  assert.equal(status.tool, 'mujoco');
+  assert.equal(status.available, true);
+  assert.equal(status.execution_lane, 'browser_wasm');
+});
+
+test('discoverAllCadTools aggregates deterministic receipts across engines', async (t) => {
+  const { binary: openscad } = makeFixture(t, 'openscad');
+  const { binary: freecad } = makeFixture(t, 'FreeCADCmd');
+  const { binary: blender } = makeFixture(t, 'blender');
+
+  const report = await discoverAllCadTools({
+    openscadBin: openscad,
+    freecadBin: freecad,
+    blenderBin: blender,
+    env: { MESHY_API_KEY: 'test_key' },
+    runProcessImpl: async (command, args) => {
+      if (args[0] === '-v') return { code: 0, stdout: '', stderr: 'OpenSCAD version 2026.04.26\n' };
+      if (command.includes('FreeCAD')) return { code: 0, stdout: 'FreeCAD 1.1.1 Revision: 20260414\n', stderr: '' };
+      return { code: 0, stdout: 'Blender 5.0.1\n', stderr: '' };
+    },
+  });
+
+  assert.equal(report.schema_version, 1);
+  assert.equal(report.total_tools, 5);
+  assert.equal(report.available_tools, 5);
+  assert.equal(report.all_systems_ready, true);
+  assert.equal(report.tools.length, 5);
+});
+
+test('getInstallGuidance provides exact OS package manager commands', () => {
+  const darwinOpenScad = getInstallGuidance('openscad', 'darwin');
+  assert.equal(darwinOpenScad.command, 'brew install openscad');
+
+  const linuxFreeCad = getInstallGuidance('freecad', 'linux');
+  assert.match(linuxFreeCad.command, /apt-get install.*freecad/);
+
+  const winBlender = getInstallGuidance('blender', 'win32');
+  assert.equal(winBlender.command, 'winget install BlenderFoundation.Blender');
+});
+
+test('discoverOpenScad returns binary: null when not found on host (no hardcoded defaults)', () => {
+  const emptyDiscovery = discoverOpenScad({
+    env: { PATH: '' },
+    platform: 'unknown_os',
+  });
+  assert.equal(emptyDiscovery.binary, null);
+  assert.equal(emptyDiscovery.source, 'none');
+});
+