@inneranimalmedia/agentsam-sdk 2.6.1 → 2.6.3

package/src/commands/eval.js

@@ -1,12 +1,62 @@
-import { evaluateContextFixture, listContextEvalFixtures } from '../eval/index.js';
+import {
+  evaluateContextFixture,
+  finishLiveEvalRun,
+  getLiveEvalStatus,
+  listContextEvalFixtures,
+  startLiveEvalRun,
+} from '../eval/index.js';
 
 function parse(argv) {
-  const out = { subcommand: argv[0] || '', fixture: '', strategy: 'all', model: 'gpt-6-astra', json: false, list: false };
-  for (let i = 1; i < argv.length; i += 1) {
+  let subcommand = argv[0] || '';
+  let help = false;
+  if (subcommand === '--help' || subcommand === '-h') {
+    help = true;
+    subcommand = '';
+  }
+  const action = argv[1] || '';
+  const out = {
+    subcommand,
+    action,
+    fixture: '',
+    strategy: 'all',
+    model: '',
+    provider: '',
+    client: '',
+    reasoning: 'high',
+    suite: '',
+    case: '',
+    gate: '',
+    tenant: '',
+    workspace: '',
+    user: '',
+    database: '',
+    endpoint: '',
+    force: false,
+    remote: false,
+    json: false,
+    list: false,
+    help,
+  };
+
+  const startIndex = subcommand === 'live' ? 2 : 1;
+  for (let i = startIndex; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === '--fixture') out.fixture = argv[++i] || '';
     else if (arg === '--strategy') out.strategy = argv[++i] || 'all';
-    else if (arg === '--model') out.model = argv[++i] || 'gpt-6-astra';
+    else if (arg === '--model') out.model = argv[++i] || '';
+    else if (arg === '--provider') out.provider = argv[++i] || '';
+    else if (arg === '--client') out.client = argv[++i] || '';
+    else if (arg === '--reasoning') out.reasoning = argv[++i] || 'high';
+    else if (arg === '--suite') out.suite = argv[++i] || '';
+    else if (arg === '--case') out.case = argv[++i] || '';
+    else if (arg === '--gate') out.gate = argv[++i] || '';
+    else if (arg === '--tenant') out.tenant = argv[++i] || '';
+    else if (arg === '--workspace') out.workspace = argv[++i] || '';
+    else if (arg === '--user') out.user = argv[++i] || '';
+    else if (arg === '--database' || arg === '--db') out.database = argv[++i] || '';
+    else if (arg === '--endpoint') out.endpoint = argv[++i] || '';
+    else if (arg === '--force') out.force = true;
+    else if (arg === '--remote') out.remote = true;
     else if (arg === '--json') out.json = true;
     else if (arg === '--list') out.list = true;
     else if (arg === '--help' || arg === '-h') out.help = true;
@@ -15,7 +65,7 @@ function parse(argv) {
   return out;
 }
 
-function render(report) {
+function renderContextReport(report) {
   const rows = [
     '',
     '  AgentSam · Context Eval',
@@ -45,19 +95,164 @@ function render(report) {
   return rows.join('\n');
 }
 
+function renderLiveHelp() {
+  return `
+  AgentSam · Live Agent Evaluation
+
+  Usage:
+    agentsam eval live start --case <id> [--suite <id>] [--model <name>] [--provider <name>] [--client <client>] [--reasoning <high|medium|low>]
+    agentsam eval live status [--json]
+    agentsam eval live finish [--gate PASS|FAIL] [--remote] [--json]
+
+  Examples:
+    agentsam eval live start --suite sdk-real-work-20260919 --case cad-shell-unification --client cursor --model "Muse Spark 1.3"
+    agentsam eval live finish --gate PASS --remote
+`;
+}
+
 export async function runEval(argv = [], options = {}) {
   const args = parse(argv);
-  const write = options.write || (text => process.stdout.write(text));
-  if (args.help || args.subcommand !== 'context') {
+  const write = options.write || ((text) => process.stdout.write(text));
+
+  if (args.help || (!args.subcommand && !argv.length)) {
     write('agentsam eval context --fixture <name> [--strategy bounded|discovery|compact|all] [--model gpt-6-astra] [--json]\n');
+    write('agentsam eval live <start|status|finish> [options]\n');
     return null;
   }
-  if (args.list) {
-    const value = { fixtures: listContextEvalFixtures() };
-    write(args.json ? `${JSON.stringify(value)}\n` : `${value.fixtures.join('\n')}\n`);
-    return value;
+
+  if (args.subcommand === 'live') {
+    const action = args.action || 'status';
+
+    if (args.help || !action) {
+      write(renderLiveHelp());
+      return null;
+    }
+
+    if (action === 'start') {
+      const run = startLiveEvalRun(
+        {
+          suite: args.suite,
+          case: args.case,
+          model: args.model,
+          provider: args.provider,
+          client: args.client,
+          reasoning: args.reasoning,
+          tenant: args.tenant,
+          workspace: args.workspace,
+          user: args.user,
+          database: args.database,
+        },
+        options
+      );
+
+      if (args.json) {
+        write(JSON.stringify(run, null, 2) + '\n');
+        return run;
+      }
+
+      write(`\n  ✓ Started live eval run: ${run.run_id}\n`);
+      write(`      Suite:      ${run.suite_id}\n`);
+      write(`      Case:       ${run.case_id}\n`);
+      write(`      Tenant:     ${run.tenant_id}\n`);
+      write(`      Model:      ${run.model} (${run.reasoning} reasoning)\n`);
+      write(`      Client:     ${run.client} (${run.provider})\n`);
+      write(`      Base Git:   ${run.base_commit.slice(0, 7) || 'clean'} on ${run.branch || 'main'}\n`);
+      write(`      Started:    ${run.started_at}\n\n`);
+      return run;
+    }
+
+    if (action === 'status') {
+      const status = getLiveEvalStatus(options);
+      if (args.json) {
+        write(JSON.stringify(status, null, 2) + '\n');
+        return status;
+      }
+
+      if (!status.active) {
+        write('  No live evaluation run currently in progress.\n');
+        return status;
+      }
+
+      const elapsedSec = (status.elapsed_ms / 1000).toFixed(1);
+      write(`\n  Live Eval In Progress · ${status.run_id}\n`);
+      write(`      Case:       ${status.case_id} (${status.suite_id})\n`);
+      write(`      Tenant:     ${status.tenant_id || 'default'}\n`);
+      write(`      Model:      ${status.model} [${status.client}]\n`);
+      write(`      Elapsed:    ${elapsedSec}s\n`);
+      write(`      Tool calls: ${status.receipts_summary?.tool_call_count || 0} (${status.receipts_summary?.mcp_call_count || 0} MCP)\n\n`);
+      return status;
+    }
+
+    if (action === 'finish') {
+      const result = await finishLiveEvalRun({
+        ...options,
+        gate: args.gate,
+        remote: args.remote,
+        tenant: args.tenant,
+        workspace: args.workspace,
+        user: args.user,
+        database: args.database,
+        evalEndpoint: args.endpoint,
+        force: args.force,
+      });
+
+      if (args.json) {
+        write(JSON.stringify(result, null, 2) + '\n');
+        return result;
+      }
+
+      const s = result.summary;
+      const elapsedMin = (s.elapsed_ms / 60000).toFixed(1);
+
+      write(`\n  AgentSam Live Eval Summary\n`);
+      write(`  ────────────────────────────────────────────────────────────\n`);
+      write(`  Model:             ${s.model} (${s.reasoning || 'high'})\n`);
+      write(`  Case:              ${s.case_id} (${s.suite_id})\n`);
+      write(`  Tenant:            ${s.tenant_id}\n`);
+      write(`  Run ID:            ${result.evalRunRow.id}\n`);
+      write(`  Observation ID:    ${result.modelObservationRow?.id || 'N/A'}\n`);
+      write(`  Elapsed:           ${elapsedMin}m (${(s.elapsed_ms / 1000).toFixed(1)}s)\n`);
+      write(`  Files changed:     ${s.files_changed} (+${s.insertions} / -${s.deletions})\n`);
+      write(`  Tool calls:        ${s.tool_call_count} total\n`);
+      write(`    • MCP calls:     ${s.mcp_call_count}\n`);
+      write(`    • Terminal:      ${s.terminal_call_count}\n`);
+      write(`    • GitHub:        ${s.github_call_count}\n`);
+      write(`    • D1 / Database: ${s.d1_call_count}\n`);
+      write(`    • Retries:       ${s.failure_count}\n`);
+      write(`  Gate status:       ${s.gate_status}\n`);
+      write(`  Commit:            ${s.head_commit?.slice(0, 7) || 'N/A'}\n`);
+      write(`  Local Archive:     ${result.local_file}\n`);
+      if (s.d1_executed) {
+        write(`  D1 Record:         ✓ Recorded to ${s.tenant_id} (runs & observations via ${s.persistence_method || 'remote'})\n`);
+      } else if (s.d1_error) {
+        write(`  D1 Record:         ⚠ Remote persistence failed: ${s.d1_error}\n`);
+        if (s.state_preserved) {
+          write(`  Status:            Active run & telemetry preserved. Retry with --remote or pass --force\n`);
+        }
+      } else {
+        write(`  D1 Record:         ○ Local only (use --remote to push)\n`);
+      }
+      write(`  ────────────────────────────────────────────────────────────\n\n`);
+      return result;
+    }
+
+    throw new Error(`unknown live eval action: ${action}`);
   }
-  const report = await evaluateContextFixture({ fixture: args.fixture || 'exact-symbol-callers', strategy: args.strategy, model: args.model });
-  write(args.json ? `${JSON.stringify(report)}\n` : render(report));
-  return report;
+
+  if (args.subcommand === 'context') {
+    if (args.list) {
+      const value = { fixtures: listContextEvalFixtures() };
+      write(args.json ? `${JSON.stringify(value)}\n` : `${value.fixtures.join('\n')}\n`);
+      return value;
+    }
+    const report = await evaluateContextFixture({
+      fixture: args.fixture || 'exact-symbol-callers',
+      strategy: args.strategy,
+      model: args.model || 'gpt-6-astra',
+    });
+    write(args.json ? `${JSON.stringify(report)}\n` : renderContextReport(report));
+    return report;
+  }
+
+  throw new Error(`unknown eval subcommand: ${args.subcommand}`);
 }

package/src/commands/go.js

@@ -0,0 +1,365 @@
+import path from 'node:path';
+import { cancel, intro, isCancel, outro, select } from '@clack/prompts';
+import pc from 'picocolors';
+import {
+  DEFAULT_PRODUCT,
+  discoverGoRuntime,
+  resolveProductRoot,
+  ensureProductContract,
+  preflightToolchain,
+  buildGoProduct,
+  deployGoCloudflare,
+  verifyGoProduct,
+  readLatestStatus,
+  runGoTests,
+  runGoVet,
+  runGoBuild,
+} from '../go/index.js';
+import { renderGoShipScenery, renderArchitectureExplorer } from '../ui/wireframes.js';
+
+function parse(argv = []) {
+  const out = {
+    subcommand: null,
+    product: DEFAULT_PRODUCT,
+    cwd: process.cwd(),
+    json: false,
+    cloudflare: false,
+    dryRun: false,
+    skipDeploy: false,
+    skipRegistry: false,
+    help: false,
+    positionals: [],
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') out.help = true;
+    else if (arg === '--json') out.json = true;
+    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 === '--cwd') out.cwd = path.resolve(argv[++i] || out.cwd);
+    else if (arg === '--cloudflare') {
+      out.cloudflare = true;
+      const next = argv[i + 1];
+      if (next && !next.startsWith('-')) {
+        out.product = next;
+        i += 1;
+      }
+    } else if (['status', 'inspect', 'build', 'test', 'verify', 'deploy', 'products', 'runtime', 'dev', 'logs', 'explore'].includes(arg) && !out.subcommand) {
+      out.subcommand = arg;
+    } else if (!arg.startsWith('-')) {
+      out.positionals.push(arg);
+    } else {
+      throw new Error(`unknown go option: ${arg}`);
+    }
+  }
+
+  if (!out.subcommand && out.positionals[0] && !out.cloudflare) {
+    const maybe = out.positionals[0];
+    if (['status', 'inspect', 'build', 'test', 'verify', 'deploy', 'products', 'runtime', 'explore'].includes(maybe)) {
+      out.subcommand = maybe;
+      out.positionals = out.positionals.slice(1);
+    }
+  }
+  if (out.positionals[0] && out.product === DEFAULT_PRODUCT) {
+    out.product = out.positionals[0];
+  }
+  if (out.cloudflare && !out.subcommand) out.subcommand = 'cloudflare-ship';
+  if (!out.subcommand) out.subcommand = 'menu';
+  return out;
+}
+
+const HELP = `Agent Sam · Go
+
+  agentsam go                         Interactive status / actions (TTY)
+  agentsam go status [--json]         Runtime + product status
+  agentsam go explore                 Architecture + operation wireframes (ANSI)
+  agentsam go inspect [--json]        Discover Go source / toolchain
+  agentsam go test                    go test ./...
+  agentsam go build                   go build + 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 deploy [name] --cloudflare
+
+  First happy path:
+    agentsam go --cloudflare agentsam-go-worker
+
+  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
+`;
+
+function writeHumanSteps(lines, write) {
+  write('\n  Agent Sam · Go\n\n');
+  for (const line of lines) write(`  ${line}\n`);
+  write('\n');
+}
+
+export async function runGo(argv = [], options = {}) {
+  const args = parse(argv);
+  const write = options.write || ((value) => process.stdout.write(value));
+  if (args.help) {
+    write(HELP);
+    return { ok: true, help: true };
+  }
+
+  const discovery = discoverGoRuntime(args.cwd);
+  const productRoot = resolveProductRoot(discovery, args.product);
+  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 });
+  }
+
+  if (args.subcommand === 'inspect' || args.subcommand === 'runtime') {
+    const payload = { ok: true, discovery, productRoot, runtimeRoot };
+    write(args.json ? `${JSON.stringify(payload)}\n` : `${JSON.stringify(payload, null, 2)}\n`);
+    return payload;
+  }
+
+  if (args.subcommand === 'explore') {
+    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 },
+    });
+    if (args.json) {
+      write(`${JSON.stringify({ ok: true, scenery: 'ansi', product: args.product })}\n`);
+    } else {
+      write(`\n${scenery}\n\n`);
+      write(`${pc.dim('Wireframes are reasoning scenery for the inline CLI — not pixel mockups.')}\n\n`);
+    }
+    return { ok: true, explore: true };
+  }
+
+  if (args.subcommand === 'status' || args.subcommand === 'products') {
+    const latest = readLatestStatus(productRoot);
+    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 }
+          : null,
+        product_exists: discovery.product_exists,
+      },
+      build: latest.build,
+      deployment: latest.deployment,
+      registry: latest.product,
+    };
+    if (args.json) write(`${JSON.stringify(status)}\n`);
+    else {
+      writeHumanSteps([
+        discovery.go?.ok ? `✓ Go ${discovery.go.goversion || discovery.go.version}` : '✗ Go toolchain missing',
+        discovery.runtime ? `✓ AgentSam Go source · ${discovery.runtime.module}` : '✗ Go runtime not discovered',
+        status.deployment?.url ? `✓ deployed · ${status.deployment.url} · ${status.deployment.health}` : '· no deployment receipt yet',
+      ], write);
+      write(`${JSON.stringify(status, null, 2)}\n`);
+    }
+    return status;
+  }
+
+  if (args.subcommand === 'test') {
+    const tests = runGoTests(runtimeRoot);
+    const vet = runGoVet(runtimeRoot);
+    const payload = { ok: tests.ok && vet.ok, tests, vet };
+    write(args.json ? `${JSON.stringify(payload)}\n` : `${tests.stdout}${tests.stderr}${vet.stdout}${vet.stderr}`);
+    if (!payload.ok) {
+      const err = new Error('go_test_failed');
+      err.reported = true;
+      throw err;
+    }
+    return payload;
+  }
+
+  if (args.subcommand === 'build') {
+    ensureProductContract(productRoot);
+    const result = buildGoProduct({
+      productRoot,
+      runtimeRoot,
+      repositoryRoot: discovery.repository_root,
+      dryRun: args.dryRun,
+    });
+    write(args.json ? `${JSON.stringify(result)}\n` : `✓ build receipt · ${result.receiptPath}\n`);
+    return result;
+  }
+
+  if (args.subcommand === 'verify') {
+    const result = await verifyGoProduct({
+      productRoot,
+      runtimeRoot,
+      skipLive: args.dryRun || args.skipDeploy,
+    });
+    write(args.json ? `${JSON.stringify(result)}\n` : `${JSON.stringify(result, null, 2)}\n`);
+    if (!result.ok) {
+      const err = new Error('go_verify_failed');
+      err.reported = true;
+      throw err;
+    }
+    return result;
+  }
+
+  if (args.subcommand === 'deploy' || args.subcommand === 'cloudflare-ship') {
+    return shipCloudflare({ discovery, productRoot, runtimeRoot, args, write });
+  }
+
+  write(HELP);
+  return { ok: true, help: true };
+}
+
+async function shipCloudflare({ discovery, productRoot, runtimeRoot, args, write }) {
+  const steps = [];
+  const note = (line) => {
+    steps.push(line);
+    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(discovery.go?.ok ? '✓ go toolchain' : '✗ go toolchain');
+  if (!discovery.go?.ok) throw new Error('go_toolchain_missing');
+
+  const preflight = preflightToolchain({
+    requireDocker: !(args.dryRun || args.skipDeploy),
+    productRoot,
+  });
+  for (const check of preflight.checks) {
+    note(`${check.ok ? '✓' : '·'} ${check.id}${check.detail ? ` · ${String(check.detail).slice(0, 80)}` : ''}`);
+  }
+
+  const contract = ensureProductContract(productRoot);
+  note(contract.existing ? '✓ existing product contract' : '✓ product contract established');
+  note('✓ deployment contract · cloudflare worker-container');
+
+  if (!args.json) {
+    write(`\n  Product\n    ${args.product}\n`);
+    write('  Target\n    cloudflare\n');
+    write('  Runtime\n    go/native + worker edge\n\n');
+  }
+
+  if (!args.json) write('  Building\n');
+  const build = buildGoProduct({
+    productRoot,
+    runtimeRoot,
+    repositoryRoot: discovery.repository_root,
+    dryRun: args.dryRun,
+  });
+  note('✓ go test ./...');
+  note('✓ go vet ./...');
+  note(build.build.binary ? `✓ Go binary · ${path.basename(build.build.binary)}` : '✓ Go build skipped (dry-run)');
+
+  if (!args.json) write('\n  Deploying\n');
+  const deploy = await deployGoCloudflare({
+    productRoot,
+    product: args.product,
+    dryRun: args.dryRun,
+    skipDeploy: args.skipDeploy,
+    skipRegistry: args.skipRegistry,
+  });
+  if (deploy.deployed) note(`✓ ${args.product}`);
+  else if (args.dryRun) note('· dry-run · deploy skipped');
+  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 (!args.json) write('\n  Validation\n');
+  if (deploy.probes?.results) {
+    for (const [key, value] of Object.entries(deploy.probes.results)) {
+      note(`${value.ok ? '✓' : '✗'} ${key}`);
+    }
+  } 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)');
+  note('✓ deployment receipt');
+
+  const payload = {
+    ok: Boolean(build && (args.dryRun || args.skipDeploy || deploy.probes?.ok || deploy.deployed)),
+    product: args.product,
+    existing_product: contract.existing,
+    scaffold_changes_required: contract.created.length > 0,
+    discovery,
+    contract,
+    build: build.receipt,
+    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`);
+  else {
+    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');
+    }
+    write('\n');
+  }
+
+  if (!payload.ok && !args.dryRun && !args.skipDeploy) {
+    const err = new Error('go_cloudflare_ship_incomplete');
+    err.detail = payload;
+    err.reported = true;
+    throw err;
+  }
+  return payload;
+}
+
+async function runInteractiveMenu({ discovery, productRoot, runtimeRoot, args, write }) {
+  intro(pc.bgCyan(pc.black(' Agent Sam · Go ')));
+  const status = readLatestStatus(productRoot);
+  write(`\n  Runtime\n`);
+  write(`    ${discovery.go?.ok ? '✓' : '✗'} Go ${discovery.go?.goversion || ''}\n`);
+  write(`    ${discovery.runtime ? '✓' : '✗'} AgentSam Go source discovered\n`);
+  write(`\n  Products\n`);
+  write(`    ${args.product.padEnd(28)} ${status.deployment?.health || 'undeployed'} ${status.deployment?.url || ''}\n\n`);
+
+  write(`\n${renderArchitectureExplorer({
+    repo: 'agentsam-sdk',
+    git: discovery.git,
+    tree: ['apps/', 'packages/', 'protocol/', 'src/go/', 'runtime/'],
+    focus: {
+      package: args.product,
+      owns: 'Go runtime + CF container edge',
+      runtime: 'go/native + worker',
+      imported_by: 'CLI · deploy adapter · D1 registry',
+      files: 'main.go · wrangler · Dockerfile',
+    },
+  })}\n\n`);
+
+  const action = await select({
+    message: 'What would you like to do?',
+    options: [
+      { value: 'explore', label: 'Explore wireframes' },
+      { value: 'build', label: 'Build' },
+      { value: 'test', label: 'Test' },
+      { value: 'inspect', label: 'Inspect' },
+      { value: 'cloudflare-ship', label: 'Deploy to Cloudflare' },
+      { value: 'verify', label: 'Verify deployment' },
+      { value: 'status', label: 'Show runtime' },
+    ],
+  });
+  if (isCancel(action)) {
+    cancel('Cancelled.');
+    return { ok: false, cancelled: true };
+  }
+  outro(`Running ${action}`);
+  return runGo([action, args.product, ...(args.json ? ['--json'] : [])], { write });
+}