@f-o-h/cli 0.1.83 → 0.1.85

package/dist/foh.js

@@ -6046,7 +6046,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve14.call(this, root, ref);
+      let _sch = resolve15.call(this, root, ref);
       if (_sch === void 0) {
         const schema2 = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
         const { schemaId } = this.opts;
@@ -6073,7 +6073,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve14(root, ref) {
+    function resolve15(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -6648,7 +6648,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve14(baseURI, relativeURI, options) {
+    function resolve15(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -6875,7 +6875,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve14,
+      resolve: resolve15,
       resolveComponent,
       equal,
       serialize,
@@ -10183,21 +10183,21 @@ async function promptLine(label, {
   allowEmpty = false,
   defaultValue
 } = {}) {
-  return await new Promise((resolve14) => {
+  return await new Promise((resolve15) => {
     const suffix = defaultValue ? ` [${defaultValue}]` : "";
     const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stdout, terminal: true });
     rl.question(`${label}${suffix}: `, (answer) => {
       rl.close();
       const value = String(answer ?? "").trim();
       if (!value && typeof defaultValue === "string") {
-        resolve14(defaultValue);
+        resolve15(defaultValue);
         return;
       }
       if (!value && !allowEmpty) {
-        resolve14("");
+        resolve15("");
         return;
       }
-      resolve14(value);
+      resolve15(value);
     });
   });
 }
@@ -10205,7 +10205,7 @@ async function promptSecret(label) {
   if (!process.stdin.isTTY || !process.stdout.isTTY || typeof process.stdin.setRawMode !== "function") {
     return await promptLine(label);
   }
-  return await new Promise((resolve14) => {
+  return await new Promise((resolve15) => {
     const stdin = process.stdin;
     const stdout = process.stdout;
     const wasRaw = Boolean(stdin.isRaw);
@@ -10219,7 +10219,7 @@ async function promptSecret(label) {
     const finish = () => {
       cleanup();
       stdout.write("\n");
-      resolve14(value);
+      resolve15(value);
     };
     const onData = (chunk) => {
       const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
@@ -10228,7 +10228,7 @@ async function promptSecret(label) {
           cleanup();
           process.exitCode = 130;
           stdout.write("\n");
-          return resolve14("");
+          return resolve15("");
         }
         if (char === "\r" || char === "\n") {
           finish();
@@ -10256,6 +10256,79 @@ async function promptSecret(label) {
   });
 }
 
+// src/tui/wizard.ts
+function resolveDefaultValue(defaultValue, state) {
+  if (typeof defaultValue === "function") return defaultValue(state);
+  return defaultValue;
+}
+async function readPromptValue(prompt, state) {
+  const kind = prompt.kind ?? "line";
+  const defaultValue = resolveDefaultValue(prompt.defaultValue, state);
+  if (kind === "confirm") {
+    const answer = await promptLine(prompt.label, { allowEmpty: true, defaultValue });
+    return isAffirmative(answer, prompt.confirmDefault ?? false);
+  }
+  if (kind === "secret") {
+    return (await promptSecret(prompt.label)).trim();
+  }
+  return await promptLine(prompt.label, {
+    allowEmpty: prompt.allowEmpty ?? false,
+    defaultValue
+  });
+}
+async function runWizardSession(options) {
+  const state = { ...options.initialState };
+  if (!options.enabled) return state;
+  ensureInteractive(options.step, options.remediation);
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    if (options.title) {
+      process.stdout.write(`
+${options.title}
+`);
+      process.stdout.write(`${"-".repeat(options.title.length)}
+`);
+    }
+    if (options.subtitle) process.stdout.write(`${options.subtitle}
+`);
+    if (Array.isArray(options.notes) && options.notes.length > 0) {
+      for (const note of options.notes) {
+        process.stdout.write(`${note}
+`);
+      }
+    }
+    if (options.title || options.subtitle || (options.notes?.length ?? 0) > 0) {
+      process.stdout.write("\n");
+    }
+  }
+  for (const prompt of options.prompts) {
+    if (typeof prompt.shouldPrompt === "function" && !prompt.shouldPrompt(state)) continue;
+    while (true) {
+      const resolved = await readPromptValue(prompt, state);
+      if (typeof resolved === "boolean") {
+        state[prompt.key] = resolved;
+        prompt.onResolved?.(resolved, state);
+        break;
+      }
+      const normalized = prompt.normalize ? prompt.normalize(resolved, state) : String(resolved).trim();
+      if (prompt.required && !normalized) {
+        process.stdout.write(`${prompt.label} is required.
+`);
+        continue;
+      }
+      const validationError = prompt.validate?.(normalized, state) ?? null;
+      if (validationError) {
+        process.stdout.write(`${validationError}
+`);
+        continue;
+      }
+      state[prompt.key] = normalized;
+      prompt.onResolved?.(normalized, state);
+      break;
+    }
+  }
+  return state;
+}
+
 // src/lib/console-url.ts
 var DEFAULT_FOH_CONSOLE_URL = "https://app.frontofhouse.okii.uk";
 function normalizeBaseUrl(value) {
@@ -10393,26 +10466,35 @@ function emitBrowserSignupLink(opts) {
   }, { json: opts.json ?? false });
 }
 async function resolveLoginInputs(opts) {
-  let email3 = String(opts.email ?? "").trim();
-  let password = String(opts.password ?? "").trim();
-  const needsPrompts = !email3 || !password;
-  if (needsPrompts) {
-    ensureInteractive("auth.login", "Pass --email and --password when running non-interactively.");
-  }
-  if ((opts.wizard || needsPrompts) && process.stdout.isTTY && process.stdin.isTTY && !opts.json) {
-    process.stdout.write("\nAuth Login Wizard\n");
-    process.stdout.write("-----------------\n");
-    process.stdout.write("Step 1/2: Enter account credentials.\n");
-  }
-  while (!email3) {
-    email3 = await promptLine("Email");
-    if (!email3) process.stdout.write("Email is required.\n");
-  }
-  while (!password) {
-    password = (await promptSecret("Password")).trim();
-    if (!password) process.stdout.write("Password is required.\n");
-  }
-  if (!email3 || !password) {
+  const initial = {
+    email: String(opts.email ?? "").trim(),
+    password: String(opts.password ?? "").trim()
+  };
+  const needsPrompts = !initial.email || !initial.password;
+  const resolved = await runWizardSession({
+    step: "auth.login",
+    remediation: "Pass --email and --password when running non-interactively.",
+    title: !opts.json ? "Auth Login Wizard" : void 0,
+    subtitle: !opts.json ? "Step 1/2: Enter account credentials." : void 0,
+    enabled: needsPrompts,
+    initialState: initial,
+    prompts: [
+      {
+        key: "email",
+        label: "Email",
+        required: true,
+        shouldPrompt: (state) => !String(state.email ?? "").trim()
+      },
+      {
+        key: "password",
+        label: "Password",
+        kind: "secret",
+        required: true,
+        shouldPrompt: (state) => !String(state.password ?? "").trim()
+      }
+    ]
+  });
+  if (!resolved.email || !resolved.password) {
     throw new FohError({
       step: "auth.login",
       error: "Email and password are required",
@@ -10422,7 +10504,7 @@ async function resolveLoginInputs(opts) {
   if ((opts.wizard || needsPrompts) && process.stdout.isTTY && process.stdin.isTTY && !opts.json) {
     process.stdout.write("Step 2/2: Requesting service token from API.\n");
   }
-  return { email: email3, password };
+  return { email: String(resolved.email), password: String(resolved.password) };
 }
 async function maybeSelectDefaultOrg(orgs, jsonMode) {
   if (jsonMode) return void 0;
@@ -10501,7 +10583,7 @@ async function storeAuthenticatedSession(params) {
   return output;
 }
 function sleep(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
 function hasExplicitTimeoutFlag(argv = process.argv) {
   return argv.some((arg) => arg === "--timeout-seconds" || arg.startsWith("--timeout-seconds="));
@@ -11059,7 +11141,7 @@ async function pollUntil(check2, opts) {
   }
 }
 function sleep2(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
 
 // src/commands/compliance.ts
@@ -14183,8 +14265,8 @@ function registerAgentGuardrailCommands(agent) {
     try {
       rule = JSON.parse(opts.rule);
     } catch {
-      const { readFileSync: readFileSync17 } = await import("fs");
-      rule = JSON.parse(readFileSync17(opts.rule, "utf-8"));
+      const { readFileSync: readFileSync19 } = await import("fs");
+      rule = JSON.parse(readFileSync19(opts.rule, "utf-8"));
     }
     const data = await apiFetch(`/v1/console/agents/${opts.agent}/guardrails`, {
       method: "POST",
@@ -14753,9 +14835,9 @@ function registerAgent(program3) {
       process.stdout.write(yaml);
       return;
     }
-    const { writeFileSync: writeFileSync14 } = await import("fs");
+    const { writeFileSync: writeFileSync15 } = await import("fs");
     const outputPath = opts.output ?? "tenant.yaml";
-    writeFileSync14(
+    writeFileSync15(
       outputPath,
       `# tenant.yaml - Front Of House agent manifest
 # Edit this file and run: foh plan tenant.yaml
@@ -14779,8 +14861,8 @@ ${yaml}`,
     format(data, { json: opts.json ?? false });
   }));
   agent.command("chat").description("Interactive REPL \u2014 send messages to an agent (human use only)").requiredOption("--agent <id>", "Agent ID").option("--org <id>", "Org ID (default: stored org from foh org use)").option("--api-url <url>", "API base URL override").action(async (opts) => withCommandErrorHandling(async () => {
-    const { createInterface: createInterface2 } = await import("readline");
-    const rl = createInterface2({ input: process.stdin, output: process.stdout, terminal: true });
+    const { createInterface: createInterface3 } = await import("readline");
+    const rl = createInterface3({ input: process.stdin, output: process.stdout, terminal: true });
     const ask = (prompt) => new Promise((res) => rl.question(prompt, res));
     console.log("Type your message and press Enter. Ctrl+C to exit.\n");
     while (true) {
@@ -15286,6 +15368,9 @@ function registerInstagramChannelCommands(instagram, addCommonOptions) {
   }));
 }
 
+// src/commands/channel-whatsapp.ts
+var import_node_fs2 = require("node:fs");
+
 // src/commands/channel-whatsapp-helpers.ts
 function parsePositiveNumber(value, fallback) {
   if (value === void 0 || value === null || String(value).trim() === "") return fallback;
@@ -15299,82 +15384,6 @@ function parsePositiveNumber(value, fallback) {
   }
   return parsed;
 }
-function readCapabilityFlag(capabilities, key) {
-  if (!capabilities || typeof capabilities !== "object") return false;
-  const direct = capabilities[key];
-  if (typeof direct === "boolean") return direct;
-  const lower = capabilities[key.toLowerCase()];
-  if (typeof lower === "boolean") return lower;
-  const upper = capabilities[key.toUpperCase()];
-  if (typeof upper === "boolean") return upper;
-  return false;
-}
-function resolveWhatsAppJourney(params) {
-  const readinessCode = String(params.verificationReadinessCode || "").trim();
-  const selectedMethod = String(params.selectedOtpMethod || "").trim().toLowerCase();
-  const recordingUrl = String(params.verificationReadiness?.recent_voice_call?.recording_url || "").trim();
-  if (params.telephonyReady === false || readinessCode === "twilio_number_not_configured") {
-    return {
-      stage: "provision_number",
-      reason_code: readinessCode || "telephony_step_incomplete",
-      explanation: "A dedicated Twilio phone number is required before WhatsApp verification can start.",
-      do_this_now: params.commands.provisionBuy,
-      after_this: params.commands.verificationReadiness
-    };
-  }
-  if (readinessCode === "verification_voice_call_required") {
-    return {
-      stage: "verify_number_voice",
-      reason_code: readinessCode,
-      explanation: recordingUrl ? `Voice OTP path is active. Latest call recording is available for OTP recovery: ${recordingUrl}` : "Voice OTP path is active. Complete Meta phone-call verification first.",
-      do_this_now: params.commands.verificationReadinessVoice,
-      after_this: params.commands.connect
-    };
-  }
-  if (readinessCode === "otp_method_sms_not_supported") {
-    return {
-      stage: "verify_number_voice",
-      reason_code: readinessCode,
-      explanation: "The current number is voice-only, so SMS verification is not supported.",
-      do_this_now: params.commands.verificationReadinessVoice,
-      after_this: params.commands.connect
-    };
-  }
-  if (readinessCode === "otp_method_voice_not_supported") {
-    return {
-      stage: "verify_number_sms",
-      reason_code: readinessCode,
-      explanation: "The current number does not support voice verification, so SMS must be used.",
-      do_this_now: params.commands.verificationReadinessSms,
-      after_this: params.commands.connect
-    };
-  }
-  if (readinessCode === "verification_code_not_found") {
-    return {
-      stage: selectedMethod === "voice" ? "verify_number_voice" : "verify_number_sms",
-      reason_code: readinessCode,
-      explanation: selectedMethod === "voice" ? "Waiting for an inbound verification call from Meta." : "Waiting for an inbound SMS verification code from Meta.",
-      do_this_now: selectedMethod === "voice" ? params.commands.verificationReadinessVoice : params.commands.verificationReadiness,
-      after_this: params.commands.connect
-    };
-  }
-  if (!params.whatsappConfigured || !params.whatsappReady || readinessCode === "verification_code_detected") {
-    return {
-      stage: "connect_channel",
-      reason_code: readinessCode || "whatsapp_channel_not_ready",
-      explanation: "Phone verification is ready; now connect WhatsApp channel credentials.",
-      do_this_now: params.commands.connect,
-      after_this: params.commands.proof
-    };
-  }
-  return {
-    stage: "proof",
-    reason_code: readinessCode || "ready_for_proof",
-    explanation: "Channel is configured and ready for deterministic closure checks.",
-    do_this_now: params.commands.proof,
-    after_this: null
-  };
-}
 function withNumberedSteps(steps) {
   return steps.filter((step) => step.trim().length > 0).map((step, index) => `${index + 1}. ${step}`).join(" ");
 }
@@ -15596,85 +15605,6 @@ function buildWebhookUrl(apiBaseUrl) {
 function generateVerifyToken() {
   return `${WHATSAPP_VERIFY_TOKEN_PREFIX}-${(0, import_node_crypto.randomBytes)(12).toString("hex")}`;
 }
-function readStepStatus(steps, id) {
-  const matched = Array.isArray(steps) ? steps.find((step) => String(step?.id || "").trim() === id) : null;
-  if (!matched) return null;
-  return matched.status === true;
-}
-async function resolveWhatsAppSetupInputs(opts) {
-  let phoneNumberId = String(opts.phoneNumberId ?? "").trim();
-  let accessToken = String(opts.accessToken ?? "").trim();
-  let verifyToken = String(opts.verifyToken ?? "").trim();
-  let verifyTokenGenerated = false;
-  let appSecret = String(opts.appSecret ?? "").trim();
-  const canGenerateVerifyToken = Boolean(opts.generateVerifyToken);
-  let audioEnabled = parseBooleanOption({
-    value: opts.audioEnabled,
-    fallback: true,
-    optionName: "--audio-enabled",
-    step: "channel.whatsapp.setup"
-  });
-  const needsPrompts = !phoneNumberId || !accessToken || !verifyToken && !canGenerateVerifyToken || !appSecret;
-  if (opts.wizard || needsPrompts) {
-    ensureInteractive(
-      "channel.whatsapp.setup",
-      "Pass --phone-number-id, --access-token, --verify-token and --app-secret when running non-interactively."
-    );
-  }
-  if ((opts.wizard || needsPrompts) && process.stdin.isTTY && process.stdout.isTTY && !opts.json) {
-    process.stdout.write("\nWhatsApp Setup Wizard\n");
-    process.stdout.write("---------------------\n");
-    process.stdout.write("This flow configures the channel and runs readiness checks before completion.\n");
-    process.stdout.write("Use a verified WhatsApp Business sender for production traffic; Meta test numbers are sandbox-only.\n");
-    process.stdout.write("\nRequired Meta values:\n");
-    process.stdout.write("  - Phone Number ID (verified production sender for production; sandbox test sender only for temporary tests)\n");
-    process.stdout.write("  - Access Token (temporary/system-user token)\n");
-    process.stdout.write("  - Verify Token (your own secret string; can auto-generate)\n");
-    process.stdout.write("  - App Secret (Meta App -> Settings -> Basic)\n\n");
-  }
-  while (!phoneNumberId) {
-    phoneNumberId = (await promptLine("Meta Phone Number ID")).trim();
-    if (!phoneNumberId) process.stdout.write("Phone Number ID is required.\n");
-  }
-  while (!accessToken) {
-    accessToken = (await promptSecret("Meta Access Token")).trim();
-    if (!accessToken) process.stdout.write("Access Token is required.\n");
-  }
-  if (!verifyToken && opts.generateVerifyToken) {
-    verifyToken = generateVerifyToken();
-    verifyTokenGenerated = true;
-  }
-  if (!verifyToken && process.stdin.isTTY && process.stdout.isTTY && !opts.json) {
-    const answer = await promptLine("Generate webhook verify token automatically? [Y/n]", { allowEmpty: true });
-    if (isAffirmative(answer, true)) {
-      verifyToken = generateVerifyToken();
-      verifyTokenGenerated = true;
-      process.stdout.write(`Generated Verify Token: ${verifyToken}
-`);
-      process.stdout.write("Copy this token into Meta webhook settings exactly.\n");
-    }
-  }
-  while (!verifyToken) {
-    verifyToken = (await promptSecret("Webhook Verify Token")).trim();
-    if (!verifyToken) process.stdout.write("Verify Token is required.\n");
-  }
-  while (!appSecret) {
-    appSecret = (await promptSecret("Meta App Secret")).trim();
-    if (!appSecret) process.stdout.write("App Secret is required.\n");
-  }
-  if (opts.audioEnabled === void 0 && process.stdin.isTTY && process.stdout.isTTY && !opts.json) {
-    const answer = await promptLine("Enable inbound WhatsApp audio fallback auto-reply? [Y/n]", { allowEmpty: true });
-    audioEnabled = isAffirmative(answer, true);
-  }
-  return {
-    phoneNumberId,
-    accessToken,
-    verifyToken,
-    verifyTokenGenerated,
-    appSecret,
-    audioEnabled
-  };
-}
 async function runWebhookChallengeCheck({
   apiBaseUrl,
   verifyToken
@@ -15728,277 +15658,409 @@ function assertProofPass(strict, reasons) {
 }
 
 // src/commands/channel-whatsapp.ts
-function registerWhatsAppChannelCommands(whatsapp, addCommonOptions) {
-  addCommonOptions(
-    whatsapp.command("start").description("Assess WhatsApp onboarding readiness and print fastest setup path")
-  ).option("--country <cc>", "ISO country code used for Twilio number recommendations", "GB").option("--area-code <code>", "Optional area code preference for number suggestions").option("--agent-id <id>", "Agent to bind to the WhatsApp channel").option("--verify-token <token>", "Optional verify token to include in generated commands").option("--generate-verify-token", "Generate verify token for the onboarding plan output").action(async (opts) => withCommandErrorHandling(async () => {
-    const resolvedOrg = resolveRequiredOrgId(opts.org, {
-      apiUrl: opts.apiUrl,
-      step: "channel.whatsapp.start",
-      remediation: "Run: foh org use --org <id> to set a default, or pass --org <id>"
+async function runWhatsAppOnboardingSession(params) {
+  return await apiFetch("/v1/console/channels/whatsapp/onboarding-session", {
+    method: "POST",
+    body: JSON.stringify({
+      accessToken: params.accessToken,
+      wabaId: params.wabaId,
+      phoneNumberId: params.phoneNumberId,
+      verifyToken: params.verifyToken,
+      appSecret: params.appSecret,
+      agentId: params.agentId,
+      businessSlug: params.businessSlug,
+      audioEnabled: params.audioEnabled,
+      dryRun: params.dryRun
+    }),
+    orgId: params.orgId,
+    apiUrlOverride: params.apiUrl
+  });
+}
+function emitLegacyCommandNotice({
+  command,
+  canonical,
+  jsonMode
+}) {
+  if (!jsonMode) {
+    process.stderr.write(
+      `[deprecated] foh channel whatsapp ${command} is a compatibility wrapper.
+Use: ${canonical}
+`
+    );
+  }
+  return {
+    command,
+    canonical,
+    status: "deprecated_compat_wrapper"
+  };
+}
+function parseBatchManifest(manifestPathRaw) {
+  const manifestPath = String(manifestPathRaw || "").trim();
+  if (!manifestPath) {
+    throw new FohError({
+      step: "channel.whatsapp.batch",
+      error: "--manifest is required",
+      remediation: "Provide a JSON manifest path with a businesses array."
     });
-    const country = String(opts.country || "GB").trim().toUpperCase();
-    const areaCode = String(opts.areaCode || "").trim();
-    const creds = loadCredentials(opts.apiUrl);
-    const apiBaseUrl = creds.apiUrl;
-    const webhookUrl = buildWebhookUrl(apiBaseUrl);
-    const verifyToken = String(opts.verifyToken || "").trim() || (opts.generateVerifyToken ? generateVerifyToken() : "<verify_token>");
-    const generatedVerifyToken = Boolean(opts.generateVerifyToken && !opts.verifyToken);
-    let onboarding = null;
-    try {
-      onboarding = await apiFetch(`/v1/console/org/${resolvedOrg}/onboarding`, {
-        orgId: resolvedOrg,
-        apiUrlOverride: opts.apiUrl
-      });
-    } catch (error2) {
-      if (!(error2 instanceof FohError)) throw error2;
+  }
+  try {
+    const raw = (0, import_node_fs2.readFileSync)(manifestPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.businesses) || parsed.businesses.length === 0) {
+      throw new Error("manifest_missing_businesses");
     }
-    let whatsappStatus = null;
-    let whatsappConfigured = true;
-    try {
-      whatsappStatus = await apiFetch("/v1/console/channels/whatsapp/status", {
-        orgId: resolvedOrg,
-        apiUrlOverride: opts.apiUrl
-      });
-    } catch (error2) {
-      if (!(error2 instanceof FohError)) throw error2;
-      const reasonCode = String(error2.detail?.code || "").trim();
-      if (error2.statusCode === 404 && reasonCode === "whatsapp_channel_not_configured") {
-        whatsappConfigured = false;
-      } else {
-        throw error2;
+    return parsed;
+  } catch (error2) {
+    throw new FohError({
+      step: "channel.whatsapp.batch",
+      error: "Failed to read --manifest JSON or businesses array is empty.",
+      remediation: 'Provide a JSON file: { "businesses": [{ "businessSlug": "...", "accessToken": "..." }] }',
+      detail: { cause: error2 instanceof Error ? error2.message : String(error2) }
+    });
+  }
+}
+function candidateLabel(candidate, index) {
+  const phoneNumberId = String(candidate.phone_number_id || "").trim() || "<missing-phone-id>";
+  const display = String(candidate.display_phone_number || "").trim();
+  const verified = String(candidate.verified_name || "").trim();
+  const wabaId = String(candidate.waba_id || "").trim();
+  const displayPart = display ? ` ${display}` : "";
+  const verifiedPart = verified ? ` (${verified})` : "";
+  const wabaPart = wabaId ? ` [waba:${wabaId}]` : "";
+  return `${index + 1}. ${phoneNumberId}${displayPart}${verifiedPart}${wabaPart}`;
+}
+async function runWhatsAppOnboardingWizard(opts) {
+  const wizardState = await runWizardSession({
+    step: "channel.whatsapp.onboard",
+    remediation: "Pass --access-token (and optionally --waba-id / --phone-number-id) when running non-interactively.",
+    title: "WhatsApp Onboarding Wizard",
+    subtitle: "Paste your Meta access token first. The wizard will auto-recover from discovery blockers.",
+    enabled: true,
+    initialState: {
+      accessToken: String(opts.accessToken || "").trim(),
+      appSecret: String(opts.appSecret || "").trim(),
+      provideAppSecret: false
+    },
+    prompts: [
+      {
+        key: "accessToken",
+        label: "Meta Access Token",
+        kind: "secret",
+        required: true,
+        shouldPrompt: (state) => !String(state.accessToken ?? "").trim()
+      },
+      {
+        key: "provideAppSecret",
+        label: "Provide Meta App Secret now for signature-ready closure? [Y/n]",
+        kind: "confirm",
+        confirmDefault: true,
+        shouldPrompt: (state) => !String(state.appSecret ?? "").trim()
+      },
+      {
+        key: "appSecret",
+        label: "Meta App Secret",
+        kind: "secret",
+        required: true,
+        shouldPrompt: (state) => !String(state.appSecret ?? "").trim() && state.provideAppSecret === true
       }
-    }
-    let availableNumbers = [];
-    let numberLookupWarning = null;
-    try {
-      const qs = new URLSearchParams({ country });
-      if (areaCode) qs.set("area_code", areaCode);
-      const availability = await apiFetch(`/v1/console/org/twilio/available-numbers?${qs.toString()}`, {
-        orgId: resolvedOrg,
-        apiUrlOverride: opts.apiUrl
-      });
-      availableNumbers = Array.isArray(availability.numbers) ? availability.numbers : [];
-    } catch (error2) {
-      if (!(error2 instanceof FohError)) throw error2;
-      numberLookupWarning = error2.error || "Twilio number lookup unavailable for this org context.";
-    }
-    const smsVoiceCandidates = availableNumbers.filter((entry) => {
-      const capabilities = entry.capabilities || {};
-      return readCapabilityFlag(capabilities, "sms") && readCapabilityFlag(capabilities, "voice");
-    }).slice(0, 3).map((entry) => entry.number).filter((value) => typeof value === "string" && value.trim().length > 0);
-    const voiceOnlyCandidates = availableNumbers.filter((entry) => {
-      const capabilities = entry.capabilities || {};
-      return readCapabilityFlag(capabilities, "voice") && !readCapabilityFlag(capabilities, "sms");
-    }).slice(0, 3).map((entry) => entry.number).filter((value) => typeof value === "string" && value.trim().length > 0);
-    const telephonyReady = readStepStatus(onboarding?.steps, "telephony");
-    const whatsappReady = Boolean(whatsappStatus?.channel?.ready);
-    const areaSegment = areaCode ? ` --area-code ${areaCode}` : "";
-    const provisionBuyCommand = `foh provision buy --country ${country}${areaSegment} --org ${resolvedOrg}`;
-    const listNumbersCommand = `foh provision numbers --country ${country}${areaSegment} --org ${resolvedOrg}`;
-    const verificationReadinessCommand = `foh provision whatsapp-verification --lookback-minutes 60 --org ${resolvedOrg}`;
-    const verificationReadinessVoiceCommand = `foh provision whatsapp-verification --lookback-minutes 60 --otp-method voice --org ${resolvedOrg}`;
-    const verificationReadinessSmsCommand = `foh provision whatsapp-verification --lookback-minutes 60 --otp-method sms --org ${resolvedOrg}`;
-    const agentIdSegment = opts.agentId ? ` --agent-id ${opts.agentId}` : "";
-    const connectCommand = `foh channel whatsapp connect${agentIdSegment} --phone-number-id <meta_phone_number_id> --access-token <meta_access_token> --verify-token ${verifyToken} --app-secret <meta_app_secret> --org ${resolvedOrg}`;
-    const setupCommand = `foh channel whatsapp setup --wizard${agentIdSegment} --verify-token ${verifyToken} --org ${resolvedOrg}`;
-    const proofCommand = `foh channel whatsapp proof --strict --verify-token ${verifyToken} --org ${resolvedOrg}`;
-    const liveProofCommand = "corepack pnpm ops:whatsapp:proof:live";
-    let verificationReadiness = null;
-    let verificationReadinessCode = null;
+    ]
+  });
+  let accessToken = String(wizardState.accessToken || "").trim();
+  let wabaId = String(opts.wabaId || "").trim();
+  let phoneNumberId = String(opts.phoneNumberId || "").trim();
+  let verifyToken = String(opts.verifyToken || "").trim();
+  let appSecret = String(wizardState.appSecret || "").trim();
+  if (!accessToken) {
+    throw new FohError({
+      step: "channel.whatsapp.onboard",
+      error: "Meta access token is required.",
+      remediation: "Run onboarding again and provide a valid token."
+    });
+  }
+  const audioEnabled = parseBooleanOption({
+    value: opts.audioEnabled,
+    fallback: true,
+    optionName: "--audio-enabled",
+    step: "channel.whatsapp.onboard"
+  });
+  const dryRun = Boolean(opts.dryRun);
+  for (let attempt = 1; attempt <= 4; attempt += 1) {
     try {
-      verificationReadiness = await apiFetch("/v1/console/channels/whatsapp/verification-readiness?lookback_minutes=60&otp_method=auto", {
-        orgId: resolvedOrg,
-        apiUrlOverride: opts.apiUrl
+      return await runWhatsAppOnboardingSession({
+        orgId: opts.org,
+        apiUrl: opts.apiUrl,
+        accessToken,
+        wabaId: wabaId || void 0,
+        phoneNumberId: phoneNumberId || void 0,
+        verifyToken: verifyToken || void 0,
+        appSecret: appSecret || void 0,
+        agentId: opts.agentId,
+        businessSlug: opts.businessSlug,
+        audioEnabled,
+        dryRun
       });
-      verificationReadinessCode = typeof verificationReadiness.code === "string" ? verificationReadiness.code : null;
     } catch (error2) {
       if (!(error2 instanceof FohError)) throw error2;
-      verificationReadinessCode = String(error2.detail?.code || "").trim() || null;
-    }
-    const selectedOtpMethod = String(verificationReadiness?.verification?.selected_method || "").trim().toLowerCase();
-    const verificationPrimaryStep = selectedOtpMethod === "voice" ? `In Meta number setup, request Phone call verification, then confirm readiness with: ${verificationReadinessVoiceCommand}` : `In Meta number setup, request SMS verification, then detect OTP with: ${verificationReadinessCommand}`;
-    const verificationFallbackStep = selectedOtpMethod === "sms" ? `If SMS OTP does not arrive, switch to voice OTP path: ${verificationReadinessVoiceCommand}` : "";
-    const nextSteps = dedupeSteps([
-      telephonyReady === false ? `Provision a dedicated business number first: ${provisionBuyCommand}` : "",
-      verificationPrimaryStep,
-      verificationFallbackStep,
-      !whatsappConfigured || !whatsappReady ? `Connect WhatsApp credentials: ${connectCommand}` : "",
-      `In Meta webhook settings, set callback URL=${webhookUrl} and verify token=${verifyToken}.`,
-      `Validate deterministic readiness: ${proofCommand}`,
-      `Capture live-provider evidence before release: ${liveProofCommand}`
-    ]);
-    const notes = dedupeSteps([
-      smsVoiceCandidates.length === 0 && availableNumbers.length > 0 ? "No SMS+voice candidates found in current Twilio list response; voice-only numbers may still work if Meta verification uses phone call." : "",
-      numberLookupWarning ? `Twilio number suggestion lookup warning: ${numberLookupWarning}` : ""
-    ]);
-    const journey = resolveWhatsAppJourney({
-      telephonyReady,
-      whatsappConfigured,
-      whatsappReady,
-      verificationReadinessCode,
-      selectedOtpMethod,
-      verificationReadiness,
-      commands: {
-        provisionBuy: provisionBuyCommand,
-        verificationReadiness: verificationReadinessCommand,
-        verificationReadinessVoice: verificationReadinessVoiceCommand,
-        verificationReadinessSms: verificationReadinessSmsCommand,
-        connect: connectCommand,
-        proof: proofCommand
+      const detail = error2.detail || {};
+      const code = String(detail.code || "").trim();
+      const discovery = detail.discovery || {};
+      const candidates = Array.isArray(discovery.candidates) ? discovery.candidates : [];
+      if (code === "whatsapp_multi_candidate_ambiguous" && candidates.length > 0) {
+        process.stdout.write("\nMultiple senders found. Choose one:\n");
+        for (const [index, candidate] of candidates.entries()) {
+          process.stdout.write(`  ${candidateLabel(candidate, index)}
+`);
+        }
+        const pick2 = (await promptLine("Select number (1..n) or paste phone_number_id")).trim();
+        const pickIndex = Number.parseInt(pick2, 10);
+        if (Number.isFinite(pickIndex) && pickIndex >= 1 && pickIndex <= candidates.length) {
+          phoneNumberId = String(candidates[pickIndex - 1]?.phone_number_id || "").trim();
+        } else {
+          phoneNumberId = pick2;
+        }
+        if (phoneNumberId) continue;
+      }
+      if (!wabaId) {
+        const reasonCode = String(discovery.reason_code || code).trim();
+        if (reasonCode === "whatsapp_discovery_failed" || reasonCode === "whatsapp_phone_discovery_blocked" || reasonCode === "whatsapp_no_phone_numbers_found") {
+          const promptedWaba = (await promptLine("Paste WABA ID (optional, press Enter to skip)", { allowEmpty: true })).trim();
+          if (promptedWaba) {
+            wabaId = promptedWaba;
+            continue;
+          }
+        }
+      }
+      if (!phoneNumberId) {
+        const promptedPhone = (await promptLine("Paste phone_number_id directly (optional, press Enter to stop)", { allowEmpty: true })).trim();
+        if (promptedPhone) {
+          phoneNumberId = promptedPhone;
+          continue;
+        }
       }
+      throw error2;
+    }
+  }
+  throw new FohError({
+    step: "channel.whatsapp.onboard",
+    error: "Unable to complete WhatsApp onboarding after guided retries.",
+    remediation: "Run again with --phone-number-id and --waba-id, or use `foh channel whatsapp start` for deterministic next steps."
+  });
+}
+function registerWhatsAppChannelCommands(whatsapp, addCommonOptions) {
+  addCommonOptions(
+    whatsapp.command("start").description("[Deprecated wrapper] Start onboarding using the canonical session flow")
+  ).option("--access-token <token>", "Meta access token with WhatsApp Business access").option("--waba-id <id>", "Optional explicit WhatsApp Business Account id when /me discovery is restricted").option("--phone-number-id <id>", "Optional explicit phone number id when discovery returns multiple candidates").option("--agent-id <id>", "Agent to bind to the WhatsApp channel").option("--verify-token <token>", "Optional webhook verify token (auto-generated when omitted)").option("--app-secret <secret>", "Optional Meta app secret (required for full signature-ready closure)").option("--business-slug <slug>", "Business identifier for operator-level targeting").option("--audio-enabled <bool>", "Enable inbound WhatsApp audio fallback auto-reply (true/false)", "true").option("--wizard", "Run guided onboarding with automatic recovery prompts").action(async (opts) => withCommandErrorHandling(async () => {
+    const accessToken = String(opts.accessToken || "").trim();
+    const useWizard = Boolean(opts.wizard) || !accessToken;
+    const legacy = emitLegacyCommandNotice({
+      command: "start",
+      canonical: "foh channel whatsapp onboard --wizard",
+      jsonMode: Boolean(opts.json)
+    });
+    const data = useWizard ? await runWhatsAppOnboardingWizard({
+      ...opts,
+      dryRun: true
+    }) : await runWhatsAppOnboardingSession({
+      orgId: opts.org,
+      apiUrl: opts.apiUrl,
+      accessToken,
+      wabaId: String(opts.wabaId || "").trim() || void 0,
+      phoneNumberId: String(opts.phoneNumberId || "").trim() || void 0,
+      verifyToken: String(opts.verifyToken || "").trim() || void 0,
+      appSecret: String(opts.appSecret || "").trim() || void 0,
+      agentId: opts.agentId,
+      businessSlug: opts.businessSlug,
+      audioEnabled: parseBooleanOption({
+        value: opts.audioEnabled,
+        fallback: true,
+        optionName: "--audio-enabled",
+        step: "channel.whatsapp.start"
+      }),
+      dryRun: true
     });
     format({
-      ok: true,
-      channel: "whatsapp",
-      org_id: resolvedOrg,
-      webhook_callback_url: webhookUrl,
-      generated_verify_token: generatedVerifyToken ? verifyToken : null,
-      readiness: {
-        telephony_step_ready: telephonyReady,
-        whatsapp_channel_configured: whatsappConfigured,
-        whatsapp_channel_ready: whatsappReady
-      },
-      market_scan: {
-        country,
-        area_code: areaCode || null,
-        candidate_count: availableNumbers.length,
-        sms_voice_candidates: smsVoiceCandidates,
-        voice_only_candidates: voiceOnlyCandidates
-      },
-      sender_model: WHATSAPP_SENDER_MODEL,
-      commands: {
-        list_numbers: listNumbersCommand,
-        provision_buy: provisionBuyCommand,
-        verification_readiness: verificationReadinessCommand,
-        verification_readiness_sms: verificationReadinessSmsCommand,
-        verification_readiness_voice: verificationReadinessVoiceCommand,
-        connect: connectCommand,
-        setup_wizard: setupCommand,
-        proof: proofCommand,
-        live_proof: liveProofCommand
-      },
-      verification_readiness: verificationReadiness || { code: verificationReadinessCode || "verification_readiness_unavailable" },
-      journey,
-      next_steps: nextSteps,
-      notes
+      ...data,
+      legacy_wrapper: legacy,
+      next_steps: dedupeSteps([
+        "Run canonical onboarding apply flow: foh channel whatsapp onboard --wizard",
+        "Run deterministic closure: foh channel whatsapp proof --strict",
+        "Capture live provider evidence: corepack pnpm ops:whatsapp:proof:live"
+      ])
     }, { json: opts.json ?? false });
   }));
   addCommonOptions(
-    whatsapp.command("setup").description("Run guided WhatsApp setup and readiness checks")
-  ).option("--phone-number-id <id>", "Meta WhatsApp phone number id").option("--access-token <token>", "Meta access token").option("--verify-token <token>", "Webhook verify token").option("--app-secret <secret>", "Meta app secret for signature verification").option("--agent-id <id>", "Agent to bind to the WhatsApp channel").option("--audio-enabled <bool>", "Enable inbound WhatsApp audio fallback auto-reply (true/false)").option("--generate-verify-token", "Generate webhook verify token automatically when missing").option("--wizard", "Run guided setup wizard prompts").action(async (opts) => withCommandErrorHandling(async () => {
-    const inputs = await resolveWhatsAppSetupInputs(opts);
-    const creds = loadCredentials(opts.apiUrl);
-    const apiBaseUrl = creds.apiUrl;
-    const webhookUrl = buildWebhookUrl(apiBaseUrl);
-    const connect = await apiFetch("/v1/console/channels/whatsapp/connect", {
-      method: "POST",
-      body: JSON.stringify({
-        phoneNumberId: inputs.phoneNumberId,
-        accessToken: inputs.accessToken,
-        agentId: opts.agentId,
-        verifyToken: inputs.verifyToken,
-        appSecret: inputs.appSecret,
-        audioEnabled: inputs.audioEnabled
-      }),
-      orgId: opts.org,
-      apiUrlOverride: opts.apiUrl
-    });
-    const checks = await runWhatsAppReadinessChecks({
+    whatsapp.command("onboard").description("Run one-session WhatsApp onboarding (discover -> bind -> verify -> prove)")
+  ).option("--access-token <token>", "Meta access token with WhatsApp Business access").option("--waba-id <id>", "Optional explicit WhatsApp Business Account id when /me discovery is restricted").option("--phone-number-id <id>", "Optional explicit phone number id when discovery returns multiple candidates").option("--verify-token <token>", "Optional webhook verify token (auto-generated when omitted)").option("--app-secret <secret>", "Optional Meta app secret (required for full signature-ready closure)").option("--agent-id <id>", "Agent to bind to the WhatsApp channel").option("--business-slug <slug>", "Business identifier for operator-level targeting").option("--audio-enabled <bool>", "Enable inbound WhatsApp audio fallback auto-reply (true/false)", "true").option("--dry-run", "Run discovery/binding preflight without writing channel config").option("--wizard", "Run guided onboarding with automatic recovery prompts").action(async (opts) => withCommandErrorHandling(async () => {
+    const accessToken = String(opts.accessToken || "").trim();
+    const useWizard = Boolean(opts.wizard) || !accessToken;
+    const data = useWizard ? await runWhatsAppOnboardingWizard(opts) : await runWhatsAppOnboardingSession({
       orgId: opts.org,
-      apiUrlOverride: opts.apiUrl,
-      verifyToken: inputs.verifyToken
-    });
-    const webhook = await runWebhookChallengeCheck({
-      apiBaseUrl,
-      verifyToken: inputs.verifyToken
+      apiUrl: opts.apiUrl,
+      accessToken,
+      wabaId: String(opts.wabaId || "").trim() || void 0,
+      phoneNumberId: String(opts.phoneNumberId || "").trim() || void 0,
+      verifyToken: String(opts.verifyToken || "").trim() || void 0,
+      appSecret: String(opts.appSecret || "").trim() || void 0,
+      agentId: opts.agentId,
+      businessSlug: opts.businessSlug,
+      audioEnabled: parseBooleanOption({
+        value: opts.audioEnabled,
+        fallback: true,
+        optionName: "--audio-enabled",
+        step: "channel.whatsapp.onboard"
+      }),
+      dryRun: Boolean(opts.dryRun)
     });
-    if (!webhook.ok) {
-      throw new FohError({
-        step: "channel.whatsapp.setup",
-        error: "Webhook verification challenge did not pass.",
-        remediation: `Set callback URL=${webhookUrl}, verify token exactly, subscribe message events, then retry.`
-      });
+    format(data, { json: opts.json ?? false });
+  }));
+  addCommonOptions(
+    whatsapp.command("batch").description("Run manifest-driven WhatsApp onboarding across multiple businesses")
+  ).requiredOption("--manifest <path>", "Path to batch manifest JSON").option("--apply", "Apply writes (default is dry-run preflight)").option("--strict", "Exit non-zero when any business fails").action(async (opts) => withCommandErrorHandling(async () => {
+    const manifest = parseBatchManifest(String(opts.manifest || ""));
+    const applyMode = Boolean(opts.apply);
+    const rows = manifest.businesses || [];
+    const results = [];
+    const failureTaxonomy = {};
+    for (const [index, row] of rows.entries()) {
+      const entry = row || {};
+      const accessToken = String(entry.accessToken || "").trim();
+      if (!accessToken) {
+        const code = "whatsapp_access_token_required";
+        failureTaxonomy[code] = (failureTaxonomy[code] || 0) + 1;
+        results.push({
+          index,
+          business_slug: String(entry.businessSlug || "").trim() || null,
+          ok: false,
+          code,
+          reason_codes: [code]
+        });
+        continue;
+      }
+      try {
+        const response = await runWhatsAppOnboardingSession({
+          orgId: opts.org,
+          apiUrl: opts.apiUrl,
+          accessToken,
+          wabaId: String(entry.wabaId || "").trim() || void 0,
+          phoneNumberId: String(entry.phoneNumberId || "").trim() || void 0,
+          verifyToken: String(entry.verifyToken || "").trim() || void 0,
+          appSecret: String(entry.appSecret || "").trim() || void 0,
+          agentId: String(entry.agentId || "").trim() || void 0,
+          businessSlug: String(entry.businessSlug || "").trim() || void 0,
+          audioEnabled: parseBooleanOption({
+            value: entry.audioEnabled,
+            fallback: true,
+            optionName: "batch.audioEnabled",
+            step: "channel.whatsapp.batch"
+          }),
+          dryRun: entry.dryRun === void 0 ? !applyMode : Boolean(entry.dryRun)
+        });
+        results.push({
+          index,
+          business_slug: String(entry.businessSlug || "").trim() || null,
+          ok: true,
+          code: String(response.code || "whatsapp_onboarding_session_ready"),
+          selected_candidate: response.selected_candidate || null
+        });
+      } catch (error2) {
+        if (!(error2 instanceof FohError)) throw error2;
+        const detail = error2.detail || {};
+        const code = String(detail.code || error2.reasonCode || "whatsapp_batch_onboarding_failed").trim();
+        failureTaxonomy[code] = (failureTaxonomy[code] || 0) + 1;
+        results.push({
+          index,
+          business_slug: String(entry.businessSlug || "").trim() || null,
+          ok: false,
+          code,
+          reason_codes: Array.isArray(detail.reason_codes) ? detail.reason_codes : [code]
+        });
+      }
     }
-    const readinessReasons = collectReadinessReasons({
-      checks,
-      webhookCheck: webhook
-    });
-    if (readinessReasons.length > 0) {
-      const steps = buildReasonedNextSteps({
-        reasons: readinessReasons,
-        webhookUrl,
-        verifyToken: inputs.verifyToken,
-        includeLiveStep: false,
-        liveArtifactPath: "test-results/whatsapp-live-proof.latest.json"
-      });
-      throw new FohError({
-        step: "channel.whatsapp.setup",
-        error: `Readiness checks failed: ${readinessReasons.join(", ")}`,
-        remediation: withNumberedSteps(steps)
-      });
+    const successCount = results.filter((entry) => entry.ok === true).length;
+    const failureCount = results.length - successCount;
+    if (Boolean(opts.strict) && failureCount > 0) {
+      process.exitCode = 1;
     }
-    const setupCommands = {
-      verify: `foh channel whatsapp proof --strict --verify-token ${inputs.verifyToken}`,
-      live: "corepack pnpm ops:whatsapp:proof:live"
-    };
     format({
-      ok: true,
+      ok: failureCount === 0,
       channel: "whatsapp",
-      status: "ready",
-      checks: {
-        connect: connect.ok ?? true,
-        status_ready: Boolean(checks.status.channel?.ready),
-        verify: Boolean(checks.verify.ok),
-        dry_run_test: Boolean(checks.test.ok),
-        webhook_verification: webhook.ok
-      },
-      channel_state: {
-        channel_id: checks.status.channel?.channel_id ?? null,
-        phone_number_id: checks.status.channel?.phone_number_id ?? null,
-        ready: Boolean(checks.status.channel?.ready),
-        verify_token_configured: Boolean(checks.status.channel?.verify_token_configured),
-        app_secret_configured: Boolean(checks.status.channel?.app_secret_configured),
-        audio_enabled: Boolean(checks.status.channel?.audio_enabled)
-      },
-      sender_model: WHATSAPP_SENDER_MODEL,
-      generated_verify_token: inputs.verifyTokenGenerated ? inputs.verifyToken : null,
-      meta_next_steps: [
-        `Meta callback URL: ${webhookUrl}`,
-        "Meta verify token: use the same value configured in this setup flow.",
-        "Subscribe webhook events for WhatsApp messages.",
-        "Use Meta test sender IDs only for sandbox testing; switch FOH channel config to a verified WhatsApp Business phone_number_id before production traffic.",
-        "Set app to live mode when Meta requirements are complete."
-      ],
-      operator_next_steps: [
-        `Run \`${setupCommands.verify}\` for a deterministic closure check.`,
-        "Run `corepack pnpm ops:whatsapp:proof:live` to capture production live-proof artifact."
-      ],
-      setup_commands: setupCommands
+      workflow: "batch_onboarding_session",
+      apply_mode: applyMode,
+      total: results.length,
+      success_count: successCount,
+      failure_count: failureCount,
+      failure_taxonomy: failureTaxonomy,
+      results
     }, { json: opts.json ?? false });
   }));
   addCommonOptions(
-    whatsapp.command("connect").description("Connect WhatsApp channel credentials")
-  ).requiredOption("--phone-number-id <id>", "Meta WhatsApp phone number id").requiredOption("--access-token <token>", "Meta access token").option("--agent-id <id>", "Agent to bind to the WhatsApp channel").option("--verify-token <token>", "Webhook verify token").option("--app-secret <secret>", "Meta app secret for signature verification").option("--audio-enabled <bool>", "Enable inbound WhatsApp audio fallback auto-reply (true/false)", "true").action(async (opts) => withCommandErrorHandling(async () => {
-    const data = await apiFetch("/v1/console/channels/whatsapp/connect", {
-      method: "POST",
-      body: JSON.stringify({
-        phoneNumberId: opts.phoneNumberId,
-        accessToken: opts.accessToken,
-        agentId: opts.agentId,
-        verifyToken: opts.verifyToken,
-        appSecret: opts.appSecret,
-        audioEnabled: parseBooleanOption({
-          value: opts.audioEnabled,
-          fallback: true,
-          optionName: "--audio-enabled",
-          step: "channel.whatsapp.connect"
-        })
+    whatsapp.command("setup").description("[Deprecated wrapper] Use canonical onboarding session flow")
+  ).option("--phone-number-id <id>", "Meta WhatsApp phone number id").option("--access-token <token>", "Meta access token").option("--verify-token <token>", "Webhook verify token").option("--app-secret <secret>", "Meta app secret for signature verification").option("--agent-id <id>", "Agent to bind to the WhatsApp channel").option("--audio-enabled <bool>", "Enable inbound WhatsApp audio fallback auto-reply (true/false)").option("--generate-verify-token", "Generate webhook verify token automatically when missing").option("--business-slug <slug>", "Business identifier for operator-level targeting").option("--wizard", "Run guided setup wizard prompts").action(async (opts) => withCommandErrorHandling(async () => {
+    const legacy = emitLegacyCommandNotice({
+      command: "setup",
+      canonical: "foh channel whatsapp onboard --wizard",
+      jsonMode: Boolean(opts.json)
+    });
+    const useWizard = Boolean(opts.wizard) || !String(opts.accessToken || "").trim();
+    const generatedVerifyToken = String(opts.verifyToken || "").trim() || (Boolean(opts.generateVerifyToken) ? generateVerifyToken() : "");
+    const data = useWizard ? await runWhatsAppOnboardingWizard({
+      ...opts,
+      verifyToken: generatedVerifyToken || void 0,
+      dryRun: false
+    }) : await runWhatsAppOnboardingSession({
+      orgId: opts.org,
+      apiUrl: opts.apiUrl,
+      accessToken: String(opts.accessToken || "").trim(),
+      wabaId: void 0,
+      phoneNumberId: String(opts.phoneNumberId || "").trim() || void 0,
+      verifyToken: generatedVerifyToken || void 0,
+      appSecret: String(opts.appSecret || "").trim() || void 0,
+      agentId: opts.agentId,
+      businessSlug: String(opts.businessSlug || "").trim() || void 0,
+      audioEnabled: parseBooleanOption({
+        value: opts.audioEnabled,
+        fallback: true,
+        optionName: "--audio-enabled",
+        step: "channel.whatsapp.setup"
       }),
+      dryRun: false
+    });
+    format({
+      ...data,
+      legacy_wrapper: legacy,
+      generated_verify_token: generatedVerifyToken && !opts.verifyToken ? generatedVerifyToken : null
+    }, { json: opts.json ?? false });
+  }));
+  addCommonOptions(
+    whatsapp.command("connect").description("[Deprecated wrapper] Use canonical onboarding session flow")
+  ).requiredOption("--phone-number-id <id>", "Meta WhatsApp phone number id").requiredOption("--access-token <token>", "Meta access token").option("--agent-id <id>", "Agent to bind to the WhatsApp channel").option("--verify-token <token>", "Webhook verify token").option("--app-secret <secret>", "Meta app secret for signature verification").option("--business-slug <slug>", "Business identifier for operator-level targeting").option("--audio-enabled <bool>", "Enable inbound WhatsApp audio fallback auto-reply (true/false)", "true").action(async (opts) => withCommandErrorHandling(async () => {
+    const legacy = emitLegacyCommandNotice({
+      command: "connect",
+      canonical: "foh channel whatsapp onboard --access-token <token> --phone-number-id <id>",
+      jsonMode: Boolean(opts.json)
+    });
+    const data = await runWhatsAppOnboardingSession({
       orgId: opts.org,
-      apiUrlOverride: opts.apiUrl
+      apiUrl: opts.apiUrl,
+      accessToken: String(opts.accessToken || "").trim(),
+      wabaId: void 0,
+      phoneNumberId: String(opts.phoneNumberId || "").trim() || void 0,
+      verifyToken: String(opts.verifyToken || "").trim() || void 0,
+      appSecret: String(opts.appSecret || "").trim() || void 0,
+      agentId: opts.agentId,
+      businessSlug: String(opts.businessSlug || "").trim() || void 0,
+      audioEnabled: parseBooleanOption({
+        value: opts.audioEnabled,
+        fallback: true,
+        optionName: "--audio-enabled",
+        step: "channel.whatsapp.connect"
+      }),
+      dryRun: false
     });
-    format(data, { json: opts.json ?? false });
+    format({
+      ...data,
+      legacy_wrapper: legacy
+    }, { json: opts.json ?? false });
   }));
   addCommonOptions(
     whatsapp.command("status").description("Get WhatsApp channel status")
@@ -16057,10 +16119,11 @@ function registerWhatsAppChannelCommands(whatsapp, addCommonOptions) {
       ],
       sender_model: WHATSAPP_SENDER_MODEL,
       commands: {
-        onboarding_start: `foh channel whatsapp start --generate-verify-token${agentIdSegment}${orgSegment}`,
+        onboarding_start: `foh channel whatsapp onboard --wizard${agentIdSegment}${orgSegment}`,
         verification_readiness: `foh provision whatsapp-verification --lookback-minutes 60${orgSegment}`,
         verification_readiness_voice: `foh provision whatsapp-verification --lookback-minutes 60 --otp-method voice${orgSegment}`,
-        connect: `foh channel whatsapp connect${agentIdSegment} --phone-number-id <meta_phone_number_id> --access-token <meta_access_token> --verify-token ${verifyToken} --app-secret <meta_app_secret>${orgSegment}`,
+        onboard: `foh channel whatsapp onboard${agentIdSegment} --access-token <meta_access_token> --verify-token ${verifyToken} --app-secret <meta_app_secret>${orgSegment}`,
+        batch: `foh channel whatsapp batch --manifest ./whatsapp-batch.manifest.json --apply${orgSegment}`,
         verify: `foh channel whatsapp proof --strict --verify-token ${verifyToken}${orgSegment}`,
         live_proof: "corepack pnpm ops:whatsapp:proof:live",
         release_gate: "corepack pnpm ops:channel:proof:gate:strict"
@@ -16375,11 +16438,11 @@ function registerVoice(program3) {
     }
     const outputPath = String(opts.out || `foh-voice-preview-${provider}-${voiceId}.mp3`).trim();
     const audio = Buffer.from(await res.arrayBuffer());
-    const { mkdirSync: mkdirSync9, writeFileSync: writeFileSync14 } = await import("fs");
-    const { dirname: dirname12, resolve: resolve14 } = await import("path");
-    const absolutePath = resolve14(outputPath);
-    mkdirSync9(dirname12(absolutePath), { recursive: true });
-    writeFileSync14(absolutePath, audio);
+    const { mkdirSync: mkdirSync10, writeFileSync: writeFileSync15 } = await import("fs");
+    const { dirname: dirname13, resolve: resolve15 } = await import("path");
+    const absolutePath = resolve15(outputPath);
+    mkdirSync10(dirname13(absolutePath), { recursive: true });
+    writeFileSync15(absolutePath, audio);
     format({
       status: "ok",
       provider,
@@ -30870,7 +30933,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve14) => setTimeout(resolve14, pollInterval));
+        await new Promise((resolve15) => setTimeout(resolve15, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -30887,7 +30950,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve15, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -30965,7 +31028,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve14(parseResult.data);
+            resolve15(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -31226,12 +31289,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve15, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve14, interval);
+      const timeoutId = setTimeout(resolve15, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -32331,7 +32394,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve14) => setTimeout(resolve14, pollInterval));
+      await new Promise((resolve15) => setTimeout(resolve15, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -32980,19 +33043,21 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       const json3 = serializeMessage(message);
       if (this._stdout.write(json3)) {
-        resolve14();
+        resolve15();
       } else {
-        this._stdout.once("drain", resolve14);
+        this._stdout.once("drain", resolve15);
       }
     });
   }
 };
 
 // src/lib/cli-version.ts
-var CLI_VERSION = "0.1.83";
+var injectedVersion = true ? String("0.1.85").trim() : "";
+var envVersion = String(process.env.FOH_CLI_VERSION || process.env.npm_package_version || "").trim();
+var CLI_VERSION = injectedVersion || envVersion || "0.0.0-dev";
 
 // src/commands/mcp-serve.ts
 var DEFAULT_TIMEOUT_MS = 12e4;
@@ -33177,7 +33242,7 @@ async function runFohCli(params) {
     effectiveArgv.push("--json");
   }
   const command = `foh ${effectiveArgv.join(" ")}`;
-  return await new Promise((resolve14) => {
+  return await new Promise((resolve15) => {
     const child = (0, import_node_child_process.spawn)(process.execPath, [cliEntry, ...effectiveArgv], {
       stdio: ["ignore", "pipe", "pipe"],
       env: {
@@ -33202,7 +33267,7 @@ async function runFohCli(params) {
     });
     child.once("error", (error2) => {
       clearTimeout(timeoutHandle);
-      resolve14({
+      resolve15({
         ok: false,
         command,
         argv: effectiveArgv,
@@ -33218,7 +33283,7 @@ async function runFohCli(params) {
       const stderrText = finalizeBoundedText(stderrBuffer);
       const exitCode = Number.isFinite(code ?? NaN) ? Number(code) : 1;
       const stdoutJson = tryParseJson(stdoutText);
-      resolve14({
+      resolve15({
         ok: !timedOut && exitCode === 0,
         command,
         argv: effectiveArgv,
@@ -35388,8 +35453,8 @@ function registerSetup(program3) {
         }
         try {
           const manifest = await agentExport(resolvedAgentId, { apiUrlOverride: opts.apiUrl });
-          const { writeFileSync: writeFileSync14 } = await import("fs");
-          writeFileSync14(
+          const { writeFileSync: writeFileSync15 } = await import("fs");
+          writeFileSync15(
             "tenant.yaml",
             `# tenant.yaml - Front Of House agent manifest
 # Edit this file and run: foh plan tenant.yaml
@@ -35559,8 +35624,8 @@ function registerSim(program3) {
       }
       const cert = response.certificate;
       if (opts.out) {
-        const { writeFileSync: writeFileSync14 } = await import("fs");
-        writeFileSync14(opts.out, JSON.stringify(cert, null, 2) + "\n", "utf-8");
+        const { writeFileSync: writeFileSync15 } = await import("fs");
+        writeFileSync15(opts.out, JSON.stringify(cert, null, 2) + "\n", "utf-8");
         process.stderr.write(`  Certificate written to ${opts.out}
 `);
       }
@@ -35610,8 +35675,8 @@ function registerSim(program3) {
         });
       }
       if (opts.out) {
-        const { writeFileSync: writeFileSync14 } = await import("fs");
-        writeFileSync14(opts.out, JSON.stringify(response.certificate, null, 2) + "\n", "utf-8");
+        const { writeFileSync: writeFileSync15 } = await import("fs");
+        writeFileSync15(opts.out, JSON.stringify(response.certificate, null, 2) + "\n", "utf-8");
         process.stderr.write(`  Final certificate written to ${opts.out}
 `);
       }
@@ -35647,7 +35712,7 @@ ${passIcon}  Certification loop summary
 }
 
 // src/commands/certify.ts
-var import_node_fs2 = require("node:fs");
+var import_node_fs3 = require("node:fs");
 function normalizeProfile(raw) {
   const value = String(raw || "release").trim().toLowerCase();
   if (value === "smoke" || value === "release" || value === "stress") return value;
@@ -35725,7 +35790,7 @@ function registerCertify(program3) {
         next_commands: passed ? [`foh agent publish --agent ${opts.agent} --json`] : [`foh certify run --agent ${opts.agent} --profile ${profile} --json`]
       };
       if (opts.out) {
-        (0, import_node_fs2.writeFileSync)(opts.out, JSON.stringify(result, null, 2) + "\n", "utf-8");
+        (0, import_node_fs3.writeFileSync)(opts.out, JSON.stringify(result, null, 2) + "\n", "utf-8");
       }
       if (opts.json ?? false) {
         format(result, { json: true });
@@ -36675,6 +36740,22 @@ function registerOpsAgencySetupCommands(reporting) {
     });
     format(data, { json: opts.json ?? false });
   }));
+  reporting.command("agency-setup-workflow").description("Run the one-shot any-agency setup workflow: dossier, launch packet, evidence packet, proof commands, and no-overclaim status").requiredOption("--agency-name <name>", "Estate agency trading name").option("--source-url <url>", "Official branch/contact/source URL").option("--branch-location <value>", "Branch/location this setup represents").option("--tools <csv>", "Requested tool surfaces", "widget,voice,email,callback,calendar,crm,webhook,whatsapp").option("--target-mode <value>", "Target exposure mode", "customer_owned_voice_trial").option("--org <id>", "Org ID (default: stored org from foh org use)").option("--api-url <url>", "API base URL override").option("--json", "Output as JSON").action(async (opts) => withCommandErrorHandling(async () => {
+    const body = {
+      agency_name: String(opts.agencyName),
+      requested_tool_surface: parseCsvOption(opts.tools) ?? [],
+      target_exposure_mode: String(opts.targetMode)
+    };
+    if (opts.sourceUrl) body.source_url = String(opts.sourceUrl);
+    if (opts.branchLocation) body.branch_location = String(opts.branchLocation);
+    const data = await apiFetch("/v1/console/agency-setup/workflow", {
+      method: "POST",
+      body: JSON.stringify(body),
+      orgId: opts.org,
+      apiUrlOverride: opts.apiUrl
+    });
+    format(data, { json: opts.json ?? false });
+  }));
 }
 
 // src/commands/ops-diagnostics.ts
@@ -36929,6 +37010,16 @@ function registerOpsReportingCommands(reporting) {
     });
     format(data, { json: opts.json ?? false });
   }));
+  reporting.command("customer-live-status").description("Show one operator-grade customer-live status answer with actions, proof refs, and next commands").option("--environment <value>", "Environment filter").option("--agency-name <name>", "Agency name for setup-preview fallback when no release packet exists").option("--source-url <url>", "Official source URL for setup-preview fallback").option("--branch-location <value>", "Branch/location for setup-preview fallback").option("--tools <csv>", "Requested tool surface for setup-preview fallback").option("--target-mode <mode>", "Target exposure mode for setup-preview fallback").option("--org <id>", "Org ID (default: stored org from foh org use)").option("--api-url <url>", "API base URL override").option("--json", "Output as JSON").action(async (opts) => withCommandErrorHandling(async () => {
+    const params = new URLSearchParams();
+    if (opts.environment) params.set("environment", String(opts.environment));
+    appendSetupPreviewContext(params, opts);
+    const data = await apiFetch(withQuery("/v1/console/customer-live-status", params), {
+      orgId: opts.org,
+      apiUrlOverride: opts.apiUrl
+    });
+    format(data, { json: opts.json ?? false });
+  }));
   reporting.command("release-scorecard").description("Show deterministic release scorecard for an agent").requiredOption("--agent <id>", "Agent ID").option("--limit <n>", "Number of runs to include", "10").option("--api-url <url>", "API base URL override").option("--json", "Output as JSON").action(async (opts) => withCommandErrorHandling(async () => {
     const limit = Math.max(1, Math.min(100, Number(opts.limit || 10) || 10));
     const data = await apiFetch(`/v1/console/agents/${opts.agent}/release-scorecard?limit=${limit}`, {
@@ -37560,41 +37651,80 @@ function defaultImprovementArtifactPath() {
 }
 async function resolveBugReportWizardInputs(opts) {
   if (!opts.wizard) return opts;
-  ensureInteractive("bug.report", "Run with --out and --command in non-interactive mode, or use --wizard in a TTY.");
-  process.stdout.write("\nBug Report Wizard\n");
-  process.stdout.write("-----------------\n");
-  const resolved = { ...opts };
-  if (!String(resolved.out ?? "").trim()) {
-    resolved.out = await promptLine("Output file path", { defaultValue: defaultArtifactPath() });
-  }
-  if (!String(resolved.command ?? "").trim()) {
-    resolved.command = await promptLine("Failing command");
-  }
-  if (!String(resolved.requestMethod ?? "").trim()) {
-    resolved.requestMethod = await promptLine("Request method", { defaultValue: "GET" });
-  }
-  const hasRequestLocation = String(resolved.requestUrl ?? "").trim() || String(resolved.requestPath ?? "").trim();
-  if (!hasRequestLocation) {
-    const requestLocation = await promptLine("Request URL or path (for example /v1/console/agents)");
-    if (requestLocation.startsWith("http://") || requestLocation.startsWith("https://")) {
-      resolved.requestUrl = requestLocation;
-    } else {
-      resolved.requestPath = requestLocation;
-    }
-  }
-  if (!String(resolved.responseStatus ?? "").trim()) {
-    resolved.responseStatus = await promptLine("Response status", { defaultValue: "500" });
-  }
-  if (!String(resolved.severity ?? "").trim()) {
-    resolved.severity = await promptLine("Severity", { defaultValue: "medium" });
-  }
-  if (!String(resolved.source ?? "").trim()) {
-    resolved.source = await promptLine("Source", { defaultValue: "cli" });
-  }
-  if (resolved.submit === void 0) {
-    const submitAnswer = await promptLine("Submit packet to FOH API now? [y/N]", { allowEmpty: true });
-    resolved.submit = isAffirmative(submitAnswer, false);
-  }
+  const resolved = await runWizardSession({
+    step: "bug.report",
+    remediation: "Run with --out and --command in non-interactive mode, or use --wizard in a TTY.",
+    title: "Bug Report Wizard",
+    initialState: { ...opts },
+    enabled: true,
+    prompts: [
+      {
+        key: "out",
+        label: "Output file path",
+        defaultValue: () => defaultArtifactPath(),
+        required: true,
+        shouldPrompt: (state) => !String(state.out ?? "").trim()
+      },
+      {
+        key: "command",
+        label: "Failing command",
+        required: true,
+        shouldPrompt: (state) => !String(state.command ?? "").trim()
+      },
+      {
+        key: "requestMethod",
+        label: "Request method",
+        defaultValue: "GET",
+        required: true,
+        shouldPrompt: (state) => !String(state.requestMethod ?? "").trim()
+      },
+      {
+        key: "requestLocation",
+        label: "Request URL or path (for example /v1/console/agents)",
+        required: true,
+        shouldPrompt: (state) => !String(state.requestUrl ?? "").trim() && !String(state.requestPath ?? "").trim(),
+        onResolved: (value, state) => {
+          const location = String(value ?? "").trim();
+          if (location.startsWith("http://") || location.startsWith("https://")) {
+            state.requestUrl = location;
+            state.requestPath = "";
+          } else {
+            state.requestPath = location;
+            state.requestUrl = "";
+          }
+        }
+      },
+      {
+        key: "responseStatus",
+        label: "Response status",
+        defaultValue: "500",
+        required: true,
+        shouldPrompt: (state) => !String(state.responseStatus ?? "").trim()
+      },
+      {
+        key: "severity",
+        label: "Severity",
+        defaultValue: "medium",
+        required: true,
+        shouldPrompt: (state) => !String(state.severity ?? "").trim()
+      },
+      {
+        key: "source",
+        label: "Source",
+        defaultValue: "cli",
+        required: true,
+        shouldPrompt: (state) => !String(state.source ?? "").trim()
+      },
+      {
+        key: "submit",
+        label: "Submit packet to FOH API now? [y/N]",
+        kind: "confirm",
+        confirmDefault: false,
+        shouldPrompt: (state) => state.submit === void 0
+      }
+    ]
+  });
+  delete resolved.requestLocation;
   return resolved;
 }
 function ensureBugReportRequiredInputs(opts) {
@@ -37790,7 +37920,7 @@ function registerBug(program3) {
 
 // src/lib/proof-cache.ts
 var import_node_crypto2 = require("node:crypto");
-var import_node_fs3 = require("node:fs");
+var import_node_fs4 = require("node:fs");
 var import_node_path = require("node:path");
 var DEFAULT_MAX_AGE_MS = 15 * 60 * 1e3;
 var DEFAULT_WAIT_MS = 180 * 1e3;
@@ -37814,7 +37944,7 @@ function publicPath(filePath) {
 }
 function readFreshCache(filePath, maxAgeMs) {
   try {
-    const payload = JSON.parse((0, import_node_fs3.readFileSync)(filePath, "utf8"));
+    const payload = JSON.parse((0, import_node_fs4.readFileSync)(filePath, "utf8"));
     const createdAt = Date.parse(String(payload.created_at || ""));
     if (!Number.isFinite(createdAt)) return null;
     const ageMs = Date.now() - createdAt;
@@ -37826,8 +37956,8 @@ function readFreshCache(filePath, maxAgeMs) {
   }
 }
 function writeCache(filePath, value) {
-  (0, import_node_fs3.mkdirSync)((0, import_node_path.dirname)(filePath), { recursive: true });
-  (0, import_node_fs3.writeFileSync)(filePath, `${JSON.stringify({
+  (0, import_node_fs4.mkdirSync)((0, import_node_path.dirname)(filePath), { recursive: true });
+  (0, import_node_fs4.writeFileSync)(filePath, `${JSON.stringify({
     schema_version: "foh_proof_cache_entry.v1",
     created_at: (/* @__PURE__ */ new Date()).toISOString(),
     value
@@ -37862,7 +37992,7 @@ async function withProofCache(options, run) {
   const maxAgeMs = options.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
   const waitMs = options.waitMs ?? Number(process.env.FOH_PROOF_CACHE_WAIT_MS || DEFAULT_WAIT_MS);
   const pollMs = options.pollMs ?? DEFAULT_POLL_MS;
-  (0, import_node_fs3.mkdirSync)(resolvedDir, { recursive: true });
+  (0, import_node_fs4.mkdirSync)(resolvedDir, { recursive: true });
   const existing = readFreshCache(cachePath, maxAgeMs);
   if (existing) {
     return {
@@ -37881,7 +38011,7 @@ async function withProofCache(options, run) {
   }
   let lockOwner = false;
   try {
-    (0, import_node_fs3.mkdirSync)(lockPath);
+    (0, import_node_fs4.mkdirSync)(lockPath);
     lockOwner = true;
   } catch {
     const started = Date.now();
@@ -37922,7 +38052,7 @@ async function withProofCache(options, run) {
       }
     };
   } finally {
-    if (lockOwner) (0, import_node_fs3.rmSync)(lockPath, { recursive: true, force: true });
+    if (lockOwner) (0, import_node_fs4.rmSync)(lockPath, { recursive: true, force: true });
   }
 }
 
@@ -38412,7 +38542,582 @@ function registerProve(program3) {
   }));
 }
 
-// src/tui/command-palette.ts
+// src/commands/interactive.ts
+var import_readline2 = require("readline");
+var import_child_process2 = require("child_process");
+var import_fs11 = require("fs");
+var import_os2 = require("os");
+var import_path9 = require("path");
+
+// src/commands/command-graph.ts
+var COMMAND_SURFACE_DEFINITIONS = [
+  {
+    id: "home",
+    commandPath: ["home"],
+    label: "home",
+    descriptionFallback: "Open onboarding home",
+    mutatesState: "read",
+    shellSlash: "/home",
+    includeInSuggestions: false,
+    homeContexts: []
+  },
+  {
+    id: "start",
+    commandPath: ["home"],
+    invokeArgs: ["start"],
+    label: "start",
+    descriptionFallback: "Run guided onboarding start",
+    mutatesState: "read",
+    shellSlash: "/start",
+    includeInSuggestions: false,
+    homeContexts: []
+  },
+  {
+    id: "auth_login",
+    commandPath: ["auth", "login"],
+    label: "login now (recommended)",
+    descriptionFallback: "Run interactive login flow.",
+    mutatesState: "write",
+    examples: ["foh auth login --wizard"],
+    homeContexts: ["unauthenticated"],
+    homeAliases: ["start", "login", "auth", "auth login"],
+    includeInSuggestions: true
+  },
+  {
+    id: "auth_login_help",
+    commandPath: ["auth", "login"],
+    invokeArgs: ["auth", "login", "--help"],
+    label: "auth login help",
+    descriptionFallback: "Show auth login examples.",
+    mutatesState: "read",
+    homeContexts: ["unauthenticated"],
+    includeInSuggestions: true
+  },
+  {
+    id: "auth_login_wizard",
+    commandPath: ["auth", "login"],
+    invokeArgs: ["auth", "login", "--wizard"],
+    label: "auth login wizard",
+    descriptionFallback: "Run login wizard",
+    mutatesState: "write",
+    shellSlash: "/login",
+    includeInSuggestions: true
+  },
+  {
+    id: "auth_whoami",
+    commandPath: ["auth", "whoami"],
+    label: "auth whoami",
+    descriptionFallback: "Show current auth context",
+    requiresAuth: true,
+    mutatesState: "read",
+    homeContexts: ["authenticated_no_org"],
+    homeAliases: ["whoami"],
+    shellSlash: "/auth",
+    includeInSuggestions: true
+  },
+  {
+    id: "org_list",
+    commandPath: ["org", "list"],
+    label: "list my orgs",
+    descriptionFallback: "View org memberships.",
+    requiresAuth: true,
+    mutatesState: "read",
+    homeContexts: ["authenticated_no_org"],
+    homeAliases: ["org"],
+    shellSlash: "/orgs",
+    includeInSuggestions: true
+  },
+  {
+    id: "org_use_help",
+    commandPath: ["org", "use"],
+    invokeArgs: ["org", "use", "--help"],
+    label: "org use help",
+    descriptionFallback: "Set default org guidance.",
+    requiresAuth: true,
+    mutatesState: "read",
+    homeContexts: ["authenticated_no_org"],
+    includeInSuggestions: true
+  },
+  {
+    id: "tenant_status",
+    commandPath: ["tenant", "status"],
+    label: "tenant status",
+    descriptionFallback: "Check tenant status and readiness.",
+    requiresAuth: true,
+    requiresOrg: true,
+    mutatesState: "read",
+    homeContexts: ["authenticated_with_org"],
+    homeAliases: ["tenant"],
+    shellSlash: "/status",
+    includeInSuggestions: true
+  },
+  {
+    id: "templates_list",
+    commandPath: ["templates", "list"],
+    label: "template list",
+    descriptionFallback: "List templates.",
+    requiresAuth: true,
+    requiresOrg: true,
+    mutatesState: "read",
+    homeContexts: ["authenticated_with_org"],
+    homeAliases: ["templates", "template list"],
+    shellSlash: "/templates",
+    includeInSuggestions: true
+  },
+  {
+    id: "agent_list_all",
+    commandPath: ["agent", "list"],
+    invokeArgs: ["agent", "list", "--segment", "all"],
+    label: "agent list",
+    descriptionFallback: "List all agents.",
+    requiresAuth: true,
+    requiresOrg: true,
+    mutatesState: "read",
+    homeContexts: ["authenticated_with_org"],
+    homeAliases: ["agent"],
+    shellSlash: "/agent",
+    includeInSuggestions: true
+  },
+  {
+    id: "setup_help",
+    commandPath: ["setup"],
+    invokeArgs: ["setup", "--help"],
+    label: "setup help",
+    descriptionFallback: "Show setup flow options.",
+    mutatesState: "read",
+    homeContexts: ["authenticated_with_org"],
+    homeAliases: ["setup"],
+    shellSlash: "/setup",
+    includeInSuggestions: true
+  },
+  {
+    id: "bug_report_help",
+    commandPath: ["bug", "report"],
+    invokeArgs: ["bug", "report", "--help"],
+    label: "bug report help",
+    descriptionFallback: "Show bug-report guidance.",
+    mutatesState: "read",
+    homeContexts: ["authenticated_with_org"],
+    homeAliases: ["bug report", "bug report help"],
+    includeInSuggestions: false
+  },
+  {
+    id: "bug_list",
+    commandPath: ["bug", "list"],
+    label: "bug list",
+    descriptionFallback: "List centralized bug reports.",
+    requiresAuth: true,
+    requiresOrg: true,
+    mutatesState: "read",
+    homeContexts: ["authenticated_with_org"],
+    homeAliases: ["bug list"],
+    includeInSuggestions: false
+  },
+  {
+    id: "interactive_shell",
+    commandPath: ["interactive"],
+    label: "interactive shell",
+    descriptionFallback: "Open slash-command shell.",
+    mutatesState: "read",
+    homeContexts: ["unauthenticated", "authenticated_no_org", "authenticated_with_org"],
+    homeAliases: ["interactive", "interactive shell", "shell"],
+    includeInSuggestions: false
+  },
+  {
+    id: "full_help",
+    commandPath: ["home"],
+    invokeArgs: ["--help"],
+    label: "full help",
+    descriptionFallback: "Show all CLI commands.",
+    mutatesState: "read",
+    homeContexts: ["unauthenticated", "authenticated_no_org"],
+    homeAliases: ["full help"],
+    includeInSuggestions: false
+  },
+  {
+    id: "whatsapp_start",
+    commandPath: ["channel", "whatsapp", "start"],
+    label: "whatsapp start",
+    descriptionFallback: "WhatsApp readiness path",
+    mutatesState: "write",
+    shellSlash: "/whatsapp",
+    includeInSuggestions: true
+  },
+  {
+    id: "voice_help",
+    commandPath: ["voice"],
+    invokeArgs: ["voice", "--help"],
+    label: "voice help",
+    descriptionFallback: "Voice command help",
+    mutatesState: "read",
+    shellSlash: "/voice",
+    includeInSuggestions: true
+  },
+  {
+    id: "widget_help",
+    commandPath: ["widget"],
+    invokeArgs: ["widget", "--help"],
+    label: "widget help",
+    descriptionFallback: "Widget command help",
+    mutatesState: "read",
+    shellSlash: "/widget",
+    includeInSuggestions: true
+  },
+  {
+    id: "diag_debug",
+    commandPath: ["diag"],
+    invokeArgs: ["debug"],
+    label: "debug",
+    descriptionFallback: "Run diagnostics",
+    mutatesState: "read",
+    shellSlash: "/debug",
+    includeInSuggestions: true
+  }
+];
+var SHELL_BUILTIN_COMMANDS = [
+  { slash: "/help", description: "Show shell help" },
+  { slash: "/?", description: "Show keymap help" },
+  { slash: "/keys", description: "Show keymap help" },
+  { slash: "/commands", description: "List available slash commands" },
+  { slash: "/again", description: "Replay last successful command" },
+  { slash: "/retry", description: "Replay last failed command" },
+  { slash: "/editlast", description: "Prefill last command for editing" },
+  { slash: "/snippet", description: "Manage named command snippets" },
+  { slash: "/clear", description: "Clear the terminal output" },
+  { slash: "/exit", description: "Exit shell" },
+  { slash: "/quit", description: "Exit shell" }
+];
+var HOME_QUICK_ACTION_ORDER = {
+  unauthenticated: ["auth_login", "interactive_shell", "full_help", "auth_login_help"],
+  authenticated_no_org: ["org_list", "interactive_shell", "org_use_help", "auth_whoami", "full_help"],
+  authenticated_with_org: [
+    "tenant_status",
+    "interactive_shell",
+    "templates_list",
+    "agent_list_all",
+    "setup_help",
+    "bug_report_help",
+    "bug_list"
+  ]
+};
+var commandPathIndex = /* @__PURE__ */ new Map();
+function contextFromState(state) {
+  if (!state.authenticated) return "unauthenticated";
+  if (!state.orgId) return "authenticated_no_org";
+  return "authenticated_with_org";
+}
+function commandKey(parts) {
+  return parts.join(" ");
+}
+function normalizeCommandToken(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+function readCommandDescription(command) {
+  try {
+    return (command.description() ?? "").trim();
+  } catch {
+    return "";
+  }
+}
+function collectCommandPaths(program3) {
+  const paths = /* @__PURE__ */ new Map();
+  const walk = (parentPath, scope) => {
+    for (const child of scope.commands) {
+      const childName = normalizeCommandToken(child.name());
+      if (!childName) continue;
+      const nextPath = [...parentPath, childName];
+      const canonicalPathKey = commandKey(nextPath);
+      const description = readCommandDescription(child);
+      paths.set(canonicalPathKey, { pathKey: canonicalPathKey, description });
+      const aliases = child.aliases().map((alias) => normalizeCommandToken(alias)).filter(Boolean);
+      for (const alias of aliases) {
+        const aliasPath = [...parentPath, alias];
+        paths.set(commandKey(aliasPath), { pathKey: canonicalPathKey, description });
+      }
+      walk(nextPath, child);
+    }
+  };
+  walk([], program3);
+  return paths;
+}
+function resolveDescription(definition) {
+  const record2 = commandPathIndex.get(commandKey(definition.commandPath));
+  if (record2 && record2.description) return record2.description;
+  return definition.descriptionFallback;
+}
+function buildEntry(definition) {
+  return {
+    id: definition.id,
+    label: definition.label,
+    description: resolveDescription(definition),
+    args: [...definition.invokeArgs ?? definition.commandPath],
+    commandPath: [...definition.commandPath],
+    requiresAuth: definition.requiresAuth === true,
+    requiresOrg: definition.requiresOrg === true,
+    mutatesState: definition.mutatesState,
+    examples: [...definition.examples ?? []],
+    homeContexts: [...definition.homeContexts ?? []],
+    homeAliases: [...definition.homeAliases ?? []],
+    shellSlash: definition.shellSlash,
+    includeInSuggestions: definition.includeInSuggestions !== false
+  };
+}
+function initializeCommandGraph(program3) {
+  commandPathIndex = collectCommandPaths(program3);
+  const missing = COMMAND_SURFACE_DEFINITIONS.filter((definition) => !commandPathIndex.has(commandKey(definition.commandPath))).map((definition) => definition.id);
+  if (missing.length > 0) {
+    throw new Error(`command_graph_definition_missing_paths:${missing.join(",")}`);
+  }
+}
+function getCommandGraphEntries() {
+  return COMMAND_SURFACE_DEFINITIONS.map(buildEntry);
+}
+function getHomeQuickActions(state) {
+  const context = contextFromState(state);
+  const rank = new Map(HOME_QUICK_ACTION_ORDER[context].map((id, index) => [id, index]));
+  return getCommandGraphEntries().filter((entry) => entry.homeContexts.includes(context)).sort((left, right) => {
+    const leftRank = rank.get(left.id) ?? Number.MAX_SAFE_INTEGER;
+    const rightRank = rank.get(right.id) ?? Number.MAX_SAFE_INTEGER;
+    if (leftRank !== rightRank) return leftRank - rightRank;
+    return left.label.localeCompare(right.label);
+  }).map((entry) => ({
+    label: entry.label,
+    description: entry.description,
+    args: [...entry.args],
+    aliases: [...entry.homeAliases]
+  }));
+}
+function getHomePaletteCommands(state) {
+  return getCommandGraphEntries().filter((entry) => {
+    if (entry.requiresAuth && !state.authenticated) return false;
+    if (entry.requiresOrg && (!state.authenticated || !state.orgId)) return false;
+    if (entry.homeContexts.length > 0) return true;
+    return Boolean(entry.shellSlash || entry.includeInSuggestions);
+  }).map((entry) => ({
+    label: entry.args.join(" "),
+    description: entry.description,
+    args: [...entry.args],
+    requiresAuth: entry.requiresAuth || void 0,
+    requiresOrg: entry.requiresOrg || void 0,
+    mutatesState: entry.mutatesState,
+    examples: [...entry.examples]
+  }));
+}
+function getInteractiveSlashCommands() {
+  const generated = getCommandGraphEntries().filter((entry) => typeof entry.shellSlash === "string").map((entry) => ({
+    slash: entry.shellSlash,
+    description: entry.description,
+    args: [...entry.args]
+  })).sort((left, right) => left.slash.localeCompare(right.slash));
+  return [...SHELL_BUILTIN_COMMANDS, ...generated];
+}
+function getInteractiveCommandSuggestions() {
+  return getCommandGraphEntries().filter((entry) => entry.includeInSuggestions).map((entry) => entry.args.join(" ")).filter((value, index, values) => values.indexOf(value) === index);
+}
+function normalizeArgs(args) {
+  return args.map((token) => normalizeCommandToken(token)).filter(Boolean);
+}
+function startsWithTokens(input, expected) {
+  if (expected.length === 0 || input.length < expected.length) return false;
+  for (let index = 0; index < expected.length; index += 1) {
+    if (input[index] !== expected[index]) return false;
+  }
+  return true;
+}
+function getCommandGraphEntryForArgs(args) {
+  const normalizedArgs = normalizeArgs(args);
+  if (normalizedArgs.length === 0) return void 0;
+  const entries = getCommandGraphEntries().map((entry) => ({
+    entry,
+    normalizedEntryArgs: normalizeArgs(entry.args),
+    normalizedCommandPath: normalizeArgs(entry.commandPath),
+    entryArgsMatch: 0,
+    commandPathMatch: 0
+  })).map((candidate) => ({
+    ...candidate,
+    entryArgsMatch: startsWithTokens(normalizedArgs, candidate.normalizedEntryArgs) ? candidate.normalizedEntryArgs.length : 0,
+    commandPathMatch: startsWithTokens(normalizedArgs, candidate.normalizedCommandPath) ? candidate.normalizedCommandPath.length : 0
+  })).filter(({ entryArgsMatch, commandPathMatch }) => entryArgsMatch > 0 || commandPathMatch > 0).sort((left, right) => {
+    if (left.entryArgsMatch !== right.entryArgsMatch) return right.entryArgsMatch - left.entryArgsMatch;
+    if (left.commandPathMatch !== right.commandPathMatch) return right.commandPathMatch - left.commandPathMatch;
+    return left.entry.id.localeCompare(right.entry.id);
+  });
+  return entries[0]?.entry;
+}
+function classifyCommandMutation(args) {
+  return getCommandGraphEntryForArgs(args)?.mutatesState ?? "read";
+}
+
+// src/commands/interactive.ts
+var SLASH_COMMANDS = getInteractiveSlashCommands();
+var COMMAND_SUGGESTIONS = getInteractiveCommandSuggestions();
+function nowIso2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function interactiveSessionArtifactPath() {
+  const override = String(process.env.FOH_CLI_INTERACTIVE_SESSION_OUT ?? "").trim();
+  if (override.length > 0) return (0, import_path9.resolve)(override);
+  return (0, import_path9.resolve)("test-results/interactive-shell-session.latest.json");
+}
+function createInteractiveSessionArtifact() {
+  const seed = `${Date.now().toString(16)}${Math.random().toString(16).slice(2, 10)}`;
+  return {
+    schema_version: "foh_cli_interactive_session.v1",
+    session_id: `shell_${seed}`,
+    started_at: nowIso2(),
+    status: "idle",
+    command_count: 0,
+    failure_count: 0,
+    events: []
+  };
+}
+function detectTerminalCapabilities() {
+  const stdinTty = Boolean(process.stdin.isTTY);
+  const stdoutTty = Boolean(process.stdout.isTTY);
+  const supportsRawMode = stdinTty && typeof process.stdin.setRawMode === "function";
+  const term = String(process.env.TERM ?? "").trim().toLowerCase();
+  const supportsAnsiClear = stdoutTty && term !== "dumb";
+  return {
+    stdinTty,
+    stdoutTty,
+    supportsRawMode,
+    supportsLinePrefill: supportsRawMode,
+    supportsAnsiClear
+  };
+}
+function recordInteractiveShellEvent(artifact, event) {
+  artifact.events.push({
+    at: nowIso2(),
+    ...event
+  });
+  if (event.type === "command_started") {
+    artifact.status = "running";
+    artifact.command_count += 1;
+    artifact.last_command = event.command;
+  } else if (event.type === "command_succeeded") {
+    artifact.status = "idle";
+    artifact.last_command = event.command;
+  } else if (event.type === "command_failed" || event.type === "shell_error") {
+    artifact.status = "failed";
+    artifact.failure_count += 1;
+    artifact.last_error = event.reason;
+    artifact.last_command = event.command;
+  } else if (event.type === "command_blocked") {
+    artifact.status = "idle";
+    artifact.last_error = event.reason;
+    artifact.last_command = event.command;
+  } else if (event.type === "shell_closed") {
+    artifact.status = artifact.status === "failed" ? "failed" : "closed";
+    artifact.completed_at = nowIso2();
+  }
+}
+function flushInteractiveSessionArtifact(artifact) {
+  const outputPath = interactiveSessionArtifactPath();
+  (0, import_fs11.mkdirSync)((0, import_path9.dirname)(outputPath), { recursive: true });
+  (0, import_fs11.writeFileSync)(outputPath, JSON.stringify(artifact, null, 2), "utf8");
+}
+function interactiveMemoryPath() {
+  const override = String(process.env.FOH_CLI_INTERACTIVE_MEMORY_OUT ?? "").trim();
+  if (override.length > 0) return (0, import_path9.resolve)(override);
+  return (0, import_path9.resolve)((0, import_os2.homedir)(), ".foh", "interactive-shell-memory.json");
+}
+function loadInteractiveShellMemory() {
+  const outputPath = interactiveMemoryPath();
+  if (!(0, import_fs11.existsSync)(outputPath)) {
+    return {
+      schema_version: "foh_cli_interactive_memory.v1",
+      updated_at: nowIso2(),
+      history: [],
+      snippets: {}
+    };
+  }
+  try {
+    const raw = JSON.parse((0, import_fs11.readFileSync)(outputPath, "utf8"));
+    return {
+      schema_version: "foh_cli_interactive_memory.v1",
+      updated_at: String(raw.updated_at ?? nowIso2()),
+      history: Array.isArray(raw.history) ? raw.history.map((entry) => String(entry)).filter(Boolean) : [],
+      snippets: raw && typeof raw.snippets === "object" && raw.snippets !== null ? Object.fromEntries(
+        Object.entries(raw.snippets).map(([key, value]) => [String(key), String(value)])
+      ) : {}
+    };
+  } catch {
+    return {
+      schema_version: "foh_cli_interactive_memory.v1",
+      updated_at: nowIso2(),
+      history: [],
+      snippets: {}
+    };
+  }
+}
+function saveInteractiveShellMemory(memory) {
+  const outputPath = interactiveMemoryPath();
+  (0, import_fs11.mkdirSync)((0, import_path9.dirname)(outputPath), { recursive: true });
+  (0, import_fs11.writeFileSync)(outputPath, JSON.stringify({ ...memory, updated_at: nowIso2() }, null, 2), "utf8");
+}
+function interactiveSessionReportPath() {
+  const override = String(process.env.FOH_CLI_INTERACTIVE_SESSION_REPORT_OUT ?? "").trim();
+  if (override.length > 0) return (0, import_path9.resolve)(override);
+  return (0, import_path9.resolve)("test-results/interactive-cli-session-report.latest.json");
+}
+function median(values) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 1) return sorted[middle];
+  return Math.round((sorted[middle - 1] + sorted[middle]) / 2);
+}
+function buildInteractiveSessionReport(artifact) {
+  const commandStarts = [];
+  const successDurations = [];
+  const errorFamilies = {};
+  let completedCommands = 0;
+  let deadEndCount = 0;
+  for (const event of artifact.events) {
+    if (event.type === "command_started") {
+      commandStarts.push(Date.parse(event.at));
+      continue;
+    }
+    if (event.type === "command_succeeded") {
+      completedCommands += 1;
+      const startedAt = commandStarts.shift();
+      if (startedAt !== void 0 && Number.isFinite(startedAt)) {
+        const duration3 = Math.max(0, Date.parse(event.at) - startedAt);
+        successDurations.push(duration3);
+      }
+      continue;
+    }
+    if (event.type === "command_failed" || event.type === "command_blocked" || event.type === "shell_error") {
+      deadEndCount += 1;
+      const key = String(event.reason ?? event.type).trim() || event.type;
+      errorFamilies[key] = (errorFamilies[key] ?? 0) + 1;
+      if (event.type === "command_failed") {
+        commandStarts.shift();
+      }
+    }
+  }
+  const totalCommands = Math.max(artifact.command_count, 0);
+  const completionRate = totalCommands > 0 ? Number((completedCommands / totalCommands).toFixed(4)) : 0;
+  const topRemediationLoops = Object.entries(errorFamilies).sort((left, right) => right[1] - left[1]).slice(0, 5).map(([reason, count]) => ({ reason, count }));
+  return {
+    schema_version: "interactive_cli_session_report.v1",
+    generated_at: nowIso2(),
+    session_id: artifact.session_id,
+    command_count: totalCommands,
+    completion_rate: completionRate,
+    dead_end_count: deadEndCount,
+    command_error_families: errorFamilies,
+    median_time_to_success_ms: median(successDurations),
+    top_remediation_loops: topRemediationLoops,
+    terminal_capabilities: artifact.terminal_capabilities
+  };
+}
+function flushInteractiveSessionReport(artifact) {
+  const outputPath = interactiveSessionReportPath();
+  const report = buildInteractiveSessionReport(artifact);
+  (0, import_fs11.mkdirSync)((0, import_path9.dirname)(outputPath), { recursive: true });
+  (0, import_fs11.writeFileSync)(outputPath, JSON.stringify(report, null, 2), "utf8");
+}
 function tokenizeInput(value) {
   const tokens = [];
   const matcher = /"([^"]*)"|'([^']*)'|(\S+)/g;
@@ -38423,193 +39128,391 @@ function tokenizeInput(value) {
   }
   return tokens;
 }
-function normalizeTypedCommandInput(raw) {
-  const normalized = String(raw ?? "").trim();
-  if (!normalized) return [];
-  const withoutLeadingSlash = normalized.startsWith("/") ? normalized.slice(1) : normalized;
-  const tokens = tokenizeInput(withoutLeadingSlash);
-  if (tokens.length > 0 && tokens[0].toLowerCase() === "foh") {
-    tokens.shift();
+async function runSelf(args, apiUrlOverride) {
+  const spawnArgs = [...args];
+  if (apiUrlOverride && !spawnArgs.includes("--api-url")) {
+    spawnArgs.push("--api-url", apiUrlOverride);
   }
-  return tokens;
-}
-function filterPaletteCommands(commands, query) {
-  const normalized = String(query ?? "").trim().toLowerCase();
-  if (!normalized) return commands;
-  return commands.filter((entry) => {
-    const commandText = `foh ${entry.args.join(" ")}`.toLowerCase();
-    return entry.label.toLowerCase().includes(normalized) || commandText.includes(normalized);
+  return await new Promise((resolve15, reject) => {
+    const child = (0, import_child_process2.spawn)(process.execPath, [process.argv[1], ...spawnArgs], {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        FOH_CLI_NO_HOME: "1",
+        FOH_CLI_SUPPRESS_BANNER: "1"
+      }
+    });
+    child.once("error", reject);
+    child.once("close", (code) => resolve15(typeof code === "number" ? code : 1));
   });
 }
-function shouldStartPaletteFromHome(char) {
-  if (typeof char !== "string" || char.length !== 1) return false;
-  if (/\s/.test(char)) return false;
-  if (char === "/") return false;
-  return /^[0-9A-Za-z._:-]$/.test(char);
-}
-
-// src/commands/home-render.ts
-var SLASH_PALETTE_COMMANDS = [
-  { label: "auth login", description: "Authenticate the CLI session", args: ["auth", "login"] },
-  { label: "auth whoami", description: "Show current auth and org context", args: ["auth", "whoami"], requiresAuth: true },
-  { label: "org list", description: "List org memberships", args: ["org", "list"], requiresAuth: true },
-  { label: "org use --help", description: "See how to set default org", args: ["org", "use", "--help"], requiresAuth: true },
-  { label: "tenant status", description: "Check tenant readiness", args: ["tenant", "status"], requiresAuth: true, requiresOrg: true },
-  { label: "templates list", description: "List available templates", args: ["templates", "list"], requiresAuth: true, requiresOrg: true },
-  { label: "agent list --segment all", description: "List agents", args: ["agent", "list", "--segment", "all"], requiresAuth: true, requiresOrg: true },
-  { label: "tests run-all --help", description: "See test workflow command usage", args: ["tests", "run-all", "--help"], requiresAuth: true, requiresOrg: true },
-  { label: "sim certify --help", description: "See simulation certification options", args: ["sim", "certify", "--help"], requiresAuth: true, requiresOrg: true },
-  { label: "setup --help", description: "Show setup command help", args: ["setup", "--help"] },
-  { label: "bug report --help", description: "Show bug report capture help", args: ["bug", "report", "--help"] },
-  { label: "bug list", description: "List submitted bug reports", args: ["bug", "list"], requiresAuth: true, requiresOrg: true },
-  { label: "--help", description: "Show full CLI help", args: ["--help"] }
-];
-function getQuickActions(state) {
-  if (!state.authenticated) {
-    return [
-      { label: "login now (recommended)", description: "Run interactive login flow.", args: ["auth", "login"] },
-      { label: "full help", description: "Show all CLI commands.", args: ["--help"] },
-      { label: "auth login help", description: "Show auth login examples.", args: ["auth", "login", "--help"] }
-    ];
-  }
-  if (!state.orgId) {
-    return [
-      { label: "list my orgs", description: "View org memberships.", args: ["org", "list"] },
-      { label: "org use help", description: "Set default org guidance.", args: ["org", "use", "--help"] },
-      { label: "auth whoami", description: "Inspect current auth context.", args: ["auth", "whoami"] },
-      { label: "full help", description: "Show all CLI commands.", args: ["--help"] }
-    ];
+function resolveInteractiveState(apiUrlOverride) {
+  try {
+    const creds = loadCredentials(apiUrlOverride);
+    return {
+      authenticated: true,
+      orgId: creds.orgId
+    };
+  } catch {
+    return { authenticated: false };
   }
+}
+function nextRecommendedCommand(state) {
+  const next = getHomeQuickActions(state)[0];
+  if (!next) return "foh --help";
+  return `foh ${next.args.join(" ")}`;
+}
+function keymapHelpText() {
   return [
-    { label: "tenant status", description: "Check tenant status and readiness.", args: ["tenant", "status"] },
-    { label: "template list", description: "List templates.", args: ["templates", "list"] },
-    { label: "agent list", description: "List all agents.", args: ["agent", "list", "--segment", "all"] },
-    { label: "setup help", description: "Show setup flow options.", args: ["setup", "--help"] },
-    { label: "bug report help", description: "Show bug-report guidance.", args: ["bug", "report", "--help"] },
-    { label: "bug list", description: "List centralized bug reports.", args: ["bug", "list"] }
-  ];
+    "",
+    "Shell Keymap",
+    "-----------",
+    "  Up / Down      Recall command history",
+    "  Tab            Complete ranked slash/command suggestions",
+    "  Enter          Run current input",
+    "  Esc            Cancel palette-style slash entry",
+    "  Ctrl+C         Exit shell safely",
+    "",
+    "Fallback: if your terminal does not forward these keys, run equivalent slash commands (/help, /commands, /exit).",
+    ""
+  ].join("\n");
 }
-function getPaletteCommands(state) {
-  return SLASH_PALETTE_COMMANDS.filter((entry) => {
-    if (entry.requiresAuth && !state.authenticated) return false;
-    if (entry.requiresOrg && (!state.authenticated || !state.orgId)) return false;
-    return true;
-  });
+function shellHelpText(state) {
+  const slashLines = SLASH_COMMANDS.map((entry) => `  ${entry.slash.padEnd(12)} ${entry.description}`);
+  return [
+    "",
+    "FOH Interactive Shell",
+    "---------------------",
+    "Use slash commands or type any normal `foh` command without the `foh` prefix.",
+    "Keys: Up/Down history, Tab completion, Ctrl+C or /exit to leave. Run /keys for full mapping.",
+    "",
+    "Slash commands:",
+    ...slashLines,
+    "",
+    `Recommended next command: ${nextRecommendedCommand(state)}`,
+    ""
+  ].join("\n");
 }
-function filterHomePaletteCommands(state, query) {
-  return filterPaletteCommands(getPaletteCommands(state), query);
+function printPrompt(rl) {
+  rl.setPrompt("foh> ");
+  rl.prompt();
 }
-function renderInteractiveHomeScreen({
-  state,
-  actions,
-  selectedActionIndex,
-  paletteOpen,
-  paletteQuery,
-  paletteSuggestions,
-  selectedPaletteIndex,
-  notice,
-  isBusy
-}) {
-  process.stdout.write("\x1B[2J\x1B[H");
-  process.stdout.write("Front Of House CLI Home\n");
-  process.stdout.write("=======================\n\n");
-  if (!state.authenticated) {
-    process.stdout.write("Status: Not authenticated\n");
-  } else {
-    process.stdout.write("Status: Authenticated\n");
-    process.stdout.write(`API: ${state.apiUrl}
-`);
-    process.stdout.write(`Default org: ${state.orgId ?? "(not set)"}
-`);
+function safePrintPrompt(rl) {
+  if (rl.closed) return;
+  printPrompt(rl);
+}
+function prefillCommand(rl, command) {
+  rl.write(null, { ctrl: true, name: "u" });
+  rl.write(command);
+}
+function resolveSlashCommand(input, state, terminal, context) {
+  const normalized = input.trim().toLowerCase();
+  if (normalized === "/exit" || normalized === "/quit") return { quit: true, args: null };
+  if (normalized === "/?" || normalized === "/keys") return { quit: false, args: [], message: keymapHelpText() };
+  if (normalized === "/help") return { quit: false, args: [], message: shellHelpText(state) };
+  if (normalized === "/commands") {
+    const rows = SLASH_COMMANDS.map((entry) => `  ${entry.slash.padEnd(12)} ${entry.description}`);
+    return {
+      quit: false,
+      args: [],
+      message: `
+Slash commands:
+${rows.join("\n")}
+`
+    };
   }
-  process.stdout.write("\nQuick actions (Up/Down, j/k, Enter, 1-9):\n");
-  actions.forEach((action, index) => {
-    const isSelected = !paletteOpen && index === selectedActionIndex;
-    const cursor = isSelected ? ">" : " ";
-    process.stdout.write(` ${cursor} [${index + 1}] ${action.label}
-`);
-    process.stdout.write(`       ${action.description}
-`);
-  });
-  process.stdout.write("\nShortcuts: [/] palette  [h] redraw  [q] exit  [Ctrl+C] exit\n");
-  process.stdout.write("Tip: start typing any command (for example auth, help, org list) to search instantly.\n");
-  if (paletteOpen) {
-    process.stdout.write("\nCommand palette\n");
-    process.stdout.write("---------------\n");
-    process.stdout.write(`/${paletteQuery}
-`);
-    if (paletteSuggestions.length === 0) {
-      process.stdout.write("  No matches. Press Enter to run typed command, or Esc to close.\n");
-    } else {
-      paletteSuggestions.slice(0, 8).forEach((entry, index) => {
-        const isSelected = index === selectedPaletteIndex;
-        const cursor = isSelected ? ">" : " ";
-        process.stdout.write(` ${cursor} ${entry.label}
-`);
-        process.stdout.write(`    foh ${entry.args.join(" ")}
-`);
-      });
+  if (normalized === "/clear") {
+    if (terminal.supportsAnsiClear) return { quit: false, args: [], message: "\x1B[2J\x1B[H" };
+    return {
+      quit: false,
+      args: [],
+      message: "\n\n\n\n\nTerminal does not support ANSI clear. Screen reset skipped.\n"
+    };
+  }
+  if (normalized === "/again") {
+    if (context.lastSuccessfulArgs && context.lastSuccessfulArgs.length > 0) {
+      return { quit: false, args: [...context.lastSuccessfulArgs] };
     }
-  } else {
-    process.stdout.write('\nPress "/" to open command palette.\n');
+    return { quit: false, args: [], message: "No successful command in current session yet.\n" };
   }
-  if (isBusy) {
-    process.stdout.write("\nRunning command...\n");
-  } else if (notice) {
-    process.stdout.write(`
-${notice}
-`);
+  if (normalized === "/retry") {
+    if (context.lastFailedArgs && context.lastFailedArgs.length > 0) {
+      return { quit: false, args: [...context.lastFailedArgs] };
+    }
+    return { quit: false, args: [], message: "No failed command in current session yet.\n" };
   }
+  if (normalized === "/editlast") {
+    const candidate = context.lastFailedArgs ?? context.lastSuccessfulArgs;
+    if (!candidate || candidate.length === 0) {
+      return { quit: false, args: [], message: "No previous command to prefill.\n" };
+    }
+    return {
+      quit: false,
+      args: [],
+      prefill: candidate.join(" "),
+      message: terminal.supportsLinePrefill ? "Prefilled last command. Edit and press Enter to run.\n" : `Terminal cannot prefill input. Replay manually: foh ${candidate.join(" ")}
+`
+    };
+  }
+  if (normalized.startsWith("/run ")) {
+    const raw = input.trim().slice("/run ".length).trim();
+    const args = tokenizeInput(raw);
+    return { quit: false, args: args.length > 0 ? args : null };
+  }
+  if (normalized === "/snippet list") {
+    const rows = Object.entries(context.snippets).sort((left, right) => left[0].localeCompare(right[0])).map(([name, command]) => `  ${name.padEnd(16)} ${command}`);
+    if (rows.length === 0) return { quit: false, args: [], message: "No snippets saved.\n" };
+    return { quit: false, args: [], message: `
+Saved snippets:
+${rows.join("\n")}
+` };
+  }
+  if (normalized.startsWith("/snippet save ")) {
+    const parts = tokenizeInput(input.trim());
+    const name = String(parts[2] ?? "").trim().toLowerCase();
+    const command = parts.slice(3).join(" ").trim();
+    if (!name || !command) {
+      return { quit: false, args: [], message: "Usage: /snippet save <name> <command>\n" };
+    }
+    const normalizedCommand = command.toLowerCase().startsWith("foh ") ? command.slice(4).trim() : command;
+    context.snippets[name] = normalizedCommand;
+    return { quit: false, args: [], message: `Saved snippet "${name}": ${normalizedCommand}
+` };
+  }
+  if (normalized.startsWith("/snippet run ")) {
+    const parts = tokenizeInput(input.trim());
+    const name = String(parts[2] ?? "").trim().toLowerCase();
+    const command = context.snippets[name];
+    if (!command) return { quit: false, args: [], message: `Snippet "${name}" not found.
+` };
+    return { quit: false, args: tokenizeInput(command) };
+  }
+  if (normalized.startsWith("/snippet edit ")) {
+    const parts = tokenizeInput(input.trim());
+    const name = String(parts[2] ?? "").trim().toLowerCase();
+    const command = context.snippets[name];
+    if (!command) return { quit: false, args: [], message: `Snippet "${name}" not found.
+` };
+    return {
+      quit: false,
+      args: [],
+      prefill: command,
+      message: terminal.supportsLinePrefill ? `Prefilled snippet "${name}".
+` : `Terminal cannot prefill input. Snippet "${name}": ${command}
+`
+    };
+  }
+  const matched = SLASH_COMMANDS.find((entry) => entry.slash.toLowerCase() === normalized);
+  if (matched?.args && matched.args.length > 0) {
+    return { quit: false, args: [...matched.args] };
+  }
+  if (normalized.startsWith("/")) {
+    return { quit: false, args: [], message: `Unknown slash command: ${input.trim()}
+Use /help.
+` };
+  }
+  return { quit: false, args: null };
 }
-function printHome(state) {
-  process.stdout.write("\nFront Of House CLI Home\n");
-  process.stdout.write("-----------------------\n");
-  if (!state.authenticated) {
-    process.stdout.write("Status: Not authenticated\n\n");
-    process.stdout.write("Fast path:\n");
-    process.stdout.write("  1) Press [1] to run interactive login\n");
-    process.stdout.write("  2) If multiple orgs are found, select one as default\n");
-    process.stdout.write("  3) Run tenant setup and ops commands\n\n");
-    process.stdout.write("Quick options:\n");
-    process.stdout.write("  [1] login now (recommended)\n");
-    process.stdout.write("  [2] full help\n");
-    process.stdout.write("  [3] auth login help\n");
-    process.stdout.write("  [h] redraw home\n");
-    process.stdout.write("  [q] exit\n");
-    process.stdout.write("  Type any foh command (example: auth whoami)\n");
-    return;
+function normalizeCommandInput(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return [];
+  const withoutPrefix = trimmed.toLowerCase().startsWith("foh ") ? trimmed.slice(4).trim() : trimmed;
+  return tokenizeInput(withoutPrefix);
+}
+function hasYesFlag(args) {
+  return args.some((token) => token === "--yes" || token === "-y");
+}
+async function confirmMutationIfNeeded(rl, args) {
+  const mutationState = classifyCommandMutation(args);
+  if (mutationState === "read" || hasYesFlag(args)) {
+    return { approved: true };
   }
-  if (!state.orgId) {
-    process.stdout.write(`Status: Authenticated
-API: ${state.apiUrl}
+  const commandEntry = getCommandGraphEntryForArgs(args);
+  const label = commandEntry ? `foh ${commandEntry.args.join(" ")}` : `foh ${args.join(" ")}`;
+  const warning = mutationState === "high_risk" ? "high-risk" : "write";
+  const approved = await new Promise((resolve15) => {
+    rl.question(`Confirm ${warning} command ${label}? [y/N]: `, (answer) => {
+      const normalized = answer.trim().toLowerCase();
+      resolve15(normalized === "y" || normalized === "yes");
+    });
+  });
+  if (approved) return { approved: true };
+  return {
+    approved: false,
+    message: `Command blocked (interactive_confirmation_required): foh ${args.join(" ")}`
+  };
+}
+function commandSuggestionsForState(state) {
+  const contextual = getHomePaletteCommands(state).map((entry) => entry.args.join(" "));
+  const merged = [...contextual, ...COMMAND_SUGGESTIONS];
+  return merged.filter((entry, index, values) => values.indexOf(entry) === index);
+}
+function fuzzyScore(query, candidate) {
+  const normalizedQuery = query.trim().toLowerCase();
+  const normalizedCandidate = candidate.toLowerCase();
+  if (!normalizedQuery) return 0;
+  if (normalizedCandidate.startsWith(normalizedQuery)) return 0;
+  const includesAt = normalizedCandidate.indexOf(normalizedQuery);
+  if (includesAt >= 0) return 100 + includesAt;
+  let queryIndex = 0;
+  let gaps = 0;
+  for (let i = 0; i < normalizedCandidate.length && queryIndex < normalizedQuery.length; i += 1) {
+    if (normalizedCandidate[i] === normalizedQuery[queryIndex]) {
+      queryIndex += 1;
+    } else if (queryIndex > 0) {
+      gaps += 1;
+    }
+  }
+  if (queryIndex !== normalizedQuery.length) return Number.POSITIVE_INFINITY;
+  return 200 + gaps;
+}
+function rankMatches(query, pool) {
+  const scored = pool.map((candidate) => ({ candidate, score: fuzzyScore(query, candidate) })).filter((entry) => Number.isFinite(entry.score)).sort((left, right) => {
+    if (left.score !== right.score) return left.score - right.score;
+    return left.candidate.localeCompare(right.candidate);
+  });
+  return scored.map((entry) => entry.candidate);
+}
+function buildCompleter(apiUrlOverride) {
+  const slashLabels = SLASH_COMMANDS.map((entry) => entry.slash);
+  return (line) => {
+    const raw = String(line ?? "");
+    const lower = raw.toLowerCase();
+    const state = resolveInteractiveState(apiUrlOverride);
+    const commandLabels = commandSuggestionsForState(state);
+    const pool = lower.trim().startsWith("/") ? slashLabels : commandLabels;
+    const hits = rankMatches(lower, pool);
+    return [hits.length > 0 ? hits : pool, raw];
+  };
+}
+function registerInteractive(program3) {
+  program3.command("interactive").alias("shell").description("Open interactive FOH shell with slash commands and key support").option("--api-url <url>", "Internal API base URL override (operators only)").action(async (opts) => {
+    const sessionArtifact = createInteractiveSessionArtifact();
+    const terminalCapabilities = detectTerminalCapabilities();
+    sessionArtifact.terminal_capabilities = {
+      stdin_tty: terminalCapabilities.stdinTty,
+      stdout_tty: terminalCapabilities.stdoutTty,
+      supports_raw_mode: terminalCapabilities.supportsRawMode,
+      supports_line_prefill: terminalCapabilities.supportsLinePrefill,
+      supports_ansi_clear: terminalCapabilities.supportsAnsiClear
+    };
+    const memory = loadInteractiveShellMemory();
+    recordInteractiveShellEvent(sessionArtifact, { type: "shell_started" });
+    ensureInteractive(
+      "interactive.shell",
+      "Run this in a TTY terminal. For automation use normal non-interactive commands with --json."
+    );
+    const rl = (0, import_readline2.createInterface)({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true,
+      historySize: 500,
+      removeHistoryDuplicates: true,
+      history: memory.history.slice(0, 500),
+      completer: buildCompleter(opts.apiUrl)
+    });
+    process.stdout.write(shellHelpText(resolveInteractiveState(opts.apiUrl)));
+    printPrompt(rl);
+    let busy = false;
+    let lastSuccessfulArgs = null;
+    let lastFailedArgs = null;
+    rl.on("line", (line) => {
+      void (async () => {
+        if (busy) return;
+        const raw = String(line ?? "");
+        const slash = resolveSlashCommand(raw, resolveInteractiveState(opts.apiUrl), terminalCapabilities, {
+          lastSuccessfulArgs,
+          lastFailedArgs,
+          snippets: memory.snippets
+        });
+        if (slash.quit) {
+          rl.close();
+          return;
+        }
+        if (slash.message) {
+          process.stdout.write(`${slash.message}${slash.message.endsWith("\n") ? "" : "\n"}`);
+        }
+        if (slash.prefill) {
+          if (terminalCapabilities.supportsLinePrefill) {
+            prefillCommand(rl, slash.prefill);
+          }
+          return;
+        }
+        const commandArgs = slash.args ?? normalizeCommandInput(raw);
+        if (commandArgs.length === 0) {
+          safePrintPrompt(rl);
+          return;
+        }
+        const confirmation = await confirmMutationIfNeeded(rl, commandArgs);
+        if (!confirmation.approved) {
+          if (confirmation.message) {
+            process.stdout.write(`${confirmation.message}
 `);
-    process.stdout.write("Default org: (not set)\n\n");
-    process.stdout.write("Quick options:\n");
-    process.stdout.write("  [1] list my orgs\n");
-    process.stdout.write("  [2] org use help\n");
-    process.stdout.write("  [3] auth whoami\n");
-    process.stdout.write("  [4] full help\n");
-    process.stdout.write("  [h] redraw home\n");
-    process.stdout.write("  [q] exit\n");
-    process.stdout.write("  Type any foh command (example: org use --org <id>)\n");
-    return;
-  }
-  process.stdout.write(`Status: Authenticated
-API: ${state.apiUrl}
+            recordInteractiveShellEvent(sessionArtifact, {
+              type: "command_blocked",
+              command: `foh ${commandArgs.join(" ")}`,
+              reason: "interactive_confirmation_required"
+            });
+          }
+          printPrompt(rl);
+          return;
+        }
+        recordInteractiveShellEvent(sessionArtifact, {
+          type: "command_started",
+          command: `foh ${commandArgs.join(" ")}`
+        });
+        busy = true;
+        try {
+          const code = await runSelf(commandArgs, opts.apiUrl);
+          if (code !== 0) {
+            lastFailedArgs = [...commandArgs];
+            process.stdout.write(`Command exited with code ${code}: foh ${commandArgs.join(" ")}
 `);
-  process.stdout.write(`Default org: ${state.orgId ?? "(not set)"}
-
+            recordInteractiveShellEvent(sessionArtifact, {
+              type: "command_failed",
+              command: `foh ${commandArgs.join(" ")}`,
+              exit_code: code,
+              reason: "non_zero_exit"
+            });
+          } else {
+            lastSuccessfulArgs = [...commandArgs];
+            recordInteractiveShellEvent(sessionArtifact, {
+              type: "command_succeeded",
+              command: `foh ${commandArgs.join(" ")}`,
+              exit_code: code
+            });
+          }
+        } finally {
+          busy = false;
+          safePrintPrompt(rl);
+        }
+      })().catch((error2) => {
+        const message = error2 instanceof Error ? error2.message : String(error2);
+        process.stdout.write(`Shell error: ${message}
 `);
-  process.stdout.write("Quick options:\n");
-  process.stdout.write("  [1] tenant status\n");
-  process.stdout.write("  [2] template list\n");
-  process.stdout.write("  [3] agent list\n");
-  process.stdout.write("  [4] setup help\n");
-  process.stdout.write("  [5] bug report help\n");
-  process.stdout.write("  [6] bug list\n");
-  process.stdout.write("  [h] redraw home\n");
-  process.stdout.write("  [q] exit\n");
-  process.stdout.write("  Type any foh command (example: agent --help)\n");
+        recordInteractiveShellEvent(sessionArtifact, {
+          type: "shell_error",
+          reason: message
+        });
+        busy = false;
+        safePrintPrompt(rl);
+      });
+    });
+    rl.on("SIGINT", () => {
+      rl.close();
+    });
+    await new Promise((resolve15) => {
+      rl.on("close", () => {
+        process.stdout.write("\n");
+        memory.history = rl.history.slice(0, 500);
+        recordInteractiveShellEvent(sessionArtifact, { type: "shell_closed" });
+        flushInteractiveSessionArtifact(sessionArtifact);
+        flushInteractiveSessionReport(sessionArtifact);
+        saveInteractiveShellMemory(memory);
+        resolve15();
+      });
+    });
+  });
 }
 
 // src/commands/home-actions.ts
@@ -38625,65 +39528,6 @@ async function promptChoice(prompt) {
   return await promptLine(`
 ${prompt}`, { allowEmpty: true });
 }
-function resolveSelection(input, state) {
-  const normalized = input.trim().toLowerCase();
-  if (!normalized || normalized === "q" || normalized === "quit" || normalized === "exit") {
-    return { kind: "exit" };
-  }
-  if (normalized === "h" || normalized === "home" || normalized === "?") {
-    return { kind: "redraw" };
-  }
-  if (normalized === "help" || normalized === "--help") {
-    return { kind: "run", args: ["--help"] };
-  }
-  if (!state.authenticated) {
-    if (normalized === "1" || normalized === "start" || normalized === "login" || normalized === "auth" || normalized === "auth login") {
-      return { kind: "run", args: ["auth", "login"] };
-    }
-    if (normalized === "2" || normalized === "full help") {
-      return { kind: "run", args: ["--help"] };
-    }
-    if (normalized === "3" || normalized === "auth login help") {
-      return { kind: "run", args: ["auth", "login", "--help"] };
-    }
-  } else if (!state.orgId) {
-    if (normalized === "1" || normalized === "org" || normalized === "org list") {
-      return { kind: "run", args: ["org", "list"] };
-    }
-    if (normalized === "2" || normalized === "org use help") {
-      return { kind: "run", args: ["org", "use", "--help"] };
-    }
-    if (normalized === "3" || normalized === "auth whoami" || normalized === "whoami") {
-      return { kind: "run", args: ["auth", "whoami"] };
-    }
-    if (normalized === "4" || normalized === "full help") {
-      return { kind: "run", args: ["--help"] };
-    }
-  } else {
-    if (normalized === "1" || normalized === "tenant" || normalized === "tenant status") {
-      return { kind: "run", args: ["tenant", "status"] };
-    }
-    if (normalized === "2" || normalized === "templates" || normalized === "template list" || normalized === "templates list") {
-      return { kind: "run", args: ["templates", "list"] };
-    }
-    if (normalized === "3" || normalized === "agent" || normalized === "agent list") {
-      return { kind: "run", args: ["agent", "list", "--segment", "all"] };
-    }
-    if (normalized === "4" || normalized === "setup" || normalized === "setup help") {
-      return { kind: "run", args: ["setup", "--help"] };
-    }
-    if (normalized === "5" || normalized === "bug report" || normalized === "bug report help") {
-      return { kind: "run", args: ["bug", "report", "--help"] };
-    }
-    if (normalized === "6" || normalized === "bug list") {
-      return { kind: "run", args: ["bug", "list"] };
-    }
-  }
-  const tokens = tokenizeInput(input);
-  if (tokens.length > 0 && tokens[0].toLowerCase() === "foh") tokens.shift();
-  if (tokens.length > 0) return { kind: "run", args: tokens };
-  return { kind: "invalid" };
-}
 async function runGuidedStart(apiUrlOverride, executeCommand) {
   process.stdout.write("\nGuided Start\n");
   process.stdout.write("------------\n");
@@ -38798,13 +39642,153 @@ async function chooseDefaultOrg(orgs) {
 `);
   }
 }
-function getHomeQuickActions(state) {
-  return getQuickActions(state);
+function getHomeQuickActions2(state) {
+  return getHomeQuickActions(state);
+}
+
+// src/tui/command-palette.ts
+function tokenizeInput2(value) {
+  const tokens = [];
+  const matcher = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let match = matcher.exec(value);
+  while (match) {
+    tokens.push(match[1] ?? match[2] ?? match[3] ?? "");
+    match = matcher.exec(value);
+  }
+  return tokens;
+}
+function normalizeTypedCommandInput(raw) {
+  const normalized = String(raw ?? "").trim();
+  if (!normalized) return [];
+  const withoutLeadingSlash = normalized.startsWith("/") ? normalized.slice(1) : normalized;
+  const tokens = tokenizeInput2(withoutLeadingSlash);
+  if (tokens.length > 0 && tokens[0].toLowerCase() === "foh") {
+    tokens.shift();
+  }
+  return tokens;
+}
+function filterPaletteCommands(commands, query) {
+  const normalized = String(query ?? "").trim().toLowerCase();
+  if (!normalized) return commands;
+  return commands.filter((entry) => {
+    const commandText = `foh ${entry.args.join(" ")}`.toLowerCase();
+    return entry.label.toLowerCase().includes(normalized) || commandText.includes(normalized);
+  });
+}
+function shouldStartPaletteFromHome(char) {
+  if (typeof char !== "string" || char.length !== 1) return false;
+  if (/\s/.test(char)) return false;
+  if (char === "/") return false;
+  return /^[0-9A-Za-z._:-]$/.test(char);
+}
+
+// src/commands/home-render.ts
+function getQuickActions(state) {
+  return getHomeQuickActions(state);
+}
+function getPaletteCommands(state) {
+  return getHomePaletteCommands(state);
+}
+function filterHomePaletteCommands(state, query) {
+  const commands = getPaletteCommands(state);
+  const commandIndex = new Map(commands.map((entry) => [entry.args.join(" "), entry]));
+  const filtered = filterPaletteCommands(commands, query);
+  return filtered.map((entry) => commandIndex.get(entry.args.join(" "))).filter((entry) => entry !== void 0);
+}
+function renderInteractiveHomeScreen({
+  state,
+  actions,
+  selectedActionIndex,
+  paletteOpen,
+  paletteQuery,
+  paletteSuggestions,
+  selectedPaletteIndex,
+  notice,
+  isBusy
+}) {
+  process.stdout.write("\x1B[2J\x1B[H");
+  process.stdout.write("Front Of House CLI Home\n");
+  process.stdout.write("=======================\n\n");
+  if (!state.authenticated) {
+    process.stdout.write("Status: Not authenticated\n");
+  } else {
+    process.stdout.write("Status: Authenticated\n");
+    process.stdout.write(`API: ${state.apiUrl}
+`);
+    process.stdout.write(`Default org: ${state.orgId ?? "(not set)"}
+`);
+  }
+  process.stdout.write("\nQuick actions (Up/Down, j/k, Enter, 1-9):\n");
+  actions.forEach((action, index) => {
+    const isSelected = !paletteOpen && index === selectedActionIndex;
+    const cursor = isSelected ? ">" : " ";
+    process.stdout.write(` ${cursor} [${index + 1}] ${action.label}
+`);
+    process.stdout.write(`       ${action.description}
+`);
+  });
+  process.stdout.write("\nShortcuts: [/] palette  [h] redraw  [q] exit  [Ctrl+C] exit\n");
+  process.stdout.write("Tip: start typing any command (for example auth, help, org list) to search instantly.\n");
+  if (paletteOpen) {
+    process.stdout.write("\nCommand palette\n");
+    process.stdout.write("---------------\n");
+    process.stdout.write(`/${paletteQuery}
+`);
+    if (paletteSuggestions.length === 0) {
+      process.stdout.write("  No matches. Press Enter to run typed command, or Esc to close.\n");
+    } else {
+      paletteSuggestions.slice(0, 8).forEach((entry, index) => {
+        const isSelected = index === selectedPaletteIndex;
+        const cursor = isSelected ? ">" : " ";
+        process.stdout.write(` ${cursor} ${entry.label}
+`);
+        process.stdout.write(`    foh ${entry.args.join(" ")}
+`);
+      });
+    }
+  } else {
+    process.stdout.write('\nPress "/" to open command palette.\n');
+  }
+  if (isBusy) {
+    process.stdout.write("\nRunning command...\n");
+  } else if (notice) {
+    process.stdout.write(`
+${notice}
+`);
+  }
+}
+function printHome(state) {
+  process.stdout.write("\nFront Of House CLI Home\n");
+  process.stdout.write("-----------------------\n");
+  if (!state.authenticated) {
+    process.stdout.write("Status: Not authenticated\n\n");
+  } else {
+    process.stdout.write(`Status: Authenticated
+API: ${state.apiUrl}
+`);
+    process.stdout.write(`Default org: ${state.orgId ?? "(not set)"}
+
+`);
+  }
+  const actions = getQuickActions(state);
+  if (actions.length > 0) {
+    process.stdout.write("Quick options:\n");
+    actions.forEach((action, index) => {
+      process.stdout.write(`  [${index + 1}] ${action.label}
+`);
+    });
+    process.stdout.write("  [h] redraw home\n");
+    process.stdout.write("  [q] exit\n");
+  }
+  const exampleAction = actions.find((entry) => entry.args.length > 0);
+  const example = exampleAction ? `Type any foh command (example: ${exampleAction.args.join(" ")})` : "Type any foh command (example: --help)";
+  process.stdout.write(`  ${example}
+`);
 }
 
 // src/commands/home-interaction.ts
-var import_child_process2 = require("child_process");
-var import_readline2 = require("readline");
+var import_child_process3 = require("child_process");
+var import_readline3 = require("readline");
 
 // src/tui/keypress.ts
 function normalizeInputChar(inputChar) {
@@ -38852,13 +39836,13 @@ function resolveNumericSelection(inputChar, length) {
 }
 
 // src/commands/home-interaction.ts
-async function runSelf(args, apiUrlOverride) {
+async function runSelf2(args, apiUrlOverride) {
   const spawnArgs = [...args];
   if (apiUrlOverride && !spawnArgs.includes("--api-url")) {
     spawnArgs.push("--api-url", apiUrlOverride);
   }
-  return await new Promise((resolve14, reject) => {
-    const child = (0, import_child_process2.spawn)(process.execPath, [process.argv[1], ...spawnArgs], {
+  return await new Promise((resolve15, reject) => {
+    const child = (0, import_child_process3.spawn)(process.execPath, [process.argv[1], ...spawnArgs], {
       stdio: "inherit",
       env: {
         ...process.env,
@@ -38867,7 +39851,7 @@ async function runSelf(args, apiUrlOverride) {
       }
     });
     child.once("error", reject);
-    child.once("close", (code) => resolve14(typeof code === "number" ? code : 1));
+    child.once("close", (code) => resolve15(typeof code === "number" ? code : 1));
   });
 }
 function shouldUseInteractiveHome(argv) {
@@ -38880,7 +39864,7 @@ function numericSelection(inputChar, actionCount) {
   return resolveNumericSelection(inputChar, actionCount);
 }
 function renderHome(state, selectedActionIndex, paletteOpen, paletteQuery, paletteSuggestions, selectedPaletteIndex, notice, isBusy) {
-  const actions = getHomeQuickActions(state);
+  const actions = getHomeQuickActions2(state);
   renderInteractiveHomeScreen({
     state,
     actions,
@@ -38893,31 +39877,6 @@ function renderHome(state, selectedActionIndex, paletteOpen, paletteQuery, palet
     isBusy
   });
 }
-async function runLegacyHomeLoop(initialState, apiUrlOverride, runCommand, promptChoice2) {
-  let state = initialState;
-  printHome(state);
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return;
-  while (true) {
-    const selected = await promptChoice2("Select option/key/command: ");
-    const resolved = resolveSelection(selected, state);
-    if (resolved.kind === "exit") return;
-    if (resolved.kind === "redraw") {
-      printHome(state);
-      continue;
-    }
-    if (resolved.kind === "invalid") {
-      process.stdout.write("Unknown selection. Use keys shown above, or type a foh command.\n");
-      continue;
-    }
-    const code = await runCommand(resolved.args, apiUrlOverride);
-    if (code !== 0) {
-      process.stdout.write(`Command exited with code ${code}.
-`);
-    }
-    state = resolveHomeState(apiUrlOverride);
-    printHome(state);
-  }
-}
 async function runKeyDrivenHomeLoop(apiUrlOverride, runCommand) {
   const stateAccessor = () => resolveHomeState(apiUrlOverride);
   let state = stateAccessor();
@@ -38929,7 +39888,7 @@ async function runKeyDrivenHomeLoop(apiUrlOverride, runCommand) {
   let notice = null;
   let isBusy = false;
   let finished = false;
-  let actions = getHomeQuickActions(state);
+  let actions = getHomeQuickActions2(state);
   const stdin = process.stdin;
   const clampPaletteIndex = () => {
     if (paletteSuggestions.length === 0) {
@@ -38942,7 +39901,7 @@ async function runKeyDrivenHomeLoop(apiUrlOverride, runCommand) {
     }
   };
   const refreshDerivedState = () => {
-    actions = getHomeQuickActions(state);
+    actions = getHomeQuickActions2(state);
     if (actions.length === 0) {
       selectedActionIndex = 0;
     } else if (selectedActionIndex >= actions.length) {
@@ -39106,7 +40065,7 @@ async function runKeyDrivenHomeLoop(apiUrlOverride, runCommand) {
     if (stdin.isTTY) stdin.setRawMode(false);
   };
   const attachInput = () => {
-    (0, import_readline2.emitKeypressEvents)(stdin);
+    (0, import_readline3.emitKeypressEvents)(stdin);
     stdin.on("keypress", onKeypress);
     if (stdin.isTTY) stdin.setRawMode(true);
     stdin.resume();
@@ -39129,18 +40088,14 @@ function registerHome(program3) {
     try {
       const explicitStart = process.argv.slice(2).some((token) => token.toLowerCase() === "start");
       if (explicitStart) {
-        await runGuidedStart(opts.apiUrl, runSelf);
+        await runGuidedStart(opts.apiUrl, runSelf2);
       }
       const state = resolveHomeState(opts.apiUrl);
       if (!process.stdin.isTTY || !process.stdout.isTTY) {
         printHome(state);
         return;
       }
-      if (process.env.FOH_CLI_HOME_LEGACY === "1") {
-        await runLegacyHomeLoop(state, opts.apiUrl, runSelf, (prompt) => promptChoice(prompt));
-        return;
-      }
-      await runKeyDrivenHomeLoop(opts.apiUrl, runSelf);
+      await runKeyDrivenHomeLoop(opts.apiUrl, runSelf2);
     } catch (e) {
       if (e instanceof FohError) {
         formatError(e);
@@ -39157,9 +40112,9 @@ function maybeDefaultToHome(argv = process.argv) {
 }
 
 // src/lib/update.ts
-var import_fs11 = require("fs");
-var import_path9 = require("path");
-var import_child_process3 = require("child_process");
+var import_fs12 = require("fs");
+var import_path10 = require("path");
+var import_child_process4 = require("child_process");
 var import_crypto5 = require("crypto");
 function parseSemver(version2) {
   const trimmed = String(version2 ?? "").trim();
@@ -39179,7 +40134,7 @@ function compareSemver(a, b) {
 }
 function readPackageJsonVersion(path2) {
   try {
-    const raw = (0, import_fs11.readFileSync)(path2, "utf-8");
+    const raw = (0, import_fs12.readFileSync)(path2, "utf-8");
     const parsed = JSON.parse(raw);
     const version2 = String(parsed.version ?? "").trim();
     return version2 || void 0;
@@ -39188,13 +40143,13 @@ function readPackageJsonVersion(path2) {
   }
 }
 function findRepoRoot(startCwd = process.cwd()) {
-  let current = (0, import_path9.resolve)(startCwd);
+  let current = (0, import_path10.resolve)(startCwd);
   while (true) {
-    const rootPackageJsonPath = (0, import_path9.join)(current, "package.json");
-    const cliPackageJsonPath = (0, import_path9.join)(current, "packages", "cli", "package.json");
-    if ((0, import_fs11.existsSync)(rootPackageJsonPath) && (0, import_fs11.existsSync)(cliPackageJsonPath)) {
+    const rootPackageJsonPath = (0, import_path10.join)(current, "package.json");
+    const cliPackageJsonPath = (0, import_path10.join)(current, "packages", "cli", "package.json");
+    if ((0, import_fs12.existsSync)(rootPackageJsonPath) && (0, import_fs12.existsSync)(cliPackageJsonPath)) {
       try {
-        const raw = (0, import_fs11.readFileSync)(rootPackageJsonPath, "utf-8");
+        const raw = (0, import_fs12.readFileSync)(rootPackageJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (String(parsed.name ?? "").trim() === "front-of-house") {
           return current;
@@ -39202,7 +40157,7 @@ function findRepoRoot(startCwd = process.cwd()) {
       } catch {
       }
     }
-    const parent = (0, import_path9.dirname)(current);
+    const parent = (0, import_path10.dirname)(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -39216,7 +40171,7 @@ function detectUpdateAvailability(currentVersion, cwd = process.cwd()) {
       remediation: "Run this command from the Front Of House repo root to compare/install the latest CLI."
     };
   }
-  const cliPackageJsonPath = (0, import_path9.join)(repoRoot, "packages", "cli", "package.json");
+  const cliPackageJsonPath = (0, import_path10.join)(repoRoot, "packages", "cli", "package.json");
   const latestVersion = readPackageJsonVersion(cliPackageJsonPath);
   if (!latestVersion) {
     return {
@@ -39243,20 +40198,20 @@ function detectUpdateAvailability(currentVersion, cwd = process.cwd()) {
   };
 }
 async function applyRepoUpdate(repoRoot) {
-  const scriptPath = (0, import_path9.join)(repoRoot, "scripts", "Install-FohCli.ps1");
+  const scriptPath = (0, import_path10.join)(repoRoot, "scripts", "Install-FohCli.ps1");
   if (process.platform === "win32") {
-    return await new Promise((resolve14, reject) => {
-      const child = (0, import_child_process3.spawn)(
+    return await new Promise((resolve15, reject) => {
+      const child = (0, import_child_process4.spawn)(
         "powershell",
         ["-ExecutionPolicy", "Bypass", "-File", scriptPath],
         { stdio: "inherit" }
       );
       child.once("error", reject);
-      child.once("close", (code) => resolve14(typeof code === "number" ? code : 1));
+      child.once("close", (code) => resolve15(typeof code === "number" ? code : 1));
     });
   }
-  return await new Promise((resolve14, reject) => {
-    const child = (0, import_child_process3.spawn)(
+  return await new Promise((resolve15, reject) => {
+    const child = (0, import_child_process4.spawn)(
       "corepack",
       ["pnpm", "cli:install:global"],
       {
@@ -39265,7 +40220,7 @@ async function applyRepoUpdate(repoRoot) {
       }
     );
     child.once("error", reject);
-    child.once("close", (code) => resolve14(typeof code === "number" ? code : 1));
+    child.once("close", (code) => resolve15(typeof code === "number" ? code : 1));
   });
 }
 function shouldShowUpdateNotice(argv = process.argv) {
@@ -39279,7 +40234,7 @@ function shouldShowUpdateNotice(argv = process.argv) {
 }
 function hashFileSha256(filePath) {
   try {
-    const bytes = (0, import_fs11.readFileSync)(filePath);
+    const bytes = (0, import_fs12.readFileSync)(filePath);
     return (0, import_crypto5.createHash)("sha256").update(bytes).digest("hex");
   } catch {
     return void 0;
@@ -39289,10 +40244,10 @@ function verifyCliArtifactIntegrity(params = {}) {
   const cwd = params.cwd ?? process.cwd();
   const argv = params.argv ?? process.argv;
   const expectedSha256 = String(params.expectedSha256 ?? "").trim().toLowerCase() || void 0;
-  const runtimePath = (0, import_path9.resolve)(String(argv[1] || ""));
+  const runtimePath = (0, import_path10.resolve)(String(argv[1] || ""));
   const runtimeHash = runtimePath ? hashFileSha256(runtimePath) : void 0;
   const warnings = [];
-  if (!runtimePath || !(0, import_fs11.existsSync)(runtimePath)) {
+  if (!runtimePath || !(0, import_fs12.existsSync)(runtimePath)) {
     warnings.push("runtime_path_unreadable");
   }
   if (!runtimeHash) {
@@ -39310,8 +40265,8 @@ function verifyCliArtifactIntegrity(params = {}) {
   let repoDistHash;
   let runtimeMatchesRepoDist;
   if (repoRoot) {
-    repoDistPath = (0, import_path9.join)(repoRoot, "packages", "cli", "dist", "foh.js");
-    if ((0, import_fs11.existsSync)(repoDistPath)) {
+    repoDistPath = (0, import_path10.join)(repoRoot, "packages", "cli", "dist", "foh.js");
+    if ((0, import_fs12.existsSync)(repoDistPath)) {
       repoDistHash = hashFileSha256(repoDistPath);
       if (runtimeHash && repoDistHash) {
         runtimeMatchesRepoDist = runtimeHash === repoDistHash;
@@ -39401,13 +40356,13 @@ function registerUpdate(program3) {
 }
 
 // src/commands/eval.ts
-var import_fs20 = require("fs");
-var import_path19 = require("path");
-var import_child_process6 = require("child_process");
+var import_fs21 = require("fs");
+var import_path20 = require("path");
+var import_child_process7 = require("child_process");
 
 // src/lib/external-agent-artifact-safety.ts
-var import_fs12 = require("fs");
-var import_path10 = require("path");
+var import_fs13 = require("fs");
+var import_path11 = require("path");
 var DEFAULT_MAX_BYTES_PER_FILE = 5 * 1024 * 1024;
 var TEXT_ARTIFACT_NAMES = /* @__PURE__ */ new Set([
   "codex-events.jsonl",
@@ -39431,7 +40386,7 @@ function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function pathVariants(path2) {
-  const resolved = (0, import_path10.resolve)(path2);
+  const resolved = (0, import_path11.resolve)(path2);
   const slash = resolved.replace(/\\/g, "/");
   const backslash = resolved.replace(/\//g, "\\");
   return Array.from(new Set([
@@ -39474,9 +40429,9 @@ function redactExternalAgentSecretText(text) {
   return text.replace(SECRET_QUERY_PARAM_RE, "$1[redacted_secret]").replace(SECRET_RE2, "[redacted_secret]");
 }
 function artifactFiles(runDir) {
-  if (!(0, import_fs12.existsSync)(runDir)) return [];
-  return (0, import_fs12.readdirSync)(runDir).map((name) => (0, import_path10.join)(runDir, name)).filter((path2) => {
-    const stat = (0, import_fs12.statSync)(path2);
+  if (!(0, import_fs13.existsSync)(runDir)) return [];
+  return (0, import_fs13.readdirSync)(runDir).map((name) => (0, import_path11.join)(runDir, name)).filter((path2) => {
+    const stat = (0, import_fs13.statSync)(path2);
     const name = path2.split(/[\\/]/).pop() || "";
     if (name.endsWith(".redacted")) return false;
     return stat.isFile() && (TEXT_ARTIFACT_NAMES.has(name) || name.startsWith("command-output-cmd_"));
@@ -39502,15 +40457,15 @@ function scanText(input) {
   ].filter(Boolean);
 }
 function scanExternalAgentArtifacts(options) {
-  const runDir = (0, import_path10.resolve)(options.runDir);
-  const privateRepoRoot = options.privateRepoRoot ? (0, import_path10.resolve)(options.privateRepoRoot) : void 0;
+  const runDir = (0, import_path11.resolve)(options.runDir);
+  const privateRepoRoot = options.privateRepoRoot ? (0, import_path11.resolve)(options.privateRepoRoot) : void 0;
   const homeDir = options.homeDir || process.env.USERPROFILE || process.env.HOME;
   const maxBytes = options.maxBytesPerFile ?? DEFAULT_MAX_BYTES_PER_FILE;
   const files = artifactFiles(runDir);
   const findings = [];
   const redactedFiles = [];
   for (const file2 of files) {
-    const stat = (0, import_fs12.statSync)(file2);
+    const stat = (0, import_fs13.statSync)(file2);
     if (stat.size > maxBytes) {
       findings.push({
         kind: "artifact_too_large",
@@ -39520,12 +40475,12 @@ function scanExternalAgentArtifacts(options) {
       });
       continue;
     }
-    const text = (0, import_fs12.readFileSync)(file2, "utf8");
+    const text = (0, import_fs13.readFileSync)(file2, "utf8");
     findings.push(...scanText({ text, file: file2, privateRepoRoot, homeDir }));
     if (options.writeRedacted) {
       const redacted = redactExternalAgentArtifactText(text, { privateRepoRoot, homeDir });
       const out = `${file2}.redacted`;
-      (0, import_fs12.writeFileSync)(out, redacted, "utf8");
+      (0, import_fs13.writeFileSync)(out, redacted, "utf8");
       redactedFiles.push(out);
     }
   }
@@ -39546,8 +40501,8 @@ function scanExternalAgentArtifacts(options) {
 }
 
 // src/lib/external-agent-capture.ts
-var import_fs13 = require("fs");
-var import_path11 = require("path");
+var import_fs14 = require("fs");
+var import_path12 = require("path");
 var EXTERNAL_AGENT_RUN_DIR_ENV = "FOH_EXTERNAL_AGENT_RUN_DIR";
 var EXTERNAL_AGENT_PROMPT_VERSION_ENV = "FOH_EXTERNAL_AGENT_PROMPT_VERSION";
 var SECRET_RE3 = /\b(?:Bearer\s+)?(?:sk|pk|xai|whsec|EAAN|ghp|gho|github_pat|npm_)[A-Za-z0-9_\-.]{12,}\b/gi;
@@ -39566,7 +40521,7 @@ function safeJsonLine(value) {
 function getExternalAgentRunDir() {
   const raw = process.env[EXTERNAL_AGENT_RUN_DIR_ENV];
   if (!raw || !raw.trim()) return null;
-  return (0, import_path11.resolve)(raw);
+  return (0, import_path12.resolve)(raw);
 }
 function commandIdFor(input) {
   const seed = `${input.startedAt}:${input.argv.join("\0")}:${process.pid}`;
@@ -39617,7 +40572,7 @@ function recordExternalAgentCliInvocation(input) {
   const runDir = getExternalAgentRunDir();
   if (!runDir) return null;
   try {
-    (0, import_fs13.mkdirSync)(runDir, { recursive: true });
+    (0, import_fs14.mkdirSync)(runDir, { recursive: true });
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const args = input.argv.slice(2).map((arg) => redactText(String(arg)));
     const commandId = commandIdFor({ startedAt, argv: args });
@@ -39636,7 +40591,7 @@ function recordExternalAgentCliInvocation(input) {
       prompt_version: promptVersion,
       started_at: startedAt
     };
-    (0, import_fs13.appendFileSync)((0, import_path11.join)(runDir, "commands.ndjson"), safeJsonLine(record2), "utf8");
+    (0, import_fs14.appendFileSync)((0, import_path12.join)(runDir, "commands.ndjson"), safeJsonLine(record2), "utf8");
     return {
       commandId,
       runDir,
@@ -39697,7 +40652,7 @@ function completeExternalAgentCliInvocation(capture, input) {
   let artifact = null;
   if (output.trim()) {
     artifact = outputArtifactName(capture.commandId);
-    (0, import_fs13.writeFileSync)((0, import_path11.join)(capture.runDir, artifact), output, "utf8");
+    (0, import_fs14.writeFileSync)((0, import_path12.join)(capture.runDir, artifact), output, "utf8");
   }
   const record2 = {
     schema_version: "external_agent_cli_command.v2",
@@ -39720,12 +40675,12 @@ function completeExternalAgentCliInvocation(capture, input) {
     output_artifact: artifact,
     output_bytes: Buffer.byteLength(output, "utf8")
   };
-  (0, import_fs13.appendFileSync)((0, import_path11.join)(capture.runDir, "commands.ndjson"), safeJsonLine(record2), "utf8");
+  (0, import_fs14.appendFileSync)((0, import_path12.join)(capture.runDir, "commands.ndjson"), safeJsonLine(record2), "utf8");
 }
 function readCommandRecords(runDir) {
-  const commandLogPath = (0, import_path11.join)(runDir, "commands.ndjson");
-  if (!(0, import_fs13.existsSync)(commandLogPath)) return [];
-  const records = (0, import_fs13.readFileSync)(commandLogPath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+  const commandLogPath = (0, import_path12.join)(runDir, "commands.ndjson");
+  if (!(0, import_fs14.existsSync)(commandLogPath)) return [];
+  const records = (0, import_fs14.readFileSync)(commandLogPath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
   const byId = /* @__PURE__ */ new Map();
   const ordered = [];
   for (const record2 of records) {
@@ -39737,13 +40692,13 @@ function readCommandRecords(runDir) {
 }
 
 // src/lib/external-agent-executor.ts
-var import_fs19 = require("fs");
-var import_os2 = require("os");
-var import_path18 = require("path");
-var import_child_process5 = require("child_process");
+var import_fs20 = require("fs");
+var import_os3 = require("os");
+var import_path19 = require("path");
+var import_child_process6 = require("child_process");
 
 // src/lib/external-agent-executor-env.ts
-var import_path12 = require("path");
+var import_path13 = require("path");
 var CODEX_EXECUTOR_DENIED_ENV_PREFIXES = [
   "SUPABASE_",
   "DATABASE_",
@@ -39807,7 +40762,7 @@ function buildCodexExecutorEnv(input) {
       env[childKey] = value;
     }
   }
-  env.npm_config_cache = (0, import_path12.join)((0, import_path12.dirname)(input.runDir), ".npm-cache");
+  env.npm_config_cache = (0, import_path13.join)((0, import_path13.dirname)(input.runDir), ".npm-cache");
   env.npm_config_prefer_online = "true";
   env.npm_config_update_notifier = "false";
   env.npm_config_yes = "true";
@@ -39819,12 +40774,12 @@ function buildCodexExecutorEnv(input) {
 }
 
 // src/lib/external-agent-executor-artifacts.ts
-var import_fs15 = require("fs");
-var import_path14 = require("path");
+var import_fs16 = require("fs");
+var import_path15 = require("path");
 
 // src/lib/external-agent-metadata.ts
-var import_fs14 = require("fs");
-var import_path13 = require("path");
+var import_fs15 = require("fs");
+var import_path14 = require("path");
 var EXTERNAL_AGENT_METADATA_FILENAMES = [
   "external-agent-metadata.json",
   "agent-metadata.json"
@@ -39846,10 +40801,10 @@ function collectDocsFrom(value, docs) {
 }
 function readExternalAgentMetadata(runDir) {
   for (const filename of EXTERNAL_AGENT_METADATA_FILENAMES) {
-    const path2 = (0, import_path13.join)(runDir, filename);
-    if (!(0, import_fs14.existsSync)(path2)) continue;
+    const path2 = (0, import_path14.join)(runDir, filename);
+    if (!(0, import_fs15.existsSync)(path2)) continue;
     try {
-      const parsed = JSON.parse((0, import_fs14.readFileSync)(path2, "utf8"));
+      const parsed = JSON.parse((0, import_fs15.readFileSync)(path2, "utf8"));
       const docs = /* @__PURE__ */ new Set();
       collectDocsFrom(parsed.docs_pages_used, docs);
       collectDocsFrom(parsed.docs_pages_observed, docs);
@@ -39878,44 +40833,44 @@ function readExternalAgentMetadata(runDir) {
 
 // src/lib/external-agent-executor-artifacts.ts
 function redactArtifactFile(path2, input = {}) {
-  if (!(0, import_fs15.existsSync)(path2)) return;
-  const original = (0, import_fs15.readFileSync)(path2, "utf8");
+  if (!(0, import_fs16.existsSync)(path2)) return;
+  const original = (0, import_fs16.readFileSync)(path2, "utf8");
   const redacted = redactExternalAgentArtifactText(original, input);
-  if (redacted !== original) (0, import_fs15.writeFileSync)(path2, redacted, "utf8");
+  if (redacted !== original) (0, import_fs16.writeFileSync)(path2, redacted, "utf8");
 }
 function redactExternalAgentOutputArtifacts(run, input = {}) {
   redactArtifactFile(run.outputs.jsonl, input);
   redactArtifactFile(run.outputs.last_message, input);
   redactArtifactFile(run.outputs.stderr, input);
-  redactArtifactFile((0, import_path14.join)(run.run_dir, "commands.ndjson"), input);
-  if (!(0, import_fs15.existsSync)(run.run_dir)) return;
-  for (const name of (0, import_fs15.readdirSync)(run.run_dir)) {
+  redactArtifactFile((0, import_path15.join)(run.run_dir, "commands.ndjson"), input);
+  if (!(0, import_fs16.existsSync)(run.run_dir)) return;
+  for (const name of (0, import_fs16.readdirSync)(run.run_dir)) {
     if (name.startsWith("command-output-cmd_") && !name.endsWith(".redacted")) {
-      redactArtifactFile((0, import_path14.join)(run.run_dir, name), input);
+      redactArtifactFile((0, import_path15.join)(run.run_dir, name), input);
     }
   }
 }
 function copyExternalAgentCommandCaptureArtifacts(input) {
-  const commandLog = (0, import_path14.join)(input.captureDir, "commands.ndjson");
-  if ((0, import_fs15.existsSync)(commandLog)) {
-    (0, import_fs15.writeFileSync)((0, import_path14.join)(input.runDir, "commands.ndjson"), (0, import_fs15.readFileSync)(commandLog, "utf8"), "utf8");
+  const commandLog = (0, import_path15.join)(input.captureDir, "commands.ndjson");
+  if ((0, import_fs16.existsSync)(commandLog)) {
+    (0, import_fs16.writeFileSync)((0, import_path15.join)(input.runDir, "commands.ndjson"), (0, import_fs16.readFileSync)(commandLog, "utf8"), "utf8");
   }
-  for (const name of (0, import_fs15.readdirSync)(input.captureDir)) {
+  for (const name of (0, import_fs16.readdirSync)(input.captureDir)) {
     if (name.startsWith("command-output-cmd_")) {
-      (0, import_fs15.copyFileSync)((0, import_path14.join)(input.captureDir, name), (0, import_path14.join)(input.runDir, name));
+      (0, import_fs16.copyFileSync)((0, import_path15.join)(input.captureDir, name), (0, import_path15.join)(input.runDir, name));
     } else if (EXTERNAL_AGENT_METADATA_FILENAMES.includes(name)) {
-      (0, import_fs15.copyFileSync)((0, import_path14.join)(input.captureDir, name), (0, import_path14.join)(input.runDir, name));
+      (0, import_fs16.copyFileSync)((0, import_path15.join)(input.captureDir, name), (0, import_path15.join)(input.runDir, name));
     }
   }
 }
 
 // src/lib/external-agent-executor-classification.ts
-var import_fs17 = require("fs");
-var import_path16 = require("path");
+var import_fs18 = require("fs");
+var import_path17 = require("path");
 
 // src/lib/external-agent-run-summary.ts
-var import_fs16 = require("fs");
-var import_path15 = require("path");
+var import_fs17 = require("fs");
+var import_path16 = require("path");
 var REQUIRED_RUN_FIELDS = [
   "schema_version",
   "run_id",
@@ -39939,8 +40894,8 @@ function quoteShellArg(value) {
   return `"${text.replace(/(["$`])/g, "\\$1")}"`;
 }
 function externalAgentSummaryCommand(root) {
-  const summaryPath = (0, import_path15.join)(root, "latest-summary.json");
-  const reportPath = (0, import_path15.join)(root, "summary.report.json");
+  const summaryPath = (0, import_path16.join)(root, "latest-summary.json");
+  const reportPath = (0, import_path16.join)(root, "summary.report.json");
   return [
     "foh",
     "eval",
@@ -39956,11 +40911,11 @@ function externalAgentSummaryCommand(root) {
   ].join(" ");
 }
 function readJson(filePath) {
-  return JSON.parse((0, import_fs16.readFileSync)(filePath, "utf8").replace(/^\uFEFF/, ""));
+  return JSON.parse((0, import_fs17.readFileSync)(filePath, "utf8").replace(/^\uFEFF/, ""));
 }
 function readNdjson(filePath) {
-  if (!(0, import_fs16.existsSync)(filePath)) return [];
-  return (0, import_fs16.readFileSync)(filePath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => {
+  if (!(0, import_fs17.existsSync)(filePath)) return [];
+  return (0, import_fs17.readFileSync)(filePath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => {
     try {
       const parsed = JSON.parse(line);
       return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
@@ -39986,7 +40941,7 @@ function collectDocUrls(text) {
   return Array.from(new Set((String(text || "").match(DOC_URL_RE) || []).map((url2) => url2.replace(/[.?!:]+$/g, "")).filter((url2) => url2.startsWith("https://frontofhouse.okii.uk/")))).sort();
 }
 function findRunCandidates(root) {
-  if (!(0, import_fs16.existsSync)(root)) return [];
+  if (!(0, import_fs17.existsSync)(root)) return [];
   const candidates = [];
   const seenRunDirs = /* @__PURE__ */ new Set();
   const captureDirs = [];
@@ -39994,13 +40949,13 @@ function findRunCandidates(root) {
   while (stack.length > 0) {
     const current = stack.pop();
     if (!current) continue;
-    for (const entry of (0, import_fs16.readdirSync)(current, { withFileTypes: true })) {
-      const absolute = (0, import_path15.join)(current, entry.name);
+    for (const entry of (0, import_fs17.readdirSync)(current, { withFileTypes: true })) {
+      const absolute = (0, import_path16.join)(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(absolute);
       } else if (entry.isFile() && entry.name === "run.json") {
         candidates.push({ path: absolute, synthetic: false });
-        seenRunDirs.add((0, import_path15.dirname)(absolute));
+        seenRunDirs.add((0, import_path16.dirname)(absolute));
       } else if (entry.isFile() && entry.name === "commands.ndjson") {
         captureDirs.push(current);
       }
@@ -40008,7 +40963,7 @@ function findRunCandidates(root) {
   }
   for (const captureDir of captureDirs) {
     if (seenRunDirs.has(captureDir)) continue;
-    candidates.push({ path: (0, import_path15.join)(captureDir, "run.json"), synthetic: true });
+    candidates.push({ path: (0, import_path16.join)(captureDir, "run.json"), synthetic: true });
   }
   return candidates.sort((a, b) => a.path.localeCompare(b.path));
 }
@@ -40086,9 +41041,9 @@ function syntheticStatusFromCommands(commands) {
   return { status: "pass", reasonCode: null };
 }
 function synthesizeRunFromCapture(runPath) {
-  const runDir = (0, import_path15.dirname)(runPath);
-  const commands = collapseCommandRecords(readNdjson((0, import_path15.join)(runDir, "commands.ndjson")));
-  const metadata = asObject((0, import_fs16.existsSync)((0, import_path15.join)(runDir, "external-agent-metadata.json")) ? readJson((0, import_path15.join)(runDir, "external-agent-metadata.json")) : {});
+  const runDir = (0, import_path16.dirname)(runPath);
+  const commands = collapseCommandRecords(readNdjson((0, import_path16.join)(runDir, "commands.ndjson")));
+  const metadata = asObject((0, import_fs17.existsSync)((0, import_path16.join)(runDir, "external-agent-metadata.json")) ? readJson((0, import_path16.join)(runDir, "external-agent-metadata.json")) : {});
   const blockerCodes = toArray2(metadata?.blocker_reason_codes).map(String).filter(Boolean);
   const commandClassification = syntheticStatusFromCommands(commands);
   const status = commandClassification.status === "fail" ? "fail" : blockerCodes.length > 0 ? "hold" : commandClassification.status;
@@ -40097,7 +41052,7 @@ function synthesizeRunFromCapture(runPath) {
   const startedAt = firstCommandTime(commands) || (/* @__PURE__ */ new Date(0)).toISOString();
   const endedAt = latestCommandTime(commands) || startedAt;
   const docs = toArray2(metadata?.docs_pages_used).map(String).filter(Boolean);
-  const runId = (0, import_path15.dirname)(runPath).split(/[\\/]/).filter(Boolean).slice(-3).join("-") || "capture-only-run";
+  const runId = (0, import_path16.dirname)(runPath).split(/[\\/]/).filter(Boolean).slice(-3).join("-") || "capture-only-run";
   return {
     schema_version: "external_agent_run.v1",
     run_id: runId,
@@ -40121,14 +41076,14 @@ function synthesizeRunFromCapture(runPath) {
     docs_pages_used: docs,
     artifacts: {
       command_log: "commands.ndjson",
-      agent_metadata: (0, import_fs16.existsSync)((0, import_path15.join)(runDir, "external-agent-metadata.json")) ? "external-agent-metadata.json" : null,
+      agent_metadata: (0, import_fs17.existsSync)((0, import_path16.join)(runDir, "external-agent-metadata.json")) ? "external-agent-metadata.json" : null,
       capture_only: true
     },
     summary: "Synthetic run record created from external-agent capture artifacts because run.json was missing."
   };
 }
 function cohortIdForRunPath(root, runPath) {
-  const normalized = (0, import_path15.relative)(root, (0, import_path15.dirname)(runPath)).replaceAll("\\", "/");
+  const normalized = (0, import_path16.relative)(root, (0, import_path16.dirname)(runPath)).replaceAll("\\", "/");
   const parts = normalized.split("/").filter(Boolean);
   if (parts.length === 0) return ".";
   if (/^\d{4}-\d{2}-\d{2}$/.test(parts[0]) && parts[1]) return `${parts[0]}/${parts[1]}`;
@@ -40143,7 +41098,7 @@ function readRunRecords(root, cwd) {
       const parsed = candidate.synthetic ? synthesizeRunFromCapture(file2) : readJson(file2);
       const findings = validateExternalAgentRun(parsed);
       if (findings.length > 0) {
-        invalid_runs.push({ path: (0, import_path15.relative)(cwd, file2).replaceAll("\\", "/"), findings });
+        invalid_runs.push({ path: (0, import_path16.relative)(cwd, file2).replaceAll("\\", "/"), findings });
         continue;
       }
       const run = parsed;
@@ -40155,7 +41110,7 @@ function readRunRecords(root, cwd) {
       });
     } catch (error2) {
       invalid_runs.push({
-        path: (0, import_path15.relative)(cwd, file2).replaceAll("\\", "/"),
+        path: (0, import_path16.relative)(cwd, file2).replaceAll("\\", "/"),
         findings: [{ id: "json_parse_failed", detail: error2 instanceof Error ? error2.message : String(error2) }]
       });
     }
@@ -40200,10 +41155,10 @@ function collapseCommandRecords(records) {
 function readCommandOutputJson(runDir, command) {
   const artifact = typeof command.output_artifact === "string" && command.output_artifact.trim() ? command.output_artifact.trim() : "";
   if (!artifact || artifact.includes("..") || artifact.includes("/") || artifact.includes("\\")) return null;
-  const artifactPath = (0, import_path15.join)(runDir, artifact);
-  if (!(0, import_fs16.existsSync)(artifactPath)) return null;
+  const artifactPath = (0, import_path16.join)(runDir, artifact);
+  if (!(0, import_fs17.existsSync)(artifactPath)) return null;
   try {
-    const text = (0, import_fs16.readFileSync)(artifactPath, "utf8");
+    const text = (0, import_fs17.readFileSync)(artifactPath, "utf8");
     const firstObject = text.indexOf("{");
     const lastObject = text.lastIndexOf("}");
     if (firstObject < 0 || lastObject <= firstObject) return null;
@@ -40257,8 +41212,8 @@ function commandTimingBreakdown(command, output) {
   return null;
 }
 function analyzeRunArtifacts(runPath, run, cwd) {
-  const runDir = (0, import_path15.dirname)(runPath);
-  const commands = collapseCommandRecords(readNdjson((0, import_path15.join)(runDir, "commands.ndjson")));
+  const runDir = (0, import_path16.dirname)(runPath);
+  const commands = collapseCommandRecords(readNdjson((0, import_path16.join)(runDir, "commands.ndjson")));
   const reasonCounts = /* @__PURE__ */ new Map();
   const slowSteps = [];
   const timingBreakdowns = [];
@@ -40270,7 +41225,7 @@ function analyzeRunArtifacts(runPath, run, cwd) {
     const breakdown = commandTimingBreakdown(command, output);
     if (breakdown) timingBreakdowns.push({
       run_id: run.run_id,
-      run_path: (0, import_path15.relative)(cwd, runPath).replaceAll("\\", "/"),
+      run_path: (0, import_path16.relative)(cwd, runPath).replaceAll("\\", "/"),
       ...breakdown
     });
     if (command.phase === "completed" || command.completed_at) completed += 1;
@@ -40279,7 +41234,7 @@ function analyzeRunArtifacts(runPath, run, cwd) {
       totalDuration += command.duration_ms;
       slowSteps.push({
         run_id: run.run_id,
-        run_path: (0, import_path15.relative)(cwd, runPath).replaceAll("\\", "/"),
+        run_path: (0, import_path16.relative)(cwd, runPath).replaceAll("\\", "/"),
         command: command.command || "",
         duration_ms: command.duration_ms,
         status: command.status || null,
@@ -40292,7 +41247,7 @@ function analyzeRunArtifacts(runPath, run, cwd) {
       if (reasonCode) increment(reasonCounts, reasonCode);
     }
   }
-  const codexEvents = readNdjson((0, import_path15.join)(runDir, "codex-exec.jsonl"));
+  const codexEvents = readNdjson((0, import_path16.join)(runDir, "codex-exec.jsonl"));
   const codexDocs = /* @__PURE__ */ new Set();
   let codexCommandExecutions = 0;
   let codexFailedExitCodes = 0;
@@ -40309,7 +41264,7 @@ function analyzeRunArtifacts(runPath, run, cwd) {
     ...Array.from(codexDocs)
   ]);
   return {
-    command_log_present: (0, import_fs16.existsSync)((0, import_path15.join)(runDir, "commands.ndjson")),
+    command_log_present: (0, import_fs17.existsSync)((0, import_path16.join)(runDir, "commands.ndjson")),
     command_count: commands.length,
     completed_command_count: completed,
     missing_completion_count: Math.max(0, commands.length - completed),
@@ -40324,8 +41279,8 @@ function analyzeRunArtifacts(runPath, run, cwd) {
   };
 }
 function summarizeExternalAgentRuns(options) {
-  const cwd = (0, import_path15.resolve)(options.cwd || process.cwd());
-  const root = (0, import_path15.resolve)(cwd, options.root);
+  const cwd = (0, import_path16.resolve)(options.cwd || process.cwd());
+  const root = (0, import_path16.resolve)(cwd, options.root);
   const loaded = readRunRecords(root, cwd);
   const selectedCohortId = options.cohortId || (options.currentBaselineOnly ? latestCohortId(loaded.records) : null);
   const records = selectedCohortId ? loaded.records.filter((record2) => record2.cohort_id === selectedCohortId) : loaded.records;
@@ -40380,7 +41335,7 @@ function summarizeExternalAgentRuns(options) {
   return {
     schema_version: "external_agent_run_summary.v1",
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
-    root: (0, import_path15.relative)(cwd, root).replaceAll("\\", "/") || ".",
+    root: (0, import_path16.relative)(cwd, root).replaceAll("\\", "/") || ".",
     cohort_id: selectedCohortId,
     current_baseline_only: Boolean(selectedCohortId),
     run_count: records.length,
@@ -40415,7 +41370,7 @@ function summarizeExternalAgentRuns(options) {
     },
     next_commands: nextRecommendedFix ? [`foh bug improve --from external-agent-run --file <run_dir>/run.json --json`] : [],
     invalid_runs: selectedCohortId ? [] : loaded.invalid_runs,
-    run_paths: records.map((record2) => (0, import_path15.relative)(cwd, record2.path).replaceAll("\\", "/")).sort()
+    run_paths: records.map((record2) => (0, import_path16.relative)(cwd, record2.path).replaceAll("\\", "/")).sort()
   };
 }
 function runExternalAgentRunSummary(options) {
@@ -40435,13 +41390,13 @@ function runExternalAgentRunSummary(options) {
     report: summary
   };
   if (options.out) {
-    (0, import_fs16.mkdirSync)((0, import_path15.dirname)((0, import_path15.resolve)(options.cwd || process.cwd(), options.out)), { recursive: true });
-    (0, import_fs16.writeFileSync)((0, import_path15.resolve)(options.cwd || process.cwd(), options.out), `${JSON.stringify(summary, null, 2)}
+    (0, import_fs17.mkdirSync)((0, import_path16.dirname)((0, import_path16.resolve)(options.cwd || process.cwd(), options.out)), { recursive: true });
+    (0, import_fs17.writeFileSync)((0, import_path16.resolve)(options.cwd || process.cwd(), options.out), `${JSON.stringify(summary, null, 2)}
 `, "utf8");
   }
   if (options.report) {
-    (0, import_fs16.mkdirSync)((0, import_path15.dirname)((0, import_path15.resolve)(options.cwd || process.cwd(), options.report)), { recursive: true });
-    (0, import_fs16.writeFileSync)((0, import_path15.resolve)(options.cwd || process.cwd(), options.report), `${JSON.stringify(report, null, 2)}
+    (0, import_fs17.mkdirSync)((0, import_path16.dirname)((0, import_path16.resolve)(options.cwd || process.cwd(), options.report)), { recursive: true });
+    (0, import_fs17.writeFileSync)((0, import_path16.resolve)(options.cwd || process.cwd(), options.report), `${JSON.stringify(report, null, 2)}
 `, "utf8");
   }
   return { summary, report };
@@ -40449,20 +41404,20 @@ function runExternalAgentRunSummary(options) {
 
 // src/lib/external-agent-executor-classification.ts
 function proofArtifactPasses(runDir) {
-  const proofPath = (0, import_path16.join)(runDir, "proof.json");
-  if (!(0, import_fs17.existsSync)(proofPath)) return false;
+  const proofPath = (0, import_path17.join)(runDir, "proof.json");
+  if (!(0, import_fs18.existsSync)(proofPath)) return false;
   try {
-    const parsed = JSON.parse((0, import_fs17.readFileSync)(proofPath, "utf8"));
+    const parsed = JSON.parse((0, import_fs18.readFileSync)(proofPath, "utf8"));
     return parsed.ok === true || parsed.status === "pass" || parsed.status === "passed";
   } catch {
     return false;
   }
 }
 function readIfExists(path2) {
-  return (0, import_fs17.existsSync)(path2) ? (0, import_fs17.readFileSync)(path2, "utf8") : "";
+  return (0, import_fs18.existsSync)(path2) ? (0, import_fs18.readFileSync)(path2, "utf8") : "";
 }
 function relativeArtifactName(path2) {
-  return (0, import_path16.basename)(path2);
+  return (0, import_path17.basename)(path2);
 }
 function classifyExternalAgentRun(input) {
   if (input.timedOut) return { status: "hold", reasonCode: `${input.run.command}_runner_timeout` };
@@ -40617,13 +41572,13 @@ function buildExecutedExternalAgentRunArtifact(input) {
     },
     artifacts: {
       terminal_transcript: relativeArtifactName(input.run.outputs.jsonl),
-      command_log: (0, import_fs17.existsSync)((0, import_path16.join)(input.run.run_dir, "commands.ndjson")) ? "commands.ndjson" : null,
-      proof_bundle: (0, import_fs17.existsSync)((0, import_path16.join)(input.run.run_dir, "proof.json")) ? "proof.json" : null,
-      replay_packet: (0, import_fs17.existsSync)((0, import_path16.join)(input.run.run_dir, "replay.json")) ? "replay.json" : null,
-      knowledge_packet: (0, import_fs17.existsSync)((0, import_path16.join)(input.run.run_dir, "knowledge.json")) ? "knowledge.json" : null,
+      command_log: (0, import_fs18.existsSync)((0, import_path17.join)(input.run.run_dir, "commands.ndjson")) ? "commands.ndjson" : null,
+      proof_bundle: (0, import_fs18.existsSync)((0, import_path17.join)(input.run.run_dir, "proof.json")) ? "proof.json" : null,
+      replay_packet: (0, import_fs18.existsSync)((0, import_path17.join)(input.run.run_dir, "replay.json")) ? "replay.json" : null,
+      knowledge_packet: (0, import_fs18.existsSync)((0, import_path17.join)(input.run.run_dir, "knowledge.json")) ? "knowledge.json" : null,
       improvement_packet: input.status === "pass" ? null : "improvement-packet.json",
       agent_metadata: agentMetadata.path,
-      notes: (0, import_fs17.existsSync)((0, import_path16.join)(input.run.run_dir, "notes.md")) ? "notes.md" : null,
+      notes: (0, import_fs18.existsSync)((0, import_path17.join)(input.run.run_dir, "notes.md")) ? "notes.md" : null,
       runner_last_message: relativeArtifactName(input.run.outputs.last_message),
       runner_stderr: relativeArtifactName(input.run.outputs.stderr),
       codex_last_message: input.run.command === "codex" ? relativeArtifactName(input.run.outputs.last_message) : null,
@@ -40631,25 +41586,25 @@ function buildExecutedExternalAgentRunArtifact(input) {
       artifact_safety: relativeArtifactName(input.run.outputs.artifact_safety)
     },
     summary: input.status === "pass" ? `Controlled ${input.run.command} external-agent run produced passing proof evidence.` : `Controlled ${input.run.command} external-agent run ended as ${input.status} with reason ${input.reasonCode}.`,
-    next_commands: input.status === "pass" ? [externalAgentSummaryCommand((0, import_path16.dirname)(input.run.run_dir))] : [
+    next_commands: input.status === "pass" ? [externalAgentSummaryCommand((0, import_path17.dirname)(input.run.run_dir))] : [
       "foh eval external-agent scan-artifacts --run-dir <run_dir> --private-repo-root <private_repo_root> --write-redacted --json",
       "foh bug improve --from external-agent-run --file <run_dir>/run.json --out <run_dir>/improvement-packet.json --json",
-      externalAgentSummaryCommand((0, import_path16.dirname)(input.run.run_dir))
+      externalAgentSummaryCommand((0, import_path17.dirname)(input.run.run_dir))
     ]
   };
 }
 
 // src/lib/external-agent-runner-execution.ts
-var import_child_process4 = require("child_process");
-var import_fs18 = require("fs");
-var import_path17 = require("path");
+var import_child_process5 = require("child_process");
+var import_fs19 = require("fs");
+var import_path18 = require("path");
 function buildCommandInvocation(command, args) {
   if (process.platform === "win32" && command.toLowerCase().endsWith(".cmd")) {
-    const binDir = (0, import_path17.dirname)(command);
-    const codexEntrypoint = (0, import_path17.join)(binDir, "node_modules", "@openai", "codex", "bin", "codex.js");
-    if ((0, import_fs18.existsSync)(codexEntrypoint)) return { command: process.execPath, args: [codexEntrypoint, ...args] };
-    const geminiEntrypoint = (0, import_path17.join)(binDir, "node_modules", "@google", "gemini-cli", "bundle", "gemini.js");
-    if ((0, import_fs18.existsSync)(geminiEntrypoint)) return { command: process.execPath, args: ["--no-warnings=DEP0040", geminiEntrypoint, ...args] };
+    const binDir = (0, import_path18.dirname)(command);
+    const codexEntrypoint = (0, import_path18.join)(binDir, "node_modules", "@openai", "codex", "bin", "codex.js");
+    if ((0, import_fs19.existsSync)(codexEntrypoint)) return { command: process.execPath, args: [codexEntrypoint, ...args] };
+    const geminiEntrypoint = (0, import_path18.join)(binDir, "node_modules", "@google", "gemini-cli", "bundle", "gemini.js");
+    if ((0, import_fs19.existsSync)(geminiEntrypoint)) return { command: process.execPath, args: ["--no-warnings=DEP0040", geminiEntrypoint, ...args] };
   }
   return { command, args };
 }
@@ -40657,15 +41612,15 @@ function spawnExternalAgentRunner(input) {
   return new Promise((resolveRun) => {
     const started = Date.now();
     const commandInvocation = buildCommandInvocation(input.command, input.args);
-    const child = (0, import_child_process4.spawn)(commandInvocation.command, commandInvocation.args, {
+    const child = (0, import_child_process5.spawn)(commandInvocation.command, commandInvocation.args, {
       cwd: input.cwd,
       env: input.env,
       shell: false,
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
-    const stdout = (0, import_fs18.createWriteStream)(input.stdoutPath, { flags: "w" });
-    const stderr = (0, import_fs18.createWriteStream)(input.stderrPath, { flags: "w" });
+    const stdout = (0, import_fs19.createWriteStream)(input.stdoutPath, { flags: "w" });
+    const stderr = (0, import_fs19.createWriteStream)(input.stderrPath, { flags: "w" });
     child.stdout.pipe(stdout);
     child.stderr.pipe(stderr);
     child.stdin.end(input.prompt);
@@ -40673,7 +41628,7 @@ function spawnExternalAgentRunner(input) {
     const timer = setTimeout(() => {
       timedOut = true;
       if (child.pid && process.platform === "win32") {
-        (0, import_child_process4.spawnSync)("taskkill.exe", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore" });
+        (0, import_child_process5.spawnSync)("taskkill.exe", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore" });
       } else {
         child.kill("SIGKILL");
       }
@@ -40777,14 +41732,14 @@ async function runExternalAgentEvalAuthPreflight(env = process.env, options = {}
   };
 }
 function normalizeForCompare(path2) {
-  const resolved = (0, import_path18.resolve)(path2);
+  const resolved = (0, import_path19.resolve)(path2);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function isPathInside(childPath, parentPath) {
   const child = normalizeForCompare(childPath);
   const parent = normalizeForCompare(parentPath);
-  const rel = (0, import_path18.relative)(parent, child);
-  return rel === "" || !!rel && !rel.startsWith("..") && !(0, import_path18.isAbsolute)(rel);
+  const rel = (0, import_path19.relative)(parent, child);
+  return rel === "" || !!rel && !rel.startsWith("..") && !(0, import_path19.isAbsolute)(rel);
 }
 function requireString(value, field) {
   if (typeof value !== "string" || value.trim() === "") {
@@ -40793,10 +41748,10 @@ function requireString(value, field) {
   return value;
 }
 function readBatch(batchPath) {
-  if (!(0, import_fs19.existsSync)(batchPath)) {
+  if (!(0, import_fs20.existsSync)(batchPath)) {
     throw new ExternalAgentExecutorError("external_agent_batch_not_found", `Batch file not found: ${batchPath}`);
   }
-  const parsed = JSON.parse((0, import_fs19.readFileSync)(batchPath, "utf8"));
+  const parsed = JSON.parse((0, import_fs20.readFileSync)(batchPath, "utf8"));
   if (parsed.schema_version !== "external_agent_batch_plan.v1") {
     throw new ExternalAgentExecutorError("invalid_external_agent_batch", "Batch schema_version must be external_agent_batch_plan.v1.");
   }
@@ -40811,11 +41766,11 @@ function defaultRunnerProbe(command, args) {
     encoding: "utf8",
     timeout: isGeminiHeadlessSmoke ? GEMINI_HEADLESS_PROBE_TIMEOUT_MS : void 0
   };
-  const result = process.platform === "win32" && command.toLowerCase().endsWith(".cmd") ? (0, import_child_process5.spawnSync)(
+  const result = process.platform === "win32" && command.toLowerCase().endsWith(".cmd") ? (0, import_child_process6.spawnSync)(
     "powershell.exe",
     ["-NoLogo", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", `& ${[command, ...args].map(quotePowerShellArg).join(" ")}`],
     spawnOptions
-  ) : (0, import_child_process5.spawnSync)(command, args, spawnOptions);
+  ) : (0, import_child_process6.spawnSync)(command, args, spawnOptions);
   return {
     status: typeof result.status === "number" ? result.status : null,
     stdout: String(result.stdout || ""),
@@ -40833,8 +41788,8 @@ function resolveCodexProbeCommand() {
   if (process.platform !== "win32") return "codex";
   const appData = process.env.APPDATA;
   if (appData) {
-    const appDataShim = (0, import_path18.join)(appData, "npm", "codex.cmd");
-    if ((0, import_fs19.existsSync)(appDataShim)) return appDataShim;
+    const appDataShim = (0, import_path19.join)(appData, "npm", "codex.cmd");
+    if ((0, import_fs20.existsSync)(appDataShim)) return appDataShim;
   }
   return "codex.cmd";
 }
@@ -40845,8 +41800,8 @@ function resolveGeminiProbeCommand() {
   if (process.platform !== "win32") return "gemini";
   const appData = process.env.APPDATA;
   if (appData) {
-    const appDataShim = (0, import_path18.join)(appData, "npm", "gemini.cmd");
-    if ((0, import_fs19.existsSync)(appDataShim)) return appDataShim;
+    const appDataShim = (0, import_path19.join)(appData, "npm", "gemini.cmd");
+    if ((0, import_fs20.existsSync)(appDataShim)) return appDataShim;
   }
   return "gemini.cmd";
 }
@@ -41117,35 +42072,35 @@ function safeRunId(value) {
   return value.toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "") || "run";
 }
 function resolveWorkspaceRoot(input) {
-  if (input.workspaceRoot) return (0, import_path18.resolve)(input.workspaceRoot);
-  const batchStem = (0, import_path18.basename)((0, import_path18.resolve)(input.batchPath)).replace(/[^a-zA-Z0-9_.-]+/g, "-");
-  const repoStem = (0, import_path18.basename)((0, import_path18.resolve)(input.privateRepoRoot)).replace(/[^a-zA-Z0-9_.-]+/g, "-");
-  return (0, import_path18.resolve)((0, import_os2.tmpdir)(), "foh-external-agent-workspaces", repoStem, batchStem);
+  if (input.workspaceRoot) return (0, import_path19.resolve)(input.workspaceRoot);
+  const batchStem = (0, import_path19.basename)((0, import_path19.resolve)(input.batchPath)).replace(/[^a-zA-Z0-9_.-]+/g, "-");
+  const repoStem = (0, import_path19.basename)((0, import_path19.resolve)(input.privateRepoRoot)).replace(/[^a-zA-Z0-9_.-]+/g, "-");
+  return (0, import_path19.resolve)((0, import_os3.tmpdir)(), "foh-external-agent-workspaces", repoStem, batchStem);
 }
 function findNearestGitRoot(startPath) {
-  let current = (0, import_path18.resolve)(startPath);
+  let current = (0, import_path19.resolve)(startPath);
   while (true) {
-    if ((0, import_fs19.existsSync)((0, import_path18.join)(current, ".git"))) return current;
-    const parent = (0, import_path18.dirname)(current);
+    if ((0, import_fs20.existsSync)((0, import_path19.join)(current, ".git"))) return current;
+    const parent = (0, import_path19.dirname)(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function resolvePrivateRepoRoot(input) {
   if (input.explicitPrivateRepoRoot) {
-    return { root: (0, import_path18.resolve)(input.explicitPrivateRepoRoot), explicit: true };
+    return { root: (0, import_path19.resolve)(input.explicitPrivateRepoRoot), explicit: true };
   }
-  const cwd = (0, import_path18.resolve)(input.cwd || process.cwd());
+  const cwd = (0, import_path19.resolve)(input.cwd || process.cwd());
   const gitRoot = findNearestGitRoot(cwd);
   if (gitRoot) return { root: gitRoot, explicit: false };
   return {
-    root: (0, import_path18.join)(cwd, ".foh-no-private-repo-root-sentinel"),
+    root: (0, import_path19.join)(cwd, ".foh-no-private-repo-root-sentinel"),
     explicit: false
   };
 }
 function promptVersionFromPath(promptPath) {
-  const raw = (0, import_fs19.readFileSync)(promptPath, "utf8");
-  if (raw.includes("arbitrary-agency setup context") || raw.includes("Mission: prove whether an arbitrary estate agency") || raw.includes("ops reporting agency-setup-preview")) return "arbitrary-agency-setup-release.v1";
+  const raw = (0, import_fs20.readFileSync)(promptPath, "utf8");
+  if (raw.includes("arbitrary-agency setup context") || raw.includes("Mission: prove whether an arbitrary estate agency") || raw.includes("ops reporting agency-setup-preview") || raw.includes("ops reporting agency-setup-workflow")) return "arbitrary-agency-setup-release.v1";
   if (raw.includes("Do not assume access to the private source repository")) return "blank-setup.v1";
   return "unknown";
 }
@@ -41154,7 +42109,7 @@ function createExternalAgentExecutorPlan(options) {
   if (runner !== "codex" && runner !== "gemini") {
     throw new ExternalAgentExecutorError("unsupported_external_agent_runner", `Unsupported runner: ${runner}`);
   }
-  const batchPath = (0, import_path18.resolve)(options.batchPath);
+  const batchPath = (0, import_path19.resolve)(options.batchPath);
   const batch = readBatch(batchPath);
   const runnerProbe = validateRunner(options, runner);
   const codexSandboxBackend = normalizeCodexSandboxBackend(options.codexSandboxBackend);
@@ -41173,17 +42128,17 @@ function createExternalAgentExecutorPlan(options) {
       `Workspace root must be outside the private repository. workspace=${workspaceRoot} repo=${privateRepoRoot}`
     );
   }
-  (0, import_fs19.mkdirSync)(workspaceRoot, { recursive: true });
-  const batchDir = (0, import_path18.resolve)(String(batch.batch_dir || (0, import_path18.resolve)(batchPath, "..")));
+  (0, import_fs20.mkdirSync)(workspaceRoot, { recursive: true });
+  const batchDir = (0, import_path19.resolve)(String(batch.batch_dir || (0, import_path19.resolve)(batchPath, "..")));
   const timeoutMinutes = Number.isFinite(options.timeoutMinutes) && Number(options.timeoutMinutes) > 0 ? Number(options.timeoutMinutes) : 30;
   const runs = batch.runs.map((run) => {
     const runId = safeRunId(requireString(run.run_id, "runs[].run_id"));
-    const runDir = (0, import_path18.resolve)(requireString(run.run_dir, `runs[${runId}].run_dir`));
-    const promptPath = (0, import_path18.resolve)(requireString(run.prompt_path, `runs[${runId}].prompt_path`));
-    const workspaceDir = (0, import_path18.join)(workspaceRoot, runId);
-    (0, import_fs19.mkdirSync)(workspaceDir, { recursive: true });
-    (0, import_fs19.writeFileSync)(
-      (0, import_path18.join)(workspaceDir, "README.md"),
+    const runDir = (0, import_path19.resolve)(requireString(run.run_dir, `runs[${runId}].run_dir`));
+    const promptPath = (0, import_path19.resolve)(requireString(run.prompt_path, `runs[${runId}].prompt_path`));
+    const workspaceDir = (0, import_path19.join)(workspaceRoot, runId);
+    (0, import_fs20.mkdirSync)(workspaceDir, { recursive: true });
+    (0, import_fs20.writeFileSync)(
+      (0, import_path19.join)(workspaceDir, "README.md"),
       [
         "# FOH External-Agent Workspace",
         "",
@@ -41201,11 +42156,11 @@ function createExternalAgentExecutorPlan(options) {
     });
     const promptVersion = String(env[EXTERNAL_AGENT_PROMPT_VERSION_ENV] || "unknown");
     const outputStem = runner === "gemini" ? "gemini" : "codex";
-    const jsonlPath = (0, import_path18.join)(runDir, `${outputStem}-exec.jsonl`);
-    const lastMessagePath = (0, import_path18.join)(runDir, `${outputStem}-last-message.md`);
-    const stderrPath = (0, import_path18.join)(runDir, `${outputStem}-stderr.txt`);
-    const runPath = (0, import_path18.join)(runDir, "run.json");
-    const artifactSafetyPath = (0, import_path18.join)(runDir, "artifact-safety.json");
+    const jsonlPath = (0, import_path19.join)(runDir, `${outputStem}-exec.jsonl`);
+    const lastMessagePath = (0, import_path19.join)(runDir, `${outputStem}-last-message.md`);
+    const stderrPath = (0, import_path19.join)(runDir, `${outputStem}-stderr.txt`);
+    const runPath = (0, import_path19.join)(runDir, "run.json");
+    const artifactSafetyPath = (0, import_path19.join)(runDir, "artifact-safety.json");
     const args = runner === "gemini" ? [
       ...runnerProbe.globalArgs,
       ...runnerProbe.execArgs
@@ -41296,9 +42251,9 @@ function createExternalAgentExecutorPlan(options) {
   };
 }
 function writeExternalAgentExecutorPlan(plan) {
-  const path2 = (0, import_path18.join)(plan.batch_dir, "executor-plan.json");
-  (0, import_fs19.mkdirSync)(plan.batch_dir, { recursive: true });
-  (0, import_fs19.writeFileSync)(path2, `${JSON.stringify(plan, null, 2)}
+  const path2 = (0, import_path19.join)(plan.batch_dir, "executor-plan.json");
+  (0, import_fs20.mkdirSync)(plan.batch_dir, { recursive: true });
+  (0, import_fs20.writeFileSync)(path2, `${JSON.stringify(plan, null, 2)}
 `, "utf8");
   return path2;
 }
@@ -41313,7 +42268,7 @@ async function executeExternalAgentExecutorPlan(plan, options = {}) {
   if (authPreflight && !authPreflight.ok) {
     const endedAt2 = (/* @__PURE__ */ new Date()).toISOString();
     const blockedResults = plan.runs.map((run) => {
-      (0, import_fs19.mkdirSync)(run.run_dir, { recursive: true });
+      (0, import_fs20.mkdirSync)(run.run_dir, { recursive: true });
       const runArtifact = buildExecutedExternalAgentRunArtifact({
         run,
         startedAt,
@@ -41324,7 +42279,7 @@ async function executeExternalAgentExecutorPlan(plan, options = {}) {
         timedOut: false,
         durationMs: 0
       });
-      (0, import_fs19.writeFileSync)(run.outputs.run, `${JSON.stringify(runArtifact, null, 2)}
+      (0, import_fs20.writeFileSync)(run.outputs.run, `${JSON.stringify(runArtifact, null, 2)}
 `, "utf8");
       return {
         run_id: run.run_id,
@@ -41351,8 +42306,8 @@ async function executeExternalAgentExecutorPlan(plan, options = {}) {
   }
   for (const run of plan.runs) {
     const runStartedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const commandCaptureDir = (0, import_path18.join)(run.workspace_dir, ".foh-capture");
-    (0, import_fs19.mkdirSync)(commandCaptureDir, { recursive: true });
+    const commandCaptureDir = (0, import_path19.join)(run.workspace_dir, ".foh-capture");
+    (0, import_fs20.mkdirSync)(commandCaptureDir, { recursive: true });
     const env = buildCodexExecutorEnv({
       sourceEnv: options.env,
       runDir: commandCaptureDir,
@@ -41363,7 +42318,7 @@ async function executeExternalAgentExecutorPlan(plan, options = {}) {
       args: run.args,
       cwd: run.workspace_dir,
       env,
-      prompt: (0, import_fs19.readFileSync)(run.prompt_path, "utf8"),
+      prompt: (0, import_fs20.readFileSync)(run.prompt_path, "utf8"),
       stdoutPath: run.outputs.jsonl,
       stderrPath: run.outputs.stderr,
       timeoutMs: plan.timeout_minutes * 60 * 1e3
@@ -41376,7 +42331,7 @@ async function executeExternalAgentExecutorPlan(plan, options = {}) {
       privateRepoRoot,
       writeRedacted: true
     });
-    (0, import_fs19.writeFileSync)(run.outputs.artifact_safety, `${JSON.stringify(artifactSafety, null, 2)}
+    (0, import_fs20.writeFileSync)(run.outputs.artifact_safety, `${JSON.stringify(artifactSafety, null, 2)}
 `, "utf8");
     const runEndedAt = (/* @__PURE__ */ new Date()).toISOString();
     const classification = classifyExternalAgentRun({
@@ -41395,7 +42350,7 @@ async function executeExternalAgentExecutorPlan(plan, options = {}) {
       timedOut: spawned.timedOut,
       durationMs: spawned.durationMs
     });
-    (0, import_fs19.writeFileSync)(run.outputs.run, `${JSON.stringify(runArtifact, null, 2)}
+    (0, import_fs20.writeFileSync)(run.outputs.run, `${JSON.stringify(runArtifact, null, 2)}
 `, "utf8");
     results.push({
       run_id: run.run_id,
@@ -41434,7 +42389,7 @@ var PROMPTS = {
   "real-estate-seller-valuation.v1": "Go to https://frontofhouse.okii.uk. Use only public docs, public API docs, and the public npm CLI package. Always invoke the CLI with `npx --yes @f-o-h/cli@latest ...`; do not use unpinned `npx @f-o-h/cli ...`. Do not assume access to the private source repository. Mission: configure a seller-valuation real-estate agent, prove valuation lead capture on widget and voice, and keep strict no-spend behavior. Required path: 1) verify auth/org scope and reuse existing eval state; 2) select/apply seller valuation template; 3) configure widget + voice; 4) run widget smoke and release certification; 5) run voice proof and classify holds. Do not claim precise valuation output without approved tooling; safe fallback or handoff must remain explicit. Do not buy numbers. Final artifact must include: selected template id/slug, lead fields observed, tool/action behavior, reason codes, docs_pages_used, and next fix commands.",
   "real-estate-viewing-and-qa.v1": "Go to https://frontofhouse.okii.uk. Use only public docs, public API docs, and the public npm CLI package. Always invoke the CLI with `npx --yes @f-o-h/cli@latest ...`; do not use unpinned `npx @f-o-h/cli ...`. Do not assume access to the private source repository. Mission: configure a viewing-booking/property-QA real-estate agent and prove booking-safe behavior under no-spend policy. Required path: 1) verify auth/org scope and reuse existing eval state; 2) select/apply viewing template; 3) configure widget + voice; 4) run widget smoke, release certification, and voice proof; 5) explicitly check no-duplicate-side-effect behavior and safe fallback/handoff when booking tooling or contact path is unavailable. Do not buy numbers. Final artifact must include: selected template id/slug, booking/fallback evidence, reason codes, docs_pages_used, and next fix commands.",
   "real-estate-landlord-enquiry.v1": "Go to https://frontofhouse.okii.uk. Use only public docs, public API docs, and the public npm CLI package. Always invoke the CLI with `npx --yes @f-o-h/cli@latest ...`; do not use unpinned `npx @f-o-h/cli ...`. Do not assume access to the private source repository. Mission: configure a landlord-enquiry real-estate agent and prove lead capture + safe escalation under no-spend constraints. Required path: 1) verify auth/org scope and reuse existing eval state; 2) select/apply landlord template; 3) configure widget + voice; 4) run widget smoke, release certification, and voice proof; 5) ensure handoff/escalation remains reason-coded and no-silent-drop. Do not buy numbers. Final artifact must include: selected template id/slug, lead/action/handoff evidence summary, reason codes, docs_pages_used, and next fix commands.",
-  "arbitrary-agency-setup-release.v1": "Go to https://frontofhouse.okii.uk. Use only public docs, public API docs, the deployed production API, and the public npm CLI package. Always invoke the CLI with `npx --yes @f-o-h/cli@latest ...`; do not use unpinned `npx @f-o-h/cli ...`, local source, private repo scripts, or unpublished commands. Do not assume access to the private source repository. Mission: prove whether an arbitrary estate agency can be set up or accurately held using the public launch evidence workflow. Required path: 1) verify CLI version and auth/org scope; 2) run `foh ops reporting agency-setup-preview` with the supplied agency name, official source URL, branch location, requested tool surface, and target mode; 3) run `foh ops reporting launch-packet --json`; 4) run `foh ops reporting launch-packet-skeletons --json`; 5) run `foh ops reporting launch-packet-evidence-check --json` only with redacted synthetic or customer-provided evidence, never raw credentials or secrets; 6) classify the outcome as pass, expected hold, or product failure. No-spend boundary: do not buy phone numbers, provision paid resources, scrape private systems, bypass credential holds, or claim live/customer-ready/production unless the launch packet explicitly allows it. Expected holds such as missing customer credentials, missing behavior approval, missing live voice validation, or missing production signoff are acceptable only when the commands expose clear reason codes and next actions. Final artifact must include commands executed, docs_pages_used, manual_intervention_count, CLI/API version readback, launch mode observed, reason codes, evidence artifacts created, and exact next commands. If `FOH_EXTERNAL_AGENT_RUN_DIR` is set, write `${FOH_EXTERNAL_AGENT_RUN_DIR}/external-agent-metadata.json` with `schema_version`, `docs_pages_used`, key decisions, and blocker reason codes before finishing.",
+  "arbitrary-agency-setup-release.v1": "Go to https://frontofhouse.okii.uk. Use only public docs, public API docs, the deployed production API, and the public npm CLI package. Always invoke the CLI with `npx --yes @f-o-h/cli@latest ...`; do not use unpinned `npx @f-o-h/cli ...`, local source, private repo scripts, or unpublished commands. Do not assume access to the private source repository. Mission: prove whether an arbitrary estate agency can be set up or accurately held using the public launch evidence workflow. Required path: 1) verify CLI version and auth/org scope; 2) run `foh ops reporting agency-setup-workflow` with the supplied agency name, official source URL, branch location, requested tool surface, and target mode; 3) inspect the returned setup dossier, launch packet, evidence packet, operator status, no-overclaim decision, and proof commands; 4) run `foh ops reporting launch-packet-evidence-check --json` only with redacted synthetic or customer-provided evidence, never raw credentials or secrets; 5) run `foh ops reporting customer-live-status --json`; 6) classify the outcome as pass, expected hold, or product failure. No-spend boundary: do not buy phone numbers, provision paid resources, scrape private systems, bypass credential holds, or claim live/customer-ready/production unless the launch packet explicitly allows it. Expected holds such as missing customer credentials, missing behavior approval, missing live voice validation, or missing production signoff are acceptable only when the commands expose clear reason codes and next actions. Final artifact must include commands executed, docs_pages_used, manual_intervention_count, CLI/API version readback, launch mode observed, reason codes, evidence artifacts created, and exact next commands. If `FOH_EXTERNAL_AGENT_RUN_DIR` is set, write `${FOH_EXTERNAL_AGENT_RUN_DIR}/external-agent-metadata.json` with `schema_version`, `docs_pages_used`, key decisions, and blocker reason codes before finishing.",
   "debug-proof-failure.v1": "You are given a FOH proof or debug artifact. Use public docs and FOH CLI/API behavior to classify whether the blocker is docs, auth, org setup, agent config, widget, channel, runtime, or product bug. Produce a redacted improvement packet or the exact command needed to produce one. Do not ask the human to interpret logs manually unless no machine-readable artifact exists.",
   "knowledge-miss.v1": "A FOH agent failed to answer a business question. Use CLI/API/docs to determine whether this is a knowledge-ingestion issue, retrieval issue, config issue, prompt/behavior issue, or runtime issue. Prefer foh knowledge query, transcript export, replay, and foh bug improve artifacts over screenshots.",
   "replay-failure.v1": "You are given a FOH transcript or replay artifact. Use CLI/API/docs to replay or inspect the failed interaction, identify expected vs actual behavior, and produce a scenario-test or improvement-packet candidate."
@@ -41449,13 +42404,13 @@ function defaultRunDir(modelName, promptVersion) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace("T", "-").slice(0, 23);
   const safeModel = String(modelName || "unknown-model").toLowerCase().replace(/[^a-z0-9_-]+/g, "-");
   const safePrompt = String(promptVersion || DEFAULT_PROMPT_VERSION).toLowerCase().replace(/[^a-z0-9_.-]+/g, "-");
-  return (0, import_path19.resolve)("test-results", "external-agent-runs", date4, `${safeModel}-${safePrompt}-${stamp}`);
+  return (0, import_path20.resolve)("test-results", "external-agent-runs", date4, `${safeModel}-${safePrompt}-${stamp}`);
 }
 function defaultBatchDir(promptVersion) {
   const date4 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace("T", "-").slice(0, 23);
   const safePrompt = String(promptVersion || DEFAULT_PROMPT_VERSION).toLowerCase().replace(/[^a-z0-9_.-]+/g, "-");
-  return (0, import_path19.resolve)("test-results", "external-agent-runs", date4, `batch-${safePrompt}-${stamp}`);
+  return (0, import_path20.resolve)("test-results", "external-agent-runs", date4, `batch-${safePrompt}-${stamp}`);
 }
 function safeSlug(value) {
   return String(value || "unknown").toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
@@ -41572,7 +42527,7 @@ function agencySetupPromptContext(context = {}) {
   const targetMode = String(context.targetMode || "").trim();
   if (!agencyName && !sourceUrl && !branchLocation && !targetMode) return "";
   const previewArgs = [
-    "ops reporting agency-setup-preview",
+    "ops reporting agency-setup-workflow",
     agencyName ? `--agency-name ${quoteArg(agencyName)}` : "--agency-name <agency-name>",
     sourceUrl ? `--source-url ${quoteArg(sourceUrl)}` : "--source-url <official-source-url>",
     branchLocation ? `--branch-location ${quoteArg(branchLocation)}` : "--branch-location <branch-location>",
@@ -41587,7 +42542,7 @@ function agencySetupPromptContext(context = {}) {
     ...branchLocation ? [`- Branch/location: ${branchLocation}`] : [],
     ...targetMode ? [`- Target mode: ${targetMode}`] : [],
     `- Start with: npx --yes @f-o-h/cli@latest ${previewArgs}`,
-    "- Then run launch-packet, launch-packet-skeletons, and launch-packet-evidence-check using public CLI commands only.",
+    "- Then inspect the workflow output and run only the returned proof/evidence commands using public CLI commands.",
     "- Treat missing customer credentials or approvals as expected holds only if the CLI gives machine-readable reason codes and next actions."
   ].join("\n");
 }
@@ -41598,14 +42553,14 @@ function writePrompt(runDir, promptVersion, context = {}) {
     knowledgeMissPromptContext(context.knowledgeQuestion, context.expectedAnswer),
     agencySetupPromptContext(context)
   ].join("");
-  const path2 = (0, import_path19.join)(runDir, "prompt.txt");
-  (0, import_fs20.writeFileSync)(path2, `${prompt}
+  const path2 = (0, import_path20.join)(runDir, "prompt.txt");
+  (0, import_fs21.writeFileSync)(path2, `${prompt}
 `, "utf8");
   return path2;
 }
 function writeSession(runDir, session) {
-  const path2 = (0, import_path19.join)(runDir, "session.json");
-  (0, import_fs20.writeFileSync)(path2, `${JSON.stringify(session, null, 2)}
+  const path2 = (0, import_path20.join)(runDir, "session.json");
+  (0, import_fs21.writeFileSync)(path2, `${JSON.stringify(session, null, 2)}
 `, "utf8");
   return path2;
 }
@@ -41685,9 +42640,9 @@ function buildRunArtifact(input) {
       notes: "notes.md"
     },
     summary: status === "pass" ? "External-agent capture session completed and was marked pass." : `External-agent capture session completed with ${commands.length} captured FOH command(s); classify and improve reason ${reasonCode}.`,
-    next_commands: status === "pass" ? [externalAgentSummaryCommand((0, import_path19.dirname)(input.runDir))] : [
-      `foh bug improve --from external-agent-run --file ${(0, import_path19.join)(input.runDir, "run.json")} --out ${(0, import_path19.join)(input.runDir, "improvement-packet.json")} --json`,
-      externalAgentSummaryCommand((0, import_path19.dirname)(input.runDir))
+    next_commands: status === "pass" ? [externalAgentSummaryCommand((0, import_path20.dirname)(input.runDir))] : [
+      `foh bug improve --from external-agent-run --file ${(0, import_path20.join)(input.runDir, "run.json")} --out ${(0, import_path20.join)(input.runDir, "improvement-packet.json")} --json`,
+      externalAgentSummaryCommand((0, import_path20.dirname)(input.runDir))
     ]
   };
 }
@@ -41696,8 +42651,8 @@ function registerEval(program3) {
   const external = evalCommand.command("external-agent").description("Capture clean external coding-agent setup attempts");
   external.command("batch").description("Create a deterministic multi-model external-agent batch plan").option("--models <list>", "Comma-separated provider/model list", DEFAULT_BATCH_MODELS).option("--prompt-version <version>", "Prompt version", DEFAULT_PROMPT_VERSION).option("--replay-file <path>", "Local transcript/replay artifact to seed replay-failure prompts").option("--knowledge-question <text>", "Question to seed knowledge-miss prompts").option("--expected-answer <text>", "Expected answer or missing fact for planted knowledge-miss prompts").option("--agency-name <name>", "Agency name to seed arbitrary-agency setup prompts").option("--source-url <url>", "Official source URL to seed arbitrary-agency setup prompts").option("--branch-location <value>", "Branch/location to seed arbitrary-agency setup prompts").option("--target-mode <mode>", "Target launch/exposure mode for arbitrary-agency setup prompts").option("--workspace-type <type>", "Workspace type label", "clean-no-repo").option("--agent-shell <name>", "Agent shell label", "vscode-terminal").option("--out-dir <path>", "Batch output directory").option("--json", "Output as JSON").action(async (opts) => {
     const promptVersion = String(opts.promptVersion || DEFAULT_PROMPT_VERSION);
-    const batchDir = (0, import_path19.resolve)(String(opts.outDir || defaultBatchDir(promptVersion)));
-    const replayFile = opts.replayFile ? (0, import_path19.resolve)(String(opts.replayFile)) : void 0;
+    const batchDir = (0, import_path20.resolve)(String(opts.outDir || defaultBatchDir(promptVersion)));
+    const replayFile = opts.replayFile ? (0, import_path20.resolve)(String(opts.replayFile)) : void 0;
     const knowledgeQuestion = opts.knowledgeQuestion ? String(opts.knowledgeQuestion) : void 0;
     const expectedAnswer = opts.expectedAnswer ? String(opts.expectedAnswer) : void 0;
     const agencyName = opts.agencyName ? String(opts.agencyName) : void 0;
@@ -41705,11 +42660,11 @@ function registerEval(program3) {
     const branchLocation = opts.branchLocation ? String(opts.branchLocation) : void 0;
     const targetMode = opts.targetMode ? String(opts.targetMode) : void 0;
     const models = parseModelList(String(opts.models || DEFAULT_BATCH_MODELS));
-    (0, import_fs20.mkdirSync)(batchDir, { recursive: true });
+    (0, import_fs21.mkdirSync)(batchDir, { recursive: true });
     const runs2 = models.map((model, index) => {
       const runId = `${String(index + 1).padStart(2, "0")}-${safeSlug(model.provider)}-${safeSlug(model.name)}`;
-      const runDir = (0, import_path19.join)(batchDir, runId);
-      (0, import_fs20.mkdirSync)(runDir, { recursive: true });
+      const runDir = (0, import_path20.join)(batchDir, runId);
+      (0, import_fs21.mkdirSync)(runDir, { recursive: true });
       const promptPath = writePrompt(runDir, promptVersion, {
         replayFile,
         knowledgeQuestion,
@@ -41772,8 +42727,8 @@ function registerEval(program3) {
       runs: runs2,
       summary_command: externalAgentSummaryCommand(batchDir)
     };
-    const batchPath = (0, import_path19.join)(batchDir, "batch.json");
-    (0, import_fs20.writeFileSync)(batchPath, `${JSON.stringify(batch, null, 2)}
+    const batchPath = (0, import_path20.join)(batchDir, "batch.json");
+    (0, import_fs21.writeFileSync)(batchPath, `${JSON.stringify(batch, null, 2)}
 `, "utf8");
     format(cliEnvelope({
       schemaVersion: "external_agent_batch_plan_result.v1",
@@ -41793,15 +42748,15 @@ function registerEval(program3) {
   external.command("run").description("Launch an instrumented shell and emit external_agent_run.v1 when it exits").option("--model-provider <name>", "Model provider label", "unknown").option("--model-name <name>", "Model name label", "unknown-model").option("--prompt-version <version>", "Prompt version", DEFAULT_PROMPT_VERSION).option("--replay-file <path>", "Local transcript/replay artifact to seed replay-failure prompts").option("--knowledge-question <text>", "Question to seed knowledge-miss prompts").option("--expected-answer <text>", "Expected answer or missing fact for planted knowledge-miss prompts").option("--agency-name <name>", "Agency name to seed arbitrary-agency setup prompts").option("--source-url <url>", "Official source URL to seed arbitrary-agency setup prompts").option("--branch-location <value>", "Branch/location to seed arbitrary-agency setup prompts").option("--target-mode <mode>", "Target launch/exposure mode for arbitrary-agency setup prompts").option("--workspace-type <type>", "Workspace type label", "clean-no-repo").option("--agent-shell <name>", "Agent shell label", "vscode-terminal").option("--out-dir <path>", "Run output directory").option("--status <status>", "Final status when not interactively classified: pass|hold|fail", "hold").option("--reason-code <code>", "Failure/hold reason code", "external_agent_run_needs_review").option("--shell <command>", "Shell command to launch for capture").option("--no-shell", "Do not launch a shell; create/finalize artifacts immediately").option("--json", "Output as JSON").action(async (opts) => {
     const status = normalizeStatus(opts.status);
     const promptVersion = String(opts.promptVersion || DEFAULT_PROMPT_VERSION);
-    const runDir = (0, import_path19.resolve)(String(opts.outDir || defaultRunDir(opts.modelName, promptVersion)));
-    const replayFile = opts.replayFile ? (0, import_path19.resolve)(String(opts.replayFile)) : void 0;
+    const runDir = (0, import_path20.resolve)(String(opts.outDir || defaultRunDir(opts.modelName, promptVersion)));
+    const replayFile = opts.replayFile ? (0, import_path20.resolve)(String(opts.replayFile)) : void 0;
     const knowledgeQuestion = opts.knowledgeQuestion ? String(opts.knowledgeQuestion) : void 0;
     const expectedAnswer = opts.expectedAnswer ? String(opts.expectedAnswer) : void 0;
     const agencyName = opts.agencyName ? String(opts.agencyName) : void 0;
     const sourceUrl = opts.sourceUrl ? String(opts.sourceUrl) : void 0;
     const branchLocation = opts.branchLocation ? String(opts.branchLocation) : void 0;
     const targetMode = opts.targetMode ? String(opts.targetMode) : void 0;
-    (0, import_fs20.mkdirSync)(runDir, { recursive: true });
+    (0, import_fs21.mkdirSync)(runDir, { recursive: true });
     const runId = runDir.split(/[\\/]/).filter(Boolean).slice(-1)[0];
     const promptPath = writePrompt(runDir, promptVersion, {
       replayFile,
@@ -41839,7 +42794,7 @@ function registerEval(program3) {
       }
     };
     writeSession(runDir, session);
-    (0, import_fs20.writeFileSync)((0, import_path19.join)(runDir, "notes.md"), "# External Agent Run Notes\n\n", "utf8");
+    (0, import_fs21.writeFileSync)((0, import_path20.join)(runDir, "notes.md"), "# External Agent Run Notes\n\n", "utf8");
     let shellExitCode = null;
     if (opts.shell !== false) {
       process.stdout.write(`
@@ -41849,7 +42804,7 @@ Prompt: ${promptPath}
 Exit the shell to finalize run.json.
 
 `);
-      const result = (0, import_child_process6.spawnSync)(shell.command, shell.args, {
+      const result = (0, import_child_process7.spawnSync)(shell.command, shell.args, {
         stdio: "inherit",
         env: {
           ...process.env,
@@ -41861,8 +42816,8 @@ Exit the shell to finalize run.json.
       shellExitCode = typeof result.status === "number" ? result.status : null;
     }
     const artifact = buildRunArtifact({ runDir, session, status, reasonCode: opts.reasonCode, shellExitCode });
-    const runPath = (0, import_path19.join)(runDir, "run.json");
-    (0, import_fs20.writeFileSync)(runPath, `${JSON.stringify(artifact, null, 2)}
+    const runPath = (0, import_path20.join)(runDir, "run.json");
+    (0, import_fs21.writeFileSync)(runPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
     format(cliEnvelope({
       schemaVersion: "external_agent_capture_result.v1",
@@ -41872,7 +42827,7 @@ Exit the shell to finalize run.json.
       artifacts: {
         run: runPath,
         prompt: promptPath,
-        commands: (0, import_path19.join)(runDir, "commands.ndjson")
+        commands: (0, import_path20.join)(runDir, "commands.ndjson")
       },
       nextCommands: artifact.next_commands,
       extra: { run: artifact }
@@ -41980,8 +42935,8 @@ Exit the shell to finalize run.json.
           requireExplicitEvalAuth: true,
           minimumEvalAuthTtlMs: (plan.timeout_minutes + 5) * 60 * 1e3
         });
-        const resultPath = (0, import_path19.join)(plan.batch_dir, "execution-result.json");
-        (0, import_fs20.writeFileSync)(resultPath, `${JSON.stringify(result, null, 2)}
+        const resultPath = (0, import_path20.join)(plan.batch_dir, "execution-result.json");
+        (0, import_fs21.writeFileSync)(resultPath, `${JSON.stringify(result, null, 2)}
 `, "utf8");
         format(cliEnvelope({
           schemaVersion: "external_agent_execution_result.v1",
@@ -42211,11 +43166,13 @@ registerCertify(program2);
 registerDiag(program2);
 registerBug(program2);
 registerProve(program2);
+registerInteractive(program2);
 registerAgentPublishCommand(program2, { publicAlias: true });
 registerEval(program2);
 registerUpdate(program2);
 registerHome(program2);
 hideInternalApiUrlOptions(program2);
+initializeCommandGraph(program2);
 maybeDefaultToHome(process.argv);
 program2.parseAsync(process.argv).catch((e) => {
   if (e instanceof CliSoftExit) {