@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-ZU4JPCPR.js

@@ -0,0 +1,319 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  MAX_ULP_TOLERANCE,
+  compareCodepoints
+} from "./chunk-2KUBKL63.js";
+import {
+  byteLength
+} from "./chunk-MYI32N4R.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  resolveSafeCwd
+} from "./chunk-M2IPMWCN.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/safety/validation-contract.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+var VALIDATION_CONTRACT_VERSION = 1;
+var VALIDATION_CONTRACT_YAML_PATHS = [
+  ".clio-coder/validation.yaml",
+  ".clio-coder/validation.yml",
+  "validation.yaml",
+  "validation.yml"
+];
+var VALIDATION_CONTRACT_MARKDOWN_PATH = "VALIDATION.md";
+var VALIDATION_CONTRACT_CAPS = Object.freeze({
+  fileBytes: 256 * 1024,
+  textBytes: 4096,
+  notesBytes: 16 * 1024,
+  artifacts: 256,
+  validators: 128,
+  modules: 64,
+  mapEntries: 256,
+  mapKeyBytes: 256
+});
+var RUNTIME_KINDS = ["local", "slurm", "mpi", "other"];
+var ROOT_FIELDS = /* @__PURE__ */ new Set(["version", "task", "runtime", "artifacts", "validators", "notes"]);
+var RUNTIME_FIELDS = /* @__PURE__ */ new Set(["kind", "nodes", "ranks", "walltime", "modules"]);
+var ARTIFACT_FIELDS = /* @__PURE__ */ new Set([
+  "path",
+  "format",
+  "expected_dimensions",
+  "expected_attributes",
+  "numerical_tolerances",
+  "preserve"
+]);
+var TOLERANCE_FIELDS = /* @__PURE__ */ new Set(["relative", "absolute", "ulp"]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function unknownFields(record, allowed) {
+  return Object.keys(record).filter((key) => !allowed.has(key)).sort(compareCodepoints);
+}
+function boundedText(value, location, cap) {
+  if (typeof value !== "string" || value.length === 0) return new Error(`${location} must be a non-empty string`);
+  if (value.includes("\0")) return new Error(`${location} must not contain a NUL byte`);
+  if (byteLength(value) > cap) return new Error(`${location} exceeds the ${cap}-byte cap`);
+  return value;
+}
+function positiveInteger(value, location) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    return new Error(`${location} must be a positive integer`);
+  }
+  return value;
+}
+function nonNegativeNumber(value, location) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return new Error(`${location} must be a finite non-negative number`);
+  }
+  return value;
+}
+function boundedStringList(value, location, cap) {
+  if (!Array.isArray(value)) return new Error(`${location} must be an array of strings`);
+  if (value.length > cap) return new Error(`${location} exceeds the ${cap}-entry cap`);
+  const items = [];
+  for (const [index, entry] of value.entries()) {
+    const text = boundedText(entry, `${location}[${index}]`, VALIDATION_CONTRACT_CAPS.textBytes);
+    if (text instanceof Error) return text;
+    items.push(text);
+  }
+  return items;
+}
+function boundedMap(value, location, validateEntry) {
+  if (!isRecord(value)) return new Error(`${location} must be a map`);
+  const keys = Object.keys(value);
+  if (keys.length > VALIDATION_CONTRACT_CAPS.mapEntries) {
+    return new Error(`${location} exceeds the ${VALIDATION_CONTRACT_CAPS.mapEntries}-entry cap`);
+  }
+  const out = {};
+  for (const key of keys.sort(compareCodepoints)) {
+    const entryLocation = `${location}.${key}`;
+    if (key.length === 0) return new Error(`${location} has an empty key`);
+    if (byteLength(key) > VALIDATION_CONTRACT_CAPS.mapKeyBytes) {
+      return new Error(`${entryLocation} key exceeds the ${VALIDATION_CONTRACT_CAPS.mapKeyBytes}-byte cap`);
+    }
+    const entry = validateEntry(value[key], entryLocation);
+    if (entry instanceof Error) return entry;
+    out[key] = entry;
+  }
+  return out;
+}
+function validateRuntime(value, location) {
+  if (!isRecord(value)) return new Error(`${location} must be an object with a kind field`);
+  const unknown = unknownFields(value, RUNTIME_FIELDS);
+  if (unknown.length > 0) return new Error(`${location} has unknown field(s): ${unknown.join(", ")}`);
+  if (!Object.hasOwn(value, "kind")) return new Error(`${location}.kind is required`);
+  const kind = value.kind;
+  if (typeof kind !== "string" || !RUNTIME_KINDS.includes(kind)) {
+    return new Error(`${location}.kind must be one of ${RUNTIME_KINDS.join(", ")}`);
+  }
+  const runtime = { kind };
+  if (Object.hasOwn(value, "nodes")) {
+    const nodes = positiveInteger(value.nodes, `${location}.nodes`);
+    if (nodes instanceof Error) return nodes;
+    runtime.nodes = nodes;
+  }
+  if (Object.hasOwn(value, "ranks")) {
+    const ranks = positiveInteger(value.ranks, `${location}.ranks`);
+    if (ranks instanceof Error) return ranks;
+    runtime.ranks = ranks;
+  }
+  if (Object.hasOwn(value, "walltime")) {
+    const walltime = boundedText(value.walltime, `${location}.walltime`, VALIDATION_CONTRACT_CAPS.textBytes);
+    if (walltime instanceof Error) return walltime;
+    runtime.walltime = walltime;
+  }
+  if (Object.hasOwn(value, "modules")) {
+    const modules = boundedStringList(value.modules, `${location}.modules`, VALIDATION_CONTRACT_CAPS.modules);
+    if (modules instanceof Error) return modules;
+    runtime.modules = modules;
+  }
+  return runtime;
+}
+function validateTolerances(value, location) {
+  if (!isRecord(value)) return new Error(`${location} must be an object`);
+  const unknown = unknownFields(value, TOLERANCE_FIELDS);
+  if (unknown.length > 0) return new Error(`${location} has unknown field(s): ${unknown.join(", ")}`);
+  const tolerances = {};
+  if (Object.hasOwn(value, "relative")) {
+    const relative = nonNegativeNumber(value.relative, `${location}.relative`);
+    if (relative instanceof Error) return relative;
+    tolerances.relative = relative;
+  }
+  if (Object.hasOwn(value, "absolute")) {
+    const absolute = nonNegativeNumber(value.absolute, `${location}.absolute`);
+    if (absolute instanceof Error) return absolute;
+    tolerances.absolute = absolute;
+  }
+  if (Object.hasOwn(value, "ulp")) {
+    const ulp = value.ulp;
+    if (typeof ulp !== "number" || !Number.isInteger(ulp) || ulp < 0 || ulp > MAX_ULP_TOLERANCE) {
+      return new Error(`${location}.ulp must be a non-negative integer no greater than ${MAX_ULP_TOLERANCE}`);
+    }
+    tolerances.ulp = ulp;
+  }
+  return tolerances;
+}
+function validateArtifact(value, location) {
+  if (!isRecord(value)) return new Error(`${location} must be an object with a path field`);
+  const unknown = unknownFields(value, ARTIFACT_FIELDS);
+  if (unknown.length > 0) return new Error(`${location} has unknown field(s): ${unknown.join(", ")}`);
+  if (!Object.hasOwn(value, "path")) return new Error(`${location}.path is required`);
+  const artifactPath = boundedText(value.path, `${location}.path`, VALIDATION_CONTRACT_CAPS.textBytes);
+  if (artifactPath instanceof Error) return artifactPath;
+  const artifact = { path: artifactPath };
+  if (Object.hasOwn(value, "format")) {
+    const format = boundedText(value.format, `${location}.format`, VALIDATION_CONTRACT_CAPS.textBytes);
+    if (format instanceof Error) return format;
+    artifact.format = format;
+  }
+  if (Object.hasOwn(value, "expected_dimensions")) {
+    const dimensions = boundedMap(
+      value.expected_dimensions,
+      `${location}.expected_dimensions`,
+      (entry, entryLocation) => typeof entry === "number" && Number.isInteger(entry) && entry >= 0 ? entry : new Error(`${entryLocation} must be a non-negative integer`)
+    );
+    if (dimensions instanceof Error) return dimensions;
+    artifact.expected_dimensions = dimensions;
+  }
+  if (Object.hasOwn(value, "expected_attributes")) {
+    const attributes = boundedMap(
+      value.expected_attributes,
+      `${location}.expected_attributes`,
+      (entry, entryLocation) => typeof entry === "string" ? boundedText(entry, entryLocation, VALIDATION_CONTRACT_CAPS.textBytes) : new Error(`${entryLocation} must be a string`)
+    );
+    if (attributes instanceof Error) return attributes;
+    artifact.expected_attributes = attributes;
+  }
+  if (Object.hasOwn(value, "numerical_tolerances")) {
+    const tolerances = validateTolerances(value.numerical_tolerances, `${location}.numerical_tolerances`);
+    if (tolerances instanceof Error) return tolerances;
+    artifact.numerical_tolerances = tolerances;
+  }
+  if (Object.hasOwn(value, "preserve")) {
+    if (typeof value.preserve !== "boolean") return new Error(`${location}.preserve must be a boolean`);
+    artifact.preserve = value.preserve;
+  }
+  return artifact;
+}
+function parseValidationContractText(text, contractPath) {
+  const invalid = (reason) => ({ ok: false, path: contractPath, reason });
+  const document = (0, import_yaml.parseDocument)(text, { prettyErrors: false, strict: true, uniqueKeys: true });
+  if (document.errors.length > 0) {
+    return invalid(`invalid YAML: ${document.errors.map((error) => error.message).join("; ")}`);
+  }
+  let parsed;
+  try {
+    parsed = document.toJS({ maxAliasCount: 0 });
+  } catch (error) {
+    return invalid(`invalid YAML: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(parsed)) return invalid("root must be an object with a version field");
+  const rootUnknown = unknownFields(parsed, ROOT_FIELDS);
+  if (rootUnknown.length > 0) return invalid(`root has unknown field(s): ${rootUnknown.join(", ")}`);
+  if (!Object.hasOwn(parsed, "version")) return invalid("root.version is required");
+  if (parsed.version !== VALIDATION_CONTRACT_VERSION) {
+    return invalid(
+      `unsupported version ${JSON.stringify(parsed.version)}; supported version is ${VALIDATION_CONTRACT_VERSION}`
+    );
+  }
+  const contract = { version: VALIDATION_CONTRACT_VERSION };
+  if (Object.hasOwn(parsed, "task")) {
+    const task = boundedText(parsed.task, "root.task", VALIDATION_CONTRACT_CAPS.textBytes);
+    if (task instanceof Error) return invalid(task.message);
+    contract.task = task;
+  }
+  if (Object.hasOwn(parsed, "runtime")) {
+    const runtime = validateRuntime(parsed.runtime, "root.runtime");
+    if (runtime instanceof Error) return invalid(runtime.message);
+    contract.runtime = runtime;
+  }
+  if (Object.hasOwn(parsed, "artifacts")) {
+    if (!Array.isArray(parsed.artifacts)) return invalid("root.artifacts must be an array");
+    if (parsed.artifacts.length > VALIDATION_CONTRACT_CAPS.artifacts) {
+      return invalid(`root.artifacts exceeds the ${VALIDATION_CONTRACT_CAPS.artifacts}-entry cap`);
+    }
+    const artifacts = [];
+    for (const [index, value] of parsed.artifacts.entries()) {
+      const artifact = validateArtifact(value, `artifacts[${index}]`);
+      if (artifact instanceof Error) return invalid(artifact.message);
+      artifacts.push(artifact);
+    }
+    contract.artifacts = artifacts;
+  }
+  if (Object.hasOwn(parsed, "validators")) {
+    const validators = boundedStringList(parsed.validators, "root.validators", VALIDATION_CONTRACT_CAPS.validators);
+    if (validators instanceof Error) return invalid(validators.message);
+    contract.validators = validators;
+  }
+  if (Object.hasOwn(parsed, "notes")) {
+    const notes = boundedText(parsed.notes, "root.notes", VALIDATION_CONTRACT_CAPS.notesBytes);
+    if (notes instanceof Error) return invalid(notes.message);
+    contract.notes = notes;
+  }
+  return { ok: true, contract, path: contractPath };
+}
+function readContractText(absolutePath, workspaceRoot) {
+  let realPath;
+  try {
+    const realRoot = realpathSync(workspaceRoot);
+    realPath = realpathSync(absolutePath);
+    resolveSafeCwd(realPath, realRoot);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return new Error(`contract file must resolve inside the workspace root (${message})`);
+  }
+  try {
+    const stats = statSync(realPath);
+    if (!stats.isFile()) return new Error("contract path must be a regular file");
+    if (stats.size > VALIDATION_CONTRACT_CAPS.fileBytes) {
+      return new Error(`file exceeds the ${VALIDATION_CONTRACT_CAPS.fileBytes}-byte cap`);
+    }
+    return readFileSync(realPath, "utf8");
+  } catch (error) {
+    return new Error(`cannot read contract (${error instanceof Error ? error.message : String(error)})`);
+  }
+}
+function loadValidationContract(workspaceRoot) {
+  let contractPath = null;
+  try {
+    contractPath = VALIDATION_CONTRACT_YAML_PATHS.find((relative) => existsSync(path.join(workspaceRoot, relative))) ?? null;
+    if (contractPath === null) {
+      if (existsSync(path.join(workspaceRoot, VALIDATION_CONTRACT_MARKDOWN_PATH))) {
+        return { ok: true, contract: null, path: VALIDATION_CONTRACT_MARKDOWN_PATH, advisory: true };
+      }
+      return { ok: true, contract: null };
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      path: contractPath ?? VALIDATION_CONTRACT_YAML_PATHS[0] ?? "validation.yaml",
+      reason: `cannot inspect workspace root (${error instanceof Error ? error.message : String(error)})`
+    };
+  }
+  const text = readContractText(path.join(workspaceRoot, contractPath), workspaceRoot);
+  if (text instanceof Error) return { ok: false, path: contractPath, reason: text.message };
+  return parseValidationContractText(text, contractPath);
+}
+function describeValidationContract(result) {
+  if (!result.ok) return `${result.path}: ${result.reason}`;
+  if (result.contract === null) {
+    return "advisory" in result ? `${result.path} is advisory prose and does not raise rigor; add a version-1 validation.yaml to raise the default to high` : null;
+  }
+  return null;
+}
+
+export {
+  VALIDATION_CONTRACT_MARKDOWN_PATH,
+  loadValidationContract,
+  describeValidationContract
+};
+//# sourceMappingURL=chunk-ZU4JPCPR.js.map

package/dist/chunk-ZUKUCZYZ.js

@@ -0,0 +1,39 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  PANES_PRESET_IDS
+} from "./chunk-QUIJZSDW.js";
+import {
+  StringEnum
+} from "./chunk-L7G7K4I2.js";
+import {
+  ToolNames
+} from "./chunk-V4XJWDHR.js";
+import {
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/panes-surface.ts
+init_esm_shims();
+var panesToolSurface = {
+  name: ToolNames.Panes,
+  description: "Manage the terminal panes Clio owns beside this session: show focuses a dispatched run's viewer pane, open starts a fixed utility preset (files, logs, or shell; never an arbitrary command) or focuses it when it is already open, close removes a Clio-created pane, list reports the inventory and the pane layer's health.",
+  parameters: typebox_exports.Object({
+    action: StringEnum(["show", "open", "close", "list"], { description: "Pane action." }),
+    target: typebox_exports.Optional(
+      typebox_exports.String({
+        description: 'show: an agent id or run id prefix, most recent match wins. close: a pane id, label, agent id, or "all".'
+      })
+    ),
+    preset: typebox_exports.Optional(StringEnum([...PANES_PRESET_IDS], { description: "open: which utility pane to start." }))
+  }),
+  baseActionClass: "read",
+  executionMode: "sequential"
+};
+
+export {
+  panesToolSurface
+};
+//# sourceMappingURL=chunk-ZUKUCZYZ.js.map

package/dist/cli/index.js

@@ -7,14 +7,15 @@ import {
   extractGlobalFlags,
   parseFlags,
   printError
-} from "../chunk-KIVFXGBM.js";
+} from "../chunk-NBXFPI7U.js";
+import "../chunk-SQZHXUB3.js";
 import {
   incompleteInstallationAdvice
-} from "../chunk-3A3CUMKA.js";
+} from "../chunk-HMN2C6YL.js";
 import {
   AI_AGENT_NAME
 } from "../chunk-ZTNFYMIO.js";
-import "../chunk-E3LEPLQ2.js";
+import "../chunk-ZPST2KQO.js";
 import {
   init_esm_shims
 } from "../chunk-ECBHH7LU.js";
@@ -30,7 +31,7 @@ science. CLIO stands for Context Layer for Input/Output, named for the Greek mus
 
 Usage:
   clio-coder                      start interactive repository chat
-  clio-coder web [--open]         start the browser application
+  clio-coder gui [--open]         start the graphical application
   clio-coder acp                  serve Clio as an ACP v1 agent over stdio
   clio-coder --acp                alias for clio-coder acp
   clio-coder run [flags] <task>   run one headless main-agent turn
@@ -79,8 +80,9 @@ Usage:
   clio-coder tools list|status|install|remove <id>  pinned external programs Clio can drive
   clio-coder interop inspect --json  detected external coding agents and how far each one is wired
   clio-coder panes install|theme  install the pane multiplexer (alias for 'tools install herdr'), or print Clio's theme as a herdr block
-  clio-coder docs [topic]         open documentation in the web app (--no-open to print the launch link)
+  clio-coder docs [topic]         open documentation in the graphical app (--no-open to print the launch link)
   clio-coder dev <command>        harness instruments; run 'clio-coder dev' for the list
+  clio-coder --demo|--no-demo      enable or disable interactive guidance for this session
   clio-coder --help, -h           this message
   clio-coder --help --all         this message plus every command under 'clio-coder dev'
 `;
@@ -128,6 +130,7 @@ async function main(argv) {
     noSkills,
     skillPaths,
     panes,
+    demo,
     autonomy,
     rest,
     error: globalFlagError
@@ -145,7 +148,7 @@ async function main(argv) {
     return 0;
   }
   if (flags.has("version") || flags.has("v")) {
-    const { runVersionCommand } = await import("../version-RFPKO6T7.js");
+    const { runVersionCommand } = await import("../version-PLZYB5KW.js");
     return runVersionCommand();
   }
   const subArgs = subcommandIndex === -1 ? [] : rest.slice(subcommandIndex + 1);
@@ -156,6 +159,10 @@ async function main(argv) {
     ...skillPaths.length > 0 ? { skillPaths } : {},
     ...panes === void 0 ? {} : { panes }
   };
+  if (demo !== void 0 && subcommand) {
+    printError("--demo and --no-demo apply to interactive sessions only; start clio-coder without a subcommand.");
+    return 2;
+  }
   if (autonomy !== void 0 && subcommand) {
     printError(
       `--autonomy before a subcommand applies to the interactive session only. For a headless turn use: clio-coder run --autonomy ${autonomy} "<task>"`
@@ -164,38 +171,42 @@ async function main(argv) {
   }
   if (!subcommand) {
     await enableBootCompileCache();
-    const { runClioCommand } = await import("../clio-JUDCLNHC.js");
-    return runClioCommand({ ...bootOptions, ...autonomy === void 0 ? {} : { autonomy } });
+    const { runClioCommand } = await import("../clio-K2PBVCEM.js");
+    return runClioCommand({
+      ...bootOptions,
+      ...demo === void 0 ? {} : { demo },
+      ...autonomy === void 0 ? {} : { autonomy }
+    });
   }
   return dispatch(subcommand, subArgs, bootOptions);
 }
 async function enableBootCompileCache(subArgs = []) {
   if (subArgs.includes("--help") || subArgs.includes("-h")) return;
-  const { enableClioCompileCache } = await import("../compile-cache-WJEPUZEJ.js");
+  const { enableClioCompileCache } = await import("../compile-cache-YRB6QRO7.js");
   enableClioCompileCache();
 }
-var extensionsCommand = async (subArgs) => (await import("../extensions-PYQH3H47.js")).runExtensionsCommand(subArgs);
+var extensionsCommand = async (subArgs) => (await import("../extensions-ROZJ5X3J.js")).runExtensionsCommand(subArgs);
 var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
   [
     "acp",
     async (subArgs, bootOptions) => {
       await enableBootCompileCache(subArgs);
-      return (await import("../acp-ZWZCPS2A.js")).runAcpCommand(subArgs, bootOptions);
+      return (await import("../acp-KS7ARGV6.js")).runAcpCommand(subArgs, bootOptions);
     }
   ],
-  ["auth", async (subArgs) => (await import("../auth-WBQGKWQ5.js")).runAuthCommand(subArgs)],
-  ["config", async (subArgs) => (await import("../config-P3ZQVF63.js")).runConfigCommand(subArgs)],
-  ["configure", async (subArgs) => (await import("../configure-25LRYZJG.js")).runConfigureCommand(subArgs)],
-  ["targets", async (subArgs) => (await import("../targets-EZKHAYRN.js")).runTargetsCommand(subArgs)],
-  ["models", async (subArgs) => (await import("../models-KQ6PQJJQ.js")).runModelsCommand(subArgs)],
-  ["agents", async (subArgs) => (await import("../agents-LYSOWZUE.js")).runAgentsCommand(subArgs)],
-  ["components", async (subArgs) => (await import("../components-OZXZMDWU.js")).runComponentsCommand(subArgs)],
-  ["evidence", async (subArgs) => (await import("../evidence-AVJ2RTHX.js")).runEvidenceCommand(subArgs)],
-  ["eval", async (subArgs) => (await import("../eval-FUNWJNUJ.js")).runEvalCommand(subArgs)],
-  ["memory", async (subArgs) => (await import("../memory-36CWN67Y.js")).runMemoryCommand(subArgs)],
-  ["usage", async (subArgs) => (await import("../usage-S2HOB7BZ.js")).runUsageCommand(subArgs)],
-  ["trace", async (subArgs) => (await import("../trace-C3MBGD4S.js")).runTraceCommand(subArgs)],
-  ["evolve", async (subArgs) => (await import("../evolve-MAWKRYWF.js")).runEvolveCommand(subArgs)],
+  ["auth", async (subArgs) => (await import("../auth-CEDCO6O6.js")).runAuthCommand(subArgs)],
+  ["config", async (subArgs) => (await import("../config-Q5J7UBAB.js")).runConfigCommand(subArgs)],
+  ["configure", async (subArgs) => (await import("../configure-KIJ32ZO6.js")).runConfigureCommand(subArgs)],
+  ["targets", async (subArgs) => (await import("../targets-AJWA6E7Z.js")).runTargetsCommand(subArgs)],
+  ["models", async (subArgs) => (await import("../models-Y3GMFJ2V.js")).runModelsCommand(subArgs)],
+  ["agents", async (subArgs) => (await import("../agents-YOGJ2YEJ.js")).runAgentsCommand(subArgs)],
+  ["components", async (subArgs) => (await import("../components-RQOJ6NUR.js")).runComponentsCommand(subArgs)],
+  ["evidence", async (subArgs) => (await import("../evidence-XNVPPLVK.js")).runEvidenceCommand(subArgs)],
+  ["eval", async (subArgs) => (await import("../eval-3D6M36N7.js")).runEvalCommand(subArgs)],
+  ["memory", async (subArgs) => (await import("../memory-J3STUUIK.js")).runMemoryCommand(subArgs)],
+  ["usage", async (subArgs) => (await import("../usage-XSILDHKF.js")).runUsageCommand(subArgs)],
+  ["trace", async (subArgs) => (await import("../trace-LA5MVR4Y.js")).runTraceCommand(subArgs)],
+  ["evolve", async (subArgs) => (await import("../evolve-TLPUDJDM.js")).runEvolveCommand(subArgs)],
   [
     "dev",
     async (subArgs, bootOptions) => {
@@ -214,33 +225,33 @@ var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
   ],
   ["extensions", extensionsCommand],
   ["ext", extensionsCommand],
-  ["fleet", async (subArgs) => (await import("../fleet-ULBXXRDR.js")).runFleetCommand(subArgs)],
-  ["library", async (subArgs) => (await import("../library-Z3KZSHPE.js")).runLibraryCommand(subArgs)],
-  ["tasks", async (subArgs) => (await import("../tasks-SNEFHWYW.js")).runTasksCommand(subArgs)],
-  ["mcp", async (subArgs) => (await import("../mcp-5FWZKUS6.js")).runMcpCommand(subArgs)],
-  ["verifiers", async (subArgs) => (await import("../verifiers-QDTEVH7R.js")).runVerifiersCommand(subArgs)],
-  ["web", async (subArgs) => (await import("../web-EMGUGGEI.js")).runWebCommand(subArgs)],
-  ["docs", async (subArgs) => (await import("../docs-ZK777W2G.js")).runDocsCommand(subArgs)],
-  ["share", async (subArgs) => (await import("../share-HVWH4FPF.js")).runShareCommand(subArgs)],
-  ["export", async (subArgs) => (await import("../share-HVWH4FPF.js")).runExportCommand(subArgs)],
-  ["import", async (subArgs) => (await import("../share-HVWH4FPF.js")).runImportCommand(subArgs)],
-  ["context", async (subArgs) => (await import("../context-WB3D474G.js")).runContextCommand(subArgs)],
+  ["fleet", async (subArgs) => (await import("../fleet-WKVBF5SZ.js")).runFleetCommand(subArgs)],
+  ["library", async (subArgs) => (await import("../library-ROZAMUIL.js")).runLibraryCommand(subArgs)],
+  ["tasks", async (subArgs) => (await import("../tasks-6L2JJRC5.js")).runTasksCommand(subArgs)],
+  ["mcp", async (subArgs) => (await import("../mcp-2GSPYQ54.js")).runMcpCommand(subArgs)],
+  ["verifiers", async (subArgs) => (await import("../verifiers-ECA5GIHL.js")).runVerifiersCommand(subArgs)],
+  ["gui", async (subArgs) => (await import("../gui-QJS7XQMV.js")).runGuiCommand(subArgs)],
+  ["docs", async (subArgs) => (await import("../docs-K4GBWRUX.js")).runDocsCommand(subArgs)],
+  ["share", async (subArgs) => (await import("../share-CAFMMQLM.js")).runShareCommand(subArgs)],
+  ["export", async (subArgs) => (await import("../share-CAFMMQLM.js")).runExportCommand(subArgs)],
+  ["import", async (subArgs) => (await import("../share-CAFMMQLM.js")).runImportCommand(subArgs)],
+  ["context", async (subArgs) => (await import("../context-LFBQOSXT.js")).runContextCommand(subArgs)],
   [
     "run",
     async (subArgs, bootOptions) => {
       await enableBootCompileCache(subArgs);
-      return (await import("../run-AR7PY6GW.js")).runClioRun(subArgs, bootOptions);
+      return (await import("../run-H64MEVTA.js")).runClioRun(subArgs, bootOptions);
     }
   ],
-  ["tools", async (subArgs) => (await import("../tools-7IM6BDCE.js")).runToolsCommand(subArgs)],
-  ["interop", async (subArgs) => (await import("../interop-EF5JUWWK.js")).runInteropCommand(subArgs)],
-  ["panes", async (subArgs) => (await import("../panes-L27QRXUH.js")).runPanesCommand(subArgs)],
-  ["doctor", async (subArgs) => (await import("../doctor-WC4OV2OB.js")).runDoctorCommand(subArgs)],
-  ["paths", async (subArgs) => (await import("../paths-7DJDU4P4.js")).runPathsCommand(subArgs)],
-  ["reset", async (subArgs) => (await import("../reset-73VU3XNT.js")).runResetCommand(subArgs)],
-  ["uninstall", async (subArgs) => (await import("../uninstall-WWLOSZ42.js")).runUninstallCommand(subArgs)],
-  ["upgrade", async (subArgs) => (await import("../upgrade-ETK2JNSJ.js")).runUpgradeCommand(subArgs)],
-  ["version", async () => (await import("../version-RFPKO6T7.js")).runVersionCommand()],
+  ["tools", async (subArgs) => (await import("../tools-5XJUABRD.js")).runToolsCommand(subArgs)],
+  ["interop", async (subArgs) => (await import("../interop-J7UOBOSF.js")).runInteropCommand(subArgs)],
+  ["panes", async (subArgs) => (await import("../panes-CTNO57ZY.js")).runPanesCommand(subArgs)],
+  ["doctor", async (subArgs) => (await import("../doctor-S5KZ2GTN.js")).runDoctorCommand(subArgs)],
+  ["paths", async (subArgs) => (await import("../paths-3SBYJQDP.js")).runPathsCommand(subArgs)],
+  ["reset", async (subArgs) => (await import("../reset-O7EUCYWO.js")).runResetCommand(subArgs)],
+  ["uninstall", async (subArgs) => (await import("../uninstall-SAWGGXAB.js")).runUninstallCommand(subArgs)],
+  ["upgrade", async (subArgs) => (await import("../upgrade-HSNSVTZG.js")).runUpgradeCommand(subArgs)],
+  ["version", async () => (await import("../version-PLZYB5KW.js")).runVersionCommand()],
   [
     "worker",
     async () => {

package/dist/clio-K2PBVCEM.js

@@ -0,0 +1,27 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  runClioCommand
+} from "./chunk-X4CEFOSG.js";
+import "./chunk-URCXX7WJ.js";
+import "./chunk-FXFVDPWY.js";
+import "./chunk-ZNUZ3EXD.js";
+import "./chunk-X6FLVUM5.js";
+import "./chunk-ALJWT6O6.js";
+import "./chunk-56XP4FJU.js";
+import "./chunk-QZTTRSJE.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-O63U2I6I.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-CTTI7G3T.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-ZPST2KQO.js";
+import "./chunk-FD2I4KBR.js";
+import "./chunk-ECBHH7LU.js";
+export {
+  runClioCommand
+};
+//# sourceMappingURL=clio-K2PBVCEM.js.map