@iowarp/clio-coder 0.4.7 → 0.4.9

package/dist/{chunk-3XE4NRLF.js → chunk-ZKJU55MX.js}

@@ -80,7 +80,8 @@ var DEFAULT_SETTINGS = {
       maxRetries: 3,
       baseDelayMs: 2e3,
       maxDelayMs: 6e4,
-      streamStallMs: 18e4
+      streamStallMs: 18e4,
+      firstTokenStallMs: 6e5
     }
   },
   fleet: {
@@ -205,6 +206,7 @@ chat:
     baseDelayMs: 2000
     maxDelayMs: 60000
     streamStallMs: 180000
+    firstTokenStallMs: 600000
 
 fleet:
   default:
@@ -321,4 +323,4 @@ export {
   DEFAULT_SETTINGS,
   DEFAULT_SETTINGS_YAML
 };
-//# sourceMappingURL=chunk-3XE4NRLF.js.map
+//# sourceMappingURL=chunk-ZKJU55MX.js.map

package/dist/{chunk-IZYTT3CD.js → chunk-ZKQ63XZ5.js}

@@ -1,19 +1,18 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  formatSize,
-  truncateHead,
+  createSafetyPolicyEngine
+} from "./chunk-IC7JXLOM.js";
+import {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
   truncateTail
+} from "./chunk-GHXGMFQ5.js";
+import {
+  formatSize
 } from "./chunk-KECNXMDE.js";
 import {
   INSTRUCTION_SHAPED_WARNING
 } from "./chunk-WXA2CFJO.js";
-import {
-  createRedactionTally,
-  redactSecretsText
-} from "./chunk-O3VV6IVK.js";
-import {
-  createSafetyPolicyEngine
-} from "./chunk-DLIYANB7.js";
 import {
   byteLength,
   truncateUtf8
@@ -22,6 +21,10 @@ import {
   GUARDRAIL_DEFAULTS,
   resolveGuardrail
 } from "./chunk-C27U2TYG.js";
+import {
+  createRedactionTally,
+  redactSecretsText
+} from "./chunk-O3VV6IVK.js";
 import {
   clioStateDir
 } from "./chunk-CTTI7G3T.js";
@@ -29,29 +32,6 @@ import {
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
 
-// src/tools/truncate.ts
-init_esm_shims();
-var DEFAULT_MAX_LINES = 2e3;
-var DEFAULT_MAX_BYTES = 64 * 1024;
-function splitLinesForCounting(content) {
-  if (content.length === 0) return [];
-  const lines = content.split("\n");
-  if (content.endsWith("\n")) lines.pop();
-  return lines;
-}
-function withClioDefaults(options) {
-  return {
-    maxLines: options.maxLines ?? DEFAULT_MAX_LINES,
-    maxBytes: options.maxBytes ?? DEFAULT_MAX_BYTES
-  };
-}
-function truncateHead2(content, options = {}) {
-  return truncateHead(content, withClioDefaults(options));
-}
-function truncateTail2(content, options = {}) {
-  return truncateTail(content, withClioDefaults(options));
-}
-
 // src/tools/result-shaping.ts
 init_esm_shims();
 import { createHash as createHash2 } from "node:crypto";
@@ -639,7 +619,7 @@ function shapeJsonOverflow(spec, result, text, bytes, maxBytes, context, offload
   return { ...result, message: stub, details: mergeDetails(result.details, resultSize) };
 }
 function shapeTailOverflow(spec, result, text, bytes, maxBytes, context, offloadMaxBytes) {
-  const truncation = truncateTail2(text, {
+  const truncation = truncateTail(text, {
     maxLines: DEFAULT_MAX_LINES,
     maxBytes: Math.max(1, maxBytes - TAIL_NOTICE_RESERVE_BYTES)
   });
@@ -847,7 +827,7 @@ function shapeTextToolResult(spec, result, context, requestedDisposition) {
     const remainder = text.split(warning).join("").trimStart();
     const allowance = Math.max(0, cap - byteLength(prefix));
     if (allowance === 0) return truncateUtf8(warning, cap, "");
-    const body = tail ? truncateTail2(remainder, { maxBytes: allowance, maxLines: Number.MAX_SAFE_INTEGER }).content : truncateUtf8(remainder, allowance, "");
+    const body = tail ? truncateTail(remainder, { maxBytes: allowance, maxLines: Number.MAX_SAFE_INTEGER }).content : truncateUtf8(remainder, allowance, "");
     return prefix + body;
   };
   const output = preserve(
@@ -1198,13 +1178,10 @@ export {
   isDispositionedToolResultError,
   toolResultPresentationText,
   toolResultPresentationPolicy,
-  DEFAULT_MAX_LINES,
-  splitLinesForCounting,
-  truncateHead2 as truncateHead,
-  truncateTail2 as truncateTail,
   DEFAULT_TOOL_RESULT_MAX_BYTES,
   toolResultDigestFor,
   sweepExpiredToolOffloads,
+  writeToolOffload,
   isSessionOffloadPath,
   shapeToolResult,
   OBSERVATION_POLICY_SLACK_BYTES,
@@ -1216,4 +1193,4 @@ export {
   finalizeObservation,
   createObservationPathFilter
 };
-//# sourceMappingURL=chunk-IZYTT3CD.js.map
+//# sourceMappingURL=chunk-ZKQ63XZ5.js.map

package/dist/{chunk-6TAATXXH.js → chunk-ZKVMDNAN.js}

@@ -2,6 +2,9 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   resolveDynamicConfigValue
 } from "./chunk-VNBICSS2.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
 import {
   findEngineEnvKeys,
   getEngineEnvApiKey
@@ -11,14 +14,11 @@ import {
   withStateFileLockSync
 } from "./chunk-DVJL77SO.js";
 import {
-  require_dist
-} from "./chunk-B5GGDIHT.js";
+  resolveClioDirs
+} from "./chunk-CTTI7G3T.js";
 import {
   safeResourceWrite
 } from "./chunk-ZZFWWYLX.js";
-import {
-  resolveClioDirs
-} from "./chunk-CTTI7G3T.js";
 import {
   __toESM,
   init_esm_shims
@@ -951,12 +951,12 @@ function openAuthStorage(path) {
 }
 
 export {
-  authStoragePath,
   registerClioOAuthProviders,
+  authStoragePath,
   resolveAuthTarget,
   resolveRuntimeAuthTarget,
   targetRequiresAuth,
   authNotRequiredStatus,
   openAuthStorage
 };
-//# sourceMappingURL=chunk-6TAATXXH.js.map
+//# sourceMappingURL=chunk-ZKVMDNAN.js.map

package/dist/chunk-ZST3FRCV.js

@@ -0,0 +1,132 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP,
+  bindExtensionSnapshotStore,
+  buildExtensionSnapshot,
+  createExtensionSnapshotStore,
+  diffExtensionSnapshots
+} from "./chunk-MZKYVIWW.js";
+import {
+  disableExtension,
+  discoverExtensionPackages,
+  enableExtension,
+  installExtension,
+  listInstalledExtensions,
+  removeExtension
+} from "./chunk-6TKOFFGE.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/extensions/index.ts
+init_esm_shims();
+
+// src/domains/extensions/extension.ts
+init_esm_shims();
+function failureDiagnostics(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    entries: [{ type: "error", message: message.slice(0, EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP) }],
+    truncated: 0
+  };
+}
+function createExtensionsBundle(_context, options = {}) {
+  const store = createExtensionSnapshotStore();
+  const cwd = options.cwd ?? (() => process.cwd());
+  const build = (generation) => buildExtensionSnapshot({
+    cwd: cwd(),
+    generation,
+    ...options.now !== void 0 ? { now: options.now } : {},
+    ...options.listRecords !== void 0 ? { listRecords: options.listRecords } : {}
+  });
+  let inFlight = null;
+  const rejected = (reason, diagnostics) => ({
+    status: "rejected",
+    reason,
+    generation: store.current()?.generation ?? 0,
+    diagnostics
+  });
+  const extension = {
+    start() {
+      bindExtensionSnapshotStore(store);
+    },
+    stop() {
+      inFlight = null;
+      bindExtensionSnapshotStore(null);
+    }
+  };
+  const contract = {
+    list(cwd2, options2 = {}) {
+      return listInstalledExtensions(cwd2, options2);
+    },
+    discover(root) {
+      return discoverExtensionPackages(root);
+    },
+    install(root, options2 = {}) {
+      return installExtension(root, options2);
+    },
+    enable(id, options2 = {}) {
+      return enableExtension(id, options2);
+    },
+    disable(id, options2 = {}) {
+      return disableExtension(id, options2);
+    },
+    remove(id, options2 = {}) {
+      return removeExtension(id, options2);
+    },
+    snapshot() {
+      return store.current();
+    },
+    generation() {
+      return store.current()?.generation ?? 0;
+    },
+    prepareReload() {
+      if (inFlight !== null) return rejected("reentrant", { entries: [], truncated: 0 });
+      const previous = store.current();
+      const generation = store.nextGeneration();
+      let snapshot;
+      try {
+        snapshot = build(generation);
+      } catch (error) {
+        return rejected("build-failed", failureDiagnostics(error));
+      }
+      const candidate = {
+        generation,
+        previousGeneration: previous?.generation ?? 0,
+        snapshot,
+        ...diffExtensionSnapshots(previous, snapshot),
+        // Identity on the committed reference covers every intervening
+        // publish; the in-flight check covers discard and double publish.
+        current: () => inFlight === candidate && store.current() === previous,
+        publish() {
+          store.publish(snapshot);
+          inFlight = null;
+        },
+        discard() {
+          if (inFlight === candidate) inFlight = null;
+        }
+      };
+      inFlight = candidate;
+      return { status: "prepared", candidate };
+    }
+  };
+  return { extension, contract };
+}
+
+// src/domains/extensions/manifest.ts
+init_esm_shims();
+var ExtensionsManifest = {
+  name: "extensions",
+  dependsOn: ["config"]
+};
+
+// src/domains/extensions/index.ts
+var ExtensionsDomainModule = {
+  manifest: ExtensionsManifest,
+  createExtension: createExtensionsBundle
+};
+
+export {
+  ExtensionsDomainModule
+};
+//# sourceMappingURL=chunk-ZST3FRCV.js.map

package/dist/cli/index.js

@@ -7,14 +7,14 @@ import {
   extractGlobalFlags,
   parseFlags,
   printError
-} from "../chunk-3T4DXWP6.js";
+} from "../chunk-KIVFXGBM.js";
 import {
   incompleteInstallationAdvice
 } from "../chunk-3A3CUMKA.js";
-import "../chunk-E3LEPLQ2.js";
 import {
   AI_AGENT_NAME
 } from "../chunk-ZTNFYMIO.js";
+import "../chunk-E3LEPLQ2.js";
 import {
   init_esm_shims
 } from "../chunk-ECBHH7LU.js";
@@ -30,6 +30,7 @@ science. CLIO stands for Context Layer for Input/Output, named for the Greek mus
 
 Usage:
   clio-coder                      start interactive repository chat
+  clio-coder web [--open]         start the browser application
   clio-coder acp                  serve Clio as an ACP v1 agent over stdio
   clio-coder --acp                alias for clio-coder acp
   clio-coder run [flags] <task>   run one headless main-agent turn
@@ -38,6 +39,7 @@ Usage:
   clio-coder --no-context-files, -nc  skip CLIO-CODER.md project-context injection
   clio-coder --with-panes         activate the panes extension (terminal panes for workers and tools)
   clio-coder --no-panes           keep panes off even when settings turn them on
+  clio-coder --autonomy <level>   start this interactive session at read-only|suggest|auto-edit|full-auto
   clio-coder configure            interactive first-run/configuration wizard
   clio-coder targets              list configured targets, health, auth, and capabilities
   clio-coder targets add          add a target interactively or via flags
@@ -71,12 +73,13 @@ 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 library              register, install, update, import, inspect, and manage packages of every kind
+  clio-coder mcp list|trust|untrust  list MCP servers and manage trust for project-declared servers
   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
   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 docs [topic]         open documentation in the web app (--no-open to print the launch link)
   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'
@@ -125,6 +128,7 @@ async function main(argv) {
     noSkills,
     skillPaths,
     panes,
+    autonomy,
     rest,
     error: globalFlagError
   } = extractGlobalFlags(argv, isCommandToken);
@@ -152,10 +156,16 @@ async function main(argv) {
     ...skillPaths.length > 0 ? { skillPaths } : {},
     ...panes === void 0 ? {} : { panes }
   };
+  if (autonomy !== void 0 && subcommand) {
+    printError(
+      `--autonomy before a subcommand applies to the interactive session only. For a headless turn use: clio-coder run --autonomy ${autonomy} "<task>"`
+    );
+    return 2;
+  }
   if (!subcommand) {
     await enableBootCompileCache();
-    const { runClioCommand } = await import("../clio-L2P7S2R2.js");
-    return runClioCommand(bootOptions);
+    const { runClioCommand } = await import("../clio-JUDCLNHC.js");
+    return runClioCommand({ ...bootOptions, ...autonomy === void 0 ? {} : { autonomy } });
   }
   return dispatch(subcommand, subArgs, bootOptions);
 }
@@ -164,28 +174,28 @@ async function enableBootCompileCache(subArgs = []) {
   const { enableClioCompileCache } = await import("../compile-cache-WJEPUZEJ.js");
   enableClioCompileCache();
 }
-var extensionsCommand = async (subArgs) => (await import("../extensions-NNL3ZOCU.js")).runExtensionsCommand(subArgs);
+var extensionsCommand = async (subArgs) => (await import("../extensions-PYQH3H47.js")).runExtensionsCommand(subArgs);
 var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
   [
     "acp",
     async (subArgs, bootOptions) => {
       await enableBootCompileCache(subArgs);
-      return (await import("../acp-W3Y3TRHD.js")).runAcpCommand(subArgs, bootOptions);
+      return (await import("../acp-ZWZCPS2A.js")).runAcpCommand(subArgs, bootOptions);
     }
   ],
-  ["auth", async (subArgs) => (await import("../auth-X2UJUMOC.js")).runAuthCommand(subArgs)],
-  ["config", async (subArgs) => (await import("../config-YXARKGTX.js")).runConfigCommand(subArgs)],
-  ["configure", async (subArgs) => (await import("../configure-LMVQJ46J.js")).runConfigureCommand(subArgs)],
-  ["targets", async (subArgs) => (await import("../targets-44VKGFLN.js")).runTargetsCommand(subArgs)],
-  ["models", async (subArgs) => (await import("../models-MASFJ6Y2.js")).runModelsCommand(subArgs)],
-  ["agents", async (subArgs) => (await import("../agents-J4ICNLQ3.js")).runAgentsCommand(subArgs)],
-  ["components", async (subArgs) => (await import("../components-63MMQKUT.js")).runComponentsCommand(subArgs)],
-  ["evidence", async (subArgs) => (await import("../evidence-O76QF7TZ.js")).runEvidenceCommand(subArgs)],
-  ["eval", async (subArgs) => (await import("../eval-4P7O6CCE.js")).runEvalCommand(subArgs)],
-  ["memory", async (subArgs) => (await import("../memory-DYVTTCP6.js")).runMemoryCommand(subArgs)],
-  ["usage", async (subArgs) => (await import("../usage-6EQV7EQK.js")).runUsageCommand(subArgs)],
-  ["trace", async (subArgs) => (await import("../trace-TAMIU4OJ.js")).runTraceCommand(subArgs)],
-  ["evolve", async (subArgs) => (await import("../evolve-H47BCETS.js")).runEvolveCommand(subArgs)],
+  ["auth", async (subArgs) => (await import("../auth-WBQGKWQ5.js")).runAuthCommand(subArgs)],
+  ["config", async (subArgs) => (await import("../config-P3ZQVF63.js")).runConfigCommand(subArgs)],
+  ["configure", async (subArgs) => (await import("../configure-25LRYZJG.js")).runConfigureCommand(subArgs)],
+  ["targets", async (subArgs) => (await import("../targets-EZKHAYRN.js")).runTargetsCommand(subArgs)],
+  ["models", async (subArgs) => (await import("../models-KQ6PQJJQ.js")).runModelsCommand(subArgs)],
+  ["agents", async (subArgs) => (await import("../agents-LYSOWZUE.js")).runAgentsCommand(subArgs)],
+  ["components", async (subArgs) => (await import("../components-OZXZMDWU.js")).runComponentsCommand(subArgs)],
+  ["evidence", async (subArgs) => (await import("../evidence-AVJ2RTHX.js")).runEvidenceCommand(subArgs)],
+  ["eval", async (subArgs) => (await import("../eval-FUNWJNUJ.js")).runEvalCommand(subArgs)],
+  ["memory", async (subArgs) => (await import("../memory-36CWN67Y.js")).runMemoryCommand(subArgs)],
+  ["usage", async (subArgs) => (await import("../usage-S2HOB7BZ.js")).runUsageCommand(subArgs)],
+  ["trace", async (subArgs) => (await import("../trace-C3MBGD4S.js")).runTraceCommand(subArgs)],
+  ["evolve", async (subArgs) => (await import("../evolve-MAWKRYWF.js")).runEvolveCommand(subArgs)],
   [
     "dev",
     async (subArgs, bootOptions) => {
@@ -204,30 +214,32 @@ var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
   ],
   ["extensions", extensionsCommand],
   ["ext", extensionsCommand],
-  ["fleet", async (subArgs) => (await import("../fleet-KMNS6NOM.js")).runFleetCommand(subArgs)],
-  ["library", async (subArgs) => (await import("../library-NY2XOT75.js")).runLibraryCommand(subArgs)],
-  ["tasks", async (subArgs) => (await import("../tasks-3KODKFU7.js")).runTasksCommand(subArgs)],
-  ["verifiers", async (subArgs) => (await import("../verifiers-JLITWSHU.js")).runVerifiersCommand(subArgs)],
-  ["docs", async (subArgs) => (await import("../docs-BL7ROUFN.js")).runDocsCommand(subArgs)],
-  ["share", async (subArgs) => (await import("../share-EZ6ERBMH.js")).runShareCommand(subArgs)],
-  ["export", async (subArgs) => (await import("../share-EZ6ERBMH.js")).runExportCommand(subArgs)],
-  ["import", async (subArgs) => (await import("../share-EZ6ERBMH.js")).runImportCommand(subArgs)],
-  ["context", async (subArgs) => (await import("../context-XSZKKFBW.js")).runContextCommand(subArgs)],
+  ["fleet", async (subArgs) => (await import("../fleet-ULBXXRDR.js")).runFleetCommand(subArgs)],
+  ["library", async (subArgs) => (await import("../library-Z3KZSHPE.js")).runLibraryCommand(subArgs)],
+  ["tasks", async (subArgs) => (await import("../tasks-SNEFHWYW.js")).runTasksCommand(subArgs)],
+  ["mcp", async (subArgs) => (await import("../mcp-5FWZKUS6.js")).runMcpCommand(subArgs)],
+  ["verifiers", async (subArgs) => (await import("../verifiers-QDTEVH7R.js")).runVerifiersCommand(subArgs)],
+  ["web", async (subArgs) => (await import("../web-EMGUGGEI.js")).runWebCommand(subArgs)],
+  ["docs", async (subArgs) => (await import("../docs-ZK777W2G.js")).runDocsCommand(subArgs)],
+  ["share", async (subArgs) => (await import("../share-HVWH4FPF.js")).runShareCommand(subArgs)],
+  ["export", async (subArgs) => (await import("../share-HVWH4FPF.js")).runExportCommand(subArgs)],
+  ["import", async (subArgs) => (await import("../share-HVWH4FPF.js")).runImportCommand(subArgs)],
+  ["context", async (subArgs) => (await import("../context-WB3D474G.js")).runContextCommand(subArgs)],
   [
     "run",
     async (subArgs, bootOptions) => {
       await enableBootCompileCache(subArgs);
-      return (await import("../run-BPZGEBZV.js")).runClioRun(subArgs, bootOptions);
+      return (await import("../run-AR7PY6GW.js")).runClioRun(subArgs, bootOptions);
     }
   ],
-  ["tools", async (subArgs) => (await import("../tools-3UB7TEVR.js")).runToolsCommand(subArgs)],
-  ["interop", async (subArgs) => (await import("../interop-FVECHFKG.js")).runInteropCommand(subArgs)],
-  ["panes", async (subArgs) => (await import("../panes-NICTHQCV.js")).runPanesCommand(subArgs)],
-  ["doctor", async (subArgs) => (await import("../doctor-EQYJOGUG.js")).runDoctorCommand(subArgs)],
-  ["paths", async (subArgs) => (await import("../paths-PSFAUIGO.js")).runPathsCommand(subArgs)],
-  ["reset", async (subArgs) => (await import("../reset-7NKZK7JN.js")).runResetCommand(subArgs)],
-  ["uninstall", async (subArgs) => (await import("../uninstall-QYVRPEM4.js")).runUninstallCommand(subArgs)],
-  ["upgrade", async (subArgs) => (await import("../upgrade-7PMKM2JH.js")).runUpgradeCommand(subArgs)],
+  ["tools", async (subArgs) => (await import("../tools-7IM6BDCE.js")).runToolsCommand(subArgs)],
+  ["interop", async (subArgs) => (await import("../interop-EF5JUWWK.js")).runInteropCommand(subArgs)],
+  ["panes", async (subArgs) => (await import("../panes-L27QRXUH.js")).runPanesCommand(subArgs)],
+  ["doctor", async (subArgs) => (await import("../doctor-WC4OV2OB.js")).runDoctorCommand(subArgs)],
+  ["paths", async (subArgs) => (await import("../paths-7DJDU4P4.js")).runPathsCommand(subArgs)],
+  ["reset", async (subArgs) => (await import("../reset-73VU3XNT.js")).runResetCommand(subArgs)],
+  ["uninstall", async (subArgs) => (await import("../uninstall-WWLOSZ42.js")).runUninstallCommand(subArgs)],
+  ["upgrade", async (subArgs) => (await import("../upgrade-ETK2JNSJ.js")).runUpgradeCommand(subArgs)],
   ["version", async () => (await import("../version-RFPKO6T7.js")).runVersionCommand()],
   [
     "worker",

package/dist/{clio-L2P7S2R2.js → clio-JUDCLNHC.js}

@@ -1,26 +1,26 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   runClioCommand
-} from "./chunk-GI5RRMAH.js";
-import "./chunk-6CA2BHOR.js";
+} from "./chunk-KW6OJ7IY.js";
+import "./chunk-OA2GDACN.js";
 import "./chunk-FXFVDPWY.js";
-import "./chunk-4MFBBY2Z.js";
-import "./chunk-24TOGHPO.js";
-import "./chunk-DXVMLM3Z.js";
-import "./chunk-4QKAITQT.js";
+import "./chunk-W72LLZAV.js";
+import "./chunk-X6FLVUM5.js";
+import "./chunk-FPS4R2RN.js";
 import "./chunk-DVNAPPXU.js";
-import "./chunk-E3LEPLQ2.js";
-import "./chunk-3XE4NRLF.js";
+import "./chunk-ZKJU55MX.js";
 import "./chunk-U2MSJ57E.js";
 import "./chunk-C27U2TYG.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-DXVMLM3Z.js";
 import "./chunk-6EXUUOSN.js";
 import "./chunk-DVJL77SO.js";
 import "./chunk-TK2BMCBZ.js";
-import "./chunk-B5GGDIHT.js";
-import "./chunk-ZZFWWYLX.js";
 import "./chunk-CTTI7G3T.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-E3LEPLQ2.js";
 import "./chunk-ECBHH7LU.js";
 export {
   runClioCommand
 };
-//# sourceMappingURL=clio-L2P7S2R2.js.map
+//# sourceMappingURL=clio-JUDCLNHC.js.map

package/dist/clio-context-tools-FT672MNZ.js

@@ -0,0 +1,136 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  runDocsScope
+} from "./chunk-NXTV5OI5.js";
+import "./chunk-4DNL43EZ.js";
+import "./chunk-IPTPMLA6.js";
+import "./chunk-MTOZEQHL.js";
+import "./chunk-ETF4ROKH.js";
+import "./chunk-XLLEL3K7.js";
+import "./chunk-WGRDABW7.js";
+import "./chunk-Y3M2T5RO.js";
+import "./chunk-7FBCRWVT.js";
+import "./chunk-DNCE23JJ.js";
+import "./chunk-YJCCMYYT.js";
+import {
+  clioDocsToolSurface,
+  clioLibraryToolSurface
+} from "./chunk-ACCECAH4.js";
+import "./chunk-HBJQQTKM.js";
+import "./chunk-O5F25NIE.js";
+import "./chunk-7QQRPB2E.js";
+import "./chunk-6UJ7RDI7.js";
+import "./chunk-2JBZYUPY.js";
+import "./chunk-SJMNU4ZS.js";
+import {
+  OBSERVE_SELF_CAPS,
+  observationBudgetExhausted,
+  reserveObservation
+} from "./chunk-ZKQ63XZ5.js";
+import "./chunk-IC7JXLOM.js";
+import "./chunk-X6FLVUM5.js";
+import "./chunk-GHXGMFQ5.js";
+import "./chunk-KECNXMDE.js";
+import "./chunk-WXA2CFJO.js";
+import "./chunk-I47EJPYL.js";
+import "./chunk-XW2UZICE.js";
+import "./chunk-FPS4R2RN.js";
+import "./chunk-DVNAPPXU.js";
+import "./chunk-5EQO5NWP.js";
+import "./chunk-H2WSCZZT.js";
+import "./chunk-SQBT46OF.js";
+import "./chunk-KQ6IDQIB.js";
+import "./chunk-H72DCH3E.js";
+import "./chunk-2KUBKL63.js";
+import "./chunk-MYI32N4R.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-M4KFUXS7.js";
+import {
+  ToolNames
+} from "./chunk-V4XJWDHR.js";
+import "./chunk-ZKJU55MX.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-UIU7MGZ3.js";
+import "./chunk-DXVMLM3Z.js";
+import "./chunk-XTQ7MEJG.js";
+import "./chunk-LTR5QCLS.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-NBPA5QM6.js";
+import "./chunk-EM2WNQS2.js";
+import "./chunk-O3VV6IVK.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-3RDHGNU7.js";
+import "./chunk-UHW5V7HC.js";
+import "./chunk-KMF54VH3.js";
+import "./chunk-SER7RRAE.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-CTTI7G3T.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-GD55RTIW.js";
+import "./chunk-E3LEPLQ2.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/gateway/clio-context-tools.ts
+init_esm_shims();
+function createClioDocsTool() {
+  return {
+    ...clioDocsToolSurface,
+    async run(args, options) {
+      const reservation = reserveObservation(OBSERVE_SELF_CAPS.contextDocs, options);
+      if (reservation.exhausted) {
+        return observationBudgetExhausted({
+          tool: ToolNames.ClioDocs,
+          unit: "sections",
+          reservation,
+          subject: typeof args.query === "string" && args.query.length > 0 ? `query=${args.query}` : "corpus",
+          hint: "Continue in a follow-up turn."
+        });
+      }
+      return runDocsScope(args, reservation, options, ToolNames.ClioDocs);
+    }
+  };
+}
+function createClioLibraryTool(deps = {}) {
+  return {
+    ...clioLibraryToolSurface,
+    async run(args, options) {
+      const reservation = reserveObservation(OBSERVE_SELF_CAPS.contextLibrary, options);
+      if (reservation.exhausted) {
+        return observationBudgetExhausted({
+          tool: ToolNames.ClioLibrary,
+          unit: "entries",
+          reservation,
+          subject: "catalog",
+          hint: "Continue in a follow-up turn."
+        });
+      }
+      const { runLibraryScope } = await import("./library-IJTOFTDS.js");
+      return runLibraryScope(
+        {
+          getCwd: () => deps.getCwd?.() ?? process.cwd(),
+          ...deps.skillMarketplace !== void 0 ? { skillMarketplace: deps.skillMarketplace } : {},
+          ...deps.getSkillLoaderOptions ? { skillLoaderOptions: deps.getSkillLoaderOptions() } : {}
+        },
+        args,
+        reservation,
+        options,
+        ToolNames.ClioLibrary
+      );
+    }
+  };
+}
+export {
+  clioDocsToolSurface,
+  clioLibraryToolSurface,
+  createClioDocsTool,
+  createClioLibraryTool
+};
+//# sourceMappingURL=clio-context-tools-FT672MNZ.js.map