terminal-pilot 0.0.15 → 0.0.17

package/dist/cli.js

@@ -1,65 +1,68 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/cli.ts
 import { realpath } from "node:fs/promises";
-import path11 from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import path14 from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // ../toolcraft/src/cli.ts
-import { access as access2, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
-import path6 from "node:path";
-import { Command as CommanderCommand, CommanderError, InvalidArgumentError, Option } from "commander";
+import { access as access2, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import path9 from "node:path";
+import {
+  Command as CommanderCommand,
+  CommanderError,
+  InvalidArgumentError,
+  Option
+} from "commander";
 
 // ../design-system/src/tokens/colors.ts
 import chalk from "chalk";
 var dark = {
-  header: (text4) => chalk.magentaBright.bold(text4),
-  divider: (text4) => chalk.dim(text4),
-  prompt: (text4) => chalk.cyan(text4),
-  number: (text4) => chalk.cyanBright(text4),
-  intro: (text4) => chalk.bgMagenta.white(` Poe - ${text4} `),
+  header: (text5) => chalk.magentaBright.bold(text5),
+  divider: (text5) => chalk.dim(text5),
+  prompt: (text5) => chalk.cyan(text5),
+  number: (text5) => chalk.cyanBright(text5),
+  intro: (text5) => chalk.bgMagenta.white(` Poe - ${text5} `),
   resolvedSymbol: chalk.magenta("\u25C7"),
   errorSymbol: chalk.red("\u25A0"),
-  accent: (text4) => chalk.cyan(text4),
-  muted: (text4) => chalk.dim(text4),
-  success: (text4) => chalk.green(text4),
-  warning: (text4) => chalk.yellow(text4),
-  error: (text4) => chalk.red(text4),
-  info: (text4) => chalk.magenta(text4),
-  badge: (text4) => chalk.bgYellow.black(` ${text4} `)
+  accent: (text5) => chalk.cyan(text5),
+  muted: (text5) => chalk.dim(text5),
+  success: (text5) => chalk.green(text5),
+  warning: (text5) => chalk.yellow(text5),
+  error: (text5) => chalk.red(text5),
+  info: (text5) => chalk.magenta(text5),
+  badge: (text5) => chalk.bgYellow.black(` ${text5} `)
 };
 var light = {
-  header: (text4) => chalk.hex("#a200ff").bold(text4),
-  divider: (text4) => chalk.hex("#666666")(text4),
-  prompt: (text4) => chalk.hex("#006699").bold(text4),
-  number: (text4) => chalk.hex("#0077cc").bold(text4),
-  intro: (text4) => chalk.bgHex("#a200ff").white(` Poe - ${text4} `),
+  header: (text5) => chalk.hex("#a200ff").bold(text5),
+  divider: (text5) => chalk.hex("#666666")(text5),
+  prompt: (text5) => chalk.hex("#006699").bold(text5),
+  number: (text5) => chalk.hex("#0077cc").bold(text5),
+  intro: (text5) => chalk.bgHex("#a200ff").white(` Poe - ${text5} `),
   resolvedSymbol: chalk.hex("#a200ff")("\u25C7"),
   errorSymbol: chalk.hex("#cc0000")("\u25A0"),
-  accent: (text4) => chalk.hex("#006699").bold(text4),
-  muted: (text4) => chalk.hex("#666666")(text4),
-  success: (text4) => chalk.hex("#008800")(text4),
-  warning: (text4) => chalk.hex("#cc6600")(text4),
-  error: (text4) => chalk.hex("#cc0000")(text4),
-  info: (text4) => chalk.hex("#a200ff")(text4),
-  badge: (text4) => chalk.bgHex("#cc6600").white(` ${text4} `)
+  accent: (text5) => chalk.hex("#006699").bold(text5),
+  muted: (text5) => chalk.hex("#666666")(text5),
+  success: (text5) => chalk.hex("#008800")(text5),
+  warning: (text5) => chalk.hex("#cc6600")(text5),
+  error: (text5) => chalk.hex("#cc0000")(text5),
+  info: (text5) => chalk.hex("#a200ff")(text5),
+  badge: (text5) => chalk.bgHex("#cc6600").white(` ${text5} `)
 };
 
 // ../design-system/src/tokens/typography.ts
 import chalk2 from "chalk";
 var typography = {
-  bold: (text4) => chalk2.bold(text4),
-  dim: (text4) => chalk2.dim(text4),
-  italic: (text4) => chalk2.italic(text4),
-  underline: (text4) => chalk2.underline(text4),
-  strikethrough: (text4) => chalk2.strikethrough(text4)
-};
-
-// ../design-system/src/tokens/widths.ts
-var widths = {
-  header: 60,
-  helpColumn: 24,
-  maxLine: 80
+  bold: (text5) => chalk2.bold(text5),
+  dim: (text5) => chalk2.dim(text5),
+  italic: (text5) => chalk2.italic(text5),
+  underline: (text5) => chalk2.underline(text5),
+  strikethrough: (text5) => chalk2.strikethrough(text5)
 };
 
 // ../design-system/src/components/text.ts
@@ -153,6 +156,12 @@ var text = {
     if (format === "markdown") return `**${content}**`;
     return typography.bold(content);
   },
+  sectionHeader(content) {
+    const format = resolveOutputFormat();
+    if (format === "json") return content;
+    if (format === "markdown") return `## ${content}`;
+    return typography.bold(content.toUpperCase());
+  },
   command(content) {
     const format = resolveOutputFormat();
     if (format === "json") return content;
@@ -465,19 +474,248 @@ function createLogger(emitter) {
 var logger = createLogger();
 
 // ../design-system/src/components/help-formatter.ts
-function formatCommand(name, description) {
-  const paddedName = name.padEnd(widths.helpColumn);
-  return `  ${text.command(paddedName)}  ${description}`;
+function stripAnsi2(value) {
+  let output = "";
+  for (let index = 0; index < value.length; index += 1)
+    if (value[index] === "\x1B" && value[index + 1] === "[")
+      while (index < value.length && value[index] !== "m") index += 1;
+    else output += value[index];
+  return output;
+}
+function visibleWidth(value) {
+  return stripAnsi2(value).length;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function padEndVisible(value, width) {
+  return value + " ".repeat(Math.max(0, width - visibleWidth(value)));
+}
+function isWhitespace(char) {
+  return char === " " || char === "\n" || char === "	" || char === "\r";
+}
+function splitWords(value) {
+  const words = [];
+  let word = "";
+  for (const char of value) {
+    if (isWhitespace(char)) {
+      if (word) {
+        words.push(word);
+        word = "";
+      }
+      continue;
+    }
+    word += char;
+  }
+  if (word) {
+    words.push(word);
+  }
+  return words;
+}
+function wrapWords(value, width) {
+  const words = splitWords(value);
+  if (words.length === 0) {
+    return [""];
+  }
+  const lines = [];
+  let line = "";
+  for (const word of words) {
+    if (!line) {
+      line = word;
+      continue;
+    }
+    if (visibleWidth(line) + 1 + visibleWidth(word) <= width) {
+      line += ` ${word}`;
+      continue;
+    }
+    lines.push(line);
+    line = word;
+  }
+  lines.push(line);
+  return lines;
 }
-function formatOption(flags, description) {
-  const paddedFlags = flags.padEnd(widths.helpColumn);
-  return `  ${text.option(paddedFlags)}  ${description}`;
+function formatColumns(opts) {
+  const { rows } = opts;
+  if (rows.length === 0) {
+    return "";
+  }
+  const totalWidth = opts.totalWidth ?? process.stdout.columns ?? 100;
+  const minLeftWidth = opts.minLeftWidth ?? 12;
+  const maxLeftWidth = opts.maxLeftWidth ?? 32;
+  const gap = opts.gap ?? 3;
+  const indent = opts.indent ?? 2;
+  const maxLeftContentWidth = Math.max(...rows.map((row) => visibleWidth(row.left)));
+  const leftWidth = clamp(maxLeftContentWidth + gap, minLeftWidth, maxLeftWidth);
+  const rightWidth = Math.max(20, totalWidth - leftWidth - indent);
+  const firstIndent = " ".repeat(indent);
+  const continuationIndent = " ".repeat(indent + leftWidth);
+  return rows.flatMap((row) => {
+    if (row.right.length === 0) {
+      return [`${firstIndent}${row.left}`];
+    }
+    const rightLines = wrapWords(row.right, rightWidth);
+    if (visibleWidth(row.left) > leftWidth) {
+      return [
+        `${firstIndent}${row.left}`,
+        ...rightLines.map((line) => `${continuationIndent}${line}`)
+      ];
+    }
+    const firstLine = `${firstIndent}${padEndVisible(row.left, leftWidth)}${rightLines[0]}`;
+    const continuationLines = rightLines.slice(1).map((line) => `${continuationIndent}${line}`);
+    return [firstLine, ...continuationLines];
+  }).join("\n");
 }
 function formatCommandList(commands) {
-  return commands.map((cmd) => formatCommand(cmd.name, cmd.description)).join("\n");
+  return formatColumns({
+    rows: commands.map((cmd) => ({
+      left: text.command(cmd.name),
+      right: cmd.description
+    }))
+  });
 }
 function formatOptionList(options) {
-  return options.map((opt) => formatOption(opt.flags, opt.description)).join("\n");
+  return formatColumns({
+    rows: options.map((opt) => ({
+      left: text.option(opt.flags),
+      right: opt.description
+    }))
+  });
+}
+
+// ../design-system/src/components/help-formatter-plain.ts
+var help_formatter_plain_exports = {};
+__export(help_formatter_plain_exports, {
+  formatColumns: () => formatColumns2,
+  formatCommandList: () => formatCommandList2,
+  formatOptionList: () => formatOptionList2
+});
+function stripAnsi3(value) {
+  let output = "";
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] === "\x1B") {
+      if (value[index + 1] === "[") {
+        index += 2;
+        while (index < value.length) {
+          const code = value.charCodeAt(index);
+          if (code >= 64 && code <= 126) {
+            break;
+          }
+          index += 1;
+        }
+      }
+      continue;
+    }
+    output += value[index];
+  }
+  return output;
+}
+function toAscii(value) {
+  let output = "";
+  const stripped = stripAnsi3(value);
+  for (let index = 0; index < stripped.length; index += 1) {
+    const code = stripped.charCodeAt(index);
+    output += code <= 127 ? stripped[index] : "?";
+  }
+  return output;
+}
+function clamp2(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function padEndVisible2(value, width) {
+  return value + " ".repeat(Math.max(0, width - value.length));
+}
+function isWhitespace2(char) {
+  return char === " " || char === "\n" || char === "	" || char === "\r";
+}
+function splitWords2(value) {
+  const words = [];
+  let word = "";
+  for (const char of value) {
+    if (isWhitespace2(char)) {
+      if (word) {
+        words.push(word);
+        word = "";
+      }
+      continue;
+    }
+    word += char;
+  }
+  if (word) {
+    words.push(word);
+  }
+  return words;
+}
+function wrapWords2(value, width) {
+  const words = splitWords2(value);
+  if (words.length === 0) {
+    return [""];
+  }
+  const lines = [];
+  let line = "";
+  for (const word of words) {
+    if (!line) {
+      line = word;
+      continue;
+    }
+    if (line.length + 1 + word.length <= width) {
+      line += ` ${word}`;
+      continue;
+    }
+    lines.push(line);
+    line = word;
+  }
+  lines.push(line);
+  return lines;
+}
+function formatColumns2(opts) {
+  const rows = opts.rows.map((row) => ({
+    left: toAscii(row.left),
+    right: toAscii(row.right)
+  }));
+  if (rows.length === 0) {
+    return "";
+  }
+  const totalWidth = opts.totalWidth ?? process.stdout.columns ?? 100;
+  const minLeftWidth = opts.minLeftWidth ?? 12;
+  const maxLeftWidth = opts.maxLeftWidth ?? 32;
+  const gap = opts.gap ?? 3;
+  const indent = opts.indent ?? 2;
+  const maxLeftContentWidth = Math.max(...rows.map((row) => row.left.length));
+  const leftWidth = clamp2(maxLeftContentWidth + gap, minLeftWidth, maxLeftWidth);
+  const rightWidth = Math.max(20, totalWidth - leftWidth - indent);
+  const firstIndent = " ".repeat(indent);
+  const continuationIndent = " ".repeat(indent + leftWidth);
+  return rows.flatMap((row) => {
+    if (row.right.length === 0) {
+      return [`${firstIndent}${row.left}`];
+    }
+    const rightLines = wrapWords2(row.right, rightWidth);
+    if (row.left.length > leftWidth) {
+      return [
+        `${firstIndent}${row.left}`,
+        ...rightLines.map((line) => `${continuationIndent}${line}`)
+      ];
+    }
+    const firstLine = `${firstIndent}${padEndVisible2(row.left, leftWidth)}${rightLines[0]}`;
+    const continuationLines = rightLines.slice(1).map((line) => `${continuationIndent}${line}`);
+    return [firstLine, ...continuationLines];
+  }).join("\n");
+}
+function formatCommandList2(commands) {
+  return formatColumns2({
+    rows: commands.map((cmd) => ({
+      left: cmd.name,
+      right: cmd.description
+    }))
+  });
+}
+function formatOptionList2(options) {
+  return formatColumns2({
+    rows: options.map((opt) => ({
+      left: opt.flags,
+      right: opt.description
+    }))
+  });
 }
 
 // ../design-system/src/components/table.ts
@@ -666,7 +904,7 @@ async function confirm2(opts) {
 import chalk16 from "chalk";
 
 // ../toolcraft/src/index.ts
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../toolcraft/src/user-error.ts
 var UserError = class extends Error {
@@ -835,6 +1073,62 @@ var S = {
   Json
 };
 
+// ../toolcraft/src/package-metadata.ts
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function pathFromInput(from) {
+  if (from instanceof URL) {
+    return fileURLToPath(from);
+  }
+  if (from.startsWith("file:")) {
+    return fileURLToPath(from);
+  }
+  return path.resolve(from);
+}
+function getSearchDirectory(from) {
+  const resolved = pathFromInput(from);
+  try {
+    return statSync(resolved).isDirectory() ? resolved : path.dirname(resolved);
+  } catch {
+    return path.dirname(resolved);
+  }
+}
+function readPackageMetadata(packageJsonPath) {
+  const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  const metadata = { path: packageJsonPath };
+  if (typeof parsed.name === "string") {
+    metadata.name = parsed.name;
+  }
+  if (typeof parsed.version === "string") {
+    metadata.version = parsed.version;
+  }
+  return metadata;
+}
+function findPackageMetadata(from) {
+  let current = getSearchDirectory(from);
+  while (true) {
+    const packageJsonPath = path.join(current, "package.json");
+    if (existsSync(packageJsonPath)) {
+      return readPackageMetadata(packageJsonPath);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+function findEntrypointPackageMetadata(entrypoint) {
+  if (entrypoint === void 0 || entrypoint.length === 0) {
+    return void 0;
+  }
+  if (!path.isAbsolute(entrypoint) && !entrypoint.startsWith("file:")) {
+    return void 0;
+  }
+  return findPackageMetadata(entrypoint);
+}
+
 // ../toolcraft/src/index.ts
 var commandConfigSymbol = /* @__PURE__ */ Symbol("toolcraft.command.config");
 var groupConfigSymbol = /* @__PURE__ */ Symbol("toolcraft.group.config");
@@ -920,7 +1214,7 @@ function validateRenameMap(rename2) {
 function parseStackPath(candidate) {
   if (candidate.startsWith("file://")) {
     try {
-      return fileURLToPath(candidate);
+      return fileURLToPath2(candidate);
     } catch {
       return void 0;
     }
@@ -1274,134 +1568,1196 @@ function getCommandSourcePath(command) {
 // ../task-list/src/open.ts
 import * as fsPromises2 from "node:fs/promises";
 
-// ../task-list/src/backends/markdown-dir.ts
-import path2 from "node:path";
-
-// ../file-lock/src/lock.ts
-import * as fsPromises from "node:fs/promises";
-import * as os from "node:os";
-var LockTimeoutError = class extends Error {
-  constructor(message2) {
-    super(message2);
-    this.name = "LockTimeoutError";
-  }
-};
-function createAbortError() {
-  const error2 = new Error("The operation was aborted.");
-  error2.name = "AbortError";
-  return error2;
+// ../task-list/src/state-machine.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function throwIfAborted(signal) {
-  if (signal?.aborted) {
-    throw createAbortError();
+function isStateList(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function canFireFromState(event, fromState) {
+  if (event.from === "*") {
+    return event.to !== fromState;
   }
+  return event.from.includes(fromState);
 }
-function sleep(ms, signal) {
-  if (!signal) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+function validateMachine(machine) {
+  if (!isRecord(machine)) {
+    throw new TypeError("State machine must be an object.");
   }
-  if (signal.aborted) {
-    return Promise.reject(createAbortError());
+  if (!isStateList(machine.states)) {
+    throw new TypeError("State machine states must be a string array.");
   }
-  return new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timeoutId);
-      signal.removeEventListener("abort", onAbort);
-      reject(createAbortError());
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-function backoff(attempt, minTimeout, maxTimeout) {
-  const delay = Math.min(maxTimeout, minTimeout * 2 ** attempt);
-  return delay + Math.random() * delay * 0.1;
-}
-function hasErrorCode(error2, code) {
-  return !!error2 && typeof error2 === "object" && "code" in error2 && error2.code === code;
-}
-function createDefaultFs() {
-  return {
-    open: (path12, flags) => fsPromises.open(path12, flags),
-    stat: fsPromises.stat,
-    unlink: fsPromises.unlink
-  };
-}
-async function removeLockFile(fs2, lockPath) {
-  try {
-    await fs2.unlink(lockPath);
-  } catch (error2) {
-    if (!hasErrorCode(error2, "ENOENT")) {
-      throw error2;
-    }
+  const states = new Set(machine.states);
+  if (typeof machine.initial !== "string") {
+    throw new TypeError("State machine initial must be a string.");
   }
-}
-async function writeLockMetadata(handle) {
-  try {
-    await handle.writeFile(
-      JSON.stringify({ pid: process.pid, host: os.hostname(), acquiredAt: (/* @__PURE__ */ new Date()).toISOString() }),
-      { encoding: "utf8" }
-    );
-  } catch (ignoredError) {
-    void ignoredError;
+  if (!states.has(machine.initial)) {
+    throw new Error(`Initial state "${machine.initial}" is not declared.`);
   }
-  try {
-    await handle.close();
-  } catch (ignoredError) {
-    void ignoredError;
+  if (!isRecord(machine.events)) {
+    throw new TypeError("State machine events must be an object.");
   }
-}
-async function acquireFileLock(filePath, options = {}) {
-  const fs2 = options.fs ?? createDefaultFs();
-  const retries = options.retries ?? 20;
-  const minTimeout = options.minTimeout ?? 25;
-  const maxTimeout = options.maxTimeout ?? 250;
-  const staleMs = options.staleMs ?? 3e4;
-  const lockPath = `${filePath}.lock`;
-  let attempt = 0;
-  while (attempt <= retries) {
-    throwIfAborted(options.signal);
-    try {
-      const handle = await fs2.open(lockPath, "wx");
-      await writeLockMetadata(handle);
-      let released = false;
-      return async () => {
-        if (released) {
-          return;
-        }
-        released = true;
-        await removeLockFile(fs2, lockPath);
-      };
-    } catch (error2) {
-      if (!hasErrorCode(error2, "EEXIST")) {
-        throw error2;
-      }
+  for (const [eventName, event] of Object.entries(machine.events)) {
+    if (!isRecord(event)) {
+      throw new TypeError(`Event "${eventName}" must be an object.`);
     }
-    let stat3;
-    try {
-      stat3 = await fs2.stat(lockPath);
-    } catch (statError) {
-      if (hasErrorCode(statError, "ENOENT")) {
-        continue;
-      }
-      throw statError;
+    if (event.from !== "*" && !isStateList(event.from)) {
+      throw new TypeError(`Event "${eventName}" has an invalid "from" definition.`);
     }
-    if (Date.now() - stat3.mtimeMs > staleMs) {
-      await removeLockFile(fs2, lockPath);
-      continue;
+    if (typeof event.to !== "string") {
+      throw new TypeError(`Event "${eventName}" target state must be a string.`);
     }
-    if (attempt >= retries) {
-      break;
+    if (!states.has(event.to)) {
+      throw new Error(`Event "${eventName}" references unknown target state "${event.to}".`);
     }
-    await sleep(backoff(attempt, minTimeout, maxTimeout), options.signal);
-    attempt += 1;
-  }
-  throw new LockTimeoutError(`Failed to acquire lock on "${filePath}".`);
-}
-
+    if (event.from !== "*") {
+      for (const fromState of event.from) {
+        if (!states.has(fromState)) {
+          throw new Error(`Event "${eventName}" references unknown source state "${fromState}".`);
+        }
+      }
+    }
+  }
+}
+function eventsFromState(machine, fromState) {
+  const events = [];
+  for (const [eventName, event] of Object.entries(machine.events)) {
+    if (canFireFromState(event, fromState)) {
+      events.push(eventName);
+    }
+  }
+  return events;
+}
+function findEvent(machine, fromState, eventName) {
+  const event = machine.events[eventName];
+  if (event === void 0) {
+    return void 0;
+  }
+  return canFireFromState(event, fromState) ? event : void 0;
+}
+
+// ../task-list/src/types.ts
+var TaskNotFoundError = class extends Error {
+  constructor(message2 = "Task not found.") {
+    super(message2);
+    this.name = "TaskNotFoundError";
+  }
+};
+var TaskAlreadyExistsError = class extends Error {
+  constructor(message2 = "Task already exists.") {
+    super(message2);
+    this.name = "TaskAlreadyExistsError";
+  }
+};
+var InvalidTransitionError = class extends Error {
+  task;
+  event;
+  to;
+  reason;
+  constructor(messageOrOptions = "Invalid task transition.") {
+    const options = typeof messageOrOptions === "string" ? {
+      reason: messageOrOptions
+    } : messageOrOptions;
+    super(options.reason);
+    this.name = "InvalidTransitionError";
+    this.task = options.task;
+    this.event = options.event;
+    this.to = options.to;
+    this.reason = options.reason;
+  }
+};
+var MalformedTaskError = class extends Error {
+  constructor(message2 = "Malformed task.") {
+    super(message2);
+    this.name = "MalformedTaskError";
+  }
+};
+var OrderMismatchError = class extends Error {
+  missing;
+  extra;
+  constructor(options) {
+    const parts = [];
+    if (options.missing.length > 0) {
+      parts.push(`missing ${options.missing.map((id) => `"${id}"`).join(", ")}`);
+    }
+    if (options.extra.length > 0) {
+      parts.push(`extra ${options.extra.map((id) => `"${id}"`).join(", ")}`);
+    }
+    super(`reorder requires the exact set of active task ids: ${parts.join("; ")}.`);
+    this.name = "OrderMismatchError";
+    this.missing = options.missing;
+    this.extra = options.extra;
+  }
+};
+var AnchorNotFoundError = class extends Error {
+  anchor;
+  constructor(anchor) {
+    super(`Anchor task "${anchor}" not found.`);
+    this.name = "AnchorNotFoundError";
+    this.anchor = anchor;
+  }
+};
+
+// ../task-list/src/backends/gh-issues-client.ts
+import { text as text4 } from "node:stream/consumers";
+
+// ../process-runner/src/docker/context.ts
+import { execSync } from "node:child_process";
+
+// ../process-runner/src/docker/engine.ts
+import { execSync as execSync2 } from "node:child_process";
+
+// ../process-runner/src/docker/docker-runner.ts
+import * as childProcess from "node:child_process";
+import { randomBytes } from "node:crypto";
+
+// ../process-runner/src/docker/args.ts
+import path2 from "node:path";
+
+// ../process-runner/src/docker/docker-execution-env.ts
+import { createHash, randomBytes as randomBytes2 } from "node:crypto";
+import { mkdtempSync, rmSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path3 from "node:path";
+
+// ../process-runner/src/host/host-runner.ts
+import { spawn as spawnChildProcess } from "node:child_process";
+function createHostRunner(options = {}) {
+  const detached = options.detached === true;
+  return {
+    name: "host",
+    exec(spec) {
+      const stdinMode = spec.stdin ?? "ignore";
+      const stdoutMode = spec.stdout ?? "pipe";
+      const stderrMode = spec.stderr ?? "pipe";
+      const stdio = stdinMode === "inherit" && stdoutMode === "inherit" && stderrMode === "inherit" ? "inherit" : [stdinMode, stdoutMode, stderrMode];
+      const child = spawnChildProcess(spec.command, spec.args ?? [], {
+        cwd: spec.cwd,
+        env: spec.env,
+        stdio,
+        ...detached ? { detached: true } : {}
+      });
+      if (detached) {
+        child.unref();
+      }
+      const kill = (signal) => {
+        if (detached && process.platform !== "win32" && child.pid !== void 0) {
+          process.kill(-child.pid, signal);
+          return;
+        }
+        child.kill(signal);
+      };
+      let settled = false;
+      let resolveResult = null;
+      const result = new Promise((resolve) => {
+        resolveResult = resolve;
+      });
+      const cleanupAbort = bindAbortSignal(spec.signal, () => {
+        kill("SIGTERM");
+      });
+      child.once("close", (code) => {
+        if (settled) return;
+        settled = true;
+        cleanupAbort();
+        resolveResult?.({ exitCode: code ?? 1 });
+      });
+      child.once("error", () => {
+        if (settled) return;
+        settled = true;
+        cleanupAbort();
+        resolveResult?.({ exitCode: 1 });
+      });
+      return {
+        pid: child.pid ?? null,
+        stdin: child.stdin,
+        stdout: child.stdout,
+        stderr: child.stderr,
+        result,
+        kill
+      };
+    }
+  };
+}
+function bindAbortSignal(signal, onAbort) {
+  if (signal === void 0) {
+    return () => {
+    };
+  }
+  if (signal.aborted) {
+    onAbort();
+    return () => {
+    };
+  }
+  signal.addEventListener("abort", onAbort, { once: true });
+  return () => {
+    signal.removeEventListener("abort", onAbort);
+  };
+}
+
+// ../process-runner/src/testing/mock-runner.ts
+import { Readable, Writable } from "node:stream";
+
+// ../task-list/src/backends/gh-issues-client.ts
+var DEFAULT_ENDPOINT = "https://api.github.com/graphql";
+var USER_AGENT = "poe-code-task-list/0.0.1";
+var AUTH_ERROR = "gh auth token failed; install gh, run 'gh auth login', or pass auth: { token }";
+function createGhClient(options) {
+  const fetchImpl = options.fetch ?? fetch;
+  const endpoint = options.endpoint || DEFAULT_ENDPOINT;
+  return {
+    async graphql(query, variables) {
+      const response = await fetchImpl(endpoint, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${options.token}`,
+          "Content-Type": "application/json",
+          "User-Agent": USER_AGENT
+        },
+        body: JSON.stringify({ query, variables })
+      });
+      const body = await response.text();
+      if (response.status !== 200) {
+        throw new Error(`GitHub GraphQL request failed with status ${response.status}: ${body}`);
+      }
+      const parsed = JSON.parse(body);
+      const firstError = parsed.errors?.[0];
+      if (firstError !== void 0) {
+        throw new Error(firstError.message ?? "GitHub GraphQL request failed");
+      }
+      return parsed.data;
+    }
+  };
+}
+async function resolveAuth(options) {
+  if (options.explicitToken !== void 0) {
+    return options.explicitToken;
+  }
+  const runner = options.runner ?? createHostRunner();
+  const handle = runner.exec({
+    command: "gh",
+    args: ["auth", "token"],
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [stdout, , result] = await Promise.all([
+    handle.stdout === null ? Promise.resolve("") : text4(handle.stdout),
+    handle.stderr === null ? Promise.resolve("") : text4(handle.stderr),
+    handle.result
+  ]);
+  const token = stdout.trim();
+  if (result.exitCode !== 0 || token.length === 0) {
+    throw new Error(AUTH_ERROR);
+  }
+  return token;
+}
+function resolveEndpoint(options = {}) {
+  const env = options.env ?? process.env;
+  const host = env.GH_HOST;
+  if (host !== void 0 && host !== "" && host !== "github.com") {
+    return `https://${host}/api/graphql`;
+  }
+  return DEFAULT_ENDPOINT;
+}
+
+// ../task-list/src/backends/utils.ts
+import path4 from "node:path";
+function compareCreated(left, right) {
+  const leftCreated = typeof left.raw.created === "string" ? left.raw.created : "";
+  const rightCreated = typeof right.raw.created === "string" ? right.raw.created : "";
+  if (leftCreated === "" && rightCreated === "") {
+    return left.task.qualifiedId.localeCompare(right.task.qualifiedId);
+  }
+  if (leftCreated === "") return 1;
+  if (rightCreated === "") return -1;
+  return leftCreated.localeCompare(rightCreated);
+}
+function applyOrder(entries, order) {
+  if (order === "alphabetical") {
+    return sortTasks(entries.map((entry) => entry.task));
+  }
+  if (order === "created") {
+    return [...entries].sort(compareCreated).map((entry) => entry.task);
+  }
+  return entries.map((entry) => entry.task);
+}
+var tmpFileCounter = 0;
+function hasErrorCode(error2, code) {
+  return !!error2 && typeof error2 === "object" && "code" in error2 && error2.code === code;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sortStrings(values) {
+  return [...values].sort((left, right) => left.localeCompare(right));
+}
+function sortTasks(tasks) {
+  return [...tasks].sort((left, right) => left.qualifiedId.localeCompare(right.qualifiedId));
+}
+function validateTaskId(id) {
+  if (id.length === 0 || id.startsWith(".") || id.includes("/") || id.includes("\\") || id.includes("..")) {
+    throw new Error(`Invalid task id "${id}".`);
+  }
+  return id;
+}
+async function statIfExists(fs2, filePath) {
+  try {
+    return await fs2.stat(filePath);
+  } catch (error2) {
+    if (hasErrorCode(error2, "ENOENT")) {
+      return void 0;
+    }
+    throw error2;
+  }
+}
+async function writeAtomically(fs2, filePath, content) {
+  const tempPath = `${filePath}.tmp-${process.pid}-${tmpFileCounter}`;
+  tmpFileCounter += 1;
+  await fs2.mkdir(path4.dirname(filePath), { recursive: true });
+  try {
+    await fs2.writeFile(tempPath, content, { encoding: "utf8", flag: "wx" });
+    await fs2.rename(tempPath, filePath);
+  } catch (error2) {
+    try {
+      await fs2.unlink(tempPath);
+    } catch (unlinkError) {
+      if (!hasErrorCode(unlinkError, "ENOENT")) {
+        throw unlinkError;
+      }
+    }
+    throw error2;
+  }
+}
+
+// ../task-list/src/backends/gh-issues.ts
+var PROJECT_ORGANIZATION_QUERY = `query Project($owner: String!, $number: Int!) {
+  organization(login: $owner) {
+    projectV2(number: $number) {
+      id
+      title
+      field(name: "Status") {
+        ... on ProjectV2SingleSelectField {
+          id
+          options { id name }
+        }
+      }
+    }
+  }
+}`;
+var PROJECT_USER_QUERY = `query Project($owner: String!, $number: Int!) {
+  user(login: $owner) {
+    projectV2(number: $number) {
+      id
+      title
+      field(name: "Status") {
+        ... on ProjectV2SingleSelectField {
+          id
+          options { id name }
+        }
+      }
+    }
+  }
+}`;
+var PROJECT_ITEMS_QUERY = `query Items($projectId: ID!, $after: String) {
+  node(id: $projectId) {
+    ... on ProjectV2 {
+      items(first: 100, after: $after) {
+        nodes {
+          id
+          content {
+            __typename
+            ... on Issue {
+              number
+              title
+              body
+              url
+              createdAt
+              labels(first: 50) { nodes { name } }
+              assignees(first: 20) { nodes { login } }
+              milestone { title }
+            }
+          }
+          fieldValueByName(name: "Status") {
+            ... on ProjectV2ItemFieldSingleSelectValue {
+              name
+            }
+          }
+        }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+}`;
+var ISSUE_QUERY = `query Issue($owner: String!, $repo: String!, $number: Int!) {
+  repository(owner: $owner, name: $repo) {
+    issue(number: $number) {
+      number
+      title
+      body
+      url
+      createdAt
+      labels(first: 50) { nodes { name } }
+      assignees(first: 20) { nodes { login } }
+      milestone { title }
+      projectItems(first: 10) {
+        nodes {
+          id
+          project { id }
+          fieldValueByName(name: "Status") {
+            ... on ProjectV2ItemFieldSingleSelectValue {
+              name
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+var REPOSITORY_QUERY = `query Repository($owner: String!, $repo: String!) {
+  repository(owner: $owner, name: $repo) {
+    id
+  }
+}`;
+var ISSUE_ID_QUERY = `query IssueId($owner: String!, $repo: String!, $number: Int!) {
+  repository(owner: $owner, name: $repo) {
+    issue(number: $number) {
+      id
+    }
+  }
+}`;
+var ISSUE_PROJECT_ITEM_QUERY = `query IssueProjectItem($owner: String!, $repo: String!, $number: Int!) {
+  repository(owner: $owner, name: $repo) {
+    issue(number: $number) {
+      id
+      projectItems(first: 10) {
+        nodes {
+          id
+          project { id }
+        }
+      }
+    }
+  }
+}`;
+var CREATE_ISSUE_MUTATION = `mutation CreateIssue($input: CreateIssueInput!) {
+  createIssue(input: $input) {
+    issue {
+      id
+      number
+    }
+  }
+}`;
+var ADD_PROJECT_ITEM_MUTATION = `mutation AddProjectItem($input: AddProjectV2ItemByIdInput!) {
+  addProjectV2ItemById(input: $input) {
+    item {
+      id
+    }
+  }
+}`;
+var UPDATE_STATUS_MUTATION = `mutation UpdateProjectItemStatus($input: UpdateProjectV2ItemFieldValueInput!) {
+  updateProjectV2ItemFieldValue(input: $input) {
+    projectV2Item {
+      id
+    }
+  }
+}`;
+var UPDATE_ISSUE_MUTATION = `mutation UpdateIssue($input: UpdateIssueInput!) {
+  updateIssue(input: $input) {
+    issue {
+      id
+    }
+  }
+}`;
+var UPDATE_PROJECT_ITEM_POSITION_MUTATION = `mutation UpdateProjectItemPosition($input: UpdateProjectV2ItemPositionInput!) {
+  updateProjectV2ItemPosition(input: $input) {
+    clientMutationId
+  }
+}`;
+var DELETE_PROJECT_ITEM_MUTATION = `mutation DeleteProjectItem($input: DeleteProjectV2ItemInput!) {
+  deleteProjectV2Item(input: $input) {
+    deletedItemId
+  }
+}`;
+async function ghIssuesBackend(deps) {
+  const client = createGhClient({
+    token: deps.token,
+    endpoint: deps.endpoint,
+    fetch: deps.fetch
+  });
+  const listName = `${deps.project.owner}/${deps.project.number}`;
+  const variables = {
+    owner: deps.project.owner,
+    number: deps.project.number
+  };
+  const organizationResult = await client.graphql(
+    PROJECT_ORGANIZATION_QUERY,
+    variables
+  );
+  let project = organizationResult.organization?.projectV2 ?? null;
+  if (project === null) {
+    const userResult = await client.graphql(PROJECT_USER_QUERY, variables);
+    project = userResult.user?.projectV2 ?? null;
+  }
+  if (project === null) {
+    throw new Error(`Project ${listName} not found or inaccessible.`);
+  }
+  const field = project.field;
+  if (!isStatusField(field)) {
+    throw new Error(`Project ${listName} has no Status field; gh-issues requires one.`);
+  }
+  if (field.options.length === 0) {
+    throw new Error(`Project ${listName} Status field has no options.`);
+  }
+  const session = createSession(project, field);
+  const repoParts = parseRepo(deps.repo);
+  const context = {
+    client,
+    repoOwner: repoParts.owner,
+    repoName: repoParts.name,
+    issueIds: /* @__PURE__ */ new Map()
+  };
+  function list(name) {
+    assertSingleList(name, listName);
+    return createTasksView(listName, session, context);
+  }
+  return {
+    list,
+    async lists() {
+      return [listName];
+    },
+    async allTasks(filter) {
+      return list(listName).all(filter);
+    },
+    async get(qualifiedId) {
+      const id = parseQualifiedId(qualifiedId, listName);
+      return list(listName).get(id);
+    },
+    async moveBetweenLists(_qualifiedId, _targetList) {
+      throw singleListError(listName);
+    }
+  };
+}
+function createSession(project, field) {
+  const statusOptions = new Map(field.options.map((option) => [option.name, option.id]));
+  const states = field.options.map((option) => option.name);
+  const events = Object.fromEntries(
+    states.map((state) => [state, Object.freeze({ from: "*", to: state })])
+  );
+  const stateMachine = Object.freeze({
+    states: Object.freeze([...states]),
+    initial: states[0],
+    events: Object.freeze(events)
+  });
+  return Object.freeze({
+    projectId: project.id,
+    statusFieldId: field.id,
+    statusOptions,
+    stateMachine
+  });
+}
+function createTasksView(name, session, context) {
+  return {
+    name,
+    stateMachine: session.stateMachine,
+    async all(filter) {
+      if (filter?.includeArchived === true) {
+        return [];
+      }
+      const tasks = await fetchProjectTasks(name, session, context);
+      const filteredTasks = filter?.state === void 0 ? tasks : tasks.filter((task) => task.state === filter.state);
+      if (filter?.order === "alphabetical") {
+        return sortTasks(filteredTasks);
+      }
+      if (filter?.order === "created") {
+        return applyOrder(
+          filteredTasks.map((task) => ({
+            task,
+            raw: {
+              created: task.metadata.created
+            }
+          })),
+          "created"
+        );
+      }
+      return filteredTasks;
+    },
+    async get(id) {
+      return fetchIssueTask(id, name, session, context);
+    },
+    /**
+     * GitHub Issues assigns the issue number, so TaskCreate.id is intentionally ignored.
+     */
+    async create(input) {
+      const repositoryId = await resolveRepositoryId(context);
+      const created = await context.client.graphql(CREATE_ISSUE_MUTATION, {
+        input: {
+          repositoryId,
+          title: input.name,
+          body: input.description ?? ""
+        }
+      });
+      const issue = created.createIssue?.issue;
+      const issueId = issue?.id ?? null;
+      const issueNumber = issue?.number ?? null;
+      if (issueId === null || issueNumber === null) {
+        throw new Error("GitHub createIssue response did not include issue id and number.");
+      }
+      context.issueIds.set(issueNumber, issueId);
+      const added = await context.client.graphql(
+        ADD_PROJECT_ITEM_MUTATION,
+        {
+          input: {
+            projectId: session.projectId,
+            contentId: issueId
+          }
+        }
+      );
+      const projectItemId = added.addProjectV2ItemById?.item?.id ?? null;
+      if (projectItemId === null) {
+        throw new Error("GitHub addProjectV2ItemById response did not include project item id.");
+      }
+      await updateProjectItemStatus(projectItemId, session.stateMachine.initial, session, context);
+      return fetchIssueTask(String(issueNumber), name, session, context);
+    },
+    async update(id, patch) {
+      const input = {};
+      if (patch.name !== void 0) {
+        input.title = patch.name;
+      }
+      if (patch.description !== void 0) {
+        input.body = patch.description;
+      }
+      if (Object.keys(input).length > 0) {
+        input.id = await resolveIssueId(id, name, context);
+        await context.client.graphql(UPDATE_ISSUE_MUTATION, {
+          input
+        });
+      }
+      return fetchIssueTask(id, name, session, context);
+    },
+    async fire(id, event, _opts) {
+      if (!session.statusOptions.has(event)) {
+        throw new InvalidTransitionError({
+          event,
+          to: event,
+          reason: `Unknown gh-issues Status state "${event}".`
+        });
+      }
+      const projectItemId = await resolveProjectItemId(id, name, session, context);
+      await updateProjectItemStatus(projectItemId, event, session, context);
+      return fetchIssueTask(id, name, session, context);
+    },
+    async canFire(id, event) {
+      return findEvent(session.stateMachine, id, event) !== void 0;
+    },
+    async events(id) {
+      return eventsFromState(session.stateMachine, id);
+    },
+    async delete(id) {
+      const projectItemId = await resolveProjectItemId(id, name, session, context);
+      await context.client.graphql(DELETE_PROJECT_ITEM_MUTATION, {
+        input: {
+          projectId: session.projectId,
+          itemId: projectItemId
+        }
+      });
+    },
+    async move(id, anchor) {
+      const projectItemId = await resolveProjectItemId(id, name, session, context);
+      const afterId = await resolveMoveAfterId(id, anchor, name, session, context);
+      await updateProjectItemPosition(projectItemId, afterId, session, context);
+      return fetchIssueTask(id, name, session, context);
+    },
+    async reorder(ids) {
+      const currentTasks = await fetchProjectTasks(name, session, context);
+      const currentIds = currentTasks.map((task) => task.id);
+      const currentSet = new Set(currentIds);
+      const inputSet = new Set(ids);
+      const seenInputIds = /* @__PURE__ */ new Set();
+      const missing = currentIds.filter((id) => !inputSet.has(id));
+      const extra = ids.filter((id) => {
+        if (!currentSet.has(id)) {
+          return true;
+        }
+        if (seenInputIds.has(id)) {
+          return true;
+        }
+        seenInputIds.add(id);
+        return false;
+      });
+      if (missing.length > 0 || extra.length > 0) {
+        throw new OrderMismatchError({ missing, extra });
+      }
+      const itemIdsByTaskId = new Map(
+        currentTasks.map((task) => [task.id, projectItemIdFromTask(task)])
+      );
+      let afterId = null;
+      for (const id of ids) {
+        const projectItemId = itemIdsByTaskId.get(id);
+        if (projectItemId === void 0) {
+          throw new OrderMismatchError({ missing: [id], extra: [] });
+        }
+        await updateProjectItemPosition(projectItemId, afterId, session, context);
+        afterId = projectItemId;
+      }
+      return fetchProjectTasks(name, session, context);
+    }
+  };
+}
+async function resolveRepositoryId(context) {
+  if (context.repositoryId !== void 0) {
+    return context.repositoryId;
+  }
+  const result = await context.client.graphql(REPOSITORY_QUERY, {
+    owner: context.repoOwner,
+    repo: context.repoName
+  });
+  const repositoryId = result.repository?.id ?? null;
+  if (repositoryId === null) {
+    throw new Error(
+      `Repository ${context.repoOwner}/${context.repoName} not found or inaccessible.`
+    );
+  }
+  context.repositoryId = repositoryId;
+  return repositoryId;
+}
+async function resolveIssueId(id, listName, context) {
+  const issueNumber = parseIssueNumber(id, listName);
+  const cachedIssueId = context.issueIds.get(issueNumber);
+  if (cachedIssueId !== void 0) {
+    return cachedIssueId;
+  }
+  const result = await context.client.graphql(ISSUE_ID_QUERY, {
+    owner: context.repoOwner,
+    repo: context.repoName,
+    number: issueNumber
+  });
+  const issueId = result.repository?.issue?.id ?? null;
+  if (issueId === null) {
+    throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
+  }
+  context.issueIds.set(issueNumber, issueId);
+  return issueId;
+}
+async function resolveProjectItemId(id, listName, session, context) {
+  const issueNumber = parseIssueNumber(id, listName);
+  const result = await context.client.graphql(ISSUE_PROJECT_ITEM_QUERY, {
+    owner: context.repoOwner,
+    repo: context.repoName,
+    number: issueNumber
+  });
+  const issue = result.repository?.issue ?? null;
+  if (issue === null) {
+    throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
+  }
+  if (issue.id !== void 0 && issue.id !== null) {
+    context.issueIds.set(issueNumber, issue.id);
+  }
+  const projectItem = issue.projectItems?.nodes?.find((item) => item.project?.id === session.projectId) ?? null;
+  if (projectItem === null) {
+    throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
+  }
+  return projectItem.id;
+}
+async function updateProjectItemStatus(projectItemId, state, session, context) {
+  const optionId = session.statusOptions.get(state);
+  if (optionId === void 0) {
+    throw new InvalidTransitionError({
+      to: state,
+      reason: `Unknown gh-issues Status state "${state}".`
+    });
+  }
+  await context.client.graphql(UPDATE_STATUS_MUTATION, {
+    input: {
+      projectId: session.projectId,
+      itemId: projectItemId,
+      fieldId: session.statusFieldId,
+      value: {
+        singleSelectOptionId: optionId
+      }
+    }
+  });
+}
+async function updateProjectItemPosition(projectItemId, afterId, session, context) {
+  await context.client.graphql(UPDATE_PROJECT_ITEM_POSITION_MUTATION, {
+    input: {
+      projectId: session.projectId,
+      itemId: projectItemId,
+      afterId
+    }
+  });
+}
+async function resolveMoveAfterId(movingId, anchor, listName, session, context) {
+  if ("position" in anchor) {
+    if (anchor.position === "top") {
+      return null;
+    }
+    const tasks2 = await fetchProjectTasks(listName, session, context);
+    for (let index = tasks2.length - 1; index >= 0; index -= 1) {
+      const task = tasks2[index];
+      if (task.id !== movingId) {
+        return projectItemIdFromTask(task);
+      }
+    }
+    return null;
+  }
+  const anchorId = "before" in anchor ? anchor.before : anchor.after;
+  let anchorProjectItemId;
+  try {
+    anchorProjectItemId = await resolveProjectItemId(anchorId, listName, session, context);
+  } catch (error2) {
+    if (error2 instanceof TaskNotFoundError) {
+      throw new AnchorNotFoundError(anchorId);
+    }
+    throw error2;
+  }
+  if ("after" in anchor) {
+    return anchorProjectItemId;
+  }
+  const tasks = await fetchProjectTasks(listName, session, context);
+  const anchorIndex = tasks.findIndex((task) => task.id === anchorId);
+  if (anchorIndex < 0) {
+    throw new AnchorNotFoundError(anchorId);
+  }
+  for (let index = anchorIndex - 1; index >= 0; index -= 1) {
+    const predecessor = tasks[index];
+    if (predecessor.id !== movingId) {
+      return projectItemIdFromTask(predecessor);
+    }
+  }
+  return null;
+}
+async function fetchProjectTasks(listName, session, context) {
+  const tasks = [];
+  let after = null;
+  do {
+    const result = await context.client.graphql(
+      PROJECT_ITEMS_QUERY,
+      {
+        projectId: session.projectId,
+        after
+      }
+    );
+    const items = result.node?.items;
+    for (const item of items?.nodes ?? []) {
+      const task = mapProjectItemToTask(item, listName, session);
+      if (task !== null) {
+        tasks.push(task);
+      }
+    }
+    after = items?.pageInfo?.hasNextPage === true ? items.pageInfo.endCursor ?? null : null;
+  } while (after !== null);
+  return tasks;
+}
+async function fetchIssueTask(id, listName, session, context) {
+  const issueNumber = parseIssueNumber(id, listName);
+  const result = await context.client.graphql(ISSUE_QUERY, {
+    owner: context.repoOwner,
+    repo: context.repoName,
+    number: issueNumber
+  });
+  const issue = result.repository?.issue ?? null;
+  if (issue === null) {
+    throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
+  }
+  const projectItem = issue.projectItems?.nodes?.find((item) => item.project?.id === session.projectId) ?? null;
+  if (projectItem === null) {
+    throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
+  }
+  return mapIssueToTask({
+    issue,
+    projectItemId: projectItem.id,
+    statusName: projectItem.fieldValueByName?.name ?? null,
+    listName,
+    initialState: session.stateMachine.initial
+  });
+}
+function parseIssueNumber(id, listName) {
+  const issueNumber = Number(id);
+  if (!Number.isInteger(issueNumber) || issueNumber < 1) {
+    throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
+  }
+  return issueNumber;
+}
+function mapProjectItemToTask(item, listName, session) {
+  const content = item.content;
+  if (!isIssueNode(content)) {
+    return null;
+  }
+  return mapIssueToTask({
+    issue: content,
+    projectItemId: item.id,
+    statusName: item.fieldValueByName?.name ?? null,
+    listName,
+    initialState: session.stateMachine.initial
+  });
+}
+function isIssueNode(value) {
+  return isRecord3(value) && value.__typename === "Issue" && typeof value.number === "number" && typeof value.title === "string" && typeof value.url === "string" && typeof value.createdAt === "string";
+}
+function mapIssueToTask(options) {
+  const id = String(options.issue.number);
+  const labels = (options.issue.labels?.nodes ?? []).filter((node) => node !== null).map((node) => node.name);
+  const assignees = (options.issue.assignees?.nodes ?? []).filter((node) => node !== null).map((node) => node.login);
+  return {
+    list: options.listName,
+    id,
+    qualifiedId: `${options.listName}/${id}`,
+    name: options.issue.title,
+    description: options.issue.body ?? "",
+    state: options.statusName ?? options.initialState,
+    metadata: {
+      url: options.issue.url,
+      labels,
+      assignees,
+      milestone: options.issue.milestone?.title ?? null,
+      projectItemId: options.projectItemId,
+      created: options.issue.createdAt
+    }
+  };
+}
+function projectItemIdFromTask(task) {
+  const projectItemId = task.metadata.projectItemId;
+  if (typeof projectItemId !== "string") {
+    throw new Error(`Task "${task.qualifiedId}" is missing GitHub project item metadata.`);
+  }
+  return projectItemId;
+}
+function parseRepo(repo) {
+  const parts = repo.split("/");
+  if (parts.length !== 2 || parts[0] === "" || parts[1] === "") {
+    throw new Error(`Invalid GitHub repository "${repo}". Expected "owner/name".`);
+  }
+  return {
+    owner: parts[0],
+    name: parts[1]
+  };
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStatusOption(value) {
+  return isRecord3(value) && typeof value.id === "string" && typeof value.name === "string";
+}
+function isStatusField(value) {
+  return isRecord3(value) && typeof value.id === "string" && Array.isArray(value.options) && value.options.every(isStatusOption);
+}
+function assertSingleList(name, listName) {
+  if (name !== listName) {
+    throw singleListError(listName);
+  }
+}
+function singleListError(listName) {
+  return new Error(`gh-issues backend has a single list ${listName}`);
+}
+function parseQualifiedId(qualifiedId, listName) {
+  const prefix = `${listName}/`;
+  if (!qualifiedId.startsWith(prefix) || qualifiedId.length === prefix.length) {
+    throw new Error(`Invalid qualified task id "${qualifiedId}".`);
+  }
+  return qualifiedId.slice(prefix.length);
+}
+
+// ../task-list/src/backends/markdown-dir.ts
+import path5 from "node:path";
+
+// ../file-lock/src/lock.ts
+import * as fsPromises from "node:fs/promises";
+import * as os from "node:os";
+var LockTimeoutError = class extends Error {
+  constructor(message2) {
+    super(message2);
+    this.name = "LockTimeoutError";
+  }
+};
+function createAbortError() {
+  const error2 = new Error("The operation was aborted.");
+  error2.name = "AbortError";
+  return error2;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw createAbortError();
+  }
+}
+function sleep(ms, signal) {
+  if (!signal) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  if (signal.aborted) {
+    return Promise.reject(createAbortError());
+  }
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timeoutId);
+      signal.removeEventListener("abort", onAbort);
+      reject(createAbortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function backoff(attempt, minTimeout, maxTimeout) {
+  const delay = Math.min(maxTimeout, minTimeout * 2 ** attempt);
+  return delay + Math.random() * delay * 0.1;
+}
+function hasErrorCode2(error2, code) {
+  return !!error2 && typeof error2 === "object" && "code" in error2 && error2.code === code;
+}
+function hasAnyErrorCode(error2, codes) {
+  return codes.some((code) => hasErrorCode2(error2, code));
+}
+function isPidRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error2) {
+    return !hasErrorCode2(error2, "ESRCH");
+  }
+}
+function createDefaultFs() {
+  return {
+    open: (path15, flags) => fsPromises.open(path15, flags),
+    readFile: (path15, encoding) => fsPromises.readFile(path15, encoding),
+    stat: fsPromises.stat,
+    unlink: fsPromises.unlink
+  };
+}
+async function removeLockFile(fs2, lockPath, signal) {
+  for (let attempt = 0; attempt <= 4; attempt += 1) {
+    throwIfAborted(signal);
+    try {
+      await fs2.unlink(lockPath);
+      return;
+    } catch (error2) {
+      if (hasErrorCode2(error2, "ENOENT")) {
+        return;
+      }
+      if (!hasAnyErrorCode(error2, ["EPERM", "EBUSY"]) || attempt === 4) {
+        throw error2;
+      }
+    }
+    await sleep(25 * 2 ** attempt, signal);
+  }
+}
+function parseLockMetadata(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object" || !("host" in parsed) || !("pid" in parsed)) {
+      return void 0;
+    }
+    const { host, pid } = parsed;
+    if (typeof host === "string" && typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0) {
+      return {
+        host,
+        pid
+      };
+    }
+  } catch (ignoredError) {
+    void ignoredError;
+  }
+  return void 0;
+}
+async function readLockMetadata(fs2, lockPath) {
+  if (!fs2.readFile) {
+    return void 0;
+  }
+  try {
+    return parseLockMetadata(await fs2.readFile(lockPath, "utf8"));
+  } catch (error2) {
+    if (hasErrorCode2(error2, "ENOENT")) {
+      return null;
+    }
+    return void 0;
+  }
+}
+async function shouldReclaimLock(options) {
+  const metadata = await readLockMetadata(options.fs, options.lockPath);
+  if (metadata === null) {
+    return "missing";
+  }
+  if (metadata?.host === os.hostname()) {
+    return !options.isPidRunning(metadata.pid);
+  }
+  return Date.now() - options.stat.mtimeMs > options.staleMs;
+}
+async function writeLockMetadata(handle) {
+  try {
+    await handle.writeFile(
+      JSON.stringify({ pid: process.pid, host: os.hostname(), acquiredAt: (/* @__PURE__ */ new Date()).toISOString() }),
+      { encoding: "utf8" }
+    );
+  } catch (ignoredError) {
+    void ignoredError;
+  }
+  try {
+    await handle.close();
+  } catch (ignoredError) {
+    void ignoredError;
+  }
+}
+async function acquireFileLock(filePath, options = {}) {
+  const fs2 = options.fs ?? createDefaultFs();
+  const retries = options.retries ?? 20;
+  const minTimeout = options.minTimeout ?? 25;
+  const maxTimeout = options.maxTimeout ?? 250;
+  const staleMs = options.staleMs ?? 1e3;
+  const pidIsRunning = options.isPidRunning ?? isPidRunning;
+  const lockPath = `${filePath}.lock`;
+  let attempt = 0;
+  while (attempt <= retries) {
+    throwIfAborted(options.signal);
+    try {
+      const handle = await fs2.open(lockPath, "wx");
+      await writeLockMetadata(handle);
+      let released = false;
+      return async () => {
+        if (released) {
+          return;
+        }
+        released = true;
+        await removeLockFile(fs2, lockPath, options.signal);
+      };
+    } catch (error2) {
+      if (!hasErrorCode2(error2, "EEXIST")) {
+        throw error2;
+      }
+    }
+    let stat3;
+    try {
+      stat3 = await fs2.stat(lockPath);
+    } catch (statError) {
+      if (hasErrorCode2(statError, "ENOENT")) {
+        continue;
+      }
+      throw statError;
+    }
+    const reclaimLock = await shouldReclaimLock({
+      fs: fs2,
+      isPidRunning: pidIsRunning,
+      lockPath,
+      staleMs,
+      stat: stat3
+    });
+    if (reclaimLock === "missing") {
+      continue;
+    }
+    if (reclaimLock) {
+      await removeLockFile(fs2, lockPath, options.signal);
+      continue;
+    }
+    if (attempt >= retries) {
+      break;
+    }
+    await sleep(backoff(attempt, minTimeout, maxTimeout), options.signal);
+    attempt += 1;
+  }
+  throw new LockTimeoutError(`Failed to acquire lock on "${filePath}".`);
+}
+
 // ../task-list/src/backends/markdown-dir.ts
 import { parseDocument, stringify } from "yaml";
 
@@ -1440,112 +2796,6 @@ var task_schema_default = {
   additionalProperties: true
 };
 
-// ../task-list/src/state-machine.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isStateList(value) {
-  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
-}
-function canFireFromState(event, fromState) {
-  if (event.from === "*") {
-    return event.to !== fromState;
-  }
-  return event.from.includes(fromState);
-}
-function validateMachine(machine) {
-  if (!isRecord(machine)) {
-    throw new TypeError("State machine must be an object.");
-  }
-  if (!isStateList(machine.states)) {
-    throw new TypeError("State machine states must be a string array.");
-  }
-  const states = new Set(machine.states);
-  if (typeof machine.initial !== "string") {
-    throw new TypeError("State machine initial must be a string.");
-  }
-  if (!states.has(machine.initial)) {
-    throw new Error(`Initial state "${machine.initial}" is not declared.`);
-  }
-  if (!isRecord(machine.events)) {
-    throw new TypeError("State machine events must be an object.");
-  }
-  for (const [eventName, event] of Object.entries(machine.events)) {
-    if (!isRecord(event)) {
-      throw new TypeError(`Event "${eventName}" must be an object.`);
-    }
-    if (event.from !== "*" && !isStateList(event.from)) {
-      throw new TypeError(`Event "${eventName}" has an invalid "from" definition.`);
-    }
-    if (typeof event.to !== "string") {
-      throw new TypeError(`Event "${eventName}" target state must be a string.`);
-    }
-    if (!states.has(event.to)) {
-      throw new Error(`Event "${eventName}" references unknown target state "${event.to}".`);
-    }
-    if (event.from !== "*") {
-      for (const fromState of event.from) {
-        if (!states.has(fromState)) {
-          throw new Error(`Event "${eventName}" references unknown source state "${fromState}".`);
-        }
-      }
-    }
-  }
-}
-function eventsFromState(machine, fromState) {
-  const events = [];
-  for (const [eventName, event] of Object.entries(machine.events)) {
-    if (canFireFromState(event, fromState)) {
-      events.push(eventName);
-    }
-  }
-  return events;
-}
-function findEvent(machine, fromState, eventName) {
-  const event = machine.events[eventName];
-  if (event === void 0) {
-    return void 0;
-  }
-  return canFireFromState(event, fromState) ? event : void 0;
-}
-
-// ../task-list/src/types.ts
-var TaskNotFoundError = class extends Error {
-  constructor(message2 = "Task not found.") {
-    super(message2);
-    this.name = "TaskNotFoundError";
-  }
-};
-var TaskAlreadyExistsError = class extends Error {
-  constructor(message2 = "Task already exists.") {
-    super(message2);
-    this.name = "TaskAlreadyExistsError";
-  }
-};
-var InvalidTransitionError = class extends Error {
-  task;
-  event;
-  to;
-  reason;
-  constructor(messageOrOptions = "Invalid task transition.") {
-    const options = typeof messageOrOptions === "string" ? {
-      reason: messageOrOptions
-    } : messageOrOptions;
-    super(options.reason);
-    this.name = "InvalidTransitionError";
-    this.task = options.task;
-    this.event = options.event;
-    this.to = options.to;
-    this.reason = options.reason;
-  }
-};
-var MalformedTaskError = class extends Error {
-  constructor(message2 = "Malformed task.") {
-    super(message2);
-    this.name = "MalformedTaskError";
-  }
-};
-
 // ../task-list/src/state.ts
 var defaultStateMachine = {
   initial: "draft",
@@ -1581,64 +2831,17 @@ function resolveStateMachine(stateMachine) {
   return stateMachine ?? defaultStateMachine;
 }
 
-// ../task-list/src/backends/utils.ts
-import path from "node:path";
-var tmpFileCounter = 0;
-function hasErrorCode2(error2, code) {
-  return !!error2 && typeof error2 === "object" && "code" in error2 && error2.code === code;
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function sortStrings(values) {
-  return [...values].sort((left, right) => left.localeCompare(right));
-}
-function sortTasks(tasks) {
-  return [...tasks].sort((left, right) => left.qualifiedId.localeCompare(right.qualifiedId));
-}
-function validateTaskId(id) {
-  if (id.length === 0 || id.startsWith(".") || id.includes("/") || id.includes("\\") || id.includes("..")) {
-    throw new Error(`Invalid task id "${id}".`);
-  }
-  return id;
-}
-async function statIfExists(fs2, filePath) {
-  try {
-    return await fs2.stat(filePath);
-  } catch (error2) {
-    if (hasErrorCode2(error2, "ENOENT")) {
-      return void 0;
-    }
-    throw error2;
-  }
-}
-async function writeAtomically(fs2, filePath, content) {
-  const tempPath = `${filePath}.tmp-${process.pid}-${tmpFileCounter}`;
-  tmpFileCounter += 1;
-  await fs2.mkdir(path.dirname(filePath), { recursive: true });
-  try {
-    await fs2.writeFile(tempPath, content, { encoding: "utf8", flag: "wx" });
-    await fs2.rename(tempPath, filePath);
-  } catch (error2) {
-    try {
-      await fs2.unlink(tempPath);
-    } catch (unlinkError) {
-      if (!hasErrorCode2(unlinkError, "ENOENT")) {
-        throw unlinkError;
-      }
-    }
-    throw error2;
-  }
-}
-
 // ../task-list/src/backends/markdown-dir.ts
 var ARCHIVE_DIRECTORY_NAME = "archive";
 var MARKDOWN_EXTENSION = ".md";
 var TASK_KIND = "task";
 var TASK_VERSION = 1;
 var TASK_SCHEMA_ID = task_schema_default.$id;
+var ORDER_LOCK_FILENAME = ".order.lock";
+var MIN_PREFIX_WIDTH = 2;
 var RESERVED_FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
   "$schema",
+  "created",
   "description",
   "kind",
   "name",
@@ -1651,7 +2854,7 @@ function validateListName(name) {
   }
   return name;
 }
-function parseQualifiedId(qualifiedId) {
+function parseQualifiedId2(qualifiedId) {
   const separatorIndex = qualifiedId.indexOf("/");
   if (separatorIndex <= 0 || separatorIndex !== qualifiedId.lastIndexOf("/") || separatorIndex === qualifiedId.length - 1) {
     throw new Error(`Invalid qualified task id "${qualifiedId}".`);
@@ -1662,16 +2865,16 @@ function parseQualifiedId(qualifiedId) {
   };
 }
 function listPath(rootPath, list) {
-  return path2.join(rootPath, list);
+  return path5.join(rootPath, list);
 }
 function archiveDirectoryPath(rootPath, list) {
-  return path2.join(listPath(rootPath, list), ARCHIVE_DIRECTORY_NAME);
+  return path5.join(listPath(rootPath, list), ARCHIVE_DIRECTORY_NAME);
 }
-function activeTaskPath(rootPath, list, id) {
-  return path2.join(listPath(rootPath, list), `${id}${MARKDOWN_EXTENSION}`);
+function activeTaskFilename(id, order, width) {
+  return `${String(order).padStart(width, "0")}-${id}${MARKDOWN_EXTENSION}`;
 }
 function archivedTaskPath(rootPath, list, id) {
-  return path2.join(archiveDirectoryPath(rootPath, list), `${id}${MARKDOWN_EXTENSION}`);
+  return path5.join(archiveDirectoryPath(rootPath, list), `${id}${MARKDOWN_EXTENSION}`);
 }
 function isMarkdownFile(entryName) {
   return entryName.endsWith(MARKDOWN_EXTENSION);
@@ -1682,6 +2885,27 @@ function isHiddenEntry(entryName) {
 function isLockFile(entryName) {
   return entryName.endsWith(".lock");
 }
+function isValidTaskIdShape(id) {
+  return id.length > 0 && !id.startsWith(".") && !id.includes("/") && !id.includes("\\") && !id.includes("..");
+}
+function parseActiveFilename(entryName) {
+  if (!isMarkdownFile(entryName)) return void 0;
+  const stem = entryName.slice(0, -MARKDOWN_EXTENSION.length);
+  const match = /^(\d+)-(.+)$/.exec(stem);
+  if (match) {
+    const id = match[2];
+    if (isValidTaskIdShape(id)) {
+      return { id, order: Number.parseInt(match[1], 10) };
+    }
+  }
+  if (isValidTaskIdShape(stem)) {
+    return { id: stem, order: null };
+  }
+  return void 0;
+}
+function padWidthForCount(count) {
+  return Math.max(MIN_PREFIX_WIDTH, String(Math.max(count, 1)).length);
+}
 function malformedTask(filePath, field) {
   return new MalformedTaskError(`Malformed task "${filePath}": invalid "${field}".`);
 }
@@ -1775,7 +2999,7 @@ async function readDirectoryNames(fs2, directoryPath) {
   try {
     return sortStrings(await fs2.readdir(directoryPath));
   } catch (error2) {
-    if (hasErrorCode2(error2, "ENOENT")) {
+    if (hasErrorCode(error2, "ENOENT")) {
       return [];
     }
     throw error2;
@@ -1799,22 +3023,31 @@ async function readTaskFile(fs2, list, id, filePath, validStates) {
     task: createTask(list, id, frontmatter, document.body)
   };
 }
+async function findActiveTaskFilename(fs2, listDirectoryPath, id) {
+  const entries = await readDirectoryNames(fs2, listDirectoryPath);
+  for (const entryName of entries) {
+    if (isHiddenEntry(entryName) || isLockFile(entryName)) continue;
+    const parsed = parseActiveFilename(entryName);
+    if (parsed?.id === id) {
+      return entryName;
+    }
+  }
+  return void 0;
+}
 async function findTaskLocation(fs2, rootPath, list, id) {
-  const activePath = activeTaskPath(rootPath, list, id);
-  const activeStat = await statIfExists(fs2, activePath);
-  if (activeStat?.isFile()) {
-    return {
-      archived: false,
-      path: activePath
-    };
+  const listDirectoryPath = listPath(rootPath, list);
+  const activeName = await findActiveTaskFilename(fs2, listDirectoryPath, id);
+  if (activeName) {
+    const activePath = path5.join(listDirectoryPath, activeName);
+    const activeStat = await statIfExists(fs2, activePath);
+    if (activeStat?.isFile()) {
+      return { archived: false, path: activePath };
+    }
   }
   const archivedPath = archivedTaskPath(rootPath, list, id);
   const archivedStat = await statIfExists(fs2, archivedPath);
   if (archivedStat?.isFile()) {
-    return {
-      archived: true,
-      path: archivedPath
-    };
+    return { archived: true, path: archivedPath };
   }
   return void 0;
 }
@@ -1843,6 +3076,7 @@ function createdFrontmatter(defaults, input, initialState) {
       frontmatter[key2] = value;
     }
   }
+  frontmatter.created = (/* @__PURE__ */ new Date()).toISOString();
   return frontmatter;
 }
 function updatedFrontmatter(existingFrontmatter, task, patch) {
@@ -1887,35 +3121,95 @@ function assertCreateDoesNotSetState(input) {
     );
   }
 }
+function assertCreateHasId(input) {
+  if (input.id === void 0) {
+    throw new Error("id is required for markdown-dir backend");
+  }
+}
 function assertUpdateDoesNotSetState(patch) {
   if (Object.prototype.hasOwnProperty.call(patch, "state")) {
     throw new Error('Tasks.update() does not accept "state"; use fire() to change task state.');
   }
 }
-function createTasksView(deps, list) {
+function createTasksView2(deps, list) {
   const listDirectoryPath = listPath(deps.path, list);
   const stateMachine = resolveStateMachine(deps.stateMachine);
   const validStates = new Set(stateMachine.states);
-  async function listFiles(directoryPath) {
-    const entries = await readDirectoryNames(deps.fs, directoryPath);
-    const tasks = [];
+  async function readActiveEntries() {
+    const entries = await readDirectoryNames(deps.fs, listDirectoryPath);
+    const result = [];
     for (const entryName of entries) {
-      if (isHiddenEntry(entryName) || isLockFile(entryName) || !isMarkdownFile(entryName)) {
-        continue;
-      }
-      const entryPath = path2.join(directoryPath, entryName);
+      if (isHiddenEntry(entryName) || isLockFile(entryName)) continue;
+      const parsed = parseActiveFilename(entryName);
+      if (!parsed) continue;
+      const entryPath = path5.join(listDirectoryPath, entryName);
       const entryStat = await statIfExists(deps.fs, entryPath);
-      if (!entryStat?.isFile()) {
-        continue;
-      }
+      if (!entryStat?.isFile()) continue;
+      result.push({ id: parsed.id, order: parsed.order, filename: entryName });
+    }
+    result.sort((left, right) => {
+      const leftOrder = left.order ?? Number.POSITIVE_INFINITY;
+      const rightOrder = right.order ?? Number.POSITIVE_INFINITY;
+      if (leftOrder !== rightOrder) return leftOrder - rightOrder;
+      return left.filename.localeCompare(right.filename);
+    });
+    return result;
+  }
+  async function readActiveTasks() {
+    const entries = await readActiveEntries();
+    const tasks = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const filePath = path5.join(listDirectoryPath, entry.filename);
+      const file = await readTaskFile(deps.fs, list, entry.id, filePath, validStates);
+      tasks.set(entry.id, { task: file.task, raw: file.frontmatter });
+    }
+    return { entries, tasks };
+  }
+  async function readArchivedTasks() {
+    const archivePath = archiveDirectoryPath(deps.path, list);
+    const entries = await readDirectoryNames(deps.fs, archivePath);
+    const result = [];
+    for (const entryName of entries) {
+      if (isHiddenEntry(entryName) || isLockFile(entryName) || !isMarkdownFile(entryName)) continue;
+      const entryPath = path5.join(archivePath, entryName);
+      const entryStat = await statIfExists(deps.fs, entryPath);
+      if (!entryStat?.isFile()) continue;
       const id = entryName.slice(0, -MARKDOWN_EXTENSION.length);
-      tasks.push((await readTaskFile(deps.fs, list, id, entryPath, validStates)).task);
+      const file = await readTaskFile(deps.fs, list, id, entryPath, validStates);
+      result.push({ task: file.task, raw: file.frontmatter });
+    }
+    return result.sort((left, right) => left.task.qualifiedId.localeCompare(right.task.qualifiedId));
+  }
+  async function rewriteListPrefixes(orderedIds) {
+    const entries = await readActiveEntries();
+    const byId = new Map(entries.map((entry) => [entry.id, entry]));
+    const width = padWidthForCount(orderedIds.length);
+    for (let index = 0; index < orderedIds.length; index += 1) {
+      const id = orderedIds[index];
+      const entry = byId.get(id);
+      if (!entry) continue;
+      const desiredFilename = activeTaskFilename(id, index + 1, width);
+      if (entry.filename !== desiredFilename) {
+        const fromPath = path5.join(listDirectoryPath, entry.filename);
+        const stagingPath = path5.join(listDirectoryPath, `${desiredFilename}.staging-${process.pid}-${index}`);
+        await deps.fs.rename(fromPath, stagingPath);
+        entry.filename = path5.basename(stagingPath);
+      }
+    }
+    const refreshed = await readDirectoryNames(deps.fs, listDirectoryPath);
+    for (const entryName of refreshed) {
+      const stagingMatch = /\.staging-\d+-\d+$/.exec(entryName);
+      if (!stagingMatch) continue;
+      const desiredName = entryName.slice(0, stagingMatch.index);
+      await deps.fs.rename(
+        path5.join(listDirectoryPath, entryName),
+        path5.join(listDirectoryPath, desiredName)
+      );
     }
-    return sortTasks(tasks);
   }
-  async function withTaskLock(id, action) {
-    validateTaskId(id);
-    const release = await acquireFileLock(activeTaskPath(deps.path, list, id), {
+  async function withListLock(action) {
+    await deps.fs.mkdir(listDirectoryPath, { recursive: true });
+    const release = await acquireFileLock(path5.join(listDirectoryPath, ORDER_LOCK_FILENAME), {
       fs: deps.fs,
       staleMs: deps.lockStaleMs,
       retries: deps.lockRetries
@@ -1926,6 +3220,10 @@ function createTasksView(deps, list) {
       await release();
     }
   }
+  async function withTaskLock(id, action) {
+    validateTaskId(id);
+    return withListLock(action);
+  }
   async function getTaskFile(id) {
     validateTaskId(id);
     return readTaskAtLocation(deps.fs, deps.path, list, id, validStates);
@@ -1946,27 +3244,41 @@ function createTasksView(deps, list) {
     name: list,
     stateMachine,
     async all(filter) {
-      const activeTasks = await listFiles(listDirectoryPath);
-      const archivedTasks = filter?.includeArchived ? await listFiles(archiveDirectoryPath(deps.path, list)) : [];
-      const combinedTasks = [...activeTasks, ...archivedTasks];
-      if (filter?.state) {
-        return combinedTasks.filter((task) => task.state === filter.state);
-      }
-      return combinedTasks;
+      const { entries: activeEntries, tasks: activeTasks } = await readActiveTasks();
+      const archivedEntries = filter?.includeArchived ? await readArchivedTasks() : [];
+      const orderedActive = activeEntries.map((entry) => activeTasks.get(entry.id)).filter((entry) => {
+        if (filter?.state && entry.task.state !== filter.state) return false;
+        return true;
+      });
+      const filteredArchived = archivedEntries.filter((entry) => {
+        if (filter?.state && entry.task.state !== filter.state) return false;
+        return true;
+      });
+      const orderedActiveTasks = applyOrder(orderedActive, filter?.order);
+      return [...orderedActiveTasks, ...filteredArchived.map((entry) => entry.task)];
     },
     async get(id) {
       return (await getTaskFile(id)).task;
     },
     async create(input) {
       assertCreateDoesNotSetState(input);
+      assertCreateHasId(input);
       validateTaskId(input.id);
       await deps.fs.mkdir(listDirectoryPath, { recursive: true });
-      return withTaskLock(input.id, async () => {
+      return withListLock(async () => {
         const existing = await findTaskLocation(deps.fs, deps.path, list, input.id);
         if (existing) {
           throw new TaskAlreadyExistsError(`Task "${list}/${input.id}" already exists.`);
         }
-        const targetPath = activeTaskPath(deps.path, list, input.id);
+        const activeEntries = await readActiveEntries();
+        const maxOrder = activeEntries.reduce(
+          (max, entry) => entry.order !== null && entry.order > max ? entry.order : max,
+          0
+        );
+        const nextOrder = maxOrder + 1;
+        const width = padWidthForCount(activeEntries.length + 1);
+        const filename = activeTaskFilename(input.id, nextOrder, width);
+        const targetPath = path5.join(listDirectoryPath, filename);
         const frontmatter = createdFrontmatter(deps.defaults, input, stateMachine.initial);
         const description = input.description ?? "";
         await writeAtomically(deps.fs, targetPath, serializeTaskDocument(frontmatter, description));
@@ -2042,14 +3354,60 @@ function createTasksView(deps, list) {
         }
         await deps.fs.unlink(location.path);
       });
+    },
+    async move(id, anchor) {
+      validateTaskId(id);
+      return withListLock(async () => {
+        const { entries, tasks } = await readActiveTasks();
+        const fromIndex = entries.findIndex((entry) => entry.id === id);
+        if (fromIndex < 0) {
+          throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
+        }
+        const ordered = entries.map((entry) => entry.id);
+        ordered.splice(fromIndex, 1);
+        let insertIndex;
+        if ("position" in anchor) {
+          insertIndex = anchor.position === "top" ? 0 : ordered.length;
+        } else {
+          const anchorId = "before" in anchor ? anchor.before : anchor.after;
+          const anchorIndex = ordered.indexOf(anchorId);
+          if (anchorIndex < 0) {
+            throw new AnchorNotFoundError(anchorId);
+          }
+          insertIndex = "before" in anchor ? anchorIndex : anchorIndex + 1;
+        }
+        ordered.splice(insertIndex, 0, id);
+        await rewriteListPrefixes(ordered);
+        return tasks.get(id).task;
+      });
+    },
+    async reorder(ids) {
+      for (const id of ids) {
+        validateTaskId(id);
+      }
+      return withListLock(async () => {
+        const { entries, tasks } = await readActiveTasks();
+        const currentIds = entries.map((entry) => entry.id);
+        const currentSet = new Set(currentIds);
+        const inputSet = new Set(ids);
+        const missing = currentIds.filter((id) => !inputSet.has(id));
+        const extra = ids.filter((id) => !currentSet.has(id));
+        if (missing.length > 0 || extra.length > 0) {
+          throw new OrderMismatchError({ missing, extra });
+        }
+        await rewriteListPrefixes(ids);
+        return ids.map((id) => tasks.get(id).task);
+      });
     }
   };
 }
 async function markdownDirBackend(deps) {
   await ensureRootPath(deps);
+  const stateMachine = resolveStateMachine(deps.stateMachine);
+  const validStates = new Set(stateMachine.states);
   const list = (name) => {
     const listName = validateListName(name);
-    return createTasksView(deps, listName);
+    return createTasksView2(deps, listName);
   };
   const lists = async () => {
     const entries = await readDirectoryNames(deps.fs, deps.path);
@@ -2058,7 +3416,7 @@ async function markdownDirBackend(deps) {
       if (entryName === ARCHIVE_DIRECTORY_NAME || isHiddenEntry(entryName) || isLockFile(entryName)) {
         continue;
       }
-      const entryPath = path2.join(deps.path, entryName);
+      const entryPath = path5.join(deps.path, entryName);
       const entryStat = await statIfExists(deps.fs, entryPath);
       if (entryStat?.isDirectory()) {
         result.push(entryName);
@@ -2072,22 +3430,70 @@ async function markdownDirBackend(deps) {
     for (const taskListName of allLists) {
       tasks.push(...await list(taskListName).all(filter));
     }
-    return sortTasks(tasks);
+    return tasks;
   };
   const get = async (qualifiedId) => {
-    const { list: listName, id } = parseQualifiedId(qualifiedId);
+    const { list: listName, id } = parseQualifiedId2(qualifiedId);
     return list(listName).get(id);
   };
+  const moveBetweenLists = async (qualifiedId, targetList) => {
+    const { list: sourceListName, id } = parseQualifiedId2(qualifiedId);
+    const targetListName = validateListName(targetList);
+    if (sourceListName === targetListName) {
+      const file2 = await readTaskAtLocation(deps.fs, deps.path, sourceListName, id, validStates);
+      return file2.task;
+    }
+    const targetExisting = await findTaskLocation(deps.fs, deps.path, targetListName, id);
+    if (targetExisting) {
+      throw new TaskAlreadyExistsError(`Task "${targetListName}/${id}" already exists.`);
+    }
+    const sourceLocation = await findTaskLocation(deps.fs, deps.path, sourceListName, id);
+    if (!sourceLocation) {
+      throw new TaskNotFoundError(`Task "${sourceListName}/${id}" not found.`);
+    }
+    const targetListDir = listPath(deps.path, targetListName);
+    await deps.fs.mkdir(targetListDir, { recursive: true });
+    const targetEntries = await (async () => {
+      const out = [];
+      const names = await readDirectoryNames(deps.fs, targetListDir);
+      for (const entryName of names) {
+        if (isHiddenEntry(entryName) || isLockFile(entryName)) continue;
+        const parsed = parseActiveFilename(entryName);
+        if (!parsed) continue;
+        out.push({ id: parsed.id, order: parsed.order, filename: entryName });
+      }
+      return out;
+    })();
+    if (sourceLocation.archived) {
+      const archivedTargetDir = archiveDirectoryPath(deps.path, targetListName);
+      await deps.fs.mkdir(archivedTargetDir, { recursive: true });
+      const archivedTargetPath = archivedTaskPath(deps.path, targetListName, id);
+      await deps.fs.rename(sourceLocation.path, archivedTargetPath);
+      const file2 = await readTaskFile(deps.fs, targetListName, id, archivedTargetPath, validStates);
+      return file2.task;
+    }
+    const maxOrder = targetEntries.reduce(
+      (max, entry) => entry.order !== null && entry.order > max ? entry.order : max,
+      0
+    );
+    const width = padWidthForCount(targetEntries.length + 1);
+    const targetFilename = activeTaskFilename(id, maxOrder + 1, width);
+    const targetPath = path5.join(targetListDir, targetFilename);
+    await deps.fs.rename(sourceLocation.path, targetPath);
+    const file = await readTaskFile(deps.fs, targetListName, id, targetPath, validStates);
+    return file.task;
+  };
   return {
     list,
     lists,
     allTasks,
-    get
+    get,
+    moveBetweenLists
   };
 }
 
 // ../task-list/src/backends/yaml-file.ts
-import { parseDocument as parseDocument2 } from "yaml";
+import { isMap, parseDocument as parseDocument2 } from "yaml";
 
 // ../task-list/src/schema/store.schema.json
 var store_schema_default = {
@@ -2130,7 +3536,15 @@ var STORE_VERSION = 1;
 var TASK_KIND2 = "task";
 var TASK_SCHEMA_ID2 = task_schema_default.$id;
 var TASK_VERSION2 = 1;
-var RESERVED_TASK_KEYS = /* @__PURE__ */ new Set(["$schema", "description", "kind", "name", "state", "version"]);
+var RESERVED_TASK_KEYS = /* @__PURE__ */ new Set([
+  "$schema",
+  "created",
+  "description",
+  "kind",
+  "name",
+  "state",
+  "version"
+]);
 function malformedStore(filePath, field) {
   return new MalformedTaskError(`Malformed task store "${filePath}": invalid "${field}".`);
 }
@@ -2143,7 +3557,7 @@ function validateListName2(name) {
   }
   return name;
 }
-function parseQualifiedId2(qualifiedId) {
+function parseQualifiedId3(qualifiedId) {
   const separatorIndex = qualifiedId.indexOf("/");
   if (separatorIndex <= 0 || separatorIndex !== qualifiedId.lastIndexOf("/") || separatorIndex === qualifiedId.length - 1) {
     throw new Error(`Invalid qualified task id "${qualifiedId}".`);
@@ -2201,6 +3615,7 @@ function createTaskRecord(defaults, input, initialState) {
       taskRecord[key2] = value;
     }
   }
+  taskRecord.created = (/* @__PURE__ */ new Date()).toISOString();
   return taskRecord;
 }
 function assertCreateDoesNotSetState2(input) {
@@ -2210,6 +3625,11 @@ function assertCreateDoesNotSetState2(input) {
     );
   }
 }
+function assertCreateHasId2(input) {
+  if (input.id === void 0) {
+    throw new Error("id is required for yaml-file backend");
+  }
+}
 function assertUpdateDoesNotSetState2(patch) {
   if (Object.prototype.hasOwnProperty.call(patch, "state")) {
     throw new Error('Tasks.update() does not accept "state"; use fire() to change task state.');
@@ -2356,7 +3776,49 @@ function getTaskOrThrow(store, list, id) {
   if (!taskRecord) {
     throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
   }
-  return taskRecord;
+  return taskRecord;
+}
+function getListNode(document, list) {
+  const lists = document.get("lists");
+  if (!isMap(lists)) {
+    return void 0;
+  }
+  const listNode = lists.get(list);
+  if (!isMap(listNode)) {
+    return void 0;
+  }
+  return listNode;
+}
+function pairKey(pair) {
+  const key2 = pair.key;
+  if (typeof key2 === "string") {
+    return key2;
+  }
+  if (key2 && typeof key2 === "object" && "value" in key2 && typeof key2.value === "string") {
+    return key2.value;
+  }
+  return void 0;
+}
+function findItemIndex(listNode, id) {
+  return listNode.items.findIndex((pair) => pairKey(pair) === id);
+}
+function activeItemIds(listNode, validStates) {
+  const ids = [];
+  for (const pair of listNode.items) {
+    const id = pairKey(pair);
+    if (id === void 0) continue;
+    const value = pair.value;
+    let state;
+    if (value && typeof value === "object" && "get" in value && typeof value.get === "function") {
+      state = value.get("state");
+    } else if (isRecord2(value)) {
+      state = value.state;
+    }
+    if (typeof state === "string" && validStates.has(state) && state !== "archived") {
+      ids.push(id);
+    }
+  }
+  return ids;
 }
 async function ensureStorePath(deps) {
   if (!deps.create) {
@@ -2395,7 +3857,7 @@ async function withStoreLock(deps, action) {
     await release();
   }
 }
-function createTasksView2(deps, list) {
+function createTasksView3(deps, list) {
   const stateMachine = resolveStateMachine(deps.stateMachine);
   const validStates = new Set(stateMachine.states);
   async function readTasks(filter) {
@@ -2404,8 +3866,11 @@ function createTasksView2(deps, list) {
     if (!listRecord) {
       return [];
     }
-    const tasks = Object.entries(listRecord).map(([id, taskRecord]) => createTask2(list, id, taskRecord));
-    return sortTasks(tasks.filter((task) => matchesFilter(task, filter)));
+    const entries = Object.entries(listRecord).map(([id, taskRecord]) => ({
+      task: createTask2(list, id, taskRecord),
+      raw: taskRecord
+    })).filter(({ task }) => matchesFilter(task, filter));
+    return applyOrder(entries, filter?.order);
   }
   function assertFireableTaskEvent(task, eventName) {
     const event = findEvent(stateMachine, task.state, eventName);
@@ -2432,6 +3897,7 @@ function createTasksView2(deps, list) {
     },
     async create(input) {
       assertCreateDoesNotSetState2(input);
+      assertCreateHasId2(input);
       validateTaskId(input.id);
       return withStoreLock(deps, async () => {
         const { document, store } = await readStore(deps.fs, deps.path, validStates);
@@ -2520,6 +3986,72 @@ function createTasksView2(deps, list) {
         document.deleteIn(["lists", list, id]);
         await writeAtomically(deps.fs, deps.path, serializeDocument(document));
       });
+    },
+    async move(id, anchor) {
+      validateTaskId(id);
+      return withStoreLock(deps, async () => {
+        const { document, store } = await readStore(deps.fs, deps.path, validStates);
+        const taskRecord = getTaskOrThrow(store, list, id);
+        const listNode = getListNode(document, list);
+        if (!listNode) {
+          throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
+        }
+        const fromIndex = findItemIndex(listNode, id);
+        if (fromIndex < 0) {
+          throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
+        }
+        const [movedPair] = listNode.items.splice(fromIndex, 1);
+        let insertIndex;
+        if ("position" in anchor) {
+          insertIndex = anchor.position === "top" ? 0 : listNode.items.length;
+        } else {
+          const anchorId = "before" in anchor ? anchor.before : anchor.after;
+          const anchorIndex = findItemIndex(listNode, anchorId);
+          if (anchorIndex < 0) {
+            listNode.items.splice(fromIndex, 0, movedPair);
+            throw new AnchorNotFoundError(anchorId);
+          }
+          insertIndex = "before" in anchor ? anchorIndex : anchorIndex + 1;
+        }
+        listNode.items.splice(insertIndex, 0, movedPair);
+        await writeAtomically(deps.fs, deps.path, serializeDocument(document));
+        return createTask2(list, id, taskRecord);
+      });
+    },
+    async reorder(ids) {
+      for (const id of ids) {
+        validateTaskId(id);
+      }
+      return withStoreLock(deps, async () => {
+        const { document, store } = await readStore(deps.fs, deps.path, validStates);
+        const listNode = getListNode(document, list);
+        if (!listNode) {
+          throw new OrderMismatchError({ missing: [...ids], extra: [] });
+        }
+        const currentActive = activeItemIds(listNode, validStates);
+        const currentSet = new Set(currentActive);
+        const inputSet = new Set(ids);
+        const missing = currentActive.filter((id) => !inputSet.has(id));
+        const extra = ids.filter((id) => !currentSet.has(id));
+        if (missing.length > 0 || extra.length > 0) {
+          throw new OrderMismatchError({ missing, extra });
+        }
+        const archivedPairs = listNode.items.filter((pair) => {
+          const id = pairKey(pair);
+          return id !== void 0 && !currentSet.has(id);
+        });
+        const orderedActive = ids.map((id) => {
+          const pair = listNode.items.find((p) => pairKey(p) === id);
+          if (!pair) {
+            throw new OrderMismatchError({ missing: [id], extra: [] });
+          }
+          return pair;
+        });
+        listNode.items.splice(0, listNode.items.length, ...orderedActive, ...archivedPairs);
+        await writeAtomically(deps.fs, deps.path, serializeDocument(document));
+        const tasks = ids.map((id) => createTask2(list, id, getTaskOrThrow(store, list, id)));
+        return tasks;
+      });
     }
   };
 }
@@ -2529,7 +4061,7 @@ async function yamlFileBackend(deps) {
   const validStates = new Set(stateMachine.states);
   const list = (name) => {
     const listName = validateListName2(name);
-    return createTasksView2({ ...deps, stateMachine }, listName);
+    return createTasksView3({ ...deps, stateMachine }, listName);
   };
   const lists = async () => {
     const { store } = await readStore(deps.fs, deps.path, validStates);
@@ -2537,26 +4069,47 @@ async function yamlFileBackend(deps) {
   };
   const allTasks = async (filter) => {
     const { store } = await readStore(deps.fs, deps.path, validStates);
-    const tasks = [];
-    for (const [listName, listRecord] of Object.entries(getListsRecord(store))) {
-      for (const [id, taskRecord] of Object.entries(listRecord)) {
-        const task = createTask2(listName, id, taskRecord);
-        if (matchesFilter(task, filter)) {
-          tasks.push(task);
-        }
-      }
+    const result = [];
+    const listNames = sortStrings(Object.keys(getListsRecord(store)));
+    for (const listName of listNames) {
+      const listRecord = getListsRecord(store)[listName];
+      if (!isRecord2(listRecord)) continue;
+      const entries = Object.entries(listRecord).map(([id, taskRecord]) => ({
+        task: createTask2(listName, id, taskRecord),
+        raw: taskRecord
+      })).filter(({ task }) => matchesFilter(task, filter));
+      result.push(...applyOrder(entries, filter?.order));
     }
-    return sortTasks(tasks);
+    return result;
   };
   const get = async (qualifiedId) => {
-    const { list: listName, id } = parseQualifiedId2(qualifiedId);
+    const { list: listName, id } = parseQualifiedId3(qualifiedId);
     return list(listName).get(id);
   };
+  const moveBetweenLists = async (qualifiedId, targetList) => {
+    const { list: sourceListName, id } = parseQualifiedId3(qualifiedId);
+    const targetListName = validateListName2(targetList);
+    return withStoreLock(deps, async () => {
+      const { document, store } = await readStore(deps.fs, deps.path, validStates);
+      const taskRecord = getTaskOrThrow(store, sourceListName, id);
+      if (sourceListName === targetListName) {
+        return createTask2(targetListName, id, taskRecord);
+      }
+      if (getTaskRecord(store, targetListName, id)) {
+        throw new TaskAlreadyExistsError(`Task "${targetListName}/${id}" already exists.`);
+      }
+      document.deleteIn(["lists", sourceListName, id]);
+      document.setIn(["lists", targetListName, id], taskRecord);
+      await writeAtomically(deps.fs, deps.path, serializeDocument(document));
+      return createTask2(targetListName, id, taskRecord);
+    });
+  };
   return {
     list,
     lists,
     allTasks,
-    get
+    get,
+    moveBetweenLists
   };
 }
 
@@ -2571,10 +4124,18 @@ function createDefaultFs2() {
   return fsPromises2;
 }
 async function openTaskList(options) {
-  const factory = backendFactories[options.type];
-  if (factory === void 0) {
-    throw new Error(`Unknown task list backend type "${options.type}".`);
+  switch (options.type) {
+    case "markdown-dir":
+    case "yaml-file":
+      return openFileBackend(options);
+    case "gh-issues":
+      return openGhIssuesBackend(options);
+    default:
+      throw new Error(`Unknown task list backend type "${options.type}".`);
   }
+}
+async function openFileBackend(options) {
+  const factory = backendFactories[options.type];
   const stateMachine = resolveStateMachine(options.stateMachine);
   validateMachine(stateMachine);
   const deps = {
@@ -2590,9 +4151,23 @@ async function openTaskList(options) {
   };
   return factory(deps);
 }
+async function openGhIssuesBackend(options) {
+  const token = await resolveAuth({ explicitToken: options.auth?.token });
+  const endpoint = resolveEndpoint();
+  return ghIssuesBackend({
+    repo: options.repo,
+    project: options.project,
+    defaults: {
+      metadata: { ...options.defaults?.metadata ?? {} }
+    },
+    token,
+    endpoint,
+    fetch: options.fetch
+  });
+}
 
 // ../toolcraft/src/human-in-loop/approval-tasks.ts
-import { randomBytes } from "node:crypto";
+import { randomBytes as randomBytes3 } from "node:crypto";
 
 // ../toolcraft/src/human-in-loop/state-machine.ts
 var approvalStateMachine = {
@@ -2675,7 +4250,7 @@ function isListValidated(runtimeOptions, listName) {
   return validatedListsByRuntime.get(runtimeOptions)?.has(listName) ?? false;
 }
 function createApprovalRecord(payload, enqueuedAt) {
-  const approvalId = `${enqueuedAt.slice(0, 19).replaceAll(":", "-")}-${randomBytes(3).toString("hex")}`;
+  const approvalId = `${enqueuedAt.slice(0, 19).replaceAll(":", "-")}-${randomBytes3(3).toString("hex")}`;
   return {
     approvalId,
     name: `${payload.commandPath} (${enqueuedAt})`,
@@ -2758,7 +4333,7 @@ function areEqualStrings(left, right) {
 }
 
 // ../toolcraft/src/human-in-loop/runner.ts
-import { access, readFile, writeFile } from "node:fs/promises";
+import { access, readFile as readFile3, writeFile } from "node:fs/promises";
 
 // ../toolcraft/src/human-in-loop/default-provider.ts
 import process2 from "node:process";
@@ -2866,13 +4441,13 @@ function defaultProviderForPlatform() {
 }
 
 // ../toolcraft/src/human-in-loop/spawn.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 function spawnApprovalRunner(approvalId, runtimeOptions, spawnFn) {
   const { execPath, entryArgs } = runtimeOptions.binPath ?? {
     execPath: process.execPath,
     entryArgs: [process.argv[1]]
   };
-  const fn = spawnFn ?? spawn;
+  const fn = spawnFn ?? spawn2;
   const child = fn(execPath, [...entryArgs, "approvals", "run", approvalId], {
     detached: true,
     stdio: "ignore",
@@ -3057,13 +4632,13 @@ function createHandlerContext(command, params17) {
 }
 function createFs() {
   return {
-    readFile: async (path12, encoding = "utf8") => readFile(path12, { encoding }),
-    writeFile: async (path12, contents) => {
-      await writeFile(path12, contents);
+    readFile: async (path15, encoding = "utf8") => readFile3(path15, { encoding }),
+    writeFile: async (path15, contents) => {
+      await writeFile(path15, contents);
     },
-    exists: async (path12) => {
+    exists: async (path15) => {
       try {
-        await access(path12);
+        await access(path15);
         return true;
       } catch {
         return false;
@@ -3315,23 +4890,23 @@ function escapeMarkdownCell(value) {
 }
 
 // ../toolcraft/src/mcp-proxy.ts
-import { existsSync } from "node:fs";
-import { mkdir, readFile as readFile2, rename, unlink as unlink2, writeFile as writeFile2 } from "node:fs/promises";
-import path5 from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir, readFile as readFile4, rename, unlink as unlink2, writeFile as writeFile2 } from "node:fs/promises";
+import path8 from "node:path";
 
 // ../tiny-mcp-client/src/internal.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { PassThrough as PassThrough2 } from "node:stream";
 
-// ../mcp-oauth/src/client/auth-store-session-store.ts
+// ../mcp-oauth/dist/client/auth-store-session-store.js
 import crypto from "node:crypto";
-import path4 from "node:path";
+import path7 from "node:path";
 
 // ../auth-store/src/encrypted-file-store.ts
-import { createCipheriv, createDecipheriv, randomBytes as randomBytes2, scrypt } from "node:crypto";
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes4, scrypt } from "node:crypto";
 import { promises as fs } from "node:fs";
 import { homedir, hostname as hostname2, userInfo } from "node:os";
-import path3 from "node:path";
+import path6 from "node:path";
 var derivedKeyCache = /* @__PURE__ */ new Map();
 var ENCRYPTION_ALGORITHM = "aes-256-gcm";
 var ENCRYPTION_VERSION = 1;
@@ -3349,13 +4924,13 @@ var EncryptedFileStore = class {
   constructor(input) {
     this.fs = input.fs ?? fs;
     this.salt = input.salt;
-    this.filePath = input.filePath ?? path3.join(
+    this.filePath = input.filePath ?? path6.join(
       (input.getHomeDirectory ?? homedir)(),
       input.defaultDirectory ?? ".auth-store",
       input.defaultFileName ?? "credentials.enc"
     );
     this.getMachineIdentity = input.getMachineIdentity ?? defaultMachineIdentity;
-    this.getRandomBytes = input.getRandomBytes ?? randomBytes2;
+    this.getRandomBytes = input.getRandomBytes ?? randomBytes4;
   }
   async get() {
     let rawDocument;
@@ -3402,7 +4977,7 @@ var EncryptedFileStore = class {
       authTag: authTag.toString("base64"),
       ciphertext: ciphertext.toString("base64")
     };
-    await this.fs.mkdir(path3.dirname(this.filePath), { recursive: true });
+    await this.fs.mkdir(path6.dirname(this.filePath), { recursive: true });
     await this.fs.writeFile(this.filePath, JSON.stringify(document), {
       encoding: "utf8"
     });
@@ -3453,7 +5028,7 @@ async function deriveEncryptionKey(getMachineIdentity, salt) {
 function parseEncryptedDocument(raw) {
   try {
     const parsed = JSON.parse(raw);
-    if (!isRecord3(parsed)) {
+    if (!isRecord4(parsed)) {
       return null;
     }
     if (parsed.version !== ENCRYPTION_VERSION) {
@@ -3472,7 +5047,7 @@ function parseEncryptedDocument(raw) {
     return null;
   }
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isNotFoundError(error2) {
@@ -3482,7 +5057,7 @@ function isNotFoundError(error2) {
 }
 
 // ../auth-store/src/keychain-store.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 var SECURITY_CLI = "security";
 var KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE = 44;
 var KeychainStore = class {
@@ -3546,7 +5121,7 @@ var KeychainStore = class {
 };
 function runSecurityCommand(command, args) {
   return new Promise((resolve) => {
-    const child = spawn2(command, args, {
+    const child = spawn3(command, args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
@@ -3640,7 +5215,7 @@ function resolveBackend(input) {
   return "file";
 }
 
-// ../mcp-oauth/src/resource-indicator.ts
+// ../mcp-oauth/dist/resource-indicator.js
 function canonicalizeResourceIndicator(value) {
   let url;
   try {
@@ -3652,7 +5227,7 @@ function canonicalizeResourceIndicator(value) {
   return url.toString();
 }
 
-// ../mcp-oauth/src/client/auth-store-session-store.ts
+// ../mcp-oauth/dist/client/auth-store-session-store.js
 var DEFAULT_FILE_SALT = "poe-code:mcp-oauth:v1";
 var DEFAULT_FILE_DIRECTORY = ".poe-code/mcp-oauth";
 var DEFAULT_KEYCHAIN_SERVICE = "poe-code-mcp-oauth";
@@ -3709,7 +5284,7 @@ function createAuthStoreClientStore(options) {
 }
 function createNamedSecretStore(key2, options, defaults) {
   const hash = crypto.createHash("sha256").update(key2).digest("hex");
-  const parsedFilePath = options.fileStore?.filePath === void 0 ? null : path4.parse(options.fileStore.filePath);
+  const parsedFilePath = options.fileStore?.filePath === void 0 ? null : path7.parse(options.fileStore.filePath);
   const fileStore = {
     ...options.fileStore,
     salt: options.fileStore?.salt ?? defaults.salt,
@@ -3724,37 +5299,29 @@ function createNamedSecretStore(key2, options, defaults) {
   return createSecretStore({ ...options, fileStore, keychainStore }).store;
 }
 function createResourceSecretStore(resource, options) {
-  return createNamedSecretStore(
-    canonicalizeResourceIndicator(resource),
-    options,
-    {
-      salt: DEFAULT_FILE_SALT,
-      directory: DEFAULT_FILE_DIRECTORY,
-      service: DEFAULT_KEYCHAIN_SERVICE,
-      accountPrefix: "provider"
-    }
-  );
+  return createNamedSecretStore(canonicalizeResourceIndicator(resource), options, {
+    salt: DEFAULT_FILE_SALT,
+    directory: DEFAULT_FILE_DIRECTORY,
+    service: DEFAULT_KEYCHAIN_SERVICE,
+    accountPrefix: "provider"
+  });
 }
 function createIssuerSecretStore(issuer, options) {
-  return createNamedSecretStore(
-    issuer,
-    options,
-    {
-      salt: DEFAULT_CLIENT_FILE_SALT,
-      directory: DEFAULT_CLIENT_FILE_DIRECTORY,
-      service: DEFAULT_CLIENT_KEYCHAIN_SERVICE,
-      accountPrefix: "issuer"
-    }
-  );
+  return createNamedSecretStore(issuer, options, {
+    salt: DEFAULT_CLIENT_FILE_SALT,
+    directory: DEFAULT_CLIENT_FILE_DIRECTORY,
+    service: DEFAULT_CLIENT_KEYCHAIN_SERVICE,
+    accountPrefix: "issuer"
+  });
 }
 
-// ../mcp-oauth/src/client/default-oauth-client-provider.ts
+// ../mcp-oauth/dist/client/default-oauth-client-provider.js
 import { URL as URL2 } from "node:url";
 
-// ../mcp-oauth/src/client/loopback-authorization.ts
+// ../mcp-oauth/dist/client/loopback-authorization.js
 import http from "node:http";
 
-// ../mcp-oauth/src/client/authorization-state.ts
+// ../mcp-oauth/dist/client/authorization-state.js
 import crypto2 from "node:crypto";
 function createAuthorizationState(input) {
   const payload = {
@@ -3784,7 +5351,7 @@ function parseAuthorizationState(value) {
   }
 }
 
-// ../mcp-oauth/src/client/loopback-authorization.ts
+// ../mcp-oauth/dist/client/loopback-authorization.js
 async function createLoopbackAuthorizationSession(options = {}) {
   const callbackPath = options.callbackPath ?? "/callback";
   const server = options.createServer ? options.createServer() : http.createServer();
@@ -3857,10 +5424,7 @@ function waitForAuthorizationCode(server, authorizationUrl, options, callbackPat
           return;
         }
         try {
-          const code = validateAuthorizationCallbackParameters(
-            callbackParameters,
-            expectedAuthorization
-          );
+          const code = validateAuthorizationCallbackParameters(callbackParameters, expectedAuthorization);
           settle(() => resolve(code));
         } catch (error2) {
           settle(() => reject(error2 instanceof Error ? error2 : new Error(String(error2))));
@@ -3926,8 +5490,8 @@ function validateAuthorizationCallbackParameters(callback, expected) {
   }
   return callback.code;
 }
-function escapeHtml(text4) {
-  return text4.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+function escapeHtml(text5) {
+  return text5.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 }
 function buildSuccessPage(landingPage) {
   const title = landingPage?.title ?? "Connected";
@@ -3943,7 +5507,7 @@ function buildSuccessPage(landingPage) {
   ].join("");
 }
 
-// ../mcp-oauth/src/client/pkce.ts
+// ../mcp-oauth/dist/client/pkce.js
 import crypto3 from "node:crypto";
 function generateCodeVerifier() {
   return crypto3.randomBytes(32).toString("base64url");
@@ -3952,7 +5516,7 @@ function generateCodeChallenge(verifier) {
   return crypto3.createHash("sha256").update(verifier).digest("base64url");
 }
 
-// ../mcp-oauth/src/client/token-endpoint.ts
+// ../mcp-oauth/dist/client/token-endpoint.js
 var OAuthError = class extends Error {
   error;
   errorDescription;
@@ -4082,7 +5646,7 @@ function normalizeBearerTokenType(value) {
   return value.toLowerCase() === "bearer" ? "Bearer" : null;
 }
 
-// ../mcp-oauth/src/client/default-oauth-client-provider.ts
+// ../mcp-oauth/dist/client/default-oauth-client-provider.js
 function createOAuthClientProvider(options) {
   if (isProviderOptions(options)) {
     return options.provider;
@@ -4116,16 +5680,10 @@ function createDefaultOAuthClientProvider(options) {
         const resource = canonicalizeResourceIndicator(input.discovery.resource);
         assertRequestMatchesResource(requestUrl, resource);
         const forceRefresh = hasCachedAccessToken(await loadSession(resource)) && input.challenge?.params.error === "invalid_token";
-        const session = await ensureAuthorizedSession(
-          resource,
-          {
-            ...input.discovery,
-            resource
-          },
-          input.fetch,
-          true,
-          forceRefresh
-        );
+        const session = await ensureAuthorizedSession(resource, {
+          ...input.discovery,
+          resource
+        }, input.fetch, true, forceRefresh);
         if (session?.tokens?.accessToken === void 0) {
           return { action: "fail" };
         }
@@ -4190,11 +5748,7 @@ function createDefaultOAuthClientProvider(options) {
               await saveSession(resource, clearedSession);
               return clearedSession;
             }
-            if (shouldReRegisterStoredDynamicClient(
-              error2,
-              await loadRegisteredClient(discovery.authorizationServer),
-              false
-            )) {
+            if (shouldReRegisterStoredDynamicClient(error2, await loadRegisteredClient(discovery.authorizationServer), false)) {
               await clearRegisteredClient(discovery.authorizationServer);
               await clearSession(resource);
               return null;
@@ -4353,10 +5907,7 @@ function createDefaultOAuthClientProvider(options) {
         };
       }
     }
-    const registrationBody = buildClientRegistrationBody(
-      getClientMetadata(options.client),
-      redirectUri
-    );
+    const registrationBody = buildClientRegistrationBody(getClientMetadata(options.client), redirectUri);
     const response = await fetch2(registrationEndpoint, {
       method: "POST",
       headers: {
@@ -4480,9 +6031,7 @@ function buildAuthorizationUrl(input) {
 }
 function assertS256PkceSupport(metadata) {
   if (!metadata.code_challenge_methods_supported.includes("S256")) {
-    throw new Error(
-      "Authorization server metadata must advertise code_challenge_methods_supported including S256"
-    );
+    throw new Error("Authorization server metadata must advertise code_challenge_methods_supported including S256");
   }
 }
 function normalizeHostname(hostname3) {
@@ -4520,9 +6069,7 @@ function assertNoAccessTokenInUrl(value, label) {
 }
 function assertRequestMatchesResource(requestUrl, resource) {
   if (requestUrl !== resource) {
-    throw new Error(
-      `OAuth request URL ${requestUrl} does not match discovered resource ${resource}`
-    );
+    throw new Error(`OAuth request URL ${requestUrl} does not match discovered resource ${resource}`);
   }
 }
 function buildClientRegistrationBody(metadata, redirectUri) {
@@ -4566,13 +6113,8 @@ function shouldReRegisterStoredDynamicClient(error2, client, alreadyAttempted) {
   return true;
 }
 
-// ../mcp-oauth/src/server/jwks-token-verifier.ts
-import {
-  decodeProtectedHeader,
-  errors,
-  importJWK,
-  jwtVerify
-} from "jose";
+// ../mcp-oauth/dist/server/jwks-token-verifier.js
+import { decodeProtectedHeader, errors, importJWK, jwtVerify } from "jose";
 
 // ../tiny-mcp-client/src/oauth-discovery.ts
 function defaultOAuthMetadataFetch(input, init) {
@@ -5336,7 +6878,7 @@ var ERROR_INVALID_REQUEST = -32600;
 var ERROR_METHOD_NOT_FOUND = -32601;
 var ERROR_INTERNAL = -32603;
 function defaultStdioSpawn(command, args, options) {
-  return spawn3(command, args, options);
+  return spawn4(command, args, options);
 }
 function defaultHttpTransportFetch(input, init) {
   return fetch(input, init);
@@ -6647,9 +8189,9 @@ function mergeJsonSchemas(base, overlay) {
     ...mergedRequired === void 0 ? {} : { required: mergedRequired }
   };
 }
-function hasSelfReferencingRef(schema, root, path12 = "#", activePaths = /* @__PURE__ */ new Set()) {
+function hasSelfReferencingRef(schema, root, path15 = "#", activePaths = /* @__PURE__ */ new Set()) {
   const nextActivePaths = new Set(activePaths);
-  nextActivePaths.add(path12);
+  nextActivePaths.add(path15);
   const localRefPath = getLocalRefPath(schema.$ref);
   if (localRefPath !== void 0) {
     if (nextActivePaths.has(localRefPath)) {
@@ -6660,13 +8202,13 @@ function hasSelfReferencingRef(schema, root, path12 = "#", activePaths = /* @__P
       return true;
     }
   }
-  if (schema.items !== void 0 && hasSelfReferencingRef(schema.items, root, `${path12}/items`, nextActivePaths)) {
+  if (schema.items !== void 0 && hasSelfReferencingRef(schema.items, root, `${path15}/items`, nextActivePaths)) {
     return true;
   }
   if (typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && hasSelfReferencingRef(
     schema.additionalProperties,
     root,
-    `${path12}/additionalProperties`,
+    `${path15}/additionalProperties`,
     nextActivePaths
   )) {
     return true;
@@ -6675,7 +8217,7 @@ function hasSelfReferencingRef(schema, root, path12 = "#", activePaths = /* @__P
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path12}/properties/${escapeJsonPointerSegment(key2)}`,
+      `${path15}/properties/${escapeJsonPointerSegment(key2)}`,
       nextActivePaths
     )) {
       return true;
@@ -6685,19 +8227,19 @@ function hasSelfReferencingRef(schema, root, path12 = "#", activePaths = /* @__P
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path12}/$defs/${escapeJsonPointerSegment(key2)}`,
+      `${path15}/$defs/${escapeJsonPointerSegment(key2)}`,
       nextActivePaths
     )) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.oneOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path12}/oneOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path15}/oneOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.anyOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path12}/anyOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path15}/anyOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
@@ -6713,14 +8255,14 @@ function getLocalRefPath(ref) {
   return ref.startsWith("#/") ? ref : void 0;
 }
 function resolveLocalRef(root, ref) {
-  const path12 = getLocalRefPath(ref);
-  if (path12 === void 0) {
+  const path15 = getLocalRefPath(ref);
+  if (path15 === void 0) {
     return void 0;
   }
-  if (path12 === "#") {
+  if (path15 === "#") {
     return root;
   }
-  const segments = path12.slice(2).split("/").map(unescapeJsonPointerSegment);
+  const segments = path15.slice(2).split("/").map(unescapeJsonPointerSegment);
   let current = root;
   for (const segment of segments) {
     if (Array.isArray(current)) {
@@ -6958,7 +8500,7 @@ async function ensureConnected(connection) {
 }
 async function readCache(cachePath) {
   try {
-    const raw = await readFile2(cachePath, "utf8");
+    const raw = await readFile4(cachePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed === null || typeof parsed !== "object" || !Array.isArray(parsed.tools) || parsed.upstream === void 0 || typeof parsed.upstream.name !== "string" || typeof parsed.upstream.version !== "string") {
       return void 0;
@@ -6979,7 +8521,7 @@ async function readCache(cachePath) {
   }
 }
 async function writeCache(cachePath, cache) {
-  const directory = path5.dirname(cachePath);
+  const directory = path8.dirname(cachePath);
   const tempPath = `${cachePath}.tmp`;
   await mkdir(directory, { recursive: true });
   await writeFile2(tempPath, `${JSON.stringify(cache, null, 2)}
@@ -7065,7 +8607,7 @@ function isRefreshRequested(name, refresh) {
   }
   return refresh?.has(name) === true;
 }
-async function resolveSingleProxy(group) {
+async function resolveSingleProxy(group, options) {
   const internal = getInternalGroupConfig2(group);
   const config = internal.mcp;
   if (config === void 0) {
@@ -7073,7 +8615,7 @@ async function resolveSingleProxy(group) {
   }
   const name = group.name;
   try {
-    const cachePath = resolveCachePath(name);
+    const cachePath = resolveCachePath(name, options.projectRoot);
     const refresh = parseRefreshEnv(process.env.TOOLCRAFT_MCP_REFRESH);
     let cache;
     if (isRefreshRequested(name, refresh)) {
@@ -7122,14 +8664,14 @@ function collectProxyGroups(root) {
 }
 function resolveCachePath(name, projectRoot) {
   if (projectRoot !== void 0) {
-    return path5.join(projectRoot, ".toolcraft", "mcp", `${name}.json`);
+    return path8.join(projectRoot, ".toolcraft", "mcp", `${name}.json`);
   }
   let current = process.cwd();
   while (true) {
-    if (existsSync(path5.join(current, "package.json"))) {
-      return path5.join(current, ".toolcraft", "mcp", `${name}.json`);
+    if (existsSync2(path8.join(current, "package.json"))) {
+      return path8.join(current, ".toolcraft", "mcp", `${name}.json`);
     }
-    const parent = path5.dirname(current);
+    const parent = path8.dirname(current);
     if (parent === current) {
       throw new Error(
         `Could not find package.json above "${process.cwd()}" while resolving MCP cache path.`
@@ -7167,9 +8709,9 @@ async function dialUpstream(name, config) {
   await client.connect(transport);
   return client;
 }
-async function resolveMcpProxies(root) {
+async function resolveMcpProxies(root, options = {}) {
   const groups = collectProxyGroups(root);
-  await Promise.all(groups.map((group) => resolveSingleProxy(group)));
+  await Promise.all(groups.map((group) => resolveSingleProxy(group, options)));
 }
 
 // ../toolcraft/src/number-schema.ts
@@ -7181,9 +8723,49 @@ function getExpectedNumberDescription(schema) {
 }
 
 // ../toolcraft/src/renderer.ts
+import YAML from "yaml";
 function isObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+function isMcpCallToolResult(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  const hasContent = Array.isArray(value.content);
+  const hasStructured = value.structuredContent !== void 0;
+  if (!hasContent && !hasStructured) {
+    return false;
+  }
+  return Object.keys(value).every(
+    (key2) => key2 === "content" || key2 === "structuredContent" || key2 === "isError" || key2 === "_meta"
+  );
+}
+function isMcpTextContent(value) {
+  return isObject(value) && value.type === "text" && typeof value.text === "string";
+}
+function extractMcpPayload(envelope) {
+  const structuredContent = envelope.structuredContent;
+  if (isObject(structuredContent) && "result" in structuredContent) {
+    return structuredContent.result;
+  }
+  if (structuredContent !== void 0) {
+    return structuredContent;
+  }
+  if (Array.isArray(envelope.content)) {
+    const text5 = envelope.content.filter(isMcpTextContent).map((block) => block.text).join("\n");
+    return text5.length > 0 ? text5 : void 0;
+  }
+  return void 0;
+}
+function unwrapMcpEnvelope(result) {
+  if (!isMcpCallToolResult(result)) {
+    return { result, mcpError: false };
+  }
+  return {
+    result: extractMcpPayload(result),
+    mcpError: result.isError === true
+  };
+}
 function isArrayOfObjects(value) {
   return Array.isArray(value) && value.every((entry) => isObject(entry));
 }
@@ -7207,30 +8789,6 @@ function stringifyJson(value, spaces) {
     return String(value);
   }
 }
-function renderObjectTable(result, primitives) {
-  const rows = Object.entries(result).map(([key2, value]) => ({
-    key: key2,
-    value: stringifyValue2(value)
-  }));
-  return primitives.renderTable({
-    theme: primitives.getTheme(),
-    columns: [
-      {
-        name: "key",
-        title: "Key",
-        alignment: "left",
-        maxLen: Math.max("Key".length, ...rows.map((row) => row.key.length))
-      },
-      {
-        name: "value",
-        title: "Value",
-        alignment: "left",
-        maxLen: Math.max("Value".length, ...rows.map((row) => row.value.length))
-      }
-    ],
-    rows
-  });
-}
 function renderObjectMarkdown(result) {
   return Object.entries(result).map(([key2, value]) => `- ${key2}: ${stringifyValue2(value)}`).join("\n");
 }
@@ -7243,29 +8801,6 @@ function getColumnNames(rows) {
   }
   return [...names];
 }
-function renderArrayTable(result, primitives) {
-  if (result.length === 0) {
-    return "[]";
-  }
-  const columnNames = getColumnNames(result);
-  return primitives.renderTable({
-    theme: primitives.getTheme(),
-    columns: columnNames.map((name) => ({
-      name,
-      title: name,
-      alignment: "left",
-      maxLen: Math.max(
-        name.length,
-        ...result.map((row) => name in row ? stringifyValue2(row[name]).length : 0)
-      )
-    })),
-    rows: result.map(
-      (row) => Object.fromEntries(
-        columnNames.map((name) => [name, name in row ? stringifyValue2(row[name]) : ""])
-      )
-    )
-  });
-}
 function renderArrayMarkdown(result) {
   if (result.length === 0) {
     return "[]";
@@ -7278,7 +8813,7 @@ function renderArrayMarkdown(result) {
   );
   return [header, separator, ...rows].join("\n");
 }
-function autoRender(result, output, primitives) {
+function autoRender(result, output, _primitives) {
   if (result === null || result === void 0) {
     if (output === "json") {
       return stringifyJson({ ok: true }, 2);
@@ -7291,14 +8826,16 @@ function autoRender(result, output, primitives) {
     }
     return result;
   }
+  if (output === "rich" && Array.isArray(result) && result.every((value) => typeof value === "string")) {
+    return result.join("\n");
+  }
   if (isObject(result)) {
-    if (output === "rich") {
-      return renderObjectTable(result, primitives);
-    }
     if (output === "md") {
       return renderObjectMarkdown(result);
     }
-    return stringifyJson(result, 2);
+    if (output === "json") {
+      return stringifyJson(result, 2);
+    }
   }
   if (isArrayOfObjects(result)) {
     if (output === "md") {
@@ -7307,20 +8844,36 @@ function autoRender(result, output, primitives) {
     if (output === "json") {
       return stringifyJson(result, 2);
     }
-    return renderArrayTable(result, primitives);
+  }
+  if (output === "rich") {
+    return YAML.stringify(result);
   }
   return stringifyJson(result, 2);
 }
-function renderResult(command, result, output, primitives, write2 = (chunk) => {
+function renderResult(command, result, output, primitives, write2 = (chunk, stream = "stdout") => {
+  if (stream === "stderr") {
+    process.stderr.write(chunk);
+    return;
+  }
   process.stdout.write(chunk);
 }) {
+  const unwrapped = unwrapMcpEnvelope(result);
+  result = unwrapped.result;
+  if (unwrapped.mcpError) {
+    const payload2 = autoRender(result, output, primitives);
+    if (payload2.length > 0) {
+      write2(`${payload2}
+`, "stderr");
+    }
+    return { mcpError: true };
+  }
   if (output === "json" && command.render?.json) {
     const payload2 = command.render.json(result, primitives);
     if (payload2 !== void 0) {
       write2(`${stringifyJson(payload2, 2)}
 `);
     }
-    return;
+    return { mcpError: false };
   }
   if (output === "md" && command.render?.markdown) {
     const payload2 = command.render.markdown(result, primitives);
@@ -7328,17 +8881,18 @@ function renderResult(command, result, output, primitives, write2 = (chunk) => {
       write2(`${payload2}
 `);
     }
-    return;
+    return { mcpError: false };
   }
   if (output === "rich" && command.render?.rich) {
     command.render.rich(result, primitives);
-    return;
+    return { mcpError: false };
   }
   const payload = autoRender(result, output, primitives);
   if (payload.length > 0) {
     write2(`${payload}
 `);
   }
+  return { mcpError: false };
 }
 
 // ../toolcraft/src/cli.ts
@@ -7349,7 +8903,7 @@ function inferProgramName(argv) {
   if (typeof entrypoint !== "string" || entrypoint.length === 0) {
     return "toolcraft";
   }
-  const parsed = path6.parse(entrypoint);
+  const parsed = path9.parse(entrypoint);
   return parsed.name.length > 0 ? parsed.name : "toolcraft";
 }
 function normalizeRoots(roots, argv) {
@@ -7371,7 +8925,7 @@ function unwrapOptional(schema) {
   }
   return schema;
 }
-function splitWords(value) {
+function splitWords3(value) {
   const words = [];
   let current = "";
   for (let index = 0; index < value.length; index += 1) {
@@ -7405,13 +8959,13 @@ function splitWords(value) {
 }
 function formatSegment(segment, casing) {
   const separator = casing === "snake" ? "_" : "-";
-  return splitWords(segment).join(separator);
+  return splitWords3(segment).join(separator);
 }
-function toOptionFlag(path12, casing) {
-  return `--${path12.map((segment) => formatSegment(segment, casing)).join(".")}`;
+function toOptionFlag(path15, casing) {
+  return `--${path15.map((segment) => formatSegment(segment, casing)).join(".")}`;
 }
-function toOptionAttribute(path12, casing) {
-  return path12.map((segment) => {
+function toOptionAttribute(path15, casing) {
+  return path15.map((segment) => {
     const formatted = formatSegment(segment, casing);
     if (casing === "snake") {
       return formatted;
@@ -7422,23 +8976,23 @@ function toOptionAttribute(path12, casing) {
     ).join("");
   }).join(".");
 }
-function toDisplayPath(path12) {
-  return path12.join(".");
+function toDisplayPath(path15) {
+  return path15.join(".");
 }
-function toUnionKindControlPath(path12) {
-  if (path12.length === 0) {
+function toUnionKindControlPath(path15) {
+  if (path15.length === 0) {
     return ["kind"];
   }
-  const head = path12.slice(0, -1);
-  const tail = path12[path12.length - 1] ?? "";
+  const head = path15.slice(0, -1);
+  const tail = path15[path15.length - 1] ?? "";
   return [...head, `${tail}Kind`];
 }
-function toUnionKindDisplayPath(path12) {
-  if (path12.length === 0) {
+function toUnionKindDisplayPath(path15) {
+  if (path15.length === 0) {
     return "kind";
   }
-  const head = path12.slice(0, -1);
-  const tail = path12[path12.length - 1] ?? "";
+  const head = path15.slice(0, -1);
+  const tail = path15[path15.length - 1] ?? "";
   return [...head, `${tail}-kind`].join(".");
 }
 function createSyntheticEnumSchema(values) {
@@ -7454,19 +9008,26 @@ function getRequiredBranchFingerprint(branch, casing) {
   const requiredKeys = Object.entries(branch.shape).filter(([, schema]) => schema.kind !== "optional").map(([key2]) => formatSegment(key2, casing)).sort();
   return requiredKeys.join("+");
 }
-function collectFields(schema, casing, path12 = [], inheritedOptional = false, variantContext) {
+function collectFields(schema, casing, globalLongOptionFlags, path15 = [], inheritedOptional = false, variantContext) {
   const collected = {
     dynamicFields: [],
     fields: [],
     variants: []
   };
   for (const [key2, rawChildSchema] of Object.entries(schema.shape)) {
-    const nextPath = [...path12, key2];
+    const nextPath = [...path15, key2];
     const runtimeOptional = inheritedOptional || rawChildSchema.kind === "optional";
     const childSchema = unwrapOptional(rawChildSchema);
     const requiredWhenActive = rawChildSchema.kind !== "optional" && childSchema.default === void 0;
     if (childSchema.kind === "object") {
-      const nested = collectFields(childSchema, casing, nextPath, runtimeOptional, variantContext);
+      const nested = collectFields(
+        childSchema,
+        casing,
+        globalLongOptionFlags,
+        nextPath,
+        runtimeOptional,
+        variantContext
+      );
       collected.dynamicFields.push(...nested.dynamicFields);
       collected.fields.push(...nested.fields);
       collected.variants.push(...nested.variants);
@@ -7480,7 +9041,11 @@ function collectFields(schema, casing, path12 = [], inheritedOptional = false, v
         path: [...nextPath, childSchema.discriminator],
         displayPath: toDisplayPath([...nextPath, childSchema.discriminator]),
         optionAttribute: toOptionAttribute([...nextPath, childSchema.discriminator], casing),
-        commanderOptionAttribute: toCommanderOptionAttribute([...nextPath, childSchema.discriminator], casing),
+        commanderOptionAttribute: toCommanderOptionAttribute(
+          [...nextPath, childSchema.discriminator],
+          casing,
+          globalLongOptionFlags
+        ),
         optionFlag: toOptionFlag([...nextPath, childSchema.discriminator], casing),
         shortFlag: void 0,
         schema: createSyntheticEnumSchema(branchIds),
@@ -7493,7 +9058,7 @@ function collectFields(schema, casing, path12 = [], inheritedOptional = false, v
       collected.fields.push(controlField);
       const branches = [];
       for (const [branchId, branchSchema] of Object.entries(childSchema.branches)) {
-        const branch = collectFields(branchSchema, casing, nextPath, true, {
+        const branch = collectFields(branchSchema, casing, globalLongOptionFlags, nextPath, true, {
           id: variantId,
           branchId
         });
@@ -7521,13 +9086,19 @@ function collectFields(schema, casing, path12 = [], inheritedOptional = false, v
       const variantId = `${toDisplayPath(nextPath)}:union`;
       const controlPath = toUnionKindControlPath(nextPath);
       const controlDisplayPath = toUnionKindDisplayPath(nextPath);
-      const branchIds = childSchema.branches.map((branch) => getRequiredBranchFingerprint(branch, casing));
+      const branchIds = childSchema.branches.map(
+        (branch) => getRequiredBranchFingerprint(branch, casing)
+      );
       const controlField = {
         id: controlDisplayPath,
         path: controlPath,
         displayPath: controlDisplayPath,
         optionAttribute: toOptionAttribute(controlPath, casing),
-        commanderOptionAttribute: toCommanderOptionAttribute(controlPath, casing),
+        commanderOptionAttribute: toCommanderOptionAttribute(
+          controlPath,
+          casing,
+          globalLongOptionFlags
+        ),
         optionFlag: toOptionFlag(controlPath, casing),
         shortFlag: void 0,
         schema: createSyntheticEnumSchema(branchIds),
@@ -7542,7 +9113,7 @@ function collectFields(schema, casing, path12 = [], inheritedOptional = false, v
       const branches = [];
       childSchema.branches.forEach((branchSchema, index) => {
         const branchId = branchIds[index] ?? "";
-        const branch = collectFields(branchSchema, casing, nextPath, true, {
+        const branch = collectFields(branchSchema, casing, globalLongOptionFlags, nextPath, true, {
           id: variantId,
           branchId
         });
@@ -7609,7 +9180,7 @@ function collectFields(schema, casing, path12 = [], inheritedOptional = false, v
       path: nextPath,
       displayPath: toDisplayPath(nextPath),
       optionAttribute: toOptionAttribute(nextPath, casing),
-      commanderOptionAttribute: toCommanderOptionAttribute(nextPath, casing),
+      commanderOptionAttribute: toCommanderOptionAttribute(nextPath, casing, globalLongOptionFlags),
       optionFlag: toOptionFlag(nextPath, casing),
       shortFlag: childSchema.short,
       schema: childSchema,
@@ -7624,10 +9195,10 @@ function collectFields(schema, casing, path12 = [], inheritedOptional = false, v
   }
   return collected;
 }
-function toCommanderOptionAttribute(path12, casing) {
-  const optionAttribute = toOptionAttribute(path12, casing);
-  const optionFlag = toOptionFlag(path12, casing);
-  if (!GLOBAL_LONG_OPTION_FLAGS.has(optionFlag)) {
+function toCommanderOptionAttribute(path15, casing, globalLongOptionFlags) {
+  const optionAttribute = toOptionAttribute(path15, casing);
+  const optionFlag = toOptionFlag(path15, casing);
+  if (!globalLongOptionFlags.has(optionFlag)) {
     return optionAttribute;
   }
   return `param_${optionAttribute}`;
@@ -7657,8 +9228,8 @@ function assignPositionals(fields, positional) {
   });
   return fields;
 }
-function formatOptionFlags(field) {
-  const collidesWithGlobalFlag = GLOBAL_LONG_OPTION_FLAGS.has(field.optionFlag);
+function formatOptionFlags(field, globalLongOptionFlags) {
+  const collidesWithGlobalFlag = globalLongOptionFlags.has(field.optionFlag);
   if (collidesWithGlobalFlag) {
     if (field.shortFlag === void 0) {
       throw new UserError(
@@ -7774,11 +9345,13 @@ function parseArrayValue(value, schema, label) {
   if (itemSchema.kind === "array" || itemSchema.kind === "object") {
     throw new UserError(`Array parameter "${label}" must use scalar items.`);
   }
-  return splitArrayInput(value).map((item) => parseScalarValue(item, itemSchema, label));
+  return splitArrayInput(value).map(
+    (item) => parseScalarValue(item, itemSchema, label)
+  );
 }
-function createOption(field) {
-  const flags = formatOptionFlags(field);
-  const collidesWithGlobalFlag = GLOBAL_LONG_OPTION_FLAGS.has(field.optionFlag);
+function createOption(field, globalLongOptionFlags) {
+  const flags = formatOptionFlags(field, globalLongOptionFlags);
+  const collidesWithGlobalFlag = globalLongOptionFlags.has(field.optionFlag);
   const commanderValue = (value) => value === null ? NULL_OPTION_VALUE : value;
   if (field.schema.kind === "boolean") {
     if (collidesWithGlobalFlag) {
@@ -7798,7 +9371,11 @@ function createOption(field) {
     return [
       createCommanderOption(`${flags} <value...>`, field.description, field).argParser(
         (value, previous = []) => {
-          const parsed = parseArrayValue(value, field.schema, field.displayPath);
+          const parsed = parseArrayValue(
+            value,
+            field.schema,
+            field.displayPath
+          );
           if (parsed === null) {
             return NULL_OPTION_VALUE;
           }
@@ -7823,7 +9400,12 @@ function createOption(field) {
   );
   return [option];
 }
-var GLOBAL_LONG_OPTION_FLAGS = /* @__PURE__ */ new Set(["--preset", "--yes", "--output", "--verbose"]);
+var ALWAYS_GLOBAL_LONG_OPTION_FLAGS = ["--yes", "--output", "--verbose"];
+function getGlobalLongOptionFlags(presetsEnabled) {
+  return new Set(
+    presetsEnabled ? ["--preset", ...ALWAYS_GLOBAL_LONG_OPTION_FLAGS] : ALWAYS_GLOBAL_LONG_OPTION_FLAGS
+  );
+}
 function createCommanderOption(flags, description, field) {
   const option = new Option(flags, description);
   if (field.commanderOptionAttribute !== field.optionAttribute) {
@@ -7883,11 +9465,7 @@ function resolveHelpTarget(root, argv, scope, rootDisplayName) {
     if (current.kind !== "group") {
       break;
     }
-    const child = findVisibleChild(
-      current,
-      token,
-      scope
-    );
+    const child = findVisibleChild(current, token, scope);
     if (child === void 0) {
       break;
     }
@@ -7899,32 +9477,23 @@ function resolveHelpTarget(root, argv, scope, rootDisplayName) {
     node: current
   };
 }
-function describeSchemaType(schema) {
-  switch (schema.kind) {
-    case "string":
-      return "string";
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "enum":
-      return "value";
-    case "array":
-      return `${describeSchemaType(unwrapOptional(schema.item))}...`;
-    case "json":
-      return "json";
-    default:
-      throw new UserError("Unsupported CLI schema kind.");
-  }
-}
-function formatHelpFieldFlags(field) {
+function formatHelpFieldFlags(field, globalLongOptionFlags) {
   if (field.positionalIndex !== void 0) {
     return formatPositionalToken(field);
   }
   if (field.schema.kind === "boolean") {
-    return `${formatOptionFlags(field)} [value]`;
+    if (field.defaultValue === true) {
+      return `--no-${field.optionFlag.slice(2)}`;
+    }
+    return formatOptionFlags(field, globalLongOptionFlags);
   }
-  return `${formatOptionFlags(field)} <${describeSchemaType(field.schema)}>`;
+  return `${formatOptionFlags(field, globalLongOptionFlags)} <${describeHelpValueToken(
+    field.schema,
+    {
+      displayPath: field.displayPath,
+      optionFlag: field.optionFlag
+    }
+  )}>`;
 }
 function appendHelpMetadata(description, metadata) {
   if (metadata.length === 0) {
@@ -7946,6 +9515,87 @@ function formatHelpFieldDescription(field) {
   }
   return appendHelpMetadata(description, metadata);
 }
+function describeKnownStringFormat(format) {
+  switch (format) {
+    case "date":
+      return "date";
+    case "date-time":
+      return "datetime";
+    case "uri":
+      return "url";
+    case "email":
+      return "email";
+    default:
+      return void 0;
+  }
+}
+function describeKnownStringPattern(pattern) {
+  if (pattern === void 0) {
+    return void 0;
+  }
+  if (pattern === "^\\d{4}-\\d{2}-\\d{2}$") {
+    return "YYYY-MM-DD";
+  }
+  if (pattern.startsWith("^\\d{4}-\\d{2}-\\d{2}T")) {
+    return "YYYY-MM-DDTHH:MM:SS";
+  }
+  return void 0;
+}
+function stripLongOptionPrefix(optionFlag) {
+  return optionFlag.startsWith("--") ? optionFlag.slice(2) : optionFlag;
+}
+function getLastSegment(value, separator) {
+  const segments = value.split(separator);
+  return segments[segments.length - 1] ?? value;
+}
+function matchesFieldNameSuffix(name, suffix) {
+  const lowerName = name.toLowerCase();
+  const lowerSuffix = suffix.toLowerCase();
+  return lowerName === lowerSuffix || name.endsWith(suffix) || lowerName.endsWith(`-${lowerSuffix}`) || lowerName.endsWith(`_${lowerSuffix}`);
+}
+function describeFieldNameValueToken(displayPath, optionFlag) {
+  const displayName = getLastSegment(displayPath, ".");
+  const optionName = getLastSegment(stripLongOptionPrefix(optionFlag), ".");
+  const candidates = [displayName, optionName];
+  const suffixTokens = [
+    ["Path", "path"],
+    ["Paths", "path"],
+    ["File", "path"],
+    ["Files", "path"],
+    ["Url", "url"],
+    ["Email", "email"],
+    ["Name", "name"],
+    ["Id", "id"]
+  ];
+  for (const [suffix, token] of suffixTokens) {
+    if (candidates.some((candidate) => matchesFieldNameSuffix(candidate, suffix))) {
+      return token;
+    }
+  }
+  return void 0;
+}
+function describeHelpValueToken(schema, field) {
+  if (schema.kind === "array") {
+    const itemSchema = unwrapOptional(schema.item);
+    if (itemSchema.kind === "array" || itemSchema.kind === "object") {
+      return "value...";
+    }
+    return `${describeHelpValueToken(itemSchema, field)}...`;
+  }
+  if (schema.kind === "json") {
+    return "json";
+  }
+  if (schema.kind === "string") {
+    const metadataToken = describeKnownStringFormat(schema.format) ?? describeKnownStringPattern(schema.pattern);
+    if (metadataToken !== void 0) {
+      return metadataToken;
+    }
+  }
+  if (schema.kind === "enum") {
+    return "value";
+  }
+  return describeFieldNameValueToken(field.displayPath, field.optionFlag) ?? "value";
+}
 function describeDynamicFieldType(field) {
   if (field.schema.kind === "record") {
     const valueSchema = unwrapOptional(field.schema.value);
@@ -7953,12 +9603,18 @@ function describeDynamicFieldType(field) {
       return "json";
     }
     if (valueSchema.kind === "array") {
-      return `${describeSchemaType(valueSchema)}`;
+      return describeHelpValueToken(valueSchema, {
+        displayPath: field.optionPathDisplay,
+        optionFlag: field.optionFlag
+      });
     }
     if (valueSchema.kind === "object") {
       return "value";
     }
-    return describeSchemaType(valueSchema);
+    return describeHelpValueToken(valueSchema, {
+      displayPath: field.optionPathDisplay,
+      optionFlag: field.optionFlag
+    });
   }
   return "value";
 }
@@ -7980,7 +9636,9 @@ function collectDynamicObjectHelpRows(schema, casing, optionPrefix, displayPrefi
     const displayPath = `${displayPrefix}.${key2}`;
     const description = childSchema.description ?? displayPath;
     if (childSchema.kind === "object") {
-      rows.push(...collectDynamicObjectHelpRows(childSchema, casing, optionFlag, displayPath, metadata));
+      rows.push(
+        ...collectDynamicObjectHelpRows(childSchema, casing, optionFlag, displayPath, metadata)
+      );
       continue;
     }
     if (childSchema.kind === "record") {
@@ -8017,7 +9675,10 @@ function collectDynamicObjectHelpRows(schema, casing, optionPrefix, displayPrefi
       continue;
     }
     rows.push({
-      flags: childSchema.kind === "boolean" ? `${optionFlag} [value]` : `${optionFlag} <${describeSchemaType(childSchema)}>`,
+      flags: childSchema.kind === "boolean" ? childSchema.default === true ? `--no-${optionFlag.slice(2)}` : optionFlag : `${optionFlag} <${describeHelpValueToken(childSchema, {
+        displayPath,
+        optionFlag
+      })}>`,
       description: appendHelpMetadata(description, metadata)
     });
   }
@@ -8049,10 +9710,12 @@ function formatDynamicHelpFields(field, casing) {
       );
     }
   }
-  return [{
-    flags: `${field.optionFlag} <${describeDynamicFieldType(field)}>`,
-    description: appendHelpMetadata(field.description ?? field.optionPathDisplay, metadata)
-  }];
+  return [
+    {
+      flags: `${field.optionFlag} <${describeDynamicFieldType(field)}>`,
+      description: appendHelpMetadata(field.description ?? field.optionPathDisplay, metadata)
+    }
+  ];
 }
 function formatSecretRows(secrets) {
   return Object.values(secrets).map((secret) => ({
@@ -8066,32 +9729,58 @@ function formatSecretDescription(secret) {
   }
   return secret.optional === true ? "Optional secret" : "Required secret";
 }
-function formatCommandRows(group, scope) {
+function wrapOptionalCommandParameterToken(token, optional) {
+  return optional ? `[${token}]` : token;
+}
+function formatCommandDynamicParameterTokens(field, casing) {
+  const optional = field.optional || field.hasDefault;
+  return formatDynamicHelpFields(field, casing).map(
+    (row) => wrapOptionalCommandParameterToken(row.flags, optional)
+  );
+}
+function formatCommandParameterTokens(command, casing, globalLongOptionFlags) {
+  const collected = collectFields(command.params, casing, globalLongOptionFlags);
+  const fields = assignPositionals(collected.fields, command.positional);
+  return fields.map(
+    (field) => wrapOptionalCommandParameterToken(
+      formatHelpFieldFlags(field, globalLongOptionFlags),
+      field.positionalIndex === void 0 && (field.optional || field.hasDefault)
+    )
+  ).concat(
+    collected.dynamicFields.flatMap((field) => formatCommandDynamicParameterTokens(field, casing))
+  );
+}
+function formatCommandRowName(node, casing, globalLongOptionFlags) {
+  const baseName = node.aliases.length === 0 ? node.name : `${node.name} (${node.aliases.join(", ")})`;
+  const parameterTokens = node.kind === "command" ? formatCommandParameterTokens(node, casing, globalLongOptionFlags) : [];
+  const name = parameterTokens.length === 0 ? baseName : `${baseName} ${parameterTokens.join(" ")}`;
+  return name;
+}
+function formatCommandRows(group, scope, casing, globalLongOptionFlags) {
   return getVisibleChildren(group, scope).map((child) => ({
-    name: child.aliases.length === 0 ? child.name : `${child.name} (${child.aliases.join(", ")})`,
+    name: formatCommandRowName(child, casing, globalLongOptionFlags),
     description: child.description ?? ""
   }));
 }
-function formatGlobalOptionRows(showVersion) {
-  const rows = [
-    {
+function formatGlobalOptionRows(ctx) {
+  const rows = [];
+  if (ctx.presetsEnabled) {
+    rows.push({
       flags: "--preset <path>",
       description: "Load parameter defaults from a JSON file"
-    },
+    });
+  }
+  rows.push(
     {
       flags: "--yes",
       description: "Accept defaults, skip prompts"
     },
     {
       flags: "--output <format>",
-      description: "Output format (rich, md, json)"
-    },
-    {
-      flags: "-h, --help",
-      description: "Show help"
+      description: "Output format: rich, md, json."
     }
-  ];
-  if (showVersion) {
+  );
+  if (ctx.showVersion) {
     rows.push({
       flags: "--version",
       description: "Show version"
@@ -8102,53 +9791,69 @@ function formatGlobalOptionRows(showVersion) {
 function renderHelpSections(sections) {
   return sections.filter((section) => section.length > 0).join("\n\n");
 }
+function formatHelpCommandList(rows) {
+  return process.stdout.isTTY === false ? help_formatter_plain_exports.formatCommandList(rows) : formatCommandList(rows);
+}
+function formatHelpOptionList(rows) {
+  return process.stdout.isTTY === false ? help_formatter_plain_exports.formatOptionList(rows) : formatOptionList(rows);
+}
 function buildUsageLine(breadcrumb, rootUsageName, suffix) {
-  if (rootUsageName === void 0) {
-    return void 0;
-  }
-  const subPath = breadcrumb.slice(1).join(" ");
-  return subPath ? `${rootUsageName} ${subPath} ${suffix}` : `${rootUsageName} ${suffix}`;
+  const visibleBreadcrumb = breadcrumb.filter((segment) => segment.length > 0);
+  const usageBreadcrumb = breadcrumb[0] === "" ? [rootUsageName, ...visibleBreadcrumb] : visibleBreadcrumb;
+  const subPath = usageBreadcrumb.slice(1).join(" ");
+  const tokens = [rootUsageName, subPath, suffix].filter((segment) => segment.length > 0);
+  return tokens.join(" ");
 }
-function renderGroupHelp(group, breadcrumb, scope, showVersion, rootUsageName) {
+function renderGroupHelp(group, breadcrumb, scope, casing, globalOptions, rootUsageName) {
   const sections = [];
-  const commandRows = formatCommandRows(group, scope);
+  const globalLongOptionFlags = getGlobalLongOptionFlags(globalOptions.presetsEnabled);
+  const commandRows = formatCommandRows(group, scope, casing, globalLongOptionFlags);
   if (commandRows.length > 0) {
-    sections.push(`${text.section("Commands:")}
-${formatCommandList(commandRows)}`);
+    sections.push(`${text.sectionHeader("Commands")}
+${formatHelpCommandList(commandRows)}`);
   }
-  sections.push(`${text.section("Global options:")}
-${formatOptionList(formatGlobalOptionRows(showVersion))}`);
+  sections.push(
+    `${text.sectionHeader("Options")}
+${formatHelpOptionList(formatGlobalOptionRows(globalOptions))}`
+  );
   return renderHelpDocument({
     breadcrumb,
-    usageLine: buildUsageLine(breadcrumb, rootUsageName, "[options] [command]"),
+    rootUsageName,
+    usageLine: buildUsageLine(breadcrumb, rootUsageName, "[command] [options]"),
     description: group.description,
     requiresAuth: group.requires?.auth === true,
     sections
   });
 }
-function renderLeafHelp(command, breadcrumb, casing, rootUsageName) {
+function renderLeafHelp(command, breadcrumb, casing, globalOptions, rootUsageName) {
   const sections = [];
-  const collected = collectFields(command.params, casing);
+  const globalLongOptionFlags = getGlobalLongOptionFlags(globalOptions.presetsEnabled);
+  const collected = collectFields(command.params, casing, globalLongOptionFlags);
   const fields = assignPositionals(collected.fields, command.positional);
   const optionRows = fields.map((field) => ({
-    flags: formatHelpFieldFlags(field),
+    flags: formatHelpFieldFlags(field, globalLongOptionFlags),
     description: formatHelpFieldDescription(field)
   })).concat(collected.dynamicFields.flatMap((field) => formatDynamicHelpFields(field, casing)));
   if (optionRows.length > 0) {
-    sections.push(`${text.section("Options:")}
-${formatOptionList(optionRows)}`);
+    sections.push(`${text.sectionHeader("Options")}
+${formatHelpOptionList(optionRows)}`);
   }
-  sections.push(`${text.section("Global options:")}
-${formatOptionList(formatGlobalOptionRows(false))}`);
+  sections.push(
+    `${text.sectionHeader("Options")}
+${formatHelpOptionList(formatGlobalOptionRows(globalOptions))}`
+  );
   const secretRows = formatSecretRows(command.secrets);
   if (secretRows.length > 0) {
-    sections.push(`${text.section("Secrets (via environment):")}
-${formatOptionList(secretRows)}`);
+    sections.push(
+      `${text.sectionHeader("Secrets (environment)")}
+${formatHelpOptionList(secretRows)}`
+    );
   }
   const positionalFields = fields.filter((f) => f.positionalIndex !== void 0);
   const usageSuffix = positionalFields.length > 0 ? `[options] ${positionalFields.map(formatPositionalToken).join(" ")}` : "[options]";
   return renderHelpDocument({
     breadcrumb,
+    rootUsageName,
     usageLine: buildUsageLine(breadcrumb, rootUsageName, usageSuffix),
     description: command.description,
     requiresAuth: command.requires?.auth === true,
@@ -8156,17 +9861,21 @@ ${formatOptionList(secretRows)}`);
   });
 }
 function renderHelpDocument(input) {
-  const lines = [text.heading(input.breadcrumb.join(" ")), ""];
-  if (input.usageLine !== void 0) {
-    lines.push(`${text.section("Usage:")} ${text.usageCommand(input.usageLine)}`, "");
-  }
-  if (input.description !== void 0) {
-    lines.push(input.description);
-  }
+  const title = input.breadcrumb.filter((segment) => segment.length > 0).join(" ") || input.rootUsageName;
+  const description = input.description ?? "";
+  const sentenceEndIndex = description.indexOf(". ");
+  const headingDescription = sentenceEndIndex === -1 ? description : description.slice(0, sentenceEndIndex + 1);
+  const remainingDescription = sentenceEndIndex === -1 ? "" : description.slice(sentenceEndIndex + 2);
+  const heading = headingDescription.length > 0 ? `${title} \u2014 ${headingDescription}` : title;
+  const lines = [text.heading(heading), ""];
+  if (remainingDescription.length > 0) {
+    lines.push(remainingDescription, "");
+  }
+  lines.push(`Usage: ${text.usageCommand(input.usageLine)}`, "");
   if (input.requiresAuth) {
     lines.push("Requires: authentication");
   }
-  if (input.description !== void 0 || input.requiresAuth) {
+  if (input.requiresAuth) {
     lines.push("");
   }
   lines.push(renderHelpSections(input.sections));
@@ -8177,26 +9886,46 @@ async function renderGeneratedHelp(root, argv, options) {
   const target = resolveHelpTarget(root, argv, "cli", options.rootDisplayName);
   const output = resolveHelpOutput(argv);
   const casing = options.casing ?? "kebab";
+  const rootUsageName = options.rootUsageName ?? inferProgramName(argv);
   await withOutputFormat2(output, async () => {
-    const rendered = target.node.kind === "group" ? renderGroupHelp(target.node, target.breadcrumb, "cli", options.version !== void 0, options.rootUsageName) : renderLeafHelp(target.node, target.breadcrumb, casing, options.rootUsageName);
+    const rendered = target.node.kind === "group" ? renderGroupHelp(
+      target.node,
+      target.breadcrumb,
+      "cli",
+      casing,
+      {
+        showVersion: options.version !== void 0,
+        presetsEnabled: options.presets === true
+      },
+      rootUsageName
+    ) : renderLeafHelp(
+      target.node,
+      target.breadcrumb,
+      casing,
+      {
+        showVersion: options.version !== void 0,
+        presetsEnabled: options.presets === true
+      },
+      rootUsageName
+    );
     process.stdout.write(rendered);
   });
 }
-function createNodeCommand(node, casing, execute, pathSegments = []) {
+function createNodeCommand(node, casing, globalLongOptionFlags, execute, presetsEnabled, pathSegments = []) {
   const nextPathSegments = [...pathSegments, node.name];
   if (node.kind === "command") {
     if (!node.scope.includes("cli")) {
       return null;
     }
     const command = new CommanderCommand(node.name);
-    const collected = collectFields(node.params, casing);
+    const collected = collectFields(node.params, casing, globalLongOptionFlags);
     const fields = assignPositionals(collected.fields, node.positional);
     if (node.description !== void 0) {
       command.description(node.description);
     }
     node.aliases.forEach((alias) => command.alias(alias));
     command.addHelpCommand(false);
-    addGlobalOptions(command);
+    addGlobalOptions(command, presetsEnabled);
     command.allowExcessArguments(true);
     if (collected.dynamicFields.length > 0) {
       command.allowUnknownOption(true);
@@ -8206,7 +9935,7 @@ function createNodeCommand(node, casing, execute, pathSegments = []) {
         command.argument(formatPositionalToken(field));
         continue;
       }
-      for (const option of createOption(field)) {
+      for (const option of createOption(field, globalLongOptionFlags)) {
         command.addOption(option);
       }
     }
@@ -8220,6 +9949,7 @@ function createNodeCommand(node, casing, execute, pathSegments = []) {
         dynamicFields: collected.dynamicFields,
         fields,
         positionalValues,
+        presetsEnabled,
         rawArgv: actionCommand.args,
         actionCommand,
         variants: collected.variants
@@ -8230,35 +9960,49 @@ function createNodeCommand(node, casing, execute, pathSegments = []) {
   if (!isNodeVisibleInScope(node, "cli")) {
     return null;
   }
-  const visibleChildren = node.children.map((child) => createNodeCommand(child, casing, execute, nextPathSegments)).filter((child) => child !== null);
+  const visibleChildren = node.children.map(
+    (child) => createNodeCommand(
+      child,
+      casing,
+      globalLongOptionFlags,
+      execute,
+      presetsEnabled,
+      nextPathSegments
+    )
+  ).filter((child) => child !== null);
   const group = new CommanderCommand(node.name);
   if (node.description !== void 0) {
     group.description(node.description);
   }
   node.aliases.forEach((alias) => group.alias(alias));
   group.addHelpCommand(false);
-  addGlobalOptions(group);
+  addGlobalOptions(group, presetsEnabled);
   for (const child of visibleChildren) {
     const isDefaultChild = node.default !== void 0 && node.default.scope.includes("cli") && (child.name() === node.default.name || child.aliases().includes(node.default.name));
     group.addCommand(child, isDefaultChild ? { isDefault: true } : void 0);
   }
   return group;
 }
-function addGlobalOptions(command) {
-  command.option("--preset <path>", "Load parameter defaults from a JSON file.").option("--yes", "Accept defaults and skip prompts.").option("--output <format>", "Output format.", (value) => {
+function addGlobalOptions(command, presetsEnabled) {
+  if (presetsEnabled) {
+    command.option("--preset <path>", "Load parameter defaults from a JSON file.");
+  }
+  command.option("--yes", "Accept defaults and skip prompts.").option("--output <format>", "Output format.", (value) => {
     if (value === "rich" || value === "md" || value === "json") {
       return value;
     }
     if (value === "markdown") {
       return "md";
     }
-    throw new InvalidArgumentError('Invalid value for "--output". Expected one of: rich, md, markdown, json.');
+    throw new InvalidArgumentError(
+      'Invalid value for "--output". Expected one of: rich, md, markdown, json.'
+    );
   }).option("--verbose", "Print stack traces for unexpected errors.");
 }
-function setNestedValue(target, path12, value) {
+function setNestedValue(target, path15, value) {
   let cursor = target;
-  for (let index = 0; index < path12.length - 1; index += 1) {
-    const segment = path12[index] ?? "";
+  for (let index = 0; index < path15.length - 1; index += 1) {
+    const segment = path15[index] ?? "";
     const existing = cursor[segment];
     if (typeof existing === "object" && existing !== null) {
       cursor = existing;
@@ -8268,7 +10012,7 @@ function setNestedValue(target, path12, value) {
     cursor[segment] = next;
     cursor = next;
   }
-  const leaf = path12[path12.length - 1];
+  const leaf = path15[path15.length - 1];
   if (leaf !== void 0) {
     cursor[leaf] = value;
   }
@@ -8370,13 +10114,13 @@ async function withOutputFormat2(output, fn) {
 }
 function createFs2() {
   return {
-    readFile: async (path12, encoding = "utf8") => readFile3(path12, { encoding }),
-    writeFile: async (path12, contents) => {
-      await writeFile3(path12, contents);
+    readFile: async (path15, encoding = "utf8") => readFile5(path15, { encoding }),
+    writeFile: async (path15, contents) => {
+      await writeFile3(path15, contents);
     },
-    exists: async (path12) => {
+    exists: async (path15) => {
       try {
-        await access2(path12);
+        await access2(path15);
         return true;
       } catch {
         return false;
@@ -8397,9 +10141,9 @@ function isPlainObject2(value) {
 function hasFieldValue(value) {
   return value !== void 0;
 }
-function hasNestedField(fields, path12) {
+function hasNestedField(fields, path15) {
   return fields.some(
-    (field) => path12.length < field.path.length && path12.every((segment, index) => field.path[index] === segment)
+    (field) => path15.length < field.path.length && path15.every((segment, index) => field.path[index] === segment)
   );
 }
 function describeExpectedPresetValue(schema) {
@@ -8456,7 +10200,12 @@ function validatePresetFieldValue(value, field, presetPath) {
     return value;
   }
   if (field.schema.kind !== "array") {
-    return validatePresetScalarValue(value, field.schema, field.displayPath, presetPath);
+    return validatePresetScalarValue(
+      value,
+      field.schema,
+      field.displayPath,
+      presetPath
+    );
   }
   const itemSchema = unwrapOptional(field.schema.item);
   if (itemSchema.kind === "array" || itemSchema.kind === "object") {
@@ -8474,7 +10223,7 @@ function validatePresetFieldValue(value, field, presetPath) {
 async function loadPresetValues(fields, presetPath) {
   let rawPreset;
   try {
-    rawPreset = await readFile3(presetPath, {
+    rawPreset = await readFile5(presetPath, {
       encoding: "utf8"
     });
   } catch (error2) {
@@ -8495,9 +10244,9 @@ async function loadPresetValues(fields, presetPath) {
   }
   const fieldByPath = new Map(fields.map((field) => [field.displayPath, field]));
   const presetValues = {};
-  function visitObject(current, path12) {
+  function visitObject(current, path15) {
     for (const [key2, value] of Object.entries(current)) {
-      const nextPath = [...path12, key2];
+      const nextPath = [...path15, key2];
       const displayPath = toDisplayPath(nextPath);
       const field = fieldByPath.get(displayPath);
       if (field !== void 0) {
@@ -8556,7 +10305,9 @@ function matchesFixtureValue(expected, actual) {
     if (!isPlainObject2(actual)) {
       return false;
     }
-    return Object.entries(expected).every(([key2, value]) => matchesFixtureValue(value, actual[key2]));
+    return Object.entries(expected).every(
+      ([key2, value]) => matchesFixtureValue(value, actual[key2])
+    );
   }
   return Object.is(expected, actual);
 }
@@ -8594,7 +10345,9 @@ function createFixtureResponse(response) {
 }
 function createFixtureFetch(entries) {
   return async (input, init) => {
-    const method = normalizeHttpMethod(init?.method ?? (input instanceof Request ? input.method : void 0));
+    const method = normalizeHttpMethod(
+      init?.method ?? (input instanceof Request ? input.method : void 0)
+    );
     const url = getFetchUrl(input);
     const match = entries?.find((entry) => {
       const requestMethod = normalizeHttpMethod(entry.request.method);
@@ -8639,7 +10392,9 @@ function resolveFixtureMethodResult(methodName, definition, args) {
       }
       const explicitMatcher = isPlainObject2(entry.request) ? entry.request : void 0;
       const matcher = explicitMatcher ?? Object.fromEntries(
-        Object.entries(entry).filter(([key2]) => key2 !== "result" && key2 !== "response" && key2 !== "error")
+        Object.entries(entry).filter(
+          ([key2]) => key2 !== "result" && key2 !== "response" && key2 !== "error"
+        )
       );
       const firstArg = args[0];
       let matched = false;
@@ -8695,8 +10450,8 @@ function createFixtureService(definition) {
   );
 }
 function resolveFixturePath(commandPath) {
-  const parsed = path6.parse(commandPath);
-  return path6.join(parsed.dir, `${parsed.name}.fixture.json`);
+  const parsed = path9.parse(commandPath);
+  return path9.join(parsed.dir, `${parsed.name}.fixture.json`);
 }
 function selectFixtureScenario(scenarios, selector) {
   if (isNumericFixtureSelector(selector)) {
@@ -8718,12 +10473,14 @@ function selectFixtureScenario(scenarios, selector) {
 async function loadFixtureScenario(command, selector) {
   const commandPath = getCommandSourcePath(command);
   if (commandPath === void 0) {
-    throw new UserError(`Fixture mode could not determine the source file for command "${command.name}".`);
+    throw new UserError(
+      `Fixture mode could not determine the source file for command "${command.name}".`
+    );
   }
   const fixturePath = resolveFixturePath(commandPath);
   let rawFixture;
   try {
-    rawFixture = await readFile3(fixturePath, {
+    rawFixture = await readFile5(fixturePath, {
       encoding: "utf8"
     });
   } catch {
@@ -8819,8 +10576,8 @@ function validateServices(services) {
     }
   }
 }
-function getNestedValue(target, path12) {
-  return path12.reduce(
+function getNestedValue(target, path15) {
+  return path15.reduce(
     (current, segment) => current !== null && typeof current === "object" ? current[segment] : void 0,
     target
   );
@@ -8919,7 +10676,13 @@ function resolveDynamicLeaf(schema, rawSegments, casing, outputPath = [], displa
         if (formatSegment(key2, casing) !== head) {
           continue;
         }
-        return resolveDynamicLeaf(childSchema, rest, casing, [...outputPath, key2], [...displayPath, key2]);
+        return resolveDynamicLeaf(
+          childSchema,
+          rest,
+          casing,
+          [...outputPath, key2],
+          [...displayPath, key2]
+        );
       }
       throw new UserError(`Unknown parameter "${[...displayPath, head].join(".")}".`);
     }
@@ -8936,13 +10699,23 @@ function resolveDynamicLeaf(schema, rawSegments, casing, outputPath = [], displa
     case "array": {
       const itemSchema = unwrapOptional(unwrappedSchema.item);
       if (itemSchema.kind !== "object") {
-        throw new UserError(`Array parameter "${toDisplayPath(displayPath)}" must use object items.`);
+        throw new UserError(
+          `Array parameter "${toDisplayPath(displayPath)}" must use object items.`
+        );
       }
       const [head, ...rest] = rawSegments;
       if (head === void 0 || !isNumericFixtureSelector(head)) {
-        throw new UserError(`Array parameter "${toDisplayPath(displayPath)}" must use numeric indices.`);
+        throw new UserError(
+          `Array parameter "${toDisplayPath(displayPath)}" must use numeric indices.`
+        );
       }
-      return resolveDynamicLeaf(itemSchema, rest, casing, [...outputPath, head], [...displayPath, head]);
+      return resolveDynamicLeaf(
+        itemSchema,
+        rest,
+        casing,
+        [...outputPath, head],
+        [...displayPath, head]
+      );
     }
     default:
       throw new UserError(`Unknown parameter "${[...displayPath, ...rawSegments].join(".")}".`);
@@ -8978,7 +10751,9 @@ function finalizeDynamicValue(schema, value, displayPath) {
       }
       for (let index = 0; index < indices.length; index += 1) {
         if (indices[index] !== index) {
-          throw new UserError(`Array parameter "${displayPath}" must use contiguous indices starting at 0.`);
+          throw new UserError(
+            `Array parameter "${displayPath}" must use contiguous indices starting at 0.`
+          );
         }
       }
       return indices.map(
@@ -9034,7 +10809,9 @@ function finalizeDynamicValue(schema, value, displayPath) {
 function parseDynamicValues(dynamicFields, rawArgv, casing) {
   const rawValues = /* @__PURE__ */ new Map();
   const providedFieldIds = /* @__PURE__ */ new Set();
-  const sortedFields = [...dynamicFields].sort((left, right) => right.optionPath.length - left.optionPath.length);
+  const sortedFields = [...dynamicFields].sort(
+    (left, right) => right.optionPath.length - left.optionPath.length
+  );
   for (let index = 0; index < rawArgv.length; index += 1) {
     const token = rawArgv[index] ?? "";
     if (!token.startsWith("--")) {
@@ -9121,7 +10898,9 @@ async function enforceVariantConstraints(params17, fields, dynamicFields, varian
           );
         }
       }
-      const invalidDynamicFieldId = branch.dynamicFieldIds.find((fieldId) => providedDynamicFieldIds.has(fieldId));
+      const invalidDynamicFieldId = branch.dynamicFieldIds.find(
+        (fieldId) => providedDynamicFieldIds.has(fieldId)
+      );
       if (invalidDynamicFieldId !== void 0) {
         const field = dynamicFieldById.get(invalidDynamicFieldId);
         if (field !== void 0) {
@@ -9286,7 +11065,7 @@ async function executeCommand(state, services, requirementOptions, runtimeOption
       optionValues,
       state.rawArgv,
       state.casing,
-      resolvedFlags.preset,
+      state.presetsEnabled ? resolvedFlags.preset : void 0,
       shouldPrompt
     );
     const context = {
@@ -9315,7 +11094,12 @@ async function executeCommand(state, services, requirementOptions, runtimeOption
         throw new UserError("Operation cancelled.");
       }
     }
-    const result = await invokeWithHumanInLoop(state.command, context, runtimeOptions, state.commandPath);
+    const result = await invokeWithHumanInLoop(
+      state.command,
+      context,
+      runtimeOptions,
+      state.commandPath
+    );
     if (output === "rich" && runtime.isFixture) {
       writeRichHeader(`${state.command.name} (fixture)`);
     }
@@ -9323,7 +11107,10 @@ async function executeCommand(state, services, requirementOptions, runtimeOption
       renderHumanInLoopPending(result);
       return;
     }
-    renderResult(state.command, result, output, primitives);
+    const renderStatus = renderResult(state.command, result, output, primitives);
+    if (renderStatus.mcpError) {
+      process.exitCode = 1;
+    }
   });
 }
 function handleRunError(error2, verbose) {
@@ -9350,10 +11137,11 @@ function handleRunError(error2, verbose) {
 }
 async function runCLI(roots, options = {}) {
   const root = mergeApprovalsGroup(normalizeRoots(roots, process.argv));
-  await resolveMcpProxies(root);
+  await resolveMcpProxies(root, { projectRoot: options.projectRoot });
   const casing = options.casing ?? "kebab";
   const services = options.services ?? {};
   const runtimeOptions = options.humanInLoop ?? {};
+  const version = options.version ?? findEntrypointPackageMetadata(process.argv[1])?.version;
   const servicesWithBuiltIns = {
     ...services,
     runtimeOptions,
@@ -9364,7 +11152,7 @@ async function runCLI(roots, options = {}) {
   };
   validateServices(services);
   if (hasHelpFlag(process.argv)) {
-    await renderGeneratedHelp(root, process.argv, options);
+    await renderGeneratedHelp(root, process.argv, { ...options, version });
     return;
   }
   const program = new CommanderCommand();
@@ -9372,9 +11160,11 @@ async function runCLI(roots, options = {}) {
   program.exitOverride();
   program.showHelpAfterError();
   program.addHelpCommand(false);
-  addGlobalOptions(program);
-  if (options.version !== void 0) {
-    program.version(options.version, "--version");
+  const presetsEnabled = options.presets === true;
+  const globalLongOptionFlags = getGlobalLongOptionFlags(presetsEnabled);
+  addGlobalOptions(program, presetsEnabled);
+  if (version !== void 0) {
+    program.version(version, "--version");
   }
   let lastActionCommand;
   const execute = async (state) => {
@@ -9382,7 +11172,13 @@ async function runCLI(roots, options = {}) {
     await executeCommand(state, servicesWithBuiltIns, requirementOptions, runtimeOptions);
   };
   for (const child of root.children) {
-    const command = createNodeCommand(child, casing, execute);
+    const command = createNodeCommand(
+      child,
+      casing,
+      globalLongOptionFlags,
+      execute,
+      presetsEnabled
+    );
     if (command === null) {
       continue;
     }
@@ -9423,7 +11219,7 @@ var DCS = 144;
 var SOS = 152;
 var PM = 158;
 var APC = 159;
-function stripAnsi2(input) {
+function stripAnsi4(input) {
   let output = "";
   for (let index = 0; index < input.length; index += 1) {
     const code = input.charCodeAt(index);
@@ -10112,7 +11908,7 @@ var TerminalScreen = class {
     cursor,
     size
   }) {
-    this.lines = Object.freeze(lines.map((line) => stripAnsi2(line)));
+    this.lines = Object.freeze(lines.map((line) => stripAnsi4(line)));
     this.rawLines = Object.freeze([...rawLines]);
     this.cursor = Object.freeze({ ...cursor });
     this.size = Object.freeze({ ...size });
@@ -10197,14 +11993,14 @@ var TerminalSession = class {
       });
     });
   }
-  async type(text4) {
-    for (const character of text4) {
+  async type(text5) {
+    for (const character of text5) {
       await this.send(character);
       await sleep2(TYPE_DELAY_MS);
     }
   }
-  async fill(text4) {
-    await this.send(text4.replace(/\r?\n/g, "\r"));
+  async fill(text5) {
+    await this.send(text5.replace(/\r?\n/g, "\r"));
   }
   async press(key2) {
     await this.send(keyToSequence(key2));
@@ -10262,7 +12058,7 @@ var TerminalSession = class {
     });
   }
   async history(opts) {
-    const normalized = normalizeHistoryBuffer(stripAnsi2(this.rawBuffer));
+    const normalized = normalizeHistoryBuffer(stripAnsi4(this.rawBuffer));
     const lines = splitHistoryLines(normalized);
     if (opts?.last === void 0) {
       return lines;
@@ -10368,7 +12164,7 @@ function isMissingFileError(error2) {
   return "code" in error2 && error2.code === "ENOENT";
 }
 function matchPattern(buffer, pattern) {
-  const clean = normalizeHistoryBuffer(stripAnsi2(buffer));
+  const clean = normalizeHistoryBuffer(stripAnsi4(buffer));
   for (const line of clean.split("\n")) {
     if (typeof pattern === "string") {
       if (line.includes(pattern)) return line;
@@ -10628,7 +12424,7 @@ var params2 = S.Object({
   rows: S.Optional(S.Number({ description: "Terminal height in rows" })),
   observe: S.Optional(S.Boolean({ description: "Mirror PTY output to stderr" }))
 });
-var createSession = defineCommand({
+var createSession2 = defineCommand({
   name: "create-session",
   description: "Spawn an interactive CLI in a PTY",
   scope: ["cli", "mcp", "sdk"],
@@ -10680,7 +12476,7 @@ var getSession = defineCommand({
 
 // ../agent-skill-config/src/configs.ts
 import os2 from "node:os";
-import path7 from "node:path";
+import path10 from "node:path";
 
 // ../agent-defs/src/agents/claude-code.ts
 var claudeCodeAgent = {
@@ -11201,20 +12997,20 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat(path12) {
-  const ext = getExtension(path12);
+function detectFormat(path15) {
+  const ext = getExtension(path15);
   return extensionMap[ext];
 }
-function getExtension(path12) {
-  const lastDot = path12.lastIndexOf(".");
+function getExtension(path15) {
+  const lastDot = path15.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path12.slice(lastDot).toLowerCase();
+  return path15.slice(lastDot).toLowerCase();
 }
 
 // ../config-mutations/src/execution/path-utils.ts
-import path8 from "node:path";
+import path11 from "node:path";
 function expandHome(targetPath, homeDir) {
   if (!targetPath?.startsWith("~")) {
     return targetPath;
@@ -11231,7 +13027,7 @@ function expandHome(targetPath, homeDir) {
       remainder = remainder.slice(1);
     }
   }
-  return remainder.length === 0 ? homeDir : path8.join(homeDir, remainder);
+  return remainder.length === 0 ? homeDir : path11.join(homeDir, remainder);
 }
 function validateHomePath(targetPath) {
   if (typeof targetPath !== "string" || targetPath.length === 0) {
@@ -11249,12 +13045,12 @@ function resolvePath(rawPath, homeDir, pathMapper) {
   if (!pathMapper) {
     return expanded;
   }
-  const rawDirectory = path8.dirname(expanded);
+  const rawDirectory = path11.dirname(expanded);
   const mappedDirectory = pathMapper.mapTargetDirectory({
     targetDirectory: rawDirectory
   });
-  const filename = path8.basename(expanded);
-  return filename.length === 0 ? mappedDirectory : path8.join(mappedDirectory, filename);
+  const filename = path11.basename(expanded);
+  return filename.length === 0 ? mappedDirectory : path11.join(mappedDirectory, filename);
 }
 
 // ../config-mutations/src/fs-utils.ts
@@ -11861,9 +13657,9 @@ import Mustache2 from "mustache";
 var originalEscape = Mustache2.escape;
 
 // ../agent-skill-config/src/templates.ts
-import { readFile as readFile4, stat as stat2 } from "node:fs/promises";
-import path9 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { readFile as readFile6, stat as stat2 } from "node:fs/promises";
+import path12 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // ../agent-skill-config/src/apply.ts
 var UnsupportedAgentError = class extends Error {
@@ -11921,9 +13717,9 @@ async function installSkill(agentId, skill, options) {
 
 // src/commands/installer.ts
 import os3 from "node:os";
-import path10 from "node:path";
+import path13 from "node:path";
 import * as nodeFs from "node:fs/promises";
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 var DEFAULT_INSTALL_AGENT = "claude-code";
 var DEFAULT_INSTALL_SCOPE = "local";
 var TERMINAL_PILOT_SKILL_NAME = "terminal-pilot";
@@ -11973,7 +13769,7 @@ async function loadTerminalPilotTemplate() {
   ];
   for (const candidate of candidates) {
     try {
-      terminalPilotTemplateCache = await readFile5(candidate, "utf8");
+      terminalPilotTemplateCache = await readFile7(candidate, "utf8");
       return terminalPilotTemplateCache;
     } catch (error2) {
       if (!isNotFoundError2(error2)) {
@@ -11988,7 +13784,7 @@ function resolveHomeRelativePath(targetPath, homeDir) {
     return homeDir;
   }
   if (targetPath.startsWith("~/")) {
-    return path10.join(homeDir, targetPath.slice(2));
+    return path13.join(homeDir, targetPath.slice(2));
   }
   return targetPath;
 }
@@ -11998,12 +13794,12 @@ function getSkillFolderWithHome(agent, scope, cwd, homeDir) {
     throwUnsupportedAgent(agent);
   }
   return {
-    displayPath: path10.join(
+    displayPath: path13.join(
       scope === "global" ? config.globalSkillDir : config.localSkillDir,
       TERMINAL_PILOT_SKILL_NAME
     ),
-    fullPath: path10.join(
-      scope === "global" ? resolveHomeRelativePath(config.globalSkillDir, homeDir) : path10.resolve(cwd, config.localSkillDir),
+    fullPath: path13.join(
+      scope === "global" ? resolveHomeRelativePath(config.globalSkillDir, homeDir) : path13.resolve(cwd, config.localSkillDir),
       TERMINAL_PILOT_SKILL_NAME
     )
   };
@@ -12195,17 +13991,17 @@ function colorsEqual(left, right) {
   }
   return false;
 }
-function pushRun(runs, style, text4) {
-  if (text4.length === 0) {
+function pushRun(runs, style, text5) {
+  if (text5.length === 0) {
     return;
   }
   const previous = runs.at(-1);
-  if (previous && text4 !== "\n" && previous.text !== "\n" && stylesEqual(previous, style)) {
-    previous.text += text4;
+  if (previous && text5 !== "\n" && previous.text !== "\n" && stylesEqual(previous, style)) {
+    previous.text += text5;
     return;
   }
   runs.push({
-    text: text4,
+    text: text5,
     fg: style.fg,
     bg: style.bg,
     bold: style.bold,
@@ -12407,18 +14203,18 @@ function parseAnsi2(input) {
 import { Resvg } from "@resvg/resvg-js";
 
 // ../terminal-png/src/font.ts
-import { readFileSync } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { dirname as dirname2, join as join2 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 var require2 = createRequire2(import.meta.url);
 var fontPackageRoot = dirname2(require2.resolve("jetbrains-mono/package.json"));
 var webfontRoot = join2(fontPackageRoot, "fonts/webfonts");
 function readWebfontBase64(filename) {
-  return readFileSync(join2(webfontRoot, filename)).toString("base64");
+  return readFileSync2(join2(webfontRoot, filename)).toString("base64");
 }
 function resolveAssetPath(filename) {
-  return fileURLToPath3(new URL(`../assets/${filename}`, import.meta.url));
+  return fileURLToPath4(new URL(`../assets/${filename}`, import.meta.url));
 }
 function createFontFace(base64, weight, style) {
   return `@font-face {
@@ -12804,10 +14600,10 @@ function measureLines(lines) {
     0
   );
 }
-function displayWidth(text4) {
+function displayWidth(text5) {
   const segmenter = new Intl.Segmenter();
   let width = 0;
-  for (const { segment } of segmenter.segment(text4)) {
+  for (const { segment } of segmenter.segment(text5)) {
     const cp = segment.codePointAt(0);
     width += cp !== void 0 && isWideCodePoint(cp) ? 2 : 1;
   }
@@ -13071,7 +14867,7 @@ var waitForExit2 = defineCommand({
 var children = [
   install,
   uninstall,
-  createSession,
+  createSession2,
   fill,
   type,
   pressKey,
@@ -13114,9 +14910,9 @@ async function isDirectExecution(argv) {
     return false;
   }
   try {
-    const modulePath = fileURLToPath4(import.meta.url);
+    const modulePath = fileURLToPath5(import.meta.url);
     const [resolvedEntryPoint, resolvedModulePath] = await Promise.all([
-      realpath(path11.resolve(entryPoint)),
+      realpath(path14.resolve(entryPoint)),
       realpath(modulePath)
     ]);
     return resolvedEntryPoint === resolvedModulePath;