@inneranimalmedia/agentsam-sdk 2.6.1 → 2.6.3

package/src/commands/brand.js

@@ -0,0 +1,293 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { repositorySnapshot } from '../capabilities/index.js';
+import {
+  brandScan,
+  brandResolve,
+  brandPlan,
+  buildBrandContractDraft,
+  brandGoapActions,
+  brandWorldFromPlan,
+  brandGoalFromPlan,
+} from '../../packages/agentsam-brand/src/index.js';
+import { suggestNextActions } from '../progression/index.js';
+import { createRuntimeActivity } from '../ui/runtime-activity.js';
+
+function parseArgs(argv = []) {
+  const out = { json: false, cwd: process.cwd(), dryRun: false, goap: false, write: false, positionals: [] };
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--json') out.json = true;
+    else if (a === '--cwd') out.cwd = argv[++i] || out.cwd;
+    else if (a === '--dry-run') out.dryRun = true;
+    else if (a === '--goap') out.goap = true;
+    else if (a === '--write') out.write = true;
+    else if (a === '--snapshot-file') out.snapshotFile = argv[++i] || '';
+    else out.positionals.push(a);
+  }
+  return out;
+}
+
+async function loadSnapshot(opts) {
+  if (opts.snapshotFile) {
+    return JSON.parse(fs.readFileSync(path.resolve(opts.cwd, opts.snapshotFile), 'utf8'));
+  }
+  return repositorySnapshot({ cwd: opts.cwd, churnDays: 30 });
+}
+
+function printNext(actions) {
+  if (!actions?.length) return;
+  console.log('\nSuggested');
+  for (const a of actions.slice(0, 5)) {
+    console.log(`→ ${a.label}`);
+    if (a.command) console.log(`  ${a.command}`);
+    if (a.reason) console.log(`  ${a.reason}`);
+  }
+  console.log('');
+}
+
+function attachProgression(capability, result, json) {
+  const { next_actions } = suggestNextActions({ capability, result });
+  const receipt = {
+    capability,
+    status: 'completed',
+    repository_snapshot: result.repository?.snapshot_id || result.snapshot_id || null,
+    content_hash: result.content_hash || null,
+    next_actions,
+  };
+  if (json) return { ...result, receipt, next_actions };
+  printNext(next_actions);
+  return { ...result, receipt, next_actions };
+}
+
+export async function runBrand(argv = []) {
+  const opts = parseArgs(argv);
+  const [sub = '', ...rest] = opts.positionals;
+  const action = sub || 'summary';
+
+  if (action === 'help' || action === '--help') {
+    console.log(`usage: agentsam brand [summary|scan|resolve|inspect|plan|apply|verify] [options]
+
+  summary (default)   Short brand intelligence overview
+  scan                Deterministic evidence extraction (no model)
+  resolve             Cluster tokens into inferred roles
+  inspect [conflicts] Show conflicts / component families
+  plan [--goap]       Normalization plan (preserve → improve)
+  apply --dry-run     Mutation stub (writes require future approval)
+  verify              Stub verification gate
+
+Options:
+  --json --cwd <path> --snapshot-file <file> --write
+`);
+    return;
+  }
+
+  if (action === 'apply') {
+    if (!opts.dryRun) {
+      console.error('brand apply requires --dry-run until mutations are gated (side_effects: repository-write)');
+      process.exitCode = 2;
+      return;
+    }
+    const out = {
+      capability: 'brand.apply',
+      status: 'dry-run',
+      message: 'No files changed. Approve a brand.plan then re-run apply when mutation executor ships.',
+    };
+    if (opts.json) console.log(JSON.stringify(out, null, 2));
+    else console.log(out.message);
+    return;
+  }
+
+  if (action === 'verify') {
+    const out = {
+      capability: 'brand.verify',
+      status: 'stub',
+      message: 'Verify will re-scan and diff against .agentsam/brand/contract.json',
+    };
+    if (opts.json) console.log(JSON.stringify(out, null, 2));
+    else console.log(out.message);
+    return;
+  }
+
+  const tty = process.stdout.isTTY && !opts.json;
+  const activity = tty ? createRuntimeActivity({ label: 'Brand intelligence' }) : null;
+  const onEvent = (ev) => {
+    if (!activity) return;
+    if (ev.type === 'operation.phase.started') activity.update(String(ev.phase || 'working'));
+    if (ev.type === 'operation.progress') activity.update(String(ev.detail || ev.phase || 'scanning'));
+  };
+
+  try {
+    activity?.start('snapshot');
+    const snapshot = await loadSnapshot(opts);
+
+    if (action === 'summary' || action === 'scan' || action === 'resolve' || action === 'inspect' || action === 'plan') {
+      const scan = await brandScan({
+        cwd: opts.cwd,
+        snapshot,
+        onEvent,
+      });
+
+      if (action === 'scan') {
+        const enriched = attachProgression('brand.scan', scan, opts.json);
+        if (opts.write) writeArtifacts(opts.cwd, { evidence: scan });
+        if (opts.json) console.log(JSON.stringify(enriched, null, 2));
+        else {
+          console.log(`\nBrand scan complete · ${scan.repository.snapshot_id}`);
+          console.log(`  colors     ${scan.tokens.colors.length}`);
+          console.log(`  conflicts  ${scan.conflicts.length}`);
+          console.log(`  css files  ${scan.sources.css}`);
+          console.log(`  components ${scan.sources.components}`);
+          console.log(`  hash       ${scan.content_hash}`);
+        }
+        return;
+      }
+
+      const resolved = brandResolve(scan);
+      if (action === 'resolve') {
+        const enriched = attachProgression('brand.resolve', { ...resolved, repository: scan.repository, content_hash: scan.content_hash }, opts.json);
+        if (opts.write) writeArtifacts(opts.cwd, { evidence: scan, resolved });
+        if (opts.json) console.log(JSON.stringify({ ...resolved, next_actions: enriched.next_actions }, null, 2));
+        else {
+          console.log(`\nBrand resolve · ${Object.keys(resolved.resolved.colors).length} color roles`);
+          console.log(`  ambiguities ${resolved.ambiguities.length}`);
+          for (const a of resolved.ambiguities.slice(0, 5)) {
+            console.log(`  ? ${a.question}`);
+          }
+        }
+        return;
+      }
+
+      if (action === 'inspect') {
+        const focus = rest[0] || 'conflicts';
+        const payload = focus === 'components'
+          ? { capability: 'brand.inspect', focus, components: scan.components, patterns: scan.patterns }
+          : { capability: 'brand.inspect', focus, conflicts: scan.conflicts, colors: scan.tokens.colors.slice(0, 20) };
+        if (opts.json) console.log(JSON.stringify(payload, null, 2));
+        else if (focus === 'components') {
+          console.log('\nComponent families');
+          for (const [k, v] of Object.entries(scan.components).slice(0, 20)) {
+            console.log(`  ${k} ×${v.count}`);
+          }
+        } else {
+          console.log(`\nConflicts (${scan.conflicts.length})`);
+          for (const c of scan.conflicts.slice(0, 15)) {
+            console.log(`  ${c.values?.join(' ≈ ')} · d=${c.distance} · n=${c.occurrences}`);
+          }
+        }
+        return;
+      }
+
+      if (action === 'plan') {
+        return runBrandPlanInner({ scan, resolved, opts });
+      }
+
+      // summary
+      const contract = buildBrandContractDraft({ scan, resolved });
+      const plan = brandPlan({ scan, resolved, contract });
+      const { next_actions } = suggestNextActions({ capability: 'brand.scan', result: scan });
+      const summary = {
+        capability: 'brand.summary',
+        repository: scan.repository,
+        sources: scan.sources,
+        summary: plan.summary,
+        confidence: resolved.confidence,
+        ambiguities: resolved.ambiguities.slice(0, 5),
+        next_actions,
+      };
+      if (opts.write) writeArtifacts(opts.cwd, { evidence: scan, resolved, contract });
+      if (opts.json) console.log(JSON.stringify(summary, null, 2));
+      else {
+        console.log(`\nBrand · ${scan.repository.snapshot_id}`);
+        console.log(`  ${plan.summary.colors} colors · ${plan.summary.near_duplicate_pairs} near-duplicates`);
+        console.log(`  ${plan.summary.button_families} button families · ${plan.summary.header_families} header/nav families`);
+        console.log(`  confidence colors=${resolved.confidence.colors} typography=${resolved.confidence.typography}`);
+        printNext(next_actions);
+      }
+    }
+  } finally {
+    activity?.stop?.();
+  }
+}
+
+async function runBrandPlanInner({ scan, resolved, opts }) {
+  const contract = buildBrandContractDraft({ scan, resolved });
+  const plan = brandPlan({ scan, resolved, contract });
+  let goap = null;
+  if (opts.goap) {
+    const world = brandWorldFromPlan(plan);
+    const goal = brandGoalFromPlan(plan);
+    const actions = brandGoapActions();
+    const sequence = [];
+    const state = { ...world };
+    // greedy applicable actions by cost until goal satisfied or stuck
+    for (let guard = 0; guard < 20; guard += 1) {
+      const done = Object.entries(goal).every(([k, v]) => state[k] === v);
+      if (done) break;
+      const candidates = actions
+        .filter((a) => Object.entries(a.preconditions || {}).every(([k, v]) => state[k] === v))
+        .filter((a) => !sequence.includes(a.id))
+        .sort((a, b) => (a.cost || 1) - (b.cost || 1));
+      if (!candidates.length) break;
+      const next = candidates[0];
+      sequence.push(next.id);
+      Object.assign(state, next.effects || {});
+    }
+    goap = {
+      ok: sequence.length > 0,
+      plan: sequence,
+      cost: sequence.reduce((n, id) => n + (actions.find((a) => a.id === id)?.cost || 0), 0),
+      engine: 'brand-goap-greedy',
+    };
+  }
+  const enriched = attachProgression('brand.plan', plan, opts.json);
+  const out = { ...plan, goap, next_actions: enriched.next_actions };
+  if (opts.write) {
+    writeArtifacts(opts.cwd, { evidence: scan, resolved, contract });
+    const dir = path.join(opts.cwd, '.agentsam', 'brand');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'plan.json'), `${JSON.stringify(out, null, 2)}\n`);
+  }
+  if (opts.json) console.log(JSON.stringify(out, null, 2));
+  else {
+    console.log('\nBrand coherence plan');
+    console.log(`  philosophy  ${plan.philosophy}`);
+    console.log(`  colors      ${plan.summary.colors} (${plan.summary.near_duplicate_pairs} near-dup pairs)`);
+    console.log('  steps');
+    for (const [i, s] of plan.steps.entries()) {
+      console.log(`    ${i + 1}. [${s.action}] ${s.title}`);
+    }
+    if (goap?.ok) console.log(`  goap        cost=${goap.cost} · ${goap.plan?.join(' → ')}`);
+  }
+}
+
+export async function runPlan(argv = []) {
+  const opts = parseArgs(argv);
+  const [domain, ...rest] = opts.positionals;
+  if (!domain || domain === 'help') {
+    console.log(`usage: agentsam plan <domain>
+
+Domains:
+  brand [--goap] [--json] [--write]
+  security   (use: agentsam security scan)
+  repository (use: agentsam inspect)
+  release    (use: agentsam status / package verify)
+
+Composable grammar: agentsam plan brand
+`);
+    return;
+  }
+  if (domain === 'brand') {
+    return runBrand(['plan', ...rest, ...(opts.json ? ['--json'] : []), ...(opts.goap ? ['--goap'] : []), ...(opts.write ? ['--write'] : []), ...(opts.cwd !== process.cwd() ? ['--cwd', opts.cwd] : [])]);
+  }
+  console.error(`plan domain not implemented: ${domain}`);
+  process.exitCode = 2;
+}
+
+function writeArtifacts(cwd, { evidence, resolved, contract }) {
+  const dir = path.join(cwd, '.agentsam', 'brand');
+  fs.mkdirSync(dir, { recursive: true });
+  if (evidence) fs.writeFileSync(path.join(dir, 'evidence.json'), `${JSON.stringify(evidence, null, 2)}\n`);
+  if (resolved) fs.writeFileSync(path.join(dir, 'resolved.json'), `${JSON.stringify(resolved, null, 2)}\n`);
+  if (contract) fs.writeFileSync(path.join(dir, 'contract.json'), `${JSON.stringify(contract, null, 2)}\n`);
+}

package/src/commands/cad.js

@@ -106,6 +106,7 @@ function required(value, message) {
 }
 
 export async function runCad(argv) {
+  if (argv[0] === 'project') return (await import('../lib/cad/project-cli.js')).runProjectCli(argv.slice(1));
   const engine = argv[0];
   if (!engine || engine === '--help' || engine === '-h') {
     console.log(usage());

package/src/commands/connections.js

@@ -9,6 +9,7 @@ import {
   resolveCloudflareOAuthClient,
 } from '../../packages/connectors/cloudflare/src/index.js';
 import { resolveIamIssuer } from '../../packages/identity/src/contracts/auth-config.js';
+import { collectRuntimeStatus } from './runtime-status.js';
 
 const PRODUCTION_CALLBACK = `https://agentsam.inneranimalmedia.com${CLOUDFLARE_CALLBACK_PATH}`;
 
@@ -45,49 +46,145 @@ function printSetup(env = process.env) {
   return 0;
 }
 
-export async function runConnections(args = []) {
+function bindingKey(row = {}) {
+  return String(row.name || '').trim();
+}
+
+function bindingTypeLabel(type = '') {
+  switch (String(type || '').trim()) {
+    case 'plain_text': return 'Variable';
+    case 'json': return 'Variable (JSON)';
+    case 'secret_text': return 'Secret';
+    case 'secret_key': return 'Secret key';
+    case 'ai': return 'Workers AI';
+    case 'd1': return 'D1 database';
+    case 'service': return 'Service binding';
+    case 'hyperdrive': return 'Hyperdrive';
+    case 'vpc_service': return 'VPC Service';
+    case 'r2_bucket': return 'R2 bucket';
+    case 'assets': return 'Assets';
+    default: return String(type || 'Binding');
+  }
+}
+
+function bindingTarget(row = {}) {
+  if (row.type === 'secret_text' || row.type === 'secret_key') return 'Value encrypted';
+  if (row.value != null) return String(row.value);
+  if (row.database_name) return row.database_name;
+  if (row.bucket_name) return row.bucket_name;
+  if (row.service) return row.environment ? `${row.service} · ${row.environment}` : row.service;
+  if (row.index_name) return row.index_name;
+  if (row.database_id) return row.database_id;
+  if (row.service_id) return row.service_id;
+  if (row.id) return row.id;
+  if (row.namespace) return row.namespace;
+  if (row.store_id && row.secret_name) return `${row.store_id} · ${row.secret_name}`;
+  return '';
+}
+
+function renderBindingRows(rows = []) {
+  if (!rows.length) return ['    none'];
+  const width = Math.min(32, Math.max(4, ...rows.map((row) => bindingKey(row).length)));
+  return rows.map((row) => {
+    const name = bindingKey(row).padEnd(width);
+    const type = bindingTypeLabel(row.type);
+    const target = bindingTarget(row);
+    return `    ${name}  ${type}${target ? ` · ${target}` : ''}`;
+  });
+}
+
+function renderWorkerBindings(status) {
+  const cloudflare = status.cloudflare || {};
+  const bindings = cloudflare.bindings;
+  if (!bindings) return ['  Worker runtime    not verified'];
+
+  const variables = Array.isArray(bindings.runtime_variables) ? bindings.runtime_variables : [];
+  const secrets = Array.isArray(bindings.runtime_secrets) ? bindings.runtime_secrets : [];
+  const resources = Array.isArray(bindings.resources) ? bindings.resources : [];
+  const declared = Array.isArray(bindings.declared) ? bindings.declared : [];
+  const missing = Array.isArray(bindings.missing) ? bindings.missing : [];
+  const mismatches = Array.isArray(bindings.type_mismatches) ? bindings.type_mismatches : [];
+
+  const lines = [];
+  if (cloudflare.version?.id || cloudflare.version?.number != null) {
+    const versionLabel = cloudflare.version?.number != null ? `v${cloudflare.version.number}` : 'version';
+    lines.push(`  live Worker       ${versionLabel}${cloudflare.version?.id ? ` · ${cloudflare.version.id}` : ''}`);
+  }
+
+  lines.push('');
+  lines.push(`  Runtime variables and secrets  ${variables.length} variables · ${secrets.length} secrets`);
+  lines.push(...renderBindingRows([...variables, ...secrets].sort((a, b) => bindingKey(a).localeCompare(bindingKey(b)))));
+
+  lines.push('');
+  lines.push(`  Bindings          ${resources.length} live resources`);
+  lines.push(...renderBindingRows(resources.sort((a, b) => bindingKey(a).localeCompare(bindingKey(b)))));
+
+  lines.push('');
+  lines.push(`  Config comparison ${declared.length} declared locally · ${missing.length} missing live · ${mismatches.length} type mismatch`);
+  if (cloudflare.config) lines.push(`    source           ${cloudflare.config}`);
+  if (missing.length) {
+    for (const row of missing) lines.push(`    ✗ ${bindingKey(row)} · declared ${row.type || 'unknown'} · missing from live version`);
+  }
+  if (mismatches.length) {
+    for (const row of mismatches) lines.push(`    ! ${bindingKey(row)} · declared ${row.declared || 'unknown'} · live ${row.live || 'unknown'}`);
+  }
+
+  return lines;
+}
+
+function renderConnections(status) {
+  const lines = ['', '  Agent Sam · connections', ''];
+  lines.push(`  IAM account       ${status.identity?.authenticated ? 'connected' : 'not connected'}`);
+  lines.push(`  active auth       ${status.identity?.active_auth?.kind || 'none'}`);
+  lines.push(`  model providers   ${(status.model_summary?.configured_providers || []).join(', ') || 'none configured'}`);
+  lines.push(`  terminal registry ${status.terminal?.connected ? `${status.terminal.active_connection_count} active / ${status.terminal.connections.length} total` : `unavailable · ${status.terminal?.error || 'not authenticated'}`}`);
+  for (const row of status.terminal?.connections || []) {
+    lines.push(`    ${row.default ? '★' : '•'} ${row.name || row.id} · ${row.kind || 'terminal'} · ${row.active ? 'active' : 'inactive'} · ${row.health}`);
+  }
+  lines.push(`  Worker            ${status.cloudflare?.connected ? `${status.cloudflare.worker_name} · live` : status.cloudflare?.configured ? `${status.cloudflare.worker_name} · not verified` : 'not configured'}`);
+  lines.push(...renderWorkerBindings(status));
+  lines.push('');
+  lines.push('  Live Cloudflare binding names/targets are shown; secret values and terminal endpoint credentials are never printed.');
+  lines.push('');
+  return lines.join('\n');
+}
+
+export async function runConnections(args = [], options = {}) {
   const argv = args.filter((a) => a !== '--json');
   const jsonMode = args.includes('--json');
-  const env = process.env;
+  const env = options.env || process.env;
+  const write = options.write || ((value) => process.stdout.write(value));
   if (argv[0] === 'cloudflare' && argv[1] === 'setup') {
     if (jsonMode) {
-      console.log(JSON.stringify({
+      write(`${JSON.stringify({
         callback: PRODUCTION_CALLBACK,
         authorize: 'https://dash.cloudflare.com/oauth2/auth',
         token: 'https://dash.cloudflare.com/oauth2/token',
         revoke: 'https://dash.cloudflare.com/oauth2/revoke',
         mintsRealClient: false,
         client: resolveCloudflareOAuthClient(env),
-      }, null, 2));
+      }, null, 2)}\n`);
       return 0;
     }
     return printSetup(env);
   }
-  const report = doctor(env);
+  if (argv.length) throw new Error(`unknown connections option: ${argv[0]}`);
+  const status = await (options.collectRuntime || collectRuntimeStatus)({
+    ...options,
+    env,
+    cwd: options.cwd || process.cwd(),
+    discoverModels: true,
+  });
   if (jsonMode) {
-    console.log(JSON.stringify({ identity: report.identity, cloudflare: report.cloudflare }, null, 2));
-    return 0;
+    write(`${JSON.stringify({
+      schema_version: status.schema_version,
+      identity: status.identity,
+      providers: status.models?.providers || [],
+      terminal: status.terminal,
+      cloudflare: status.cloudflare,
+    }, null, 2)}\n`);
+    return status;
   }
-  const iam = report.identity;
-  const cf = report.cloudflare;
-  const client = report.client;
-  console.log('AgentSam Identity');
-  console.log('');
-  console.log('IAM client');
-  console.log(`  ${iam.clientId ? '✓' : '•'} client id`);
-  console.log(`  ✓ issuer ${iam.issuer}`);
-  console.log(`  ${iam.serverSecret ? '✓' : '•'} server secret configured`);
-  if (iam.originAlias) console.log('Compatibility\n  IAM_ORIGIN -> deprecated alias');
-  console.log('');
-  console.log('Cloudflare connection');
-  console.log('');
-  console.log('OAuth client');
-  console.log(`  client id: ${cf.clientId}`);
-  console.log(`  secret: ${cf.secret}`);
-  console.log(`  status: ${client.status}`);
-  if (client.fixture) {
-    console.log('  OAuth client fixture configured');
-    console.log('  real Cloudflare OAuth client still required');
-  }
-  return 0;
+  write(renderConnections(status));
+  return status;
 }

package/src/commands/context-economics.js

@@ -58,6 +58,8 @@ export function buildContextEconomicsReport(cwd, options = {}) {
     model: model.provider_model_id,
     model_key: model.model_key,
     resolved: true,
+    compaction_supported: ['openai', 'grok'].includes(model.provider) && model.capabilities?.compaction === true,
+    auto_compact: options.autoCompact !== false,
     reasoning_effort: preferences.reasoningEffort || 'auto',
     service_tier: preferences.serviceTier || 'default',
     active_input_tokens: active,
@@ -117,6 +119,12 @@ export function renderContextEconomics(report) {
     `    intervene at    ${formatInteger(report.intervene_at_tokens)}`,
     `    max normal      ${formatInteger(report.max_normal_input_tokens)}`,
     '',
+    '  Compaction',
+    `    support         ${report.compaction_supported ? 'native' : 'unavailable'}`,
+    `    automatic       ${report.compaction_supported && report.auto_compact ? 'enabled' : 'disabled'}`,
+    `    threshold       ${formatInteger(report.compact_at_tokens)}`,
+    '    command         /compact · /compact status',
+    '',
     '  Economics',
     `    price threshold ${formatInteger(report.pricing_threshold_tokens)}`,
     `    remaining       ${remaining}`,

package/src/commands/db.js

@@ -1,3 +1,4 @@
+import { discoverProjectStores, selectKnowledgeStore } from '../knowledge/store-discovery.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { createLocalSqliteDatabase, initializeLocalSqlite, inspectLocalSqlite } from '../local/sqlite.js';
@@ -24,6 +25,12 @@ function resolveDb(root, config) {
 
 export async function runDb(argv = [], opts = {}) {
   const sub = argv[0] || 'status';
+  if (sub === 'sources' || sub === 'select') {
+    if (sub === 'select' && (argv[1] !== 'knowledge' || !argv[2] || argv.length > 4)) throw new Error('Usage: /db select knowledge sqlite|postgres [CONNECTION_ENV]');
+    const result = sub === 'sources' ? await discoverProjectStores(opts.cwd || process.cwd()) : selectKnowledgeStore(opts.cwd || process.cwd(), argv[2], argv[3]);
+    (opts.write || console.log)(JSON.stringify(result, null, 2) + '\n');
+    return result;
+  }
   if (!['init', 'migrate', 'status'].includes(sub)) {
     throw new Error(`unknown db command: ${sub}`);
   }

package/src/commands/deploy.js

@@ -6,7 +6,7 @@ import path from 'node:path';
 import readline from 'node:readline';
 import { authenticateViaBrowser } from '../lib/auth.js';
 import { getJson, streamScaffold } from '../lib/core-client.js';
-import { resolveAccountSdkKey } from '../lib/account-session.js';
+import { resolveAccountAuth } from '../lib/account-session.js';
 import { getDefaultProfile, getDeployTarget, getLocalSchemaPath, getProjectName, getProjectPreset, readProjectConfig, setDeployTarget, writeProjectConfig } from '../lib/project-config.js';
 import { isLocalStudioCheckout, runLocalStudioDeploy } from '../lib/deploy/local-studio.js';
 
@@ -68,7 +68,7 @@ function ask(question) {
 async function runCloudflareDeploy(cwd, config, accountId) {
   console.log('\n  Cloudflare deploy — browser sign-in + resource provisioning…\n');
 
-  let token = resolveAccountSdkKey({ env: process.env }).value;
+  let token = resolveAccountAuth({ env: process.env }).value;
   if (!token) {
     const session = await authenticateViaBrowser();
     token = session.access_token;

package/src/commands/env.js

@@ -5,12 +5,13 @@ const PROVIDERS = Object.freeze(['openai', 'anthropic', 'gemini', 'grok', 'cloud
 
 function writeLine(write, value = '') { write(`${value}\n`); }
 
-function detectCloudflareAccounts(options = {}) {
+export function detectCloudflareAccounts(options = {}) {
   const env = options.env || process.env;
-  const explicit = String(options.accountId || env.ACCOUNT_ID || env.CLOUDFLARE_ACCOUNT_ID || '').trim();
+  const explicit = String(options.accountId || env.CLOUDFLARE_ACCOUNT_ID || '').trim();
   if (explicit) return { accounts: [{ id: explicit, name: null }], source: 'environment' };
   const spawn = options.spawnSyncImpl || spawnSync;
-  const result = spawn('npx', ['--no-install', 'wrangler', 'whoami', '--json'], { cwd: options.cwd || process.cwd(), env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  const npxBin = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+  const result = spawn(npxBin, ['--no-install', 'wrangler', 'whoami', '--json'], { cwd: options.cwd || process.cwd(), env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], shell: process.platform === 'win32' });
   if (result?.status !== 0) return { accounts: [], source: 'wrangler', error: String(result?.stderr || '').trim() || `wrangler exited ${result?.status ?? 'unknown'}` };
   try {
     const parsed = JSON.parse(String(result.stdout || '{}'));
@@ -67,7 +68,7 @@ export async function runEnv(argv = [], options = {}) {
     if (provider === 'cloudflare') {
       if (accountId) writeLine(write, `  account  detected/configured (${cloudflareAccounts?.source || 'explicit'})`);
       else if ((cloudflareAccounts?.accounts || []).length > 1) writeLine(write, `  account  ${cloudflareAccounts.accounts.length} Wrangler accounts found · rerun with --account-id <id>`);
-      else writeLine(write, '  account  not detected · set ACCOUNT_ID in the profile or rerun with --account-id <id>');
+      else writeLine(write, '  account  not detected · set CLOUDFLARE_ACCOUNT_ID in the profile or rerun with --account-id <id>');
       cloudflareGuidance(write);
     }
     writeLine(write, '');