@namzu/cli 35.0.0 → 36.1.0

package/dist/chunks/chunk-N5IF64K3.js

@@ -0,0 +1,1858 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  isCompletionArgument
+} from "./chunk-JV3LONAU.js";
+import {
+  SKILL_NAME_MAX_CHARS,
+  SKILL_NAME_PATTERN,
+  resolveTurnGuards
+} from "./chunk-PYG7DZ2D.js";
+import {
+  renderConfigDebug
+} from "./chunk-KU3W6IHV.js";
+import {
+  CLI_VERSION
+} from "./chunk-HE7WUOX2.js";
+import {
+  homePath,
+  plural,
+  shortId,
+  stringWidth
+} from "./chunk-US5ZFPAU.js";
+import {
+  terminalDisplayText
+} from "./chunk-EEDZOGV4.js";
+import {
+  effectivePermissionMode,
+  isPermissionMode,
+  permissionModeDescription,
+  permissionModeLabel
+} from "./chunk-5GRV6P5C.js";
+import {
+  namzuHomePath
+} from "./chunk-NQY5P2EB.js";
+import {
+  RegistryCollisionError,
+  isMemoryType,
+  kernelHostCommands,
+  parseFrontmatter
+} from "./chunk-EWKJGHRO.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/user-commands/store.ts
+import { readFileSync, readdirSync, realpathSync } from "node:fs";
+import { platform } from "node:os";
+import { join, resolve } from "node:path";
+var ARGUMENTS_TOKEN = "$ARGUMENTS";
+function userCommandsDir(home) {
+  return join(namzuHomePath(home), "commands");
+}
+__name(userCommandsDir, "userCommandsDir");
+function projectCommandsDir(cwd = process.cwd()) {
+  return join(cwd, ".namzu", "commands");
+}
+__name(projectCommandsDir, "projectCommandsDir");
+function readCommandsFrom(dir, source) {
+  let files;
+  try {
+    files = readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const file of files) {
+    const path = join(dir, file);
+    const name = file.slice(0, -".md".length);
+    let raw;
+    try {
+      raw = readFileSync(path, "utf8");
+    } catch {
+      continue;
+    }
+    try {
+      if (!raw.trimStart().startsWith("---")) {
+        out.push({ name, description: "(no description)", template: raw.trim(), path, source });
+        continue;
+      }
+      const { values, body } = parseFrontmatter(raw, path);
+      const description = values.description?.kind === "scalar" ? values.description.value : "(no description)";
+      out.push({ name, description, template: body, path, source });
+    } catch (err) {
+      out.push({
+        name,
+        description: "(could not be read)",
+        template: "",
+        path,
+        source,
+        problem: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return out;
+}
+__name(readCommandsFrom, "readCommandsFrom");
+function discoverUserCommands(opts = {}) {
+  const reserved = new Set(opts.reserved ?? []);
+  const userDir = userCommandsDir(opts.home);
+  const projectDir = projectCommandsDir(opts.cwd);
+  const user = readCommandsFrom(userDir, "user");
+  const project = samePhysicalDirectory(userDir, projectDir) ? [] : readCommandsFrom(projectDir, "project");
+  const byName = /* @__PURE__ */ new Map();
+  for (const c of user) byName.set(c.name, c);
+  for (const c of project) byName.set(c.name, c);
+  return [...byName.values()].map(
+    (c) => reserved.has(c.name) ? { ...c, problem: `"/${c.name}" is a built-in command, so this file is not used.` } : c
+  ).sort((a, b) => a.name.localeCompare(b.name));
+}
+__name(discoverUserCommands, "discoverUserCommands");
+function samePhysicalDirectory(left, right) {
+  const canonical = /* @__PURE__ */ __name((path) => {
+    let value;
+    try {
+      value = realpathSync(path);
+    } catch {
+      value = resolve(path);
+    }
+    return platform() === "win32" ? value.toLocaleLowerCase("en-US") : value;
+  }, "canonical");
+  return canonical(left) === canonical(right);
+}
+__name(samePhysicalDirectory, "samePhysicalDirectory");
+function expandHeadlessCommand(prompt, opts = {}) {
+  const trimmed = prompt.trim();
+  if (!trimmed.startsWith("/")) return { kind: "unchanged", prompt };
+  const [token, ...rest] = trimmed.slice(1).split(/\s+/);
+  const name = token ?? "";
+  if (!name) return { kind: "unchanged", prompt };
+  const builtins = new Set(opts.builtins ?? []);
+  if (rest.length === 0 && builtins.has(name)) {
+    return {
+      kind: "refused",
+      reason: `/${name} is an interactive command and does nothing in \`namzu exec\`. Run \`namzu\` for the terminal agent, or pass a prompt instead.`,
+      fixable: true
+    };
+  }
+  const commands = discoverUserCommands({
+    ...opts.home !== void 0 ? { home: opts.home } : {},
+    ...opts.cwd !== void 0 ? { cwd: opts.cwd } : {},
+    reserved: [...builtins]
+  });
+  const found = commands.find((c) => c.name === name);
+  if (!found) return { kind: "unchanged", prompt };
+  const expanded = expandCommand(found, rest.join(" "));
+  return expanded.ok ? { kind: "expanded", prompt: expanded.prompt, name } : (
+    // A command whose FILE is the problem is not fixable by sending a
+    // different prompt. Taken from `found.problem` rather than from the
+    // refusal reason, because that is where the fact lives — reading it back
+    // out of the sentence would make the sentence unrewordable.
+    { kind: "refused", reason: expanded.reason, fixable: found.problem === void 0 }
+  );
+}
+__name(expandHeadlessCommand, "expandHeadlessCommand");
+function expandCommand(command, args) {
+  if (command.problem) return { ok: false, reason: command.problem };
+  const trimmed = args.trim();
+  if (command.template.includes(ARGUMENTS_TOKEN)) {
+    return { ok: true, prompt: command.template.split(ARGUMENTS_TOKEN).join(trimmed) };
+  }
+  if (trimmed.length === 0) return { ok: true, prompt: command.template };
+  return {
+    ok: false,
+    reason: [
+      `/${command.name} takes no arguments, but you gave: ${trimmed}`,
+      "",
+      `Add ${ARGUMENTS_TOKEN} where they belong in ${command.path}, and they will be`,
+      "substituted there. Running it now would silently discard them."
+    ].join("\n")
+  };
+}
+__name(expandCommand, "expandCommand");
+
+// src/installation.ts
+import { createHash } from "node:crypto";
+import { readFileSync as readFileSync2, readdirSync as readdirSync2 } from "node:fs";
+import { dirname, join as join2, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+function fingerprintCli(directory) {
+  const hash = createHash("sha256");
+  const visit = /* @__PURE__ */ __name((folder) => {
+    for (const entry of readdirSync2(folder, { withFileTypes: true }).sort(
+      (a, b) => a.name.localeCompare(b.name, "en")
+    )) {
+      const path = join2(folder, entry.name);
+      if (entry.isDirectory() && !["node_modules", "__tests__", "__fixtures__"].includes(entry.name))
+        visit(path);
+      else if (entry.isFile() && /\.(js|ts|tsx)$/.test(entry.name) && !/\.(d|test|proc-test)\.(js|ts|tsx)$/.test(entry.name)) {
+        hash.update(relative(directory, path).replaceAll("\\", "/"));
+        hash.update("\0");
+        hash.update(readFileSync2(path));
+        hash.update("\0");
+      }
+    }
+  }, "visit");
+  visit(directory);
+  return hash.digest("hex").slice(0, 16);
+}
+__name(fingerprintCli, "fingerprintCli");
+var cached;
+function installationRows() {
+  if (cached) return cached;
+  const directory = dirname(fileURLToPath(new URL("../", import.meta.url).href + "installation.js"));
+  let fingerprint = "unavailable";
+  try {
+    fingerprint = fingerprintCli(directory);
+  } catch {
+  }
+  cached = [
+    ["Version", CLI_VERSION],
+    ["Build", fingerprint],
+    ["Executable", join2(directory, (new URL("../", import.meta.url).href + "installation.js").endsWith(".ts") ? "bin.ts" : "bin.js")]
+  ];
+  return cached;
+}
+__name(installationRows, "installationRows");
+
+// src/tui/terminal-choice-text.ts
+var graphemes = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function eraseLastChoiceGrapheme(source) {
+  let boundary = 0;
+  for (const { index } of graphemes.segment(source)) boundary = index;
+  return source.slice(0, boundary);
+}
+__name(eraseLastChoiceGrapheme, "eraseLastChoiceGrapheme");
+function choiceDisplayText(source) {
+  return terminalDisplayText(source).replace(/[\n\t]/g, " ");
+}
+__name(choiceDisplayText, "choiceDisplayText");
+function choiceDisplayWidth(source) {
+  return stringWidth(choiceDisplayText(source));
+}
+__name(choiceDisplayWidth, "choiceDisplayWidth");
+function wrapChoiceText(source, columns) {
+  const width = Math.max(1, Math.floor(columns));
+  const lines = [];
+  for (const paragraph of terminalDisplayText(source).split("\n").map((line) => line.replace(/\t/g, " "))) {
+    let line = "";
+    for (const word of paragraph.split(" ")) {
+      if (word === "") continue;
+      if (line === "") {
+        line = word;
+        continue;
+      }
+      if (choiceDisplayWidth(`${line} ${word}`) <= width) {
+        line = `${line} ${word}`;
+        continue;
+      }
+      lines.push(line);
+      line = word;
+    }
+    lines.push(line);
+  }
+  return lines.flatMap((line) => breakOverlongWord(line, width));
+}
+__name(wrapChoiceText, "wrapChoiceText");
+function wrapBalancedText(source, columns) {
+  const width = Math.max(1, Math.floor(columns));
+  const greedy = wrapChoiceText(source, width);
+  if (greedy.length < 2) return greedy;
+  let low = 1;
+  let high = width;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (wrapChoiceText(source, middle).length <= greedy.length) high = middle;
+    else low = middle + 1;
+  }
+  return wrapChoiceText(source, high);
+}
+__name(wrapBalancedText, "wrapBalancedText");
+function breakOverlongWord(line, width) {
+  if (choiceDisplayWidth(line) <= width) return [line];
+  const pieces = [];
+  let piece = "";
+  let used = 0;
+  for (const { segment } of graphemes.segment(line)) {
+    const size = stringWidth(segment);
+    if (used + size > width && piece !== "") {
+      pieces.push(piece);
+      piece = "";
+      used = 0;
+    }
+    piece += segment;
+    used += size;
+  }
+  pieces.push(piece);
+  return pieces;
+}
+__name(breakOverlongWord, "breakOverlongWord");
+function capChoiceLines(lines, max, columns) {
+  if (lines.length <= max || max < 1) return lines;
+  const kept = lines.slice(0, max);
+  const last = kept[max - 1] ?? "";
+  return [...kept.slice(0, max - 1), truncateChoiceText(`${last} \u2026`, columns)];
+}
+__name(capChoiceLines, "capChoiceLines");
+function truncateChoiceText(source, columns) {
+  const text = choiceDisplayText(source);
+  const width = Math.max(0, Math.floor(columns));
+  if (width === 0) return "";
+  if (stringWidth(text) <= width) return text;
+  let result = "";
+  let used = 0;
+  for (const { segment } of graphemes.segment(text)) {
+    const size = stringWidth(segment);
+    if (used + size > width - 1) break;
+    result += segment;
+    used += size;
+  }
+  return `${result}\u2026`;
+}
+__name(truncateChoiceText, "truncateChoiceText");
+
+// src/tui/status-card.ts
+function statusCard(rows, columns = 80) {
+  const width = Math.min(96, Math.max(12, columns - 6));
+  const lines = rows.map(([label, value]) => `${label}: ${choiceDisplayText(value)}`);
+  if (width < 30) return ["NAMZU / STATUS", ...lines].join("\n");
+  const inside = width - 4;
+  const title = "\u250C\u2500 NAMZU / STATUS ";
+  const result = [`${title}${"\u2500".repeat(width - stringWidth(title) - 1)}\u2510`];
+  for (const line of lines) {
+    let text = "";
+    let cells = 0;
+    for (const { segment } of new Intl.Segmenter(void 0, { granularity: "grapheme" }).segment(
+      line
+    )) {
+      const size = stringWidth(segment);
+      if (cells + size > inside) {
+        result.push(`\u2502 ${text}${" ".repeat(inside - cells)} \u2502`);
+        text = "  ";
+        cells = 2;
+      }
+      text += segment;
+      cells += size;
+    }
+    result.push(`\u2502 ${text}${" ".repeat(Math.max(0, inside - cells))} \u2502`);
+  }
+  result.push(`\u2514${"\u2500".repeat(width - 2)}\u2518`);
+  return result.join("\n");
+}
+__name(statusCard, "statusCard");
+
+// src/tui/turn-limits-settings.ts
+var TURN_LIMIT_FIELDS = [
+  {
+    name: "tokens",
+    key: "tokenBudget",
+    label: "Token budget",
+    hint: "Whole tokens across the reply and its agents; 0 or unlimited removes the cap."
+  },
+  {
+    name: "iterations",
+    key: "maxIterations",
+    label: "Model calls",
+    hint: "Whole model calls per reply; 0 or unlimited removes the cap."
+  },
+  {
+    name: "time",
+    key: "timeoutMs",
+    label: "Reply duration",
+    hint: "Duration such as 30m, 2h or 1500ms; a bare number is milliseconds. 0 or unlimited removes the cap."
+  }
+];
+function turnLimitsAction(args) {
+  if (args.length === 0) return { kind: "turn-limits-picker" };
+  if (args.length === 1 && args[0] === "unlimited")
+    return { kind: "turn-limits-set", limits: resolveTurnGuards() };
+  const field = TURN_LIMIT_FIELDS.find((field2) => field2.name === args[0]);
+  if (field && args.length === 1) return { kind: "turn-limit-editor", key: field.key };
+  if (field && args.length === 2) {
+    try {
+      const raw = (args[1] ?? "").toLowerCase();
+      const duration = field.key === "timeoutMs" ? /^(\d+(?:\.\d+)?)(ms|s|m|h)$/.exec(raw) : null;
+      const value = raw === "unlimited" ? 0 : duration ? Number(duration[1]) * ({ ms: 1, s: 1e3, m: 6e4, h: 36e5 }[duration[2] ?? "ms"] ?? 1) : /^\d+$/.test(raw) ? Number(raw) : Number.NaN;
+      resolveTurnGuards({ [field.key]: value });
+      return { kind: "turn-limits-set", limits: { [field.key]: value } };
+    } catch {
+      return {
+        kind: "message",
+        role: "system",
+        content: `${field.label} was not changed: ${field.key === "timeoutMs" ? "use a time such as 90s, 5m or 2h" : "use a whole number"}, or 0 or unlimited for no limit. ${field.hint}`
+      };
+    }
+  }
+  return {
+    kind: "message",
+    role: "system",
+    content: "Usage: /config limits [tokens|iterations|time] [value]; /config limits unlimited removes all three caps."
+  };
+}
+__name(turnLimitsAction, "turnLimitsAction");
+function formatTurnLimit(key, value) {
+  if (value === 0) return "Unlimited";
+  if (key === "timeoutMs") {
+    for (const [unit, divisor] of [
+      ["h", 36e5],
+      ["m", 6e4],
+      ["s", 1e3]
+    ])
+      if (value % divisor === 0) return `${value / divisor}${unit}`;
+    return `${value}ms`;
+  }
+  return value.toLocaleString("en-US");
+}
+__name(formatTurnLimit, "formatTurnLimit");
+function turnLimitCommands(limits) {
+  return [
+    ...TURN_LIMIT_FIELDS.map((field) => ({
+      name: `config limits ${field.name}`,
+      label: field.label,
+      description: formatTurnLimit(field.key, limits[field.key])
+    })),
+    {
+      name: "config limits unlimited",
+      label: "Remove all reply limits",
+      description: "Unlimited tokens, model calls and duration. Usage is still measured."
+    }
+  ];
+}
+__name(turnLimitCommands, "turnLimitCommands");
+
+// src/release-notes.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function changelogSection(changelog, version) {
+  const lines = changelog.split("\n");
+  const start = lines.findIndex((line) => line.trim() === `## ${version}`);
+  if (start === -1) return null;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (lines[i]?.startsWith("## ")) {
+      end = i;
+      break;
+    }
+  }
+  const body = lines.slice(start + 1, end).join("\n").trim();
+  return { version, body };
+}
+__name(changelogSection, "changelogSection");
+function changelogVersions(changelog) {
+  return changelog.split("\n").filter((line) => line.startsWith("## ")).map((line) => line.slice(3).trim());
+}
+__name(changelogVersions, "changelogVersions");
+function readChangelog() {
+  try {
+    const here = dirname2(fileURLToPath2(new URL("../", import.meta.url).href + "release-notes.js"));
+    return readFileSync3(join3(here, "..", "CHANGELOG.md"), "utf8");
+  } catch {
+    return null;
+  }
+}
+__name(readChangelog, "readChangelog");
+var RELEASE_NOTES_MAX_LINES = 80;
+function renderReleaseNotes(changelog, version = CLI_VERSION) {
+  if (changelog === null) {
+    return "No release notes: this install has no CHANGELOG.md beside its package.json.";
+  }
+  const section = changelogSection(changelog, version);
+  if (!section) {
+    const known = changelogVersions(changelog).slice(0, 8);
+    return `No notes for ${version}. Versions with notes: ${known.join(", ")}${known.length < changelogVersions(changelog).length ? ", \u2026" : ""}.`;
+  }
+  const lines = section.body.split("\n");
+  const shown = lines.slice(0, RELEASE_NOTES_MAX_LINES);
+  const cut = lines.length > shown.length ? `
+\u2026 ${lines.length - shown.length} more lines in CHANGELOG.md` : "";
+  return `@namzu/cli ${section.version}
+
+${shown.join("\n")}${cut}`;
+}
+__name(renderReleaseNotes, "renderReleaseNotes");
+
+// src/tui/slashCommands.ts
+function renameConversationAction(_ctx, args) {
+  const text = args.join(" ").trim();
+  if (text.toLowerCase() === "clear") return { kind: "title", title: "", clear: true };
+  return { kind: "title", title: text, clear: false };
+}
+__name(renameConversationAction, "renameConversationAction");
+function matchSlashCommands(value, userCommands = [], builtins = CLI_LOCAL_COMMANDS) {
+  const m = /^\/([\w-]*)$/.exec(value);
+  if (!m) return [];
+  const prefix = (m[1] ?? "").toLowerCase();
+  const own = userCommands.map((c) => ({
+    name: c.name,
+    description: c.problem ? `Unavailable: ${c.problem}` : c.description,
+    action: /* @__PURE__ */ __name(() => ({ kind: "none" }), "action")
+  }));
+  const matches = [...builtins.filter((command) => command.discoverable !== false), ...own].filter(
+    (command) => command.name.startsWith(prefix)
+  );
+  if (prefix.length === 0) return matches;
+  const exact = matches.findIndex((command) => command.name === prefix);
+  if (exact <= 0) return matches;
+  const exactMatch = matches[exact];
+  if (!exactMatch) return matches;
+  return [exactMatch, ...matches.slice(0, exact), ...matches.slice(exact + 1)];
+}
+__name(matchSlashCommands, "matchSlashCommands");
+var CommandNameCollisionError = class extends RegistryCollisionError {
+  static {
+    __name(this, "CommandNameCollisionError");
+  }
+  constructor(name) {
+    super(
+      "SlashCommands",
+      name,
+      `/${name} is registered by the kernel AND by this host. One of them would silently never run, and which depends on merge order \u2014 rename one.`
+    );
+    this.name = "CommandNameCollisionError";
+  }
+};
+var HOST_OWNED_COMMAND_NAMES = ["skills", "agents", "goal"];
+function mergeHostCommands(descriptors, locals = CLI_LOCAL_COMMANDS) {
+  const localNames = new Set(locals.map((c) => c.name));
+  const owned = new Set(HOST_OWNED_COMMAND_NAMES);
+  const fromKernel = descriptors.filter((descriptor) => !owned.has(descriptor.name));
+  for (const descriptor of fromKernel) {
+    if (localNames.has(descriptor.name)) throw new CommandNameCollisionError(descriptor.name);
+  }
+  return [
+    ...locals,
+    ...fromKernel.map(
+      (descriptor) => ({
+        name: descriptor.name,
+        description: descriptor.description,
+        help: {
+          // An arbitrary JSON Schema does not declare positional CLI syntax.
+          usage: [`/${descriptor.name}${descriptor.args ? " [arguments]" : ""}`],
+          ...descriptor.hint ? { details: [descriptor.hint] } : {}
+        },
+        action: /* @__PURE__ */ __name((_ctx, args) => ({
+          kind: "host-command",
+          name: descriptor.name,
+          args
+        }), "action")
+      })
+    )
+  ];
+}
+__name(mergeHostCommands, "mergeHostCommands");
+function renderOutcome(outcome) {
+  switch (outcome.kind) {
+    case "ack":
+      return outcome.message;
+    case "prompt":
+      return outcome.text;
+    case "refused":
+      return outcome.reason;
+    case "report": {
+      if (outcome.rows.length === 0) return `${outcome.title}: none.`;
+      const columns = [...new Set(outcome.rows.flatMap((r) => Object.keys(r)))];
+      return [
+        `${outcome.title} (${outcome.rows.length}):`,
+        ...outcome.rows.map(
+          (row) => `  ${columns.map((c) => row[c] === null || row[c] === void 0 ? "-" : String(row[c])).join("  ")}`
+        )
+      ].join("\n");
+    }
+  }
+}
+__name(renderOutcome, "renderOutcome");
+function hostCommandNames(descriptors = kernelCommandDescriptors(), locals = CLI_LOCAL_COMMANDS) {
+  return mergeHostCommands(descriptors, locals).map((c) => c.name);
+}
+__name(hostCommandNames, "hostCommandNames");
+function kernelCommandDescriptors() {
+  return kernelHostCommands({}).map(({ handler: _handler, ...rest }) => rest);
+}
+__name(kernelCommandDescriptors, "kernelCommandDescriptors");
+function parseSlash(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const [name, ...args] = trimmed.slice(1).split(/\s+/);
+  if (!name) return null;
+  return { name, args };
+}
+__name(parseSlash, "parseSlash");
+function commandHelp(ctx, args) {
+  const name = args[0]?.replace(/^\//, "");
+  if (args.length !== 1 || !name) {
+    return {
+      kind: "message",
+      role: "system",
+      content: "Usage: /help [command]. For example: /help permissions."
+    };
+  }
+  const command = (ctx.builtins ?? CLI_LOCAL_COMMANDS).find((entry) => entry.name === name);
+  if (command) {
+    const reason = command.unavailable?.(ctx);
+    return {
+      kind: "message",
+      role: "system",
+      content: [
+        `/${command.name}`,
+        command.description,
+        "",
+        "Usage:",
+        ...(command.help?.usage ?? [`/${command.name}`]).map((usage) => `  ${usage}`),
+        ...command.help?.details?.length ? ["", ...command.help.details] : [],
+        ...reason ? ["", `Unavailable: ${reason}`] : []
+      ].join("\n")
+    };
+  }
+  const user = ctx.userCommands.find((entry) => entry.name === name);
+  if (user) {
+    const acceptsArguments = user.template.includes(ARGUMENTS_TOKEN);
+    return {
+      kind: "message",
+      role: "system",
+      content: [
+        `/${user.name}`,
+        user.description,
+        "",
+        ...user.problem ? [] : [
+          "Usage:",
+          `  /${user.name}${acceptsArguments ? " [arguments]" : ""}`,
+          "",
+          "Running this command sends its saved prompt to the model."
+        ],
+        `${user.source === "project" ? "Project command" : "User command (all projects)"}: ${user.path}`,
+        ...user.problem ? [`Unavailable: ${user.problem}`] : []
+      ].join("\n")
+    };
+  }
+  return {
+    kind: "message",
+    role: "system",
+    content: `Unknown command: /${name}. Use /help to browse available commands.`
+  };
+}
+__name(commandHelp, "commandHelp");
+var CLI_LOCAL_COMMANDS = [
+  {
+    name: "setup",
+    description: "Check provider installation and access; install optional CLIs or connect.",
+    action: /* @__PURE__ */ __name(() => ({ kind: "provider-setup" }), "action")
+  },
+  {
+    name: "config",
+    description: "View configuration and change model, reasoning, permissions and reply limits.",
+    help: {
+      usage: [
+        "/config",
+        "/config sources",
+        "/config limits [tokens|iterations|time] [value]",
+        "/config limits unlimited",
+        "/config triggers [on|off|list]"
+      ],
+      details: [
+        '/config triggers off stops words in a message (hypermode, "save this as a skill") from acting for that message, in your user config; /config triggers on turns them back on; /config triggers lists what is in force.'
+      ]
+    },
+    action: /* @__PURE__ */ __name((ctx, args) => {
+      if (args.length === 0) return { kind: "settings-picker" };
+      if (args[0] === "limits") return turnLimitsAction(args.slice(1));
+      if (args[0] === "triggers") {
+        const setting = (args[1] ?? "list").toLowerCase();
+        if (args.length <= 2 && (setting === "on" || setting === "off" || setting === "list"))
+          return { kind: "composer-triggers", setting };
+        return {
+          kind: "message",
+          role: "system",
+          content: "Usage: /config triggers [on|off|list]"
+        };
+      }
+      return {
+        kind: "message",
+        role: "system",
+        content: args.join(" ") === "sources" ? renderConfigDebug(ctx.configDebug) : "Usage: /config [sources|limits|triggers]"
+      };
+    }, "action")
+  },
+  {
+    name: "settings",
+    description: "View current settings and change model, reasoning or permissions.",
+    action: /* @__PURE__ */ __name(() => ({ kind: "settings-picker" }), "action")
+  },
+  {
+    name: "peers",
+    description: "Find and message other live terminals in this project.",
+    help: { usage: ["/peers [list|on|off]", "/peers send <ref> <message>"] },
+    action: /* @__PURE__ */ __name((_ctx, args) => ({ kind: "peers", args }), "action")
+  },
+  {
+    name: "agents",
+    description: "Inspect delegated agents; /agents available lists configured agents, /agents batches lists past and running batches of delegated work.",
+    help: { usage: ["/agents [running|available|batches]"] },
+    // The subcommands are the delegation UI's (`agentsSlashCommand`): App hands
+    // it the arguments and renders what it answers, usage line included.
+    action: /* @__PURE__ */ __name((_ctx, args) => ({ kind: "agents", args }), "action")
+  },
+  {
+    name: "goal",
+    description: "Manage this conversation\u2019s goal and automatic continuation.",
+    help: {
+      usage: [
+        "/goal",
+        "/goal status",
+        "/goal set [objective]",
+        "/goal edit [objective]",
+        "/goal pause|resume|clear"
+      ],
+      details: [
+        "Set and edit open an editor when no objective is supplied. Direct /goal <objective> also creates a goal.",
+        "Creating or resuming a goal enables automatic work. Pausing or clearing stops future automatic replies."
+      ]
+    },
+    action: /* @__PURE__ */ __name((_ctx, args) => {
+      if (args.length === 0) return { kind: "goal-picker" };
+      if (args.length === 1 && args[0] === "status") {
+        return { kind: "host-command", name: "goal", args: [] };
+      }
+      if (args.length === 1 && (args[0] === "set" || args[0] === "edit")) {
+        return { kind: "goal-editor", edit: args[0] === "edit" };
+      }
+      return { kind: "host-command", name: "goal", args };
+    }, "action")
+  },
+  {
+    name: "schedule",
+    description: "Scheduled jobs that run while namzu is closed: list, confirm, pause, run, add.",
+    help: {
+      usage: [
+        "/schedule",
+        "/schedule confirm|pause|resume|run|remove <job>",
+        '/schedule add <name> "<when>" <read-only|edit-in-folder> <prompt\u2026>'
+      ],
+      details: [
+        "A run waiting for your approval is answered with /resume of its conversation in its folder.",
+        "The scheduler itself is installed with `namzu schedule install`."
+      ]
+    },
+    action: /* @__PURE__ */ __name((_ctx, args) => ({ kind: "host-command", name: "schedule", args }), "action")
+  },
+  {
+    name: "browser",
+    description: "The browser this conversation drives: engine, profile, site rules; switch profile.",
+    help: {
+      usage: ["/browser", "/browser profile <name>"],
+      details: [
+        "A profile holds your sign-ins; sign in once with `namzu browser login <profile> <url>`.",
+        "Site rules come from `browser.sites` in your config."
+      ]
+    },
+    action: /* @__PURE__ */ __name((_ctx, args) => ({ kind: "browser", args }), "action")
+  },
+  {
+    name: "loop",
+    description: "Re-send a prompt to this conversation on an interval, between replies.",
+    help: {
+      usage: ["/loop <interval> <prompt or /command>", "/loop list", "/loop stop <id>|all"],
+      details: [
+        "5m, 1h, or a five-field cron expression. Fires once when idle, never once per missed interval; expires after 7 days."
+      ]
+    },
+    action: /* @__PURE__ */ __name((_ctx, args) => ({ kind: "host-command", name: "loop", args }), "action")
+  },
+  {
+    name: "help",
+    description: "Browse commands, or show usage with /help <command>.",
+    help: {
+      usage: ["/help", "/help <command>"],
+      details: [
+        "Without a name, opens the command menu. With a name, shows help without running the command."
+      ]
+    },
+    action: /* @__PURE__ */ __name((ctx, args) => {
+      if (args.length > 0) return commandHelp(ctx, args);
+      return {
+        kind: "command-picker",
+        commands: [
+          ...(ctx.builtins ?? CLI_LOCAL_COMMANDS).filter((command) => command.discoverable !== false).map((command) => ({
+            name: command.name,
+            description: command.description,
+            ...command.unavailable?.(ctx) ? { problem: command.unavailable(ctx) } : {}
+          })),
+          ...ctx.userCommands.map((command) => ({
+            name: command.name,
+            description: command.description,
+            ...command.problem ? { problem: command.problem } : {}
+          }))
+        ]
+      };
+    }, "action")
+  },
+  {
+    name: "feedback",
+    help: { usage: ["/feedback", "/feedback good|bad [note]"] },
+    unavailable: /* @__PURE__ */ __name((ctx) => ctx.lastAssistantMessageId() ? void 0 : "Nothing to rate yet. Wait for an assistant answer.", "unavailable"),
+    description: "Rate the last answer; choose good/bad or add an optional note.",
+    action: /* @__PURE__ */ __name((ctx, args) => {
+      if (args.length === 0) {
+        const messageId2 = ctx.lastAssistantMessageId();
+        return messageId2 ? { kind: "feedback-picker", messageId: messageId2 } : {
+          kind: "message",
+          role: "system",
+          content: "Nothing to rate yet \u2014 /feedback applies to the last answer in this reply."
+        };
+      }
+      const [rating, ...rest] = args;
+      if (rating !== "good" && rating !== "bad") {
+        return {
+          kind: "message",
+          role: "system",
+          content: "Usage: /feedback good|bad [note]"
+        };
+      }
+      const messageId = ctx.lastAssistantMessageId();
+      if (!messageId) {
+        return {
+          kind: "message",
+          role: "system",
+          content: "Nothing to rate yet \u2014 /feedback applies to the last answer in this reply."
+        };
+      }
+      const note = rest.join(" ").trim();
+      return { kind: "feedback", rating, messageId, ...note ? { note } : {} };
+    }, "action")
+  },
+  {
+    name: "clear",
+    description: "Clear the terminal and start a fresh conversation.",
+    action: /* @__PURE__ */ __name(() => ({ kind: "new-conversation", clearScreen: true }), "action")
+  },
+  {
+    name: "new",
+    description: "Start a fresh conversation without clearing the terminal.",
+    action: /* @__PURE__ */ __name(() => ({ kind: "new-conversation", clearScreen: false }), "action")
+  },
+  {
+    name: "archive",
+    description: "Archive this conversation and exit after confirmation.",
+    action: /* @__PURE__ */ __name(() => ({ kind: "archive-picker" }), "action")
+  },
+  {
+    name: "unarchive",
+    description: "Restore an archived conversation in this project.",
+    action: /* @__PURE__ */ __name(() => ({ kind: "unarchive" }), "action")
+  },
+  {
+    name: "exit",
+    description: "Exit namzu.",
+    action: /* @__PURE__ */ __name(() => ({ kind: "exit" }), "action")
+  },
+  {
+    name: "rename",
+    help: { usage: ["/rename [name]", "/rename clear"] },
+    description: "Rename this conversation; opens an editor when no name is supplied. /rename clear removes the saved name.",
+    action: renameConversationAction
+  },
+  {
+    name: "fork",
+    description: "Continue in a copy of this conversation, leaving the original where it is.",
+    action: /* @__PURE__ */ __name(() => ({ kind: "fork" }), "action")
+  },
+  {
+    name: "worktree",
+    help: {
+      usage: ["/worktree [list|create [name]|fork [name]|resume <name>]"]
+    },
+    description: "List or create separate Git checkouts; fork this conversation into one.",
+    action: /* @__PURE__ */ __name((_ctx, args) => ({ kind: "worktree", args }), "action")
+  },
+  {
+    name: "add-dir",
+    help: {
+      usage: ["/add-dir [path]"],
+      details: ["Without a path, lists added directories. Paths may contain spaces."]
+    },
+    description: "Let the file tools reach another directory in this conversation: /add-dir <path>. Alone, list them.",
+    action: /* @__PURE__ */ __name((ctx, args) => {
+      const path = args.join(" ").trim();
+      if (path.length === 0) {
+        const dirs = ctx.directories?.() ?? [];
+        return {
+          kind: "message",
+          role: "system",
+          content: dirs.length === 0 ? "No added directories. The file tools reach the working directory without asking; a path elsewhere is asked about call by call (refused inside the sandbox). /add-dir <path> adds one for this conversation, after asking when it is outside the working directory; `additionalDirectories` in the config file adds one for every session." : `Added directories (reachable by absolute path, bound into the sandbox):
+${dirs.map((d) => `  ${d}`).join("\n")}`
+        };
+      }
+      return { kind: "add-dir", path };
+    }, "action")
+  },
+  {
+    name: "restore",
+    help: {
+      usage: ["/restore [number]"],
+      details: ["Run /restore to list restore points before choosing one."]
+    },
+    description: "Put files back to how they were before a reply: /restore lists the restore points, /restore N restores.",
+    action: /* @__PURE__ */ __name((_ctx, args) => {
+      const raw = args[0]?.trim();
+      if (!raw) return { kind: "restore" };
+      const turn = Number.parseInt(raw, 10);
+      if (!Number.isInteger(turn) || turn < 1 || String(turn) !== raw) {
+        return {
+          kind: "message",
+          role: "system",
+          content: `/restore takes a number from the list: /restore 3. Not: ${raw}`
+        };
+      }
+      return { kind: "restore", turn };
+    }, "action")
+  },
+  {
+    name: "memory",
+    help: {
+      usage: [
+        "/memory [show|list]",
+        "/memory add [--type user|feedback|project|reference] <text>",
+        "/memory --user add <text>",
+        "/memory import-notes"
+      ],
+      details: [
+        "Show and list read stored and curated memory, with what turns recorded on their own in a section of its own. Add saves a typed memory file for this project (type project unless --type says otherwise); --user appends a note to the curated file for all projects.",
+        "Direct /memory <text> also saves a project note. To save a reserved word as a note, use /memory add show.",
+        "import-notes copies every top-level bullet of the project\u2019s curated MEMORY.md, where #note used to append, into typed memory files, skipping any already stored. The curated file is never changed; delete bullets from it yourself."
+      ]
+    },
+    description: "Show memory, or save a typed project memory with /memory add <text>. Use /memory --user add <text> for every project.",
+    action: /* @__PURE__ */ __name((_ctx, args) => {
+      const user = args[0] === "--user";
+      const memoryArgs = user ? args.slice(1) : args;
+      const text = memoryArgs.join(" ").trim();
+      if (text.length === 0 || ["show", "list"].includes(text.toLowerCase())) {
+        return { kind: "show-memory" };
+      }
+      if (text.toLowerCase() === "import-notes") {
+        if (user) {
+          return {
+            kind: "message",
+            role: "system",
+            content: "import-notes copies project notes; the curated file for all projects stays as it is."
+          };
+        }
+        return { kind: "import-notes" };
+      }
+      if (memoryArgs[0]?.toLowerCase() === "add") {
+        let rest = memoryArgs.slice(1);
+        let memoryType;
+        if (rest[0] === "--type") {
+          const requested = rest[1]?.toLowerCase();
+          if (!isMemoryType(requested) || user) {
+            return {
+              kind: "message",
+              role: "system",
+              content: user ? "--type applies to project memories; /memory --user add appends to the curated file for all projects." : "Usage: /memory add --type user|feedback|project|reference <text>."
+            };
+          }
+          memoryType = requested;
+          rest = rest.slice(2);
+        }
+        const fact = rest.join(" ").trim();
+        if (fact.length === 0) {
+          return {
+            kind: "message",
+            role: "system",
+            content: "Usage: /memory add <text> or /memory --user add <text>. /memory show displays saved memory."
+          };
+        }
+        return {
+          kind: "remember",
+          text: fact,
+          scope: user ? "user" : "project",
+          ...memoryType ? { memoryType } : {}
+        };
+      }
+      return { kind: "remember", text, scope: user ? "user" : "project" };
+    }, "action")
+  },
+  {
+    name: "skills",
+    help: {
+      usage: [
+        "/skills",
+        "/skills list",
+        "/skills new [what it should do]",
+        "/skills save [name]",
+        "/skills save off|on",
+        "/skills <name>"
+      ],
+      details: [
+        "/skills new starts the skill-creator interview; the model drafts a SKILL.md and nothing is saved until you choose where on its confirmation screen.",
+        "/skills save turns what this conversation just did into a skill, generalised and without secrets or tool output, ending on the same confirmation screen.",
+        "/skills save off stops the proposal printed after a multi-step task, in your user config; /skills save on turns it back on."
+      ]
+    },
+    description: "Choose an available skill; /skills list shows them all, /skills new makes one.",
+    action: /* @__PURE__ */ __name((_ctx, args) => {
+      const choice = args.join(" ").trim();
+      if (choice.length === 0) return { kind: "skill-picker" };
+      if (choice.toLowerCase() === "list") return { kind: "list-skills" };
+      if (args[0]?.toLowerCase() === "new")
+        return { kind: "new-skill", idea: args.slice(1).join(" ").trim() };
+      if (args[0]?.toLowerCase() === "save") {
+        const rest = args.slice(1).join(" ").trim();
+        const word = rest.toLowerCase();
+        if (word === "off" || word === "on") return { kind: "skill-suggestions", on: word === "on" };
+        if (rest.length === 0) return { kind: "save-skill" };
+        if (!SKILL_NAME_PATTERN.test(rest) || rest.length > SKILL_NAME_MAX_CHARS) {
+          return {
+            kind: "message",
+            role: "system",
+            content: `"${rest}" is not a skill name: use lowercase letters, digits and single hyphens, at most ${SKILL_NAME_MAX_CHARS} characters (/skills save release-notes).`
+          };
+        }
+        return { kind: "save-skill", name: rest };
+      }
+      return { kind: "load-skill", name: choice };
+    }, "action")
+  },
+  {
+    name: "plugins",
+    description: "Inspect plugins, turn them on or off for this conversation, or remember it after restart.",
+    help: {
+      usage: ["/plugins", "/plugins list", "/plugins <name>"],
+      details: [
+        "Choose a plugin to inspect its contributions or turn it on or off for this conversation. Changes wait until the current reply has finished. Use Keep enabled/disabled after restart to remember its state for future conversations and model switches. Plugin loading must first be enabled in configuration."
+      ]
+    },
+    action: /* @__PURE__ */ __name((_ctx, args) => args.length > 1 ? {
+      kind: "message",
+      role: "system",
+      content: "Usage: /plugins [list|name]"
+    } : {
+      kind: "plugins",
+      list: args[0] === "list",
+      ...args[0] && args[0] !== "list" ? { name: args[0] } : {}
+    }, "action")
+  },
+  {
+    name: "resume",
+    description: "Continue this conversation\u2019s paused reply, or, when it has none, resume a past conversation in this folder.",
+    action: /* @__PURE__ */ __name(() => ({ kind: "resume" }), "action")
+  },
+  {
+    name: "abandon",
+    description: "Close this conversation\u2019s paused or stopped reply without resuming it, so the next prompt starts a new one.",
+    help: { usage: ["/abandon [reason]"] },
+    action: /* @__PURE__ */ __name((_ctx, args) => ({
+      kind: "abandon",
+      reason: args.join(" ").trim() || "Abandoned by the operator with /abandon."
+    }), "action")
+  },
+  {
+    name: "model",
+    description: "Choose a model for the current provider, or change providers.",
+    help: {
+      usage: ["/model", "/model <model-or-provider/model>"],
+      details: [
+        "Pass a model ID to change only this conversation, without a model request. Without an ID, open the searchable picker; press / to search names starting with a reserved shortcut.",
+        "Press p in the model picker to change providers. Normal selections are saved for future launches; temporary credentials keep the selection in this conversation."
+      ]
+    },
+    action: /* @__PURE__ */ __name(() => ({ kind: "repick" }), "action")
+  },
+  {
+    name: "login",
+    description: "Sign in with a Claude or Codex subscription.",
+    help: {
+      usage: ["/login", "/login <callback-address-or-code>"],
+      details: [
+        "Start sign-in with /login, then paste the callback address or code when requested."
+      ]
+    },
+    action: /* @__PURE__ */ __name((_ctx, args) => isCompletionArgument(args) ? { kind: "login", pasted: args.join(" ").trim() } : { kind: "login" }, "action")
+  },
+  {
+    name: "logout",
+    help: { usage: ["/logout [claude|codex|gemini|all]"] },
+    description: "Remove a Namzu-owned credential: /logout [claude|codex|gemini|all].",
+    action: /* @__PURE__ */ __name((_ctx, args) => {
+      const target = args.join(" ").trim().toLowerCase();
+      if (target.length === 0) return { kind: "logout" };
+      if (target === "claude" || target === "anthropic") {
+        return { kind: "logout", target: "anthropic" };
+      }
+      if (target === "codex" || target === "chatgpt") return { kind: "logout", target: "codex" };
+      if (target === "gemini" || target === "google") return { kind: "logout", target: "google" };
+      if (target === "all") return { kind: "logout", target: "all" };
+      return {
+        kind: "message",
+        role: "system",
+        content: "Usage: /logout [claude|codex|gemini|all]"
+      };
+    }, "action")
+  },
+  {
+    name: "cost",
+    help: { usage: ["/cost [details]"] },
+    description: "Show usage and cost for the current or latest reply.",
+    action: /* @__PURE__ */ __name((ctx, args) => reportCommand("cost", args, (details) => renderCost(ctx.usage, ctx.compaction, details)), "action")
+  },
+  {
+    name: "jobs",
+    description: "Inspect background shells, read output, and stop a running shell.",
+    help: { usage: ["/jobs", "/jobs list"] },
+    action: /* @__PURE__ */ __name((ctx, args) => args.length === 0 ? { kind: "jobs" } : args.length === 1 && args[0] === "list" ? { kind: "message", role: "system", content: renderJobs(ctx.jobs()) } : { kind: "message", role: "system", content: "Usage: /jobs [list]" }, "action")
+  },
+  {
+    name: "release-notes",
+    help: { usage: ["/release-notes [version]"] },
+    description: "Show what changed in the version that is running: /release-notes [version].",
+    action: /* @__PURE__ */ __name((_ctx, args) => ({
+      kind: "message",
+      role: "system",
+      content: renderReleaseNotes(readChangelog(), args[0]?.trim() || void 0)
+    }), "action")
+  },
+  {
+    name: "hooks",
+    description: "List the shell hooks this conversation runs, by event.",
+    action: /* @__PURE__ */ __name((ctx) => ({
+      kind: "message",
+      role: "system",
+      content: renderHooks(ctx.hooks?.())
+    }), "action")
+  },
+  {
+    name: "context",
+    help: { usage: ["/context [details]"] },
+    description: "Show context usage and automatic cleanup.",
+    action: /* @__PURE__ */ __name((ctx, args) => reportCommand(
+      "context",
+      args,
+      (details) => renderContext(ctx.usage, ctx.compaction, details)
+    ), "action")
+  },
+  {
+    name: "review",
+    help: {
+      usage: ["/review [instructions]"],
+      details: [
+        "Without instructions, opens the review target menu. Starting a review uses the selected model."
+      ]
+    },
+    description: "Choose a review target, or provide custom instructions: /review [instructions].",
+    action: /* @__PURE__ */ __name((_ctx, args) => {
+      const instructions = args.join(" ").trim();
+      return instructions ? { kind: "review", instructions } : { kind: "review" };
+    }, "action")
+  },
+  {
+    name: "mcp",
+    help: { usage: ["/mcp [tools|details]"] },
+    description: "Show connected tool servers and connection problems.",
+    action: /* @__PURE__ */ __name((ctx, args) => reportCommand("mcp", args, (details) => renderMcp(ctx.mcp(), details), "tools"), "action")
+  },
+  {
+    name: "diff",
+    description: "Show what is uncommitted in this working tree.",
+    action: /* @__PURE__ */ __name(() => ({ kind: "diff" }), "action")
+  },
+  {
+    name: "compact",
+    description: "Summarise the older half of this conversation to free up context.",
+    help: {
+      usage: ["/compact"],
+      details: ["Summarising uses a model call to condense older messages."]
+    },
+    action: /* @__PURE__ */ __name(() => ({ kind: "compact" }), "action")
+  },
+  {
+    name: "copy",
+    description: "Choose the whole latest answer, a code block, or a quote to copy.",
+    action: /* @__PURE__ */ __name(() => ({ kind: "copy" }), "action")
+  },
+  {
+    name: "raw",
+    help: { usage: ["/raw [on|off]"] },
+    description: "Toggle copy-friendly plain transcript rendering: /raw [on|off].",
+    action: /* @__PURE__ */ __name((_ctx, args) => {
+      const choice = args.join(" ").trim().toLowerCase();
+      if (choice.length === 0) return { kind: "raw", enabled: "toggle" };
+      if (choice === "on") return { kind: "raw", enabled: true };
+      if (choice === "off") return { kind: "raw", enabled: false };
+      return {
+        kind: "message",
+        role: "system",
+        content: "Usage: /raw [on|off]"
+      };
+    }, "action")
+  },
+  {
+    name: "export",
+    help: {
+      usage: ["/export [path]"],
+      details: [
+        "Without a path, choose the clipboard or a Markdown file. Existing files are not overwritten. Paths may contain spaces."
+      ]
+    },
+    description: "Export this verified conversation to the clipboard or a Markdown file.",
+    action: /* @__PURE__ */ __name((_ctx, args) => {
+      const path = args.join(" ").trim();
+      return path.length > 0 ? { kind: "export", path } : { kind: "export-picker" };
+    }, "action")
+  },
+  {
+    name: "status",
+    help: { usage: ["/status [details|config|tools]"] },
+    description: "Show the model, permissions, workspace and latest cost.",
+    action: /* @__PURE__ */ __name((ctx, args) => {
+      const which = args.join(" ").trim().toLowerCase();
+      if (which === "config") {
+        return {
+          kind: "message",
+          role: "system",
+          content: renderConfigDebug(ctx.configDebug)
+        };
+      }
+      if (which === "tools") {
+        const tools = ctx.availableTools();
+        return {
+          kind: "message",
+          role: "system",
+          content: tools.length === 0 ? "No tools registered yet \u2014 the model may still be connecting." : `Registered tools (${tools.length}):
+  ${tools.join("\n  ")}`
+        };
+      }
+      if (which.length > 0 && which !== "details") {
+        return {
+          kind: "message",
+          role: "system",
+          content: "Usage: /status [details|config|tools]"
+        };
+      }
+      return {
+        kind: "message",
+        role: "system",
+        content: renderStatus(ctx, which === "details"),
+        ...which === "" ? { statusRows: statusRows(ctx) } : {}
+      };
+    }, "action")
+  },
+  {
+    name: "permissions",
+    description: "Choose which actions need your approval.",
+    help: {
+      usage: ["/permissions", "/permissions details", "/permissions <mode>"],
+      details: [
+        "Choose a preset in the menu, or use a typed mode:",
+        ...["prompt", "accept-edits", "plan", "auto", "strict"].map(
+          (mode) => `  ${mode}: ${permissionModeLabel(mode)}`
+        ),
+        "Changes apply to this conversation. Explicit deny rules and sandbox restrictions still apply."
+      ]
+    },
+    action: /* @__PURE__ */ __name((ctx, args) => {
+      if (args.length === 0) return { kind: "permission-mode-picker" };
+      const mode = args.length === 1 ? args[0]?.toLowerCase() : void 0;
+      if (mode === "details") {
+        return {
+          kind: "message",
+          role: "system",
+          content: renderPermissions(ctx.permissions, true)
+        };
+      }
+      if (isPermissionMode(mode)) return { kind: "permission-mode", mode };
+      return {
+        kind: "message",
+        role: "system",
+        content: "Usage: /permissions opens the permission menu. Choose a preset there, or use /permissions details to view rules."
+      };
+    }, "action")
+  },
+  {
+    name: "effort",
+    help: {
+      usage: ["/effort [level|default]"],
+      details: [
+        "Run /effort to see the levels supported by the selected model and usable fallbacks. Changes affect future replies in this conversation."
+      ]
+    },
+    description: "Choose reasoning effort for future replies: /effort [level|default].",
+    action: /* @__PURE__ */ __name((ctx, args) => {
+      if (args.length === 0) {
+        if (!ctx.providerSummary) {
+          return {
+            kind: "message",
+            role: "system",
+            content: "No provider is active yet. Pick one with /model before changing reasoning."
+          };
+        }
+        if (ctx.reasoningEffort.levels === void 0) {
+          return {
+            kind: "message",
+            role: "system",
+            content: `${ctx.modelSummary ?? "This model"} has no reasoning levels to choose from.`
+          };
+        }
+        return { kind: "reasoning-effort-picker" };
+      }
+      if (!ctx.providerSummary) {
+        return {
+          kind: "message",
+          role: "system",
+          content: "No provider is active yet. Pick one with /model before changing reasoning."
+        };
+      }
+      const token = args.length === 1 ? args[0]?.toLowerCase() : void 0;
+      if (token === "default") return { kind: "reasoning-effort", effort: null };
+      const offered = ctx.reasoningEffort.levels;
+      if (offered === void 0) {
+        return {
+          kind: "message",
+          role: "system",
+          content: `Reasoning was not changed: ${ctx.modelSummary ?? "this model"} has no reasoning levels to choose from. It keeps the provider default.`
+        };
+      }
+      const effort = offered.find((level) => level === token);
+      if (effort) return { kind: "reasoning-effort", effort };
+      const levels = offered.length > 0 ? offered.join("|") : "<none>";
+      return {
+        kind: "message",
+        role: "system",
+        content: `Usage: /effort [${levels}|default]`
+      };
+    }, "action")
+  },
+  {
+    name: "hypermode",
+    help: {
+      usage: ["/hypermode [on|off]"],
+      details: [
+        "A setting for this conversation, not a reasoning-effort level \u2014 see /effort, where it is the last stop. On, effort pins to xhigh (the highest level below it when this model or usable fallback publishes no xhigh) and delegation guidance strengthens toward delegating by default, so independent work goes to parallel agents; off, both revert. With no argument, toggles the current state. When no exact effort menu is published, effort is left as is and the model is told so.",
+        "For one message only, start or end that message with the word hypermode: effort pinned the same way for that reply, then back."
+      ]
+    },
+    description: "Toggle hypermode for this conversation: /hypermode [on|off].",
+    action: /* @__PURE__ */ __name((_ctx, args) => hypermodeAction(args), "action")
+  },
+  {
+    name: "orchestrate",
+    help: {
+      usage: ["/orchestrate [on|off]"],
+      details: [
+        "Deprecated: the mode is now called hypermode. Does what /hypermode does, after saying so."
+      ]
+    },
+    description: "Deprecated: use /hypermode.",
+    action: /* @__PURE__ */ __name((_ctx, args) => hypermodeAction(args, "orchestrate"), "action")
+  },
+  {
+    name: "init",
+    description: "Write an AGENTS.md describing this project to future agents.",
+    help: {
+      usage: ["/init"],
+      details: [
+        "Asks the selected model to read the project and write instructions. Existing instructions are read before changes are proposed."
+      ]
+    },
+    action: /* @__PURE__ */ __name((ctx) => {
+      if (!ctx.providerSummary) {
+        return {
+          kind: "message",
+          role: "system",
+          content: "/init asks the agent to read this repository and write the file, so it needs a provider. Run /model to pick one."
+        };
+      }
+      return { kind: "prompt", text: initPrompt(ctx.instructionFiles) };
+    }, "action")
+  }
+];
+function initPrompt(instructionFiles) {
+  const existing = instructionFiles.length > 0 ? [
+    "",
+    "This project ALREADY has project instructions, loaded from:",
+    ...instructionFiles.map((f) => `  ${f}`),
+    "",
+    "Do not overwrite them. Read them first, then propose specific edits \u2014",
+    "what is now wrong, what is missing \u2014 and make only the changes I agree to."
+  ].join("\n") : ["", "This project has no AGENTS.md yet. Create one at the repository root."].join("\n");
+  return [
+    "Write the project instructions that a coding agent joining this repository would need.",
+    "",
+    "Verify every claim against the tree before you write it. Do not describe a",
+    "command you have not found, a layout you have not opened, or a convention you",
+    "have inferred from one file. If you cannot establish something, leave it out \u2014",
+    "an AGENTS.md full of plausible inventions is worse than a short true one,",
+    "because the next agent will follow it.",
+    existing,
+    "",
+    "Cover what a newcomer cannot get from the file listing:",
+    "  - what this project is, in a sentence or two",
+    "  - the build, test and lint commands that actually work here (check the",
+    "    package manifest or task runner rather than assuming the usual ones)",
+    "  - the layout, and any part of it that is deliberate rather than incidental",
+    "  - conventions the code visibly holds to, with the evidence that shows it",
+    "  - anything that would let someone break the project without noticing",
+    "",
+    "Keep it short enough to be read in full. Every line costs context on every",
+    "future turn, so a sentence that says nothing is not free."
+  ].join("\n");
+}
+__name(initPrompt, "initPrompt");
+function hypermodeAction(args, via) {
+  const choice = args.join(" ").trim().toLowerCase();
+  const alias = via ? { via } : {};
+  if (choice.length === 0) return { kind: "hypermode", enabled: "toggle", ...alias };
+  if (choice === "on") return { kind: "hypermode", enabled: true, ...alias };
+  if (choice === "off") return { kind: "hypermode", enabled: false, ...alias };
+  return {
+    kind: "message",
+    role: "system",
+    content: `Usage: /${via ?? "hypermode"} [on|off]`
+  };
+}
+__name(hypermodeAction, "hypermodeAction");
+function renderHooks(hooks) {
+  const events = Object.entries(hooks ?? {}).filter(([, entries]) => (entries?.length ?? 0) > 0);
+  if (events.length === 0) {
+    return "No hooks. Add a `hooks` key to namzu.config.json or ~/.namzu/config.yaml: event \u2192 list of { command, matcher?, timeoutMs? }.";
+  }
+  const lines = [];
+  for (const [event, entries] of events) {
+    lines.push(`${event}`);
+    for (const entry of entries ?? []) {
+      const when = entry.matcher ? ` \xB7 matches ${entry.matcher}` : "";
+      const deadline = entry.timeoutMs !== void 0 ? ` \xB7 ${Math.round(entry.timeoutMs / 1e3)}s` : "";
+      lines.push(`  ${entry.command}${when}${deadline}`);
+    }
+  }
+  return lines.join("\n");
+}
+__name(renderHooks, "renderHooks");
+function renderJobs(jobs) {
+  if (jobs.length === 0) {
+    return "No background jobs in this conversation. The agent starts one with `run_in_background` on bash.";
+  }
+  const lines = jobs.map((job) => {
+    const state = job.status === "running" ? `running for ${Math.max(1, Math.round((Date.now() - job.startedAt) / 1e3))}s` : job.status === "killed" ? "stopped" : `exited ${job.exitCode ?? "?"}`;
+    return `${job.id}  ${state.padEnd(16)}  ${job.command}`;
+  });
+  return [
+    `${jobs.length} background job${jobs.length === 1 ? "" : "s"} in this conversation:`,
+    ...lines,
+    "",
+    "Use /jobs to inspect output or stop a running shell; /exit stops them all."
+  ].join("\n");
+}
+__name(renderJobs, "renderJobs");
+function reportCommand(name, args, render, detailName = "details") {
+  const option = args.join(" ").trim().toLowerCase();
+  const details = option === detailName || option === "details";
+  return {
+    kind: "message",
+    role: "system",
+    content: option.length === 0 || details ? render(details) : `Usage: /${name} [${detailName}]`
+  };
+}
+__name(reportCommand, "reportCommand");
+function contextMeasurement(usage) {
+  const context = usage?.context;
+  if (!context || context.windowTokens <= 0)
+    return ["No context size yet. It appears after the first reply."];
+  const percent = Math.min(999, Math.round(context.tokens / context.windowTokens * 100));
+  const approx = context.measured && !context.windowAssumed ? "" : "~";
+  return [
+    `Context: ${context.tokens.toLocaleString("en-US")} / ${context.windowTokens.toLocaleString("en-US")} tokens (${approx}${percent}%)`,
+    `${context.measured ? "Counted by the provider" : "Estimated by Namzu"}; window ${context.windowAssumed ? "assumed from a table or default" : "declared by the provider or config"}.`
+  ];
+}
+__name(contextMeasurement, "contextMeasurement");
+function renderContext(usage, compaction, details = false) {
+  const lines = contextMeasurement(usage);
+  if (usage?.context) lines.push("Latest reported context size; not cumulative token usage.");
+  if (!compaction) {
+    lines.push("Automatic summarising starts with the conversation.");
+  } else {
+    lines.push(
+      compaction.passes === 0 ? "Nothing summarised yet in this conversation." : `Summarised ${plural(compaction.passes, "time")} in this conversation, freeing about ${compaction.reclaimedTokens.toLocaleString("en-US")} tokens.`
+    );
+    if (details) {
+      const pct = /* @__PURE__ */ __name((fraction) => `${Math.round(fraction * 100)}%`, "pct");
+      lines.push(`Strategy: ${compaction.strategy}`);
+      if (compaction.strategy === "salience") {
+        lines.push(
+          `Older, less useful content is shortened from ${pct(compaction.softTarget)} of the window; older history is summarised at ${pct(compaction.triggerThreshold)}.`
+        );
+      } else {
+        lines.push(
+          `Older tool results are cleared at ${pct(compaction.triggerThreshold)} of the window; history is summarised if needed.`
+        );
+      }
+      lines.push(
+        `Tool results cleared: ${compaction.clearedResults.toLocaleString("en-US")}`,
+        `Messages shortened: ${compaction.stubbedNarrations.toLocaleString("en-US")}`,
+        `Summaries written: ${compaction.summaries.toLocaleString("en-US")}`
+      );
+    }
+  }
+  if (!details) lines.push("/context details for how the conversation was summarised.");
+  return lines.join("\n");
+}
+__name(renderContext, "renderContext");
+function costAmount(cost) {
+  if (cost.unpricedTokens > 0) {
+    return cost.totalCost > 0 ? `at least $${cost.totalCost.toFixed(4)}` : "not known";
+  }
+  return `$${cost.totalCost.toFixed(4)}${cost.totalCost === 0 ? " (measured zero)" : ""}`;
+}
+__name(costAmount, "costAmount");
+function renderCost(usage, compaction = null, details = false) {
+  if (usage === null) return "No usage reported yet. Send a message to begin.";
+  const lines = [
+    "Current or latest reply",
+    `Tokens: ${usage.totalTokens.toLocaleString("en-US")} (own model calls)`,
+    `Cost: ${costAmount(usage.cost)}`
+  ];
+  if (usage.cost.unpricedTokens > 0) {
+    lines.push(
+      `${usage.cost.unpricedTokens.toLocaleString("en-US")} tokens have no known price and are excluded from the cost.`
+    );
+  }
+  if (usage.budget) {
+    lines.push(
+      `Including delegated agents: ${usage.budget.treeTokens.toLocaleString("en-US")} tokens; limit ${usage.budget.limit === 0 ? "unlimited" : usage.budget.limit.toLocaleString("en-US")}.`
+    );
+    if ((usage.budget.unresolvedRequests ?? 0) > 0)
+      lines.push(
+        `${plural(usage.budget.unresolvedRequests ?? 0, "request")} without confirmed usage; token totals are measured usage, not a complete spend total.`
+      );
+    if (usage.budget.poisoned)
+      lines.push("Further spending is blocked until usage for those requests is confirmed.");
+  }
+  if (details) {
+    lines.push(
+      "Cost covers the latest reply\u2019s own model calls, excluding delegated work and earlier replies. These are not conversation totals."
+    );
+    if (usage.cost.unpricedTokens > 0) {
+      lines.push("Missing prices do not mean those tokens were free.");
+    } else {
+      lines.push("All reported tokens have a known rate.");
+    }
+    if (usage.cost.cacheDiscount > 0)
+      lines.push(`Cache discount: $${usage.cost.cacheDiscount.toFixed(4)}`);
+    if (usage.context && usage.context.windowTokens > 0) {
+      lines.push("", ...contextMeasurement(usage), "/context details for automatic cleanup.");
+    }
+    if (compaction) lines.push(`Cleanup passes in this conversation: ${compaction.passes}.`);
+  } else {
+    lines.push("/cost details for scope and pricing; /context for context size.");
+  }
+  return lines.join("\n");
+}
+__name(renderCost, "renderCost");
+function reviewPrompt(stat, untracked) {
+  const lines = [
+    "Review the uncommitted work in this repository.",
+    "",
+    "`git diff HEAD` reports:",
+    "",
+    stat.length > 0 ? stat : "(no tracked file changed)"
+  ];
+  if (untracked.length > 0) {
+    lines.push("", "Untracked, which no diff shows:", ...untracked.map((p) => `  ${p}`));
+  }
+  lines.push(
+    "",
+    "Read what you need \u2014 the diff, the files around it, the tests. Then report:",
+    "",
+    "- Correctness problems, each tied to a file and line, with the input or",
+    "  state that produces the wrong behaviour. If you cannot name one, do not",
+    "  raise the finding.",
+    "- Anything the change claims in a comment or a message that the code does",
+    "  not do.",
+    "- Tests that would pass whether or not the change is correct.",
+    "",
+    "Do not summarise the diff back to me \u2014 I can read it, and a summary is what",
+    "a review turns into when it has nothing to say. If the work looks right,",
+    "say so in one line and stop. Say plainly what you did not examine."
+  );
+  return lines.join("\n");
+}
+__name(reviewPrompt, "reviewPrompt");
+function baseBranchReviewPrompt(mergeBaseSha) {
+  return reviewTargetPrompt([
+    "Review the changes between the current working tree and its selected base branch.",
+    `The host resolved the merge base to ${mergeBaseSha}.`,
+    `Use \`git diff ${mergeBaseSha}\` as the comparison boundary.`
+  ]);
+}
+__name(baseBranchReviewPrompt, "baseBranchReviewPrompt");
+function commitReviewPrompt(sha) {
+  return reviewTargetPrompt([
+    `Review the code changes introduced by commit ${sha}.`,
+    `Use \`git show --stat --oneline ${sha}\` and \`git diff ${sha}^ ${sha}\` as the boundary.`
+  ]);
+}
+__name(commitReviewPrompt, "commitReviewPrompt");
+function reviewTargetPrompt(target) {
+  return [
+    ...target,
+    "",
+    "Read the changed files and surrounding code, then report prioritized, actionable findings.",
+    "Every finding must name the file, line and concrete state that produces the wrong behavior.",
+    "Do not summarize the change back to me. If there are no findings, say so in one line.",
+    "Say plainly what you did not examine."
+  ].join("\n");
+}
+__name(reviewTargetPrompt, "reviewTargetPrompt");
+function renderMcp(mcp, details = false) {
+  if (mcp === null) return "Not connected yet. Tool servers have not been checked.";
+  if (mcp.connected.length === 0 && mcp.failed.length === 0) {
+    return "No tool servers configured. Add mcpServers to namzu.config.json.";
+  }
+  const lines = [
+    `Tool servers: ${mcp.connected.length} connected, ${mcp.failed.length} unavailable.`
+  ];
+  for (const server of mcp.connected) {
+    lines.push(`${server.name}: connected, ${server.tools.length} tools`);
+    const drift = server.drift;
+    if (drift) {
+      for (const name of drift.added) lines.push(`  added: ${terminalDisplayText(name)}`);
+      for (const name of drift.removed) lines.push(`  removed: ${terminalDisplayText(name)}`);
+      for (const name of drift.changed)
+        lines.push(`  changed, earlier definition held: ${terminalDisplayText(name)}`);
+    }
+    for (const item of server.refused ?? []) {
+      lines.push(`  refused ${item.kind}: ${terminalDisplayText(item.name)} (${item.reason})`);
+    }
+    if (details) {
+      if (server.instructions) {
+        const safe = terminalDisplayText(server.instructions).replace(/\s+/g, " ").trim();
+        lines.push(`  instructions: ${safe.length > 300 ? `${safe.slice(0, 300)}\u2026` : safe}`);
+      }
+      for (const tool of server.tools) lines.push(`  ${tool}`);
+    }
+  }
+  for (const server of mcp.failed) lines.push(`${server.name}: unavailable \u2014 ${server.reason}`);
+  if (!details && mcp.connected.length > 0) lines.push("/mcp tools to list available tools.");
+  return lines.join("\n");
+}
+__name(renderMcp, "renderMcp");
+function statusRows(ctx) {
+  const current = ctx.permissions.currentMode();
+  const permissions = effectivePermissionMode(current.mode, ctx.permissions.approvalLatched());
+  const rows = [
+    ["Version", CLI_VERSION],
+    ["Model", ctx.modelSummary ?? "Not selected"],
+    ["Reasoning", ctx.reasoningEffort.current() ?? "Model default"],
+    ["Provider", ctx.providerSummary ?? "None. Run /model to choose one."],
+    ["Folder", homePath(ctx.cwd)],
+    ["Permissions", permissionModeLabel(permissions)],
+    ["Sandbox", sandboxInWords(ctx.sandbox)],
+    ["Web search", ctx.webSearchSummary ?? "Not set up yet"],
+    ["Tools", String(ctx.availableTools().length)],
+    ["Instructions", ctx.instructionFiles.map((file) => homePath(file)).join(", ") || "None"]
+  ];
+  if (ctx.sandbox?.workspace)
+    rows.push([
+      "Workspace",
+      ctx.sandbox.workspace === "ephemeral" ? "Temporary files, removed when the reply ends" : "Your real project files; edits are kept"
+    ]);
+  if (ctx.sessionId) rows.push(["Conversation", shortId(ctx.sessionId)]);
+  if (ctx.usage) {
+    rows.push(["Tokens", `${ctx.usage.totalTokens.toLocaleString("en-US")} \xB7 latest reply`]);
+    rows.push(["Spend", `${costAmount(ctx.usage.cost)} \xB7 latest reply`]);
+    if (ctx.usage.context) {
+      const context = ctx.usage.context;
+      rows.push([
+        "Context",
+        `${context.tokens.toLocaleString("en-US")} / ${context.windowTokens.toLocaleString("en-US")}${context.measured && !context.windowAssumed ? "" : " \xB7 estimated"}`
+      ]);
+    }
+  }
+  return rows;
+}
+__name(statusRows, "statusRows");
+function sandboxInWords(sandbox) {
+  if (!sandbox) return "Not set up yet";
+  if (sandbox.unconfined) return "Off. Commands run on this computer with your access.";
+  return `${sandbox.environment ?? "On"}${sandbox.enforced.length > 0 ? ` \xB7 limits ${sandbox.enforced.join(", ")}` : ""}`;
+}
+__name(sandboxInWords, "sandboxInWords");
+function renderStatus(ctx, details = false) {
+  if (!details)
+    return `${statusCard(statusRows(ctx), ctx.columns)}
+/config changes settings \xB7 /status details for the full report`;
+  const lines = [
+    `Provider: ${ctx.providerSummary ?? "none \u2014 run /model to choose one"}`,
+    `Model: ${ctx.modelSummary ?? "not selected"}`,
+    `Working directory: ${homePath(ctx.cwd)}`,
+    ...installationRows().map(
+      ([key, value]) => `${key}: ${key === "Executable" ? homePath(value) : value}`
+    ),
+    ...ctx.sessionId ? [`Conversation: ${ctx.sessionId}`] : [],
+    ...renderPermissions(ctx.permissions, details).split("\n")
+  ];
+  const sandbox = ctx.sandbox;
+  if (!sandbox) {
+    lines.push("Sandbox: not resolved yet.");
+  } else if (sandbox.unconfined) {
+    lines.push("Sandbox: commands are not confined; they have this shell\u2019s access.");
+  } else {
+    lines.push(
+      `Sandbox: ${sandbox.environment ?? "active"}; enforces ${sandbox.enforced.join(", ") || "no reported restrictions"}.`
+    );
+  }
+  if (sandbox?.workspace === "ephemeral") {
+    lines.push("Workspace: temporary files; removed when the reply ends.");
+  } else if (sandbox?.workspace === "working-directory" || sandbox?.workspace === "host") {
+    lines.push("Workspace: real project files; edits persist.");
+  }
+  if (details) {
+    for (const dir of ctx.directories?.() ?? []) lines.push(`Additional directory: ${dir}`);
+    if (sandbox) {
+      lines.push(
+        `Required isolation: ${sandbox.required.length > 0 ? sandbox.required.join(", ") : "none"}.`
+      );
+      if (sandbox.required.length > 0)
+        lines.push("Without the required isolation, Namzu will not start.");
+    }
+    lines.push("/status config for setting sources; /status tools for available tools.");
+  }
+  if (ctx.usage) lines.push(`Spend (latest reply): ${costAmount(ctx.usage.cost)}`);
+  if (!details) lines.push("/status details for rules and workspace details.");
+  return lines.join("\n");
+}
+__name(renderStatus, "renderStatus");
+function renderPermissions(permissions, details = false) {
+  const current = permissions.currentMode();
+  const effective = effectivePermissionMode(current.mode, permissions.approvalLatched());
+  const approvedAll = effective !== current.mode;
+  const lines = [
+    `Permissions: ${permissionModeLabel(effective)}. ${approvedAll ? "Tools are approved automatically for this conversation." : permissionModeDescription(effective)}`
+  ];
+  if (approvedAll) lines.push("Choose a preset in /permissions to change this.");
+  if (!details) return lines.join("\n");
+  if (current.source === "launch-bypass")
+    lines.push("Selected at launch with --dangerously-skip-permissions.");
+  if (current.source === "launch-flag") lines.push("Selected at launch with --permission-mode.");
+  lines.push("Explicit deny rules and the built-in safety gate apply in every mode.");
+  if (current.mode === "plan")
+    lines.push("Plan mode also blocks writes that an allow rule would otherwise permit.");
+  const exempt = permissions.neverPrompted();
+  if (exempt.length > 0) {
+    lines.push(`Tools exempt from ordinary prompts: ${exempt.join(", ")}.`);
+    lines.push(
+      "Destructive calls still require review; the selected mode decides whether to allow, ask or refuse. Plan mode still requires read-only tools."
+    );
+  }
+  if (effective === "prompt" || effective === "accept-edits" || effective === "plan") {
+    lines.push(
+      'Read-only agents (explore, or an agent file with readOnly: true) on the conversation\u2019s model start without asking; each call they make is still reviewed. A permissions rule Agent: "ask" asks about every launch.'
+    );
+  }
+  if (permissions.rules.length > 0) {
+    lines.push(
+      `Rules (${permissions.rules.length}):`,
+      ...permissions.rules.map((rule) => `  ${describeRule(rule)}`)
+    );
+  } else {
+    lines.push("No custom rules. Configure permissions in namzu.config.json.");
+  }
+  return lines.join("\n");
+}
+__name(renderPermissions, "renderPermissions");
+function describeRule(rule) {
+  switch (rule.type) {
+    case "deny_by_name":
+      return `deny   ${rule.toolNames.join(", ")}`;
+    case "allow_by_name":
+      return `allow  ${rule.toolNames.join(", ")}`;
+    case "by_source": {
+      const verb = rule.decision === "review" ? "review" : rule.decision;
+      return `${verb}  tools from source ${rule.sources.join(", ")}`;
+    }
+    case "allow_by_category":
+      return `allow  any tool in category: ${rule.categories.join(", ")}`;
+    case "allow_by_tier":
+      return `allow  any tool in tier: ${rule.tiers.join(", ")}`;
+    case "allow_read_only":
+      return "allow  any tool that only observes";
+    case "deny_dangerous_patterns":
+      return "deny   the built-in catastrophic-command patterns";
+    case "argument_pattern": {
+      const verb = rule.decision === "deny" ? "deny  " : "allow ";
+      return `${verb} ${rule.toolNames.join(", ")} when ${rule.argument} matches ${rule.pattern}`;
+    }
+    case "custom_pattern": {
+      const verb = rule.decision === "deny" ? "deny  " : "allow ";
+      const where = rule.target === "both" ? "name+args" : rule.target;
+      return `${verb} ${where} matching ${rule.pattern}`;
+    }
+    case "predicate":
+      return `decide  ${rule.description}`;
+    default: {
+      const exhaustive = rule;
+      return `unrecognised rule: ${JSON.stringify(exhaustive)}`;
+    }
+  }
+}
+__name(describeRule, "describeRule");
+function renderAgents(ids) {
+  if (ids.length === 0) {
+    return "No delegates. This conversation has no delegation tool, so it does the work itself.";
+  }
+  return [
+    `Delegates (${ids.length}):`,
+    ...ids.map((id) => `  ${id}`),
+    "",
+    "The agent dispatches to these itself when a task suits one. It may also",
+    "define a specialist for a single task, which is not listed here because",
+    "it does not exist until the agent asks for it."
+  ].join("\n");
+}
+__name(renderAgents, "renderAgents");
+function runSlash(line, ctx, builtins = CLI_LOCAL_COMMANDS) {
+  const parsed = parseSlash(line);
+  if (!parsed) return null;
+  const cmd = builtins.find((c) => c.name === parsed.name);
+  if (cmd) {
+    const commandContext = { ...ctx, builtins };
+    const reason = cmd.unavailable?.(commandContext);
+    return reason ? { kind: "message", role: "system", content: reason } : cmd.action(commandContext, parsed.args);
+  }
+  const user = ctx.userCommands.find((c) => c.name === parsed.name);
+  if (user) {
+    const expanded = expandCommand(user, parsed.args.join(" "));
+    return expanded.ok ? { kind: "prompt", text: expanded.prompt } : { kind: "message", role: "system", content: expanded.reason };
+  }
+  return {
+    kind: "message",
+    role: "system",
+    content: `Unknown command: /${parsed.name}. Try /help.`
+  };
+}
+__name(runSlash, "runSlash");
+
+export {
+  eraseLastChoiceGrapheme,
+  choiceDisplayText,
+  choiceDisplayWidth,
+  wrapChoiceText,
+  wrapBalancedText,
+  capChoiceLines,
+  truncateChoiceText,
+  TURN_LIMIT_FIELDS,
+  turnLimitCommands,
+  discoverUserCommands,
+  expandHeadlessCommand,
+  matchSlashCommands,
+  mergeHostCommands,
+  renderOutcome,
+  hostCommandNames,
+  kernelCommandDescriptors,
+  reviewPrompt,
+  baseBranchReviewPrompt,
+  commitReviewPrompt,
+  renderAgents,
+  runSlash
+};
+//# sourceMappingURL=chunk-N5IF64K3.js.map