@poetic-ai/poetic 1.42.0

package/dist/entry.js

@@ -0,0 +1,940 @@
+#!/usr/bin/env node
+import {
+  buildRoutedArgv,
+  createLocalCiDetachedChildEnv,
+  isObservationalProcessesHealthInvocation,
+  isObservationalProcessesJsonInvocation,
+  localCiRootMappingPath,
+  matchPlanNestedCommand,
+  renderOrdinaryHelp,
+  resolveCliCommand,
+  resolveStartupPoeticDir
+} from "./chunk-JRVNSWSQ.js";
+import "./chunk-YESZJFK6.js";
+import {
+  acquireCliBuildLock
+} from "./chunk-2XQXYBM2.js";
+import {
+  isCiEnvironment
+} from "./chunk-A722DEVA.js";
+import "./chunk-D5RYINO7.js";
+import "./chunk-6TZJRKNW.js";
+import "./chunk-PCAGC5MR.js";
+import "./chunk-5WCQRDRB.js";
+import "./chunk-5WRLK5KW.js";
+import "./chunk-C57KJOUQ.js";
+import "./chunk-DF5SLDE4.js";
+import "./chunk-TGON4N4O.js";
+import "./chunk-I5WRT7ZR.js";
+import "./chunk-A3YGID55.js";
+import "./chunk-5EERLVZB.js";
+import "./chunk-XQD2B6BB.js";
+import "./chunk-34CNP2HB.js";
+import "./chunk-KNDYMVWN.js";
+import "./chunk-RWREC3KJ.js";
+import "./chunk-LO23NABI.js";
+import "./chunk-7R2WLDOS.js";
+import "./chunk-LAMKBTXX.js";
+import "./chunk-FD4ERYEG.js";
+import {
+  setProcessExitHandler
+} from "./chunk-KTMW65UX.js";
+import "./chunk-FHOWVDF5.js";
+import "./chunk-UDMS5AD3.js";
+import "./chunk-MWHLBPNU.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-TRSVUPCX.js";
+import {
+  isDebugOutputRequested,
+  isJsonOutputRequested,
+  isVerboseOutputRequested,
+  outputPolicyToEnv,
+  resolveOutputPolicyFromArgs
+} from "./chunk-FKAUPHMR.js";
+import "./chunk-TSXGRLPR.js";
+import "./chunk-LUVKFFWR.js";
+import "./chunk-ENRGKNR5.js";
+import "./chunk-XB5YLCLB.js";
+import "./chunk-QOCOVLUH.js";
+import "./chunk-2VSQMRCB.js";
+import "./chunk-ON3G73BU.js";
+import "./chunk-3G6FZCRF.js";
+import "./chunk-N5DX4JAK.js";
+import "./chunk-2QLYTVYX.js";
+import "./chunk-7GDRQBQC.js";
+import "./chunk-PGSPX4SU.js";
+import {
+  validateEnvironmentVars
+} from "./chunk-AT4TNPWW.js";
+import "./chunk-GSGD5E4C.js";
+import {
+  createExecutionContext,
+  setExecutionContext
+} from "./chunk-UI2F6DJ5.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-L6OM4A22.js";
+import "./chunk-G4THLFV3.js";
+import "./chunk-RGWHUI5E.js";
+import "./chunk-UUH2RVKS.js";
+import "./chunk-LEIIWPWQ.js";
+import {
+  resolveCliRepoRoot
+} from "./chunk-L7JZLXQL.js";
+import "./chunk-IZYIQQ7X.js";
+import {
+  assertPoeticRuntimeReady,
+  isDiagnosticInvocation,
+  prepareDiagnosticRuntime
+} from "./chunk-JPKSXKNB.js";
+import "./chunk-TAJPCXSB.js";
+import "./chunk-XZE4XARH.js";
+import "./chunk-EJGCZGUF.js";
+import {
+  sanitizeValue
+} from "./chunk-LPITVM7M.js";
+import {
+  POETIC_CI_RECONCILING,
+  POETIC_CLI_REEXEC_AFTER_BUILD,
+  POETIC_TELEMETRY_DIR,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/cli/entry.ts
+import { spawn as spawn2 } from "child_process";
+import fs from "fs";
+import os from "os";
+import path3 from "path";
+import { fileURLToPath } from "url";
+
+// src/core/ci/local-ci-opportunistic.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import path2 from "path";
+
+// src/core/ci/local-ci-throttle.ts
+import { closeSync, mkdirSync, openSync, statSync, unlinkSync } from "fs";
+import path from "path";
+var RECONCILE_THROTTLE_MS = 6e4;
+function acquireLocalCiReconcileThrottle(mappingPath, now = Date.now()) {
+  const stampPath = `${mappingPath}.reconcile-stamp`;
+  mkdirSync(path.dirname(stampPath), { recursive: true, mode: 448 });
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      closeSync(openSync(stampPath, "wx", 384));
+      return true;
+    } catch (error) {
+      if (!(error && typeof error === "object" && "code" in error && error.code === "EEXIST")) {
+        return false;
+      }
+      try {
+        if (now - statSync(stampPath).mtimeMs < RECONCILE_THROTTLE_MS) return false;
+        unlinkSync(stampPath);
+      } catch {
+        return false;
+      }
+    }
+  }
+  return false;
+}
+
+// src/core/ci/local-ci-opportunistic.ts
+function createLocalCiReconcileChildEnv() {
+  return createLocalCiDetachedChildEnv({ POETIC_CI_RECONCILING: "1" });
+}
+function triggerOpportunisticLocalCiReconcile(input, dependencies = {}) {
+  if (input.command === "ci") return;
+  try {
+    const isReconciling = dependencies.isReconciling ?? (() => readEnv(POETIC_CI_RECONCILING).value === true);
+    if (isReconciling()) return;
+    const mappingPath = localCiRootMappingPath(input.repoRoot);
+    if (!(dependencies.mappingExists ?? existsSync)(mappingPath)) return;
+    if (!(dependencies.acquireThrottle ?? acquireLocalCiReconcileThrottle)(mappingPath)) return;
+    const child = (dependencies.spawnProcess ?? spawn)(
+      process.execPath,
+      [path2.resolve(input.entryPath), "ci", "reconcile", "--quiet"],
+      {
+        cwd: input.repoRoot,
+        detached: process.platform !== "win32",
+        stdio: "ignore",
+        env: createLocalCiReconcileChildEnv()
+      }
+    );
+    child.on("error", () => void 0);
+    child.unref();
+  } catch {
+  }
+}
+
+// src/core/config/mock-providers-policy.ts
+function isTestRunner(env) {
+  if (env.NODE_ENV === "test") {
+    return true;
+  }
+  const vitest = env.VITEST;
+  return vitest === "true" || vitest === "1";
+}
+function applyMockProvidersPolicy(env = process.env) {
+  const requested = env.POETIC_MOCK_PROVIDERS === "1";
+  if (!requested) {
+    return { allowed: false, reason: "not-requested" };
+  }
+  if (isTestRunner(env)) {
+    return { allowed: true, reason: "test-runner" };
+  }
+  if (env.POETIC_ALLOW_MOCK_PROVIDERS === "1") {
+    return { allowed: true, reason: "explicit-allow" };
+  }
+  const scrubbedValue = env.POETIC_MOCK_PROVIDERS;
+  delete env.POETIC_MOCK_PROVIDERS;
+  return { allowed: false, reason: "scrubbed", scrubbedValue };
+}
+
+// src/cli/build-freshness-policy.ts
+function isHelpRequested(args2) {
+  if (!args2) return false;
+  const commandArgs2 = args2.slice(1);
+  return commandArgs2.length === 1 && (commandArgs2[0] === "--help" || commandArgs2[0] === "-h");
+}
+function shouldEnsureFreshBuildBeforeStartup({
+  command: command2,
+  args: args2,
+  bareMode: bareMode2
+}) {
+  if (command2 === void 0) {
+    return bareMode2 === "tui";
+  }
+  if (isHelpRequested(args2)) {
+    return false;
+  }
+  return true;
+}
+
+// src/cli/tui/entry-mode.ts
+function resolveBareCommandMode(input) {
+  if (input.args.length > 0) {
+    return "dispatch";
+  }
+  const ci = input.ci ?? isCiEnvironment(input.env);
+  return ci !== true && input.stdinIsTTY === true && input.stdoutIsTTY === true ? "tui" : "help";
+}
+
+// src/cli/entry.ts
+setProcessExitHandler({ exit: (code) => process.exit(code) });
+function safeErrorMessage(error) {
+  return sanitizeValue(error);
+}
+function safeErrorSuffix(error) {
+  const message = safeErrorMessage(error);
+  return message ? `: ${message}` : "";
+}
+function findPackageJson(startDir) {
+  let current = startDir;
+  while (true) {
+    const candidate = path3.join(current, "package.json");
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+var _entryFile = fileURLToPath(import.meta.url);
+var _pkgJsonPath = findPackageJson(path3.dirname(_entryFile));
+var POETIC_VERSION = (() => {
+  try {
+    if (!_pkgJsonPath) {
+      return "0.0.0";
+    }
+    const pkg = JSON.parse(fs.readFileSync(_pkgJsonPath, "utf-8"));
+    return typeof pkg.version === "string" && pkg.version.trim() ? pkg.version.trim() : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+})();
+var args = process.argv.slice(2);
+var route = resolveCliCommand(args);
+var command = route.command;
+var commandArgs = route.commandArgs;
+var routedArgv = buildRoutedArgv(process.argv, route);
+var outputPolicyEnvOverrides = outputPolicyToEnv(resolveOutputPolicyFromArgs(args));
+var bareMode = command === void 0 ? resolveBareCommandMode({
+  args,
+  env: process.env,
+  stdinIsTTY: process.stdin.isTTY,
+  stdoutIsTTY: process.stdout.isTTY
+}) : void 0;
+var mockPolicy = applyMockProvidersPolicy();
+if (mockPolicy.reason === "scrubbed") {
+  process.stderr.write(
+    `Warning: ignoring POETIC_MOCK_PROVIDERS=${mockPolicy.scrubbedValue} (set POETIC_ALLOW_MOCK_PROVIDERS=1 to opt in to synthetic provider responses).
+`
+  );
+}
+if (command === "cleanup") {
+  process.env.POETIC_DISABLE_AUTOMATIC_WORKTREE_CLEANUP ??= "1";
+}
+for (const [key, value] of Object.entries(outputPolicyEnvOverrides)) {
+  process.env[key] = value;
+}
+if (command === "--version" || command === "-V") {
+  console.log(POETIC_VERSION);
+  process.exit(0);
+}
+function printLightHelp() {
+  process.stdout.write(renderOrdinaryHelp(POETIC_VERSION));
+}
+if (command === "--help" || command === "-h" || command === "help" && args.length === 1) {
+  printLightHelp();
+  process.exit(0);
+}
+var diagnosticInvocation = isDiagnosticInvocation({ command, args, bareMode });
+var requiresNativeTelemetry = command !== "next" && !(command === "task" && commandArgs[1] === "list");
+if (diagnosticInvocation) {
+  prepareDiagnosticRuntime();
+} else {
+  try {
+    assertPoeticRuntimeReady({ command, requiresNativeTelemetry });
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  }
+}
+var repoRoot = process.cwd();
+try {
+  repoRoot = resolveCliRepoRoot(process.cwd());
+} catch {
+}
+triggerOpportunisticLocalCiReconcile({
+  repoRoot,
+  entryPath: _entryFile,
+  command
+});
+function loadHomeDotEnvOverrides() {
+  const overrides = {};
+  const envPath = path3.join(os.homedir(), ".poetic", ".env");
+  let raw;
+  try {
+    raw = fs.readFileSync(envPath, "utf8");
+  } catch {
+    return overrides;
+  }
+  for (const lineRaw of raw.split(/\r?\n/)) {
+    const line = lineRaw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if (!key) continue;
+    if (key === "POETIC_RESEARCH_NATIVE_PROVIDERS") continue;
+    if (process.env[key] !== void 0) continue;
+    if (value.startsWith('"') && value.endsWith('"') && value.length >= 2 || value.startsWith("'") && value.endsWith("'") && value.length >= 2) {
+      value = value.slice(1, -1);
+    }
+    overrides[key] = value;
+  }
+  return overrides;
+}
+var homeDotEnvOverrides = loadHomeDotEnvOverrides();
+var entryPoeticDir = resolveStartupPoeticDir({ args, repoRoot });
+var entryEnvOverrides = {
+  ...homeDotEnvOverrides,
+  ...outputPolicyEnvOverrides
+};
+if (!readEnv(POETIC_TELEMETRY_DIR)) {
+  entryEnvOverrides.POETIC_TELEMETRY_DIR = entryPoeticDir;
+}
+setExecutionContext(
+  createExecutionContext({
+    repoRoot,
+    poeticDir: entryPoeticDir,
+    taskId: "cli-entry",
+    envOverrides: entryEnvOverrides
+  })
+);
+if (process.env.POETIC_STRICT_ENV === "1") {
+  validateEnvironmentVars();
+}
+function isMissingDistChunkError(error) {
+  if (!(error instanceof Error)) return false;
+  const code = error.code;
+  return code === "ERR_MODULE_NOT_FOUND" || error.message.includes("Cannot find module") || error.message.includes("ERR_MODULE_NOT_FOUND");
+}
+async function reexecEntryAfterBuildRace() {
+  const entryPath = process.argv[1] ? path3.resolve(process.argv[1]) : _entryFile;
+  const child = spawn2(process.execPath, [entryPath, ...process.argv.slice(2)], {
+    cwd: repoRoot,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      POETIC_CLI_REEXEC_AFTER_BUILD: "1"
+    }
+  });
+  const exitCode = await new Promise((resolve) => {
+    child.once("exit", (code, signal) => {
+      if (typeof code === "number") {
+        resolve(code);
+        return;
+      }
+      if (signal === "SIGINT") resolve(130);
+      else if (signal === "SIGTERM") resolve(143);
+      else if (signal === "SIGHUP") resolve(129);
+      else resolve(signal ? 1 : 0);
+    });
+    child.once("error", () => resolve(1));
+  });
+  process.exit(exitCode);
+}
+async function ensureHeavyCommandFreshBuild() {
+  if (readEnv(POETIC_CLI_REEXEC_AFTER_BUILD).value) return;
+  const releaseBuildLock = await acquireCliBuildLock(repoRoot);
+  try {
+    let buildHelpers;
+    try {
+      buildHelpers = await import("./flywheel-preflight-XEY5SHM6.js");
+    } catch (error) {
+      if (isMissingDistChunkError(error)) {
+        await releaseBuildLock();
+        await reexecEntryAfterBuildRace();
+      }
+      throw error;
+    }
+    const { ensureFreshBuild, reexecCurrentCliCommand } = buildHelpers;
+    const buildResult = await ensureFreshBuild({
+      quiet: !(isVerboseOutputRequested() || isDebugOutputRequested())
+    });
+    if (buildResult.rebuilt) {
+      await releaseBuildLock();
+      await reexecCurrentCliCommand(repoRoot);
+    }
+  } finally {
+    await releaseBuildLock();
+  }
+}
+async function ensureStartupFreshBuildOrExit() {
+  try {
+    await ensureHeavyCommandFreshBuild();
+  } catch (error) {
+    console.error("Error: Failed to prepare fresh CLI build:", safeErrorMessage(error));
+    process.exit(1);
+  }
+}
+var READ_ONLY_CONFIG_SUBCOMMANDS = /* @__PURE__ */ new Set(["show", "list", "get", "precedence"]);
+var FIXABLE_READ_ONLY_CONFIG_SUBCOMMANDS = /* @__PURE__ */ new Set(["validate", "diagnose"]);
+function isReadOnlyConfigCommand(cliArgs) {
+  const subcommand = cliArgs[1];
+  if (!subcommand) {
+    return true;
+  }
+  if (READ_ONLY_CONFIG_SUBCOMMANDS.has(subcommand)) {
+    return true;
+  }
+  return FIXABLE_READ_ONLY_CONFIG_SUBCOMMANDS.has(subcommand) && !cliArgs.includes("--fix");
+}
+function isReadOnlyCostCommand(cliArgs) {
+  const subcommand = cliArgs[1];
+  if (!subcommand) {
+    return true;
+  }
+  const hasWriteFlag = (flag) => cliArgs.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+  return !hasWriteFlag("--output-file") && !hasWriteFlag("--recalculate");
+}
+function isReadOnlyMonitorCommand(cliArgs) {
+  return !cliArgs.includes("--follow") && !cliArgs.includes("--detailed");
+}
+function isReadOnlySprintCommand(cliArgs) {
+  return cliArgs[1] === "status" || cliArgs[1] === "list" || cliArgs[1] === "capacity";
+}
+function hasPositionalSubcommand(cliArgs, subcommand) {
+  for (let i = 1; i < cliArgs.length; i += 1) {
+    if (cliArgs[i] === subcommand) return true;
+  }
+  return false;
+}
+if (command === void 0) {
+  if (bareMode === "tui") {
+    if (shouldEnsureFreshBuildBeforeStartup({ command, args, bareMode })) {
+      await ensureStartupFreshBuildOrExit();
+    }
+    await import("./run-poetic-tui-J6LWRJUP.js").then(({ runPoeticTui }) => runPoeticTui({ repoRoot })).catch(async (error) => {
+      if (isMissingDistChunkError(error)) {
+        await ensureStartupFreshBuildOrExit();
+        const { runPoeticTui } = await import("./run-poetic-tui-J6LWRJUP.js");
+        await runPoeticTui({ repoRoot });
+        return;
+      }
+      console.error("Failed to load TUI:", safeErrorMessage(error));
+      process.exitCode = 1;
+    });
+  } else {
+    printLightHelp();
+  }
+} else if (command === "next") {
+  import("./next-PB5ZXZKB.js").then(async ({ createNextCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError } = await import("./exit-code-error-Z4SW2DVK.js");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createNextCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute next command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (command === "task" && commandArgs[1] === "list") {
+  import("./task-list-fast-PTMA4LUC.js").then(async ({ createTaskListFastCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError } = await import("./exit-code-error-Z4SW2DVK.js");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createTaskListFastCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute task list command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (matchPlanNestedCommand(command, commandArgs, "backlog", "list")) {
+  import("./plan-backlog-list-fast-VAGYBV3J.js").then(async ({ createPlanBacklogListFastCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError } = await import("./exit-code-error-Z4SW2DVK.js");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createPlanBacklogListFastCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute plan backlog list command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (matchPlanNestedCommand(command, commandArgs, "backlog", "show")) {
+  import("./plan-backlog-show-fast-SG2CZPW3.js").then(async ({ createPlanBacklogShowFastCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError } = await import("./exit-code-error-Z4SW2DVK.js");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createPlanBacklogShowFastCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute plan backlog show command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (matchPlanNestedCommand(command, commandArgs, "task", "status")) {
+  import("./plan-task-status-fast-HNYBMQI4.js").then(async ({ createPlanTaskStatusFastCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError } = await import("./exit-code-error-Z4SW2DVK.js");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createPlanTaskStatusFastCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute plan task status command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (matchPlanNestedCommand(command, commandArgs, "sprint", "status")) {
+  import("./plan-sprint-status-fast-FJAODCHD.js").then(async ({ createPlanSprintStatusFastCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError } = await import("./exit-code-error-Z4SW2DVK.js");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createPlanSprintStatusFastCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute plan sprint status command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (matchPlanNestedCommand(command, commandArgs, "sprint", "list")) {
+  import("./plan-sprint-list-fast-LURAX47V.js").then(async ({ createPlanSprintListFastCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError } = await import("./exit-code-error-Z4SW2DVK.js");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createPlanSprintListFastCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error(`Failed to execute plan sprint list command${safeErrorSuffix(error)}`);
+    process.exitCode = 1;
+  });
+} else if (command === "ask") {
+  (async () => {
+    if (shouldEnsureFreshBuildBeforeStartup({ command, args: commandArgs })) {
+      await ensureStartupFreshBuildOrExit();
+    }
+    try {
+      const { createAskCommand } = await import("./ask-HWVV6QFR.js");
+      const { Command } = await import("commander");
+      const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+      program.addCommand(createAskCommand());
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      console.error("Failed to execute ask command:", safeErrorMessage(error));
+      process.exitCode = 1;
+    }
+  })();
+} else if (command === "quickstart") {
+  import("./quickstart-FIRLKGJI.js").then(async ({ createQuickstartCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createQuickstartCommand());
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    process.stderr.write(`Failed to execute quickstart command: ${safeErrorMessage(error)}
+`);
+    process.exitCode = 1;
+  });
+} else if (command === "instructions") {
+  import("./instructions-6BURLQJC.js").then(async ({ createInstructionsCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createInstructionsCommand());
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute instructions command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if ((command === "config" || command === "settings") && isReadOnlyConfigCommand(commandArgs)) {
+  import("./config-JCOKXOQT.js").then(async ({ createConfigCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createConfigCommand());
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute config command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if ((command === "doctor" || command === "d") && !commandArgs.includes("--fix")) {
+  import("./doctor-GJOYE7AE.js").then(async ({ createDoctorCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createDoctorCommand());
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute doctor command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if ((command === "cost" || command === "$") && isReadOnlyCostCommand(commandArgs)) {
+  import("./cost-YC42XUF3.js").then(async ({ createCostCommand }) => {
+    const { Command } = await import("commander");
+    const {
+      disposeSharedTelemetry,
+      ensurePricingLoaded,
+      getSharedCostCalculator,
+      getSharedCostTracker,
+      getSharedModelInvocationsDb,
+      getSharedTelemetry
+    } = await import("./cli-utils-IXL26KJT.js");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(
+      createCostCommand({
+        get telemetry() {
+          return getSharedTelemetry();
+        },
+        get costCalculator() {
+          return getSharedCostCalculator();
+        },
+        get costTracker() {
+          return getSharedCostTracker();
+        },
+        get modelInvocationsDb() {
+          return getSharedModelInvocationsDb();
+        },
+        ensurePricingLoaded
+      })
+    );
+    await program.parseAsync(routedArgv);
+    disposeSharedTelemetry();
+  }).catch((error) => {
+    console.error("Failed to execute cost command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (isObservationalProcessesHealthInvocation(args)) {
+  import("./processes-KMQUD7HY.js").then(async ({ processesCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(processesCommand);
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    const exitError = error;
+    if (exitError.name === "ExitCodeError" && typeof exitError.exitCode === "number") {
+      process.exitCode = exitError.exitCode;
+      return;
+    }
+    console.error("Failed to execute processes health command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (isObservationalProcessesJsonInvocation(args)) {
+  import("./processes-json-fast-IBDXZ6WW.js").then(async ({ createProcessesJsonFastCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createProcessesJsonFastCommand());
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    const exitError = error;
+    if (exitError.name === "ExitCodeError" && typeof exitError.exitCode === "number") {
+      process.exitCode = exitError.exitCode;
+      return;
+    }
+    console.error("Failed to execute processes json command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if ((command === "monitor" || command === "m") && isReadOnlyMonitorCommand(commandArgs)) {
+  import("./monitor-XGYBG2DW.js").then(async ({ createMonitorCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError } = await import("./exit-code-error-Z4SW2DVK.js");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createMonitorCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error("Failed to execute monitor command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "sprint" && isReadOnlySprintCommand(commandArgs)) {
+  import("./sprint-UIXPYOXQ.js").then(async ({ registerSprintCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    registerSprintCommand(program);
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute sprint command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "profile") {
+  import("./profile-SE5EVXAP.js").then(async ({ createProfileCommand }) => {
+    const { Command } = await import("commander");
+    const { isExitCodeError } = await import("./exit-code-error-Z4SW2DVK.js");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createProfileCommand());
+    try {
+      await program.parseAsync(routedArgv);
+    } catch (error) {
+      if (isExitCodeError(error)) {
+        process.exitCode = error.exitCode;
+        return;
+      }
+      throw error;
+    }
+  }).catch((error) => {
+    console.error("Failed to execute profile command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "sandbox" && !commandArgs.includes("--probe")) {
+  import("./sandbox-32QXJEMV.js").then(async ({ createSandboxCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createSandboxCommand());
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute sandbox command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "package") {
+  import("./package-3YCWIQQ5.js").then(async ({ createPackageCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    program.addCommand(createPackageCommand());
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    process.stderr.write(`Failed to execute package command: ${safeErrorMessage(error)}
+`);
+    process.exitCode = 1;
+  });
+} else if ((command === "compete" || command === "c") && hasPositionalSubcommand(commandArgs, "results")) {
+  import("./compete-results-QEPG6FZX.js").then(async ({ createCompeteResultsCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    const compete = new Command("compete").description("Run multi-provider competition");
+    compete.addCommand(createCompeteResultsCommand());
+    program.addCommand(compete);
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute compete results command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "fusion" && hasPositionalSubcommand(commandArgs, "results")) {
+  import("./compete-results-QEPG6FZX.js").then(async ({ createCompeteResultsCommand }) => {
+    const { Command } = await import("commander");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    const fusion = new Command("fusion").description("Merge AI perspectives into a synthesis");
+    fusion.addCommand(createCompeteResultsCommand({ surface: "fusion" }));
+    program.addCommand(fusion);
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute fusion results command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "telemetry" && hasPositionalSubcommand(commandArgs, "reliability")) {
+  import("./telemetry-reliability-XUOZNZZ6.js").then(async ({ createTelemetryReliabilityCommand }) => {
+    const { Command } = await import("commander");
+    const { setTelemetryLabContext } = await import("./cli-utils-IXL26KJT.js");
+    const { findLabRun, findLatestLabRun } = await import("./lab-utils-BJRFLGK4.js");
+    const { LabPathResolver } = await import("./lab-mode-OTWVHN63.js");
+    const program = new Command().name("poetic").description("AI orchestration CLI").version(POETIC_VERSION);
+    const telemetry = new Command("telemetry").description(
+      "View telemetry and variant performance data"
+    );
+    telemetry.option("--lab [selector]", "Use lab telemetry data (value: latest)").option("--lab-id <labId>", "(OPTIONAL) Specify lab ID (requires --run-id)").option("--run-id <runId>", "(OPTIONAL) Specify run ID (requires --lab-id)").hook("preAction", (thisCommand) => {
+      const telemetryOpts = thisCommand.opts();
+      const failLabOptions = (message) => {
+        throw new Error(`${message}. Run \`poetic lab list\` to browse available lab runs.`);
+      };
+      if (telemetryOpts.lab && (telemetryOpts.labId || telemetryOpts.runId)) {
+        failLabOptions("--lab cannot be combined with --lab-id/--run-id");
+      }
+      if (telemetryOpts.labId && !telemetryOpts.runId) {
+        failLabOptions("--lab-id requires --run-id");
+      }
+      if (telemetryOpts.runId && !telemetryOpts.labId) {
+        failLabOptions("--run-id requires --lab-id");
+      }
+      let labSelection = null;
+      if (telemetryOpts.lab) {
+        const selector = typeof telemetryOpts.lab === "string" ? telemetryOpts.lab.trim().toLowerCase() : telemetryOpts.lab === true ? "latest" : null;
+        if (!selector || selector === "latest") {
+          labSelection = findLatestLabRun(path3.join(repoRoot, ".poetic"));
+          if (!labSelection) {
+            failLabOptions(
+              "No lab runs found. Start a lab run with `poetic compete --lab` before querying telemetry"
+            );
+          }
+        } else {
+          failLabOptions("Unsupported --lab value. Supported value: latest");
+        }
+      } else if (telemetryOpts.labId && telemetryOpts.runId) {
+        labSelection = findLabRun(
+          telemetryOpts.labId,
+          telemetryOpts.runId,
+          path3.join(repoRoot, ".poetic")
+        );
+        if (!labSelection) {
+          failLabOptions(`Lab run not found: ${telemetryOpts.labId}/${telemetryOpts.runId}`);
+        }
+      }
+      if (labSelection) {
+        setTelemetryLabContext({ labId: labSelection.labId, runId: labSelection.runId });
+        LabPathResolver.getInstance().setContext({
+          labId: labSelection.labId,
+          runId: labSelection.runId,
+          baseline: "HEAD",
+          task: "telemetry-cli"
+        });
+      } else {
+        setTelemetryLabContext(null);
+        LabPathResolver.getInstance().clearContext();
+      }
+    }).hook("postAction", () => {
+      setTelemetryLabContext(null);
+      LabPathResolver.getInstance().clearContext();
+    });
+    telemetry.addCommand(createTelemetryReliabilityCommand());
+    program.addCommand(telemetry);
+    await program.parseAsync(routedArgv);
+  }).catch((error) => {
+    console.error("Failed to execute telemetry reliability command:", safeErrorMessage(error));
+    process.exitCode = 1;
+  });
+} else if (command === "--help-full") {
+  globalThis.__POETIC_HELP_FULL__ = true;
+  process.argv = [process.argv[0] ?? "node", process.argv[1] ?? "dist/entry.js", "--help"];
+  await import("./index.js").catch((error) => {
+    console.error("Failed to load CLI:", safeErrorMessage(error));
+    process.exit(1);
+  });
+} else {
+  if (shouldEnsureFreshBuildBeforeStartup({ command, args: commandArgs })) {
+    await ensureStartupFreshBuildOrExit();
+  }
+  const isTsxPath = process.argv[1]?.includes("entry.ts");
+  const suppressWarning = args.includes("--json") || isJsonOutputRequested();
+  if (isTsxPath && !suppressWarning) {
+    try {
+      const srcStat = fs.statSync(new URL(import.meta.url));
+      const distStat = fs.statSync(new URL("../../dist/entry.js", import.meta.url));
+      if (srcStat.mtimeMs > distStat.mtimeMs) {
+        process.stderr.write(
+          "\x1B[2m(poetic binary may be stale \u2014 run npm run build to update)\x1B[0m\n"
+        );
+      }
+    } catch {
+    }
+  }
+  await import("./index.js").catch((error) => {
+    const isStaleBuild = error.message.includes("Dynamic require") || error.message.includes("Cannot find module") || error.code === "ERR_MODULE_NOT_FOUND";
+    if (isStaleBuild) {
+      console.error("\x1B[31mCLI build is missing or outdated\x1B[0m\n");
+      console.log("\x1B[33mHow to fix:\x1B[0m");
+      console.log("\x1B[90m  1) Rebuild the CLI:\x1B[0m");
+      console.log("\x1B[36m     npm run build\x1B[0m\n");
+      console.log("\x1B[90m  2) Or use the automated script:\x1B[0m");
+      console.log("\x1B[36m     ./scripts/build-poetic.sh\x1B[0m\n");
+      console.log("\x1B[90mCommon causes:\x1B[0m");
+      console.log("\x1B[90m  \u2022 git pull/checkout changed source files\x1B[0m");
+      console.log("\x1B[90m  \u2022 Local edits to src/ directory\x1B[0m");
+      console.log("\x1B[90m  \u2022 Deleted dist/ directory\x1B[0m\n");
+      console.log("\x1B[90mFor more help: docs/TROUBLESHOOTING.md#stale-cli-build\x1B[0m");
+      process.exit(1);
+    }
+    console.error("\x1B[31mFailed to load CLI:\x1B[0m", safeErrorMessage(error));
+    process.exit(1);
+  });
+}
+//# sourceMappingURL=entry.js.map