terminal-pilot 0.0.30 → 0.0.32

package/dist/commands/install.js

@@ -727,7 +727,54 @@ var symbols = {
 
 // ../toolcraft-design/src/internal/strip-ansi.ts
 function stripAnsi(value) {
-  return value.replace(/\u001b\[[0-9;]*m/g, "");
+  let output = "";
+  let index = 0;
+  while (index < value.length) {
+    const char = value[index];
+    if (char === "\x1B") {
+      index = skipEscapeSequence(value, index);
+      continue;
+    }
+    if (char === "\x9B") {
+      index = skipCsiSequence(value, index + 1);
+      continue;
+    }
+    output += char;
+    index += char.length;
+  }
+  return output;
+}
+function skipEscapeSequence(value, index) {
+  const next = value[index + 1];
+  if (next === "[") {
+    return skipCsiSequence(value, index + 2);
+  }
+  if (next === "]") {
+    return skipOscSequence(value, index + 2);
+  }
+  return Math.min(value.length, index + 2);
+}
+function skipCsiSequence(value, index) {
+  while (index < value.length) {
+    const codePoint = value.charCodeAt(index);
+    index += 1;
+    if (codePoint >= 64 && codePoint <= 126) {
+      break;
+    }
+  }
+  return index;
+}
+function skipOscSequence(value, index) {
+  while (index < value.length) {
+    if (value[index] === "\x07") {
+      return index + 1;
+    }
+    if (value[index] === "\x1B" && value[index + 1] === "\\") {
+      return index + 2;
+    }
+    index += 1;
+  }
+  return index;
 }
 
 // ../toolcraft-design/src/prompts/primitives/log.ts
@@ -924,6 +971,10 @@ var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 // ../toolcraft-design/src/components/table.ts
 var graphemeSegmenter2 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 
+// ../toolcraft-design/src/components/detail-card.ts
+import stringWidth from "fast-string-width";
+import { wrapAnsi } from "fast-wrap-ansi";
+
 // ../toolcraft-design/src/components/template.ts
 var MAX_PARTIAL_DEPTH = 100;
 var HTML_ESCAPE = {
@@ -1346,13 +1397,13 @@ import { LineCounter, parse, parseDocument } from "yaml";
 // ../frontmatter/src/stringify.ts
 import { stringify } from "yaml";
 
+// ../toolcraft-design/src/dashboard/terminal-width.ts
+var graphemeSegmenter3 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+
 // ../toolcraft-design/src/acp/writer.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var storage = new AsyncLocalStorage2();
 
-// ../toolcraft-design/src/dashboard/terminal-width.ts
-var graphemeSegmenter3 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-
 // ../toolcraft-design/src/dashboard/terminal.ts
 import readline from "node:readline";
 import { PassThrough } from "node:stream";
@@ -1401,11 +1452,11 @@ import { EventEmitter } from "node:events";
 import * as readline2 from "node:readline";
 
 // ../toolcraft-design/src/prompts/interactive/wrap.ts
-import { wrapAnsi } from "fast-wrap-ansi";
-import stringWidth from "fast-string-width";
+import { wrapAnsi as wrapAnsi2 } from "fast-wrap-ansi";
+import stringWidth2 from "fast-string-width";
 
 // ../toolcraft-design/src/prompts/interactive/pagination.ts
-import { wrapAnsi as wrapAnsi2 } from "fast-wrap-ansi";
+import { wrapAnsi as wrapAnsi3 } from "fast-wrap-ansi";
 
 // ../toolcraft-design/src/static/spinner.ts
 var SPINNER_FRAMES = Object.freeze(["\u25D2", "\u25D0", "\u25D3", "\u25D1"]);
@@ -1835,9 +1886,9 @@ function hasOwnErrorCode(error2, code) {
 function isNotFound(error2) {
   return hasOwnErrorCode(error2, "ENOENT");
 }
-async function readFileIfExists(fs3, target) {
+async function readFileIfExists(fs4, target) {
   try {
-    return await fs3.readFile(target, "utf8");
+    return await fs4.readFile(target, "utf8");
   } catch (error2) {
     if (isNotFound(error2)) {
       return null;
@@ -1845,9 +1896,9 @@ async function readFileIfExists(fs3, target) {
     throw error2;
   }
 }
-async function pathExists(fs3, target) {
+async function pathExists(fs4, target) {
   try {
-    await fs3.stat(target);
+    await fs4.stat(target);
     return true;
   } catch (error2) {
     if (isNotFound(error2)) {
@@ -1970,6 +2021,56 @@ function describeMutation(kind, targetPath) {
       return "Operation";
   }
 }
+function mutationTargetPath(mutation, options) {
+  switch (mutation.kind) {
+    case "ensureDirectory":
+    case "removeDirectory":
+      return resolveValue(mutation.path, options);
+    case "removeFile":
+    case "chmod":
+    case "backup":
+    case "restoreBackup":
+    case "configMerge":
+    case "configPrune":
+    case "configTransform":
+    case "templateWrite":
+    case "templateMergeToml":
+    case "templateMergeJson":
+      return resolveValue(mutation.target, options);
+    default:
+      return void 0;
+  }
+}
+function resolveMutationDetails(mutation, context, options) {
+  try {
+    const rawTarget = mutationTargetPath(mutation, options);
+    if (rawTarget === void 0) {
+      return {
+        kind: mutation.kind,
+        label: mutation.label ?? mutation.kind
+      };
+    }
+    try {
+      const targetPath = resolvePath(rawTarget, context.homeDir, context.pathMapper);
+      return {
+        kind: mutation.kind,
+        label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+        targetPath
+      };
+    } catch {
+      return {
+        kind: mutation.kind,
+        label: mutation.label ?? describeMutation(mutation.kind, rawTarget),
+        targetPath: void 0
+      };
+    }
+  } catch {
+    return {
+      kind: mutation.kind,
+      label: mutation.label ?? mutation.kind
+    };
+  }
+}
 function pruneKeysByPrefix(table, prefix) {
   const result = {};
   for (const [key, value] of Object.entries(table)) {
@@ -2060,6 +2161,7 @@ async function applyEnsureDirectory(mutation, context, options) {
     label: mutation.label ?? describeMutation(mutation.kind, targetPath),
     targetPath
   };
+  await assertRegularWriteTarget(context, targetPath);
   const existed = await pathExists(context.fs, targetPath);
   if (!context.dryRun) {
     await context.fs.mkdir(targetPath, { recursive: true });
@@ -2176,6 +2278,7 @@ async function applyChmod(mutation, context, options) {
     };
   }
   try {
+    await assertRegularWriteTarget(context, targetPath);
     const stat2 = await context.fs.stat(targetPath);
     const currentMode = typeof stat2.mode === "number" ? stat2.mode & 511 : null;
     if (currentMode === mutation.mode) {
@@ -2209,6 +2312,7 @@ async function applyBackup(mutation, context, options) {
     label: mutation.label ?? describeMutation(mutation.kind, targetPath),
     targetPath
   };
+  await assertRegularWriteTarget(context, targetPath);
   if (mutation.once && await findLatestGeneratedBackup(context.fs, targetPath) !== null) {
     return {
       outcome: { changed: false, effect: "none", detail: "noop" },
@@ -2275,13 +2379,13 @@ async function applyRestoreBackup(mutation, context, options) {
   }
   return { outcome: { changed: true, effect: "copy", detail: "restore" }, details };
 }
-async function findLatestGeneratedBackup(fs3, targetPath) {
+async function findLatestGeneratedBackup(fs4, targetPath) {
   const separatorIndex = targetPath.lastIndexOf("/");
   const directoryPath = separatorIndex <= 0 ? "/" : targetPath.slice(0, separatorIndex);
   const targetName = targetPath.slice(separatorIndex + 1);
   let entries;
   try {
-    entries = await fs3.readdir(directoryPath);
+    entries = await fs4.readdir(directoryPath);
   } catch (error2) {
     if (isNotFound(error2)) {
       return null;
@@ -2345,6 +2449,9 @@ async function applyConfigMerge(mutation, context, options) {
     preserveContent = null;
   }
   const value = resolveValue(mutation.value, options);
+  if (!isConfigObject4(value)) {
+    throw new Error(`configMerge value must be an object for "${rawPath}".`);
+  }
   let merged;
   if (mutation.pruneByPrefix) {
     merged = mergeWithPruneByPrefix(current, value, mutation.pruneByPrefix);
@@ -2478,6 +2585,13 @@ async function applyConfigTransform(mutation, context, options) {
     };
   }
   const serialized = serializeConfigUpdate(format, preserveContent, current, transformed);
+  const serializedChanged = serialized !== rawContent;
+  if (!serializedChanged) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
   if (!context.dryRun) {
     await writeAtomically(context, targetPath, serialized);
   }
@@ -2594,25 +2708,14 @@ async function runMutations(mutations, context, options) {
   };
 }
 async function executeMutation(mutation, context, options) {
-  context.observers?.onStart?.({
-    kind: mutation.kind,
-    label: mutation.label ?? mutation.kind,
-    targetPath: void 0
-    // Will be resolved during apply
-  });
+  const pendingDetails = resolveMutationDetails(mutation, context, options);
+  context.observers?.onStart?.(pendingDetails);
   try {
     const { outcome, details } = await applyMutation(mutation, context, options);
     context.observers?.onComplete?.(details, outcome);
     return { outcome, details };
   } catch (error2) {
-    context.observers?.onError?.(
-      {
-        kind: mutation.kind,
-        label: mutation.label ?? mutation.kind,
-        targetPath: void 0
-      },
-      error2
-    );
+    context.observers?.onError?.(pendingDetails, error2);
     throw error2;
   }
 }
@@ -2641,9 +2744,9 @@ function toHomeRelative(localSkillDir) {
   const normalized = localSkillDir.startsWith("./") ? localSkillDir.slice(2) : localSkillDir;
   return `~/${normalized}`;
 }
-async function pathExists2(fs3, targetPath) {
+async function pathExists2(fs4, targetPath) {
   try {
-    await fs3.stat(targetPath);
+    await fs4.stat(targetPath);
     return true;
   } catch (error2) {
     if (hasOwnErrorCode2(error2, "ENOENT")) {
@@ -2660,7 +2763,7 @@ async function installSkill(agentId, skill, options) {
   }
   const scope = options.scope ?? "local";
   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")) {
+  if (skill.name.length === 0 || skill.name !== skill.name.trim() || 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" ? config2.globalSkillDir : toHomeRelative(config2.localSkillDir);
@@ -2696,21 +2799,21 @@ async function installSkill(agentId, skill, options) {
       }
     }
   );
-  return { skillPath: skillFilePath, displayPath };
+  return { skillPath: absoluteSkillPath, displayPath };
 }
 
 // ../agent-skill-config/src/resolve-skill-reference.ts
-import { statSync } from "node:fs";
+import * as fs from "node:fs";
 import path5 from "node:path";
 
 // ../agent-skill-config/src/git-exclude.ts
 import { execFileSync } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as fs from "node:fs";
+import * as fs2 from "node:fs";
 import path6 from "node:path";
 
 // ../agent-skill-config/src/bridge-active-skills.ts
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 import { createHash, randomUUID as randomUUID3 } from "node:crypto";
 import path7 from "node:path";
 
@@ -2792,6 +2895,9 @@ function isOptionalSchema(schema) {
 function getRequiredKeys(schema) {
   return Object.keys(schema.shape).filter((key) => !isOptionalSchema(schema.shape[key])).sort();
 }
+function getRequiredKeyFingerprint(schema) {
+  return getRequiredKeys(schema).join("+");
+}
 function assertUniqueRequiredKeyFingerprints(branches) {
   const fingerprints = /* @__PURE__ */ new Map();
   branches.forEach((branch, index) => {
@@ -2829,6 +2935,451 @@ function Union(branches) {
   };
 }
 
+// ../toolcraft-schema/src/validate.ts
+var missingValue = /* @__PURE__ */ Symbol("missingValue");
+function validate(schema, value) {
+  const state = { issues: [] };
+  const result = walkSchema(schema, value, [], state);
+  if (state.issues.length > 0) {
+    return { ok: false, issues: state.issues };
+  }
+  return { ok: true, value: result.present ? result.value : void 0 };
+}
+function walkSchema(schema, value, path10, state) {
+  if (schema.kind === "optional") {
+    return walkOptional(schema, value, path10, state);
+  }
+  if (value === missingValue) {
+    addIssue(
+      state,
+      path10,
+      expectedFor(schema),
+      "missing",
+      `Expected ${expectedFor(schema)} at ${formatPath(path10)}`
+    );
+    return { present: false };
+  }
+  if (value === null && schema.nullable === true) {
+    return { present: true, value };
+  }
+  switch (schema.kind) {
+    case "string":
+      return walkString(schema, value, path10, state);
+    case "number":
+      return walkNumber(schema, value, path10, state);
+    case "boolean":
+      return walkBoolean(value, path10, state);
+    case "enum":
+      return walkEnum(schema, value, path10, state);
+    case "array":
+      return walkArray(schema, value, path10, state);
+    case "object":
+      return walkObject(schema, value, path10, state);
+    case "oneOf":
+      return walkOneOf(schema, value, path10, state);
+    case "union":
+      return walkUnion(schema, value, path10, state);
+    case "record":
+      return walkRecord(schema, value, path10, state);
+    case "json":
+      return walkJson(value, path10, state);
+  }
+}
+function walkOptional(schema, value, path10, state) {
+  if (value === missingValue || value === void 0) {
+    const defaultValue = getDefault(schema.inner);
+    if (defaultValue.present) {
+      return walkSchema(schema.inner, cloneDefault(defaultValue.value), path10, state);
+    }
+    return { present: false };
+  }
+  return walkSchema(schema.inner, value, path10, state);
+}
+function walkString(schema, value, path10, state) {
+  if (typeof value !== "string") {
+    addExpectedIssue(state, path10, "string", value);
+    return { present: true, value };
+  }
+  if (schema.minLength !== void 0 && value.length < schema.minLength) {
+    const expected = `string with length at least ${schema.minLength}`;
+    addIssue(
+      state,
+      path10,
+      expected,
+      `string with length ${value.length}`,
+      `Expected ${expected} at ${formatPath(path10)}`
+    );
+  }
+  if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+    const expected = `string with length at most ${schema.maxLength}`;
+    addIssue(
+      state,
+      path10,
+      expected,
+      `string with length ${value.length}`,
+      `Expected ${expected} at ${formatPath(path10)}`
+    );
+  }
+  if (schema.pattern !== void 0) {
+    const pattern = compilePattern(schema.pattern);
+    if (pattern === void 0 || !pattern.test(value)) {
+      const expected = `string matching pattern ${schema.pattern}`;
+      addIssue(state, path10, expected, value, `Expected ${expected} at ${formatPath(path10)}`);
+    }
+  }
+  return { present: true, value };
+}
+function walkNumber(schema, value, path10, state) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    addExpectedIssue(state, path10, schema.jsonType === "integer" ? "integer" : "number", value);
+    return { present: true, value };
+  }
+  if (schema.jsonType === "integer" && !Number.isInteger(value)) {
+    addExpectedIssue(state, path10, "integer", value);
+  }
+  if (schema.minimum !== void 0 && value < schema.minimum) {
+    const expected = `number greater than or equal to ${schema.minimum}`;
+    addIssue(state, path10, expected, String(value), `Expected ${expected} at ${formatPath(path10)}`);
+  }
+  if (schema.maximum !== void 0 && value > schema.maximum) {
+    const expected = `number less than or equal to ${schema.maximum}`;
+    addIssue(state, path10, expected, String(value), `Expected ${expected} at ${formatPath(path10)}`);
+  }
+  return { present: true, value };
+}
+function walkBoolean(value, path10, state) {
+  if (typeof value !== "boolean") {
+    addExpectedIssue(state, path10, "boolean", value);
+  }
+  return { present: true, value };
+}
+function walkEnum(schema, value, path10, state) {
+  if (!schema.values.includes(value)) {
+    const expected = `one of ${schema.values.join(", ")}`;
+    addIssue(
+      state,
+      path10,
+      expected,
+      receivedValue(value),
+      `Expected ${expected} at ${formatPath(path10)}`
+    );
+  }
+  return { present: true, value };
+}
+function walkArray(schema, value, path10, state) {
+  if (!Array.isArray(value)) {
+    addExpectedIssue(state, path10, "array", value);
+    return { present: true, value };
+  }
+  if (schema.minItems !== void 0 && value.length < schema.minItems) {
+    const expected = `array with at least ${schema.minItems} items`;
+    addIssue(
+      state,
+      path10,
+      expected,
+      `array with ${value.length} items`,
+      `Expected ${expected} at ${formatPath(path10)}`
+    );
+  }
+  if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
+    const expected = `array with at most ${schema.maxItems} items`;
+    addIssue(
+      state,
+      path10,
+      expected,
+      `array with ${value.length} items`,
+      `Expected ${expected} at ${formatPath(path10)}`
+    );
+  }
+  const nextValue = value.map((item, index) => {
+    const result = walkSchema(schema.item, item, [...path10, String(index)], state);
+    return result.present ? result.value : item;
+  });
+  return { present: true, value: nextValue };
+}
+function walkObject(schema, value, path10, state, injectedProperties = {}) {
+  if (!isPlainRecord(value)) {
+    addExpectedIssue(state, path10, "object", value);
+    return { present: true, value };
+  }
+  const nextValue = {};
+  const allowedKeys = /* @__PURE__ */ new Set([...Object.keys(schema.shape), ...Object.keys(injectedProperties)]);
+  for (const [key, propertySchema] of Object.entries(schema.shape)) {
+    const propertyValue = Object.hasOwn(value, key) ? value[key] : missingValue;
+    const result = walkSchema(propertySchema, propertyValue, [...path10, key], state);
+    if (result.present) {
+      setOwnValue(nextValue, key, result.value);
+    }
+  }
+  for (const [key, injectedValue] of Object.entries(injectedProperties)) {
+    if (Object.hasOwn(value, key)) {
+      setOwnValue(nextValue, key, value[key]);
+    } else {
+      setOwnValue(nextValue, key, injectedValue);
+    }
+  }
+  for (const [key, propertyValue] of Object.entries(value)) {
+    if (allowedKeys.has(key)) {
+      continue;
+    }
+    if (schema.additionalProperties === true) {
+      setOwnValue(nextValue, key, propertyValue);
+    } else {
+      addUnexpectedPropertyIssue(state, [...path10, key]);
+    }
+  }
+  return { present: true, value: nextValue };
+}
+function walkOneOf(schema, value, path10, state) {
+  if (!isPlainRecord(value)) {
+    addExpectedIssue(state, path10, "object", value);
+    return { present: true, value };
+  }
+  const discriminatorValue = value[schema.discriminator];
+  const discriminatorPath = [...path10, schema.discriminator];
+  const branchValues = Object.keys(schema.branches);
+  const expected = `one of ${branchValues.join(", ")}`;
+  if (!Object.hasOwn(value, schema.discriminator)) {
+    addIssueWithMessage(
+      state,
+      discriminatorPath,
+      expected,
+      "missing",
+      `Missing discriminator "${schema.discriminator}" at ${formatPath(path10)}. Expected one of: ${branchValues.join(", ")}.`
+    );
+    return { present: true, value };
+  }
+  if (typeof discriminatorValue !== "string" || !Object.hasOwn(schema.branches, discriminatorValue)) {
+    addIssueWithMessage(
+      state,
+      discriminatorPath,
+      expected,
+      receivedValue(discriminatorValue),
+      `Expected ${expected} at ${formatPath(discriminatorPath)}, got ${formatReceivedDiscriminator(discriminatorValue)}`
+    );
+    return { present: true, value };
+  }
+  return walkObject(schema.branches[discriminatorValue], value, path10, state, {
+    [schema.discriminator]: discriminatorValue
+  });
+}
+function walkUnion(schema, value, path10, state) {
+  if (isPlainRecord(value)) {
+    const candidateBranches = schema.branches.filter((branch) => hasRequiredKeys(branch, value));
+    if (candidateBranches.length === 1) {
+      return walkObject(candidateBranches[0], value, path10, state);
+    }
+  }
+  const matches = [];
+  for (const branch of schema.branches) {
+    const branchState = { issues: [] };
+    const result = walkObject(branch, value, path10, branchState);
+    if (branchState.issues.length === 0 && result.present) {
+      matches.push({ fingerprint: getRequiredKeyFingerprint(branch), value: result.value });
+    }
+  }
+  if (matches.length === 1) {
+    return { present: true, value: matches[0].value };
+  }
+  if (matches.length === 0) {
+    const branchDescriptions = schema.branches.map((branch) => getRequiredKeyFingerprint(branch));
+    addIssueWithMessage(
+      state,
+      path10,
+      "exactly one union branch",
+      "0 matching branches",
+      `No union branch matched at ${formatPath(path10)}. Tried ${schema.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`
+    );
+    return { present: true, value };
+  }
+  addIssueWithMessage(
+    state,
+    path10,
+    "exactly one union branch",
+    `${matches.length} matching branches`,
+    `Expected exactly one union branch at ${formatPath(path10)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`
+  );
+  return { present: true, value };
+}
+function hasRequiredKeys(schema, value) {
+  for (const [key, propertySchema] of Object.entries(schema.shape)) {
+    if (propertySchema.kind !== "optional" && !Object.hasOwn(value, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+function walkRecord(schema, value, path10, state) {
+  if (!isPlainRecord(value)) {
+    addExpectedIssue(state, path10, "object", value);
+    return { present: true, value };
+  }
+  const nextValue = {};
+  for (const [key, propertyValue] of Object.entries(value)) {
+    const result = walkSchema(schema.value, propertyValue, [...path10, key], state);
+    if (result.present) {
+      setOwnValue(nextValue, key, result.value);
+    }
+  }
+  return { present: true, value: nextValue };
+}
+function walkJson(value, path10, state) {
+  if (isJsonValue(value)) {
+    return { present: true, value };
+  }
+  addExpectedIssue(state, path10, "JSON value", value);
+  return { present: true, value };
+}
+function getDefault(schema) {
+  if (schema.default !== void 0) {
+    return { present: true, value: schema.default };
+  }
+  if (schema.kind === "optional") {
+    return getDefault(schema.inner);
+  }
+  return { present: false };
+}
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isJsonValue(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return typeof value !== "number" || Number.isFinite(value);
+  }
+  if (Array.isArray(value)) {
+    if (ancestors.has(value)) {
+      return false;
+    }
+    ancestors.add(value);
+    const result = value.every((item) => isJsonValue(item, ancestors));
+    ancestors.delete(value);
+    return result;
+  }
+  if (isPlainRecord(value)) {
+    if (ancestors.has(value)) {
+      return false;
+    }
+    ancestors.add(value);
+    const result = Object.values(value).every((item) => isJsonValue(item, ancestors));
+    ancestors.delete(value);
+    return result;
+  }
+  return false;
+}
+function cloneDefault(value) {
+  return structuredClone(value);
+}
+function setOwnValue(target, key, value) {
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value
+  });
+}
+function expectedFor(schema) {
+  switch (schema.kind) {
+    case "string":
+      return "string";
+    case "number":
+      return schema.jsonType === "integer" ? "integer" : "number";
+    case "boolean":
+      return "boolean";
+    case "enum":
+      return `one of ${schema.values.join(", ")}`;
+    case "array":
+      return "array";
+    case "object":
+    case "oneOf":
+    case "record":
+      return "object";
+    case "union":
+      return "exactly one union branch";
+    case "json":
+      return "JSON value";
+    case "optional":
+      return expectedFor(schema.inner);
+  }
+}
+function addExpectedIssue(state, path10, expected, value) {
+  addIssue(
+    state,
+    path10,
+    expected,
+    receivedType(value),
+    `Expected ${expected} at ${formatPath(path10)}`
+  );
+}
+function addUnexpectedPropertyIssue(state, path10) {
+  addIssue(
+    state,
+    path10,
+    "no additional properties",
+    "unknown property",
+    `Unexpected property ${formatPath(path10)}`
+  );
+}
+function addIssue(state, path10, expected, received, _message) {
+  state.issues.push({
+    path: path10,
+    expected,
+    received,
+    message: formatIssueMessage(expected, path10, received)
+  });
+}
+function addIssueWithMessage(state, path10, expected, received, message2) {
+  state.issues.push({
+    path: path10,
+    expected,
+    received,
+    message: message2
+  });
+}
+function formatIssueMessage(expected, path10, received) {
+  return `Expected ${expected} at ${formatPath(path10)}, got ${received}`;
+}
+function formatPath(path10) {
+  return path10.length === 0 ? "value" : path10.join(".");
+}
+function compilePattern(pattern) {
+  try {
+    return new RegExp(pattern);
+  } catch {
+    return void 0;
+  }
+}
+function receivedType(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return "integer";
+  }
+  return typeof value;
+}
+function receivedValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  return String(value);
+}
+function formatReceivedDiscriminator(value) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  return receivedValue(value);
+}
+
 // ../toolcraft-schema/src/index.ts
 function assertValidEnumValues(values) {
   if (values.length === 0) {
@@ -2852,6 +3403,22 @@ function assertFiniteNumber(value, name) {
     throw new Error(`${name} must be finite`);
   }
 }
+function assertMinMaxOrder(minimum, maximum, minimumName, maximumName) {
+  if (minimum !== void 0 && maximum !== void 0 && minimum > maximum) {
+    throw new Error(`${minimumName} must be less than or equal to ${maximumName}`);
+  }
+}
+function assertValidDefault(schema) {
+  if (schema.default === void 0) {
+    return;
+  }
+  const result = validate(schema, schema.default);
+  if (!result.ok) {
+    throw new Error(
+      `default must satisfy schema: ${result.issues[0]?.message ?? "invalid default"}`
+    );
+  }
+}
 function assertPattern(pattern) {
   if (pattern === void 0) {
     return;
@@ -2866,56 +3433,71 @@ var S = {
   String(options = {}) {
     assertNonNegativeInteger(options.minLength, "minLength");
     assertNonNegativeInteger(options.maxLength, "maxLength");
+    assertMinMaxOrder(options.minLength, options.maxLength, "minLength", "maxLength");
     assertPattern(options.pattern);
-    return {
+    const schema = {
       kind: "string",
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Number(options = {}) {
     assertFiniteNumber(options.minimum, "minimum");
     assertFiniteNumber(options.maximum, "maximum");
+    assertMinMaxOrder(options.minimum, options.maximum, "minimum", "maximum");
     assertFiniteNumber(options.default, "default");
     if (options.jsonType === "integer" && options.default !== void 0 && !Number.isInteger(options.default)) {
       throw new Error("default must be an integer");
     }
-    return {
+    const schema = {
       kind: "number",
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Boolean(options = {}) {
-    return {
+    const schema = {
       kind: "boolean",
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Enum(values, options = {}) {
     assertValidEnumValues(values);
     if (options.jsonType === "integer" && values.some((value) => typeof value !== "number" || !Number.isInteger(value))) {
       throw new Error("Integer enum values must be integers");
     }
-    return {
+    const schema = {
       kind: "enum",
       values,
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Array(item, options = {}) {
     assertNonNegativeInteger(options.minItems, "minItems");
     assertNonNegativeInteger(options.maxItems, "maxItems");
-    return {
+    assertMinMaxOrder(options.minItems, options.maxItems, "minItems", "maxItems");
+    const schema = {
       kind: "array",
       item,
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Object(shape, options = {}) {
-    return {
+    const schema = {
       kind: "object",
       shape,
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Optional(inner) {
     return {
@@ -3064,6 +3646,7 @@ function createBaseCommand(config2) {
     kind: "command",
     name: config2.name,
     description: config2.description,
+    hidden: config2.hidden ?? false,
     examples: cloneCommandExamples(config2.examples),
     aliases: [...config2.aliases ?? []],
     positional: [...config2.positional ?? []],
@@ -3080,6 +3663,7 @@ function createBaseCommand(config2) {
   Object.defineProperty(command, commandConfigSymbol, {
     value: {
       scope: cloneScope(config2.scope),
+      hidden: config2.hidden ?? false,
       examples: cloneCommandExamples(config2.examples),
       result: config2.result,
       humanInLoop: config2.humanInLoop,
@@ -3099,6 +3683,7 @@ function materializeCommand(command, inherited) {
     kind: "command",
     name: command.name,
     description: command.description,
+    hidden: internal.hidden,
     examples: cloneCommandExamples(internal.examples),
     aliases: [...command.aliases],
     positional: [...command.positional],
@@ -3115,6 +3700,7 @@ function materializeCommand(command, inherited) {
   Object.defineProperty(materialized, commandConfigSymbol, {
     value: {
       scope: cloneScope(internal.scope),
+      hidden: internal.hidden,
       examples: cloneCommandExamples(internal.examples),
       result: internal.result,
       humanInLoop: internal.humanInLoop,