@namzu/cli 35.0.0 → 36.0.0

package/dist/chunks/chunk-PT537V7B.js

@@ -0,0 +1,787 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  createFormatter,
+  isFormatName
+} from "./chunk-KONYGNG6.js";
+import {
+  Command,
+  CommanderError,
+  Option
+} from "./chunk-MZP6SH3M.js";
+import {
+  CLI_VERSION
+} from "./chunk-HE7WUOX2.js";
+import {
+  bindTrustedProjectContext,
+  resolveTrustedProjectContext
+} from "./chunk-CHIEVVQ2.js";
+import {
+  debugRequested
+} from "./chunk-GNBMKISG.js";
+import {
+  EXIT_BAD_CONFIG,
+  EXIT_INTERNAL_ERROR
+} from "./chunk-Y7B67G22.js";
+import {
+  REASONING_EFFORT_LEVELS
+} from "./chunk-LXB3S4IC.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/commands/lazy.ts
+function lazyCommand(meta, load) {
+  let loaded;
+  return {
+    ...meta,
+    // One import however many times it is asked, and a failed one is asked
+    // again rather than remembered.
+    load: /* @__PURE__ */ __name(() => {
+      if (!loaded) {
+        loaded = load().catch((error) => {
+          loaded = void 0;
+          throw error;
+        });
+      }
+      return loaded;
+    }, "load")
+  };
+}
+__name(lazyCommand, "lazyCommand");
+function isLazyCommand(def) {
+  return "load" in def;
+}
+__name(isLazyCommand, "isLazyCommand");
+
+// src/commands/registry.ts
+function registerCommand(program, def, opts) {
+  registerCommandOrLazy(program, def, opts);
+}
+__name(registerCommand, "registerCommand");
+function registerCommandOrLazy(program, def, opts) {
+  const resolve2 = /* @__PURE__ */ __name(async () => isLazyCommand(def) ? def.load() : def, "resolve");
+  const cmd = program.command(def.name).description(def.description);
+  if (def.aliases) cmd.aliases([...def.aliases]);
+  if (def.passThrough) {
+    cmd.helpOption(false).allowUnknownOption(true).passThroughOptions(true).argument("[args...]").action(async (args) => {
+      const rawArgs = args ?? [];
+      const real = await resolve2();
+      if (real.help !== void 0 && rawArgs.some((a) => a === "--help" || a === "-h")) {
+        opts.getContext().formatter.print({ text: real.help });
+        opts.setExitCode(0);
+        return;
+      }
+      const code = await real.handler({ ctx: opts.getContext(), rawArgs });
+      opts.setExitCode(code);
+    });
+  } else {
+    cmd.action(async () => {
+      const real = await resolve2();
+      const code = await real.handler({ ctx: opts.getContext(), rawArgs: [] });
+      opts.setExitCode(code);
+    });
+  }
+}
+__name(registerCommandOrLazy, "registerCommandOrLazy");
+function registerAll(program, defs, opts) {
+  for (const def of defs) registerCommand(program, def, opts);
+}
+__name(registerAll, "registerAll");
+
+// src/cli.ts
+import { resolve } from "node:path";
+
+// src/usage-error.ts
+var HELP_POINTER = "Run namzu --help to see what is available.";
+function wrapAtWords(line, width) {
+  if (width < 20 || line.length <= width) return [line];
+  const rows = [];
+  const indent = /^\s*/.exec(line)?.[0] ?? "";
+  let current = "";
+  for (const word of line.trim().split(/\s+/)) {
+    if (current.length === 0) current = `${indent}${word}`;
+    else if (current.length + 1 + word.length <= width) current += ` ${word}`;
+    else {
+      rows.push(current);
+      current = `${indent}${word}`;
+    }
+  }
+  if (current.length > 0) rows.push(current);
+  return rows;
+}
+__name(wrapAtWords, "wrapAtWords");
+function flagName(spelled) {
+  return /--[\w-]+/.exec(spelled)?.[0] ?? spelled.split(/[ ,]/)[0] ?? spelled;
+}
+__name(flagName, "flagName");
+function plainer(first) {
+  const invalid = /^option '([^']+)' argument '(.*)' is invalid\.(?: Allowed choices are (.+)\.)?$/.exec(first);
+  if (invalid) {
+    const choices = invalid[3] ? ` Choose one of ${invalid[3]}.` : "";
+    return `\u201C${invalid[2]}\u201D is not a valid value for ${flagName(invalid[1] ?? "")}.${choices}`;
+  }
+  const missing = /^option '([^']+)' argument missing$/.exec(first);
+  if (missing) return `${flagName(missing[1] ?? "")} needs a value.`;
+  return first;
+}
+__name(plainer, "plainer");
+function formatUsageError(text, columns) {
+  const width = Math.min(Math.max(columns ?? 80, 20), 100);
+  const lines = text.trim().split("\n").map((line, index) => {
+    let sentence = index === 0 ? plainer(line.replace(/^error:\s*/i, "")) : line;
+    if (index === 0 && /^[a-z]/.test(sentence)) {
+      sentence = `${sentence.charAt(0).toUpperCase()}${sentence.slice(1)}`;
+    }
+    if (index === 0 && !/[.!?:]$/.test(sentence)) sentence = `${sentence}.`;
+    return sentence;
+  });
+  const points = lines.length > 1 || /\bhelp\b/i.test(text);
+  const body = (points ? lines : [...lines, HELP_POINTER]).flatMap(
+    (line) => wrapAtWords(line, width)
+  );
+  return `${body.join("\n")}
+`;
+}
+__name(formatUsageError, "formatUsageError");
+
+// src/commands/manifest.ts
+var acpCommand = lazyCommand(
+  {
+    name: "acp",
+    description: "Speak the agent-client protocol over this process\u2019s stdio",
+    passThrough: true
+  },
+  async () => (await import("./acp-BOSEA4R3.js")).acpCommand
+);
+var computerCommand = lazyCommand(
+  {
+    name: "computer",
+    description: "Check and set up the computer Pals run on (Windows)",
+    passThrough: true
+  },
+  async () => (await import("./computer-GXDY4H35.js")).computerCommand
+);
+var archiveCommand = lazyCommand(
+  {
+    name: "archive",
+    description: "List or restore archived conversations in this project",
+    passThrough: true
+  },
+  async () => (await import("./archive-6ZENIEBP.js")).archiveCommand
+);
+var doctorCommand = lazyCommand(
+  {
+    name: "doctor",
+    description: "Run health checks against the local Namzu environment",
+    passThrough: true
+  },
+  async () => (await import("./doctor-VXSB4Y4P.js")).doctorCommand
+);
+var execCommand = lazyCommand(
+  {
+    name: "exec",
+    aliases: ["e"],
+    description: "Run a single prompt headlessly: print the reply, or stream events with --json",
+    passThrough: true
+  },
+  async () => (await import("./exec-3T5ESZPH.js")).execCommand
+);
+var residentCommand = lazyCommand(
+  {
+    name: "resident",
+    description: "Manage persistent work and explicitly authorized resident runners (experimental)",
+    passThrough: true
+  },
+  async () => (await import("./resident-5ZY6OG6B.js")).residentCommand
+);
+var loginCommand = lazyCommand(
+  {
+    name: "login",
+    description: "Sign in with a provider subscription and store the credential.",
+    passThrough: true
+  },
+  async () => (await import("./login-26NCG6EQ.js")).loginCommand
+);
+var logoutCommand = lazyCommand(
+  {
+    name: "logout",
+    description: "Remove a credential namzu stored on this machine.",
+    passThrough: true
+  },
+  async () => (await import("./login-26NCG6EQ.js")).logoutCommand
+);
+var mcpCommand = lazyCommand(
+  { name: "mcp", description: "Manage user tool servers", passThrough: true },
+  async () => (await import("./mcp-BTHCU5ZC.js")).mcpCommand
+);
+var drainCommand = lazyCommand(
+  {
+    name: "drain",
+    description: "Continue a turn another process left behind (one pass, then exit)",
+    passThrough: true
+  },
+  async () => (await import("./drain-DXVICQBR.js")).drainCommand
+);
+var evalCommand = lazyCommand(
+  { name: "eval", description: "Run eval suites and set an exit code", passThrough: true },
+  async () => (await import("./eval-BMJQXDKA.js")).evalCommand
+);
+var historyCommand = lazyCommand(
+  {
+    name: "history",
+    description: "Print a session's persisted messages as JSON (for host UIs)",
+    passThrough: true
+  },
+  async () => (await import("./host-queries-QCMWDZGS.js")).historyCommand
+);
+var skillsCommand = lazyCommand(
+  {
+    name: "skills",
+    description: "List skills available to a working directory",
+    passThrough: true
+  },
+  async () => (await import("./skills-KAZJYGX5.js")).skillsCommand
+);
+var skillsJSONCommand = lazyCommand(
+  {
+    name: "skills-json",
+    description: "Print discovered skills as JSON (for host UIs)",
+    passThrough: true
+  },
+  async () => (await import("./host-queries-QCMWDZGS.js")).skillsJSONCommand
+);
+var providersJSONCommand = lazyCommand(
+  {
+    name: "providers-json",
+    description: "Print providers + per-provider models as JSON (for host UIs)",
+    passThrough: true
+  },
+  async () => (await import("./host-queries-QCMWDZGS.js")).providersJSONCommand
+);
+var upgradeCommand = lazyCommand(
+  {
+    name: "upgrade",
+    description: "Update the active global Namzu installation",
+    passThrough: true
+  },
+  async () => (await import("./upgrade-BYM4MWBC.js")).upgradeCommand
+);
+var serveCommand = lazyCommand(
+  {
+    name: "serve",
+    description: "namzu needs no central server; each session is a process"
+  },
+  async () => (await import("./serve-S7UWNIR3.js")).serveCommand
+);
+var stateCommand = lazyCommand(
+  {
+    name: "state",
+    description: "Inspect local Namzu state without changing it",
+    passThrough: true
+  },
+  async () => (await import("./state-263OUKQA.js")).stateCommand
+);
+var scheduleCommand = lazyCommand(
+  {
+    name: "schedule",
+    description: "Scheduled jobs that run while namzu is closed, and the service that runs them",
+    passThrough: true
+  },
+  async () => (await import("./schedule-6JPEO4NR.js")).scheduleCommand
+);
+var browserCommand = lazyCommand(
+  {
+    name: "browser",
+    description: "Browser profiles for the browser tools: sign in, list, status, install, remove",
+    passThrough: true
+  },
+  async () => (await import("./browser-VT2U6NG2.js")).browserCommand
+);
+function createLazyPalCommand(resumeCommand) {
+  return lazyCommand(
+    {
+      name: "pal",
+      description: "Create and operate persistent Pals with their own local virtual computers",
+      passThrough: true
+    },
+    async () => (await import("./pal-YEUKHA6F.js")).createPalCommand(resumeCommand)
+  );
+}
+__name(createLazyPalCommand, "createLazyPalCommand");
+function createLazyWorktreeCommand(open) {
+  return lazyCommand(
+    {
+      name: "worktree",
+      description: "Create, fork, list and resume managed Git worktrees",
+      passThrough: true
+    },
+    async () => (await import("./worktree-K3ZIPXRM.js")).createWorktreeCommand(open)
+  );
+}
+__name(createLazyWorktreeCommand, "createLazyWorktreeCommand");
+
+// src/permissions/mode-names.ts
+var PERMISSION_MODE_NAMES = [
+  "prompt",
+  "accept-edits",
+  "auto",
+  "strict",
+  "plan"
+];
+
+// src/cli.ts
+var EX_USAGE = 64;
+var REMOVED_COMMANDS = {
+  run: '`namzu run` was replaced by `namzu exec "<prompt>"`, which takes the same options.',
+  "run-stream": '`namzu run-stream` was replaced by `namzu exec --json "<prompt>"`, which emits the same events.'
+};
+var CATALOGUE_REFRESH_COMMANDS = /* @__PURE__ */ new Set(["exec", "acp", "drain"]);
+function opensSessions(name, args) {
+  if (CATALOGUE_REFRESH_COMMANDS.has(name)) return true;
+  return name === "resident" && args[0] === "run";
+}
+__name(opensSessions, "opensSessions");
+async function runCli(opts) {
+  let exitCode = 0;
+  const setExitCode = /* @__PURE__ */ __name((code) => {
+    exitCode = code;
+  }, "setExitCode");
+  let catalogueRefresh;
+  const beginCatalogueRefresh = /* @__PURE__ */ __name((config) => {
+    if (catalogueRefresh !== void 0 || config.modelCatalogueRefresh === false) return;
+    try {
+      catalogueRefresh = runtime().startZenCatalogueRefresh({
+        home: runtime().resolveNamzuHome(),
+        // The function, not its current value: see the option's comment.
+        log: runtime().cliLogger
+      });
+    } catch (error) {
+      runtime().cliLogger().warn("Zen model catalogue refresh not started", {
+        "namzu.zen_catalogue.reason": error instanceof Error ? error.message : String(error)
+      });
+    }
+  }, "beginCatalogueRefresh");
+  let rt;
+  const runtime = /* @__PURE__ */ __name(() => {
+    if (rt === void 0) throw new Error("the CLI runtime is used before a command started");
+    return rt;
+  }, "runtime");
+  const program = new Command().name("namzu").description("Operator CLI for the Namzu agent platform").version(CLI_VERSION, "-V, --version", "Print version and exit").addOption(
+    new Option("-f, --format <type>", "Output format: text, json, yaml").choices([
+      "text",
+      "json",
+      "yaml"
+    ])
+  ).option(
+    "--output-schema <path>",
+    "Constrain TUI answers to a JSON Schema file using native structured output (for exec, pass it after the command)"
+  ).option("-q, --quiet", "Suppress non-essential output; also raises the log floor to warn").addOption(
+    new Option("-v, --verbose", "Emit debug-level log records to stderr").conflicts("quiet")
+  ).option("--debug", "Show technical details when something goes wrong (same as NAMZU_DEBUG=1)").addOption(
+    new Option(
+      "--log-format <format>",
+      "Log record format for exec/drain/TUI-flush output: pretty (default) or json. namzu exec --json always writes json, regardless of this flag."
+    ).choices(["pretty", "json"])
+  ).option(
+    "--dangerously-skip-permissions",
+    "Run tools without asking for approval (no permission prompts). Only use in a sandbox or a folder you fully trust."
+  ).option("--yolo", "Alias of --dangerously-skip-permissions.").option(
+    "--provider <id>",
+    "Start the interactive session on this provider for this launch only; the saved choice is untouched."
+  ).option(
+    "--model <id>",
+    "Start the interactive session on this model for this launch only. With --provider it models that provider; alone it re-models the saved primary."
+  ).addOption(
+    new Option(
+      "--effort <level>",
+      "Reasoning effort for this launch only. A level the model does not offer is reported and the default stays."
+    ).choices(REASONING_EFFORT_LEVELS)
+  ).addOption(
+    new Option(
+      "--permission-mode <mode>",
+      "Permission mode for this launch only; wins over --yolo. /permissions changes it from inside."
+    ).choices(PERMISSION_MODE_NAMES)
+  ).option(
+    "--message <text>",
+    "Send this text as the first message once the interactive session is ready, for this launch only. It runs as a plain prompt, never a slash command, and is not sent again on resume."
+  ).option(
+    "--add-dir <path>",
+    "Let the file tools reach another directory this session; repeatable. /add-dir does the same from inside.",
+    (value, previous) => [...previous, value],
+    []
+  ).option(
+    "--profile <name>",
+    "Apply a named profile from the config files. A name no file declares is refused, not ignored."
+  ).hook("preAction", async (command, action) => {
+    rt ??= await import("./cli-runtime-F4MBZ2UQ.js");
+    const launchOnly = ["provider", "model", "effort", "permissionMode", "message"].filter((key) => command.opts()[key] !== void 0);
+    if (launchOnly.length > 0 && !["namzu", "resume"].includes(action.name())) {
+      const flags = launchOnly.map(
+        (key) => `--${key === "permissionMode" ? "permission-mode" : key}`
+      );
+      command.error(
+        action.name() === "exec" || action.name() === "drain" ? `${flags.join(", ")} before the command apply to the interactive TUI; for ${action.name()}, pass them after it: namzu ${action.name()} ${flags[0]} <value> "<prompt>".` : `${flags.join(", ")} apply to the interactive TUI, not this subcommand.`,
+        { exitCode: EX_USAGE, code: "commander.invalidArgument" }
+      );
+    }
+    if (action.name() === "resume" && command.opts().message !== void 0)
+      command.error(
+        "--message is the first message of a new conversation; it is not sent when resuming one.",
+        { exitCode: EX_USAGE, code: "commander.invalidArgument" }
+      );
+    if (command.opts().outputSchema && !["namzu", "resume"].includes(action.name())) {
+      command.error(
+        action.name() === "exec" ? '--output-schema before the command applies to the interactive TUI; for exec, pass it after: namzu exec --output-schema <file> "<prompt>".' : "--output-schema applies to the interactive TUI and to exec, not this subcommand.",
+        {
+          exitCode: EX_USAGE,
+          code: "commander.invalidArgument"
+        }
+      );
+    }
+    if (opensSessions(action.name(), action.args)) {
+      beginCatalogueRefresh(getBootstrapContext().config);
+    }
+  }).enablePositionalOptions(true).exitOverride().showHelpAfterError(false).configureOutput({
+    // Commander's one-line complaint becomes sentences, wrapped, with a way forward.
+    outputError: /* @__PURE__ */ __name((text, write) => write(formatUsageError(text, process.stderr.columns)), "outputError")
+  });
+  const buildContext = /* @__PURE__ */ __name((load) => {
+    const globalOpts = program.opts();
+    const { config: fileConfig, provenance } = load();
+    const cliFormat = (() => {
+      if (globalOpts.format === void 0) return void 0;
+      if (isFormatName(globalOpts.format)) return globalOpts.format;
+      throw new Error(`Commander admitted an invalid --format value: ${globalOpts.format}`);
+    })();
+    const formatFromCli = cliFormat !== void 0;
+    const format = cliFormat ?? fileConfig.format ?? "text";
+    const quiet = globalOpts.quiet ?? fileConfig.quiet ?? false;
+    const envProfile = process.env.NAMZU_PROFILE;
+    const selectedProfile = globalOpts.profile !== void 0 && globalOpts.profile !== "" ? { name: globalOpts.profile, selectedBy: "--profile" } : globalOpts.profile === void 0 && envProfile !== void 0 && envProfile !== "" ? { name: envProfile, selectedBy: "NAMZU_PROFILE" } : void 0;
+    const configDebug = runtime().createConfigDebugSnapshot(provenance, {
+      formatFromCli,
+      quietFromCli: globalOpts.quiet !== void 0,
+      ...selectedProfile ? { selectedProfile } : {}
+    });
+    const logging = {
+      level: runtime().resolveLogLevel({
+        verbose: globalOpts.verbose,
+        quiet: globalOpts.quiet
+      }),
+      format: runtime().resolveLogFormat({ logFormat: globalOpts.logFormat })
+    };
+    return {
+      formatter: createFormatter(format, { quiet }),
+      config: { ...fileConfig, format, quiet },
+      configDebug,
+      logging
+    };
+  }, "buildContext");
+  const selectedConfigOpts = /* @__PURE__ */ __name((cwd) => {
+    const profile = program.opts().profile;
+    return {
+      ...profile !== void 0 ? { profile } : {},
+      ...cwd !== void 0 ? { cwd } : {}
+    };
+  }, "selectedConfigOpts");
+  let bootstrapCtx = null;
+  const trustedContexts = /* @__PURE__ */ new Map();
+  const getTrustedContext = /* @__PURE__ */ __name((cwd) => {
+    const target = resolve(cwd);
+    const cached = trustedContexts.get(target);
+    if (cached) return cached;
+    const loaded = runtime().loadConfigWithProvenance(selectedConfigOpts(target));
+    const trusted = buildContext(() => loaded);
+    runtime().emitBootNarrative(loaded.provenance, loaded.config);
+    trustedContexts.set(target, trusted);
+    return trusted;
+  }, "getTrustedContext");
+  const getBootstrapContext = /* @__PURE__ */ __name(() => {
+    if (bootstrapCtx) return bootstrapCtx;
+    const loaded = runtime().loadBootstrapConfigWithProvenance(selectedConfigOpts());
+    const bootstrap = buildContext(() => loaded);
+    runtime().installCliLogging(
+      runtime().createStderrSink(bootstrap.logging.format),
+      bootstrap.logging.level
+    );
+    bootstrapCtx = bindTrustedProjectContext(bootstrap, getTrustedContext);
+    return bootstrapCtx;
+  }, "getBootstrapContext");
+  const getContext = /* @__PURE__ */ __name(() => {
+    getBootstrapContext();
+    return getTrustedContext(process.cwd());
+  }, "getContext");
+  let recoveryCtx = null;
+  const getRecoveryContext = /* @__PURE__ */ __name(() => {
+    if (recoveryCtx) return recoveryCtx;
+    const globalOpts = program.opts();
+    const format = (() => {
+      if (globalOpts.format === void 0) return "text";
+      if (isFormatName(globalOpts.format)) return globalOpts.format;
+      throw new Error(`Commander admitted an invalid --format value: ${globalOpts.format}`);
+    })();
+    const quiet = globalOpts.quiet ?? false;
+    const logging = {
+      level: runtime().resolveLogLevel({
+        verbose: globalOpts.verbose,
+        quiet: globalOpts.quiet
+      }),
+      format: runtime().resolveLogFormat({ logFormat: globalOpts.logFormat })
+    };
+    runtime().installCliLogging(runtime().createStderrSink(logging.format), logging.level);
+    recoveryCtx = {
+      formatter: createFormatter(format, { quiet }),
+      config: { format, quiet },
+      logging,
+      ...globalOpts.profile ? { selectedProfile: globalOpts.profile } : {}
+    };
+    return recoveryCtx;
+  }, "getRecoveryContext");
+  const getResidentContext = /* @__PURE__ */ __name(() => bindTrustedProjectContext(getRecoveryContext(), getTrustedContext), "getResidentContext");
+  const worktreeCommand = createLazyWorktreeCommand(async (target) => {
+    const previous = process.cwd();
+    try {
+      process.chdir(target.worktree.path);
+      await launchInteractiveTui(target.conversationId);
+    } finally {
+      process.chdir(previous);
+    }
+  });
+  const palCommand = createLazyPalCommand(opts.resumeCommand);
+  for (const def of [
+    acpCommand,
+    palCommand,
+    computerCommand,
+    archiveCommand,
+    doctorCommand,
+    execCommand,
+    residentCommand,
+    loginCommand,
+    logoutCommand,
+    mcpCommand,
+    drainCommand,
+    evalCommand,
+    historyCommand,
+    skillsCommand,
+    skillsJSONCommand,
+    providersJSONCommand,
+    upgradeCommand,
+    serveCommand,
+    stateCommand,
+    scheduleCommand,
+    browserCommand,
+    worktreeCommand
+  ]) {
+    registerCommandOrLazy(program, def, {
+      getContext: def === residentCommand ? getResidentContext : def === stateCommand || def === worktreeCommand || def === mcpCommand || def === archiveCommand ? getRecoveryContext : def === palCommand || def === computerCommand || def === acpCommand || def === execCommand || def === drainCommand || def === skillsCommand || def === upgradeCommand || def === scheduleCommand || def === browserCommand ? getBootstrapContext : getContext,
+      setExitCode
+    });
+  }
+  const launchInteractiveTui = /* @__PURE__ */ __name(async (initialConversationId) => {
+    if (process.stdout.isTTY) {
+      const launchOpts = program.opts();
+      const structuredOutput = launchOpts.outputSchema ? (await import("./output-schema-XCONYVZ7.js")).loadOutputSchema(
+        resolve(process.cwd(), launchOpts.outputSchema)
+      ) : void 0;
+      const skipPermissions = Boolean(launchOpts.dangerouslySkipPermissions || launchOpts.yolo);
+      const provider = launchOpts.provider?.trim();
+      const model = launchOpts.model?.trim();
+      const launchSettings = {
+        ...provider ? { provider } : {},
+        ...model ? { model } : {},
+        ...launchOpts.effort ? { effort: launchOpts.effort } : {},
+        ...launchOpts.permissionMode ? { permissionMode: launchOpts.permissionMode } : {},
+        ...launchOpts.message?.trim() ? { message: launchOpts.message } : {}
+      };
+      const commandCtx = getBootstrapContext();
+      beginCatalogueRefresh(commandCtx.config);
+      const buildTuiContext = /* @__PURE__ */ __name((resolvedCtx, cwd) => {
+        runtime().warnLegacyMcpPermissionNames(resolvedCtx.config.permissions);
+        const permissions = runtime().compilePermissions(
+          resolvedCtx.config.permissions,
+          resolvedCtx.config.permissionChecks
+        );
+        for (const d of permissions.diagnostics) {
+          const where = d.pattern ? `permissions.${d.tool}."${d.pattern}"` : `permissions.${d.tool}`;
+          resolvedCtx.formatter.error({ message: `${where}: ${d.message}` });
+        }
+        const browserConfig = resolvedCtx.config.browser;
+        const browserSites = browserConfig?.enabled === false ? void 0 : runtime().compileBrowserSites(browserConfig?.sites);
+        for (const message of browserSites?.diagnostics ?? []) {
+          resolvedCtx.formatter.error({ message });
+        }
+        const additionalDirectories = [
+          ...resolvedCtx.config.additionalDirectories ?? [],
+          ...launchOpts.addDir ?? []
+        ].map((dir) => resolve(cwd, dir));
+        return {
+          cwd,
+          ...structuredOutput ? { structuredOutput } : {},
+          version: CLI_VERSION,
+          configDebug: resolvedCtx.configDebug,
+          skipPermissions,
+          ...Object.keys(launchSettings).length > 0 ? { launchSettings } : {},
+          ...additionalDirectories.length > 0 ? { additionalDirectories } : {},
+          rules: browserSites ? runtime().withBrowserSiteRules(permissions.rules, browserSites.rules) : permissions.rules,
+          ...browserSites ? { browser: { ...browserConfig, sites: browserSites.sites } } : {},
+          logging: resolvedCtx.logging,
+          ...initialConversationId ? { initialConversationId } : {},
+          ...resolvedCtx.config.mcpServers ? { mcpServers: resolvedCtx.config.mcpServers } : {},
+          ...resolvedCtx.config.plugins ? { plugins: resolvedCtx.config.plugins } : {},
+          ...resolvedCtx.config.skills ? { skills: resolvedCtx.config.skills } : {},
+          ...resolvedCtx.config.composerTriggers ? { composerTriggers: resolvedCtx.config.composerTriggers } : {},
+          ...resolvedCtx.config.web ? { web: resolvedCtx.config.web } : {},
+          ...resolvedCtx.config.hooks ? { hooks: resolvedCtx.config.hooks } : {},
+          ...resolvedCtx.config.compaction ? { compaction: resolvedCtx.config.compaction } : {},
+          ...resolvedCtx.config.memory ? { memory: resolvedCtx.config.memory } : {},
+          ...resolvedCtx.config.limits ? { limits: resolvedCtx.config.limits } : {},
+          ...resolvedCtx.config.sandbox ? { sandbox: resolvedCtx.config.sandbox } : {},
+          // `!== undefined`, never `??`: an empty list is the operator
+          // switching the screens off, and it is the answer this key
+          // exists for. A truthiness test would drop it and the turn
+          // would install the kernel default instead — the opposite
+          // of what was asked for, in the one case the operator was
+          // explicit about.
+          ...resolvedCtx.config.toolResultScreens !== void 0 ? { toolResultScreens: resolvedCtx.config.toolResultScreens } : {},
+          ...resolvedCtx.config.tui ? { tui: resolvedCtx.config.tui } : {}
+        };
+      }, "buildTuiContext");
+      const tuiCtx = buildTuiContext(commandCtx, process.cwd());
+      bindTrustedProjectContext(
+        tuiCtx,
+        (cwd) => buildTuiContext(resolveTrustedProjectContext(commandCtx, cwd), cwd)
+      );
+      const { launchTui } = await import("./tui-5MU7JBXX.js");
+      const resumeCommand = launchOpts.outputSchema ? [
+        ...opts.resumeCommand ?? ["namzu"],
+        "--output-schema",
+        resolve(process.cwd(), launchOpts.outputSchema)
+      ] : opts.resumeCommand;
+      if (resumeCommand) await launchTui(tuiCtx, { resumeCommand });
+      else await launchTui(tuiCtx);
+      const code = await Promise.resolve(0);
+      setExitCode(code);
+      return;
+    }
+    process.stdout.write(
+      "namzu \u2014 interactive TUI requires a terminal. For utility subcommands run `namzu --help`.\n"
+    );
+  }, "launchInteractiveTui");
+  program.command("resume").description("Resume an interactive conversation by its durable id").argument("<conversation-id>", "Conversation id printed when the TUI exited").action(async (conversationId) => {
+    const { scheduledSessionElsewhere } = await import("./resume-command-ONYRZIIA.js");
+    const elsewhere = scheduledSessionElsewhere(
+      runtime().resolveNamzuHome(),
+      conversationId,
+      process.cwd()
+    );
+    if (elsewhere) {
+      process.stderr.write(
+        `namzu: ${conversationId} is a run of the scheduled job ${elsewhere.job.name}, and its conversation is stored with the job\u2019s folder, ${elsewhere.job.folder.canonical}. Open it there:
+  ${elsewhere.command}
+`
+      );
+      setExitCode(EX_USAGE);
+      return;
+    }
+    await launchInteractiveTui(conversationId);
+  });
+  program.action(async () => {
+    await launchInteractiveTui();
+  });
+  try {
+    const removed = firstRootOperand(program, opts.argv.slice(2));
+    const hint = removed !== void 0 ? REMOVED_COMMANDS[removed] : void 0;
+    if (removed !== void 0 && hint !== void 0) {
+      program.error(`error: unknown command '${removed}'
+${hint}`, {
+        exitCode: EX_USAGE,
+        code: "commander.unknownCommand"
+      });
+    }
+    await program.parseAsync(opts.argv, { from: "node" });
+    return exitCode;
+  } catch (err) {
+    if (err instanceof CommanderError) {
+      return mapCommanderError(err);
+    }
+    if (rt !== void 0 && err instanceof rt.ConfigLoadError) {
+      const next = err.complete ? "" : "namzu will not start with a config it cannot read. Fix the file or remove it.\n";
+      const detail = err.complete && err.cause instanceof Error && debugRequested(process.env, opts.argv) ? `${err.cause.message}
+` : "";
+      process.stderr.write(`${err.message}
+${next}${detail}`);
+      return EXIT_BAD_CONFIG;
+    }
+    if (rt !== void 0 && err instanceof rt.ConfigValueError) {
+      const remediation = err.source.kind === "file" ? "Fix the named setting or remove it from that file." : `Fix or unset ${err.source.variable}.`;
+      process.stderr.write(
+        `${err.message}
+namzu will not start with an explicit config value it cannot honour. ${remediation}
+`
+      );
+      return EXIT_BAD_CONFIG;
+    }
+    const { reportCrash } = await import("./crash-report-STOHSORG.js");
+    process.stderr.write(reportCrash(err));
+    return EXIT_INTERNAL_ERROR;
+  } finally {
+    catalogueRefresh?.cancel();
+  }
+}
+__name(runCli, "runCli");
+function firstRootOperand(program, args) {
+  const takesValue = /* @__PURE__ */ __name((flag) => {
+    if (flag === "-h" || flag === "--help") return false;
+    const option = program.options.find((o) => o.long === flag || o.short === flag);
+    if (option === void 0) return void 0;
+    return option.required || option.optional;
+  }, "takesValue");
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") return void 0;
+    if (arg.startsWith("--")) {
+      const eq = arg.indexOf("=");
+      const value = takesValue(eq === -1 ? arg : arg.slice(0, eq));
+      if (value === void 0) return void 0;
+      if (value && eq === -1) i++;
+      continue;
+    }
+    if (arg.length > 1 && arg.startsWith("-")) {
+      const value = takesValue(arg.slice(0, 2));
+      if (value === void 0) return void 0;
+      if (value && arg.length === 2) i++;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+__name(firstRootOperand, "firstRootOperand");
+function mapCommanderError(err) {
+  switch (err.code) {
+    case "commander.helpDisplayed":
+    case "commander.help":
+    case "commander.version":
+      return 0;
+    case "commander.unknownCommand":
+    case "commander.unknownOption":
+    case "commander.missingArgument":
+    case "commander.missingMandatoryOptionValue":
+    case "commander.invalidArgument":
+    case "commander.invalidOptionArgument":
+    case "commander.excessArguments":
+    case "commander.conflictingOption":
+      return EX_USAGE;
+    default:
+      return EXIT_INTERNAL_ERROR;
+  }
+}
+__name(mapCommanderError, "mapCommanderError");
+
+export {
+  registerCommand,
+  registerAll,
+  runCli
+};
+//# sourceMappingURL=chunk-PT537V7B.js.map