@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/chunk-YXLYO42X.js

@@ -0,0 +1,91 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/engine/env-api-keys.ts
+init_esm_shims();
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var ANTHROPIC_AUTH_TOKEN_ENV = "ANTHROPIC_AUTH_TOKEN";
+var ANTHROPIC_OAUTH_TOKEN_ENV = "ANTHROPIC_OAUTH_TOKEN";
+var ANTHROPIC_API_KEY_ENV = "ANTHROPIC_API_KEY";
+var ENV_KEYS = {
+  "ant-ling": "ANT_LING_API_KEY",
+  "qwen-token-plan": "QWEN_TOKEN_PLAN_API_KEY",
+  "qwen-token-plan-cn": "QWEN_TOKEN_PLAN_CN_API_KEY",
+  openai: "OPENAI_API_KEY",
+  "azure-openai-responses": "AZURE_OPENAI_API_KEY",
+  nvidia: "NVIDIA_API_KEY",
+  deepseek: "DEEPSEEK_API_KEY",
+  google: "GEMINI_API_KEY",
+  "google-vertex": "GOOGLE_CLOUD_API_KEY",
+  groq: "GROQ_API_KEY",
+  cerebras: "CEREBRAS_API_KEY",
+  xai: "XAI_API_KEY",
+  radius: "RADIUS_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  "vercel-ai-gateway": "AI_GATEWAY_API_KEY",
+  zai: "ZAI_API_KEY",
+  "zai-coding-cn": "ZAI_CODING_CN_API_KEY",
+  mistral: "MISTRAL_API_KEY",
+  minimax: "MINIMAX_API_KEY",
+  "minimax-cn": "MINIMAX_CN_API_KEY",
+  moonshotai: "MOONSHOT_API_KEY",
+  "moonshotai-cn": "MOONSHOT_API_KEY",
+  huggingface: "HF_TOKEN",
+  fireworks: "FIREWORKS_API_KEY",
+  together: "TOGETHER_API_KEY",
+  baseten: "BASETEN_API_KEY",
+  opencode: "OPENCODE_API_KEY",
+  "opencode-go": "OPENCODE_API_KEY",
+  "kimi-coding": "KIMI_API_KEY",
+  "cloudflare-workers-ai": "CLOUDFLARE_API_KEY",
+  "cloudflare-ai-gateway": "CLOUDFLARE_API_KEY",
+  xiaomi: "XIAOMI_API_KEY",
+  "xiaomi-token-plan-cn": "XIAOMI_TOKEN_PLAN_CN_API_KEY",
+  "xiaomi-token-plan-ams": "XIAOMI_TOKEN_PLAN_AMS_API_KEY",
+  "xiaomi-token-plan-sgp": "XIAOMI_TOKEN_PLAN_SGP_API_KEY"
+};
+function envValue(name, env) {
+  return env?.[name] || process.env[name] || void 0;
+}
+function apiKeyEnvVars(provider) {
+  if (provider === "github-copilot") return ["COPILOT_GITHUB_TOKEN"];
+  if (provider === "anthropic") {
+    return [ANTHROPIC_AUTH_TOKEN_ENV, ANTHROPIC_OAUTH_TOKEN_ENV, ANTHROPIC_API_KEY_ENV];
+  }
+  const name = ENV_KEYS[provider];
+  return name ? [name] : void 0;
+}
+function findEngineEnvKeys(provider, env) {
+  const names = apiKeyEnvVars(provider);
+  if (!names) return void 0;
+  const found = names.filter((name) => !!envValue(name, env));
+  return found.length > 0 ? found : void 0;
+}
+function getEngineEnvApiKey(provider, env) {
+  const keys = findEngineEnvKeys(provider, env);
+  if (keys?.[0]) {
+    const name = provider === "anthropic" ? keys.find((key) => key !== ANTHROPIC_AUTH_TOKEN_ENV) : keys[0];
+    if (name) return envValue(name, env);
+  }
+  if (provider === "google-vertex") {
+    const credentialsPath = envValue("GOOGLE_APPLICATION_CREDENTIALS", env);
+    const hasCredentials = credentialsPath ? existsSync(credentialsPath) : existsSync(join(homedir(), ".config", "gcloud", "application_default_credentials.json"));
+    const hasProject = !!(envValue("GOOGLE_CLOUD_PROJECT", env) || envValue("GCLOUD_PROJECT", env));
+    const hasLocation = !!envValue("GOOGLE_CLOUD_LOCATION", env);
+    if (hasCredentials && hasProject && hasLocation) return "<authenticated>";
+  }
+  if (provider === "amazon-bedrock" && (envValue("AWS_PROFILE", env) || envValue("AWS_ACCESS_KEY_ID", env) && envValue("AWS_SECRET_ACCESS_KEY", env) || envValue("AWS_BEARER_TOKEN_BEDROCK", env) || envValue("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI", env) || envValue("AWS_CONTAINER_CREDENTIALS_FULL_URI", env) || envValue("AWS_WEB_IDENTITY_TOKEN_FILE", env))) {
+    return "<authenticated>";
+  }
+  return void 0;
+}
+
+export {
+  findEngineEnvKeys,
+  getEngineEnvApiKey
+};
+//# sourceMappingURL=chunk-YXLYO42X.js.map

package/dist/{chunk-NMOX6HFD.js → chunk-ZDOOVTXZ.js}

@@ -1,70 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  GUARDRAIL_DEFAULTS
+} from "./chunk-4ZG3XFUR.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
 // src/core/defaults.ts
 init_esm_shims();
-
-// src/core/guardrails.ts
-init_esm_shims();
-var GUARDRAIL_DEFAULTS = {
-  turnToolCallBudget: 60,
-  workerToolCallCap: 150,
-  maxDispatchRuns: 1e3,
-  readMaxBytes: 50 * 1024,
-  observationTurnBudgetBytes: 192 * 1024,
-  internalDispatchTimeoutMs: 15 * 60 * 1e3
-};
-var GUARDRAIL_ENV_VARS = {
-  turnToolCallBudget: "CLIO_CODER_TURN_TOOL_CALL_BUDGET",
-  workerToolCallCap: "CLIO_CODER_WORKER_TOOL_CALL_CAP",
-  maxDispatchRuns: "CLIO_CODER_MAX_DISPATCH_RUNS",
-  readMaxBytes: "CLIO_CODER_READ_MAX_BYTES",
-  observationTurnBudgetBytes: "CLIO_CODER_OBSERVATION_TURN_BUDGET_BYTES",
-  internalDispatchTimeoutMs: "CLIO_CODER_INTERNAL_DISPATCH_TIMEOUT_MS"
-};
-var GUARDRAIL_ENV_ALIASES = {
-  maxDispatchRuns: "CLIO_CODER_MAX_RUNS"
-};
-function workerSynthesisReserveDirective(remaining, cap) {
-  return `budget reserve: only ${remaining} of your ${cap} tool calls remain, and they are reserved for verification reads and synthesis. Stop broad exploration now: re-read the locations you will cite, then answer in prose. Calls that are not reads will be blocked.`;
-}
-function workerSynthesisReserveBlockReason(tool, remaining, cap) {
-  return `workerToolCallReserve: only ${remaining} of ${cap} tool calls remain and they are reserved for verification reads and synthesis; ${tool} is not a read. Re-read any locations you will cite, then answer in prose from what you have gathered.`;
-}
-function workerToolCallCapExceededReason(cap) {
-  return `workerToolCallCap reached (${cap}); abort run`;
-}
-function isWorkerToolCallCapExceededReason(reason) {
-  return /^workerToolCallCap reached \([1-9]\d*\); abort run$/.test(reason);
-}
-function workerToolCallCapSynthesisReason(cap) {
-  return `workerToolCallCap reached (${cap}); tool calls are now disabled for the rest of this run. Everything you retrieved is already in the conversation above. Answer the operator now, in plain prose, from what you have gathered. Do not write tool-call markup such as <tool_call> blocks; tool calls are disabled and will not run.`;
-}
-function isWorkerToolCallCapSynthesisReason(reason) {
-  return /^workerToolCallCap reached \([1-9]\d*\); tool calls are now disabled/.test(reason);
-}
-function mentionsWorkerToolCallCap(text) {
-  return typeof text === "string" && /workerToolCallCap reached \([1-9]\d*\)/.test(text);
-}
-var configured = {};
-function configureGuardrails(values) {
-  configured = { ...values ?? {} };
-}
-function parsePositiveSafeInt(raw) {
-  if (raw === void 0) return void 0;
-  const normalized = raw.trim();
-  if (!/^[1-9]\d*$/.test(normalized)) return void 0;
-  const parsed = Number(normalized);
-  return Number.isSafeInteger(parsed) ? parsed : void 0;
-}
-function resolveGuardrail(key, env = process.env) {
-  const alias = GUARDRAIL_ENV_ALIASES[key];
-  return parsePositiveSafeInt(env[GUARDRAIL_ENV_VARS[key]]) ?? (alias ? parsePositiveSafeInt(env[alias]) : void 0) ?? configured[key] ?? GUARDRAIL_DEFAULTS[key];
-}
-
-// src/core/defaults.ts
 var THINKING_LEVELS = [
   "off",
   "minimal",
@@ -151,11 +94,17 @@ var DEFAULT_SETTINGS = {
   theme: "default",
   terminal: {
     showTerminalProgress: false,
-    outputVerbosity: "default"
+    outputVerbosity: "default",
+    tuiMode: "regular",
+    fullscreenScrollbar: "auto",
+    smoothStreaming: "off"
   },
   skills: {
     trustProjectCompatRoots: false
   },
+  attribution: {
+    gitCommits: true
+  },
   delegation: {
     agents: [],
     defaults: {
@@ -216,7 +165,7 @@ autonomy: auto-edit         # read-only | suggest | auto-edit | full-auto
 # directory next to this file).
 targets: []
 # Local runtime examples (uncomment/adapt one; replace your-model-id):
-#   clio-coder configure --id local-lmstudio --runtime lmstudio-native --url http://localhost:1234 --model your-model-id --set-orchestrator --set-fleet-default
+#   clio-coder configure --id local-lmstudio --runtime lmstudio --url http://localhost:1234 --model your-model-id --set-orchestrator --set-fleet-default
 #   clio-coder configure --id local-ollama --runtime ollama-native --url http://localhost:11434 --model your-model-id --set-orchestrator --set-fleet-default
 #   clio-coder configure --id local-llamacpp --runtime llamacpp --url http://127.0.0.1:8080 --model your-model-id --set-orchestrator --set-fleet-default
 #   clio-coder configure --id local-vllm --runtime vllm --url http://localhost:8000 --model your-model-id --set-orchestrator --set-fleet-default
@@ -227,7 +176,7 @@ targets: []
 # Example target block equivalent to one configured local runtime:
 # targets:
 #   - id: local-lmstudio
-#     runtime: lmstudio-native
+#     runtime: lmstudio
 #     url: http://localhost:1234
 #     defaultModel: your-model-id
 #     capabilities:
@@ -323,7 +272,7 @@ routing:
 # Alt+J / Alt+K cycling order: plain target ids or "target/model" refs.
 scope: []
 
-# /models focused picker. Favorites are exact "target/model" refs shown before
+# /model focused picker. Favorites are exact "target/model" refs shown before
 # the full search catalog. Recently selected models are runtime state and live
 # in the state dir (recent-models.json), not in this file.
 modelSelector:
@@ -350,6 +299,15 @@ terminal:
   showTerminalProgress: false
   # Transcript detail: minimal, default, or verbose. Also changeable with /output.
   outputVerbosity: default
+  # regular preserves terminal scrollback; fullscreen keeps the editor/footer
+  # sticky above an independently scrollable alternate-screen transcript.
+  tuiMode: regular
+  # hidden, auto (visible while scrolling), or always in fullscreen mode.
+  fullscreenScrollbar: auto
+  # off preserves immediate 16ms coalescing; auto paces only on a capable,
+  # accessibility-safe local TTY; on requests pacing but still honors stdout
+  # backpressure. CLIO_CODER_SMOOTH_STREAM overrides this for one process.
+  smoothStreaming: off
 
 # Skills are local prompt resources. Project-local compatibility roots such as
 # .agents/skills, .claude/skills, .codex/skills, .github/skills, and
@@ -358,6 +316,11 @@ terminal:
 skills:
   trustProjectCompatRoots: false
 
+# Evidence-aware Git commit provenance. The identity and trailer semantics are
+# compiled into Clio; this switch only enables or disables attribution.
+attribution:
+  gitCommits: true
+
 # External coding agents that speak Agent Client Protocol v1 over stdio.
 # These are delegated harnesses, not model targets, so they stay outside
 # targets[], orchestrator, workers, and model pickers.
@@ -399,7 +362,7 @@ keybindings: {}
 
 # Context compaction controls.
 #   auto              master switch for the pre-request compaction trigger.
-#                     Manual /compact always runs the LLM summary.
+#                     Manual /context compact always runs the LLM summary.
 #   threshold         pressure = estimated_tokens / context_window. Crossing
 #                     it masks stale tool observations first, then runs a
 #                     full LLM summary if pressure stays above the threshold.
@@ -450,17 +413,6 @@ guardrails:
 `;
 
 export {
-  GUARDRAIL_DEFAULTS,
-  GUARDRAIL_ENV_VARS,
-  workerSynthesisReserveDirective,
-  workerSynthesisReserveBlockReason,
-  workerToolCallCapExceededReason,
-  isWorkerToolCallCapExceededReason,
-  workerToolCallCapSynthesisReason,
-  isWorkerToolCallCapSynthesisReason,
-  mentionsWorkerToolCallCap,
-  configureGuardrails,
-  resolveGuardrail,
   THINKING_LEVELS,
   DEFAULT_DELEGATION_CONNECT_TIMEOUT_MS,
   DEFAULT_DELEGATION_TURN_TIMEOUT_MS,
@@ -471,4 +423,4 @@ export {
   DEFAULT_SETTINGS,
   DEFAULT_SETTINGS_YAML
 };
-//# sourceMappingURL=chunk-NMOX6HFD.js.map
+//# sourceMappingURL=chunk-ZDOOVTXZ.js.map

package/dist/chunk-ZI647VB5.js

@@ -0,0 +1,37 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  typebox_exports
+} from "./chunk-5B2AEOW5.js";
+import {
+  ToolNames
+} from "./chunk-CGKSTWHD.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/web-fetch-surface.ts
+init_esm_shims();
+var webFetchToolSurface = {
+  name: ToolNames.WebFetch,
+  description: "Fetch an http(s) URL; HTML is cleaned and converted to Markdown. Non-2xx responses are errors.",
+  parameters: typebox_exports.Object({
+    url: typebox_exports.String({ description: "Fully-qualified http(s) URL." }),
+    method: typebox_exports.Optional(typebox_exports.String({ description: "HTTP method (default GET)." })),
+    headers: typebox_exports.Optional(typebox_exports.Record(typebox_exports.String(), typebox_exports.String(), { description: "Request headers." })),
+    body: typebox_exports.Optional(typebox_exports.String({ description: "Request body (POST/PUT)." })),
+    timeout_ms: typebox_exports.Optional(typebox_exports.Number({ description: "Timeout ms (default 30000)." })),
+    max_bytes: typebox_exports.Optional(typebox_exports.Number({ description: "Max bytes returned (default 600000)." })),
+    format: typebox_exports.Optional(
+      typebox_exports.String({
+        description: "auto (default: HTML is cleaned to Markdown, other content passes through) or raw (no conversion)."
+      })
+    )
+  }),
+  baseActionClass: "read",
+  executionMode: "parallel"
+};
+
+export {
+  webFetchToolSurface
+};
+//# sourceMappingURL=chunk-ZI647VB5.js.map

package/dist/{chunk-C4PTHK7P.js → chunk-ZWLZP4ZT.js}

@@ -1,13 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   require_dist
-} from "./chunk-GB6QRBXN.js";
-import {
-  safeResourceWrite
-} from "./chunk-WEPFGWHJ.js";
+} from "./chunk-APJ265NV.js";
 import {
   clioConfigDir
 } from "./chunk-BNAZZHFG.js";
+import {
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
 import {
   __toESM,
   init_esm_shims
@@ -474,4 +474,4 @@ export {
   enabledExtensionResourceRoots,
   ExtensionsDomainModule
 };
-//# sourceMappingURL=chunk-C4PTHK7P.js.map
+//# sourceMappingURL=chunk-ZWLZP4ZT.js.map

package/dist/cli/index.js

@@ -2,20 +2,28 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   traceBoot
-} from "../chunk-PIUMUEMV.js";
+} from "../chunk-HKIYEGME.js";
+import {
+  incompleteInstallationAdvice
+} from "../chunk-65DEGPJ6.js";
 import {
   extractGlobalFlags,
   parseFlags,
   printError
-} from "../chunk-K2ITRMHZ.js";
+} from "../chunk-ED4KHGC3.js";
+import "../chunk-5TSRNF4G.js";
+import {
+  AI_AGENT_NAME
+} from "../chunk-6EJMN2Y3.js";
+import "../chunk-IWHMRKLL.js";
 import {
   init_esm_shims
 } from "../chunk-3R73A4XB.js";
 
 // src/cli/index.ts
 init_esm_shims();
-import { fileURLToPath } from "node:url";
 process.title = "clio-coder";
+process.env.AI_AGENT = AI_AGENT_NAME;
 var HELP = `Clio Coder command line
 
 Coding agent for HPC and scientific-software work, part of IOWarp's CLIO ecosystem of agentic
@@ -57,7 +65,7 @@ Usage:
   clio-coder trace                query or view the durable dispatch trace mirror
   clio-coder extensions           install, list, enable, disable, or remove extension packages
   clio-coder skills               list, inspect, validate, or install skills
-  clio-coder docs [topic]         serve bundled HTML docs on 127.0.0.1 (--no-open to skip browser)
+  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
   clio-coder --help --all         this message plus every command under 'clio-coder dev'
@@ -132,27 +140,39 @@ async function main(argv) {
     ...skillPaths.length > 0 ? { skillPaths } : {}
   };
   if (!subcommand) {
-    const { runClioCommand } = await import("../clio-BZVGEUFJ.js");
+    await enableBootCompileCache();
+    const { runClioCommand } = await import("../clio-4LY5K2AC.js");
     return runClioCommand(bootOptions);
   }
   return dispatch(subcommand, subArgs, bootOptions);
 }
-var extensionsCommand = async (subArgs) => (await import("../extensions-OZFJ3A3G.js")).runExtensionsCommand(subArgs);
+async function enableBootCompileCache(subArgs = []) {
+  if (subArgs.includes("--help") || subArgs.includes("-h")) return;
+  const { enableClioCompileCache } = await import("../compile-cache-CVJMMODC.js");
+  enableClioCompileCache();
+}
+var extensionsCommand = async (subArgs) => (await import("../extensions-QVDOHDGJ.js")).runExtensionsCommand(subArgs);
 var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
-  ["acp", async (subArgs, bootOptions) => (await import("../acp-FPR54DGL.js")).runAcpCommand(subArgs, bootOptions)],
-  ["auth", async (subArgs) => (await import("../auth-IC3K6NIZ.js")).runAuthCommand(subArgs)],
-  ["config", async (subArgs) => (await import("../config-IRUQ7SE4.js")).runConfigCommand(subArgs)],
-  ["configure", async (subArgs) => (await import("../configure-S7S6F6CL.js")).runConfigureCommand(subArgs)],
-  ["targets", async (subArgs) => (await import("../targets-TYXLPB23.js")).runTargetsCommand(subArgs)],
-  ["models", async (subArgs) => (await import("../models-A4PVNWJK.js")).runModelsCommand(subArgs)],
-  ["agents", async (subArgs) => (await import("../agents-OGPIHPJH.js")).runAgentsCommand(subArgs)],
-  ["components", async (subArgs) => (await import("../components-DMAOEKFB.js")).runComponentsCommand(subArgs)],
-  ["evidence", async (subArgs) => (await import("../evidence-YEGUW4L3.js")).runEvidenceCommand(subArgs)],
-  ["eval", async (subArgs) => (await import("../eval-U6TJHRLX.js")).runEvalCommand(subArgs)],
-  ["memory", async (subArgs) => (await import("../memory-73ESV5YC.js")).runMemoryCommand(subArgs)],
-  ["usage", async (subArgs) => (await import("../usage-ZAFSXKKG.js")).runUsageCommand(subArgs)],
-  ["trace", async (subArgs) => (await import("../trace-GGOJ6Q6Z.js")).runTraceCommand(subArgs)],
-  ["evolve", async (subArgs) => (await import("../evolve-TXARCTPG.js")).runEvolveCommand(subArgs)],
+  [
+    "acp",
+    async (subArgs, bootOptions) => {
+      await enableBootCompileCache(subArgs);
+      return (await import("../acp-BIYHVZIM.js")).runAcpCommand(subArgs, bootOptions);
+    }
+  ],
+  ["auth", async (subArgs) => (await import("../auth-5TWEIYDN.js")).runAuthCommand(subArgs)],
+  ["config", async (subArgs) => (await import("../config-GTLUW2PR.js")).runConfigCommand(subArgs)],
+  ["configure", async (subArgs) => (await import("../configure-R6A64DHX.js")).runConfigureCommand(subArgs)],
+  ["targets", async (subArgs) => (await import("../targets-C4SSGQOB.js")).runTargetsCommand(subArgs)],
+  ["models", async (subArgs) => (await import("../models-BZU34YWD.js")).runModelsCommand(subArgs)],
+  ["agents", async (subArgs) => (await import("../agents-YT6SSRIT.js")).runAgentsCommand(subArgs)],
+  ["components", async (subArgs) => (await import("../components-KELWS457.js")).runComponentsCommand(subArgs)],
+  ["evidence", async (subArgs) => (await import("../evidence-UA6AWDQQ.js")).runEvidenceCommand(subArgs)],
+  ["eval", async (subArgs) => (await import("../eval-XSSNATB4.js")).runEvalCommand(subArgs)],
+  ["memory", async (subArgs) => (await import("../memory-MD3O64RI.js")).runMemoryCommand(subArgs)],
+  ["usage", async (subArgs) => (await import("../usage-GV4PKT3M.js")).runUsageCommand(subArgs)],
+  ["trace", async (subArgs) => (await import("../trace-PNCASAXC.js")).runTraceCommand(subArgs)],
+  ["evolve", async (subArgs) => (await import("../evolve-QNTFGV6Z.js")).runEvolveCommand(subArgs)],
   [
     "dev",
     async (subArgs, bootOptions) => {
@@ -171,23 +191,31 @@ var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
   ],
   ["extensions", extensionsCommand],
   ["ext", extensionsCommand],
-  ["fleet", async (subArgs) => (await import("../fleet-6G3DHNYE.js")).runFleetCommand(subArgs)],
-  ["skills", async (subArgs) => (await import("../skills-2V6RA3OQ.js")).runSkillsCommand(subArgs)],
-  ["docs", async (subArgs) => (await import("../docs-5AWSPS37.js")).runDocsCommand(subArgs)],
-  ["share", async (subArgs) => (await import("../share-YIFFV4NQ.js")).runShareCommand(subArgs)],
-  ["export", async (subArgs) => (await import("../share-YIFFV4NQ.js")).runExportCommand(subArgs)],
-  ["import", async (subArgs) => (await import("../share-YIFFV4NQ.js")).runImportCommand(subArgs)],
-  ["context", async (subArgs) => (await import("../context-3KWFLHJG.js")).runContextCommand(subArgs)],
-  ["run", async (subArgs, bootOptions) => (await import("../run-YTPEYQOH.js")).runClioRun(subArgs, bootOptions)],
-  ["doctor", async (subArgs) => (await import("../doctor-UC5NAJYQ.js")).runDoctorCommand(subArgs)],
-  ["paths", async (subArgs) => (await import("../paths-C4H6IV77.js")).runPathsCommand(subArgs)],
-  ["reset", async (subArgs) => (await import("../reset-BGW6OGMV.js")).runResetCommand(subArgs)],
-  ["uninstall", async (subArgs) => (await import("../uninstall-LLLT4F4W.js")).runUninstallCommand(subArgs)],
-  ["upgrade", async (subArgs) => (await import("../upgrade-33G2LMM5.js")).runUpgradeCommand(subArgs)],
+  ["fleet", async (subArgs) => (await import("../fleet-Q7UOMUSG.js")).runFleetCommand(subArgs)],
+  ["skills", async (subArgs) => (await import("../skills-LQEKRDTN.js")).runSkillsCommand(subArgs)],
+  ["docs", async (subArgs) => (await import("../docs-2C2LTVT2.js")).runDocsCommand(subArgs)],
+  ["share", async (subArgs) => (await import("../share-S5BZQC5I.js")).runShareCommand(subArgs)],
+  ["export", async (subArgs) => (await import("../share-S5BZQC5I.js")).runExportCommand(subArgs)],
+  ["import", async (subArgs) => (await import("../share-S5BZQC5I.js")).runImportCommand(subArgs)],
+  ["context", async (subArgs) => (await import("../context-JFZEJ7W5.js")).runContextCommand(subArgs)],
+  [
+    "run",
+    async (subArgs, bootOptions) => {
+      await enableBootCompileCache(subArgs);
+      return (await import("../run-IV4Q6RLN.js")).runClioRun(subArgs, bootOptions);
+    }
+  ],
+  ["doctor", async (subArgs) => (await import("../doctor-KI767GSN.js")).runDoctorCommand(subArgs)],
+  ["paths", async (subArgs) => (await import("../paths-UXLN5YYZ.js")).runPathsCommand(subArgs)],
+  ["reset", async (subArgs) => (await import("../reset-L2FQEE3E.js")).runResetCommand(subArgs)],
+  ["uninstall", async (subArgs) => (await import("../uninstall-FZCQCDKC.js")).runUninstallCommand(subArgs)],
+  ["upgrade", async (subArgs) => (await import("../upgrade-7TT7SQ3G.js")).runUpgradeCommand(subArgs)],
   ["version", async () => (await import("../version-KGEG7EPO.js")).runVersionCommand()],
   [
     "worker",
     async () => {
+      Reflect.deleteProperty(process.env, "CLIO_CODER_INJECTED_COMPILE_CACHE");
+      await enableBootCompileCache();
       await import("../worker/entry.js");
       return 0;
     }
@@ -197,26 +225,6 @@ var RETIRED_SUBCOMMANDS = /* @__PURE__ */ new Set(["context-init", "context-inde
 function isCommandToken(token) {
   return COMMAND_HANDLERS.has(token) || RETIRED_SUBCOMMANDS.has(token);
 }
-function incompleteInstallationAdvice(err) {
-  if (err?.code !== "ERR_MODULE_NOT_FOUND") return null;
-  const message = err instanceof Error ? err.message : String(err);
-  let outputDir;
-  try {
-    outputDir = fileURLToPath(new URL("../", import.meta.url));
-  } catch {
-    return null;
-  }
-  if (!message.includes(outputDir)) return null;
-  return [
-    `${message}`,
-    "",
-    "This Clio Coder installation is incomplete: the command's own module is missing from",
-    `${outputDir}`,
-    "Reinstall to restore it, using the line that matches how you installed:",
-    "  npm install -g @iowarp/clio-coder    # npm install",
-    "  npm run install:local                # source checkout"
-  ].join("\n");
-}
 async function dispatch(subcommand, subArgs, bootOptions) {
   const handler = COMMAND_HANDLERS.get(subcommand);
   if (handler) {
@@ -230,7 +238,7 @@ async function dispatch(subcommand, subArgs, bootOptions) {
     }
   }
   printError(`unknown subcommand: ${subcommand}`);
-  process.stdout.write(helpText(false));
+  process.stderr.write(helpText(false));
   return 2;
 }
 main(process.argv.slice(2)).then((code) => {

package/dist/clio-4LY5K2AC.js

@@ -0,0 +1,25 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  runClioCommand,
+  terminalLeaseEligible
+} from "./chunk-MBS4V7ZP.js";
+import "./chunk-CBCAPZAA.js";
+import "./chunk-HKIYEGME.js";
+import "./chunk-BMEMKKIT.js";
+import "./chunk-A3CYT5EX.js";
+import "./chunk-ZDOOVTXZ.js";
+import "./chunk-FQ4SKYE4.js";
+import "./chunk-IKCO5N3L.js";
+import "./chunk-3I7MS7N2.js";
+import "./chunk-4ZG3XFUR.js";
+import "./chunk-APJ265NV.js";
+import "./chunk-YXLYO42X.js";
+import "./chunk-BNAZZHFG.js";
+import "./chunk-WEPFGWHJ.js";
+import "./chunk-IWHMRKLL.js";
+import "./chunk-3R73A4XB.js";
+export {
+  runClioCommand,
+  terminalLeaseEligible
+};
+//# sourceMappingURL=clio-4LY5K2AC.js.map