@iowarp/clio-coder 0.4.0 → 0.4.2

package/dist/{chunk-X75E3D2N.js → chunk-ZGNYYXQ6.js}

@@ -2,10 +2,10 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   parseJsonObjectPayload,
   parseVerifierResult
-} from "./chunk-DYJP44XW.js";
+} from "./chunk-PGF63K6I.js";
 import {
   atomicWrite
-} from "./chunk-76ONBSIA.js";
+} from "./chunk-MQXIVJ35.js";
 import {
   clioStateDir
 } from "./chunk-BYP5D4HI.js";
@@ -143,7 +143,7 @@ function semanticError(value) {
   }
   const needsWinner = value.outcome === "winner" || value.outcome === "operator-confirmed" || value.outcome === "full-auto-applied";
   if (needsWinner) {
-    if (!isRecord(value.winner) || typeof value.winner.index !== "number" || !Number.isInteger(value.winner.index) || value.winner.index < 1 || !isSubjectRef(value.winner.subject) || typeof value.winner.branch !== "string" || value.winner.branch !== `clio/compete/${value.group}/${value.winner.index}`) {
+    if (!isRecord(value.winner) || typeof value.winner.index !== "number" || !Number.isInteger(value.winner.index) || value.winner.index < 1 || !isSubjectRef(value.winner.subject) || typeof value.winner.branch !== "string" || value.winner.branch !== `clio-coder/compete/${value.group}/${value.winner.index}` && value.winner.branch !== `clio/compete/${value.group}/${value.winner.index}`) {
       return "gate decision winner invalid";
     }
     const winnerSubject = value.winner.subject;
@@ -180,9 +180,9 @@ function decisionArtifactPath(id, stateDir = clioStateDir()) {
 function pendingDecisionPath(id, stateDir = clioStateDir()) {
   return join(pendingDecisionsDirectory(stateDir), `${id}.json`);
 }
-function decisionPayload(decision) {
+function decisionPayload(decision, legacyNaming = false) {
   return {
-    contract: "clio.gateDecision.integrity",
+    contract: legacyNaming ? "clio.gateDecision.integrity" : "clio-coder.gateDecision.integrity",
     version: decision.version,
     id: decision.id,
     group: decision.group,
@@ -207,8 +207,8 @@ function decisionPayload(decision) {
     createdAt: decision.createdAt
   };
 }
-function decisionDigest(decision) {
-  return createHash("sha256").update(JSON.stringify(decisionPayload(decision)), "utf8").digest("hex");
+function decisionDigest(decision, legacyNaming = false) {
+  return createHash("sha256").update(JSON.stringify(decisionPayload(decision, legacyNaming)), "utf8").digest("hex");
 }
 function artifactWithoutIntegrity(artifact) {
   const result = {
@@ -238,7 +238,8 @@ function verifyGateDecisionArtifact(artifact) {
   const invalid = semanticError(artifact);
   if (invalid !== null) return { ok: false, reason: invalid };
   if (!/^[0-9a-f]{64}$/.test(artifact.integrity.digest)) return { ok: false, reason: "gate decision integrity invalid" };
-  return decisionDigest(artifactWithoutIntegrity(artifact)) === artifact.integrity.digest ? { ok: true } : { ok: false, reason: "gate decision integrity mismatch" };
+  const withoutIntegrity = artifactWithoutIntegrity(artifact);
+  return decisionDigest(withoutIntegrity) === artifact.integrity.digest || decisionDigest(withoutIntegrity, true) === artifact.integrity.digest ? { ok: true } : { ok: false, reason: "gate decision integrity mismatch" };
 }
 function buildGateDecisionArtifact(draft, id = newDecisionId(draft.group), createdAt = draft.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()) {
   if (draft.group.trim().length === 0) throw new Error("gate decision group is required");
@@ -310,10 +311,10 @@ function cloneGateDecisionArtifact(artifact) {
     integrity: { ...artifact.integrity }
   };
 }
-function pendingRecordPayload(record) {
+function pendingRecordPayload(record, legacyNaming = false) {
   if (record.kind === "output") {
     return {
-      contract: "clio.gateDecision.pending",
+      contract: legacyNaming ? "clio.gateDecision.pending" : "clio-coder.gateDecision.pending",
       version: record.version,
       kind: record.kind,
       id: record.id,
@@ -330,12 +331,12 @@ function pendingRecordPayload(record) {
   }
   const decisionWithoutIntegrity = artifactWithoutIntegrity(record.decision);
   return {
-    contract: "clio.gateDecision.pending",
+    contract: legacyNaming ? "clio.gateDecision.pending" : "clio-coder.gateDecision.pending",
     version: record.version,
     kind: record.kind,
     id: record.id,
     decision: {
-      ...decisionPayload(decisionWithoutIntegrity),
+      ...decisionPayload(decisionWithoutIntegrity, legacyNaming),
       integrity: { ...record.decision.integrity }
     },
     ...record.finalOutput !== void 0 ? { finalOutput: record.finalOutput } : {},
@@ -343,8 +344,8 @@ function pendingRecordPayload(record) {
     createdAt: record.createdAt
   };
 }
-function pendingRecordDigest(record) {
-  return createHash("sha256").update(JSON.stringify(pendingRecordPayload(record)), "utf8").digest("hex");
+function pendingRecordDigest(record, legacyNaming = false) {
+  return createHash("sha256").update(JSON.stringify(pendingRecordPayload(record, legacyNaming)), "utf8").digest("hex");
 }
 function pendingRecordWithoutIntegrity(record) {
   if (record.kind === "output") {
@@ -425,7 +426,8 @@ function pendingSemanticError(value) {
 function verifyPendingGateDecisionRecord(record) {
   const invalid = pendingSemanticError(record);
   if (invalid !== null) return { ok: false, reason: invalid };
-  return pendingRecordDigest(pendingRecordWithoutIntegrity(record)) === record.integrity.digest ? { ok: true } : { ok: false, reason: "pending gate decision integrity mismatch" };
+  const withoutIntegrity = pendingRecordWithoutIntegrity(record);
+  return pendingRecordDigest(withoutIntegrity) === record.integrity.digest || pendingRecordDigest(withoutIntegrity, true) === record.integrity.digest ? { ok: true } : { ok: false, reason: "pending gate decision integrity mismatch" };
 }
 function clonePendingGateDecisionRecord(record) {
   const without = pendingRecordWithoutIntegrity(record);
@@ -683,4 +685,4 @@ export {
   readGateDecisionArtifacts,
   readGateDecisionArtifactsForRunIds
 };
-//# sourceMappingURL=chunk-X75E3D2N.js.map
+//# sourceMappingURL=chunk-ZGNYYXQ6.js.map

package/dist/{chunk-LY4S7GJC.js → chunk-ZNT2M6TG.js}

@@ -1,46 +1,48 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   parseAgentRecipeSchema
-} from "./chunk-Z4TXYIEG.js";
+} from "./chunk-CRFOIAX3.js";
 import {
   discoverMarketplaceSkills,
   expandSkillInvocationInput,
   installSkill,
   loadSkills,
-  normalizedSkillHash,
   parsePendingSkillRequests,
   projectCompatTrusted
-} from "./chunk-VYMXRQI6.js";
+} from "./chunk-O3YUNJZ2.js";
+import {
+  normalizedSkillHash
+} from "./chunk-NDDGJUXD.js";
 import {
   COMPAT_RESOURCE_PRECEDENCE,
   defaultScopedResourceRoots,
   sourceInfoForRoot,
   splitYamlFrontmatter,
   stringField
-} from "./chunk-FEFIFZTL.js";
+} from "./chunk-XGDPUNND.js";
 import {
   parseFleetContract
-} from "./chunk-CTJ4RNAA.js";
+} from "./chunk-3F7VUY77.js";
 import {
   parseFrontmatter
 } from "./chunk-RKKLTLYB.js";
 import {
   assertAgentSpecPolicy,
   normalizeAgentSpec
-} from "./chunk-DYJP44XW.js";
+} from "./chunk-PGF63K6I.js";
 import {
   INTEROP_AGENT_KINDS
 } from "./chunk-IHXBNWMM.js";
 import {
   readSettings,
   updateSettings
-} from "./chunk-VFA6GDY5.js";
+} from "./chunk-34BHNEE3.js";
 import {
   runCommandVector
-} from "./chunk-BBVJUZHB.js";
+} from "./chunk-HJWWJ6IL.js";
 import {
   expandConfigPath
-} from "./chunk-SST6Z5JA.js";
+} from "./chunk-336NSSKI.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -345,7 +347,7 @@ function expandPromptTemplateInput(input, templates) {
     };
   }
   if (!template.trusted) {
-    const message = `prompt template ${template.name} comes from an untrusted project root; set skills.trustProjectCompatRoots to use it`;
+    const message = `prompt template ${template.name} comes from an untrusted project root; set integrations.projectResources.trustProjectImports to use it`;
     return {
       expanded: false,
       text: input,
@@ -405,7 +407,7 @@ function createResourcesBundle(context, options = {}) {
     ...options.cwd !== void 0 ? { cwd: options.cwd } : {},
     ...options.reservedPromptNames !== void 0 ? { reservedPromptNames: options.reservedPromptNames } : {},
     skills: () => ({
-      ...skillOptions(config()?.get().skills.trustProjectCompatRoots === true, options)
+      ...skillOptions(config()?.get().integrations.projectResources.trustProjectImports === true, options)
     })
   });
   const extension = {
@@ -464,7 +466,7 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function catalogPath() {
-  const configured = readSettings().library.catalog;
+  const configured = readSettings().integrations.library.catalog;
   return path2.resolve(configured ?? path2.join(clioConfigDir(), "library.yaml"));
 }
 function parseCatalog(filePath, diagnostics) {
@@ -647,20 +649,20 @@ function installLibraryPlan(plan) {
   recordPin(plan);
 }
 function confirmedRemote() {
-  const settings = readSettings().library;
+  const settings = readSettings().integrations.library;
   if (!settings.remote || settings.remote !== settings.confirmedRemote) throw new Error("library_remote_unconfirmed");
   return settings.remote;
 }
 function confirmLibraryRemote(url) {
-  const current = readSettings().library.remote;
+  const current = readSettings().integrations.library.remote;
   if (current !== null && current !== url) throw new Error("library_remote_mismatch");
   updateSettings((settings) => {
-    if (settings.library.remote === null) settings.library.remote = url;
-    settings.library.confirmedRemote = url;
+    if (settings.integrations.library.remote === null) settings.integrations.library.remote = url;
+    settings.integrations.library.confirmedRemote = url;
   });
 }
 async function syncLibrary(direction, runner = runCommandVector) {
-  const settings = readSettings().library;
+  const settings = readSettings().integrations.library;
   if (!settings.sync) throw new Error("library_sync_disabled");
   const remote = confirmedRemote();
   const cwd = path2.dirname(catalogPath());
@@ -906,4 +908,4 @@ export {
   ResourcesDomainModule,
   createResourcesDomainModule
 };
-//# sourceMappingURL=chunk-LY4S7GJC.js.map
+//# sourceMappingURL=chunk-ZNT2M6TG.js.map

package/dist/{chunk-HKIYEGME.js → chunk-ZTJUVLTU.js}

@@ -12,7 +12,7 @@ function isBootTraceEnabled() {
 function formatBootTrace(phase, detail) {
   if (!isBootTraceEnabled()) return null;
   const suffix = detail !== void 0 && detail.length > 0 ? ` (${detail})` : "";
-  return `[clio:boot] +${performance.now().toFixed(1)}ms ${phase}${suffix}
+  return `[clio-coder:boot] +${performance.now().toFixed(1)}ms ${phase}${suffix}
 `;
 }
 function traceBoot(phase, detail) {
@@ -27,4 +27,4 @@ export {
   formatBootTrace,
   traceBoot
 };
-//# sourceMappingURL=chunk-HKIYEGME.js.map
+//# sourceMappingURL=chunk-ZTJUVLTU.js.map

package/dist/{chunk-IBEBSCYA.js → chunk-ZW4HH5JJ.js}

@@ -1,25 +1,27 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  truncateToWidth
-} from "./chunk-NYS75XW5.js";
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi
+} from "./chunk-YAKGTXEV.js";
 import {
   openLedger,
   readFleetRun
-} from "./chunk-BUMFYQFY.js";
+} from "./chunk-I66ZTYNP.js";
 import {
   formatTrustSummaryLine,
   inspectRunReceiptTrustStatus
-} from "./chunk-B7OBL7PK.js";
+} from "./chunk-B74PXLU7.js";
 import {
   WRITE_BOUNDARY_VIOLATION_REASON
-} from "./chunk-U77AMWDL.js";
+} from "./chunk-W6NIE6OW.js";
 import {
   readRunEventJournal,
   runEventJournalPath
-} from "./chunk-IQ7KR472.js";
+} from "./chunk-VIA6RFQZ.js";
 import {
   sanitizeCallTargetText
-} from "./chunk-TVHHYFHE.js";
+} from "./chunk-NEDJ26B5.js";
 import {
   clioStateDir,
   resetXdgCache
@@ -45,7 +47,7 @@ run event journal, and the sealed receipt once it exists.
 
 Without --follow the current snapshot is printed and the command exits.
 The transcript comes from <state>/runs/<runId>/events.ndjson, which the
-orchestrator writes when panes.journal is on (the default). A run dispatched
+orchestrator writes when fleet.history.journal is on (the default). A run dispatched
 with the journal off shows its ledger and receipt but no transcript.
 
 Given the fleet root id that \`fleet run\` prints (fleet-<hex>), this prints the
@@ -65,6 +67,9 @@ function sanitizeBounded(value, maxWidth) {
   if (sanitized.length === 0) return "";
   return sanitizeCallTargetText(truncateToWidth(sanitized, maxWidth, "\u2026", false));
 }
+function truncatePlain(value, width) {
+  return truncateToWidth(value, width, "\u2026", false).replaceAll("\x1B[0m", "");
+}
 function receiptPathFor(run) {
   return run.receiptPath ?? join(clioStateDir(), "receipts", `${run.id}.json`);
 }
@@ -175,42 +180,54 @@ function clockOf(iso) {
   const time = iso.slice(11, 19);
   return time.length === 8 ? time : iso.slice(0, 8);
 }
+function wrapViewerValue(prefix, value, columns) {
+  const prefixWidth = visibleWidth(prefix);
+  const valueWidth = Math.max(1, columns - prefixWidth);
+  return wrapTextWithAnsi(value, valueWidth).map(
+    (line, index) => `${index === 0 ? prefix : " ".repeat(prefixWidth)}${line}`
+  );
+}
 function renderRunView(model, width = DEFAULT_WIDTH) {
   const columns = Math.max(MIN_WIDTH, width);
   const rule = "\u2500".repeat(columns);
   const lines = [];
-  lines.push(truncateToWidth(`run ${model.runId}  ${model.agentId}`, columns, "\u2026", false));
+  lines.push(truncatePlain(`run ${model.runId}  ${model.agentId}`, columns));
   lines.push(
-    truncateToWidth(
+    truncatePlain(
       `model ${model.model}  target ${model.target}  node ${model.node}  phase ${model.phase}  elapsed ${formatElapsed(model.elapsedMs)}`,
-      columns,
-      "\u2026",
-      false
+      columns
     )
   );
   if (model.task !== void 0) {
-    lines.push(truncateToWidth(`task ${model.task}`, columns, "\u2026", false));
+    lines.push(...wrapViewerValue("task ", model.task, columns));
   }
   lines.push(rule);
   if (!model.journalPresent) {
     lines.push("no event journal for this run.");
-    lines.push(`expected ${model.journalPath} (panes.journal may have been off when it ran)`);
+    lines.push(
+      ...wrapViewerValue(
+        "expected ",
+        `${model.journalPath} (fleet.history.journal may have been off when it ran)`,
+        columns
+      )
+    );
   } else if (model.transcript.length === 0) {
     lines.push("journal is empty; no events recorded yet.");
   } else {
     if (model.transcriptTruncated) lines.push("\u2026 earlier events dropped (journal truncated)");
     for (const entry of model.transcript) {
       const head = `${clockOf(entry.at)} ${entry.label}`;
-      lines.push(truncateToWidth(entry.detail === void 0 ? head : `${head}: ${entry.detail}`, columns, "\u2026", false));
+      if (entry.detail === void 0) lines.push(truncatePlain(head, columns));
+      else lines.push(...wrapViewerValue(`${head}: `, entry.detail, columns));
     }
   }
   lines.push(rule);
-  lines.push(truncateToWidth(`evidence  ${model.evidence}`, columns, "\u2026", false));
+  lines.push(...wrapViewerValue("evidence  ", model.evidence, columns));
   if (model.receiptPath !== null) {
-    lines.push(truncateToWidth(`receipt   ${model.receiptPath}`, columns, "\u2026", false));
+    lines.push(truncatePlain(`receipt   ${model.receiptPath}`, columns));
   }
   const outcome = model.outcome === null ? model.terminal ? "terminal, outcome not recorded" : "running" : model.outcomeDetail === null || model.outcomeDetail.length === 0 ? model.outcome : `${model.outcome} (${sanitizeBounded(model.outcomeDetail, DETAIL_MAX_WIDTH)})`;
-  lines.push(truncateToWidth(`outcome   ${outcome}`, columns, "\u2026", false));
+  lines.push(...wrapViewerValue("outcome   ", outcome, columns));
   return lines;
 }
 function renderWatchView(runId, model, width = DEFAULT_WIDTH, ledgerRoot = clioStateDir()) {
@@ -303,14 +320,12 @@ function renderFleetRunView(model, width = DEFAULT_WIDTH) {
   const columns = Math.max(MIN_WIDTH, width);
   const rule = "\u2500".repeat(columns);
   const lines = [];
-  lines.push(truncateToWidth(`fleet ${sanitizeBounded(model.fleet, 64)}  root ${model.rootId}`, columns, "\u2026", false));
+  lines.push(truncatePlain(`fleet ${sanitizeBounded(model.fleet, 64)}  root ${model.rootId}`, columns));
   const resumed = model.resumedFrom === null ? "" : `  resumed from ${sanitizeBounded(model.resumedFrom, 64)}`;
   lines.push(
-    truncateToWidth(
+    truncatePlain(
       `started ${model.startedAt}  elapsed ${formatElapsed(model.elapsedMs)}  ${model.recordedSteps} of ${model.plannedSteps} steps recorded${model.running ? "  (running)" : ""}${resumed}`,
-      columns,
-      "\u2026",
-      false
+      columns
     )
   );
   lines.push(rule);
@@ -329,7 +344,7 @@ function renderFleetRunView(model, width = DEFAULT_WIDTH) {
     for (const row of rows) {
       const head = `${row.step.padEnd(stepWidth)}  ${row.runId.padEnd(runWidth)}  ${row.outcome.padEnd(outcomeWidth)}`;
       const text = row.tail.length === 0 ? head : `${head}  ${sanitizeBounded(row.tail, DETAIL_MAX_WIDTH)}`;
-      lines.push(truncateToWidth(text.trimEnd(), columns, "\u2026", false));
+      lines.push(truncatePlain(text.trimEnd(), columns));
     }
   }
   lines.push(rule);
@@ -463,7 +478,7 @@ async function runFleetView(args) {
   return followRun(runId);
 }
 async function watchSelection(selectionPath) {
-  const { ProcessTerminal, TuiAltScreen } = await import("./tui-primitives-2AKXQNZK.js");
+  const { ProcessTerminal, TuiAltScreen } = await import("./tui-primitives-K5PASC3O.js");
   const terminal = new ProcessTerminal();
   const tui = new TuiAltScreen(terminal);
   let selected = readWatchSelection(selectionPath);
@@ -506,7 +521,7 @@ async function watchSelection(selectionPath) {
   });
 }
 async function followRun(runId) {
-  const { ProcessTerminal, TuiAltScreen } = await import("./tui-primitives-2AKXQNZK.js");
+  const { ProcessTerminal, TuiAltScreen } = await import("./tui-primitives-K5PASC3O.js");
   const terminal = new ProcessTerminal();
   const tui = new TuiAltScreen(terminal);
   let model = loadRunViewModel(runId);
@@ -551,14 +566,8 @@ async function followRun(runId) {
 }
 
 export {
-  resolveRunId,
   loadRunViewModel,
-  renderRunView,
-  renderWatchView,
-  resolveFleetRootId,
   loadFleetRunViewModel,
-  renderFleetRunView,
-  readWatchSelection,
   runFleetView
 };
-//# sourceMappingURL=chunk-IBEBSCYA.js.map
+//# sourceMappingURL=chunk-ZW4HH5JJ.js.map

package/dist/{chunk-2ANTL7MR.js → chunk-ZW55JB7N.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-5TSRNF4G.js";
 import {
   authStoragePath
-} from "./chunk-BBVYXMFO.js";
+} from "./chunk-WNP7O5WZ.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -35,4 +35,4 @@ export {
   printPlaintextCredentialWarning,
   credentialWriteFailed
 };
-//# sourceMappingURL=chunk-2ANTL7MR.js.map
+//# sourceMappingURL=chunk-ZW55JB7N.js.map

package/dist/cli/index.js

@@ -2,7 +2,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   traceBoot
-} from "../chunk-HKIYEGME.js";
+} from "../chunk-ZTJUVLTU.js";
 import {
   incompleteInstallationAdvice
 } from "../chunk-65DEGPJ6.js";
@@ -50,6 +50,7 @@ Usage:
   clio-coder auth list|status|login|logout [target-or-runtime]
   clio-coder doctor [--fix]       diagnose state; --fix creates or repairs it
   clio-coder paths [--json]       print resolved config/data/cache directories
+  clio-coder config inspect [--json]  inspect effective customization and provenance
   clio-coder reset                recover or wipe Clio Coder state
   clio-coder context              show project context status (CLIO-CODER.md, preload, codewiki)
   clio-coder context init [--yes] [--preview|--heuristic]  explore the repo and bootstrap CLIO-CODER.md and codewiki
@@ -74,7 +75,7 @@ Usage:
   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
-  clio-coder panes install        install the pane multiplexer (alias for 'tools install herdr')
+  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]         serve the HTML docs of a source checkout on 127.0.0.1 (--no-open to skip browser)
   clio-coder dev <command>        harness instruments; run 'clio-coder dev' for the list
   clio-coder --help, -h           this message
@@ -153,38 +154,38 @@ async function main(argv) {
   };
   if (!subcommand) {
     await enableBootCompileCache();
-    const { runClioCommand } = await import("../clio-2JXHBBY5.js");
+    const { runClioCommand } = await import("../clio-7VB377CC.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-7FPE6PS3.js");
+  const { enableClioCompileCache } = await import("../compile-cache-OQAVB7Y5.js");
   enableClioCompileCache();
 }
-var extensionsCommand = async (subArgs) => (await import("../extensions-7BGBHN57.js")).runExtensionsCommand(subArgs);
+var extensionsCommand = async (subArgs) => (await import("../extensions-KPZ2UHBB.js")).runExtensionsCommand(subArgs);
 var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
   [
     "acp",
     async (subArgs, bootOptions) => {
       await enableBootCompileCache(subArgs);
-      return (await import("../acp-G5WJBNCT.js")).runAcpCommand(subArgs, bootOptions);
+      return (await import("../acp-TMDQZDIG.js")).runAcpCommand(subArgs, bootOptions);
     }
   ],
-  ["auth", async (subArgs) => (await import("../auth-3IDSJEIK.js")).runAuthCommand(subArgs)],
-  ["config", async (subArgs) => (await import("../config-QZPCMYSO.js")).runConfigCommand(subArgs)],
-  ["configure", async (subArgs) => (await import("../configure-TEGEBYCA.js")).runConfigureCommand(subArgs)],
-  ["targets", async (subArgs) => (await import("../targets-NCPZ644J.js")).runTargetsCommand(subArgs)],
-  ["models", async (subArgs) => (await import("../models-CEYXJBO6.js")).runModelsCommand(subArgs)],
-  ["agents", async (subArgs) => (await import("../agents-FMV2Q5G4.js")).runAgentsCommand(subArgs)],
-  ["components", async (subArgs) => (await import("../components-RYZV4JGP.js")).runComponentsCommand(subArgs)],
-  ["evidence", async (subArgs) => (await import("../evidence-ERGESKGN.js")).runEvidenceCommand(subArgs)],
-  ["eval", async (subArgs) => (await import("../eval-TFBYQH4H.js")).runEvalCommand(subArgs)],
-  ["memory", async (subArgs) => (await import("../memory-I4C4HMLW.js")).runMemoryCommand(subArgs)],
-  ["usage", async (subArgs) => (await import("../usage-3NLHGTU2.js")).runUsageCommand(subArgs)],
-  ["trace", async (subArgs) => (await import("../trace-FYVW2MQA.js")).runTraceCommand(subArgs)],
-  ["evolve", async (subArgs) => (await import("../evolve-VDXTSYCJ.js")).runEvolveCommand(subArgs)],
+  ["auth", async (subArgs) => (await import("../auth-Z5CCBXKQ.js")).runAuthCommand(subArgs)],
+  ["config", async (subArgs) => (await import("../config-4HVOS65E.js")).runConfigCommand(subArgs)],
+  ["configure", async (subArgs) => (await import("../configure-PIWO7B24.js")).runConfigureCommand(subArgs)],
+  ["targets", async (subArgs) => (await import("../targets-P2FUC4IL.js")).runTargetsCommand(subArgs)],
+  ["models", async (subArgs) => (await import("../models-2GPMFYCM.js")).runModelsCommand(subArgs)],
+  ["agents", async (subArgs) => (await import("../agents-5N5NG3XG.js")).runAgentsCommand(subArgs)],
+  ["components", async (subArgs) => (await import("../components-UBWCQSRW.js")).runComponentsCommand(subArgs)],
+  ["evidence", async (subArgs) => (await import("../evidence-6SHONYAF.js")).runEvidenceCommand(subArgs)],
+  ["eval", async (subArgs) => (await import("../eval-C45FYRJ6.js")).runEvalCommand(subArgs)],
+  ["memory", async (subArgs) => (await import("../memory-HYOKAGGJ.js")).runMemoryCommand(subArgs)],
+  ["usage", async (subArgs) => (await import("../usage-ME5MPXGX.js")).runUsageCommand(subArgs)],
+  ["trace", async (subArgs) => (await import("../trace-YMGMUM6A.js")).runTraceCommand(subArgs)],
+  ["evolve", async (subArgs) => (await import("../evolve-KRKMV72X.js")).runEvolveCommand(subArgs)],
   [
     "dev",
     async (subArgs, bootOptions) => {
@@ -203,30 +204,30 @@ var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
   ],
   ["extensions", extensionsCommand],
   ["ext", extensionsCommand],
-  ["fleet", async (subArgs) => (await import("../fleet-2RRVDF2V.js")).runFleetCommand(subArgs)],
-  ["skills", async (subArgs) => (await import("../skills-L55TEW6R.js")).runSkillsCommand(subArgs)],
-  ["library", async (subArgs) => (await import("../library-YWZG7IMW.js")).runLibraryCommand(subArgs)],
-  ["verifiers", async (subArgs) => (await import("../verifiers-SSQONKRT.js")).runVerifiersCommand(subArgs)],
-  ["docs", async (subArgs) => (await import("../docs-23KQS3XK.js")).runDocsCommand(subArgs)],
-  ["share", async (subArgs) => (await import("../share-GTJN6A5O.js")).runShareCommand(subArgs)],
-  ["export", async (subArgs) => (await import("../share-GTJN6A5O.js")).runExportCommand(subArgs)],
-  ["import", async (subArgs) => (await import("../share-GTJN6A5O.js")).runImportCommand(subArgs)],
-  ["context", async (subArgs) => (await import("../context-AV7OEZ4D.js")).runContextCommand(subArgs)],
+  ["fleet", async (subArgs) => (await import("../fleet-IVTCKDHT.js")).runFleetCommand(subArgs)],
+  ["skills", async (subArgs) => (await import("../skills-IYMXMKW4.js")).runSkillsCommand(subArgs)],
+  ["library", async (subArgs) => (await import("../library-LSCATDLZ.js")).runLibraryCommand(subArgs)],
+  ["verifiers", async (subArgs) => (await import("../verifiers-BVZ7IWOO.js")).runVerifiersCommand(subArgs)],
+  ["docs", async (subArgs) => (await import("../docs-PD3EXDKU.js")).runDocsCommand(subArgs)],
+  ["share", async (subArgs) => (await import("../share-IHWTLO3M.js")).runShareCommand(subArgs)],
+  ["export", async (subArgs) => (await import("../share-IHWTLO3M.js")).runExportCommand(subArgs)],
+  ["import", async (subArgs) => (await import("../share-IHWTLO3M.js")).runImportCommand(subArgs)],
+  ["context", async (subArgs) => (await import("../context-N6ZE3LGJ.js")).runContextCommand(subArgs)],
   [
     "run",
     async (subArgs, bootOptions) => {
       await enableBootCompileCache(subArgs);
-      return (await import("../run-H2GQDUER.js")).runClioRun(subArgs, bootOptions);
+      return (await import("../run-5DEYH5QK.js")).runClioRun(subArgs, bootOptions);
     }
   ],
-  ["tools", async (subArgs) => (await import("../tools-DAF3DI3C.js")).runToolsCommand(subArgs)],
-  ["interop", async (subArgs) => (await import("../interop-OZBKXAYL.js")).runInteropCommand(subArgs)],
-  ["panes", async (subArgs) => (await import("../panes-HMABYVO4.js")).runPanesCommand(subArgs)],
-  ["doctor", async (subArgs) => (await import("../doctor-QOA5FNY5.js")).runDoctorCommand(subArgs)],
-  ["paths", async (subArgs) => (await import("../paths-II4K7DNR.js")).runPathsCommand(subArgs)],
-  ["reset", async (subArgs) => (await import("../reset-DQ6FGCSH.js")).runResetCommand(subArgs)],
-  ["uninstall", async (subArgs) => (await import("../uninstall-DW2PNOIC.js")).runUninstallCommand(subArgs)],
-  ["upgrade", async (subArgs) => (await import("../upgrade-3XPP6OQL.js")).runUpgradeCommand(subArgs)],
+  ["tools", async (subArgs) => (await import("../tools-5B7RO6MV.js")).runToolsCommand(subArgs)],
+  ["interop", async (subArgs) => (await import("../interop-IN5I2A66.js")).runInteropCommand(subArgs)],
+  ["panes", async (subArgs) => (await import("../panes-IXKLOKA2.js")).runPanesCommand(subArgs)],
+  ["doctor", async (subArgs) => (await import("../doctor-LHBD36VU.js")).runDoctorCommand(subArgs)],
+  ["paths", async (subArgs) => (await import("../paths-L7LGY6RN.js")).runPathsCommand(subArgs)],
+  ["reset", async (subArgs) => (await import("../reset-OAQP3W4O.js")).runResetCommand(subArgs)],
+  ["uninstall", async (subArgs) => (await import("../uninstall-N34PCTGJ.js")).runUninstallCommand(subArgs)],
+  ["upgrade", async (subArgs) => (await import("../upgrade-PXK3S2YM.js")).runUpgradeCommand(subArgs)],
   ["version", async () => (await import("../version-KGEG7EPO.js")).runVersionCommand()],
   [
     "worker",

package/dist/{clio-2JXHBBY5.js → clio-7VB377CC.js}

@@ -1,17 +1,17 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  runClioCommand,
-  terminalLeaseEligible
-} from "./chunk-GR5G2PVF.js";
-import "./chunk-7MCTRUCE.js";
-import "./chunk-HKIYEGME.js";
-import "./chunk-2OQE55CK.js";
-import "./chunk-VFA6GDY5.js";
-import "./chunk-FQ4SKYE4.js";
+  runClioCommand
+} from "./chunk-2HFQNRV3.js";
+import "./chunk-M2DAX4F6.js";
+import "./chunk-ZTJUVLTU.js";
+import "./chunk-I7XBWTYH.js";
+import "./chunk-34BHNEE3.js";
+import "./chunk-D7E7WCDF.js";
+import "./chunk-EBY63B7G.js";
 import "./chunk-IWHMRKLL.js";
-import "./chunk-GXNLGKAB.js";
+import "./chunk-UXCU4E3T.js";
 import "./chunk-LL4KHSZI.js";
-import "./chunk-4ZG3XFUR.js";
+import "./chunk-S66XZJOF.js";
 import "./chunk-IKCO5N3L.js";
 import "./chunk-3I7MS7N2.js";
 import "./chunk-APJ265NV.js";
@@ -20,7 +20,6 @@ import "./chunk-WEPFGWHJ.js";
 import "./chunk-YXLYO42X.js";
 import "./chunk-3R73A4XB.js";
 export {
-  runClioCommand,
-  terminalLeaseEligible
+  runClioCommand
 };
-//# sourceMappingURL=clio-2JXHBBY5.js.map
+//# sourceMappingURL=clio-7VB377CC.js.map