atris 3.37.1 → 3.40.0

package/commands/bench.js

@@ -8,12 +8,10 @@ const {
   taskMetadata,
 } = require('../lib/bench/runner');
 const { buildBenchReport, renderBenchReportText } = require('../lib/bench/report');
+const { hasFlag } = require('../lib/arg-parser');
 
-function hasFlag(args, name) {
-  return args.includes(name);
-}
-
-function readFlag(args, name) {
+// Preserve the existing rule that any inline value wins over a split value.
+function readInlineFirstFlag(args, name) {
   const prefix = `${name}=`;
   const inline = args.find((arg) => String(arg).startsWith(prefix));
   if (inline) return String(inline).slice(prefix.length);
@@ -58,11 +56,11 @@ async function runCommand(args) {
   const asJson = hasFlag(args, '--json');
   try {
     const result = await runBench({
-      pack: readFlag(args, '--pack') || undefined,
-      engine: readFlag(args, '--engine') || undefined,
+      pack: readInlineFirstFlag(args, '--pack') || undefined,
+      engine: readInlineFirstFlag(args, '--engine') || undefined,
       taskIds: readRepeatedFlag(args, '--task'),
-      label: readFlag(args, '--label'),
-      experiment: readFlag(args, '--experiment'),
+      label: readInlineFirstFlag(args, '--label'),
+      experiment: readInlineFirstFlag(args, '--experiment'),
       updateBaseline: hasFlag(args, '--update-baseline'),
       stateRoot: process.cwd(),
     });
@@ -87,7 +85,7 @@ async function runCommand(args) {
 }
 
 function tasksCommand(args) {
-  const pack = readFlag(args, '--pack') || undefined;
+  const pack = readInlineFirstFlag(args, '--pack') || undefined;
   const tasks = taskMetadata({ pack });
   if (hasFlag(args, '--json')) {
     console.log(JSON.stringify({
@@ -121,7 +119,7 @@ function packsCommand(args) {
 }
 
 function resultsCommand(args) {
-  const last = Number(readFlag(args, '--last') || 0);
+  const last = Number(readInlineFirstFlag(args, '--last') || 0);
   const results = readResultRecords({ stateRoot: process.cwd(), last });
   if (hasFlag(args, '--json')) {
     console.log(JSON.stringify({
@@ -143,7 +141,7 @@ function resultsCommand(args) {
 }
 
 function reportCommand(args) {
-  const pack = readFlag(args, '--pack') || undefined;
+  const pack = readInlineFirstFlag(args, '--pack') || undefined;
   const asJson = hasFlag(args, '--json');
   try {
     const report = buildBenchReport({ pack, stateRoot: process.cwd() });

package/commands/brain.js

@@ -1714,17 +1714,10 @@ function brainCommand(args = process.argv.slice(3)) {
 module.exports = {
   brainCommand,
   collectState,
-  prepareBrainState,
   renderStatus,
-  renderLedger,
-  renderActivationCard,
-  renderActivationGallery,
   recordTaskEpisodeScorecards,
-  recordFeedback,
-  recordApproval,
   verifyActivationCard,
   verifyActivationGallery,
-  verifyBrain,
   parseContributionCard,
   escapeRegExp,
   countTodoItems,

package/commands/brief.js

@@ -642,10 +642,8 @@ module.exports = {
   buildBriefData,
   briefCommand,
   handleBriefAnswer,
-  parsePromptAnswer,
   renderBrief,
   renderBriefHtml,
   run: briefCommand,
-  runBriefLedgerCommand,
   shouldPromptBrief,
 };

package/commands/business-sync.js

@@ -1082,7 +1082,6 @@ module.exports = {
   buildConflictMarkers,
   canPreviewPush,
   collectBrainSnapshot,
-  collectWorkspaceSnapshot,
   collectWorkspaceWarnings,
   collectLocalSyncStatus,
   collectConflictResolutionEntries,

package/commands/business.js

@@ -6,6 +6,12 @@ const { apiRequestJson } = require('../utils/api');
 const { syncBusinessCanonical, ensureWorkspaceStateFiles, ensureBusinessRootAgentAdapters } = require('./sync');
 const { ensureContextScaffold, writeWikiStatus, appendWikiLog } = require('../lib/wiki');
 const { writeRuntimeReceipt } = require('../lib/runtime-bootstrap');
+const {
+  SIMULATE_USAGE,
+  buildSimulationPlan,
+  parseSimulationArgs,
+  renderDryRun,
+} = require('../lib/business-simulate');
 
 function getBusinessConfigPath() {
   const home = require('os').homedir();
@@ -2022,6 +2028,328 @@ function activityBar(daysSinceActive, width = 10) {
   return '\u2501'.repeat(filled) + '\u2591'.repeat(width - filled);
 }
 
+function asRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  return '';
+}
+
+function firstNumber(...values) {
+  for (const value of values) {
+    const parsed = typeof value === 'number'
+      ? value
+      : (typeof value === 'string' && value.trim() ? Number(value) : Number.NaN);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return 0;
+}
+
+function firstBoolean(...values) {
+  for (const value of values) {
+    if (typeof value === 'boolean') return value;
+    if (value === 1 || value === '1' || value === 'true') return true;
+    if (value === 0 || value === '0' || value === 'false') return false;
+  }
+  return false;
+}
+
+function normalizeOrdersPayload(value) {
+  const root = asRecord(value);
+  const body = asRecord(root.data);
+  const source = Object.keys(body).length > 0 ? body : root;
+  const summary = asRecord(source.summary);
+  const rawOrders = Array.isArray(value)
+    ? value
+    : (Array.isArray(source.orders) ? source.orders : (Array.isArray(root.orders) ? root.orders : []));
+  const orders = rawOrders.map((rawOrder, index) => {
+    const order = asRecord(rawOrder);
+    const product = asRecord(order.product);
+    const item = asRecord(order.item);
+    const buyer = asRecord(order.buyer);
+    const customer = asRecord(order.customer);
+    const metadata = asRecord(order.metadata);
+    const firstItem = Array.isArray(order.items) ? asRecord(order.items[0]) : {};
+    const status = firstString(order.status, order.payment_status, order.order_type).toLowerCase();
+    const createdAt = firstString(
+      order.created_at,
+      order.createdAt,
+      order.order_date,
+      order.date,
+      order.paid_at,
+    ) || null;
+
+    return {
+      id: firstString(order.id, order.order_id, order.reference) || `order-${index + 1}`,
+      reference: firstString(order.order_ref, order.reference, order.order_number, order.id) || `order ${index + 1}`,
+      product: firstString(
+        order.product_name,
+        order.product_title,
+        typeof order.product === 'string' ? order.product : null,
+        product.name,
+        product.title,
+        item.name,
+        firstItem.name,
+        firstItem.product_name,
+        metadata.product_name,
+      ) || 'product',
+      quantity: Math.max(1, Math.round(firstNumber(order.quantity, order.qty, firstItem.quantity, 1))),
+      buyer: firstString(
+        order.buyer_name,
+        order.customer_name,
+        buyer.name,
+        customer.name,
+        order.buyer_email,
+        order.customer_email,
+        buyer.email,
+        customer.email,
+      ) || 'guest',
+      status: status || 'unknown',
+      isPreorder: firstBoolean(order.is_preorder, order.preorder)
+        || status.replace(/[_-]/g, '').includes('preorder')
+        || status === 'pending',
+      amountCents: firstNumber(order.amount_cents, order.price_cents, order.total_cents, firstItem.amount_cents),
+      createdAt,
+    };
+  });
+
+  orders.sort((a, b) => {
+    const aTime = a.createdAt ? Date.parse(a.createdAt) : 0;
+    const bTime = b.createdAt ? Date.parse(b.createdAt) : 0;
+    return (Number.isFinite(bTime) ? bTime : 0) - (Number.isFinite(aTime) ? aTime : 0);
+  });
+
+  return {
+    orders,
+    revenueCents: firstNumber(summary.revenue_cents, source.revenue_cents, root.revenue_cents),
+    paidOrders: Math.max(0, Math.round(firstNumber(summary.paid_orders, source.paid_orders, root.paid_orders))),
+    pendingRevenueCents: firstNumber(
+      summary.pending_revenue_cents,
+      source.pending_revenue_cents,
+      root.pending_revenue_cents,
+    ),
+  };
+}
+
+function readStorefront(business) {
+  const config = asRecord(asRecord(business).config);
+  const storefront = asRecord(config.storefront);
+  return {
+    enabled: storefront.enabled === true,
+    products: Array.isArray(storefront.products) ? storefront.products.filter(product => product && typeof product === 'object') : [],
+  };
+}
+
+function readWalletNet(business) {
+  const config = asRecord(asRecord(business).config);
+  for (const key of ['wallet_balance', 'credits_balance', 'credits', 'wallet_credits']) {
+    const value = config[key];
+    if (typeof value === 'number' && Number.isFinite(value)) return value;
+  }
+  return null;
+}
+
+function formatWalletNet(value) {
+  if (value === null) return 'not available';
+  return `$${value.toLocaleString('en-US', { maximumFractionDigits: 2 })}`;
+}
+
+function formatCents(value, currency = 'usd') {
+  const amount = firstNumber(value) / 100;
+  const code = firstString(currency).toUpperCase() || 'USD';
+  const formatted = amount.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+  return code === 'USD' ? `$${formatted}` : `${code} ${formatted}`;
+}
+
+function businessOperationError(message) {
+  console.error(message);
+  process.exitCode = 1;
+  return null;
+}
+
+async function resolveBusinessOperation(slug, usage) {
+  const requestedSlug = detectBusinessSlug(slug);
+  if (!requestedSlug) return businessOperationError(`No business specified. Usage: ${usage}`);
+
+  const creds = loadCredentials();
+  if (!creds || !creds.token) return businessOperationError('Not logged in. Run: atris login');
+
+  const resolved = await resolveSlug(requestedSlug, creds);
+  if (!resolved) return businessOperationError(`Business "${requestedSlug}" not found.`);
+  return { requestedSlug, resolved, token: creds.token };
+}
+
+async function fetchBusinessDashboard(context) {
+  const result = await apiRequestJson(`/business/${context.resolved.business_id}/dashboard`, {
+    method: 'GET',
+    token: context.token,
+    timeoutMs: 120000,
+  });
+  if (!result.ok) {
+    const detail = result.errorMessage || result.error || `HTTP ${result.status}`;
+    return businessOperationError(`Could not load business room: ${detail}`);
+  }
+  return result.data || {};
+}
+
+async function fetchBusinessOrders(context, limit = 50) {
+  return apiRequestJson(`/storefront/${context.resolved.business_id}/orders?limit=${limit}`, {
+    method: 'GET',
+    token: context.token,
+    timeoutMs: 120000,
+  });
+}
+
+function renderOrderLine(order) {
+  const kind = order.isPreorder ? ', preorder' : '';
+  const when = order.createdAt ? relativeTime(order.createdAt) : 'date unavailable';
+  return `  ${order.reference}: ${order.product} x${order.quantity}, ${order.buyer}, ${when}${kind}`;
+}
+
+async function businessRoom(slug) {
+  const context = await resolveBusinessOperation(slug, 'atris business room <slug>');
+  if (!context) return;
+
+  const [dashboard, ordersResult] = await Promise.all([
+    fetchBusinessDashboard(context),
+    fetchBusinessOrders(context, 5),
+  ]);
+  if (!dashboard) return;
+
+  const business = asRecord(dashboard.business);
+  const roster = asRecord(dashboard.roster);
+  const members = Array.isArray(roster.members)
+    ? roster.members
+    : (Array.isArray(business.members) ? business.members : []);
+  const storefront = readStorefront(business);
+  const orders = ordersResult.ok ? normalizeOrdersPayload(ordersResult.data).orders.slice(0, 5) : [];
+  const name = business.name || context.resolved.name || context.requestedSlug;
+  const appCount = Number.isFinite(business.app_count)
+    ? business.app_count
+    : (Array.isArray(business.apps) ? business.apps.length : 0);
+
+  console.log('');
+  console.log(`business room: ${name}`);
+  console.log(`wallet/net: ${formatWalletNet(readWalletNet(business))}`);
+  console.log(`members: ${members.length}`);
+  for (const member of members) {
+    const agent = asRecord(member.atris);
+    const memberName = firstString(member.display_name, agent.agent_name, member.name, member.email) || 'unknown';
+    console.log(`  ${memberName} (${member.role || 'member'})`);
+  }
+  console.log(`apps: ${appCount}`);
+  console.log(`store: ${storefront.enabled ? 'enabled' : 'disabled'}, ${storefront.products.length} products`);
+  console.log('recent orders:');
+  if (!ordersResult.ok) {
+    const detail = ordersResult.errorMessage || ordersResult.error || `HTTP ${ordersResult.status}`;
+    console.log(`  unavailable: ${detail}`);
+    process.exitCode = 1;
+  } else if (orders.length === 0) {
+    console.log('  none');
+  } else {
+    orders.forEach(order => console.log(renderOrderLine(order)));
+  }
+  console.log('');
+}
+
+async function businessProducts(slug) {
+  const context = await resolveBusinessOperation(slug, 'atris business products <slug>');
+  if (!context) return;
+  const dashboard = await fetchBusinessDashboard(context);
+  if (!dashboard) return;
+
+  const business = asRecord(dashboard.business);
+  const storefront = readStorefront(business);
+  const name = business.name || context.resolved.name || context.requestedSlug;
+  console.log('');
+  console.log(`products: ${name} (${storefront.products.length})`);
+  if (storefront.products.length === 0) {
+    console.log('  none');
+  } else {
+    for (const product of storefront.products) {
+      const productName = firstString(product.name) || 'unnamed product';
+      const productId = firstString(product.id) || 'no id';
+      console.log(`  ${productName} (${productId}): ${formatCents(product.price_cents, product.currency)}`);
+    }
+  }
+  console.log('');
+}
+
+async function businessOrders(slug) {
+  const context = await resolveBusinessOperation(slug, 'atris business orders <slug>');
+  if (!context) return;
+  const result = await fetchBusinessOrders(context, 50);
+  if (!result.ok) {
+    const detail = result.errorMessage || result.error || `HTTP ${result.status}`;
+    businessOperationError(`Could not load orders: ${detail}`);
+    return;
+  }
+
+  const data = normalizeOrdersPayload(result.data);
+  const name = context.resolved.name || context.requestedSlug;
+  console.log('');
+  console.log(`orders: ${name} (${data.orders.length})`);
+  console.log(`revenue: ${formatCents(data.revenueCents)}`);
+  console.log(`paid orders: ${data.paidOrders}`);
+  console.log(`pending revenue: ${formatCents(data.pendingRevenueCents)}`);
+  if (data.orders.length === 0) {
+    console.log('  none');
+  } else {
+    data.orders.forEach(order => console.log(renderOrderLine(order)));
+  }
+  console.log('');
+}
+
+function parseBusinessStoreArgs(args = []) {
+  const actions = new Set(['status', 'on', 'enable', 'toggle', 'off', 'disable']);
+  if (actions.has(args[0])) return { action: args[0], slug: args[1] };
+  if (actions.has(args[1])) return { action: args[1], slug: args[0] };
+  return { action: 'status', slug: args[0] };
+}
+
+async function businessStore(args = []) {
+  const { action, slug } = parseBusinessStoreArgs(args);
+  if (action === 'off' || action === 'disable') {
+    businessOperationError('The production store API does not support disabling stores yet.');
+    return;
+  }
+
+  const context = await resolveBusinessOperation(slug, 'atris business store <on|status> [slug]');
+  if (!context) return;
+  const dashboard = await fetchBusinessDashboard(context);
+  if (!dashboard) return;
+
+  const business = asRecord(dashboard.business);
+  const storefront = readStorefront(business);
+  const name = business.name || context.resolved.name || context.requestedSlug;
+  if (action === 'status') {
+    console.log(`store: ${storefront.enabled ? 'enabled' : 'disabled'} for ${name}, ${storefront.products.length} products`);
+    return;
+  }
+  if (storefront.enabled) {
+    console.log(`store: already enabled for ${name}, ${storefront.products.length} products`);
+    return;
+  }
+
+  const result = await apiRequestJson(`/storefront/${context.resolved.business_id}/products`, {
+    method: 'PUT',
+    token: context.token,
+    body: { products: storefront.products },
+    timeoutMs: 120000,
+  });
+  if (!result.ok) {
+    const detail = result.errorMessage || result.error || `HTTP ${result.status}`;
+    businessOperationError(`Could not enable store: ${detail}`);
+    return;
+  }
+  const enabledProducts = Array.isArray(result.data?.products) ? result.data.products.length : storefront.products.length;
+  console.log(`store: enabled for ${name}, ${enabledProducts} products`);
+}
+
 // ---------------------------------------------------------------------------
 // atris business health <slug>
 // ---------------------------------------------------------------------------
@@ -2386,6 +2714,7 @@ async function createBusinessInternal(name, flags = [], mode = 'auto') {
     options.here ||
     Boolean(options.root)
   );
+  let workspaceRoot = null;
 
   // Scaffold legacy local directory if in an atris project
   const atrisDir = !shouldCreateCanonicalWorkspace ? findAtrisDir() : null;
@@ -2405,7 +2734,7 @@ async function createBusinessInternal(name, flags = [], mode = 'auto') {
       console.log(`  Local scaffold: ${bizDir}/`);
     }
   } else if (shouldCreateCanonicalWorkspace) {
-    const workspaceRoot = resolveWorkspaceRoot(biz.slug, options);
+    workspaceRoot = resolveWorkspaceRoot(biz.slug, options);
     const scaffold = createCanonicalBusinessWorkspace(workspaceRoot, {
       business_id: biz.id,
       workspace_id: biz.workspace_id,
@@ -2446,10 +2775,10 @@ async function createBusinessInternal(name, flags = [], mode = 'auto') {
   console.log(`  Agent:     ${biz.agent_id || '(none)'}`);
   console.log(`  Dashboard: https://atris.ai/dashboard/gm/${biz.id}`);
   if (shouldCreateCanonicalWorkspace) {
-    const workspaceRoot = resolveWorkspaceRoot(biz.slug, options);
     console.log(renderBusinessCreatedNextSteps(biz, workspaceRoot));
   }
   console.log('');
+  return { business: biz, workspaceRoot };
 }
 
 async function createBusiness(name, ...flags) {
@@ -2875,6 +3204,96 @@ function findAtrisDir() {
   return null;
 }
 
+function printBusinessSimulateHelp() {
+  console.log(SIMULATE_USAGE);
+  console.log('');
+  console.log('Creates a business workspace, four simulation members, their missions, and atris/ENDGAME.md.');
+  console.log('Use --dry-run to preview every simulation file without cloud calls or writes.');
+}
+
+async function simulateBusiness(args = [], dependencies = {}) {
+  const options = parseSimulationArgs(args);
+  const createdAt = new Date().toISOString();
+  const preview = buildSimulationPlan({
+    idea: options.idea,
+    businessName: options.businessName,
+    roleNames: options.roleNames,
+    createdAt,
+  });
+
+  if (options.dryRun) {
+    console.log(renderDryRun(preview));
+    return preview;
+  }
+
+  const init = dependencies.initBusinessWorkspace || initBusinessWorkspace;
+  const runMemberCommand = dependencies.memberCommand || require('./member').memberCommand;
+  const initialized = await init(options.businessName);
+  const business = initialized?.business || {};
+  const workspaceRoot = initialized?.workspaceRoot
+    || resolveWorkspaceRoot(business.slug || options.businessSlug, {});
+  const plan = buildSimulationPlan({
+    idea: options.idea,
+    businessName: business.name || options.businessName,
+    businessSlug: business.slug || options.businessSlug,
+    roleNames: options.roleNames,
+    createdAt,
+    workspacePath: workspaceRoot,
+  });
+
+  const businessJson = path.join(workspaceRoot, '.atris', 'business.json');
+  if (!fs.existsSync(businessJson)) {
+    throw new Error(`Business init did not create the expected workspace: ${workspaceRoot}`);
+  }
+
+  const originalCwd = process.cwd();
+  try {
+    process.chdir(workspaceRoot);
+
+    const endgame = plan.files.find((file) => file.kind === 'endgame');
+    fs.writeFileSync(path.join(workspaceRoot, endgame.path), endgame.content, 'utf8');
+
+    for (const role of plan.roles) {
+      const memberDir = path.join(workspaceRoot, 'atris', 'team', role.name);
+      const memberFile = path.join(memberDir, 'MEMBER.md');
+      if (!fs.existsSync(memberFile)) {
+        await runMemberCommand(
+          'create',
+          role.name,
+          `--role=${role.title}`,
+          `--description=${role.description}`,
+        );
+      } else {
+        console.log(`Using existing team/${role.name}/ scaffold from business init.`);
+      }
+
+      for (const directory of ['skills', 'tools', 'context', 'logs']) {
+        fs.mkdirSync(path.join(memberDir, directory), { recursive: true });
+      }
+
+      const roleFiles = plan.files.filter((file) => file.role?.name === role.name);
+      for (const file of roleFiles) {
+        fs.writeFileSync(path.join(workspaceRoot, file.path), file.content, 'utf8');
+      }
+
+      await runMemberCommand('push', role.name);
+    }
+  } finally {
+    process.chdir(originalCwd);
+  }
+
+  console.log('');
+  console.log('business simulation ready');
+  console.log(`workspace: ${workspaceRoot}`);
+  console.log('roster:');
+  for (const role of plan.roles) {
+    console.log(`  - ${role.name}: ${role.role}`);
+  }
+  console.log('next: open an agent session in the workspace and run the loop against atris/ENDGAME.md');
+  console.log('');
+  return plan;
+}
+
 
 async function quickstart() {
   console.log(`
@@ -2945,8 +3364,13 @@ function printBusinessHelp() {
   console.log('  init <name>          RECOMMENDED: create a business environment (cloud + local)');
   console.log('  workspace <name>     Alias for init');
   console.log('  create <name>        Cloud-only business record; add --workspace to also scaffold local');
+  console.log('  simulate <idea>      Create a business, four-role team, missions, and endgame loop');
   console.log('  add <slug>           Register an existing cloud business');
   console.log('  list                 Show registered businesses');
+  console.log('  room [slug]          Show wallet, members, apps, store, and recent orders');
+  console.log('  products [slug]      List store products');
+  console.log('  orders [slug]        List store orders');
+  console.log('  store on [slug]      Enable the store with its current catalog');
   console.log('  team [slug]          Show members, roles, and admin access');
   console.log('  status <slug>        Quick status check');
   console.log('  health [slug]        Full health dashboard');
@@ -2973,6 +3397,10 @@ async function businessCommand(subcommand, ...args) {
     printBusinessHelp();
     return;
   }
+  if (subcommand === 'simulate' && args.some(isHelpToken)) {
+    printBusinessSimulateHelp();
+    return;
+  }
   const nameTakingSubcommands = new Set(['create', 'new', 'init', 'workspace']);
   if (nameTakingSubcommands.has(subcommand) && args.some(isHelpToken)) {
     printBusinessHelp();
@@ -2995,6 +3423,9 @@ async function businessCommand(subcommand, ...args) {
     case 'workspace':
       await initBusinessWorkspace(args[0], ...args.slice(1));
       break;
+    case 'simulate':
+      await simulateBusiness(args);
+      break;
     case 'list':
     case 'ls': {
       const opts = {};
@@ -3017,6 +3448,21 @@ async function businessCommand(subcommand, ...args) {
     case 'health':
       await businessHealth(args[0]);
       break;
+    case 'room':
+      await businessRoom(args[0]);
+      break;
+    case 'products':
+    case 'product':
+      await businessProducts(args[0]);
+      break;
+    case 'orders':
+    case 'order':
+      await businessOrders(args[0]);
+      break;
+    case 'store':
+    case 'storefront':
+      await businessStore(args);
+      break;
     case 'team':
     case 'members':
     case 'roster':
@@ -3072,26 +3518,20 @@ async function businessCommand(subcommand, ...args) {
 
 module.exports = {
   businessCommand,
-  businessHealth,
-  businessAudit,
-  businessDoctor,
-  businessTeam,
   loadBusinesses,
   saveBusinesses,
-  getBusinessConfigPath,
   businessMatchesSlug,
   isAccidentalHelpBusiness,
   validateBusinessCreateName,
   analyzeBusinessDoctor,
-  readBusinessFolderBindings,
   createCanonicalBusinessWorkspace,
-  initBusinessWorkspace,
   onboardBusiness,
-  startBusinessWorkspace,
   shareBusinessWorkspace,
   collectBusinessShareState,
   renderBusinessCreatedNextSteps,
-  renderBusinessShareHandoff,
-  renderBusinessStartCard,
   recordBusinessRun,
+  normalizeOrdersPayload,
+  parseBusinessStoreArgs,
+  readStorefront,
+  readWalletNet,
 };

package/commands/chat-scan.js

@@ -1,12 +1,10 @@
 const fs = require('fs');
 const path = require('path');
+const { hasFlag } = require('../lib/arg-parser');
 const { scanChatLogs, writeLatestScan } = require('../lib/chat-log-scan');
 
-function hasFlag(args, name) {
-  return args.includes(name);
-}
-
-function readFlag(args, name, fallback) {
+// Preserve the existing rule that the next token is a value, even if it is a flag.
+function readFollowingFlag(args, name, fallback) {
   const i = args.indexOf(name);
   if (i === -1 || i === args.length - 1) return fallback;
   return args[i + 1];
@@ -79,8 +77,8 @@ Options:
 
   const report = scanChatLogs({
     cwd: root,
-    hours: readFlag(args, '--hours', 720),
-    limit: readFlag(args, '--limit', 12),
+    hours: readFollowingFlag(args, '--hours', 720),
+    limit: readFollowingFlag(args, '--limit', 12),
   });
 
   let latestPath = null;