@inneranimalmedia/agentsam-sdk 2.6.3 → 2.6.4

package/test/cli/wireframes-go-registry.test.mjs

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { renderArchitectureExplorer, renderOperationInspector, drawBox } from '../../src/ui/wireframes.js';
-import { buildGoProductRegistrySql } from '../../src/go/registry.js';
+import { applyInnerAnimalMediaOfficialGoProductRegistry, buildGoProductRegistrySql } from '../../src/go/official-registry.js';
 
 test('architecture explorer is boxed reasoning scenery', () => {
   const view = renderArchitectureExplorer({
@@ -38,7 +38,7 @@ test('drawBox pads visible ANSI width', () => {
 test('buildGoProductRegistrySql upserts product + relationships without inventing tables', () => {
   const sql = buildGoProductRegistrySql({
     product: 'agentsam-go-worker',
-    status: 'wired',
+    status: 'deployed',
     url: 'https://agentsam-go-worker.example.workers.dev',
     commit: 'abc123',
     health: 'healthy',
@@ -52,3 +52,88 @@ test('buildGoProductRegistrySql upserts product + relationships without inventin
   assert.doesNotMatch(sql, /CREATE TABLE/);
   assert.doesNotMatch(sql, /account_id/);
 });
+
+
+test('InnerAnimalMedia remote registry requires the explicit official-release guard', () => {
+  const preferred = process.env.AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE;
+  const legacy = process.env.AGENTSAM_IAM_OFFICIAL_RELEASE;
+
+  delete process.env.AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE;
+  delete process.env.AGENTSAM_IAM_OFFICIAL_RELEASE;
+
+  try {
+    assert.throws(
+      () => applyInnerAnimalMediaOfficialGoProductRegistry({
+        productRoot: '/tmp/agentsam-test-state',
+        officialRelease: true,
+        skipRemote: true,
+      }),
+      /inneranimalmedia_registry_official_release_required/,
+    );
+  } finally {
+    if (preferred == null) {
+      delete process.env.AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE;
+    } else {
+      process.env.AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE = preferred;
+    }
+
+    if (legacy == null) {
+      delete process.env.AGENTSAM_IAM_OFFICIAL_RELEASE;
+    } else {
+      process.env.AGENTSAM_IAM_OFFICIAL_RELEASE = legacy;
+    }
+  }
+});
+
+test('InnerAnimalMedia official registry normalizes deployed lifecycle status to D1 production', () => {
+  const prior = process.env.AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE;
+  process.env.AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE = '1';
+  try {
+    const result = applyInnerAnimalMediaOfficialGoProductRegistry({
+      productRoot: null,
+      officialRelease: true,
+      status: 'deployed',
+      dryRun: true,
+      skipRemote: true,
+    });
+    assert.match(result.sql, /'production'/);
+    assert.doesNotMatch(result.sql, /'deployed',\n  'AgentSam Go runtime/);
+  } finally {
+    if (prior == null) delete process.env.AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE;
+    else process.env.AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE = prior;
+  }
+});
+
+
+test('legacy AGENTSAM_IAM_OFFICIAL_RELEASE guard remains backward compatible', () => {
+  const preferred = process.env.AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE;
+  const legacy = process.env.AGENTSAM_IAM_OFFICIAL_RELEASE;
+
+  delete process.env.AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE;
+  process.env.AGENTSAM_IAM_OFFICIAL_RELEASE = '1';
+
+  try {
+    const result = applyInnerAnimalMediaOfficialGoProductRegistry({
+      productRoot: null,
+      officialRelease: true,
+      status: 'deployed',
+      dryRun: true,
+      skipRemote: true,
+    });
+
+    assert.equal(result.ok, true);
+    assert.match(result.sql, /'production'/);
+  } finally {
+    if (preferred == null) {
+      delete process.env.AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE;
+    } else {
+      process.env.AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE = preferred;
+    }
+
+    if (legacy == null) {
+      delete process.env.AGENTSAM_IAM_OFFICIAL_RELEASE;
+    } else {
+      process.env.AGENTSAM_IAM_OFFICIAL_RELEASE = legacy;
+    }
+  }
+});

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

@@ -1,53 +1,317 @@
 import assert from 'node:assert/strict';
+import path from 'node:path';
 import test from 'node:test';
-import { extractWorkersDevUrl, probeGoDeployment } from '../../src/go/cloudflare.js';
+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 deterministic Go capabilities', async () => {
+test('probeGoDeployment requires edge, source identity, capabilities, deterministic functions and ErrorEnvelope', async () => {
   const responses = new Map([
-    ['/health', { status: 200, body: { ok: true, service: 'agentsam-go-worker', runtime: 'go' } }],
-    ['/v1/runtime', { status: 200, body: { schema: 'agentsam.go-runtime.v1', capabilities: ['hash'] } }],
-    ['/v1/hash', { status: 200, body: { hash: 'a'.repeat(64), algorithm: 'sha256' } }],
+    ['/', { 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, init = {}) => {
+  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, error: 'files_required' }; },
+          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 });
+
+  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('buildProductRow stays on agentsam_products projection', () => {
+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: 'agentsam-sdk',
+    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/cli-help.test.mjs

@@ -14,7 +14,7 @@ test('agentsam help is concise, topic-aware, and deterministic outside a TTY', (
   assert.equal(help.status, 0, help.stderr);
   assert.doesNotMatch(help.stderr, /Unknown command/);
   assert.match(help.stdout, /Agent Sam/);
-  assert.match(help.stdout, /Type normally to work with Agent Sam/);
+  assert.match(help.stdout, /SAM = Systematic Autonomous Machinery/);
   assert.match(help.stdout, /agentsam help <topic>/);
   assert.match(help.stdout, /press \/ for the command picker/i);
   assert.doesNotMatch(help.stdout, /Inspect options:/);

package/test/integration/cms-site-tenancy-contract.test.mjs

@@ -143,13 +143,13 @@ test('homepage.html is decomposed into reusable site partials with relative link
   assert.ok(header.length > 500, 'header.html must contain full header content');
   assert.ok(footer.length > 500, 'footer.html must contain full footer content');
 
-  // Relative navigation links (R2 partial SSOT)
-  assert.match(header, /href="\/work"/);
-  assert.match(header, /href="\/about"/);
-  assert.match(header, /href="\/services"/);
-  assert.match(header, /href="\/contact"/);
+  // AgentSam public header navigation is relative and product-specific (R2 partial SSOT).
+  assert.match(header, /href="\/"/);
+  assert.match(header, /href="\/learn\/"/);
+  assert.match(header, /href="\/themes\/"/);
+  assert.match(header, /href="\/packages\/sdk\/help\/"/);
   assert.match(header, /href="\/auth\/login\?next=\/agentsam"/);
-  assert.doesNotMatch(header, /href="https:\/\/inneranimalmedia\.com\/(work|about|services|contact)"/);
+  assert.doesNotMatch(header, /href="https:\/\/inneranimalmedia\.com\/(learn|themes|packages\/sdk|agentsam)"/);
 
   assert.match(footer, /href="\/work"/);
   assert.match(footer, /href="\/about"/);