terminal-pilot 0.0.19 → 0.0.21

package/dist/cli.js

@@ -6,13 +6,13 @@ var __export = (target, all) => {
 };
 
 // src/cli.ts
-import { realpath as realpath2 } from "node:fs/promises";
-import path22 from "node:path";
+import { realpath as realpath3 } from "node:fs/promises";
+import path23 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // ../toolcraft/src/cli.ts
 import { access as access2, lstat as lstat3, readFile as readFile4, rename as rename3, unlink as unlink2, writeFile as writeFile5 } from "node:fs/promises";
-import path13 from "node:path";
+import path14 from "node:path";
 import {
   Command as CommanderCommand,
   CommanderError as CommanderError2,
@@ -20,7 +20,7 @@ import {
   Option
 } from "commander";
 
-// ../design-system/src/internal/color-support.ts
+// ../toolcraft-design/src/internal/color-support.ts
 function supportsColor(env = process.env, stream = process.stdout) {
   if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "0") {
     return true;
@@ -34,7 +34,7 @@ function supportsColor(env = process.env, stream = process.stdout) {
   return typeof env.TERM === "string" && env.TERM.length > 0 && env.TERM !== "dumb";
 }
 
-// ../design-system/src/components/color.ts
+// ../toolcraft-design/src/components/color.ts
 var reset = "\x1B[0m";
 var ansiStyles = {
   reset: { open: reset },
@@ -136,41 +136,135 @@ function createColor(styles = []) {
 }
 var color = createColor();
 
-// ../design-system/src/tokens/colors.ts
-var dark = {
-  header: (text5) => color.magentaBright.bold(text5),
-  divider: (text5) => color.dim(text5),
-  prompt: (text5) => color.cyan(text5),
-  number: (text5) => color.cyanBright(text5),
-  intro: (text5) => color.bgMagenta.white(` Poe - ${text5} `),
-  resolvedSymbol: color.magenta("\u25C7"),
-  errorSymbol: color.red("\u25A0"),
-  accent: (text5) => color.cyan(text5),
-  muted: (text5) => color.dim(text5),
-  success: (text5) => color.green(text5),
-  warning: (text5) => color.yellow(text5),
-  error: (text5) => color.red(text5),
-  info: (text5) => color.magenta(text5),
-  badge: (text5) => color.bgYellow.black(` ${text5} `)
+// ../toolcraft-design/src/tokens/brand.ts
+var brands = {
+  purple: { name: "purple", primary: "#a200ff" },
+  blue: { name: "blue", primary: "#2f6fed" },
+  green: { name: "green", primary: "#1f9d57" }
 };
-var light = {
-  header: (text5) => color.hex("#a200ff").bold(text5),
-  divider: (text5) => color.hex("#666666")(text5),
-  prompt: (text5) => color.hex("#006699").bold(text5),
-  number: (text5) => color.hex("#0077cc").bold(text5),
-  intro: (text5) => color.bgHex("#a200ff").white(` Poe - ${text5} `),
-  resolvedSymbol: color.hex("#a200ff")("\u25C7"),
-  errorSymbol: color.hex("#cc0000")("\u25A0"),
-  accent: (text5) => color.hex("#006699").bold(text5),
-  muted: (text5) => color.hex("#666666")(text5),
-  success: (text5) => color.hex("#008800")(text5),
-  warning: (text5) => color.hex("#cc6600")(text5),
-  error: (text5) => color.hex("#cc0000")(text5),
-  info: (text5) => color.hex("#a200ff")(text5),
-  badge: (text5) => color.bgHex("#cc6600").white(` ${text5} `)
+
+// ../toolcraft-design/src/internal/theme-state.ts
+var defaults = {
+  brand: "purple",
+  label: "Poe"
 };
+var config = { ...defaults };
+var revision = 0;
+var brandConfigured = false;
+function configureTheme(patch) {
+  if (patch.brand !== void 0 && !Object.hasOwn(brands, patch.brand)) {
+    throw new Error(`Unknown brand: ${patch.brand}`);
+  }
+  config = {
+    brand: patch.brand ?? config.brand,
+    label: patch.label ?? config.label
+  };
+  if (patch.brand !== void 0) {
+    brandConfigured = true;
+  }
+  revision += 1;
+}
+function getThemeConfig() {
+  return { ...config };
+}
+function getThemeRevision() {
+  return revision;
+}
+function isThemeBrandConfigured() {
+  return brandConfigured;
+}
+
+// ../toolcraft-design/src/tokens/colors.ts
+var brand = brands.purple.primary;
+function withStyles(palette, styles) {
+  return Object.defineProperty(palette, "styles", {
+    value: styles,
+    enumerable: false
+  });
+}
+function brandColor(activeBrand, purple) {
+  return activeBrand.name === "purple" ? purple : color.hex(activeBrand.primary);
+}
+function brandBackground(activeBrand, purple) {
+  return activeBrand.name === "purple" ? purple : color.bgHex(activeBrand.primary);
+}
+function createPalette(activeBrand, mode) {
+  const isPurple = activeBrand.name === "purple";
+  if (mode === "light") {
+    const active2 = color.hex(activeBrand.primary);
+    const prompt2 = isPurple ? color.hex("#006699") : active2;
+    const number2 = isPurple ? color.hex("#0077cc") : active2;
+    return withStyles(
+      {
+        header: (text5) => active2.bold(text5),
+        divider: (text5) => color.hex("#666666")(text5),
+        prompt: (text5) => prompt2.bold(text5),
+        number: (text5) => number2.bold(text5),
+        intro: (text5) => color.bgHex(activeBrand.primary).white(` ${getThemeConfig().label} - ${text5} `),
+        get resolvedSymbol() {
+          return active2("\u25C7");
+        },
+        get errorSymbol() {
+          return color.hex("#cc0000")("\u25A0");
+        },
+        accent: (text5) => prompt2.bold(text5),
+        muted: (text5) => color.hex("#666666")(text5),
+        success: (text5) => color.hex("#008800")(text5),
+        warning: (text5) => color.hex("#cc6600")(text5),
+        error: (text5) => color.hex("#cc0000")(text5),
+        info: (text5) => active2(text5),
+        badge: (text5) => color.bgHex("#cc6600").white(` ${text5} `)
+      },
+      {
+        accent: { fg: isPurple ? "#006699" : activeBrand.primary, bold: true },
+        muted: { fg: "#666666" },
+        success: { fg: "#008800" },
+        warning: { fg: "#cc6600" },
+        error: { fg: "#cc0000" },
+        info: { fg: activeBrand.primary }
+      }
+    );
+  }
+  const active = brandColor(activeBrand, color.magenta);
+  const activeBright = brandColor(activeBrand, color.magentaBright);
+  const activeBackground = brandBackground(activeBrand, color.bgMagenta);
+  const prompt = isPurple ? color.cyan : active;
+  const number = isPurple ? color.cyanBright : active;
+  return withStyles(
+    {
+      header: (text5) => activeBright.bold(text5),
+      divider: (text5) => color.dim(text5),
+      prompt: (text5) => prompt(text5),
+      number: (text5) => number(text5),
+      intro: (text5) => activeBackground.white(` ${getThemeConfig().label} - ${text5} `),
+      get resolvedSymbol() {
+        return active("\u25C7");
+      },
+      get errorSymbol() {
+        return color.red("\u25A0");
+      },
+      accent: (text5) => prompt(text5),
+      muted: (text5) => color.dim(text5),
+      success: (text5) => color.green(text5),
+      warning: (text5) => color.yellow(text5),
+      error: (text5) => color.red(text5),
+      info: (text5) => active(text5),
+      badge: (text5) => color.bgYellow.black(` ${text5} `)
+    },
+    {
+      accent: { fg: isPurple ? "cyan" : activeBrand.primary, bold: true },
+      muted: { dim: true },
+      success: { fg: "green" },
+      warning: { fg: "yellow" },
+      error: { fg: "red" },
+      info: { fg: isPurple ? "magenta" : activeBrand.primary }
+    }
+  );
+}
+var dark = createPalette(brands.purple, "dark");
+var light = createPalette(brands.purple, "light");
 
-// ../design-system/src/tokens/typography.ts
+// ../toolcraft-design/src/tokens/typography.ts
 var typography = {
   bold: (text5) => color.bold(text5),
   dim: (text5) => color.dim(text5),
@@ -179,14 +273,14 @@ var typography = {
   strikethrough: (text5) => color.strikethrough(text5)
 };
 
-// ../design-system/src/tokens/widths.ts
+// ../toolcraft-design/src/tokens/widths.ts
 var widths = {
   header: 60,
   helpColumn: 24,
   maxLine: 80
 };
 
-// ../design-system/src/internal/output-format.ts
+// ../toolcraft-design/src/internal/output-format.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 var VALID_FORMATS = /* @__PURE__ */ new Set(["terminal", "markdown", "json"]);
 var formatStorage = new AsyncLocalStorage();
@@ -207,7 +301,7 @@ function resetOutputFormatCache() {
   cached = void 0;
 }
 
-// ../design-system/src/internal/theme-detect.ts
+// ../toolcraft-design/src/internal/theme-detect.ts
 function detectThemeFromEnv(env) {
   const apple = env.APPLE_INTERFACE_STYLE;
   if (typeof apple === "string") {
@@ -244,17 +338,30 @@ function resolveThemeName(env = process.env) {
   }
   return "dark";
 }
-var cachedTheme;
+var themeCache = /* @__PURE__ */ new Map();
+var cachedRevision = -1;
 function getTheme(env) {
+  const themeName = resolveThemeName(env);
+  const config2 = getThemeConfig();
+  const requestedBrand = env?.POE_BRAND?.toLowerCase();
+  const activeBrandName = !isThemeBrandConfigured() && requestedBrand && Object.hasOwn(brands, requestedBrand) ? requestedBrand : config2.brand;
+  const revision2 = getThemeRevision();
+  if (revision2 !== cachedRevision) {
+    themeCache.clear();
+    cachedRevision = revision2;
+  }
+  const cacheKey = `${activeBrandName}:${themeName}`;
+  const cachedTheme = themeCache.get(cacheKey);
   if (cachedTheme) {
     return cachedTheme;
   }
-  const themeName = resolveThemeName(env);
-  cachedTheme = themeName === "light" ? light : dark;
-  return cachedTheme;
+  const activeBrand = brands[activeBrandName];
+  const theme = activeBrandName === "purple" ? themeName === "light" ? light : dark : createPalette(activeBrand, themeName);
+  themeCache.set(cacheKey, theme);
+  return theme;
 }
 
-// ../design-system/src/components/text.ts
+// ../toolcraft-design/src/components/text.ts
 function renderMarkdownInline(content) {
   return content.replaceAll("\r\n", " ").replaceAll("\n", " ").replaceAll("\r", " ");
 }
@@ -370,7 +477,7 @@ var text = {
   }
 };
 
-// ../design-system/src/components/symbols.ts
+// ../toolcraft-design/src/components/symbols.ts
 var symbols = {
   get info() {
     const format = resolveOutputFormat();
@@ -424,12 +531,12 @@ var symbols = {
   }
 };
 
-// ../design-system/src/internal/strip-ansi.ts
+// ../toolcraft-design/src/internal/strip-ansi.ts
 function stripAnsi(value) {
   return value.replace(/\u001b\[[0-9;]*m/g, "");
 }
 
-// ../design-system/src/prompts/primitives/log.ts
+// ../toolcraft-design/src/prompts/primitives/log.ts
 function renderMarkdownInline2(value) {
   return stripAnsi(value).replaceAll("\r\n", " ").replaceAll("\n", " ").replaceAll("\r", " ");
 }
@@ -556,7 +663,7 @@ var log = {
   error
 };
 
-// ../design-system/src/components/logger.ts
+// ../toolcraft-design/src/components/logger.ts
 function createLogger(emitter) {
   const emit = (level, message2) => {
     if (emitter) {
@@ -617,7 +724,7 @@ function createLogger(emitter) {
 }
 var logger = createLogger();
 
-// ../design-system/src/components/help-formatter.ts
+// ../toolcraft-design/src/components/help-formatter.ts
 var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 function normalizeInline(value) {
   return value.replaceAll("\r\n", " ").replaceAll("\n", " ").replaceAll("\r", " ");
@@ -793,7 +900,7 @@ function formatOptionList(options) {
   });
 }
 
-// ../design-system/src/components/help-formatter-plain.ts
+// ../toolcraft-design/src/components/help-formatter-plain.ts
 var help_formatter_plain_exports = {};
 __export(help_formatter_plain_exports, {
   formatColumns: () => formatColumns2,
@@ -930,7 +1037,7 @@ function formatOptionList2(options) {
   });
 }
 
-// ../design-system/src/components/table.ts
+// ../toolcraft-design/src/components/table.ts
 var reset2 = "\x1B[0m";
 var ellipsis = "\u2026";
 var graphemeSegmenter2 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
@@ -1214,7 +1321,7 @@ function renderTable(options) {
   }
 }
 
-// ../design-system/src/components/detail-card.ts
+// ../toolcraft-design/src/components/detail-card.ts
 function wrap(value, width) {
   const lines = [];
   for (const paragraph of value.split("\n")) {
@@ -1277,7 +1384,8 @@ ${options.theme.muted(options.badges.map((badge) => badge[0] + badge.slice(1).to
   return blocks.join("\n\n");
 }
 
-// ../design-system/src/components/template.ts
+// ../toolcraft-design/src/components/template.ts
+var MAX_PARTIAL_DEPTH = 100;
 var HTML_ESCAPE = {
   "&": "&",
   "<": "&lt;",
@@ -1289,14 +1397,27 @@ var HTML_ESCAPE = {
   "=": "&#x3D;"
 };
 function renderTemplate(template, view, options = {}) {
-  const prepared = options.yield === void 0 ? template : template.split("{{yield}}").join(options.yield);
+  const prepared = options.yield === void 0 ? template : resolveTemplatePartials(template, options.partials ?? {}).split("{{yield}}").join(options.yield);
   const tokens = parseTemplate(prepared);
-  const escape = options.escape === "none" ? String : escapeHtml;
-  const preserveMissing = options.yield !== void 0 && options.escape === "none";
-  return renderTokens(tokens, { view }, prepared, escape, preserveMissing);
+  validatePartialReferences(tokens, options.partials ?? {}, []);
+  if (options.validate === true) {
+    const expanded = resolveTemplatePartials(prepared, options.partials ?? {});
+    validateVariables(parseTemplate(expanded), { view });
+  }
+  const state = {
+    escape: options.escape === "none" ? String : escapeHtml,
+    partials: options.partials ?? {},
+    partialStack: [],
+    preserveMissing: options.yield !== void 0 && options.escape === "none",
+    validate: options.validate === true
+  };
+  return renderTokens(tokens, { view }, prepared, state);
+}
+function resolveTemplatePartials(template, partials) {
+  return expandTemplatePartials(template, partials, []);
 }
-function renderTemplateInContext(template, context, escape, preserveMissing) {
-  return renderTokens(parseTemplate(template), context, template, escape, preserveMissing);
+function renderTemplateInContext(template, context, state) {
+  return renderTokens(parseTemplate(template), context, template, state);
 }
 function parseTemplate(template) {
   const root = [];
@@ -1319,9 +1440,6 @@ function parseTemplate(template) {
       index = standalone?.nextIndex ?? parsed.end;
       continue;
     }
-    if (parsed.kind === "partial") {
-      throw new Error(`Partials are not supported: "${parsed.name}"`);
-    }
     if (parsed.kind === "delimiter") {
       throw new Error("Custom delimiters are not supported");
     }
@@ -1339,6 +1457,15 @@ function parseTemplate(template) {
       index = standalone?.nextIndex ?? parsed.end;
       continue;
     }
+    if (parsed.kind === "partial") {
+      tokens.push({
+        type: "partial",
+        name: parsed.name,
+        indent: standalone === void 0 ? "" : template.slice(standalone.lineStart, open)
+      });
+      index = standalone?.nextIndex ?? parsed.end;
+      continue;
+    }
     if (parsed.kind === "close") {
       const frame2 = stack.pop();
       if (frame2 === void 0) {
@@ -1409,7 +1536,7 @@ function getStandalone(template, tagStart, tagEnd, kind) {
   }
   return void 0;
 }
-function renderTokens(tokens, context, template, escape, preserveMissing) {
+function renderTokens(tokens, context, template, state) {
   let output = "";
   for (const token of tokens) {
     switch (token.type) {
@@ -1418,32 +1545,62 @@ function renderTokens(tokens, context, template, escape, preserveMissing) {
         continue;
       case "name":
       case "unescaped": {
-        const value = lookup(context, token.name);
-        if (value == null) {
-          if (preserveMissing) {
+        const result = lookup(context, token.name);
+        if (!result.hit || result.value == null) {
+          if (state.validate) {
+            throw new Error(`Template variable "${token.name}" not found.`);
+          }
+          if (state.preserveMissing) {
             output += token.raw;
           }
           continue;
         }
-        const rendered = String(value);
-        output += token.type === "name" ? escape(rendered) : rendered;
+        const rendered = String(result.value);
+        output += token.type === "name" ? state.escape(rendered) : rendered;
+        continue;
+      }
+      case "partial": {
+        if (!Object.hasOwn(state.partials, token.name)) {
+          throw new Error(`Partial "${token.name}" not found.`);
+        }
+        if (state.partialStack.includes(token.name)) {
+          throw new Error(
+            `Circular partial reference detected: ${[...state.partialStack, token.name].join(" -> ")}.`
+          );
+        }
+        if (state.partialStack.length >= MAX_PARTIAL_DEPTH) {
+          throw new Error(`Maximum partial depth exceeded (${MAX_PARTIAL_DEPTH}).`);
+        }
+        const partial = indentPartial(state.partials[token.name], token.indent);
+        output += renderTokens(parseTemplate(partial), context, partial, {
+          ...state,
+          partialStack: [...state.partialStack, token.name]
+        });
         continue;
       }
       case "inverted": {
-        const value = lookup(context, token.name);
+        const result = lookup(context, token.name);
+        if (!result.hit && state.validate) {
+          throw new Error(`Template variable "${token.name}" not found.`);
+        }
+        const value = result.value;
         if (!value || Array.isArray(value) && value.length === 0) {
-          output += renderTokens(token.children, context, template, escape, preserveMissing);
+          output += renderTokens(token.children, context, template, state);
         }
         continue;
       }
       case "section": {
-        const value = lookup(context, token.name);
+        const result = lookup(context, token.name);
+        if (!result.hit && state.validate) {
+          throw new Error(`Template variable "${token.name}" not found.`);
+        }
+        const value = result.value;
         if (!value) {
           continue;
         }
         if (Array.isArray(value)) {
           for (const item of value) {
-            output += renderTokens(token.children, pushContext(context, item), template, escape, preserveMissing);
+            output += renderTokens(token.children, pushContext(context, item), template, state);
           }
           continue;
         }
@@ -1452,7 +1609,7 @@ function renderTokens(tokens, context, template, escape, preserveMissing) {
           const rendered = value.call(
             context.view,
             raw,
-            (nextTemplate) => renderTemplateInContext(nextTemplate, context, escape, preserveMissing)
+            (nextTemplate) => renderTemplateInContext(nextTemplate, context, state)
           );
           if (rendered != null) {
             output += String(rendered);
@@ -1460,10 +1617,10 @@ function renderTokens(tokens, context, template, escape, preserveMissing) {
           continue;
         }
         if (typeof value === "object" || typeof value === "string" || typeof value === "number") {
-          output += renderTokens(token.children, pushContext(context, value), template, escape, preserveMissing);
+          output += renderTokens(token.children, pushContext(context, value), template, state);
           continue;
         }
-        output += renderTokens(token.children, context, template, escape, preserveMissing);
+        output += renderTokens(token.children, context, template, state);
       }
     }
   }
@@ -1471,17 +1628,115 @@ function renderTokens(tokens, context, template, escape, preserveMissing) {
 }
 function lookup(context, name) {
   if (name === ".") {
-    return callLambda(context.view, context.view);
+    return { hit: true, value: callLambda(context.view, context.view) };
   }
   let cursor = context;
   while (cursor !== void 0) {
     const result = name.includes(".") ? lookupDotted(cursor.view, name) : lookupName(cursor.view, name);
     if (result.hit) {
-      return callLambda(result.value, cursor.view);
+      return { hit: true, value: callLambda(result.value, cursor.view) };
     }
     cursor = cursor.parent;
   }
-  return void 0;
+  return { hit: false, value: void 0 };
+}
+function validateVariables(tokens, context) {
+  for (const token of tokens) {
+    if (token.type === "text" || token.type === "partial") {
+      continue;
+    }
+    if (token.type === "name" || token.type === "unescaped") {
+      if (!lookup(context, token.name).hit) {
+        throw new Error(`Template variable "${token.name}" not found.`);
+      }
+      continue;
+    }
+    if (token.type !== "section" && token.type !== "inverted") {
+      continue;
+    }
+    const result = lookup(context, token.name);
+    if (!result.hit) {
+      throw new Error(`Template variable "${token.name}" not found.`);
+    }
+    if (Array.isArray(result.value) && result.value.length > 0) {
+      for (const item of result.value) {
+        validateVariables(token.children, pushContext(context, item));
+      }
+      continue;
+    }
+    if (typeof result.value === "object" && result.value !== null || typeof result.value === "string" || typeof result.value === "number") {
+      validateVariables(token.children, pushContext(context, result.value));
+      continue;
+    }
+    validateVariables(token.children, context);
+  }
+}
+function validatePartialReferences(tokens, partials, partialStack) {
+  for (const token of tokens) {
+    if (token.type === "section" || token.type === "inverted") {
+      validatePartialReferences(token.children, partials, partialStack);
+      continue;
+    }
+    if (token.type !== "partial") {
+      continue;
+    }
+    if (!Object.hasOwn(partials, token.name)) {
+      throw new Error(`Partial "${token.name}" not found.`);
+    }
+    if (partialStack.includes(token.name)) {
+      throw new Error(
+        `Circular partial reference detected: ${[...partialStack, token.name].join(" -> ")}.`
+      );
+    }
+    if (partialStack.length >= MAX_PARTIAL_DEPTH) {
+      throw new Error(`Maximum partial depth exceeded (${MAX_PARTIAL_DEPTH}).`);
+    }
+    validatePartialReferences(parseTemplate(partials[token.name]), partials, [
+      ...partialStack,
+      token.name
+    ]);
+  }
+}
+function indentPartial(partial, indent) {
+  if (indent === "") {
+    return partial;
+  }
+  return partial.split("\n").map((line) => line === "" ? "" : `${indent}${line}`).join("\n");
+}
+function expandTemplatePartials(template, partials, partialStack) {
+  let output = "";
+  let index = 0;
+  while (index < template.length) {
+    const open = template.indexOf("{{", index);
+    if (open === -1) {
+      output += template.slice(index);
+      break;
+    }
+    const parsed = parseTag(template, open);
+    if (parsed.kind !== "partial") {
+      output += template.slice(index, parsed.end);
+      index = parsed.end;
+      continue;
+    }
+    if (!Object.hasOwn(partials, parsed.name)) {
+      throw new Error(`Partial "${parsed.name}" not found.`);
+    }
+    if (partialStack.includes(parsed.name)) {
+      throw new Error(
+        `Circular partial reference detected: ${[...partialStack, parsed.name].join(" -> ")}.`
+      );
+    }
+    if (partialStack.length >= MAX_PARTIAL_DEPTH) {
+      throw new Error(`Maximum partial depth exceeded (${MAX_PARTIAL_DEPTH}).`);
+    }
+    const standalone = getStandalone(template, open, parsed.end, parsed.kind);
+    const beforePartial = standalone === void 0 ? template.slice(index, open) : template.slice(index, standalone.lineStart);
+    const indent = standalone === void 0 ? "" : template.slice(standalone.lineStart, open);
+    const partial = indentPartial(partials[parsed.name], indent);
+    output += beforePartial + expandTemplatePartials(partial, partials, [...partialStack, parsed.name]);
+    index = standalone?.nextIndex ?? parsed.end;
+  }
+  return output;
 }
 function lookupName(view, name) {
   if (!isPropertyContainer(view) || !hasProperty(view, name)) {
@@ -1541,22 +1796,22 @@ function hasProperty(value, key2) {
   return Object.prototype.hasOwnProperty.call(value, key2);
 }
 
-// ../design-system/src/components/browser.ts
+// ../toolcraft-design/src/components/browser.ts
 import { spawn } from "node:child_process";
 import process2 from "node:process";
 
-// ../design-system/src/acp/writer.ts
+// ../toolcraft-design/src/acp/writer.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var storage = new AsyncLocalStorage2();
 
-// ../design-system/src/dashboard/terminal-width.ts
+// ../toolcraft-design/src/dashboard/terminal-width.ts
 var graphemeSegmenter3 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 
-// ../design-system/src/dashboard/terminal.ts
+// ../toolcraft-design/src/dashboard/terminal.ts
 import readline from "node:readline";
 import { PassThrough } from "node:stream";
 
-// ../design-system/src/explorer/state.ts
+// ../toolcraft-design/src/explorer/state.ts
 var REGION_HEADER = 1 << 0;
 var REGION_LIST = 1 << 1;
 var REGION_DETAIL = 1 << 2;
@@ -1565,10 +1820,10 @@ var REGION_MODAL = 1 << 4;
 var REGION_TOAST = 1 << 5;
 var REGION_ALL = REGION_HEADER | REGION_LIST | REGION_DETAIL | REGION_FOOTER | REGION_MODAL | REGION_TOAST;
 
-// ../design-system/src/prompts/index.ts
+// ../toolcraft-design/src/prompts/index.ts
 import * as clack from "@clack/prompts";
 
-// ../design-system/src/prompts/primitives/cancel.ts
+// ../toolcraft-design/src/prompts/primitives/cancel.ts
 import { isCancel } from "@clack/prompts";
 function cancel(msg = "") {
   if (resolveOutputFormat() !== "terminal") {
@@ -1579,7 +1834,7 @@ function cancel(msg = "") {
 `);
 }
 
-// ../design-system/src/prompts/primitives/note.ts
+// ../toolcraft-design/src/prompts/primitives/note.ts
 function getVisibleWidth(value) {
   return stripAnsi(value).length;
 }
@@ -1628,10 +1883,10 @@ function note(message2, title) {
 `);
 }
 
-// ../design-system/src/static/spinner.ts
+// ../toolcraft-design/src/static/spinner.ts
 var SPINNER_FRAMES = Object.freeze(["\u25D2", "\u25D0", "\u25D3", "\u25D1"]);
 
-// ../design-system/src/prompts/index.ts
+// ../toolcraft-design/src/prompts/index.ts
 async function select2(opts) {
   return clack.select(opts);
 }
@@ -1674,19 +1929,19 @@ var ApprovalDeclinedError = class extends UserError {
 };
 
 // ../toolcraft/src/human-in-loop/config.ts
-function validateHumanInLoopOnDefine(config) {
-  const label = Array.isArray(config.children) ? "group" : "command";
-  if (config.confirm === true && config.humanInLoop !== void 0 && config.humanInLoop !== null) {
-    throw new Error(`${label} '${config.name}': use either confirm or humanInLoop, not both`);
+function validateHumanInLoopOnDefine(config2) {
+  const label = Array.isArray(config2.children) ? "group" : "command";
+  if (config2.confirm === true && config2.humanInLoop !== void 0 && config2.humanInLoop !== null) {
+    throw new Error(`${label} '${config2.name}': use either confirm or humanInLoop, not both`);
   }
-  if (config.humanInLoop === void 0 || config.humanInLoop === null) {
+  if (config2.humanInLoop === void 0 || config2.humanInLoop === null) {
     return;
   }
-  if (config.humanInLoop.mode !== "sync" && config.humanInLoop.mode !== "async") {
-    throw new Error(`${label} '${config.name}': humanInLoop.mode must be "sync" or "async"`);
+  if (config2.humanInLoop.mode !== "sync" && config2.humanInLoop.mode !== "async") {
+    throw new Error(`${label} '${config2.name}': humanInLoop.mode must be "sync" or "async"`);
   }
-  if (typeof config.humanInLoop.message !== "function") {
-    throw new Error(`${label} '${config.name}': humanInLoop.message must be a function`);
+  if (typeof config2.humanInLoop.message !== "function") {
+    throw new Error(`${label} '${config2.name}': humanInLoop.message must be a function`);
   }
 }
 function mergeHumanInLoopFromGroup(groupHumanInLoop, childHumanInLoop) {
@@ -1762,12 +2017,12 @@ function assertValidBranches(branches, discriminator) {
     }
   }
 }
-function OneOf(config) {
-  assertValidBranches(config.branches, config.discriminator);
+function OneOf(config2) {
+  assertValidBranches(config2.branches, config2.discriminator);
   return {
     kind: "oneOf",
-    discriminator: config.discriminator,
-    branches: config.branches
+    discriminator: config2.discriminator,
+    branches: config2.branches
   };
 }
 
@@ -2017,22 +2272,22 @@ function cloneStringArray(values) {
 function cloneStringRecord(values) {
   return values === void 0 ? void 0 : { ...values };
 }
-function cloneMcpServerConfig(config) {
-  if (config === void 0) {
+function cloneMcpServerConfig(config2) {
+  if (config2 === void 0) {
     return void 0;
   }
-  if (config.transport === "stdio") {
+  if (config2.transport === "stdio") {
     return {
       transport: "stdio",
-      command: config.command,
-      args: cloneStringArray(config.args),
-      env: cloneStringRecord(config.env)
+      command: config2.command,
+      args: cloneStringArray(config2.args),
+      env: cloneStringRecord(config2.env)
     };
   }
   return {
     transport: "http",
-    url: config.url,
-    headers: cloneStringRecord(config.headers)
+    url: config2.url,
+    headers: cloneStringRecord(config2.headers)
   };
 }
 function cloneRenameMap(rename5) {
@@ -2273,57 +2528,57 @@ function resolveCommandScope(ownScope, inheritedScope) {
 function resolveGroupScope(ownScope, inheritedScope) {
   return cloneScope(ownScope ?? inheritedScope);
 }
-function createBaseCommand(config) {
+function createBaseCommand(config2) {
   const command = {
     kind: "command",
-    name: config.name,
-    description: config.description,
-    aliases: [...config.aliases ?? []],
-    positional: [...config.positional ?? []],
-    params: config.params,
-    secrets: cloneSecrets(config.secrets),
-    scope: resolveCommandScope(config.scope, void 0),
-    confirm: config.confirm ?? false,
-    humanInLoop: config.humanInLoop,
-    requires: cloneRequires(config.requires),
-    handler: config.handler,
-    render: config.render
+    name: config2.name,
+    description: config2.description,
+    aliases: [...config2.aliases ?? []],
+    positional: [...config2.positional ?? []],
+    params: config2.params,
+    secrets: cloneSecrets(config2.secrets),
+    scope: resolveCommandScope(config2.scope, void 0),
+    confirm: config2.confirm ?? false,
+    humanInLoop: config2.humanInLoop,
+    requires: cloneRequires(config2.requires),
+    handler: config2.handler,
+    render: config2.render
   };
   Object.defineProperty(command, commandConfigSymbol, {
     value: {
-      scope: cloneScope(config.scope),
-      humanInLoop: config.humanInLoop,
-      secrets: cloneSecrets(config.secrets),
-      requires: cloneRequires(config.requires),
+      scope: cloneScope(config2.scope),
+      humanInLoop: config2.humanInLoop,
+      secrets: cloneSecrets(config2.secrets),
+      requires: cloneRequires(config2.requires),
       sourcePath: inferCommandSourcePath()
     }
   });
   return command;
 }
-function createBaseGroup(config) {
+function createBaseGroup(config2) {
   const group = {
     kind: "group",
-    name: config.name,
-    description: config.description,
-    aliases: [...config.aliases ?? []],
-    scope: resolveGroupScope(config.scope, void 0),
-    humanInLoop: config.humanInLoop,
-    secrets: cloneSecrets(config.secrets),
-    requires: cloneRequires(config.requires),
+    name: config2.name,
+    description: config2.description,
+    aliases: [...config2.aliases ?? []],
+    scope: resolveGroupScope(config2.scope, void 0),
+    humanInLoop: config2.humanInLoop,
+    secrets: cloneSecrets(config2.secrets),
+    requires: cloneRequires(config2.requires),
     children: [],
     default: void 0
   };
   Object.defineProperty(group, groupConfigSymbol, {
     value: {
-      mcp: cloneMcpServerConfig(config.mcp),
-      scope: cloneScope(config.scope),
-      humanInLoop: config.humanInLoop,
-      secrets: cloneSecrets(config.secrets),
-      tools: cloneStringArray(config.tools),
-      rename: cloneRenameMap(config.rename),
-      requires: cloneRequires(config.requires),
-      children: [...config.children],
-      default: config.default
+      mcp: cloneMcpServerConfig(config2.mcp),
+      scope: cloneScope(config2.scope),
+      humanInLoop: config2.humanInLoop,
+      secrets: cloneSecrets(config2.secrets),
+      tools: cloneStringArray(config2.tools),
+      rename: cloneRenameMap(config2.rename),
+      requires: cloneRequires(config2.requires),
+      children: [...config2.children],
+      default: config2.default
     }
   });
   return group;
@@ -2426,10 +2681,10 @@ function materializeNode(node, inherited) {
   }
   return materializeGroup(node, inherited);
 }
-function defineCommand(config) {
-  validateHumanInLoopOnDefine(config);
+function defineCommand(config2) {
+  validateHumanInLoopOnDefine(config2);
   return materializeCommand(
-    createBaseCommand(config),
+    createBaseCommand(config2),
     {
       scope: void 0,
       humanInLoop: void 0,
@@ -2438,10 +2693,10 @@ function defineCommand(config) {
     }
   );
 }
-function defineGroup(config) {
-  validateRenameMap(config.rename);
-  validateHumanInLoopOnDefine(config);
-  return materializeGroup(createBaseGroup(config), {
+function defineGroup(config2) {
+  validateRenameMap(config2.rename);
+  validateHumanInLoopOnDefine(config2);
+  return materializeGroup(createBaseGroup(config2), {
     scope: void 0,
     humanInLoop: void 0,
     secrets: {},
@@ -2602,17 +2857,22 @@ import { randomBytes } from "node:crypto";
 // ../process-runner/src/docker/args.ts
 import path2 from "node:path";
 
+// ../process-runner/src/docker/env-file.ts
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path3 from "node:path";
+
 // ../process-runner/src/docker/docker-execution-env.ts
 import { createHash as createHash2, randomBytes as randomBytes2 } from "node:crypto";
-import { mkdtempSync, rmSync } from "node:fs";
-import { readdir, readFile, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path4 from "node:path";
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync2 } from "node:fs";
+import { readdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import path5 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;
+  const detachedByDefault = options.detached === true;
   return {
     name: "host",
     exec(spec) {
@@ -2630,18 +2890,19 @@ function createHostRunner(options = {}) {
       const stdinMode = spec.stdin ?? "ignore";
       const stdoutMode = spec.stdout ?? "pipe";
       const stderrMode = spec.stderr ?? "pipe";
+      const killProcessGroup = detachedByDefault || spec.killProcessGroup === true;
       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 } : {}
+        ...killProcessGroup ? { detached: true } : {}
       });
-      if (detached) {
+      if (killProcessGroup) {
         child.unref();
       }
       const kill = (signal) => {
-        if (detached && process.platform !== "win32" && child.pid !== void 0) {
+        if (killProcessGroup && process.platform !== "win32" && child.pid !== void 0) {
           process.kill(-child.pid, signal);
           return;
         }
@@ -2699,9 +2960,9 @@ function bindAbortSignal(signal, onAbort) {
 }
 
 // ../process-runner/src/workspace-transfer.ts
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { promises as nodeFs } from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 
 // ../process-runner/src/testing/mock-runner.ts
 import { Readable, Writable } from "node:stream";
@@ -2772,7 +3033,7 @@ function resolveEndpoint(options = {}) {
 }
 
 // ../task-list/src/backends/utils.ts
-import path5 from "node:path";
+import path6 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 : "";
@@ -2822,12 +3083,12 @@ async function statIfExists(fs4, filePath) {
   }
 }
 async function rejectSymbolicLinkComponents(fs4, filePath) {
-  const resolvedPath = path5.resolve(filePath);
-  const rootPath = path5.parse(resolvedPath).root;
-  const components = resolvedPath.slice(rootPath.length).split(path5.sep).filter(Boolean);
+  const resolvedPath = path6.resolve(filePath);
+  const rootPath = path6.parse(resolvedPath).root;
+  const components = resolvedPath.slice(rootPath.length).split(path6.sep).filter(Boolean);
   let currentPath = rootPath;
   for (const component of components) {
-    currentPath = path5.join(currentPath, component);
+    currentPath = path6.join(currentPath, component);
     try {
       if ((await fs4.lstat(currentPath)).isSymbolicLink()) {
         throw new Error(`Path "${filePath}" contains a symbolic link.`);
@@ -2843,7 +3104,7 @@ async function rejectSymbolicLinkComponents(fs4, filePath) {
 async function writeAtomically(fs4, filePath, content) {
   const tempPath = `${filePath}.tmp-${process.pid}-${tmpFileCounter}`;
   tmpFileCounter += 1;
-  await fs4.mkdir(path5.dirname(filePath), { recursive: true });
+  await fs4.mkdir(path6.dirname(filePath), { recursive: true });
   try {
     await fs4.writeFile(tempPath, content, { encoding: "utf8", flag: "wx" });
     await fs4.rename(tempPath, filePath);
@@ -2859,7 +3120,7 @@ async function writeAtomically(fs4, filePath, content) {
   }
 }
 async function withFileLock(fs4, lockPath, operation) {
-  await fs4.mkdir(path5.dirname(lockPath), { recursive: true });
+  await fs4.mkdir(path6.dirname(lockPath), { recursive: true });
   for (; ; ) {
     try {
       await fs4.writeFile(lockPath, String(process.pid), { encoding: "utf8", flag: "wx" });
@@ -3946,7 +4207,7 @@ function parseQualifiedId(qualifiedId, listName) {
 }
 
 // ../task-list/src/backends/markdown-dir.ts
-import path6 from "node:path";
+import path7 from "node:path";
 import { parseDocument, stringify } from "yaml";
 
 // ../task-list/src/schema/task.schema.json
@@ -4065,16 +4326,16 @@ function parseQualifiedId2(qualifiedId) {
   };
 }
 function listPath(rootPath, layout, list) {
-  return layout.kind === "single" ? rootPath : path6.join(rootPath, list);
+  return layout.kind === "single" ? rootPath : path7.join(rootPath, list);
 }
 function archiveDirectoryPath(rootPath, layout, list) {
-  return layout.kind === "single" ? path6.join(rootPath, ARCHIVE_DIRECTORY_NAME) : path6.join(rootPath, list, ARCHIVE_DIRECTORY_NAME);
+  return layout.kind === "single" ? path7.join(rootPath, ARCHIVE_DIRECTORY_NAME) : path7.join(rootPath, list, ARCHIVE_DIRECTORY_NAME);
 }
 function activeTaskFilename(id, order, width) {
   return `${String(order).padStart(width, "0")}-${id}${MARKDOWN_EXTENSION}`;
 }
 function archivedTaskPath(rootPath, layout, list, id) {
-  return path6.join(archiveDirectoryPath(rootPath, layout, list), `${id}${MARKDOWN_EXTENSION}`);
+  return path7.join(archiveDirectoryPath(rootPath, layout, list), `${id}${MARKDOWN_EXTENSION}`);
 }
 function isMarkdownFile(entryName) {
   return entryName.endsWith(MARKDOWN_EXTENSION);
@@ -4200,7 +4461,7 @@ function createTask(list, id, frontmatter, body, mode, sourcePath) {
     state: frontmatter.state,
     description: body,
     metadata: metadataFromFrontmatter(frontmatter, mode),
-    ...sourcePath !== void 0 && { sourcePath: path6.resolve(sourcePath) }
+    ...sourcePath !== void 0 && { sourcePath: path7.resolve(sourcePath) }
   };
 }
 function serializeTaskDocument(frontmatter, description) {
@@ -4240,7 +4501,7 @@ async function readTaskFile(fs4, list, id, filePath, validStates, initialState,
       task: createTask(list, id, frontmatter, document.body, mode, filePath)
     };
   }
-  const parsedFilename = parseActiveFilename(path6.basename(filePath));
+  const parsedFilename = parseActiveFilename(path7.basename(filePath));
   const defaultName = parsedFilename?.id ?? id;
   const effectiveFrontmatter = {
     ...frontmatter,
@@ -4269,7 +4530,7 @@ async function findTaskLocation(fs4, rootPath, layout, list, id) {
   await rejectSymbolicLinkComponents(fs4, listDirectoryPath);
   const activeName = await findActiveTaskFilename(fs4, listDirectoryPath, id);
   if (activeName) {
-    const activePath = path6.join(listDirectoryPath, activeName);
+    const activePath = path7.join(listDirectoryPath, activeName);
     await rejectSymbolicLinkComponents(fs4, activePath);
     const activeStat = await statIfExists(fs4, activePath);
     if (activeStat?.isFile()) {
@@ -4292,7 +4553,7 @@ async function readTaskAtLocation(fs4, rootPath, layout, list, id, validStates,
   }
   return readTaskFile(fs4, list, id, location.path, validStates, initialState, mode);
 }
-function createdFrontmatter(defaults, input, initialState, mode) {
+function createdFrontmatter(defaults2, input, initialState, mode) {
   const frontmatter = mode !== "passthrough" ? {
     $schema: TASK_SCHEMA_ID,
     kind: TASK_KIND,
@@ -4304,7 +4565,7 @@ function createdFrontmatter(defaults, input, initialState, mode) {
     state: initialState
   };
   const reservedKeys = reservedFrontmatterKeys(mode);
-  for (const [key2, value] of Object.entries(defaults.metadata)) {
+  for (const [key2, value] of Object.entries(defaults2.metadata)) {
     if (!reservedKeys.has(key2)) {
       setOwnValue(frontmatter, key2, value);
     }
@@ -4391,7 +4652,7 @@ function createTasksView2(deps, layout, list) {
       if (isHiddenEntry(entryName)) continue;
       const parsed = parseActiveFilename(entryName);
       if (!parsed) continue;
-      const entryPath = path6.join(listDirectoryPath, entryName);
+      const entryPath = path7.join(listDirectoryPath, entryName);
       await rejectSymbolicLinkComponents(deps.fs, entryPath);
       const entryStat = await statIfExists(deps.fs, entryPath);
       if (!entryStat?.isFile()) continue;
@@ -4409,7 +4670,7 @@ function createTasksView2(deps, layout, list) {
     const entries = await readActiveEntries();
     const tasks = /* @__PURE__ */ new Map();
     for (const entry of entries) {
-      const filePath = path6.join(listDirectoryPath, entry.filename);
+      const filePath = path7.join(listDirectoryPath, entry.filename);
       const file = await readTaskFile(
         deps.fs,
         list,
@@ -4430,7 +4691,7 @@ function createTasksView2(deps, layout, list) {
     const result = [];
     for (const entryName of entries) {
       if (isHiddenEntry(entryName) || !isMarkdownFile(entryName)) continue;
-      const entryPath = path6.join(archivePath, entryName);
+      const entryPath = path7.join(archivePath, entryName);
       await rejectSymbolicLinkComponents(deps.fs, entryPath);
       const entryStat = await statIfExists(deps.fs, entryPath);
       if (!entryStat?.isFile()) continue;
@@ -4460,12 +4721,12 @@ function createTasksView2(deps, layout, list) {
       if (desiredOrder === void 0) continue;
       const desiredFilename = activeTaskFilename(entry.id, desiredOrder, width);
       if (entry.filename !== desiredFilename) {
-        const fromPath = path6.join(listDirectoryPath, entry.filename);
-        const stagingPath = path6.join(
+        const fromPath = path7.join(listDirectoryPath, entry.filename);
+        const stagingPath = path7.join(
           listDirectoryPath,
           `${desiredFilename}.staging-${process.pid}-${index}`
         );
-        const targetPath = path6.join(listDirectoryPath, desiredFilename);
+        const targetPath = path7.join(listDirectoryPath, desiredFilename);
         try {
           await deps.fs.rename(fromPath, stagingPath);
           staged.push({ original: fromPath, staging: stagingPath, target: targetPath, finalized: false });
@@ -4614,7 +4875,7 @@ function createTasksView2(deps, layout, list) {
       assertCreateHasId(input);
       validateTaskId(input.id);
       await rejectSymbolicLinkComponents(deps.fs, listDirectoryPath);
-      return withFileLock(deps.fs, path6.join(listDirectoryPath, ".transition.lock"), async () => {
+      return withFileLock(deps.fs, path7.join(listDirectoryPath, ".transition.lock"), async () => {
         const existing = await findTaskLocation(deps.fs, deps.path, layout, list, input.id);
         if (existing) {
           throw new TaskAlreadyExistsError(`Task "${list}/${input.id}" already exists.`);
@@ -4627,7 +4888,7 @@ function createTasksView2(deps, layout, list) {
         const nextOrder = maxOrder + 1;
         const width = padWidthForCount(activeEntries.length + 1);
         const filename = activeTaskFilename(input.id, nextOrder, width);
-        const targetPath = path6.join(listDirectoryPath, filename);
+        const targetPath = path7.join(listDirectoryPath, filename);
         const frontmatter = createdFrontmatter(
           deps.defaults,
           input,
@@ -4735,7 +4996,7 @@ function createTasksView2(deps, layout, list) {
       validateTaskId(id);
       const { event, nextTask } = await withFileLock(
         deps.fs,
-        path6.join(listDirectoryPath, ".transition.lock"),
+        path7.join(listDirectoryPath, ".transition.lock"),
         fireTask
       );
       await event.onEnter?.(nextTask);
@@ -4828,7 +5089,7 @@ async function markdownDirBackend(deps) {
       if (entryName === ARCHIVE_DIRECTORY_NAME || isHiddenEntry(entryName)) {
         continue;
       }
-      const entryPath = path6.join(deps.path, entryName);
+      const entryPath = path7.join(deps.path, entryName);
       await rejectSymbolicLinkComponents(deps.fs, entryPath);
       const entryStat = await statIfExists(deps.fs, entryPath);
       if (entryStat?.isDirectory()) {
@@ -4870,7 +5131,7 @@ async function markdownDirBackend(deps) {
     }
     const targetListDir = listPath(deps.path, layout, targetListName);
     await rejectSymbolicLinkComponents(deps.fs, targetListDir);
-    return withFileLock(deps.fs, path6.join(targetListDir, ".transition.lock"), async () => {
+    return withFileLock(deps.fs, path7.join(targetListDir, ".transition.lock"), async () => {
       const targetExisting = await findTaskLocation(deps.fs, deps.path, layout, targetListName, id);
       if (targetExisting) {
         throw new TaskAlreadyExistsError(`Task "${targetListName}/${id}" already exists.`);
@@ -4920,7 +5181,7 @@ async function markdownDirBackend(deps) {
       );
       const width = padWidthForCount(targetEntries.length + 1);
       const targetFilename = activeTaskFilename(id, maxOrder + 1, width);
-      const targetPath = path6.join(targetListDir, targetFilename);
+      const targetPath = path7.join(targetListDir, targetFilename);
       await deps.fs.rename(sourceLocation.path, targetPath);
       return createTask(
         targetListName,
@@ -4942,7 +5203,7 @@ async function markdownDirBackend(deps) {
 }
 
 // ../task-list/src/backends/yaml-file.ts
-import path7 from "node:path";
+import path8 from "node:path";
 import { isMap, parseDocument as parseDocument2 } from "yaml";
 
 // ../task-list/src/schema/store.schema.json
@@ -5038,7 +5299,7 @@ function createTask2(list, id, taskRecord, sourcePath) {
     state: taskRecord.state,
     description: descriptionFromTaskRecord(taskRecord),
     metadata: metadataFromTaskRecord(taskRecord),
-    ...sourcePath !== void 0 && { sourcePath: path7.resolve(sourcePath) }
+    ...sourcePath !== void 0 && { sourcePath: path8.resolve(sourcePath) }
   };
 }
 function matchesFilter(task, filter) {
@@ -5050,13 +5311,13 @@ function matchesFilter(task, filter) {
   }
   return true;
 }
-function createTaskRecord(defaults, input, initialState) {
+function createTaskRecord(defaults2, input, initialState) {
   const taskRecord = Object.assign(/* @__PURE__ */ Object.create(null), {
     name: input.name,
     state: initialState,
     description: input.description ?? ""
   });
-  for (const [key2, value] of Object.entries(defaults.metadata)) {
+  for (const [key2, value] of Object.entries(defaults2.metadata)) {
     if (!RESERVED_TASK_KEYS.has(key2)) {
       taskRecord[key2] = value;
     }
@@ -5603,7 +5864,7 @@ async function openGhIssuesBackend(options) {
 
 // ../task-list/src/move.ts
 import * as fsPromises2 from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 
 // ../toolcraft/src/human-in-loop/approval-tasks.ts
 import { randomBytes as randomBytes3 } from "node:crypto";
@@ -6099,13 +6360,13 @@ function formatAvailableApprovalCommandPaths(root) {
 }
 function enumerateApprovalCommandPaths(root) {
   const paths = [];
-  const visit = (node, path23) => {
+  const visit = (node, path24) => {
     if (node.kind === "command") {
-      paths.push(path23.join("."));
+      paths.push(path24.join("."));
       return;
     }
     for (const child of getVisibleCliChildren(node)) {
-      visit(child, [...path23, child.name]);
+      visit(child, [...path24, child.name]);
     }
   };
   if (root.kind === "command") {
@@ -6140,21 +6401,21 @@ function createHandlerContext(command, params17) {
 }
 function createFs() {
   return {
-    readFile: async (path23, encoding = "utf8") => readFile2(path23, { encoding }),
-    writeFile: async (path23, contents) => {
-      await writeFile2(path23, contents);
+    readFile: async (path24, encoding = "utf8") => readFile2(path24, { encoding }),
+    writeFile: async (path24, contents) => {
+      await writeFile2(path24, contents);
     },
-    exists: async (path23) => {
+    exists: async (path24) => {
       try {
-        await access(path23);
+        await access(path24);
         return true;
       } catch {
         return false;
       }
     },
-    lstat: async (path23) => lstat(path23),
+    lstat: async (path24) => lstat(path24),
     rename: async (fromPath, toPath) => rename(fromPath, toPath),
-    unlink: async (path23) => unlink(path23)
+    unlink: async (path24) => unlink(path24)
   };
 }
 function createEnv(values = process.env) {
@@ -6430,17 +6691,17 @@ function isMissingStateError(error3) {
 }
 
 // ../toolcraft/src/error-report.ts
-import { mkdir as mkdir2, realpath, writeFile as writeFile4 } from "node:fs/promises";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir2, realpath as realpath2, writeFile as writeFile4 } from "node:fs/promises";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import os from "node:os";
-import path12 from "node:path";
+import path13 from "node:path";
 import { CommanderError } from "commander";
 
 // ../toolcraft/src/mcp-proxy.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { lstat as lstat2, mkdir, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "node:fs/promises";
-import path11 from "node:path";
-import { createHash as createHash3, randomUUID } from "node:crypto";
+import path12 from "node:path";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
 
 // ../tiny-mcp-client/src/internal.ts
 import { spawn as spawn5 } from "node:child_process";
@@ -6448,13 +6709,13 @@ import { PassThrough as PassThrough2 } from "node:stream";
 
 // ../mcp-oauth/src/client/auth-store-session-store.ts
 import crypto from "node:crypto";
-import path10 from "node:path";
+import path11 from "node:path";
 
 // ../auth-store/src/encrypted-file-store.ts
 import { createCipheriv, createDecipheriv, randomBytes as randomBytes4, scrypt } from "node:crypto";
 import { promises as fs } from "node:fs";
 import { homedir, hostname, userInfo } from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 var derivedKeyCache = /* @__PURE__ */ new Map();
 var ENCRYPTION_ALGORITHM = "aes-256-gcm";
 var ENCRYPTION_VERSION = 1;
@@ -6466,6 +6727,7 @@ var temporaryFileSequence = 0;
 var EncryptedFileStore = class {
   fs;
   filePath;
+  symbolicLinkCheckStartPath;
   salt;
   getMachineIdentity;
   getRandomBytes;
@@ -6473,11 +6735,22 @@ var EncryptedFileStore = class {
   constructor(input) {
     this.fs = input.fs ?? fs;
     this.salt = input.salt;
-    this.filePath = input.filePath ?? path9.join(
-      (input.getHomeDirectory ?? homedir)(),
-      input.defaultDirectory ?? ".auth-store",
-      input.defaultFileName ?? "credentials.enc"
-    );
+    if (input.filePath === void 0) {
+      const homeDirectory = (input.getHomeDirectory ?? homedir)();
+      const defaultDirectory = input.defaultDirectory ?? ".auth-store";
+      this.filePath = path10.join(
+        homeDirectory,
+        defaultDirectory,
+        input.defaultFileName ?? "credentials.enc"
+      );
+      this.symbolicLinkCheckStartPath = resolveDefaultDirectoryCheckStart(
+        homeDirectory,
+        defaultDirectory
+      );
+    } else {
+      this.filePath = input.filePath;
+      this.symbolicLinkCheckStartPath = null;
+    }
     this.getMachineIdentity = input.getMachineIdentity ?? defaultMachineIdentity;
     this.getRandomBytes = input.getRandomBytes ?? randomBytes4;
   }
@@ -6528,7 +6801,7 @@ var EncryptedFileStore = class {
       authTag: authTag.toString("base64"),
       ciphertext: ciphertext.toString("base64")
     };
-    await this.fs.mkdir(path9.dirname(this.filePath), { recursive: true });
+    await this.fs.mkdir(path10.dirname(this.filePath), { recursive: true });
     await this.assertRegularCredentialPath();
     const temporaryPath = `${this.filePath}.${process.pid}.${temporaryFileSequence++}.tmp`;
     try {
@@ -6557,8 +6830,11 @@ var EncryptedFileStore = class {
     }
   }
   async assertRegularCredentialPath() {
-    const resolvedPath = path9.resolve(this.filePath);
-    const protectedPaths = [path9.dirname(resolvedPath), resolvedPath];
+    const resolvedPath = path10.resolve(this.filePath);
+    const protectedPaths = getProtectedCredentialPaths(
+      resolvedPath,
+      this.symbolicLinkCheckStartPath
+    );
     for (const currentPath of protectedPaths) {
       try {
         const stats = await this.fs.lstat(currentPath);
@@ -6586,6 +6862,30 @@ var EncryptedFileStore = class {
     return this.keyPromise;
   }
 };
+function resolveDefaultDirectoryCheckStart(homeDirectory, defaultDirectory) {
+  const [firstSegment] = defaultDirectory.split(/[\\/]+/).filter(Boolean);
+  return path10.resolve(homeDirectory, firstSegment ?? ".");
+}
+function getProtectedCredentialPaths(resolvedPath, symbolicLinkCheckStartPath) {
+  if (symbolicLinkCheckStartPath === null) {
+    return [path10.dirname(resolvedPath), resolvedPath];
+  }
+  const resolvedStartPath = path10.resolve(symbolicLinkCheckStartPath);
+  if (!isPathInsideOrEqual(resolvedPath, resolvedStartPath)) {
+    return [path10.dirname(resolvedPath), resolvedPath];
+  }
+  const protectedPaths = [resolvedStartPath];
+  let currentPath = resolvedStartPath;
+  for (const segment of path10.relative(resolvedStartPath, resolvedPath).split(path10.sep).filter(Boolean)) {
+    currentPath = path10.join(currentPath, segment);
+    protectedPaths.push(currentPath);
+  }
+  return protectedPaths;
+}
+function isPathInsideOrEqual(childPath, parentPath) {
+  const relativePath = path10.relative(parentPath, childPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path10.isAbsolute(relativePath);
+}
 async function removeIfPresent(fileSystem, filePath) {
   try {
     await fileSystem.unlink(filePath);
@@ -6736,6 +7036,17 @@ function runSecurityCommand(command, args, options) {
     });
     let stdout = "";
     let stderr = "";
+    let stdinErrorMessage;
+    const appendStderr = (message2) => {
+      stderr = stderr.length === 0 ? message2 : `${stderr}${stderr.endsWith("\n") ? "" : "\n"}${message2}`;
+    };
+    const appendStdinError = () => {
+      if (stdinErrorMessage === void 0) {
+        return;
+      }
+      appendStderr(stdinErrorMessage);
+      stdinErrorMessage = void 0;
+    };
     child.stdout?.setEncoding("utf8");
     child.stdout?.on("data", (chunk) => {
       stdout += chunk.toString();
@@ -6745,17 +7056,23 @@ function runSecurityCommand(command, args, options) {
       stderr += chunk.toString();
     });
     if (options?.stdin !== void 0) {
+      child.stdin?.once("error", (error3) => {
+        stdinErrorMessage = error3 instanceof Error ? error3.message : String(error3);
+      });
       child.stdin?.end(options.stdin);
     }
     child.on("error", (error3) => {
       const message2 = error3 instanceof Error ? error3.message : String(error3 ?? "Unknown error");
+      appendStdinError();
+      appendStderr(message2);
       resolve({
         stdout,
-        stderr: stderr ? `${stderr}${message2}` : message2,
+        stderr,
         exitCode: 127
       });
     });
     child.on("close", (code) => {
+      appendStdinError();
       resolve({
         stdout,
         stderr,
@@ -6893,19 +7210,24 @@ function createAuthStoreClientStore(options) {
     }
   };
 }
-function createNamedSecretStore(key2, options, defaults) {
+function createNamedSecretStore(key2, options, defaults2) {
   const hash = crypto.createHash("sha256").update(key2).digest("hex");
-  const parsedFilePath = options.fileStore?.filePath === void 0 ? null : path10.parse(options.fileStore.filePath);
+  const configuredFilePath = options.fileStore?.filePath;
+  const parsedFilePath = configuredFilePath === void 0 ? null : path11.parse(configuredFilePath);
   const fileStore = {
     ...options.fileStore,
-    salt: options.fileStore?.salt ?? defaults.salt,
-    defaultDirectory: parsedFilePath?.dir || options.fileStore?.defaultDirectory || defaults.directory,
+    filePath: parsedFilePath === null ? void 0 : path11.join(
+      parsedFilePath.dir,
+      `${parsedFilePath.name}-${hash}${parsedFilePath.ext || ".enc"}`
+    ),
+    salt: options.fileStore?.salt ?? defaults2.salt,
+    defaultDirectory: options.fileStore?.defaultDirectory || defaults2.directory,
     defaultFileName: parsedFilePath === null ? `${hash}.enc` : `${parsedFilePath.name}-${hash}${parsedFilePath.ext || ".enc"}`
   };
   const keychainStore = {
     ...options.keychainStore,
-    service: options.keychainStore?.service ?? defaults.service,
-    account: `${options.keychainStore?.account ?? defaults.accountPrefix}:${hash}`
+    service: options.keychainStore?.service ?? defaults2.service,
+    account: `${options.keychainStore?.account ?? defaults2.accountPrefix}:${hash}`
   };
   return createSecretStore({ ...options, fileStore, keychainStore }).store;
 }
@@ -8478,10 +8800,19 @@ var McpClient = class {
     }
     try {
       let requestId;
+      let cancellationSent = false;
+      const sendCancellationNotification = () => {
+        if (requestId === void 0 || cancellationSent) {
+          return;
+        }
+        cancellationSent = true;
+        messageLayer.sendNotification("notifications/cancelled", { requestId });
+      };
       const requestPromise = messageLayer.sendRequest("tools/call", requestParams, {
         onRequestId: (nextRequestId) => {
           requestId = nextRequestId;
-        }
+        },
+        onTimeout: sendCancellationNotification
       }).then((result) => {
         if (!isCallToolResult(result)) {
           throw new McpError(ERROR_INVALID_REQUEST, "Invalid tool result");
@@ -8495,8 +8826,9 @@ var McpClient = class {
       let abortListener;
       const abortPromise = new Promise((_, reject) => {
         const rejectWithAbortReason = () => {
+          sendCancellationNotification();
           if (requestId !== void 0) {
-            messageLayer.sendNotification("notifications/cancelled", { requestId });
+            messageLayer.cancelRequest(requestId, signal.reason);
           }
           reject(signal.reason);
         };
@@ -8672,11 +9004,13 @@ var StdioTransport = class _StdioTransport {
     const child = this.child;
     this.readable = child.stdout;
     this.writable = child.stdin;
+    const stderrDecoder = new TextDecoder();
     child.stderr.on("data", (chunk) => {
-      this.stderrOutput += chunkToString(chunk);
-      if (this.stderrOutput.length > _StdioTransport.STDERR_MAX_LENGTH) {
-        this.stderrOutput = this.stderrOutput.slice(-_StdioTransport.STDERR_MAX_LENGTH);
-      }
+      const decoded = chunk instanceof Uint8Array ? stderrDecoder.decode(chunk, { stream: true }) : `${stderrDecoder.decode()}${String(chunk)}`;
+      this.appendStderrOutput(decoded);
+    });
+    child.stderr.once("end", () => {
+      this.appendStderrOutput(stderrDecoder.decode());
     });
     this.closed = new Promise((resolve) => {
       let settled = false;
@@ -8716,6 +9050,15 @@ var StdioTransport = class _StdioTransport {
   getStderrOutput() {
     return this.stderrOutput;
   }
+  appendStderrOutput(chunk) {
+    if (chunk.length === 0) {
+      return;
+    }
+    this.stderrOutput += chunk;
+    if (this.stderrOutput.length > _StdioTransport.STDERR_MAX_LENGTH) {
+      this.stderrOutput = this.stderrOutput.slice(-_StdioTransport.STDERR_MAX_LENGTH);
+    }
+  }
   dispose(reason = new Error("Stdio transport disposed")) {
     void reason;
     if (this.disposed) {
@@ -9123,15 +9466,6 @@ function serializeJsonRpcMessage(message2) {
   return `${JSON.stringify(message2)}
 `;
 }
-function chunkToString(chunk) {
-  if (typeof chunk === "string") {
-    return chunk;
-  }
-  if (chunk instanceof Uint8Array) {
-    return Buffer.from(chunk).toString("utf8");
-  }
-  return String(chunk);
-}
 function normalizeLine(line) {
   return line.endsWith("\r") ? line.slice(0, -1) : line;
 }
@@ -9308,6 +9642,7 @@ var JsonRpcMessageLayer = class {
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         this.pendingRequests.delete(id);
+        options.onTimeout?.(id);
         reject(new Error(`JSON-RPC request "${method}" timed out after ${timeoutMs}ms`));
       }, timeoutMs);
       this.pendingRequests.set(id, { resolve, reject, timeout });
@@ -9320,6 +9655,16 @@ var JsonRpcMessageLayer = class {
       }
     });
   }
+  cancelRequest(requestId, reason) {
+    const pending = this.pendingRequests.get(requestId);
+    if (pending === void 0) {
+      return false;
+    }
+    this.pendingRequests.delete(requestId);
+    clearTimeout(pending.timeout);
+    pending.reject(reason);
+    return true;
+  }
   dispose(reason = new Error("JSON-RPC message layer disposed")) {
     if (this.disposedError !== void 0) {
       return;
@@ -9720,13 +10065,13 @@ function convertJsonSchema(schema) {
   }
   return convertSchema(schema, schema, []);
 }
-function convertSchema(schema, root, path23) {
-  const resolvedSchema = resolveReferencedSchema(schema, root, path23);
+function convertSchema(schema, root, path24) {
+  const resolvedSchema = resolveReferencedSchema(schema, root, path24);
   const normalizedSchema = normalizeNullability(resolvedSchema);
   const composition = getComposition(normalizedSchema.schema);
   if (Array.isArray(normalizedSchema.schema.type)) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path23)}" has an unsupported type "${formatJsonSchemaType(
+      `JSON Schema "${formatJsonSchemaPath(path24)}" has an unsupported type "${formatJsonSchemaType(
         normalizedSchema.schema.type
       )}". Supported: string, number, integer, boolean, array, object.`
     );
@@ -9738,13 +10083,13 @@ function convertSchema(schema, root, path23) {
     return convertEnumSchema(resolvedSchema, normalizedSchema.nullable);
   }
   if (composition !== void 0) {
-    return convertCompositionSchema(normalizedSchema.schema, root, normalizedSchema.nullable, path23);
+    return convertCompositionSchema(normalizedSchema.schema, root, normalizedSchema.nullable, path24);
   }
   if (isRecordSchema(normalizedSchema.schema)) {
     return applyMetadata(
       S.Record(
         convertSchema(normalizedSchema.schema.additionalProperties, root, [
-          ...path23,
+          ...path24,
           "additionalProperties"
         ])
       ),
@@ -9793,12 +10138,12 @@ function convertSchema(schema, root, path23) {
       if (normalizedSchema.schema.items === void 0) {
         throw new Error(
           `JSON Schema "${formatJsonSchemaPath(
-            path23
+            path24
           )}" is an array but is missing the "items" field. Add "items": { ... } to declare the element type.`
         );
       }
       return S.Array(
-        convertSchema(normalizedSchema.schema.items, root, [...path23, "items"]),
+        convertSchema(normalizedSchema.schema.items, root, [...path24, "items"]),
         createCommonOptions(
           normalizedSchema.schema,
           normalizedSchema.nullable,
@@ -9808,7 +10153,7 @@ function convertSchema(schema, root, path23) {
     case "object":
       return convertObjectSchema(normalizedSchema.schema, root, {
         nullable: normalizedSchema.nullable,
-        path: path23
+        path: path24
       });
     case "null":
       return applyMetadata(S.Json(), normalizedSchema.schema, {
@@ -9823,12 +10168,12 @@ function convertSchema(schema, root, path23) {
       }
       throw new Error(
         `JSON Schema "${formatJsonSchemaPath(
-          path23
+          path24
         )}" must declare one of: "type", "enum", "const", "oneOf", "anyOf", or "allOf".`
       );
   }
   throw new Error(
-    `JSON Schema "${formatJsonSchemaPath(path23)}" has an unsupported type "${formatJsonSchemaType(
+    `JSON Schema "${formatJsonSchemaPath(path24)}" has an unsupported type "${formatJsonSchemaType(
       normalizedSchema.schema.type
     )}". Supported: string, number, integer, boolean, array, object.`
   );
@@ -9872,21 +10217,21 @@ function convertEnumSchema(schema, nullable) {
     )
   });
 }
-function convertCompositionSchema(schema, root, nullable, path23) {
+function convertCompositionSchema(schema, root, nullable, path24) {
   const composition = getComposition(schema);
   const branchSchemas = composition?.branches ?? [];
   const keyword = composition?.keyword ?? "oneOf";
   const branches = branchSchemas.map(
-    (branch, index) => resolveReferencedSchema(branch, root, [...path23, keyword, String(index)])
+    (branch, index) => resolveReferencedSchema(branch, root, [...path24, keyword, String(index)])
   );
-  const discriminator = findDiscriminator(branches, root, path23);
+  const discriminator = findDiscriminator(branches, root, path24);
   if (discriminator !== void 0) {
     const convertedBranches = Object.fromEntries(
       branches.map((branch, index) => [
         getDiscriminatorLiteral(branch, discriminator, root),
         convertObjectSchema(branch, root, {
           omitProperty: discriminator,
-          path: [...path23, keyword, String(index)]
+          path: [...path24, keyword, String(index)]
         })
       ])
     );
@@ -9905,7 +10250,7 @@ function convertCompositionSchema(schema, root, nullable, path23) {
     S.Union(
       branches.map(
         (branch, index) => convertObjectSchema(branch, root, {
-          path: [...path23, keyword, String(index)]
+          path: [...path24, keyword, String(index)]
         })
       )
     ),
@@ -10007,11 +10352,11 @@ function getComposition(schema) {
   }
   return void 0;
 }
-function formatJsonSchemaPath(path23) {
-  if (path23.length === 0) {
+function formatJsonSchemaPath(path24) {
+  if (path24.length === 0) {
     return "#";
   }
-  return `#/${path23.map(escapeJsonPointerSegment).join("/")}`;
+  return `#/${path24.map(escapeJsonPointerSegment).join("/")}`;
 }
 function formatJsonSchemaType(type2) {
   return Array.isArray(type2) ? JSON.stringify(type2) : String(type2);
@@ -10027,11 +10372,11 @@ function isRecordSchema(schema) {
   const propertyKeys = Object.keys(schema.properties ?? {});
   return schema.type === "object" && propertyKeys.length === 0 && typeof schema.additionalProperties === "object" && schema.additionalProperties !== null;
 }
-function findDiscriminator(branches, root, path23) {
+function findDiscriminator(branches, root, path24) {
   const [firstBranch] = branches;
   if (firstBranch === void 0) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path23)}" uses oneOf/anyOf/allOf but has no branches.`
+      `JSON Schema "${formatJsonSchemaPath(path24)}" uses oneOf/anyOf/allOf but has no branches.`
     );
   }
   const candidateKeys = Object.keys(firstBranch.properties ?? {});
@@ -10071,19 +10416,19 @@ function getDiscriminatorLiteral(branch, key2, root) {
   }
   return void 0;
 }
-function resolveReferencedSchema(schema, root, path23) {
+function resolveReferencedSchema(schema, root, path24) {
   if (schema.$ref === void 0) {
     return schema;
   }
   const resolvedTarget = resolveLocalRef(root, schema.$ref);
   if (resolvedTarget === void 0) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path23)}" uses "$ref": ${schema.$ref}. toolcraft only supports internal refs like "#/components/schemas/Foo".`
+      `JSON Schema "${formatJsonSchemaPath(path24)}" uses "$ref": ${schema.$ref}. toolcraft only supports internal refs like "#/components/schemas/Foo".`
     );
   }
   const { $ref: ignoredRef, ...siblingKeywords } = schema;
   void ignoredRef;
-  const resolvedSchema = resolveReferencedSchema(resolvedTarget, root, path23);
+  const resolvedSchema = resolveReferencedSchema(resolvedTarget, root, path24);
   if (Object.keys(siblingKeywords).length === 0) {
     return resolvedSchema;
   }
@@ -10107,9 +10452,9 @@ function mergeJsonSchemas(base, overlay) {
     ...mergedRequired === void 0 ? {} : { required: mergedRequired }
   };
 }
-function hasSelfReferencingRef(schema, root, path23 = "#", activePaths = /* @__PURE__ */ new Set()) {
+function hasSelfReferencingRef(schema, root, path24 = "#", activePaths = /* @__PURE__ */ new Set()) {
   const nextActivePaths = new Set(activePaths);
-  nextActivePaths.add(path23);
+  nextActivePaths.add(path24);
   const localRefPath = getLocalRefPath(schema.$ref);
   if (localRefPath !== void 0) {
     if (nextActivePaths.has(localRefPath)) {
@@ -10120,13 +10465,13 @@ function hasSelfReferencingRef(schema, root, path23 = "#", activePaths = /* @__P
       return true;
     }
   }
-  if (schema.items !== void 0 && hasSelfReferencingRef(schema.items, root, `${path23}/items`, nextActivePaths)) {
+  if (schema.items !== void 0 && hasSelfReferencingRef(schema.items, root, `${path24}/items`, nextActivePaths)) {
     return true;
   }
   if (typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && hasSelfReferencingRef(
     schema.additionalProperties,
     root,
-    `${path23}/additionalProperties`,
+    `${path24}/additionalProperties`,
     nextActivePaths
   )) {
     return true;
@@ -10135,7 +10480,7 @@ function hasSelfReferencingRef(schema, root, path23 = "#", activePaths = /* @__P
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path23}/properties/${escapeJsonPointerSegment(key2)}`,
+      `${path24}/properties/${escapeJsonPointerSegment(key2)}`,
       nextActivePaths
     )) {
       return true;
@@ -10145,24 +10490,24 @@ function hasSelfReferencingRef(schema, root, path23 = "#", activePaths = /* @__P
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path23}/$defs/${escapeJsonPointerSegment(key2)}`,
+      `${path24}/$defs/${escapeJsonPointerSegment(key2)}`,
       nextActivePaths
     )) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.oneOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path23}/oneOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path24}/oneOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.anyOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path23}/anyOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path24}/anyOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.allOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path23}/allOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path24}/allOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
@@ -10178,14 +10523,14 @@ function getLocalRefPath(ref) {
   return ref.startsWith("#/") ? ref : void 0;
 }
 function resolveLocalRef(root, ref) {
-  const path23 = getLocalRefPath(ref);
-  if (path23 === void 0) {
+  const path24 = getLocalRefPath(ref);
+  if (path24 === void 0) {
     return void 0;
   }
-  if (path23 === "#") {
+  if (path24 === "#") {
     return root;
   }
-  const segments = path23.slice(2).split("/").map(unescapeJsonPointerSegment);
+  const segments = path24.slice(2).split("/").map(unescapeJsonPointerSegment);
   let current = root;
   for (const segment of segments) {
     if (Array.isArray(current)) {
@@ -10388,10 +10733,10 @@ function validateRenameMap2(name, tools, rename5) {
     }
   }
 }
-function createConnection(name, config) {
+function createConnection(name, config2) {
   const connection = {
     name,
-    config,
+    config: config2,
     async dispose() {
       shutdownDisposers.delete(connection.dispose);
       connection.connecting = void 0;
@@ -10446,8 +10791,8 @@ async function readCache(cachePath) {
   }
 }
 async function writeCache(cachePath, cache) {
-  const directory = path11.dirname(cachePath);
-  const tempPath = `${cachePath}.tmp-${randomUUID()}`;
+  const directory = path12.dirname(cachePath);
+  const tempPath = `${cachePath}.tmp-${randomUUID2()}`;
   await assertCachePathHasNoSymlinks(cachePath);
   await assertCachePathHasNoSymlinks(tempPath);
   await mkdir(directory, { recursive: true });
@@ -10458,13 +10803,13 @@ async function writeCache(cachePath, cache) {
   await assertCachePathHasNoSymlinks(cachePath);
   await rename2(tempPath, cachePath);
 }
-async function fetchCache(name, config) {
+async function fetchCache(name, config2) {
   const logger2 = createLogger((message2) => {
     process.stderr.write(`${message2}
 `);
   });
   logger2.info(`MCP ${name}: connecting`);
-  const client = await dialUpstream(name, config);
+  const client = await dialUpstream(name, config2);
   try {
     logger2.info(`MCP ${name}: listing tools`);
     const tools = [];
@@ -10483,7 +10828,7 @@ async function fetchCache(name, config) {
       $schema: MCP_PROXY_SCHEMA_URL,
       version: 1,
       upstream,
-      configFingerprint: fingerprintMcpServerConfig(config),
+      configFingerprint: fingerprintMcpServerConfig(config2),
       fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
       tools
     };
@@ -10553,8 +10898,8 @@ function isRefreshRequested(name, refresh) {
 }
 async function resolveSingleProxy(group, options) {
   const internal = getInternalGroupConfig2(group);
-  const config = internal.mcp;
-  if (config === void 0) {
+  const config2 = internal.mcp;
+  if (config2 === void 0) {
     return;
   }
   const name = group.name;
@@ -10564,21 +10909,21 @@ async function resolveSingleProxy(group, options) {
     let cache;
     let shouldWriteCache = false;
     if (isRefreshRequested(name, refresh)) {
-      cache = await fetchCache(name, config);
+      cache = await fetchCache(name, config2);
       shouldWriteCache = true;
     } else {
       const storedCache = await readCache(cachePath);
-      if (storedCache && cacheMatchesConfig(storedCache, config)) {
+      if (storedCache && cacheMatchesConfig(storedCache, config2)) {
         cache = storedCache;
       } else {
-        cache = await fetchCache(name, config);
+        cache = await fetchCache(name, config2);
         shouldWriteCache = true;
       }
     }
     const tools = filterAllowlistedTools(cache.tools, internal.tools);
     validateRenameMap2(name, tools, internal.rename);
     const previousConnection = getProxyConnection(group);
-    const nextConnection = createConnection(name, config);
+    const nextConnection = createConnection(name, config2);
     try {
       replaceProxyChildrenSafely(group, tools, internal.rename, nextConnection);
       if (shouldWriteCache) {
@@ -10603,11 +10948,11 @@ async function resolveSingleProxy(group, options) {
     );
   }
 }
-function cacheMatchesConfig(cache, config) {
-  return cache.configFingerprint === fingerprintMcpServerConfig(config);
+function cacheMatchesConfig(cache, config2) {
+  return cache.configFingerprint === fingerprintMcpServerConfig(config2);
 }
-function fingerprintMcpServerConfig(config) {
-  return createHash3("sha256").update(JSON.stringify(config)).digest("hex");
+function fingerprintMcpServerConfig(config2) {
+  return createHash3("sha256").update(JSON.stringify(config2)).digest("hex");
 }
 function collectProxyGroups(root) {
   const groups = [];
@@ -10627,13 +10972,13 @@ function collectProxyGroups(root) {
 function findProjectRoot(from = process.cwd()) {
   let current = process.cwd();
   if (from !== current) {
-    current = path11.resolve(from);
+    current = path12.resolve(from);
   }
   while (true) {
-    if (existsSync2(path11.join(current, "package.json"))) {
+    if (existsSync2(path12.join(current, "package.json"))) {
       return current;
     }
-    const parent = path11.dirname(current);
+    const parent = path12.dirname(current);
     if (parent === current) {
       return void 0;
     }
@@ -10650,7 +10995,7 @@ function resolveCachePath(name, projectRoot) {
   if (name.length === 0 || name === "." || name === ".." || name.includes("/") || name.includes("\\")) {
     throw new Error(`MCP proxy group name must be a file-safe name: "${name}".`);
   }
-  return path11.join(resolvedProjectRoot, ".toolcraft", "mcp", `${name}.json`);
+  return path12.join(resolvedProjectRoot, ".toolcraft", "mcp", `${name}.json`);
 }
 async function assertCachePathHasNoSymlinks(filePath) {
   let currentPath = filePath;
@@ -10664,10 +11009,10 @@ async function assertCachePathHasNoSymlinks(filePath) {
         throw error3;
       }
     }
-    if (path11.basename(currentPath) === ".toolcraft") {
+    if (path12.basename(currentPath) === ".toolcraft") {
       return;
     }
-    const parentPath = path11.dirname(currentPath);
+    const parentPath = path12.dirname(currentPath);
     if (parentPath === currentPath) {
       return;
     }
@@ -10685,20 +11030,20 @@ function parseRefreshEnv(value) {
   const names = trimmed.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
   return names.length === 0 ? void 0 : new Set(names);
 }
-async function dialUpstream(name, config) {
+async function dialUpstream(name, config2) {
   const client = new McpClient({
     clientInfo: {
       name: `${DEFAULT_CLIENT_INFO.name}-${name}`,
       version: DEFAULT_CLIENT_INFO.version
     }
   });
-  const transport = config.transport === "stdio" ? new StdioTransport({
-    command: config.command,
-    ...config.args === void 0 ? {} : { args: config.args },
-    ...config.env === void 0 ? {} : { env: config.env }
+  const transport = config2.transport === "stdio" ? new StdioTransport({
+    command: config2.command,
+    ...config2.args === void 0 ? {} : { args: config2.args },
+    ...config2.env === void 0 ? {} : { env: config2.env }
   }) : new HttpTransport({
-    url: config.url,
-    ...config.headers === void 0 ? {} : { headers: config.headers }
+    url: config2.url,
+    ...config2.headers === void 0 ? {} : { headers: config2.headers }
   });
   await client.connect(transport);
   return client;
@@ -10708,10 +11053,82 @@ async function resolveMcpProxies(root, options = {}) {
   await Promise.all(groups.map((group) => resolveSingleProxy(group, options)));
 }
 
+// ../toolcraft/src/redaction.ts
+var REDACTED_VALUE = "<redacted>";
+var SENSITIVE_NAME_PARTS = ["password", "token", "apikey", "secret"];
+var AUTHORIZATION_HEADER_NAMES = /* @__PURE__ */ new Set(["authorization", "proxyauthorization"]);
+var SECRET_HEADER_NAMES = /* @__PURE__ */ new Set(["cookie", "setcookie"]);
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function isSensitiveName(name) {
+  const normalized = normalizeName(name);
+  return SENSITIVE_NAME_PARTS.some((candidate) => normalized.includes(candidate));
+}
+function redactSecretLikeFieldsValue(value, name, seen) {
+  if (name.length > 0 && isSensitiveName(name)) {
+    return REDACTED_VALUE;
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    return value.map((entry) => redactSecretLikeFieldsValue(entry, name, seen));
+  }
+  if (isPlainObject2(value)) {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    return Object.fromEntries(
+      Object.entries(value).map(([key2, entry]) => [
+        key2,
+        redactSecretLikeFieldsValue(entry, key2, seen)
+      ])
+    );
+  }
+  return value;
+}
+function redactSecretLikeFields(value, name = "") {
+  return redactSecretLikeFieldsValue(value, name, /* @__PURE__ */ new WeakSet());
+}
+function parseJsonObjectOrArray(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    return isPlainObject2(parsed) || Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function redactHttpBody(body) {
+  if (typeof body === "string") {
+    const parsed = parseJsonObjectOrArray(body);
+    return parsed === void 0 ? body : redactSecretLikeFields(parsed);
+  }
+  return redactSecretLikeFields(body);
+}
+function redactHttpHeaderValue(name, value) {
+  const normalized = normalizeName(name);
+  if (AUTHORIZATION_HEADER_NAMES.has(normalized)) {
+    return "Bearer ****";
+  }
+  if (SECRET_HEADER_NAMES.has(normalized) || isSensitiveName(name)) {
+    return REDACTED_VALUE;
+  }
+  return value;
+}
+
 // ../toolcraft/src/error-report.ts
 var ERROR_REPORTS_ENV = "TOOLCRAFT_ERROR_REPORTS";
-var DEFAULT_SENSITIVE_NAMES = ["password", "token", "apikey", "secret"];
-function isPlainObject2(value) {
+function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function unwrapOptional(schema) {
@@ -10721,7 +11138,7 @@ function unwrapOptional(schema) {
   return schema;
 }
 function hasHttpContext(error3) {
-  return error3 instanceof Error && error3.name === "HttpError" && isPlainObject2(error3.request) && isPlainObject2(error3.response);
+  return error3 instanceof Error && error3.name === "HttpError" && isPlainObject3(error3.request) && isPlainObject3(error3.response);
 }
 function isSkippedError(error3) {
   if (error3 instanceof ApprovalDeclinedError) {
@@ -10741,25 +11158,25 @@ function reportsEnabled(option, env) {
 function resolveReportDir(option, projectRoot) {
   const configuredDir = typeof option === "object" ? option.dir : void 0;
   if (configuredDir === void 0 || configuredDir.length === 0) {
-    return path12.join(projectRoot, ".toolcraft", "errors");
+    return path13.join(projectRoot, ".toolcraft", "errors");
   }
-  return path12.isAbsolute(configuredDir) ? configuredDir : path12.join(projectRoot, configuredDir);
+  return path13.isAbsolute(configuredDir) ? configuredDir : path13.join(projectRoot, configuredDir);
 }
 function reportDirMustStayWithinProject(option) {
   const configuredDir = typeof option === "object" ? option.dir : void 0;
-  return configuredDir === void 0 || configuredDir.length === 0 || !path12.isAbsolute(configuredDir);
+  return configuredDir === void 0 || configuredDir.length === 0 || !path13.isAbsolute(configuredDir);
 }
 function isWithinDirectory(parent, child) {
-  const relative = path12.relative(parent, child);
-  return relative === "" || !path12.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path12.sep}`);
+  const relative = path13.relative(parent, child);
+  return relative === "" || !path13.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path13.sep}`);
 }
 async function assertReportDirWithinProject(projectRoot, reportDir) {
-  if (!isWithinDirectory(path12.resolve(projectRoot), path12.resolve(reportDir))) {
+  if (!isWithinDirectory(path13.resolve(projectRoot), path13.resolve(reportDir))) {
     throw new Error("Error report directory resolves outside project root.");
   }
   const [canonicalProjectRoot, canonicalReportDir] = await Promise.all([
-    realpath(projectRoot),
-    realpath(reportDir)
+    realpath2(projectRoot),
+    realpath2(reportDir)
   ]);
   if (!isWithinDirectory(canonicalProjectRoot, canonicalReportDir)) {
     throw new Error("Error report directory resolves outside project root.");
@@ -10805,7 +11222,7 @@ function slugifyCommandPath(commandPath) {
   return output.length === 0 ? "root" : output;
 }
 function relativeDisplayPath(projectRoot, absolutePath) {
-  const relative = path12.relative(projectRoot, absolutePath);
+  const relative = path13.relative(projectRoot, absolutePath);
   return relative.length === 0 || relative.startsWith("..") ? absolutePath : relative;
 }
 function redactValue(value) {
@@ -10814,9 +11231,24 @@ function redactValue(value) {
   }
   return `<set, ${value.length} chars>`;
 }
-function isSensitiveName(name) {
-  const normalized = name.toLowerCase();
-  return DEFAULT_SENSITIVE_NAMES.some((candidate) => normalized.includes(candidate));
+function collectStringLeaves(value, output) {
+  if (typeof value === "string") {
+    if (value.length > 0) {
+      output.add(value);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      collectStringLeaves(entry, output);
+    }
+    return;
+  }
+  if (isPlainObject3(value)) {
+    for (const entry of Object.values(value)) {
+      collectStringLeaves(entry, output);
+    }
+  }
 }
 function schemaSecretValue(schema) {
   const unwrapped = unwrapOptional(schema);
@@ -10837,7 +11269,7 @@ function redactParamsValue(value, schema, name) {
     return "<redacted>";
   }
   const unwrapped = unwrapOptional(schema);
-  if (unwrapped.kind === "object" && isPlainObject2(value)) {
+  if (unwrapped.kind === "object" && isPlainObject3(value)) {
     return Object.fromEntries(
       Object.entries(value).map(([key2, childValue]) => {
         const childSchema = unwrapped.shape[key2];
@@ -10859,6 +11291,52 @@ function redactParams(params17, command) {
   }
   return redactParamsValue(params17, command.params, "");
 }
+function collectSensitiveParamValues(value, schema, name, output) {
+  if (shouldRedactParam(name, schema)) {
+    collectStringLeaves(value, output);
+    return;
+  }
+  const unwrapped = unwrapOptional(schema);
+  if (unwrapped.kind === "object" && isPlainObject3(value)) {
+    for (const [key2, childValue] of Object.entries(value)) {
+      const childSchema = unwrapped.shape[key2];
+      if (childSchema !== void 0) {
+        collectSensitiveParamValues(childValue, childSchema, key2, output);
+      }
+    }
+    return;
+  }
+  if (unwrapped.kind === "array" && Array.isArray(value)) {
+    for (const entry of value) {
+      collectSensitiveParamValues(entry, unwrapped.item, name, output);
+    }
+  }
+}
+function createReportStringRedactor(context, env) {
+  const values = /* @__PURE__ */ new Set();
+  for (const value of Object.values(context.secrets ?? {})) {
+    if (value !== void 0 && value.length > 0) {
+      values.add(value);
+    }
+  }
+  for (const [name, secret] of Object.entries(context.command?.secrets ?? {})) {
+    const value = context.secrets?.[name] ?? env[secret.env];
+    if (value !== void 0 && value.length > 0) {
+      values.add(value);
+    }
+  }
+  if (context.command !== void 0) {
+    collectSensitiveParamValues(context.params, context.command.params, "", values);
+  }
+  const orderedValues = [...values].sort((left, right) => right.length - left.length);
+  return (value) => {
+    let redacted = value;
+    for (const secretValue of orderedValues) {
+      redacted = redacted.split(secretValue).join("<redacted>");
+    }
+    return redacted;
+  };
+}
 function commandSecretEnvNames(secrets) {
   if (secrets === void 0) {
     return [];
@@ -10912,28 +11390,42 @@ function redactArgv(argv, options) {
 function stableJson(value) {
   return JSON.stringify(value, null, 2) ?? "undefined";
 }
-function redactStructuredErrorField(name, value) {
-  if (typeof value === "string" && name.toLowerCase() === "authorization") {
-    return "Bearer ****";
+function redactStructuredErrorField(name, value, redactString) {
+  if (typeof value === "string") {
+    const redactedHeaderValue = redactHttpHeaderValue(name, value);
+    if (redactedHeaderValue !== value) {
+      return redactedHeaderValue;
+    }
+    if (isSensitiveName(name)) {
+      return "<redacted>";
+    }
+    return redactString(value);
   }
   if (Array.isArray(value)) {
-    return value.map((entry) => redactStructuredErrorField(name, entry));
+    return value.map((entry) => redactStructuredErrorField(name, entry, redactString));
   }
-  if (isPlainObject2(value)) {
+  if (isPlainObject3(value)) {
     return Object.fromEntries(
-      Object.entries(value).map(([key2, entry]) => [key2, redactStructuredErrorField(key2, entry)])
+      Object.entries(value).map(([key2, entry]) => [
+        key2,
+        redactStructuredErrorField(key2, entry, redactString)
+      ])
     );
   }
   return value;
 }
-function ownStructuredFields(error3) {
+function ownStructuredFields(error3, redactString) {
   const fields = {};
   for (const key2 of Object.keys(error3)) {
     if (key2 === "name" || key2 === "message" || key2 === "stack" || key2 === "cause") {
       continue;
     }
     Object.defineProperty(fields, key2, {
-      value: redactStructuredErrorField(key2, error3[key2]),
+      value: redactStructuredErrorField(
+        key2,
+        error3[key2],
+        redactString
+      ),
       enumerable: true,
       configurable: true,
       writable: true
@@ -10941,43 +11433,44 @@ function ownStructuredFields(error3) {
   }
   return fields;
 }
-function formatStackChain(error3) {
+function formatStackChain(error3, redactString) {
   const lines = [];
   let current = error3;
   let index = 0;
   while (current !== void 0) {
     if (current instanceof Error) {
-      lines.push(
-        index === 0 ? current.stack ?? String(current) : `Caused by: ${current.stack ?? String(current)}`
-      );
+      const stack = current.stack ?? String(current);
+      lines.push(redactString(index === 0 ? stack : `Caused by: ${stack}`));
       current = current.cause;
     } else {
-      lines.push(index === 0 ? String(current) : `Caused by: ${String(current)}`);
+      const message2 = String(current);
+      lines.push(redactString(index === 0 ? message2 : `Caused by: ${message2}`));
       current = void 0;
     }
     index += 1;
   }
   return lines.join("\n");
 }
-function formatHeaderValue(name, value) {
-  return name.toLowerCase() === "authorization" ? "Bearer ****" : value;
+function formatHeaderValue(name, value, redactString) {
+  return redactString(redactHttpHeaderValue(name, value));
 }
-function formatHeaders(headers) {
-  return Object.entries(headers).map(([name, value]) => `${name}: ${formatHeaderValue(name, value)}`).join("\n");
+function formatHeaders(headers, redactString) {
+  return Object.entries(headers).map(([name, value]) => `${name}: ${formatHeaderValue(name, value, redactString)}`).join("\n");
 }
-function formatBody(body) {
-  if (typeof body === "string") {
-    return body;
+function formatBody(body, redactString) {
+  const redactedBody = redactHttpBody(body);
+  if (typeof redactedBody === "string") {
+    return redactString(redactedBody);
   }
-  return stableJson(body);
+  return redactString(stableJson(redactedBody));
 }
-function formatHttpTranscript(error3) {
+function formatHttpTranscript(error3, redactString) {
   const requestLines = [
     `${error3.request.method} ${error3.request.url}`,
-    formatHeaders(error3.request.headers)
+    formatHeaders(error3.request.headers, redactString)
   ].filter((line) => line.length > 0);
   if (error3.request.body !== void 0) {
-    requestLines.push("", formatBody(error3.request.body));
+    requestLines.push("", formatBody(error3.request.body, redactString));
   }
   return [
     "Request:",
@@ -10985,9 +11478,9 @@ function formatHttpTranscript(error3) {
     "",
     "Response:",
     `${error3.response.status} ${error3.response.statusText}`,
-    formatHeaders(error3.response.headers),
+    formatHeaders(error3.response.headers, redactString),
     "",
-    formatBody(error3.response.body)
+    formatBody(error3.response.body, redactString)
   ].join("\n");
 }
 function resolveToolcraftVersion(version) {
@@ -10996,9 +11489,10 @@ function resolveToolcraftVersion(version) {
 function buildReport(context) {
   const env = context.env ?? process.env;
   const error3 = context.error;
+  const redactString = createReportStringRedactor(context, env);
   const errorName = error3 instanceof Error ? error3.name : typeof error3;
-  const errorMessage = error3 instanceof Error ? error3.message : String(error3);
-  const structuredFields = error3 instanceof Error ? ownStructuredFields(error3) : {};
+  const errorMessage = redactString(error3 instanceof Error ? error3.message : String(error3));
+  const structuredFields = error3 instanceof Error ? ownStructuredFields(error3, redactString) : {};
   const secretLines = Object.entries(context.command?.secrets ?? {}).map(([name, secret]) => {
     const value = context.secrets?.[name] ?? env[secret.env];
     return `${secret.env}=${redactValue(value)}`;
@@ -11012,7 +11506,9 @@ function buildReport(context) {
     `platform: ${process.platform} ${process.arch}`,
     "",
     "Argv",
-    stableJson(redactArgv(context.argv, { command: context.command, secrets: context.secrets })),
+    redactString(
+      stableJson(redactArgv(context.argv, { command: context.command, secrets: context.secrets }))
+    ),
     "",
     "Resolved Secrets",
     ...secretLines.length === 0 ? ["<none>"] : secretLines,
@@ -11021,19 +11517,19 @@ function buildReport(context) {
     context.commandPath === void 0 || context.commandPath.length === 0 ? "root" : context.commandPath,
     "",
     "Parsed Params",
-    stableJson(redactParams(context.params, context.command)),
+    redactString(stableJson(redactParams(context.params, context.command))),
     "",
     "Error",
     `name: ${errorName}`,
     `message: ${errorMessage}`,
     "structured fields:",
-    stableJson(structuredFields),
+    redactString(stableJson(structuredFields)),
     "",
     "Stack",
-    formatStackChain(error3)
+    formatStackChain(error3, redactString)
   ];
   if (hasHttpContext(error3)) {
-    lines.push("", "HTTP Transcript", formatHttpTranscript(error3));
+    lines.push("", "HTTP Transcript", formatHttpTranscript(error3, redactString));
   }
   return `${lines.join("\n")}
 `;
@@ -11045,8 +11541,8 @@ async function writeErrorReport(context) {
   }
   const projectRoot = resolveProjectRoot(context.projectRoot);
   const reportDir = resolveReportDir(context.errorReports, projectRoot);
-  const fileName = `${formatTimestamp(/* @__PURE__ */ new Date())}-${slugifyCommandPath(context.commandPath)}-${randomUUID2()}.log`;
-  const absolutePath = path12.join(reportDir, fileName);
+  const fileName = `${formatTimestamp(/* @__PURE__ */ new Date())}-${slugifyCommandPath(context.commandPath)}-${randomUUID3()}.log`;
+  const absolutePath = path13.join(reportDir, fileName);
   await mkdir2(reportDir, { recursive: true });
   if (reportDirMustStayWithinProject(context.errorReports)) {
     await assertReportDirWithinProject(projectRoot, reportDir);
@@ -11493,6 +11989,7 @@ ${rendered.join("\n")}`);
 }
 
 // ../toolcraft/src/cli.ts
+configureTheme({ brand: "blue", label: "Toolcraft" });
 var RESERVED_SERVICE_NAMES = /* @__PURE__ */ new Set([
   "params",
   "secrets",
@@ -11510,7 +12007,7 @@ function inferProgramName(argv) {
   if (typeof entrypoint !== "string" || entrypoint.length === 0) {
     return "toolcraft";
   }
-  const parsed = path13.parse(entrypoint);
+  const parsed = path14.parse(entrypoint);
   return parsed.name.length > 0 ? parsed.name : "toolcraft";
 }
 function normalizeRoots(roots, argv) {
@@ -11568,11 +12065,11 @@ function formatSegment(segment, casing) {
   const separator = casing === "snake" ? "_" : "-";
   return splitWords3(segment).join(separator);
 }
-function toOptionFlag(path23, casing) {
-  return `--${path23.map((segment) => formatSegment(segment, casing)).join(".")}`;
+function toOptionFlag(path24, casing) {
+  return `--${path24.map((segment) => formatSegment(segment, casing)).join(".")}`;
 }
-function toOptionAttribute(path23, casing) {
-  return path23.map((segment) => {
+function toOptionAttribute(path24, casing) {
+  return path24.map((segment) => {
     const formatted = formatSegment(segment, casing);
     if (casing === "snake") {
       return formatted;
@@ -11583,23 +12080,23 @@ function toOptionAttribute(path23, casing) {
     ).join("");
   }).join(".");
 }
-function toDisplayPath(path23) {
-  return path23.join(".");
+function toDisplayPath(path24) {
+  return path24.join(".");
 }
-function toUnionKindControlPath(path23) {
-  if (path23.length === 0) {
+function toUnionKindControlPath(path24) {
+  if (path24.length === 0) {
     return ["kind"];
   }
-  const head = path23.slice(0, -1);
-  const tail = path23[path23.length - 1] ?? "";
+  const head = path24.slice(0, -1);
+  const tail = path24[path24.length - 1] ?? "";
   return [...head, `${tail}Kind`];
 }
-function toUnionKindDisplayPath(path23) {
-  if (path23.length === 0) {
+function toUnionKindDisplayPath(path24) {
+  if (path24.length === 0) {
     return "kind";
   }
-  const head = path23.slice(0, -1);
-  const tail = path23[path23.length - 1] ?? "";
+  const head = path24.slice(0, -1);
+  const tail = path24[path24.length - 1] ?? "";
   return [...head, `${tail}-kind`].join(".");
 }
 function createSyntheticEnumSchema(values) {
@@ -11615,14 +12112,14 @@ 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, globalLongOptionFlags, path23 = [], inheritedOptional = false, variantContext) {
+function collectFields(schema, casing, globalLongOptionFlags, path24 = [], inheritedOptional = false, variantContext) {
   const collected = {
     dynamicFields: [],
     fields: [],
     variants: []
   };
   for (const [key2, rawChildSchema] of Object.entries(schema.shape)) {
-    const nextPath = [...path23, key2];
+    const nextPath = [...path24, key2];
     const runtimeOptional = inheritedOptional || rawChildSchema.kind === "optional";
     const childSchema = unwrapOptional2(rawChildSchema);
     const requiredWhenActive = rawChildSchema.kind !== "optional" && childSchema.default === void 0;
@@ -11803,9 +12300,9 @@ function collectFields(schema, casing, globalLongOptionFlags, path23 = [], inher
   }
   return collected;
 }
-function toCommanderOptionAttribute(path23, casing, globalLongOptionFlags) {
-  const optionAttribute = toOptionAttribute(path23, casing);
-  const optionFlag = toOptionFlag(path23, casing);
+function toCommanderOptionAttribute(path24, casing, globalLongOptionFlags) {
+  const optionAttribute = toOptionAttribute(path24, casing);
+  const optionFlag = toOptionFlag(path24, casing);
   if (!globalLongOptionFlags.has(optionFlag)) {
     return optionAttribute;
   }
@@ -12774,10 +13271,10 @@ function parseDebugStackMode(value) {
     formatInvalidEnumMessage("--debug", String(value), ["raw"], { candidates: ["raw"] })
   );
 }
-function setNestedValue(target, path23, value) {
+function setNestedValue(target, path24, value) {
   let cursor = target;
-  for (let index = 0; index < path23.length - 1; index += 1) {
-    const segment = path23[index] ?? "";
+  for (let index = 0; index < path24.length - 1; index += 1) {
+    const segment = path24[index] ?? "";
     const existing = Object.prototype.hasOwnProperty.call(cursor, segment) ? cursor[segment] : void 0;
     if (typeof existing === "object" && existing !== null) {
       cursor = existing;
@@ -12792,7 +13289,7 @@ function setNestedValue(target, path23, value) {
     });
     cursor = next;
   }
-  const leaf = path23[path23.length - 1];
+  const leaf = path24[path24.length - 1];
   if (leaf !== void 0) {
     Object.defineProperty(cursor, leaf, {
       value,
@@ -12902,21 +13399,21 @@ async function withOutputFormat2(output, fn) {
 }
 function createFs2() {
   return {
-    readFile: async (path23, encoding = "utf8") => readFile4(path23, { encoding }),
-    writeFile: async (path23, contents) => {
-      await writeFile5(path23, contents);
+    readFile: async (path24, encoding = "utf8") => readFile4(path24, { encoding }),
+    writeFile: async (path24, contents) => {
+      await writeFile5(path24, contents);
     },
-    exists: async (path23) => {
+    exists: async (path24) => {
       try {
-        await access2(path23);
+        await access2(path24);
         return true;
       } catch {
         return false;
       }
     },
-    lstat: async (path23) => lstat3(path23),
+    lstat: async (path24) => lstat3(path24),
     rename: async (fromPath, toPath) => rename3(fromPath, toPath),
-    unlink: async (path23) => unlink2(path23)
+    unlink: async (path24) => unlink2(path24)
   };
 }
 function createEnv2(values = process.env) {
@@ -12926,15 +13423,15 @@ function createEnv2(values = process.env) {
     }
   };
 }
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasFieldValue(value) {
   return value !== void 0;
 }
-function hasNestedField(fields, path23) {
+function hasNestedField(fields, path24) {
   return fields.some(
-    (field) => path23.length < field.path.length && path23.every((segment, index) => field.path[index] === segment)
+    (field) => path24.length < field.path.length && path24.every((segment, index) => field.path[index] === segment)
   );
 }
 function describeExpectedPresetValue(schema) {
@@ -13035,14 +13532,14 @@ async function loadPresetValues(fields, presetPath) {
       { cause: error3 }
     );
   }
-  if (!isPlainObject3(parsedPreset)) {
+  if (!isPlainObject4(parsedPreset)) {
     throw new UserError(`Preset file "${presetPath}" must contain a JSON object.`);
   }
   const fieldByPath = new Map(fields.map((field) => [field.displayPath, field]));
   const presetValues = {};
-  function visitObject(current, path23) {
+  function visitObject(current, path24) {
     for (const [key2, value] of Object.entries(current)) {
-      const nextPath = [...path23, key2];
+      const nextPath = [...path24, key2];
       const displayPath = toDisplayPath(nextPath);
       const field = fieldByPath.get(displayPath);
       if (field !== void 0) {
@@ -13054,7 +13551,7 @@ async function loadPresetValues(fields, presetPath) {
           `Preset file "${presetPath}" contains unknown parameter "${displayPath}".`
         );
       }
-      if (!isPlainObject3(value)) {
+      if (!isPlainObject4(value)) {
         throw new UserError(
           `Preset file "${presetPath}" has an invalid value for "${displayPath}". Expected an object, got ${describeReceived(value)}.`
         );
@@ -13097,8 +13594,8 @@ function matchesFixtureValue(expected, actual) {
     }
     return expected.every((item, index) => matchesFixtureValue(item, actual[index]));
   }
-  if (isPlainObject3(expected)) {
-    if (!isPlainObject3(actual)) {
+  if (isPlainObject4(expected)) {
+    if (!isPlainObject4(actual)) {
       return false;
     }
     return Object.entries(expected).every(
@@ -13161,9 +13658,9 @@ function createFixtureFetch(entries) {
   };
 }
 function createFixtureFs(definition) {
-  const fsDefinition = isPlainObject3(definition) ? definition : {};
-  const readFileEntries = isPlainObject3(fsDefinition.readFile) ? fsDefinition.readFile : {};
-  const existsEntries = isPlainObject3(fsDefinition.exists) ? fsDefinition.exists : {};
+  const fsDefinition = isPlainObject4(definition) ? definition : {};
+  const readFileEntries = isPlainObject4(fsDefinition.readFile) ? fsDefinition.readFile : {};
+  const existsEntries = isPlainObject4(fsDefinition.exists) ? fsDefinition.exists : {};
   return {
     readFile: async (filePath) => {
       if (Object.prototype.hasOwnProperty.call(readFileEntries, filePath)) {
@@ -13186,10 +13683,10 @@ function createFixtureFs(definition) {
 function resolveFixtureMethodResult(methodName, definition, args) {
   if (Array.isArray(definition)) {
     for (const entry of definition) {
-      if (!isPlainObject3(entry)) {
+      if (!isPlainObject4(entry)) {
         continue;
       }
-      const explicitMatcher = isPlainObject3(entry.request) ? entry.request : void 0;
+      const explicitMatcher = isPlainObject4(entry.request) ? entry.request : void 0;
       const matcher = explicitMatcher ?? Object.fromEntries(
         Object.entries(entry).filter(
           ([key2]) => key2 !== "result" && key2 !== "response" && key2 !== "error"
@@ -13201,7 +13698,7 @@ function resolveFixtureMethodResult(methodName, definition, args) {
         matched = matchesFixtureValue(matcher.args, args);
       } else if (Object.keys(matcher).length === 0) {
         matched = true;
-      } else if (isPlainObject3(firstArg)) {
+      } else if (isPlainObject4(firstArg)) {
         matched = matchesFixtureValue(matcher, firstArg);
       } else if (args.length === 1 && Object.keys(matcher).length === 1) {
         const [[, expectedValue]] = Object.entries(matcher);
@@ -13222,7 +13719,7 @@ function resolveFixtureMethodResult(methodName, definition, args) {
       return Promise.resolve(null);
     }
   }
-  if (isPlainObject3(definition)) {
+  if (isPlainObject4(definition)) {
     const firstArg = args[0];
     if (typeof firstArg === "string" && Object.prototype.hasOwnProperty.call(definition, firstArg)) {
       return Promise.resolve(definition[firstArg]);
@@ -13234,7 +13731,7 @@ function resolveFixtureMethodResult(methodName, definition, args) {
   return Promise.resolve(null);
 }
 function createFixtureService(definition) {
-  const methods = isPlainObject3(definition) ? definition : {};
+  const methods = isPlainObject4(definition) ? definition : {};
   return new Proxy(
     {},
     {
@@ -13249,8 +13746,8 @@ function createFixtureService(definition) {
   );
 }
 function resolveFixturePath(commandPath) {
-  const parsed = path13.parse(commandPath);
-  return path13.join(parsed.dir, `${parsed.name}.fixture.json`);
+  const parsed = path14.parse(commandPath);
+  return path14.join(parsed.dir, `${parsed.name}.fixture.json`);
 }
 function selectFixtureScenario(scenarios, selector, fixturePath) {
   if (isNumericFixtureSelector(selector)) {
@@ -13332,7 +13829,7 @@ async function resolveFixtureRuntime(command, services, requirementOptions) {
     };
   }
   const scenario = await loadFixtureScenario(command, selector);
-  const scenarioServices = isPlainObject3(scenario.services) ? scenario.services : {};
+  const scenarioServices = isPlainObject4(scenario.services) ? scenario.services : {};
   const customServiceNames = /* @__PURE__ */ new Set([
     ...Object.keys(services),
     ...Object.keys(scenarioServices).filter((name) => !RESERVED_SERVICE_NAMES.has(name))
@@ -13384,8 +13881,8 @@ function validateServices(services) {
     }
   }
 }
-function getNestedValue(target, path23) {
-  return path23.reduce(
+function getNestedValue(target, path24) {
+  return path24.reduce(
     (current, segment) => current !== null && typeof current === "object" ? current[segment] : void 0,
     target
   );
@@ -13614,7 +14111,7 @@ function finalizeDynamicValue(schema, value, displayPath, errors2) {
       if (itemSchema.kind !== "object") {
         return value;
       }
-      if (!isPlainObject3(value)) {
+      if (!isPlainObject4(value)) {
         errors2.push({
           path: displayPath,
           message: `Invalid value for "${displayPath}". Expected indexed object entries, got ${describeReceived(value)}.`
@@ -13649,7 +14146,7 @@ function finalizeDynamicValue(schema, value, displayPath, errors2) {
       );
     }
     case "object": {
-      if (!isPlainObject3(value)) {
+      if (!isPlainObject4(value)) {
         errors2.push({
           path: displayPath,
           message: `Invalid value for "${displayPath}". Expected an object, got ${describeReceived(value)}.`
@@ -13680,7 +14177,7 @@ function finalizeDynamicValue(schema, value, displayPath, errors2) {
       return result;
     }
     case "record": {
-      if (!isPlainObject3(value)) {
+      if (!isPlainObject4(value)) {
         errors2.push({
           path: displayPath,
           message: `Invalid value for "${displayPath}". Expected an object, got ${describeReceived(value)}.`
@@ -14106,10 +14603,10 @@ async function executeCommand(state, services, requirementOptions, runtimeOption
   }
 }
 function isStringRecord(value) {
-  return isPlainObject3(value) && Object.values(value).every((entry) => typeof entry === "string");
+  return isPlainObject4(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
 function isHttpErrorLike(error3) {
-  if (!isPlainObject3(error3)) {
+  if (!isPlainObject4(error3)) {
     return false;
   }
   if (error3.name !== "HttpError" || typeof error3.message !== "string") {
@@ -14117,7 +14614,7 @@ function isHttpErrorLike(error3) {
   }
   const request = error3.request;
   const response = error3.response;
-  return isPlainObject3(request) && typeof request.method === "string" && typeof request.url === "string" && isStringRecord(request.headers) && isPlainObject3(response) && typeof response.status === "number" && typeof response.statusText === "string" && isStringRecord(response.headers) && "body" in response;
+  return isPlainObject4(request) && typeof request.method === "string" && typeof request.url === "string" && isStringRecord(request.headers) && isPlainObject4(response) && typeof response.status === "number" && typeof response.statusText === "string" && isStringRecord(response.headers) && "body" in response;
 }
 function hasTypedOptionalField(value, field, type2) {
   return !(field in value) || typeof value[field] === type2;
@@ -14126,7 +14623,7 @@ function isNonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
 function isProblemDetailsLike(body) {
-  if (!isPlainObject3(body)) {
+  if (!isPlainObject4(body)) {
     return false;
   }
   if (!hasTypedOptionalField(body, "type", "string")) {
@@ -14147,11 +14644,11 @@ function isProblemDetailsLike(body) {
   return isNonEmptyString(body.title) || isNonEmptyString(body.detail);
 }
 function isGraphQLErrorEnvelopeLike(body) {
-  if (!isPlainObject3(body) || !Array.isArray(body.errors) || body.errors.length === 0) {
+  if (!isPlainObject4(body) || !Array.isArray(body.errors) || body.errors.length === 0) {
     return false;
   }
   return body.errors.every((error3) => {
-    if (!isPlainObject3(error3) || typeof error3.message !== "string") {
+    if (!isPlainObject4(error3) || typeof error3.message !== "string") {
       return false;
     }
     if ("path" in error3) {
@@ -14161,7 +14658,7 @@ function isGraphQLErrorEnvelopeLike(body) {
       }
     }
     if ("extensions" in error3) {
-      if (!isPlainObject3(error3.extensions)) {
+      if (!isPlainObject4(error3.extensions)) {
         return false;
       }
       if ("code" in error3.extensions && typeof error3.extensions.code !== "string") {
@@ -14209,23 +14706,24 @@ function formatGraphQLErrorEnvelopeBody(body) {
   }).join("\n\n");
 }
 function formatHttpErrorBody(body) {
-  if (typeof body === "string") {
-    return body;
+  const redactedBody = redactHttpBody(body);
+  if (typeof redactedBody === "string") {
+    return redactedBody;
   }
-  if (isProblemDetailsLike(body)) {
-    return formatProblemDetailsBody(body);
+  if (isProblemDetailsLike(redactedBody)) {
+    return formatProblemDetailsBody(redactedBody);
   }
-  if (isGraphQLErrorEnvelopeLike(body)) {
-    return formatGraphQLErrorEnvelopeBody(body);
+  if (isGraphQLErrorEnvelopeLike(redactedBody)) {
+    return formatGraphQLErrorEnvelopeBody(redactedBody);
   }
-  const serialized = JSON.stringify(body, null, 2);
-  return serialized === void 0 ? String(body) : serialized;
+  const serialized = JSON.stringify(redactedBody, null, 2);
+  return serialized === void 0 ? String(redactedBody) : serialized;
 }
 function indentHttpErrorBlock(value) {
   return value.split("\n").map((line) => `  ${line}`).join("\n");
 }
 function formatHttpHeaderValue(name, value) {
-  return name.toLowerCase() === "authorization" ? "Bearer ****" : value;
+  return redactHttpHeaderValue(name, value);
 }
 function formatHttpErrorHeaders(headers) {
   return Object.entries(headers).map(
@@ -14243,7 +14741,11 @@ function renderHttpError(error3, options) {
   if (detailed) {
     lines.push("", "Request headers:", ...formatHttpErrorHeaders(error3.request.headers), "");
     if (error3.request.body !== void 0) {
-      lines.push("Request body:", indentHttpErrorBlock(formatHttpErrorBody(error3.request.body)), "");
+      lines.push(
+        "Request body:",
+        indentHttpErrorBlock(formatHttpErrorBody(error3.request.body)),
+        ""
+      );
     }
   }
   lines.push(
@@ -14536,7 +15038,8 @@ function configureCommanderSuggestionOutput(command) {
 }
 async function runCLI(roots, options = {}) {
   enableSourceMaps();
-  const root = mergeApprovalsGroup(normalizeRoots(roots, process.argv));
+  const normalizedRoot = normalizeRoots(roots, process.argv);
+  const root = options.approvals === false ? normalizedRoot : mergeApprovalsGroup(normalizedRoot);
   await resolveMcpProxies(root, { projectRoot: options.projectRoot });
   const casing = options.casing ?? "kebab";
   const services = options.services ?? {};
@@ -14648,7 +15151,7 @@ async function runCLI(roots, options = {}) {
 }
 
 // src/terminal-pilot.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/terminal-session.ts
 import { EventEmitter } from "node:events";
@@ -14667,7 +15170,7 @@ var DCS = 144;
 var SOS = 152;
 var PM = 158;
 var APC = 159;
-function stripAnsi3(input) {
+function stripAnsi4(input) {
   let output = "";
   for (let index = 0; index < input.length; index += 1) {
     const code = input.charCodeAt(index);
@@ -15547,7 +16050,7 @@ var TerminalScreen = class {
     cursor,
     size
   }) {
-    this.lines = Object.freeze(lines.map((line) => stripAnsi3(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 });
@@ -15702,7 +16205,7 @@ var TerminalSession = class {
     });
   }
   async history(opts) {
-    const normalized = normalizeHistoryBuffer(stripAnsi3(this.rawBuffer));
+    const normalized = normalizeHistoryBuffer(stripAnsi4(this.rawBuffer));
     const lines = splitHistoryLines(normalized);
     if (opts?.last === void 0) {
       return lines;
@@ -15835,7 +16338,7 @@ function isMissingFileError(error3) {
   return "code" in error3 && error3.code === "ENOENT";
 }
 function matchPattern(buffer, pattern) {
-  const clean = normalizeHistoryBuffer(stripAnsi3(buffer));
+  const clean = normalizeHistoryBuffer(stripAnsi4(buffer));
   for (const line of clean.split("\n")) {
     if (typeof pattern === "string") {
       if (line.includes(pattern)) return line;
@@ -15923,7 +16426,7 @@ var TerminalPilot = class _TerminalPilot {
   }
   async newSession(opts) {
     const session = new TerminalSession({
-      id: randomUUID3(),
+      id: randomUUID4(),
       command: opts.command,
       args: opts.args,
       cwd: opts.cwd,
@@ -16191,7 +16694,7 @@ var getSession = defineCommand({
 
 // ../agent-skill-config/src/configs.ts
 import os2 from "node:os";
-import path14 from "node:path";
+import path15 from "node:path";
 
 // ../agent-defs/src/agents/claude-code.ts
 var claudeCodeAgent = {
@@ -16397,11 +16900,11 @@ function resolveAgentSupport(input, registry = agentSkillConfigs) {
   if (!resolvedId) {
     return { status: "unknown", input };
   }
-  const config = registry[resolvedId];
-  if (!config) {
+  const config2 = registry[resolvedId];
+  if (!config2) {
     return { status: "unsupported", input, id: resolvedId };
   }
-  return { status: "supported", input, id: resolvedId, config: { ...config } };
+  return { status: "supported", input, id: resolvedId, config: { ...config2 } };
 }
 function getAgentConfig(agentId) {
   const support = resolveAgentSupport(agentId);
@@ -16500,7 +17003,7 @@ var templateMutation = {
 };
 
 // ../config-mutations/src/execution/apply-mutation.ts
-import path16 from "node:path";
+import path17 from "node:path";
 
 // ../config-mutations/src/formats/json.ts
 import * as jsonc from "jsonc-parser";
@@ -16538,6 +17041,13 @@ function cloneConfigValue(value) {
 function isConfigObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function detectIndent(content) {
+  const match = content.match(/^[\t ]+/m);
+  if (match) {
+    return match[0];
+  }
+  return "  ";
+}
 function parse3(content) {
   if (!content || content.trim() === "") {
     return {};
@@ -16577,6 +17087,9 @@ function merge(base, patch) {
   }
   return result;
 }
+function configValuesEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
 function prune(obj, shape) {
   let changed = false;
   const result = cloneConfigObject(obj);
@@ -16613,9 +17126,56 @@ function prune(obj, shape) {
   }
   return { changed, result };
 }
+function modifyAtPath(content, path24, value) {
+  const indent = detectIndent(content);
+  const formattingOptions = {
+    tabSize: indent === "	" ? 1 : indent.length,
+    insertSpaces: indent !== "	",
+    eol: "\n"
+  };
+  const edits = jsonc.modify(content, path24, value, { formattingOptions });
+  let result = jsonc.applyEdits(content, edits);
+  if (!result.endsWith("\n")) {
+    result += "\n";
+  }
+  return result;
+}
+function removeAtPath(content, path24) {
+  return modifyAtPath(content, path24, void 0);
+}
+function serializeUpdate(content, current, next) {
+  let result = content || "{}";
+  result = applyObjectUpdate(result, [], current, next);
+  if (!result.endsWith("\n")) {
+    result += "\n";
+  }
+  return result;
+}
+function applyObjectUpdate(content, path24, current, next) {
+  let result = content;
+  for (const key2 of Object.keys(current)) {
+    if (!hasConfigEntry(next, key2)) {
+      result = removeAtPath(result, [...path24, key2]);
+    }
+  }
+  for (const [key2, nextValue] of Object.entries(next)) {
+    const nextPath = [...path24, key2];
+    const hasCurrent = hasConfigEntry(current, key2);
+    const currentValue = hasCurrent ? current[key2] : void 0;
+    if (hasCurrent && isConfigObject(currentValue) && isConfigObject(nextValue)) {
+      result = applyObjectUpdate(result, nextPath, currentValue, nextValue);
+      continue;
+    }
+    if (!hasCurrent || !configValuesEqual(currentValue, nextValue)) {
+      result = modifyAtPath(result, nextPath, nextValue);
+    }
+  }
+  return result;
+}
 var jsonFormat = {
   parse: parse3,
   serialize,
+  serializeUpdate,
   merge,
   prune
 };
@@ -16799,20 +17359,20 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat(path23) {
-  const ext = getExtension(path23);
+function detectFormat(path24) {
+  const ext = getExtension(path24);
   return extensionMap[ext];
 }
-function getExtension(path23) {
-  const lastDot = path23.lastIndexOf(".");
+function getExtension(path24) {
+  const lastDot = path24.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path23.slice(lastDot).toLowerCase();
+  return path24.slice(lastDot).toLowerCase();
 }
 
 // ../config-mutations/src/execution/path-utils.ts
-import path15 from "node:path";
+import path16 from "node:path";
 function expandHome(targetPath, homeDir) {
   if (!targetPath?.startsWith("~")) {
     return targetPath;
@@ -16829,7 +17389,7 @@ function expandHome(targetPath, homeDir) {
       remainder = remainder.slice(1);
     }
   }
-  return remainder.length === 0 ? homeDir : path15.join(homeDir, remainder);
+  return remainder.length === 0 ? homeDir : path16.join(homeDir, remainder);
 }
 function validateHomePath(targetPath) {
   if (typeof targetPath !== "string" || targetPath.length === 0) {
@@ -16844,21 +17404,21 @@ function validateHomePath(targetPath) {
 function resolvePath(rawPath, homeDir, pathMapper) {
   validateHomePath(rawPath);
   const expanded = expandHome(rawPath, homeDir);
-  const canonicalHome = path15.resolve(homeDir);
-  const canonicalExpanded = path15.resolve(expanded);
-  const relative = path15.relative(canonicalHome, canonicalExpanded);
-  if (relative === ".." || relative.startsWith(`..${path15.sep}`) || path15.isAbsolute(relative)) {
+  const canonicalHome = path16.resolve(homeDir);
+  const canonicalExpanded = path16.resolve(expanded);
+  const relative = path16.relative(canonicalHome, canonicalExpanded);
+  if (relative === ".." || relative.startsWith(`..${path16.sep}`) || path16.isAbsolute(relative)) {
     throw new Error(`Target path resolves outside home directory: "${rawPath}"`);
   }
   if (!pathMapper) {
     return canonicalExpanded;
   }
-  const rawDirectory = path15.dirname(expanded);
+  const rawDirectory = path16.dirname(expanded);
   const mappedDirectory = pathMapper.mapTargetDirectory({
     targetDirectory: rawDirectory
   });
-  const filename = path15.basename(expanded);
-  return filename.length === 0 ? mappedDirectory : path15.join(mappedDirectory, filename);
+  const filename = path16.basename(expanded);
+  return filename.length === 0 ? mappedDirectory : path16.join(mappedDirectory, filename);
 }
 
 // ../config-mutations/src/fs-utils.ts
@@ -16922,8 +17482,8 @@ function isAlreadyExists(error3) {
   return Boolean(error3 && typeof error3 === "object" && "code" in error3 && error3.code === "EEXIST");
 }
 async function assertRegularWriteTarget(context, targetPath) {
-  const boundary = path16.dirname(path16.resolve(context.homeDir));
-  let currentPath = path16.resolve(targetPath);
+  const boundary = path17.dirname(path17.resolve(context.homeDir));
+  let currentPath = path17.resolve(targetPath);
   while (currentPath !== boundary) {
     try {
       if ((await context.fs.lstat(currentPath)).isSymbolicLink()) {
@@ -16934,7 +17494,7 @@ async function assertRegularWriteTarget(context, targetPath) {
         throw error3;
       }
     }
-    const parentPath = path16.dirname(currentPath);
+    const parentPath = path17.dirname(currentPath);
     if (parentPath === currentPath) {
       return;
     }
@@ -16997,7 +17557,7 @@ function pruneKeysByPrefix(table, prefix) {
   const result = {};
   for (const [key2, value] of Object.entries(table)) {
     if (!key2.startsWith(prefix)) {
-      result[key2] = value;
+      setConfigEntry(result, key2, value);
     }
   }
   return result;
@@ -17006,28 +17566,43 @@ function isConfigObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function mergeWithPruneByPrefix(base, patch, pruneByPrefix) {
-  const result = { ...base };
+  const result = cloneConfigObject(base);
   const prefixMap = pruneByPrefix ?? {};
   for (const [key2, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
     const current = result[key2];
     const prefix = prefixMap[key2];
     if (isConfigObject4(current) && isConfigObject4(value)) {
       if (prefix) {
         const pruned = pruneKeysByPrefix(current, prefix);
-        result[key2] = { ...pruned, ...value };
+        setConfigEntry(result, key2, mergePrunedConfigObject(pruned, value));
       } else {
-        result[key2] = mergeWithPruneByPrefix(
-          current,
-          value,
-          prefixMap
-        );
+        setConfigEntry(result, key2, mergeWithPruneByPrefix(current, value, prefixMap));
       }
       continue;
     }
-    result[key2] = value;
+    setConfigEntry(result, key2, value);
   }
   return result;
 }
+function mergePrunedConfigObject(base, patch) {
+  const result = cloneConfigObject(base);
+  for (const [key2, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    setConfigEntry(result, key2, value);
+  }
+  return result;
+}
+function serializeConfigUpdate(format, rawContent, current, next) {
+  if (rawContent !== null && format.serializeUpdate) {
+    return format.serializeUpdate(rawContent, current, next);
+  }
+  return format.serialize(next);
+}
 async function applyMutation(mutation, context, options) {
   switch (mutation.kind) {
     case "ensureDirectory":
@@ -17340,6 +17915,7 @@ async function applyConfigMerge(mutation, context, options) {
   }
   const format = getConfigFormat(formatName);
   const rawContent = await readFileIfExists(context.fs, targetPath);
+  let preserveContent = rawContent;
   let current;
   try {
     current = rawContent === null ? {} : format.parse(rawContent);
@@ -17348,6 +17924,7 @@ async function applyConfigMerge(mutation, context, options) {
       await backupInvalidDocument(context, targetPath, rawContent);
     }
     current = {};
+    preserveContent = null;
   }
   const value = resolveValue(mutation.value, options);
   let merged;
@@ -17356,7 +17933,7 @@ async function applyConfigMerge(mutation, context, options) {
   } else {
     merged = format.merge(current, value);
   }
-  const serialized = format.serialize(merged);
+  const serialized = serializeConfigUpdate(format, preserveContent, current, merged);
   const changed = serialized !== rawContent;
   if (changed && !context.dryRun) {
     await writeAtomically2(context, targetPath, serialized);
@@ -17424,7 +18001,7 @@ async function applyConfigPrune(mutation, context, options) {
       details
     };
   }
-  const serialized = format.serialize(result);
+  const serialized = serializeConfigUpdate(format, rawContent, current, result);
   if (!context.dryRun) {
     await writeAtomically2(context, targetPath, serialized);
   }
@@ -17449,6 +18026,7 @@ async function applyConfigTransform(mutation, context, options) {
   }
   const format = getConfigFormat(formatName);
   const rawContent = await readFileIfExists(context.fs, targetPath);
+  let preserveContent = rawContent;
   let current;
   try {
     current = rawContent === null ? {} : format.parse(rawContent);
@@ -17457,6 +18035,7 @@ async function applyConfigTransform(mutation, context, options) {
       await backupInvalidDocument(context, targetPath, rawContent);
     }
     current = {};
+    preserveContent = null;
   }
   const { content: transformed, changed } = mutation.transform(current, options);
   if (!changed) {
@@ -17480,7 +18059,7 @@ async function applyConfigTransform(mutation, context, options) {
       details
     };
   }
-  const serialized = format.serialize(transformed);
+  const serialized = serializeConfigUpdate(format, preserveContent, current, transformed);
   if (!context.dryRun) {
     await writeAtomically2(context, targetPath, serialized);
   }
@@ -17622,7 +18201,7 @@ async function executeMutation(mutation, context, options) {
 
 // ../agent-skill-config/src/templates.ts
 import { readFile as readFile5, stat } from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // ../agent-skill-config/src/apply.ts
@@ -17657,14 +18236,14 @@ async function installSkill(agentId, skill, options) {
     throw new UnsupportedAgentError(agentId);
   }
   const scope = options.scope ?? "local";
-  const config = support.config;
+  const config2 = support.config;
   if (skill.name.length === 0 || skill.name === "." || skill.name === ".." || skill.name.includes("/") || skill.name.includes("\\") || skill.name.includes("\n") || skill.name.includes("\r")) {
     throw new Error(`Invalid skill name: ${skill.name}`);
   }
-  const skillDir = scope === "global" ? config.globalSkillDir : toHomeRelative(config.localSkillDir);
+  const skillDir = scope === "global" ? config2.globalSkillDir : toHomeRelative(config2.localSkillDir);
   const skillFolderPath = `${skillDir}/${skill.name}`;
   const skillFilePath = `${skillFolderPath}/SKILL.md`;
-  const displayPath = `${scope === "global" ? config.globalSkillDir : config.localSkillDir}/${skill.name}/SKILL.md`;
+  const displayPath = `${scope === "global" ? config2.globalSkillDir : config2.localSkillDir}/${skill.name}/SKILL.md`;
   const absoluteSkillPath = `${scope === "global" ? options.homeDir : options.cwd}/${skillFilePath.slice(2)}`;
   if (await pathExists2(options.fs, absoluteSkillPath)) {
     throw new Error(`Skill already exists: ${displayPath}`);
@@ -17699,21 +18278,21 @@ async function installSkill(agentId, skill, options) {
 
 // ../agent-skill-config/src/resolve-skill-reference.ts
 import { statSync as statSync2 } from "node:fs";
-import path18 from "node:path";
+import path19 from "node:path";
 
 // ../agent-skill-config/src/git-exclude.ts
 import { execFileSync } from "node:child_process";
 import * as fs2 from "node:fs";
-import path19 from "node:path";
+import path20 from "node:path";
 
 // ../agent-skill-config/src/bridge-active-skills.ts
 import * as fs3 from "node:fs";
-import { createHash as createHash4, randomUUID as randomUUID4 } from "node:crypto";
-import path20 from "node:path";
+import { createHash as createHash4, randomUUID as randomUUID5 } from "node:crypto";
+import path21 from "node:path";
 
 // src/commands/installer.ts
 import os3 from "node:os";
-import path21 from "node:path";
+import path22 from "node:path";
 import * as nodeFs2 from "node:fs/promises";
 import { readFile as readFile6 } from "node:fs/promises";
 var DEFAULT_INSTALL_AGENT = "claude-code";
@@ -17780,28 +18359,28 @@ function resolveHomeRelativePath(targetPath, homeDir) {
     return homeDir;
   }
   if (targetPath.startsWith("~/")) {
-    return path21.join(homeDir, targetPath.slice(2));
+    return path22.join(homeDir, targetPath.slice(2));
   }
   return targetPath;
 }
 function getSkillFolderWithHome(agent, scope, cwd, homeDir) {
-  const config = getAgentConfig(agent);
-  if (!config) {
+  const config2 = getAgentConfig(agent);
+  if (!config2) {
     throwUnsupportedAgent(agent);
   }
   return {
-    displayPath: path21.join(
-      scope === "global" ? config.globalSkillDir : config.localSkillDir,
+    displayPath: path22.join(
+      scope === "global" ? config2.globalSkillDir : config2.localSkillDir,
       TERMINAL_PILOT_SKILL_NAME
     ),
-    fullPath: path21.join(
-      scope === "global" ? resolveHomeRelativePath(config.globalSkillDir, homeDir) : path21.resolve(cwd, config.localSkillDir),
+    fullPath: path22.join(
+      scope === "global" ? resolveHomeRelativePath(config2.globalSkillDir, homeDir) : path22.resolve(cwd, config2.localSkillDir),
       TERMINAL_PILOT_SKILL_NAME
     )
   };
 }
 async function assertNoSymbolicLinkPath(fs4, targetPath) {
-  const rootPath = path21.parse(targetPath).root;
+  const rootPath = path22.parse(targetPath).root;
   let currentPath = targetPath;
   while (currentPath !== rootPath) {
     try {
@@ -17813,7 +18392,7 @@ async function assertNoSymbolicLinkPath(fs4, targetPath) {
         throw error3;
       }
     }
-    currentPath = path21.dirname(currentPath);
+    currentPath = path22.dirname(currentPath);
   }
 }
 
@@ -17952,7 +18531,7 @@ var resize = defineCommand({
 });
 
 // ../terminal-png/src/index.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { rename as rename4, rm, writeFile as writeFile6 } from "node:fs/promises";
 
 // ../terminal-png/src/ansi-parser.ts
@@ -18892,7 +19471,7 @@ async function renderTerminalPng(ansiText, options = {}) {
   });
   const png = renderPng(svg);
   if (options.output) {
-    const temporaryPath = `${options.output}.${randomUUID5()}.tmp`;
+    const temporaryPath = `${options.output}.${randomUUID6()}.tmp`;
     try {
       await writeFile6(temporaryPath, png, { flag: "wx" });
       await rename4(temporaryPath, options.output);
@@ -18969,7 +19548,7 @@ var type = defineCommand({
 });
 
 // src/commands/uninstall.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 var params14 = S.Object({
   agent: S.Enum(installableAgents, {
     description: "Agent to uninstall terminal-pilot from",
@@ -19005,7 +19584,7 @@ var uninstall = defineCommand({
         if (!await folderExists(services.fs, skill.fullPath)) {
           continue;
         }
-        const stagingPath = `${skill.fullPath}.removing-${randomUUID6()}`;
+        const stagingPath = `${skill.fullPath}.removing-${randomUUID7()}`;
         await services.fs.rename(skill.fullPath, stagingPath);
         staged.push({ ...skill, stagingPath });
       }
@@ -19112,6 +19691,7 @@ function createTerminalPilotGroup() {
 var terminalPilotGroup = Object.freeze(createTerminalPilotGroup());
 
 // src/cli.ts
+configureTheme({ brand: "green", label: "Terminal Pilot" });
 function normalizeArgv(argv) {
   if (argv.includes("--json") && !argv.some((argument) => argument === "--output" || argument.startsWith("--output="))) {
     return argv.flatMap((argument) => argument === "--json" ? ["--output", "json"] : [argument]);
@@ -19135,8 +19715,8 @@ async function isDirectExecution(argv) {
   try {
     const modulePath = fileURLToPath5(import.meta.url);
     const [resolvedEntryPoint, resolvedModulePath] = await Promise.all([
-      realpath2(path22.resolve(entryPoint)),
-      realpath2(modulePath)
+      realpath3(path23.resolve(entryPoint)),
+      realpath3(modulePath)
     ]);
     return resolvedEntryPoint === resolvedModulePath;
   } catch {