@inneranimalmedia/agentsam-sdk 2.6.3 → 2.6.5

package/src/commands/go.js

@@ -1,16 +1,20 @@
 import path from 'node:path';
-import { cancel, intro, isCancel, outro, select } from '@clack/prompts';
+import { cancel, confirm, intro, isCancel, outro, select } from '@clack/prompts';
 import pc from 'picocolors';
 import {
   DEFAULT_PRODUCT,
   discoverGoRuntime,
   resolveProductRoot,
+  resolveGoStateRoot,
   ensureProductContract,
   preflightToolchain,
   buildGoProduct,
   deployGoCloudflare,
+  resolveWranglerIdentity,
+  verifyGoContainer,
   verifyGoProduct,
   readLatestStatus,
+  innerAnimalMediaOfficialReleaseEnabled,
   runGoTests,
   runGoVet,
   runGoBuild,
@@ -27,6 +31,9 @@ function parse(argv = []) {
     dryRun: false,
     skipDeploy: false,
     skipRegistry: false,
+    accountId: null,
+    officialRelease: false,
+    yes: false,
     help: false,
     positionals: [],
   };
@@ -38,6 +45,9 @@ function parse(argv = []) {
     else if (arg === '--dry-run') out.dryRun = true;
     else if (arg === '--skip-deploy') out.skipDeploy = true;
     else if (arg === '--skip-registry') out.skipRegistry = true;
+    else if (arg === '--official-release') out.officialRelease = true;
+    else if (arg === '--yes' || arg === '-y') out.yes = true;
+    else if (arg === '--account') out.accountId = String(argv[++i] || '').trim() || null;
     else if (arg === '--cwd') out.cwd = path.resolve(argv[++i] || out.cwd);
     else if (arg === '--cloudflare') {
       out.cloudflare = true;
@@ -72,27 +82,88 @@ function parse(argv = []) {
 
 const HELP = `Agent Sam · Go
 
+  Normal AgentSam use does not require deploying this service.
+  This command is for maintainers, contributors, and advanced self-hosters.
+
   agentsam go                         Interactive status / actions (TTY)
-  agentsam go status [--json]         Runtime + product status
+  agentsam go status [--json]         Runtime + service status
   agentsam go explore                 Architecture + operation wireframes (ANSI)
-  agentsam go inspect [--json]        Discover Go source / toolchain
+  agentsam go inspect [--json]        Discover packaged/development Go source
   agentsam go test                    go test ./...
-  agentsam go build                   go build + build receipt
+  agentsam go build                   go build + local build receipt
   agentsam go verify [name] [--json]  Local tests + optional live probe
-  agentsam go --cloudflare [name]      Discover → build → validate → deploy → probe → D1 → receipt
+  agentsam go --cloudflare [name]     Self-host in YOUR explicit Cloudflare account
   agentsam go deploy [name] --cloudflare
 
-  First happy path:
-    agentsam go --cloudflare agentsam-go-worker
+  Self-host dry-run:
+    agentsam go --cloudflare agentsam-go-worker --dry-run --account <account-id>
+
+  Live self-host:
+    agentsam go --cloudflare agentsam-go-worker --account <account-id> --yes
+
+  InnerAnimalMedia official release only:
+    AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE=1 agentsam go --cloudflare agentsam-go-worker --official-release --account <account-id> --yes
 
   Flags:
-    --json            Machine-readable output
-    --dry-run         Validate and print plan without deploying
-    --skip-deploy     Build/test/receipt only (no Wrangler deploy)
-    --skip-registry   Skip remote D1 agentsam_products upsert
-    --cwd <path>      Repository root override
+    --account <id>       Explicit Cloudflare account target
+    --yes, -y            Confirm a live non-interactive deployment
+    --json               Machine-readable output
+    --dry-run            Build/probe + Wrangler dry-run; no live deploy or InnerAnimalMedia registry write
+    --skip-deploy        Build/test/receipt only
+    --skip-registry      Official-release escape hatch; self-host is isolated by default
+    --official-release   InnerAnimalMedia maintainer mode; guarded and never the self-host default
+    --cwd <path>         Caller project/repository root
 `;
 
+function portableStatusPath(value, root) {
+  if (!value) return null;
+  const absolute = path.resolve(value);
+  const base = root ? path.resolve(root) : null;
+
+  if (base) {
+    const rel = path.relative(base, absolute);
+    if (
+      rel
+      && rel !== '..'
+      && !rel.startsWith('..' + path.sep)
+      && !path.isAbsolute(rel)
+    ) {
+      return rel.split(path.sep).join('/');
+    }
+  }
+
+  return path.basename(absolute);
+}
+
+function publicBuildReceipt(receipt) {
+  if (!receipt) return null;
+  const out = JSON.parse(JSON.stringify(receipt));
+
+  if (out.probe && 'origin' in out.probe) {
+    delete out.probe.origin;
+  }
+
+  return out;
+}
+
+function publicBuildResult(result, root) {
+  if (!result) return null;
+  const out = JSON.parse(JSON.stringify(result));
+
+  out.receipt = publicBuildReceipt(result.receipt);
+  out.receiptPath = portableStatusPath(result.receiptPath, root);
+
+  if (out.build?.binary) {
+    out.build.binary = portableStatusPath(result.build.binary, root);
+  }
+
+  if (out.probe && 'origin' in out.probe) {
+    delete out.probe.origin;
+  }
+
+  return out;
+}
+
 function writeHumanSteps(lines, write) {
   write('\n  Agent Sam · Go\n\n');
   for (const line of lines) write(`  ${line}\n`);
@@ -109,14 +180,17 @@ export async function runGo(argv = [], options = {}) {
 
   const discovery = discoverGoRuntime(args.cwd);
   const productRoot = resolveProductRoot(discovery, args.product);
+  const stateRoot = options.stateRoot
+    ? path.resolve(options.stateRoot)
+    : resolveGoStateRoot(discovery, args.cwd);
   const runtimeRoot = discovery.runtime?.runtimeRoot || path.join(productRoot, 'runtime');
 
   if (args.subcommand === 'menu' && process.stdout.isTTY && !args.json) {
-    return runInteractiveMenu({ discovery, productRoot, runtimeRoot, args, write });
+    return runInteractiveMenu({ discovery, productRoot, stateRoot, runtimeRoot, args, write });
   }
 
   if (args.subcommand === 'inspect' || args.subcommand === 'runtime') {
-    const payload = { ok: true, discovery, productRoot, runtimeRoot };
+    const payload = { ok: true, discovery, productRoot, stateRoot, runtimeRoot };
     write(args.json ? `${JSON.stringify(payload)}\n` : `${JSON.stringify(payload, null, 2)}\n`);
     return payload;
   }
@@ -125,8 +199,8 @@ export async function runGo(argv = [], options = {}) {
     const scenery = renderGoShipScenery({
       product: args.product,
       discovery,
-      deploy: { url: readLatestStatus(productRoot).deployment?.url, receipt: readLatestStatus(productRoot).deployment, probes: { ok: readLatestStatus(productRoot).deployment?.health === 'healthy' } },
-      build: { receipt: readLatestStatus(productRoot).build },
+      deploy: { url: readLatestStatus(stateRoot).deployment?.url, receipt: readLatestStatus(stateRoot).deployment, probes: { ok: readLatestStatus(stateRoot).deployment?.health === 'healthy' } },
+      build: { receipt: readLatestStatus(stateRoot).build },
     });
     if (args.json) {
       write(`${JSON.stringify({ ok: true, scenery: 'ansi', product: args.product })}\n`);
@@ -138,20 +212,103 @@ export async function runGo(argv = [], options = {}) {
   }
 
   if (args.subcommand === 'status' || args.subcommand === 'products') {
-    const latest = readLatestStatus(productRoot);
+    const latest = readLatestStatus(stateRoot);
+
+    const production = (
+      latest.deployment
+      && latest.deployment.dry_run !== true
+      && latest.deployment.deployed_at
+    )
+      ? {
+          provider: latest.deployment.provider || null,
+          target: 'cloudflare',
+          canonical_url: latest.deployment.url || null,
+          account_id: latest.deployment.cloudflare?.account_id || null,
+          deployment_id: latest.deployment.worker_deployment_id || null,
+          version_id: latest.deployment.worker_version_id || null,
+          container_image_digest: latest.deployment.container_image_digest || null,
+          deployed_at: latest.deployment.deployed_at || null,
+          health: latest.deployment.health || null,
+          probe: {
+            origin: latest.deployment.url || null,
+            status: latest.deployment.probes?.skipped
+              ? 'pending'
+              : latest.deployment.probes?.ok
+                ? 'passed'
+                : 'failed',
+          },
+        }
+      : null;
+
     const status = {
       ok: true,
       product: args.product,
       discovery: {
         go: discovery.go,
         runtime: discovery.runtime
-          ? { module: discovery.runtime.module, runtimeRoot: discovery.runtime.runtimeRoot, entry: discovery.runtime.entry }
+          ? {
+              module: discovery.runtime.module,
+              runtimeRoot: portableStatusPath(
+                discovery.runtime.runtimeRoot,
+                discovery.repository_root || args.cwd,
+              ),
+              entry: portableStatusPath(
+                discovery.runtime.entry,
+                discovery.repository_root || args.cwd,
+              ),
+            }
           : null,
         product_exists: discovery.product_exists,
       },
-      build: latest.build,
+      source: {
+        repository_id:
+          latest.product?.row?.repository_id
+          || latest.build?.source?.repository_id
+          || null,
+        commit:
+          latest.deployment?.source_commit
+          || latest.build?.source?.commit
+          || null,
+        identity:
+          latest.deployment?.source_identity
+          || latest.build?.source?.identity
+          || null,
+        package:
+          latest.deployment?.source_package
+          || latest.build?.source?.package_name
+          || null,
+        version:
+          latest.deployment?.source_package_version
+          || latest.build?.source?.package_version
+          || null,
+      },
+      verification: {
+        local_native_probe: {
+          target: 'local',
+          status: latest.build?.probe?.ok
+            ? 'passed'
+            : latest.build
+              ? 'failed'
+              : 'unknown',
+        },
+        container: {
+          target: 'linux/amd64',
+          status: latest.deployment?.container_image_digest
+            ? 'passed'
+            : 'unknown',
+        },
+      },
+      production,
+      build: publicBuildReceipt(latest.build),
       deployment: latest.deployment,
-      registry: latest.product,
+      registry: latest.product
+        ? {
+            ...latest.product,
+            authority: latest.deployment?.official_release
+              ? 'inneranimalmedia'
+              : 'local',
+          }
+        : null,
     };
     if (args.json) write(`${JSON.stringify(status)}\n`);
     else {
@@ -184,15 +341,25 @@ export async function runGo(argv = [], options = {}) {
       productRoot,
       runtimeRoot,
       repositoryRoot: discovery.repository_root,
+      stateRoot,
       dryRun: args.dryRun,
     });
-    write(args.json ? `${JSON.stringify(result)}\n` : `✓ build receipt · ${result.receiptPath}\n`);
+    const publicResult = publicBuildResult(
+      result,
+      discovery.repository_root || args.cwd,
+    );
+    write(
+      args.json
+        ? `${JSON.stringify(publicResult)}\n`
+        : `✓ build receipt · ${publicResult.receiptPath}\n`,
+    );
     return result;
   }
 
   if (args.subcommand === 'verify') {
     const result = await verifyGoProduct({
       productRoot,
+      stateRoot,
       runtimeRoot,
       skipLive: args.dryRun || args.skipDeploy,
     });
@@ -206,33 +373,124 @@ export async function runGo(argv = [], options = {}) {
   }
 
   if (args.subcommand === 'deploy' || args.subcommand === 'cloudflare-ship') {
-    return shipCloudflare({ discovery, productRoot, runtimeRoot, args, write });
+    return shipCloudflare({ discovery, productRoot, stateRoot, runtimeRoot, args, write, options });
   }
 
   write(HELP);
   return { ok: true, help: true };
 }
 
-async function shipCloudflare({ discovery, productRoot, runtimeRoot, args, write }) {
+async function shipCloudflare({ discovery, productRoot, stateRoot, runtimeRoot, args, write, options = {} }) {
   const steps = [];
   const note = (line) => {
     steps.push(line);
-    if (!args.json) write(`  ${line}\n`);
+    if (!args.json) write('  ' + line + '\n');
   };
 
   if (!args.json) write('\n  Agent Sam · Go\n\n');
 
   note(discovery.runtime ? '✓ existing AgentSam Go runtime discovered' : '✗ Go runtime missing');
   if (!discovery.runtime) throw new Error('go_runtime_not_found');
+  note('✓ source · ' + (discovery.distribution?.origin || discovery.runtime.origin || 'unknown')
+    + (discovery.distribution?.package_name
+      ? ' · ' + discovery.distribution.package_name + '@' + discovery.distribution.package_version
+      : ''));
   note(discovery.go?.ok ? '✓ go toolchain' : '✗ go toolchain');
   if (!discovery.go?.ok) throw new Error('go_toolchain_missing');
 
+  if (args.officialRelease) {
+    if (!innerAnimalMediaOfficialReleaseEnabled()) {
+      const err = new Error('inneranimalmedia_official_release_guard_missing');
+      err.code = 'inneranimalmedia_official_release_guard_missing';
+      err.legacy_code = 'iam_official_release_guard_missing';
+      err.hint = 'Set AGENTSAM_INNERANIMALMEDIA_OFFICIAL_RELEASE=1 only in the authorized InnerAnimalMedia maintainer release flow.';
+      throw err;
+    }
+    if (
+      String(process.env.CI || '').toLowerCase() === 'true'
+      && process.env.AGENTSAM_ALLOW_CI_OFFICIAL_RELEASE !== '1'
+    ) {
+      const err = new Error('inneranimalmedia_official_release_ci_guard_missing');
+      err.hint = 'Official production deployment is disabled in CI unless AGENTSAM_ALLOW_CI_OFFICIAL_RELEASE=1 is explicitly set by a manual release workflow.';
+      throw err;
+    }
+    if (discovery.runtime?.origin !== 'repository' && discovery.runtime?.origin !== 'sdk_development_tree') {
+      const err = new Error('inneranimalmedia_official_release_requires_maintainer_source');
+      err.code = 'inneranimalmedia_official_release_requires_maintainer_source';
+      err.legacy_code = 'iam_official_release_requires_maintainer_source';
+      err.hint = 'Official InnerAnimalMedia releases must originate from the AgentSam SDK maintainer source tree.';
+      throw err;
+    }
+    note('✓ release mode · InnerAnimalMedia official');
+  } else {
+    note('✓ release mode · self-host · InnerAnimalMedia D1 isolated');
+  }
+
+  let cfIdentity = null;
+  if (!args.skipDeploy) {
+    cfIdentity = resolveWranglerIdentity(productRoot, {
+      requestedAccountId: args.accountId,
+    });
+
+    if (!cfIdentity.ok && cfIdentity.error === 'cloudflare_account_ambiguous' && !args.json && process.stdout.isTTY) {
+      const selectImpl = options.selectImpl || select;
+      const chosen = await selectImpl({
+        message: 'Cloudflare account',
+        options: cfIdentity.accounts.map((account) => ({
+          value: account.id,
+          label: account.name || account.id,
+          hint: account.id,
+        })),
+      });
+      if (isCancel(chosen)) {
+        cancel('Cloudflare deployment cancelled.');
+        return { ok: false, cancelled: true };
+      }
+      args.accountId = String(chosen);
+      cfIdentity = resolveWranglerIdentity(productRoot, {
+        requestedAccountId: args.accountId,
+      });
+    }
+
+    if (!cfIdentity.ok || !cfIdentity.account?.id) {
+      const err = new Error(cfIdentity.error || 'cloudflare_identity_unavailable');
+      err.detail = cfIdentity;
+      err.hint = cfIdentity.error === 'cloudflare_account_ambiguous'
+        ? 'Pass --account <account-id> so the deployment target is explicit.'
+        : 'Authenticate Wrangler with your Cloudflare account before self-hosting.';
+      throw err;
+    }
+
+    args.accountId = cfIdentity.account.id;
+    note('✓ Cloudflare identity · ' + (cfIdentity.auth_type || 'authenticated'));
+    note('✓ Cloudflare account · ' + (cfIdentity.account.name || 'unnamed') + ' · ' + cfIdentity.account.id);
+
+    if (!args.dryRun && !args.yes) {
+      if (args.json || !process.stdout.isTTY) {
+        const err = new Error('cloudflare_deploy_confirmation_required');
+        err.hint = 'Re-run with --yes after reviewing the resolved Cloudflare account target.';
+        throw err;
+      }
+      const confirmImpl = options.confirmImpl || confirm;
+      const approved = await confirmImpl({
+        message: 'Deploy ' + args.product + ' to ' + (cfIdentity.account.name || cfIdentity.account.id)
+          + ' (' + cfIdentity.account.id + ')?',
+        initialValue: false,
+      });
+      if (isCancel(approved) || approved !== true) {
+        cancel('Cloudflare deployment cancelled.');
+        return { ok: false, cancelled: true };
+      }
+    }
+  }
+
   const preflight = preflightToolchain({
-    requireDocker: !(args.dryRun || args.skipDeploy),
+    requireDocker: !args.skipDeploy,
     productRoot,
   });
   for (const check of preflight.checks) {
-    note(`${check.ok ? '✓' : '·'} ${check.id}${check.detail ? ` · ${String(check.detail).slice(0, 80)}` : ''}`);
+    note((check.ok ? '✓' : '·') + ' ' + check.id
+      + (check.detail ? ' · ' + String(check.detail).slice(0, 80) : ''));
   }
 
   const contract = ensureProductContract(productRoot);
@@ -240,9 +498,10 @@ async function shipCloudflare({ discovery, productRoot, runtimeRoot, args, write
   note('✓ deployment contract · cloudflare worker-container');
 
   if (!args.json) {
-    write(`\n  Product\n    ${args.product}\n`);
+    write('\n  Product\n    ' + args.product + '\n');
     write('  Target\n    cloudflare\n');
-    write('  Runtime\n    go/native + worker edge\n\n');
+    write('  Runtime\n    go/native + worker edge\n');
+    write('  State\n    ' + stateRoot + '\n\n');
   }
 
   if (!args.json) write('  Building\n');
@@ -250,63 +509,114 @@ async function shipCloudflare({ discovery, productRoot, runtimeRoot, args, write
     productRoot,
     runtimeRoot,
     repositoryRoot: discovery.repository_root,
-    dryRun: args.dryRun,
+    stateRoot,
+    dryRun: false,
   });
+  note('✓ source identity · ' + build.receipt.source.identity);
   note('✓ go test ./...');
   note('✓ go vet ./...');
-  note(build.build.binary ? `✓ Go binary · ${path.basename(build.build.binary)}` : '✓ Go build skipped (dry-run)');
+  note('✓ Go binary · ' + path.basename(build.build.binary) + ' · ' + build.receipt.artifact.digest);
+  note('✓ native runtime boot/probe/shutdown');
+
+  let container = null;
+  if (!args.skipDeploy) {
+    if (!args.json) write('\n  Container\n');
+    container = await verifyGoContainer({
+      productRoot,
+      product: args.product,
+      expectedSource: build.receipt.source.identity,
+      expectedSourceCommit: build.receipt.source.commit,
+      expectedBuiltAt: build.receipt.built_at,
+    });
+    note('✓ linux/' + container.architecture + ' · ' + container.user);
+    note('✓ container runtime probe · ' + container.image_digest);
+  }
 
   if (!args.json) write('\n  Deploying\n');
   const deploy = await deployGoCloudflare({
     productRoot,
+    stateRoot,
     product: args.product,
     dryRun: args.dryRun,
     skipDeploy: args.skipDeploy,
     skipRegistry: args.skipRegistry,
+    officialRelease: args.officialRelease,
+    accountId: args.accountId,
+    cloudflareIdentity: cfIdentity,
+    source: build.receipt.source,
+    builtAt: build.receipt.built_at,
+    artifactDigest: build.receipt.artifact.digest,
+    containerDigest: container?.image_digest || null,
   });
-  if (deploy.deployed) note(`✓ ${args.product}`);
-  else if (args.dryRun) note('· dry-run · deploy skipped');
+
+  if (deploy.deployed) note('✓ ' + args.product + ' · ' + deploy.deploymentId + ' · ' + deploy.versionId);
+  else if (args.dryRun && deploy.dryRunValidated) note('✓ Wrangler dry-run validated Worker + Container config');
   else if (args.skipDeploy) note('· skip-deploy · local receipts only');
   else note('· deploy not completed');
 
-  if (deploy.url && !args.json) write(`\n  Live\n    ${deploy.url}\n`);
+  if (deploy.url && !args.json) write('\n  Live\n    ' + deploy.url + '\n');
   if (!args.json) write('\n  Validation\n');
   if (deploy.probes?.results) {
     for (const [key, value] of Object.entries(deploy.probes.results)) {
-      note(`${value.ok ? '✓' : '✗'} ${key}`);
+      // The raw malformed request is expected to return HTTP 400. Its
+      // correctness is represented by malformed_rejected/error_envelope.
+      if (key === 'malformed') continue;
+
+      const label = key === 'malformed_rejected'
+        ? 'malformed input rejected'
+        : key;
+
+      note((value.ok ? '✓' : '✗') + ' ' + label);
     }
   } else {
     note('· live probes skipped');
   }
 
-  if (!args.json) write('\n  Registered\n');
-  if (deploy.registry?.remote) note('✓ agentsam_products · remote D1 upsert');
-  else if (deploy.registry?.skipped) note(`· agentsam_products · ${deploy.registry.reason || 'local only'}`);
-  else note('✓ agentsam_products (local projection)');
-  if (deploy.registry?.remote) note('✓ asset_relationships · remote D1 upsert');
-  else note('✓ asset relationships (local metadata)');
+  if (!args.json) write('\n  Registry\n');
+  if (deploy.registry?.remote) {
+    note('✓ InnerAnimalMedia agentsam_products + asset_relationships · official release');
+  } else if (!args.officialRelease) {
+    note('✓ local AgentSam registry · InnerAnimalMedia D1 isolated');
+  } else {
+    note('· InnerAnimalMedia registry · ' + (deploy.registry?.reason || 'not written'));
+  }
   note('✓ deployment receipt');
 
+  const buildOk = Boolean(
+    build.receipt.tests.go_test
+    && build.receipt.tests.go_vet
+    && build.receipt.tests.runtime_probe
+    && build.receipt.artifact.digest
+    && build.receipt.source.identity,
+  );
+  const containerOk = args.skipDeploy ? true : Boolean(container?.ok && container?.image_digest);
+  const deploymentOk = args.skipDeploy
+    ? true
+    : (args.dryRun ? Boolean(deploy.dryRunValidated) : Boolean(deploy.deployed && deploy.probes?.ok));
+  const registryOk = !args.officialRelease
+    ? deploy.registry?.reason === 'self_host_registry_isolated'
+    : (args.skipRegistry || args.dryRun || args.skipDeploy ? true : Boolean(deploy.registry?.remote));
+
   const payload = {
-    ok: Boolean(build && (args.dryRun || args.skipDeploy || deploy.probes?.ok || deploy.deployed)),
+    ok: buildOk && containerOk && deploymentOk && registryOk,
+    mode: args.officialRelease ? 'inneranimalmedia_official_release' : 'self_host',
     product: args.product,
+    state_root: stateRoot,
+    cloudflare: deploy.cloudflare,
     existing_product: contract.existing,
     scaffold_changes_required: contract.created.length > 0,
     discovery,
     contract,
     build: build.receipt,
+    container,
     deploy,
     steps,
   };
 
-  // Idempotent success: second run with healthy prior deploy still ok even if live probe skipped.
-  if (args.dryRun || args.skipDeploy) payload.ok = true;
-  if (deploy.deployed && deploy.probes && !deploy.probes.skipped) payload.ok = deploy.probes.ok;
-
-  if (args.json) write(`${JSON.stringify(payload)}\n`);
+  if (args.json) write(JSON.stringify(payload) + '\n');
   else {
-    write(`\n${renderGoShipScenery({ product: args.product, discovery, deploy, build })}\n`);
-    write(`\n  ${payload.ok ? 'ready' : 'incomplete'} · ${args.product}\n`);
+    write('\n' + renderGoShipScenery({ product: args.product, discovery, deploy, build }) + '\n');
+    write('\n  ' + (payload.ok ? 'ready' : 'incomplete') + ' · ' + args.product + '\n');
     if (contract.existing && !contract.created.length) {
       write('  ✓ existing product · update/redeploy path (no sibling scaffold)\n');
     }
@@ -322,9 +632,9 @@ async function shipCloudflare({ discovery, productRoot, runtimeRoot, args, write
   return payload;
 }
 
-async function runInteractiveMenu({ discovery, productRoot, runtimeRoot, args, write }) {
+async function runInteractiveMenu({ discovery, productRoot, stateRoot, runtimeRoot, args, write }) {
   intro(pc.bgCyan(pc.black(' Agent Sam · Go ')));
-  const status = readLatestStatus(productRoot);
+  const status = readLatestStatus(stateRoot);
   write(`\n  Runtime\n`);
   write(`    ${discovery.go?.ok ? '✓' : '✗'} Go ${discovery.go?.goversion || ''}\n`);
   write(`    ${discovery.runtime ? '✓' : '✗'} AgentSam Go source discovered\n`);
@@ -339,7 +649,7 @@ async function runInteractiveMenu({ discovery, productRoot, runtimeRoot, args, w
       package: args.product,
       owns: 'Go runtime + CF container edge',
       runtime: 'go/native + worker',
-      imported_by: 'CLI · deploy adapter · D1 registry',
+      imported_by: 'CLI · deploy adapter · local registry · InnerAnimalMedia official registry',
       files: 'main.go · wrangler · Dockerfile',
     },
   })}\n\n`);
@@ -351,7 +661,7 @@ async function runInteractiveMenu({ discovery, productRoot, runtimeRoot, args, w
       { value: 'build', label: 'Build' },
       { value: 'test', label: 'Test' },
       { value: 'inspect', label: 'Inspect' },
-      { value: 'cloudflare-ship', label: 'Deploy to Cloudflare' },
+      { value: 'deploy', label: 'Self-host on Cloudflare' },
       { value: 'verify', label: 'Verify deployment' },
       { value: 'status', label: 'Show runtime' },
     ],
@@ -361,5 +671,8 @@ async function runInteractiveMenu({ discovery, productRoot, runtimeRoot, args, w
     return { ok: false, cancelled: true };
   }
   outro(`Running ${action}`);
-  return runGo([action, args.product, ...(args.json ? ['--json'] : [])], { write });
+  const forwarded = [action, args.product, '--cwd', args.cwd];
+  if (action === 'deploy') forwarded.push('--cloudflare');
+  if (args.json) forwarded.push('--json');
+  return runGo(forwarded, { write });
 }