@iowarp/clio-coder 0.3.0 → 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-UHTSULZS.js → chunk-ZDOOVTXZ.js}

@@ -1,57 +1,13 @@
-// src/core/guardrails.ts
-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_RUNS",
-  readMaxBytes: "CLIO_CODER_READ_MAX_BYTES",
-  observationTurnBudgetBytes: "CLIO_CODER_OBSERVATION_TURN_BUDGET_BYTES",
-  internalDispatchTimeoutMs: "CLIO_CODER_INTERNAL_DISPATCH_TIMEOUT_MS"
-};
-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) {
-  return parsePositiveSafeInt(env[GUARDRAIL_ENV_VARS[key]]) ?? configured[key] ?? GUARDRAIL_DEFAULTS[key];
-}
+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();
 var THINKING_LEVELS = [
   "off",
   "minimal",
@@ -69,7 +25,6 @@ var ACTIVE_ROUTING_POSTURES = ["quality", "balanced", "latency", "economy"];
 var ACTIVE_AGENT_AUTOMATION_ROLES = ["builder", "researcher", "verifier", "reviewer", "judge"];
 var DEFAULT_SETTINGS = {
   version: 1,
-  identity: "clio",
   autonomy: "auto-edit",
   targets: [],
   runtimePlugins: [],
@@ -139,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: {
@@ -167,7 +128,8 @@ var DEFAULT_SETTINGS = {
     enabled: true,
     maxRetries: 3,
     baseDelayMs: 2e3,
-    maxDelayMs: 6e4
+    maxDelayMs: 6e4,
+    streamStallMs: 18e4
   },
   // Numeric backstops that bound runaway agent behavior. Settings are the
   // primary home; each value also has a per-process env override for CI and
@@ -194,7 +156,6 @@ var DEFAULT_SETTINGS_YAML = `# Clio Coder settings. Written once on first instal
 #   5. Launch: clio-coder
 
 version: 1
-identity: clio
 autonomy: auto-edit         # read-only | suggest | auto-edit | full-auto
 
 # Inference targets. Each entry becomes selectable for chat and workers.
@@ -204,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
@@ -215,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:
@@ -311,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:
@@ -338,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
@@ -346,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.
@@ -387,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.
@@ -411,6 +386,7 @@ retry:
   maxRetries: 3
   baseDelayMs: 2000
   maxDelayMs: 60000
+  streamStallMs: 180000
 
 # Guardrails: numeric backstops that bound runaway agent behavior.
 #   turnToolCallBudget          orchestrator per-turn soft tool-call budget;
@@ -424,7 +400,7 @@ retry:
 #   internalDispatchTimeoutMs   wall-clock cap for one internal generator
 #                               dispatch (wiki documenter, bootstrap scout).
 # Each value also has a per-process env override (CLIO_CODER_TURN_TOOL_CALL_BUDGET,
-# CLIO_CODER_WORKER_TOOL_CALL_CAP, CLIO_CODER_MAX_RUNS, CLIO_CODER_READ_MAX_BYTES,
+# CLIO_CODER_WORKER_TOOL_CALL_CAP, CLIO_CODER_MAX_DISPATCH_RUNS, CLIO_CODER_READ_MAX_BYTES,
 # CLIO_CODER_OBSERVATION_TURN_BUDGET_BYTES, CLIO_CODER_INTERNAL_DISPATCH_TIMEOUT_MS) meant
 # for CI and one-off experiments.
 guardrails:
@@ -437,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,
@@ -458,4 +423,4 @@ export {
   DEFAULT_SETTINGS,
   DEFAULT_SETTINGS_YAML
 };
-//# sourceMappingURL=chunk-UHTSULZS.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-CLJ5HLUD.js → chunk-ZWLZP4ZT.js}

@@ -1,14 +1,23 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  safeResourceWrite
-} from "./chunk-VPAWTYLY.js";
+  require_dist
+} from "./chunk-APJ265NV.js";
 import {
   clioConfigDir
-} from "./chunk-X3NE4WVW.js";
+} from "./chunk-BNAZZHFG.js";
+import {
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
 
 // src/domains/extensions/discovery.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 var MANIFEST_NAMES = ["clio-coder-extension.yaml", "clio-coder-extension.yml", "clio-coder-extension.json"];
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -28,7 +37,7 @@ function validateId(id) {
 function readJsonOrYaml(filePath) {
   const raw = readFileSync(filePath, "utf8");
   if (filePath.endsWith(".json")) return JSON.parse(raw);
-  return parseYaml(raw);
+  return (0, import_yaml.parse)(raw);
 }
 function normalizeResources(value) {
   if (!isRecord(value)) return {};
@@ -171,6 +180,7 @@ function discoverExtensionPackages(root) {
 }
 
 // src/domains/extensions/state.ts
+init_esm_shims();
 import { cpSync, existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, renameSync, rmSync } from "node:fs";
 import path2 from "node:path";
 var DEFAULT_STATE = { version: 1, disabled: [], installed: {} };
@@ -364,7 +374,11 @@ function removeExtension(id, options = {}) {
   return { removed: { id, scope: target.scope, path: target.rootPath }, diagnostics: [] };
 }
 
+// src/domains/extensions/manager.ts
+init_esm_shims();
+
 // src/domains/extensions/resources.ts
+init_esm_shims();
 import { statSync as statSync2 } from "node:fs";
 import path3 from "node:path";
 function extensionResourcePath(rootPath, resourcePath) {
@@ -397,7 +411,11 @@ function enabledExtensionResourceRoots(kind, cwd = process.cwd()) {
   return roots;
 }
 
+// src/domains/extensions/index.ts
+init_esm_shims();
+
 // src/domains/extensions/extension.ts
+init_esm_shims();
 function createExtensionsBundle(_context) {
   const extension = {
     start() {
@@ -434,6 +452,7 @@ function createExtensionsBundle(_context) {
 }
 
 // src/domains/extensions/manifest.ts
+init_esm_shims();
 var ExtensionsManifest = {
   name: "extensions",
   dependsOn: ["config"]
@@ -455,4 +474,4 @@ export {
   enabledExtensionResourceRoots,
   ExtensionsDomainModule
 };
-//# sourceMappingURL=chunk-CLJ5HLUD.js.map
+//# sourceMappingURL=chunk-ZWLZP4ZT.js.map

package/dist/cli/index.js

@@ -1,15 +1,29 @@
 #!/usr/bin/env node
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   traceBoot
-} from "../chunk-6CWDTGUC.js";
+} from "../chunk-HKIYEGME.js";
+import {
+  incompleteInstallationAdvice
+} from "../chunk-65DEGPJ6.js";
 import {
   extractGlobalFlags,
   parseFlags,
   printError
-} from "../chunk-67MTHP2E.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
-import { fileURLToPath } from "node:url";
+init_esm_shims();
+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
@@ -51,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'
@@ -115,7 +129,7 @@ async function main(argv) {
     return 0;
   }
   if (flags.has("version") || flags.has("v")) {
-    const { runVersionCommand } = await import("../version-ROZ6CZKH.js");
+    const { runVersionCommand } = await import("../version-KGEG7EPO.js");
     return runVersionCommand();
   }
   const subArgs = subcommandIndex === -1 ? [] : rest.slice(subcommandIndex + 1);
@@ -126,27 +140,39 @@ async function main(argv) {
     ...skillPaths.length > 0 ? { skillPaths } : {}
   };
   if (!subcommand) {
-    const { runClioCommand } = await import("../clio-KIQ5SNDS.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-SRG7XCAH.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-UMLFVA3F.js")).runAcpCommand(subArgs, bootOptions)],
-  ["auth", async (subArgs) => (await import("../auth-O6HYIJ6J.js")).runAuthCommand(subArgs)],
-  ["config", async (subArgs) => (await import("../config-ZFCDBMDC.js")).runConfigCommand(subArgs)],
-  ["configure", async (subArgs) => (await import("../configure-G4E3A2PG.js")).runConfigureCommand(subArgs)],
-  ["targets", async (subArgs) => (await import("../targets-DZMEZAH4.js")).runTargetsCommand(subArgs)],
-  ["models", async (subArgs) => (await import("../models-DY35XI7Y.js")).runModelsCommand(subArgs)],
-  ["agents", async (subArgs) => (await import("../agents-Q4MYPMUW.js")).runAgentsCommand(subArgs)],
-  ["components", async (subArgs) => (await import("../components-JVHMUBEB.js")).runComponentsCommand(subArgs)],
-  ["evidence", async (subArgs) => (await import("../evidence-V67CHM35.js")).runEvidenceCommand(subArgs)],
-  ["eval", async (subArgs) => (await import("../eval-B3KZZESM.js")).runEvalCommand(subArgs)],
-  ["memory", async (subArgs) => (await import("../memory-3PIQQAKX.js")).runMemoryCommand(subArgs)],
-  ["usage", async (subArgs) => (await import("../usage-ULIDAGFF.js")).runUsageCommand(subArgs)],
-  ["trace", async (subArgs) => (await import("../trace-7NYCUI2J.js")).runTraceCommand(subArgs)],
-  ["evolve", async (subArgs) => (await import("../evolve-YDZSUQYA.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) => {
@@ -165,23 +191,31 @@ var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
   ],
   ["extensions", extensionsCommand],
   ["ext", extensionsCommand],
-  ["fleet", async (subArgs) => (await import("../fleet-CA2CRTVG.js")).runFleetCommand(subArgs)],
-  ["skills", async (subArgs) => (await import("../skills-F2MRLELY.js")).runSkillsCommand(subArgs)],
-  ["docs", async (subArgs) => (await import("../docs-YIETIWZI.js")).runDocsCommand(subArgs)],
-  ["share", async (subArgs) => (await import("../share-D36RQCXM.js")).runShareCommand(subArgs)],
-  ["export", async (subArgs) => (await import("../share-D36RQCXM.js")).runExportCommand(subArgs)],
-  ["import", async (subArgs) => (await import("../share-D36RQCXM.js")).runImportCommand(subArgs)],
-  ["context", async (subArgs) => (await import("../context-CDXTP2MP.js")).runContextCommand(subArgs)],
-  ["run", async (subArgs, bootOptions) => (await import("../run-3VSPP24F.js")).runClioRun(subArgs, bootOptions)],
-  ["doctor", async (subArgs) => (await import("../doctor-M5HJJZOL.js")).runDoctorCommand(subArgs)],
-  ["paths", async (subArgs) => (await import("../paths-5OMXW7Z4.js")).runPathsCommand(subArgs)],
-  ["reset", async (subArgs) => (await import("../reset-PIFYNOS3.js")).runResetCommand(subArgs)],
-  ["uninstall", async (subArgs) => (await import("../uninstall-AD3JWHBB.js")).runUninstallCommand(subArgs)],
-  ["upgrade", async (subArgs) => (await import("../upgrade-WYYBKGDY.js")).runUpgradeCommand(subArgs)],
-  ["version", async () => (await import("../version-ROZ6CZKH.js")).runVersionCommand()],
+  ["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;
     }
@@ -191,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) {
@@ -224,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