@iowarp/clio-coder 0.4.2 → 0.4.4

package/dist/{chunk-2NHR3NAY.js → chunk-36CT5VVL.js}

@@ -5,17 +5,16 @@ import {
 } from "./chunk-BMS5RKQY.js";
 import {
   webFetchToolSurface
-} from "./chunk-MCEPRMZW.js";
+} from "./chunk-2CU2H6KE.js";
 import {
-  gitTool,
   verifyToolSurface
-} from "./chunk-7BHIY2MW.js";
+} from "./chunk-GX5WYQO4.js";
 import {
   codeNavToolSurface
-} from "./chunk-LJID3DYZ.js";
+} from "./chunk-RXTN6AKH.js";
 import {
   contextToolSurface
-} from "./chunk-PBP4B7XR.js";
+} from "./chunk-3UNOLWNZ.js";
 import {
   compileGlobRegex,
   fallbackIgnoredDirs,
@@ -32,31 +31,25 @@ import {
   readMaxBytes,
   readTool,
   renderAgentLedger
-} from "./chunk-IKSLQ4XV.js";
+} from "./chunk-75W7L2E2.js";
+import {
+  hashToolCall
+} from "./chunk-6QOTUPRG.js";
 import {
   createTaskBoardStore,
   taskBoardCounts
-} from "./chunk-Q4XWMHX6.js";
-import {
-  hashToolCall
-} from "./chunk-IDNA72AH.js";
+} from "./chunk-6PAZTBPA.js";
 import {
   formatModelRejection
-} from "./chunk-FVDGR2ZL.js";
+} from "./chunk-6Q3CYFD3.js";
 import {
   describeCallAction
 } from "./chunk-NEDJ26B5.js";
-import {
-  applyToolProfile
-} from "./chunk-42FMPA75.js";
 import {
   resolveReadPath,
   resolveToCwd,
   toPosixPath
 } from "./chunk-OQE5J4C6.js";
-import {
-  skillActivationFromToolDetails
-} from "./chunk-FSP7CMNU.js";
 import {
   OBSERVATION_POLICY_SLACK_BYTES,
   OBSERVE_SELF_CAPS,
@@ -68,42 +61,55 @@ import {
   reserveObservation,
   toolResultContextText,
   truncateHead
-} from "./chunk-B7HM5Z7T.js";
+} from "./chunk-NAI6ZFCY.js";
 import {
   GREP_MAX_LINE_LENGTH,
   truncateLine
 } from "./chunk-OZNBF4L3.js";
 import {
-  truncateUtf8
-} from "./chunk-6XLNIQDB.js";
-import {
-  parseAgentLedgerBody
-} from "./chunk-VAVR4IJY.js";
+  applyToolProfile
+} from "./chunk-QZWQA4DE.js";
 import {
   classify
-} from "./chunk-PGF63K6I.js";
+} from "./chunk-KFV5L5SK.js";
 import {
-  CLIO_ARTIFACT_DIR,
-  artifactDefaultPath,
   protectArtifact,
   protectedArtifactMutationBlockReason
-} from "./chunk-IKOZFYBN.js";
+} from "./chunk-NXYCB2VD.js";
+import {
+  gitTool
+} from "./chunk-BJVFZO5U.js";
+import {
+  CLIO_ARTIFACT_DIR,
+  artifactDefaultPath
+} from "./chunk-GYV6VZOC.js";
 import {
   typebox_exports
 } from "./chunk-5B2AEOW5.js";
+import {
+  parseAgentLedgerBody
+} from "./chunk-VAVR4IJY.js";
+import {
+  decisionRef,
+  skillActivationFromToolDetails
+} from "./chunk-54X7T7DK.js";
+import {
+  byteLength,
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
 import {
   ToolNames,
   isBuiltinToolName
-} from "./chunk-K6BSR66V.js";
+} from "./chunk-4NSRCOYP.js";
 import {
-  incompleteInstallationAdvice
-} from "./chunk-65DEGPJ6.js";
-import {
-  buildSafeToolEnv
-} from "./chunk-HJWWJ6IL.js";
+  assertSafeId
+} from "./chunk-R346GLFC.js";
 import {
   BusChannels
 } from "./chunk-F4EKGO4N.js";
+import {
+  incompleteInstallationAdvice
+} from "./chunk-65DEGPJ6.js";
 import {
   GUARDRAIL_DEFAULTS,
   resolveGuardrail,
@@ -112,10 +118,17 @@ import {
   workerToolCallCapExceededReason,
   workerToolCallCapSynthesisReason
 } from "./chunk-S66XZJOF.js";
+import {
+  buildSafeToolEnv
+} from "./chunk-TOIVGRUX.js";
 import {
   StringEnum,
   engineStreamSimple
-} from "./chunk-VXMFAE2W.js";
+} from "./chunk-YPC6ZR5L.js";
+import {
+  clioDataDir,
+  clioStateDir
+} from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -809,9 +822,13 @@ function dispositionAwareAfterToolCall(delegate) {
   };
 }
 function createEngineAgent(options = {}) {
+  const { streamFn = engineStreamSimple, onStreamInvocation, ...agentOptions } = options;
   const agent = new Agent({
-    streamFn: engineStreamSimple,
-    ...options,
+    ...agentOptions,
+    streamFn: onStreamInvocation ? (...args) => {
+      onStreamInvocation();
+      return streamFn(...args);
+    } : streamFn,
     afterToolCall: dispositionAwareAfterToolCall(options.afterToolCall)
   });
   return {
@@ -1480,6 +1497,115 @@ var credentialPresentTool = {
   }
 };
 
+// src/tools/decide.ts
+init_esm_shims();
+var DECIDE_CAPS = Object.freeze({
+  keyBytes: 64,
+  valueBytes: 512,
+  alternatives: 6,
+  alternativeBytes: 256,
+  rationaleBytes: 1024,
+  labelBytes: 128
+});
+var KEBAB_KEY = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+function boundedText(value, field, cap) {
+  if (typeof value !== "string") return new Error(`decide: ${field} must be a string`);
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return new Error(`decide: ${field} is required`);
+  if (byteLength(trimmed) > cap) return new Error(`decide: ${field} exceeds the ${cap}-byte cap`);
+  return trimmed;
+}
+function boundedAlternatives(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return new Error("decide: alternatives must list at least one option you rejected");
+  }
+  if (value.length > DECIDE_CAPS.alternatives) {
+    return new Error(`decide: alternatives exceeds the ${DECIDE_CAPS.alternatives}-entry cap`);
+  }
+  const alternatives = [];
+  for (const [index, entry] of value.entries()) {
+    const text = boundedText(entry, `alternatives[${index}]`, DECIDE_CAPS.alternativeBytes);
+    if (text instanceof Error) return text;
+    alternatives.push(text);
+  }
+  return alternatives;
+}
+function createDecideTool(deps = {}) {
+  return {
+    name: ToolNames.Decide,
+    description: "Record a design decision you made between two or more viable options, with the alternatives you rejected and why. Call it before implementing the choice; a later call with the same key supersedes the earlier record.",
+    parameters: typebox_exports.Object({
+      key: typebox_exports.String({
+        description: `Stable kebab-case name for the decision, e.g. "cache-key-shape" (at most ${DECIDE_CAPS.keyBytes} bytes).`
+      }),
+      value: typebox_exports.String({ description: `The option you chose (at most ${DECIDE_CAPS.valueBytes} bytes).` }),
+      alternatives: typebox_exports.Array(typebox_exports.String(), {
+        description: `Options you considered and rejected, 1 to ${DECIDE_CAPS.alternatives} entries.`
+      }),
+      rationale: typebox_exports.String({
+        description: `Why the chosen option won over the alternatives (at most ${DECIDE_CAPS.rationaleBytes} bytes).`
+      }),
+      label: typebox_exports.Optional(typebox_exports.String({ description: "Short human-readable title for the decision." }))
+    }),
+    // Read class on purpose: the only effect is one session-ledger append,
+    // so it must stay available at every autonomy level without a prompt.
+    baseActionClass: "read",
+    executionMode: "sequential",
+    async run(args) {
+      const key = boundedText(args.key, "key", DECIDE_CAPS.keyBytes);
+      if (key instanceof Error) return { kind: "error", message: key.message };
+      if (!KEBAB_KEY.test(key)) {
+        return { kind: "error", message: "decide: key must be kebab-case (lowercase letters, digits, single hyphens)" };
+      }
+      const value = boundedText(args.value, "value", DECIDE_CAPS.valueBytes);
+      if (value instanceof Error) return { kind: "error", message: value.message };
+      const alternatives = boundedAlternatives(args.alternatives);
+      if (alternatives instanceof Error) return { kind: "error", message: alternatives.message };
+      const rationale = boundedText(args.rationale, "rationale", DECIDE_CAPS.rationaleBytes);
+      if (rationale instanceof Error) return { kind: "error", message: rationale.message };
+      let label;
+      if (args.label !== void 0 && args.label !== null) {
+        const bounded = boundedText(args.label, "label", DECIDE_CAPS.labelBytes);
+        if (bounded instanceof Error) return { kind: "error", message: bounded.message };
+        label = bounded;
+      }
+      if (deps.decisionBoard === void 0) {
+        return { kind: "error", message: "decide: no session decision board is available in this context" };
+      }
+      let outcome;
+      try {
+        outcome = deps.decisionBoard.recordAgentDecision({
+          key,
+          value,
+          alternatives,
+          rationale,
+          ...label !== void 0 ? { label } : {}
+        });
+      } catch (error) {
+        return { kind: "error", message: error instanceof Error ? error.message : String(error) };
+      }
+      const ref = decisionRef(outcome.entry.interviewId, key);
+      const supersededNote = outcome.superseded === null ? "" : ` (supersedes ${decisionRef(outcome.superseded.interviewId, outcome.superseded.key)})`;
+      return {
+        kind: "ok",
+        output: `decision recorded: ${key} = ${value} [${ref}]${supersededNote}
+`,
+        details: {
+          decision: {
+            ref,
+            key,
+            value,
+            alternatives,
+            rationale,
+            ...label !== void 0 ? { label } : {},
+            ...outcome.superseded !== null ? { superseded: decisionRef(outcome.superseded.interviewId, outcome.superseded.key) } : {}
+          }
+        }
+      };
+    }
+  };
+}
+
 // src/tools/edit.ts
 init_esm_shims();
 import { readFileSync, writeFileSync as writeFileSync2 } from "node:fs";
@@ -2509,6 +2635,88 @@ var editTool = {
   }
 };
 
+// src/tools/evidence.ts
+init_esm_shims();
+var EVIDENCE_TOOL_MAX_BYTES = 16384;
+function boundedResult(value) {
+  const serialized = JSON.stringify(value, null, 2);
+  if (Buffer.byteLength(serialized, "utf8") <= EVIDENCE_TOOL_MAX_BYTES) {
+    return { kind: "ok", output: serialized, details: { truncated: false } };
+  }
+  const hint = "Inspect one run to narrow the output; this preview is incomplete JSON text.";
+  let preview = truncateUtf8(serialized, EVIDENCE_TOOL_MAX_BYTES, "");
+  let output = JSON.stringify({ truncated: true, hint, preview });
+  while (Buffer.byteLength(output, "utf8") > EVIDENCE_TOOL_MAX_BYTES) {
+    const excess = Buffer.byteLength(output, "utf8") - EVIDENCE_TOOL_MAX_BYTES;
+    preview = truncateUtf8(preview, Math.max(0, Buffer.byteLength(preview, "utf8") - excess), "");
+    output = JSON.stringify({ truncated: true, hint, preview });
+  }
+  return { kind: "ok", output, details: { truncated: true } };
+}
+var evidenceTool = {
+  name: ToolNames.Evidence,
+  description: "Read canonical evidence as JSON. List recent bundles, inspect a bundle's overview, trust axes and tier, gate decisions, and findings, or build/read evidence for a run.",
+  parameters: typebox_exports.Object({
+    mode: StringEnum(["list", "inspect", "run"]),
+    id: typebox_exports.Optional(typebox_exports.String({ description: "Evidence bundle id for inspect." })),
+    runId: typebox_exports.Optional(typebox_exports.String({ description: "Run id for run." }))
+  }),
+  baseActionClass: "read",
+  // Run mode may materialize a derived bundle in Clio's data directory.
+  executionMode: "sequential",
+  async run(args) {
+    const mode = args.mode;
+    if (mode !== "list" && mode !== "inspect" && mode !== "run") {
+      return { kind: "error", message: "evidence: mode must be list, inspect, or run" };
+    }
+    try {
+      const dataDir = clioDataDir();
+      if (mode === "list") {
+        const { evidenceInventorySnapshot } = await import("./inventory-C26CFDRR.js");
+        return boundedResult(await evidenceInventorySnapshot(Date.now, dataDir));
+      }
+      const id = mode === "inspect" ? args.id : args.runId;
+      if (typeof id !== "string" || id.length === 0) {
+        return { kind: "error", message: `evidence: ${mode} requires ${mode === "inspect" ? "id" : "runId"}` };
+      }
+      assertSafeId(id, mode === "inspect" ? "evidence" : "run");
+      const { buildEvidence, EvidenceNotFoundError, inspectEvidence, loadEvidenceGateDecisions } = await import("./evidence-4F5USFKH.js");
+      const { evidenceDetailSnapshot } = await import("./detail-A7JAVSIG.js");
+      let evidenceId = mode === "run" ? `run-${id}` : id;
+      let inspected;
+      try {
+        inspected = await inspectEvidence(dataDir, evidenceId);
+      } catch (error) {
+        if (mode !== "run" || !(error instanceof EvidenceNotFoundError)) throw error;
+        try {
+          evidenceId = (await buildEvidence({ dataDir, stateDir: clioStateDir(), runId: id })).evidenceId;
+        } catch (buildError) {
+          if (buildError instanceof Error && (buildError.message === "run ledger not found" || buildError.message === `run not found: ${id}`))
+            throw new EvidenceNotFoundError(evidenceId);
+          throw buildError;
+        }
+        inspected = await inspectEvidence(dataDir, evidenceId);
+      }
+      return boundedResult({
+        ...inspected,
+        ...await evidenceDetailSnapshot(evidenceId, Date.now, dataDir),
+        gateDecisions: await loadEvidenceGateDecisions(dataDir, evidenceId)
+      });
+    } catch (error) {
+      const absent = error instanceof Error && error.name === "EvidenceNotFoundError";
+      return {
+        kind: "error",
+        message: truncateUtf8(
+          `evidence: ${error instanceof Error ? error.message : String(error)}`,
+          EVIDENCE_TOOL_MAX_BYTES - 3,
+          "..."
+        ),
+        details: { code: absent ? "artifact_absent" : "evidence_error", artifactAbsent: absent }
+      };
+    }
+  }
+};
+
 // src/tools/find.ts
 init_esm_shims();
 import { existsSync, statSync } from "node:fs";
@@ -3364,6 +3572,59 @@ ${output}`,
   };
 }
 
+// src/tools/limitation.ts
+init_esm_shims();
+var LIMITATION_REASONS = ["no-runner", "blocked", "out-of-scope", "environment", "other"];
+function isLimitationReason(value) {
+  return typeof value === "string" && LIMITATION_REASONS.includes(value);
+}
+function trimString2(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function normalizePaths(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) return null;
+  const paths = [];
+  for (const item of value) {
+    const path4 = trimString2(item);
+    if (path4 === null) return null;
+    if (!paths.includes(path4)) paths.push(path4);
+  }
+  return paths;
+}
+var limitationTool = {
+  name: ToolNames.Limitation,
+  description: "Record what this turn could not verify and why. Call it once, before your final reply, when you changed files but could not run validation; the receipt stands in for validation evidence at the finish gate.",
+  parameters: typebox_exports.Object({
+    scope: typebox_exports.String({ description: "What could not be verified, in one sentence." }),
+    reason: StringEnum(LIMITATION_REASONS, {
+      description: "no-runner: no test or build runner is available; blocked: a safety gate or denial stopped the check; out-of-scope: verification was excluded by the task; environment: the environment cannot run the check; other."
+    }),
+    paths: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String(), { description: "Repository-relative paths left unverified." }))
+  }),
+  baseActionClass: "read",
+  executionMode: "parallel",
+  async run(args) {
+    const scope = trimString2(args.scope);
+    if (scope === null) return { kind: "error", message: "limitation: scope is required" };
+    if (!isLimitationReason(args.reason)) {
+      return { kind: "error", message: `limitation: reason must be one of ${LIMITATION_REASONS.join(", ")}` };
+    }
+    const paths = normalizePaths(args.paths);
+    if (paths === null) return { kind: "error", message: "limitation: paths must be an array of non-empty strings" };
+    const limitation = { scope, reason: args.reason, paths };
+    const pathSuffix = paths.length > 0 ? ` paths=${paths.join(",")}` : "";
+    return {
+      kind: "ok",
+      output: `limitation recorded: ${scope} (reason=${limitation.reason}${pathSuffix})
+`,
+      details: { limitation }
+    };
+  }
+};
+
 // src/tools/ls.ts
 init_esm_shims();
 import { readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
@@ -3461,6 +3722,7 @@ var lsTool = {
 // src/tools/policy.ts
 init_esm_shims();
 var TOOL_PLANES = {
+  [ToolNames.Evidence]: { plane: "observe", actionClass: "read", executionMode: "sequential" },
   [ToolNames.Read]: { plane: "observe", actionClass: "read", executionMode: "parallel" },
   [ToolNames.Grep]: { plane: "observe", actionClass: "read", executionMode: "parallel" },
   [ToolNames.Find]: { plane: "observe", actionClass: "read", executionMode: "parallel" },
@@ -3493,6 +3755,14 @@ var TOOL_PLANES = {
   // panes. It mutates no workspace, so it stays read class; sequential because
   // two pane operations in one batch would race the same pane registry.
   [ToolNames.Panes]: { plane: "orchestrate", actionClass: "read", executionMode: "sequential" },
+  // limitation records a typed receipt in the session ledger and nothing
+  // else: no filesystem, no shell. Read class so it never trips a safety
+  // gate; parallel because the call is pure and idempotent.
+  [ToolNames.Limitation]: { plane: "orchestrate", actionClass: "read", executionMode: "parallel" },
+  // decide appends one decision-board entry to the session ledger and
+  // nothing else. Read class so it never trips a safety gate; sequential so
+  // two decisions in one batch never race the supersede lookup.
+  [ToolNames.Decide]: { plane: "orchestrate", actionClass: "read", executionMode: "sequential" },
   [ToolNames.WebFetch]: { plane: "retrieve", actionClass: "read", executionMode: "parallel" },
   [ToolNames.AskUser]: { plane: "interact", actionClass: "read", executionMode: "sequential" },
   [ToolNames.Artifact]: { plane: "artifact", actionClass: "write", executionMode: "sequential" }
@@ -3599,6 +3869,10 @@ function renderTaskBoardText(board, userTasks = []) {
     if (task.status === "blocked" && task.reason) line += ` \u2014 blocked: ${task.reason}`;
     if (task.status === "cancelled" && task.reason) line += ` \u2014 dropped: ${task.reason}`;
     lines.push(line);
+    const outputs = userTasks.find((item) => item.id === task.userTaskId)?.acceptance?.expectedOutputs;
+    if (outputs?.length) lines.push(`  expected outputs: ${outputs.join(", ")}`);
+    for (const item of task.requiredValidationEvidence ?? [])
+      lines.push(`  acceptance: ${item.command} (${item.status}; ${item.notes})`);
   }
   if (counts.open > 0 && counts.active === 0) {
     lines.push(`next: start a task with action="start" before working it`);
@@ -3732,7 +4006,12 @@ function createTasksTool(deps) {
         if (userTask.status !== "open" && userTask.status !== "handed") {
           return { kind: "error", message: `tasks: operator task ${id} is ${userTask.status}; it cannot be picked` };
         }
-        const result2 = deps.board.apply({ op: "pick", title: userTask.title, userTaskId: userTask.id });
+        const result2 = deps.board.apply({
+          op: "pick",
+          title: userTask.title,
+          userTaskId: userTask.id,
+          ...userTask.acceptance ? { verification: userTask.acceptance.verification } : {}
+        });
         if (!result2.ok) return { kind: "error", message: `tasks: ${result2.message}` };
         const picked = result2.board.tasks.find((task) => task.userTaskId === userTask.id && task.status === "pending");
         if (!picked) return { kind: "error", message: `tasks: durable pickup for ${id} did not produce a board row` };
@@ -3834,6 +4113,7 @@ note: ${pathArg} no longer ends with a newline; the previous content did`;
 // src/tools/core-bootstrap.ts
 function registerCoreTools(registry, deps = {}) {
   const includeNetworkTools = !networkToolsDisabled();
+  registry.register(builtin(evidenceTool, { path: "src/tools/evidence.ts", scope: "core" }));
   registry.register({
     ...builtin(readTool, { path: "src/tools/read.ts", scope: "core" })
   });
@@ -3858,7 +4138,7 @@ function registerCoreTools(registry, deps = {}) {
   if (includeNetworkTools) {
     registry.register({
       ...builtin(
-        lazyTool(webFetchToolSurface, async () => (await import("./web-fetch-MPARV2K7.js")).webFetchTool),
+        lazyTool(webFetchToolSurface, async () => (await import("./web-fetch-V4FKSDAV.js")).webFetchTool),
         { path: "src/tools/web-fetch.ts", scope: "core" }
       )
     });
@@ -3868,13 +4148,13 @@ function registerCoreTools(registry, deps = {}) {
   });
   registry.register({
     ...builtin(
-      lazyTool(verifyToolSurface, async () => (await import("./verify-5K7ZKQFC.js")).verifyTool),
+      lazyTool(verifyToolSurface, async () => (await import("./verify-FWYGPKMR.js")).verifyTool),
       { path: "src/tools/verify/index.ts", scope: "core" }
     )
   });
   registry.register({
     ...builtin(
-      lazyTool(codeNavToolSurface, async () => (await import("./code-nav-YVLCYA7V.js")).codeNavTool),
+      lazyTool(codeNavToolSurface, async () => (await import("./code-nav-IJR2DBPR.js")).codeNavTool),
       { path: "src/tools/codewiki/code-nav.ts", scope: "core" }
     )
   });
@@ -3894,12 +4174,21 @@ function registerCoreTools(registry, deps = {}) {
   registry.register({
     ...builtin(credentialPresentTool, { path: "src/tools/credential-present.ts", scope: "core" })
   });
+  registry.register({
+    ...builtin(limitationTool, { path: "src/tools/limitation.ts", scope: "core" })
+  });
+  registry.register({
+    ...builtin(createDecideTool(deps.decisionBoard ? { decisionBoard: deps.decisionBoard } : {}), {
+      path: "src/tools/decide.ts",
+      scope: "core"
+    })
+  });
   const session = deps.session;
   const readSessionEntries = deps.readSessionEntries;
   registry.register({
     ...builtin(
       lazyTool(contextToolSurface, async () => {
-        const { createContextTool } = await import("./context-KQYIWPWT.js");
+        const { createContextTool } = await import("./context-2DKHWH2T.js");
         if (!session) return createContextTool(skillToolDeps);
         const { probeWorkspace } = await import("./workspace-ZJ6BFM3Q.js");
         return createContextTool({
@@ -3997,4 +4286,4 @@ export {
   registerCoreTools,
   assertRegisteredBuiltinTools
 };
-//# sourceMappingURL=chunk-2NHR3NAY.js.map
+//# sourceMappingURL=chunk-36CT5VVL.js.map

package/dist/{chunk-2X4RYJTJ.js → chunk-3GY4F45V.js}

@@ -7,10 +7,10 @@ import {
 } from "./chunk-5B2AEOW5.js";
 import {
   ToolNames
-} from "./chunk-K6BSR66V.js";
+} from "./chunk-4NSRCOYP.js";
 import {
   StringEnum
-} from "./chunk-VXMFAE2W.js";
+} from "./chunk-YPC6ZR5L.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -36,4 +36,4 @@ var panesToolSurface = {
 export {
   panesToolSurface
 };
-//# sourceMappingURL=chunk-2X4RYJTJ.js.map
+//# sourceMappingURL=chunk-3GY4F45V.js.map

package/dist/{chunk-ZW55JB7N.js → chunk-3ODX73FK.js}

@@ -1,13 +1,11 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  printError
-} from "./chunk-VPKWYKEY.js";
-import {
+  printError,
   source_default
-} from "./chunk-5TSRNF4G.js";
+} from "./chunk-JCI2ROMZ.js";
 import {
   authStoragePath
-} from "./chunk-WNP7O5WZ.js";
+} from "./chunk-ID64D7PE.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -35,4 +33,4 @@ export {
   printPlaintextCredentialWarning,
   credentialWriteFailed
 };
-//# sourceMappingURL=chunk-ZW55JB7N.js.map
+//# sourceMappingURL=chunk-3ODX73FK.js.map

package/dist/{chunk-PBP4B7XR.js → chunk-3UNOLWNZ.js}

@@ -4,10 +4,10 @@ import {
 } from "./chunk-5B2AEOW5.js";
 import {
   ToolNames
-} from "./chunk-K6BSR66V.js";
+} from "./chunk-4NSRCOYP.js";
 import {
   StringEnum
-} from "./chunk-VXMFAE2W.js";
+} from "./chunk-YPC6ZR5L.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -32,4 +32,4 @@ var contextToolSurface = {
 export {
   contextToolSurface
 };
-//# sourceMappingURL=chunk-PBP4B7XR.js.map
+//# sourceMappingURL=chunk-3UNOLWNZ.js.map

package/dist/{chunk-4JDLP6ZS.js → chunk-3UUXNFEX.js}

@@ -1,7 +1,4 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  shellQuote
-} from "./chunk-TXOTCRLG.js";
 import {
   WORKER_BULK_FRAME_MAX_BYTES,
   WORKER_EVENT_QUEUE_MAX_FRAMES,
@@ -17,17 +14,17 @@ import {
   toolSignatureOf
 } from "./chunk-VAVR4IJY.js";
 import {
-  enableClioCompileCache,
-  workerCompileCacheEnvironment
-} from "./chunk-2LEAKD4C.js";
+  readClioVersion,
+  resolvePackageRoot
+} from "./chunk-IWHMRKLL.js";
 import {
   AI_AGENT_NAME,
   withClioAgentEnvironment
 } from "./chunk-6EJMN2Y3.js";
 import {
-  readClioVersion,
-  resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
+  enableClioCompileCache,
+  workerCompileCacheEnvironment
+} from "./chunk-2LEAKD4C.js";
 import {
   clioStateDir
 } from "./chunk-BYP5D4HI.js";
@@ -42,6 +39,12 @@ import { existsSync, readFileSync } from "node:fs";
 import { join as join2 } from "node:path";
 import { performance as performance2 } from "node:perf_hooks";
 
+// src/core/shell-quote.ts
+init_esm_shims();
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
 // src/domains/dispatch/route-facts.ts
 init_esm_shims();
 var ROUTE_FACT_FRESHNESS_MS = 15 * 60 * 1e3;
@@ -929,6 +932,7 @@ async function runFleetNodePreflight(node, projectRoot, options) {
 }
 
 export {
+  shellQuote,
   computeSettingsFingerprint,
   receiptAttestationFields,
   spawnNativeWorker,
@@ -940,4 +944,4 @@ export {
   routeFactVerdict,
   runFleetNodePreflight
 };
-//# sourceMappingURL=chunk-4JDLP6ZS.js.map
+//# sourceMappingURL=chunk-3UUXNFEX.js.map