@iowarp/clio-coder 0.4.3 → 0.4.5

package/dist/{chunk-54CBCGIR.js → chunk-ZMZQEBKI.js}

@@ -1,36 +1,43 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   verifyTool
-} from "./chunk-F5JHEYZM.js";
+} from "./chunk-UXAC2FX4.js";
 import {
   discoverDeclaredChecksAtRoot,
   discoverDeclaredProjectEntriesAtRoot
-} from "./chunk-V2ANDPVT.js";
+} from "./chunk-HGSLRG33.js";
+import {
+  VALIDATION_CONTRACT_MARKDOWN_PATH,
+  loadValidationContract
+} from "./chunk-T52TPHYC.js";
 import {
   parseTomlDocument,
   tomlTableAt
-} from "./chunk-LCGCVYZ4.js";
+} from "./chunk-LQTKDAUO.js";
 import {
   PROJECT_VERIFIER_CATALOG_CAPS,
   PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
   PROJECT_VERIFIER_CATALOG_VERSION,
-  compareCodepoints,
+  normalizeNumericTolerance,
   parseProjectVerifierCatalogText
-} from "./chunk-7DICMOS6.js";
+} from "./chunk-MDU3C27C.js";
 import {
   isVerificationScriptName
-} from "./chunk-UL3WSD3F.js";
+} from "./chunk-M4KFUXS7.js";
+import {
+  compareCodepoints
+} from "./chunk-B6UM3OZC.js";
 import {
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   resolveSafeCwd
-} from "./chunk-JSC3U7TI.js";
+} from "./chunk-GJ24ODAX.js";
 import {
   require_dist
-} from "./chunk-APJ265NV.js";
+} from "./chunk-B5GGDIHT.js";
 import {
   __toESM,
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/tools/verify/authoring.ts
 init_esm_shims();
@@ -48,12 +55,6 @@ import {
 } from "node:fs";
 import path from "node:path";
 var DECLARED_FILE_CAP_BYTES = 1024 * 1024;
-var VALIDATION_CONTRACT_PATHS = [
-  ".clio-coder/validation.yaml",
-  ".clio-coder/validation.yml",
-  "validation.yaml",
-  "validation.yml"
-];
 function manualEntryInstruction() {
   return 'No unambiguous declared command was found. Add one explicitly with `clio-coder verifiers add --id <id> --description <text> --command \'["executable","arg"]\'`; `--command` is an exact JSON argv array. Review the preview, then rerun with `--yes`.';
 }
@@ -62,9 +63,20 @@ function cloneCheck(check) {
     ...check,
     command: [...check.command],
     tags: [...check.tags],
+    ...check.numeric !== void 0 ? { numeric: structuredClone(check.numeric) } : {},
+    ...check.perf !== void 0 ? { perf: structuredClone(check.perf) } : {},
     provenance: { ...check.provenance }
   };
 }
+function kindFields(check) {
+  const kind = check.kind ?? "command";
+  if (kind === "command") return {};
+  return {
+    kind,
+    ...check.numeric !== void 0 ? { numeric: structuredClone(check.numeric) } : {},
+    ...check.perf !== void 0 ? { perf: structuredClone(check.perf) } : {}
+  };
+}
 function relativePath(workspaceRoot, filePath) {
   const relative = path.relative(workspaceRoot, filePath);
   return relative.length === 0 ? "." : relative.split(path.sep).join("/");
@@ -139,6 +151,7 @@ function projectedCheck(workspaceRoot, check) {
     cwd: check.cwd,
     timeoutMs: check.timeoutMs,
     tags: [...check.tags],
+    ...kindFields(check),
     provenance: sourceProvenance(workspaceRoot, check),
     state: check.source.kind === "package.json" ? "active" : "existing",
     ...check.source.kind === "package.json" ? {} : { catalogId: check.id }
@@ -469,13 +482,6 @@ function shellLikeArgv(command) {
   if ((argv[0] ?? "").includes("=")) return new Error("environment assignments are not argv executables");
   return argv;
 }
-function validatorArgv(value) {
-  if (typeof value === "string") return shellLikeArgv(value);
-  if (!Array.isArray(value) || value.length === 0 || value.some((entry) => typeof entry !== "string" || entry.length === 0)) {
-    return new Error("validator must be a command string or a non-empty argv string array");
-  }
-  return [...value];
-}
 function validationPreferredId(argv) {
   const executable = path.basename(argv[0] ?? "check").replace(/\.[^.]+$/u, "");
   const script = argv.find((entry, index) => index > 0 && /\.(?:py|js|mjs|sh)$/u.test(entry));
@@ -484,80 +490,64 @@ function validationPreferredId(argv) {
 }
 function validationContractProposals(workspaceRoot, diagnostics) {
   const proposals = [];
-  for (const relative of VALIDATION_CONTRACT_PATHS) {
-    const text = regularFileText(path.join(workspaceRoot, relative), workspaceRoot);
-    if (text === null) continue;
-    if (text instanceof Error) {
-      diagnostics.push(`${relative}: ${text.message}; validation command discovery skipped.`);
-      continue;
-    }
-    const document = (0, import_yaml.parseDocument)(text, { prettyErrors: false, strict: true, uniqueKeys: true });
-    if (document.errors.length > 0) {
-      diagnostics.push(`${relative}: invalid YAML; validation command discovery skipped.`);
-      continue;
-    }
-    let parsed;
-    try {
-      parsed = document.toJS({ maxAliasCount: 0 });
-    } catch (error) {
-      diagnostics.push(`${relative}: invalid YAML (${error instanceof Error ? error.message : String(error)}).`);
-      continue;
-    }
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) continue;
-    const validators = parsed.validators;
-    if (!Array.isArray(validators)) continue;
-    for (const [index, validator] of validators.entries()) {
-      const record = validator !== null && typeof validator === "object" && !Array.isArray(validator) ? validator : null;
-      if (record !== null) {
-        const typedFields = [
-          ["id", (value) => typeof value === "string"],
-          ["description", (value) => typeof value === "string"],
-          ["cwd", (value) => typeof value === "string"],
-          ["timeoutMs", (value) => typeof value === "number"],
-          ["tags", (value) => Array.isArray(value) && value.every((tag) => typeof tag === "string")]
-        ];
-        const invalidField = typedFields.find(([field, valid]) => Object.hasOwn(record, field) && !valid(record[field]));
-        if (invalidField !== void 0) {
-          diagnostics.push(
-            `${relative}: validators[${index}].${String(invalidField[0])} has an ambiguous type; use manual argv entry.`
-          );
-          continue;
-        }
-      }
-      const commandValue = record === null ? validator : record.command;
-      const argv = validatorArgv(commandValue);
+  const loaded = loadValidationContract(workspaceRoot);
+  if (!loaded.ok) {
+    diagnostics.push(`${loaded.path}: ${loaded.reason}; validation command discovery skipped.`);
+  } else if (loaded.contract !== null) {
+    for (const [index, validator] of (loaded.contract.validators ?? []).entries()) {
+      const argv = shellLikeArgv(validator);
       if (argv instanceof Error) {
-        diagnostics.push(`${relative}: validators[${index}] is ambiguous (${argv.message}); use manual argv entry.`);
+        diagnostics.push(`${loaded.path}: validators[${index}] is ambiguous (${argv.message}); use manual argv entry.`);
         continue;
       }
-      const declaredId = typeof record?.id === "string" ? record.id : validationPreferredId(argv);
-      const description = typeof record?.description === "string" ? record.description : `Run validation contract command ${JSON.stringify(argv)}`;
-      const cwd = typeof record?.cwd === "string" ? record.cwd : ".";
-      const timeoutMs = typeof record?.timeoutMs === "number" ? record.timeoutMs : SAFE_EXEC_DEFAULT_TIMEOUT_MS;
-      const tags = Array.isArray(record?.tags) ? record.tags.filter((tag) => typeof tag === "string") : [];
       proposals.push({
-        preferredId: declaredId,
-        description,
+        preferredId: validationPreferredId(argv),
+        description: `Run validation contract command ${JSON.stringify(argv)}`,
         command: argv,
-        cwd,
-        timeoutMs,
-        tags: tags.length > 0 ? tags : ["scientific", "validation"],
+        cwd: ".",
+        timeoutMs: SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+        tags: ["scientific", "validation"],
         provenance: {
           kind: "validation-contract",
-          path: relative,
+          path: loaded.path,
           detail: `validators[${index}]`,
           authority: "project-declared"
         }
       });
     }
   }
-  if (existsSync(path.join(workspaceRoot, "VALIDATION.md"))) {
+  if (existsSync(path.join(workspaceRoot, VALIDATION_CONTRACT_MARKDOWN_PATH))) {
     diagnostics.push(
-      "VALIDATION.md is advisory prose; enter an exact argv vector manually instead of inferring a command."
+      `${VALIDATION_CONTRACT_MARKDOWN_PATH} is advisory prose; enter an exact argv vector manually instead of inferring a command.`
     );
   }
   return proposals;
 }
+function numericContractProposals(workspaceRoot) {
+  const loaded = loadValidationContract(workspaceRoot);
+  if (!loaded.ok || loaded.contract === null) return [];
+  const proposals = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const artifact of loaded.contract.artifacts ?? []) {
+    if (artifact.numerical_tolerances === void 0) continue;
+    const tolerance = normalizeNumericTolerance(artifact.numerical_tolerances);
+    if (tolerance instanceof Error) continue;
+    const base = slug(path.basename(artifact.path).replace(/\.[^.]+$/u, ""), "artifact");
+    const preferred = boundedId(`numeric-${base}`);
+    let id = preferred;
+    for (let suffix = 2; seen.has(id); suffix += 1) id = `${boundedId(preferred, `-${suffix}`)}-${suffix}`;
+    seen.add(id);
+    const reference = `${artifact.path}.reference.json`;
+    proposals.push({
+      id,
+      artifactPath: artifact.path,
+      reference,
+      tolerance,
+      addCommand: `clio-coder verifiers add --id ${id} --kind numeric-compare --reference ${JSON.stringify(reference)} --tolerance '${JSON.stringify(tolerance)}' --description ${JSON.stringify(`Compare ${artifact.path} against its reference within tolerance`)} --command '["<executable>","<arg>"]'`
+    });
+  }
+  return proposals;
+}
 function deduplicatedRawProposals(proposals, diagnostics) {
   const seen = /* @__PURE__ */ new Map();
   for (const proposal of proposals.sort(rawProposalSort)) {
@@ -652,6 +642,7 @@ function discoverVerifierAuthoring(workspaceRoot = process.cwd()) {
     activeChecks,
     existingChecks,
     proposals,
+    numericProposals: numericContractProposals(workspaceRoot),
     diagnostics,
     manualEntry,
     ...typeof catalogText === "string" ? { catalogText } : {}
@@ -663,13 +654,28 @@ function createVerifierDraft(discovery, options = {}) {
     catalogPath: discovery.catalogPath,
     activeChecks: discovery.activeChecks.map(cloneCheck),
     checks: [...discovery.existingChecks, ...options.includeProposals === false ? [] : discovery.proposals].map(cloneCheck).sort((left, right) => compareCodepoints(left.id, right.id)),
+    numericProposals: options.includeProposals === false ? [] : discovery.numericProposals.map((proposal) => ({ ...proposal })),
     diagnostics: [...discovery.diagnostics],
     manualEntry: discovery.manualEntry,
     ...discovery.catalogText === void 0 ? {} : { catalogText: discovery.catalogText }
   };
 }
-function catalogEntry({ id, description, command, cwd, timeoutMs, tags }) {
-  return { id, description, command: [...command], cwd, timeoutMs, tags: [...tags] };
+function catalogEntry(check) {
+  const { id, description, command, cwd, timeoutMs, tags } = check;
+  const entry = { id, description, command: [...command], cwd, timeoutMs, tags: [...tags] };
+  const kind = check.kind ?? "command";
+  if (kind === "command") return entry;
+  entry.kind = kind;
+  if (check.numeric !== void 0) {
+    entry.reference = check.numeric.reference;
+    entry.tolerance = { ...check.numeric.tolerance };
+  }
+  if (check.perf !== void 0) {
+    if (check.perf.budget !== void 0) entry.budget = structuredClone(check.perf.budget);
+    if (check.perf.baseline !== void 0) entry.baseline = check.perf.baseline;
+    if (check.perf.tolerance !== void 0) entry.tolerance = { ...check.perf.tolerance };
+  }
+  return entry;
 }
 function serializeVerifierDraft(draft) {
   const checks = [...draft.checks].sort((left, right) => compareCodepoints(left.id, right.id));
@@ -697,8 +703,17 @@ function serializeVerifierDraft(draft) {
       node.set(field, value);
       changed = true;
     }
+    for (const field of ["kind", "reference", "tolerance", "budget", "baseline"]) {
+      if (Object.hasOwn(current, field) && !Object.hasOwn(entry, field)) {
+        node.delete(field);
+        changed = true;
+      }
+    }
   }
   if (!changed && appended.length === 0 && kept.size === sequence.items.length) return draft.catalogText;
+  if (document.get("version") !== PROJECT_VERIFIER_CATALOG_VERSION) {
+    document.set("version", PROJECT_VERIFIER_CATALOG_VERSION);
+  }
   sequence.items = [...sequence.items.filter((node) => (0, import_yaml.isMap)(node) && kept.has(node)), ...appended];
   return document.toString({ lineWidth: 0 });
 }
@@ -727,6 +742,7 @@ function validateVerifierDraft(draft) {
       cwd: check.cwd,
       timeoutMs: check.timeoutMs,
       tags: [...check.tags],
+      ...kindFields(check),
       provenance: original?.provenance ?? {
         kind: "manual-entry",
         path: PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
@@ -744,6 +760,7 @@ function cloneDraft(draft) {
     ...draft,
     activeChecks: draft.activeChecks.map(cloneCheck),
     checks: draft.checks.map(cloneCheck),
+    numericProposals: draft.numericProposals.map((proposal) => ({ ...proposal })),
     diagnostics: [...draft.diagnostics]
   };
 }
@@ -806,6 +823,17 @@ function reviseVerifierDraft(draft, revisions) {
     if (revision.changes.cwd !== void 0) check.cwd = revision.changes.cwd;
     if (revision.changes.timeoutMs !== void 0) check.timeoutMs = revision.changes.timeoutMs;
     if (revision.changes.tags !== void 0) check.tags = [...revision.changes.tags];
+    if (revision.changes.kind !== void 0) {
+      const next2 = kindFields({
+        kind: revision.changes.kind,
+        ...revision.changes.numeric !== void 0 ? { numeric: revision.changes.numeric } : {},
+        ...revision.changes.perf !== void 0 ? { perf: revision.changes.perf } : {}
+      });
+      delete check.kind;
+      delete check.numeric;
+      delete check.perf;
+      Object.assign(check, next2);
+    }
     diagnostics.push(`Edited check '${revision.id}' without changing its deterministic ID.`);
   }
   next.checks.sort((left, right) => compareCodepoints(left.id, right.id));
@@ -830,9 +858,24 @@ function renderCheck(check, destinationPath) {
     `  cwd: ${check.cwd}`,
     `  timeoutMs: ${check.timeoutMs}`,
     `  tags: ${JSON.stringify(check.tags)}`,
+    ...renderKind(check),
     `  effective execution authority: ${authorityDescription(check)}`
   ];
 }
+function renderKind(check) {
+  const kind = check.kind ?? "command";
+  if (kind === "command") return [];
+  const lines = [`  kind: ${kind}`];
+  if (check.numeric !== void 0) {
+    lines.push(`  reference: ${check.numeric.reference}`, `  tolerance: ${JSON.stringify(check.numeric.tolerance)}`);
+  }
+  if (check.perf !== void 0) {
+    if (check.perf.budget !== void 0) lines.push(`  budget: ${JSON.stringify(check.perf.budget)}`);
+    if (check.perf.baseline !== void 0) lines.push(`  baseline: ${check.perf.baseline}`);
+    if (check.perf.tolerance !== void 0) lines.push(`  tolerance: ${JSON.stringify(check.perf.tolerance)}`);
+  }
+  return lines;
+}
 function previewVerifierDraft(draft, options = {}) {
   const validation = validateVerifierDraft(draft);
   const lines = [
@@ -847,6 +890,18 @@ function previewVerifierDraft(draft, options = {}) {
   lines.push("", "Catalog checks after confirmation:");
   if (draft.checks.length === 0) lines.push("(none)");
   else for (const check of draft.checks) lines.push(...renderCheck(check, draft.catalogPath));
+  if (draft.numericProposals.length > 0) {
+    lines.push("", "Numeric-compare checks the validation contract implies (command required before they can be added):");
+    for (const proposal of draft.numericProposals) {
+      lines.push(
+        `- ${proposal.id}`,
+        `  artifact: ${proposal.artifactPath}`,
+        `  reference: ${proposal.reference}`,
+        `  tolerance: ${JSON.stringify(proposal.tolerance)}`,
+        `  add with: ${proposal.addCommand}`
+      );
+    }
+  }
   if (draft.diagnostics.length > 0) {
     lines.push("", "Diagnostics:");
     for (const diagnostic of draft.diagnostics) lines.push(`- ${diagnostic}`);
@@ -960,4 +1015,4 @@ export {
   previewVerifierDraft,
   runVerifierAuthoringWorkflow
 };
-//# sourceMappingURL=chunk-54CBCGIR.js.map
+//# sourceMappingURL=chunk-ZMZQEBKI.js.map

package/dist/{chunk-6EJMN2Y3.js → chunk-ZTNFYMIO.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/core/agent-environment.ts
 init_esm_shims();
@@ -14,4 +14,4 @@ export {
   AI_AGENT_NAME,
   withClioAgentEnvironment
 };
-//# sourceMappingURL=chunk-6EJMN2Y3.js.map
+//# sourceMappingURL=chunk-ZTNFYMIO.js.map

package/dist/{chunk-WEPFGWHJ.js → chunk-ZZFWWYLX.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/core/safe-resource-write.ts
 init_esm_shims();
@@ -120,4 +120,4 @@ export {
   fsyncDirectory,
   safeResourceWrite
 };
-//# sourceMappingURL=chunk-WEPFGWHJ.js.map
+//# sourceMappingURL=chunk-ZZFWWYLX.js.map

package/dist/cli/index.js

@@ -2,23 +2,22 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   traceBoot
-} from "../chunk-ZTJUVLTU.js";
+} from "../chunk-FXFVDPWY.js";
 import {
   extractGlobalFlags,
   parseFlags,
   printError
-} from "../chunk-VPKWYKEY.js";
-import "../chunk-5TSRNF4G.js";
+} from "../chunk-3T4DXWP6.js";
 import {
   incompleteInstallationAdvice
-} from "../chunk-65DEGPJ6.js";
-import "../chunk-IWHMRKLL.js";
+} from "../chunk-3A3CUMKA.js";
+import "../chunk-E3LEPLQ2.js";
 import {
   AI_AGENT_NAME
-} from "../chunk-6EJMN2Y3.js";
+} from "../chunk-ZTNFYMIO.js";
 import {
   init_esm_shims
-} from "../chunk-3R73A4XB.js";
+} from "../chunk-ECBHH7LU.js";
 
 // src/cli/index.ts
 init_esm_shims();
@@ -73,6 +72,7 @@ Usage:
   clio-coder extensions           install, list, enable, disable, or remove extension packages
   clio-coder skills               list, inspect, validate, or install skills
   clio-coder library              list, search, add, or sync agents, prompts, fleets, and skills from catalogs
+  clio-coder tasks                list, add, hand, finish, or drop project operator tasks
   clio-coder verifiers            discover, inspect, author, validate, edit, or dry-run project checks
   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
@@ -142,7 +142,7 @@ async function main(argv) {
     return 0;
   }
   if (flags.has("version") || flags.has("v")) {
-    const { runVersionCommand } = await import("../version-KGEG7EPO.js");
+    const { runVersionCommand } = await import("../version-RFPKO6T7.js");
     return runVersionCommand();
   }
   const subArgs = subcommandIndex === -1 ? [] : rest.slice(subcommandIndex + 1);
@@ -155,38 +155,38 @@ async function main(argv) {
   };
   if (!subcommand) {
     await enableBootCompileCache();
-    const { runClioCommand } = await import("../clio-CMMK4KRR.js");
+    const { runClioCommand } = await import("../clio-5I2IBFYL.js");
     return runClioCommand(bootOptions);
   }
   return dispatch(subcommand, subArgs, bootOptions);
 }
 async function enableBootCompileCache(subArgs = []) {
   if (subArgs.includes("--help") || subArgs.includes("-h")) return;
-  const { enableClioCompileCache } = await import("../compile-cache-OQAVB7Y5.js");
+  const { enableClioCompileCache } = await import("../compile-cache-WJEPUZEJ.js");
   enableClioCompileCache();
 }
-var extensionsCommand = async (subArgs) => (await import("../extensions-MOVJ32NM.js")).runExtensionsCommand(subArgs);
+var extensionsCommand = async (subArgs) => (await import("../extensions-YVRHX6ZI.js")).runExtensionsCommand(subArgs);
 var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
   [
     "acp",
     async (subArgs, bootOptions) => {
       await enableBootCompileCache(subArgs);
-      return (await import("../acp-H2NGRPWO.js")).runAcpCommand(subArgs, bootOptions);
+      return (await import("../acp-H3CU2HBQ.js")).runAcpCommand(subArgs, bootOptions);
     }
   ],
-  ["auth", async (subArgs) => (await import("../auth-E5SW4HMS.js")).runAuthCommand(subArgs)],
-  ["config", async (subArgs) => (await import("../config-SVM5P5YI.js")).runConfigCommand(subArgs)],
-  ["configure", async (subArgs) => (await import("../configure-LE3IK2TJ.js")).runConfigureCommand(subArgs)],
-  ["targets", async (subArgs) => (await import("../targets-4QC3HIEW.js")).runTargetsCommand(subArgs)],
-  ["models", async (subArgs) => (await import("../models-HEKUAXXK.js")).runModelsCommand(subArgs)],
-  ["agents", async (subArgs) => (await import("../agents-TL5LLUQP.js")).runAgentsCommand(subArgs)],
-  ["components", async (subArgs) => (await import("../components-UCUQ4QXW.js")).runComponentsCommand(subArgs)],
-  ["evidence", async (subArgs) => (await import("../evidence-VD6736FQ.js")).runEvidenceCommand(subArgs)],
-  ["eval", async (subArgs) => (await import("../eval-7G7SGAYO.js")).runEvalCommand(subArgs)],
-  ["memory", async (subArgs) => (await import("../memory-SGGSEP65.js")).runMemoryCommand(subArgs)],
-  ["usage", async (subArgs) => (await import("../usage-N7ZNVLEM.js")).runUsageCommand(subArgs)],
-  ["trace", async (subArgs) => (await import("../trace-FXMXUZUF.js")).runTraceCommand(subArgs)],
-  ["evolve", async (subArgs) => (await import("../evolve-AL3NGVRL.js")).runEvolveCommand(subArgs)],
+  ["auth", async (subArgs) => (await import("../auth-R7KYF7N3.js")).runAuthCommand(subArgs)],
+  ["config", async (subArgs) => (await import("../config-Y2JDJ3JJ.js")).runConfigCommand(subArgs)],
+  ["configure", async (subArgs) => (await import("../configure-SML6UBZ5.js")).runConfigureCommand(subArgs)],
+  ["targets", async (subArgs) => (await import("../targets-N5REUETU.js")).runTargetsCommand(subArgs)],
+  ["models", async (subArgs) => (await import("../models-3IK2Y5WE.js")).runModelsCommand(subArgs)],
+  ["agents", async (subArgs) => (await import("../agents-IXQQZ7BD.js")).runAgentsCommand(subArgs)],
+  ["components", async (subArgs) => (await import("../components-TNIKXCBH.js")).runComponentsCommand(subArgs)],
+  ["evidence", async (subArgs) => (await import("../evidence-SQ5DNFEN.js")).runEvidenceCommand(subArgs)],
+  ["eval", async (subArgs) => (await import("../eval-BUU3ZOUZ.js")).runEvalCommand(subArgs)],
+  ["memory", async (subArgs) => (await import("../memory-OQOXQGYD.js")).runMemoryCommand(subArgs)],
+  ["usage", async (subArgs) => (await import("../usage-4GWM2WWP.js")).runUsageCommand(subArgs)],
+  ["trace", async (subArgs) => (await import("../trace-JHLXWUMN.js")).runTraceCommand(subArgs)],
+  ["evolve", async (subArgs) => (await import("../evolve-IJNUFZDS.js")).runEvolveCommand(subArgs)],
   [
     "dev",
     async (subArgs, bootOptions) => {
@@ -205,31 +205,32 @@ var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
   ],
   ["extensions", extensionsCommand],
   ["ext", extensionsCommand],
-  ["fleet", async (subArgs) => (await import("../fleet-QZHUMAGI.js")).runFleetCommand(subArgs)],
-  ["skills", async (subArgs) => (await import("../skills-SG662R2K.js")).runSkillsCommand(subArgs)],
-  ["library", async (subArgs) => (await import("../library-QUQEIUG6.js")).runLibraryCommand(subArgs)],
-  ["verifiers", async (subArgs) => (await import("../verifiers-DJTP4XX6.js")).runVerifiersCommand(subArgs)],
-  ["docs", async (subArgs) => (await import("../docs-PD3EXDKU.js")).runDocsCommand(subArgs)],
-  ["share", async (subArgs) => (await import("../share-WML67FT3.js")).runShareCommand(subArgs)],
-  ["export", async (subArgs) => (await import("../share-WML67FT3.js")).runExportCommand(subArgs)],
-  ["import", async (subArgs) => (await import("../share-WML67FT3.js")).runImportCommand(subArgs)],
-  ["context", async (subArgs) => (await import("../context-E3VC7RX5.js")).runContextCommand(subArgs)],
+  ["fleet", async (subArgs) => (await import("../fleet-ZNNVSYFO.js")).runFleetCommand(subArgs)],
+  ["skills", async (subArgs) => (await import("../skills-S36AAJHU.js")).runSkillsCommand(subArgs)],
+  ["library", async (subArgs) => (await import("../library-GJI6W6OK.js")).runLibraryCommand(subArgs)],
+  ["tasks", async (subArgs) => (await import("../tasks-6BVY5YZF.js")).runTasksCommand(subArgs)],
+  ["verifiers", async (subArgs) => (await import("../verifiers-GSKWKWVG.js")).runVerifiersCommand(subArgs)],
+  ["docs", async (subArgs) => (await import("../docs-BL7ROUFN.js")).runDocsCommand(subArgs)],
+  ["share", async (subArgs) => (await import("../share-4JUB4BL7.js")).runShareCommand(subArgs)],
+  ["export", async (subArgs) => (await import("../share-4JUB4BL7.js")).runExportCommand(subArgs)],
+  ["import", async (subArgs) => (await import("../share-4JUB4BL7.js")).runImportCommand(subArgs)],
+  ["context", async (subArgs) => (await import("../context-S2EEC3EJ.js")).runContextCommand(subArgs)],
   [
     "run",
     async (subArgs, bootOptions) => {
       await enableBootCompileCache(subArgs);
-      return (await import("../run-7DP7ZF2J.js")).runClioRun(subArgs, bootOptions);
+      return (await import("../run-3VFZQ33N.js")).runClioRun(subArgs, bootOptions);
     }
   ],
-  ["tools", async (subArgs) => (await import("../tools-TFGJICCU.js")).runToolsCommand(subArgs)],
-  ["interop", async (subArgs) => (await import("../interop-3FCM6XLG.js")).runInteropCommand(subArgs)],
-  ["panes", async (subArgs) => (await import("../panes-TALGNPZT.js")).runPanesCommand(subArgs)],
-  ["doctor", async (subArgs) => (await import("../doctor-WNNVO6FY.js")).runDoctorCommand(subArgs)],
-  ["paths", async (subArgs) => (await import("../paths-NBMFAIEZ.js")).runPathsCommand(subArgs)],
-  ["reset", async (subArgs) => (await import("../reset-EAJFFJVB.js")).runResetCommand(subArgs)],
-  ["uninstall", async (subArgs) => (await import("../uninstall-5PEVOE5B.js")).runUninstallCommand(subArgs)],
-  ["upgrade", async (subArgs) => (await import("../upgrade-M4WXY6KN.js")).runUpgradeCommand(subArgs)],
-  ["version", async () => (await import("../version-KGEG7EPO.js")).runVersionCommand()],
+  ["tools", async (subArgs) => (await import("../tools-6OCQ6SVB.js")).runToolsCommand(subArgs)],
+  ["interop", async (subArgs) => (await import("../interop-YOTGXFJM.js")).runInteropCommand(subArgs)],
+  ["panes", async (subArgs) => (await import("../panes-WPOMEMRH.js")).runPanesCommand(subArgs)],
+  ["doctor", async (subArgs) => (await import("../doctor-N3LCM2LG.js")).runDoctorCommand(subArgs)],
+  ["paths", async (subArgs) => (await import("../paths-J3KN7UAO.js")).runPathsCommand(subArgs)],
+  ["reset", async (subArgs) => (await import("../reset-MUVQDLNL.js")).runResetCommand(subArgs)],
+  ["uninstall", async (subArgs) => (await import("../uninstall-FXYMFFRT.js")).runUninstallCommand(subArgs)],
+  ["upgrade", async (subArgs) => (await import("../upgrade-4HD5HAIV.js")).runUpgradeCommand(subArgs)],
+  ["version", async () => (await import("../version-RFPKO6T7.js")).runVersionCommand()],
   [
     "worker",
     async () => {

package/dist/clio-5I2IBFYL.js

@@ -0,0 +1,26 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  runClioCommand
+} from "./chunk-SBZX6ARC.js";
+import "./chunk-YYB3MC65.js";
+import "./chunk-T53XI6I7.js";
+import "./chunk-FXFVDPWY.js";
+import "./chunk-NTK3WTHM.js";
+import "./chunk-FKIOX6DS.js";
+import "./chunk-DVNAPPXU.js";
+import "./chunk-E3LEPLQ2.js";
+import "./chunk-SE4ZKILO.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-2QPI3TR3.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-DXVMLM3Z.js";
+import "./chunk-CTTI7G3T.js";
+import "./chunk-ECBHH7LU.js";
+export {
+  runClioCommand
+};
+//# sourceMappingURL=clio-5I2IBFYL.js.map