@iowarp/clio-coder 0.4.4 → 0.4.5

package/dist/{chunk-BWH6N36D.js → chunk-VHKTOLEW.js}

@@ -1,34 +1,225 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  createSlicer,
-  isIndexablePath,
-  languageForPath
-} from "./chunk-UUVG37B4.js";
+  createSlicer
+} from "./chunk-KPRLAMP4.js";
 import {
-  CODEWIKI_VERSION
-} from "./chunk-LBMZMYH2.js";
+  CODEWIKI_VERSION,
+  readCodewiki,
+  readCodewikiAsync
+} from "./chunk-W2RJEH6Q.js";
 import {
   WORKSPACE_EXCLUDED_DIRS,
+  enumerateWorkspaceFiles,
   enumerateWorkspaceFilesAsync,
   filterWorkspaceFileCandidates
-} from "./chunk-33YXPOE3.js";
+} from "./chunk-PPEZJWUG.js";
 import {
   classifyCHeaderLanguage,
   isAmbiguousHeaderPath
-} from "./chunk-7CR24IG7.js";
+} from "./chunk-WDV62RKY.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
-// src/domains/context/codewiki/indexer.ts
+// src/domains/context/fingerprint.ts
 init_esm_shims();
+import { execFile, execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+// src/domains/context/codewiki/paths.ts
+init_esm_shims();
+
+// src/domains/context/excluded-dirs.ts
+init_esm_shims();
+
+// src/domains/context/codewiki/paths.ts
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Map([
+  [".ts", "typescript"],
+  [".tsx", "typescript"],
+  [".mts", "typescript"],
+  [".cts", "typescript"],
+  [".js", "javascript"],
+  [".jsx", "javascript"],
+  [".mjs", "javascript"],
+  [".cjs", "javascript"],
+  [".py", "python"],
+  [".pyw", "python"],
+  [".rs", "rust"],
+  [".go", "go"],
+  [".c", "c"],
+  [".h", "c"],
+  [".cc", "c++"],
+  [".cpp", "c++"],
+  [".cxx", "c++"],
+  [".hpp", "c++"],
+  [".hh", "c++"],
+  [".hxx", "c++"],
+  [".cu", "c++"],
+  [".cuh", "c++"],
+  [".java", "java"],
+  [".rb", "ruby"],
+  [".cs", "c#"]
+]);
+var CONFIG_FILE_NAMES = /* @__PURE__ */ new Set([
+  "package.json",
+  "pyproject.toml",
+  "setup.py",
+  "Cargo.toml",
+  "go.mod",
+  "pom.xml",
+  "CMakeLists.txt",
+  "compile_commands.json",
+  "Gemfile"
+]);
+function extensionOf(name) {
+  const index = name.lastIndexOf(".");
+  return index === -1 ? "" : name.slice(index);
+}
+function sourceLanguageForPath(relPath) {
+  if (relPath.endsWith(".d.ts")) return null;
+  return SOURCE_EXTENSIONS.get(extensionOf(relPath)) ?? null;
+}
+function languageForPath(relPath) {
+  const source = sourceLanguageForPath(relPath);
+  if (source) return source;
+  const name = relPath.split("/").pop() ?? relPath;
+  return CONFIG_FILE_NAMES.has(name) || name.endsWith(".csproj") || name.toLowerCase().endsWith(".cmake") ? "config" : null;
+}
+function isIndexablePath(relPath) {
+  if (relPath.split("/").some((segment) => WORKSPACE_EXCLUDED_DIRS.has(segment))) return false;
+  return languageForPath(relPath) !== null;
+}
+
+// src/domains/context/fingerprint.ts
+var execFileAsync = promisify(execFile);
+var DEFAULT_FINGERPRINT_CACHE_TTL_MS = 5e3;
+var cachedFingerprints = /* @__PURE__ */ new Map();
+var LOC_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".rs",
+  ".go",
+  ".cc",
+  ".cpp",
+  ".cxx",
+  ".hpp",
+  ".hh",
+  ".hxx",
+  ".c",
+  ".h",
+  ".cu",
+  ".cuh",
+  ".java",
+  ".kt"
+]);
+function extensionOf2(name) {
+  const index = name.lastIndexOf(".");
+  return index === -1 ? "" : name.slice(index);
+}
+function currentGitHead(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+async function currentGitHeadAsync(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", "HEAD"], { cwd, encoding: "utf8" });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+function countLines(text) {
+  if (text.length === 0) return 0;
+  let lines = 1;
+  for (const ch of text) {
+    if (ch === "\n") lines += 1;
+  }
+  return lines;
+}
+function locFromCodewiki(codewiki) {
+  if (!codewiki) return null;
+  return codewiki.files.reduce((sum, file) => file.lang === "config" ? sum : sum + file.loc, 0);
+}
+function createTreeHash() {
+  return createHash("sha256").update("clio-codewiki-tree:v3\n");
+}
+function accumulateFile(cwd, relPath, hash, artifactLoc) {
+  const contents = readFileSync(join(cwd, relPath));
+  const digest = createHash("sha256").update(contents).digest("hex");
+  hash.update(`${JSON.stringify(relPath)}:${digest}
+`);
+  if (artifactLoc === null && LOC_EXTENSIONS.has(extensionOf2(relPath))) return countLines(contents.toString("utf8"));
+  return 0;
+}
+function computeFingerprint(cwd, codewiki = readCodewiki(cwd), options = {}) {
+  const files = enumerateWorkspaceFiles(cwd, WORKSPACE_EXCLUDED_DIRS).filter(isIndexablePath);
+  const hash = createTreeHash();
+  const artifactLoc = options.artifactLoc ?? locFromCodewiki(codewiki);
+  let loc = 0;
+  for (const relPath of files) loc += accumulateFile(cwd, relPath, hash, artifactLoc);
+  return {
+    treeHash: hash.digest("hex"),
+    gitHead: currentGitHead(cwd),
+    loc: artifactLoc ?? loc
+  };
+}
+async function computeFingerprintAsync(cwd, codewiki = void 0, options = {}) {
+  const slicer = options.slicer ?? createSlicer();
+  const artifact = codewiki === void 0 ? await readCodewikiAsync(cwd) : codewiki;
+  await slicer.tick();
+  const files = (await enumerateWorkspaceFilesAsync(cwd, WORKSPACE_EXCLUDED_DIRS, void 0, slicer)).filter(isIndexablePath);
+  const hash = createTreeHash();
+  const artifactLoc = locFromCodewiki(artifact);
+  let loc = 0;
+  for (const relPath of files) {
+    await slicer.tick();
+    loc += accumulateFile(cwd, relPath, hash, artifactLoc);
+  }
+  return {
+    treeHash: hash.digest("hex"),
+    gitHead: await currentGitHeadAsync(cwd),
+    loc: artifactLoc ?? loc
+  };
+}
+function computeFingerprintCached(cwd, codewiki = readCodewiki(cwd), options = {}) {
+  const now = Date.now();
+  const cached = cachedFingerprints.get(cwd);
+  if (cached && cached.expiresAtMs > now) return cached.fingerprint;
+  const fingerprint = computeFingerprint(cwd, codewiki, options);
+  const ttlMs = options.ttlMs ?? DEFAULT_FINGERPRINT_CACHE_TTL_MS;
+  cachedFingerprints.set(cwd, {
+    fingerprint,
+    expiresAtMs: Date.now() + Math.max(0, ttlMs)
+  });
+  return fingerprint;
+}
+function isStale(prev, curr) {
+  return prev.treeHash !== curr.treeHash;
+}
+
+// src/domains/context/codewiki/indexer.ts
+init_esm_shims();
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { dirname, join as join2, relative, resolve } from "node:path";
 
 // src/domains/context/codewiki/cmake.ts
 init_esm_shims();
-var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([
   ".c",
   ".cc",
   ".cpp",
@@ -280,7 +471,7 @@ function sourceSpecifier(value) {
   if (!path || path.includes(";") || path.startsWith("-") || TARGET_SOURCE_KEYWORDS.has(path.toUpperCase())) return null;
   const withoutQuery = path.split(/[?#]/, 1)[0] ?? path;
   const dot = withoutQuery.lastIndexOf(".");
-  if (dot === -1 || !SOURCE_EXTENSIONS.has(withoutQuery.slice(dot).toLowerCase())) return null;
+  if (dot === -1 || !SOURCE_EXTENSIONS2.has(withoutQuery.slice(dot).toLowerCase())) return null;
   return relativeSpecifier(path);
 }
 function childCMakeSpecifier(value) {
@@ -332,7 +523,7 @@ function extractCMake(text) {
 var CODEWIKI_SYMBOL_KINDS_WITH_SIG = /* @__PURE__ */ new Set(["func", "class", "method", "type"]);
 var treeSitterExtractorPromise = null;
 function loadTreeSitterExtractor() {
-  treeSitterExtractorPromise ??= import("./tree-sitter-HGKH6LG4.js").then(
+  treeSitterExtractorPromise ??= import("./tree-sitter-AQUUOSYM.js").then(
     ({ createTreeSitterExtractor }) => createTreeSitterExtractor()
   );
   return treeSitterExtractorPromise;
@@ -367,14 +558,14 @@ function compareStrings2(a, b) {
   return a.localeCompare(b);
 }
 function stableFileId(path) {
-  return `f_${createHash("sha256").update(path).digest("hex").slice(0, 16)}`;
+  return `f_${createHash2("sha256").update(path).digest("hex").slice(0, 16)}`;
 }
 function contentHash(text) {
-  return createHash("sha256").update(text).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(text).digest("hex").slice(0, 16);
 }
 function defaultReadFile(path) {
   try {
-    return readFileSync(path, "utf8");
+    return readFileSync2(path, "utf8");
   } catch {
     return null;
   }
@@ -923,7 +1114,7 @@ function buildFile(cwd, relPath, treeSitterExtractor, readFile) {
   if (!pathLanguage) return null;
   let text;
   try {
-    text = readFile(join(cwd, relPath));
+    text = readFile(join2(cwd, relPath));
   } catch {
     return null;
   }
@@ -960,22 +1151,17 @@ function buildFile(cwd, relPath, treeSitterExtractor, readFile) {
   };
 }
 function candidatePathsForImport(cwd, fromRel, specifier) {
-  const fromDir = dirname(join(cwd, fromRel));
+  const fromDir = dirname(join2(cwd, fromRel));
   const cleaned = specifier.replace(/\\/g, "/");
   const base = cleaned.startsWith(".") || cleaned.startsWith("/") ? resolve(fromDir, cleaned) : "";
   if (!base) return [];
   const candidates = [base];
   for (const ext of RESOLUTION_EXTENSIONS) candidates.push(`${base}${ext}`);
-  for (const ext of RESOLUTION_EXTENSIONS) candidates.push(join(base, `index${ext}`));
+  for (const ext of RESOLUTION_EXTENSIONS) candidates.push(join2(base, `index${ext}`));
   if (cleaned.endsWith(".js")) {
     const stripped = base.replace(/\.js$/, "");
     for (const ext of [".ts", ".tsx", ".mts", ".cts"]) candidates.push(`${stripped}${ext}`);
   }
-  if (/^[.]+[A-Za-z_]/.test(cleaned)) {
-    const pythonModule = cleaned.replace(/^\.+/, "").replace(/\./g, "/");
-    const pythonBase = resolve(fromDir, pythonModule);
-    candidates.push(`${pythonBase}.py`, join(pythonBase, "__init__.py"));
-  }
   return uniqueSorted2(
     candidates.map((candidate) => normalizeRel(cwd, candidate)).filter((candidate) => !candidate.startsWith(".."))
   );
@@ -984,10 +1170,34 @@ function createImportResolver(cwd) {
   const candidatesByOrigin = /* @__PURE__ */ new Map();
   const onDisk = /* @__PURE__ */ new Map();
   const candidatesFor = (fromRel, specifier) => {
-    const key = `${dirname(fromRel)}\0${specifier}`;
+    const python = /\.pyw?$/.test(fromRel);
+    const key = `${python}\0${dirname(fromRel)}\0${specifier}`;
     let candidates = candidatesByOrigin.get(key);
     if (!candidates) {
-      candidates = candidatePathsForImport(cwd, fromRel, specifier);
+      if (python) {
+        const fromDir = dirname(fromRel);
+        let packageRoot = fromDir;
+        while (packageRoot !== "." && isFile(join2(packageRoot, "__init__.py"))) {
+          packageRoot = dirname(packageRoot);
+        }
+        const dots = /^\.+/.exec(specifier)?.[0].length ?? 0;
+        const modulePath = specifier.slice(dots).replace(/\./g, "/");
+        let bases;
+        if (dots > 0) {
+          const parent = resolve(cwd, fromDir, ...Array(dots - 1).fill(".."));
+          const root = resolve(cwd, packageRoot === fromDir ? "." : packageRoot);
+          const insidePackage = parent !== root || root === resolve(cwd) && isFile("__init__.py");
+          bases = insidePackage && !relative(root, parent).startsWith("..") ? [join2(parent, modulePath)] : [];
+        } else {
+          bases = [resolve(cwd, modulePath)];
+          if (packageRoot !== fromDir && packageRoot !== ".") bases.push(resolve(cwd, packageRoot, modulePath));
+        }
+        candidates = [...new Set(bases.flatMap((base) => [join2(base, "__init__.py"), `${base}.py`]))].map(
+          (candidate) => normalizeRel(cwd, candidate)
+        );
+      } else {
+        candidates = candidatePathsForImport(cwd, fromRel, specifier);
+      }
       candidatesByOrigin.set(key, candidates);
     }
     return candidates;
@@ -997,7 +1207,7 @@ function createImportResolver(cwd) {
     if (cached !== void 0) return cached;
     let exists;
     try {
-      exists = statSync(join(cwd, candidate)).isFile();
+      exists = statSync(join2(cwd, candidate)).isFile();
     } catch {
       exists = false;
     }
@@ -1102,30 +1312,42 @@ async function updateCodewikiPaths(cwd, codewiki, paths, options = {}) {
   if (normalizedPaths.some(
     (path) => path === ".gitignore" || path.endsWith("/.gitignore") || path === ".git/info/exclude" || path === ".git/index" || path === ".gitmodules"
   )) {
-    return buildCodewiki({ cwd, language: codewiki.language }, options);
+    return syncCodewiki(cwd, codewiki, options);
   }
   const slicer = options.slicer ?? createSlicer();
-  const existingPaths = new Set(codewiki.files.map((file) => file.path));
+  const existingFiles = new Map(codewiki.files.map((file) => [file.path, file]));
   const visiblePaths = new Set(filterWorkspaceFileCandidates(cwd, normalizedPaths, WORKSPACE_EXCLUDED_DIRS));
   const readFile = options.readFile ?? defaultReadFile;
-  const changedPathSet = new Set(normalizedPaths);
+  const currentTexts = /* @__PURE__ */ new Map();
+  const changedPathSet = /* @__PURE__ */ new Set();
   const rebuildPaths = [];
-  let hasIndexChange = false;
   for (const relPath of normalizedPaths) {
-    const wasIndexed = existingPaths.has(relPath);
+    const existing = existingFiles.get(relPath);
     const isCurrentIndexableFile = isIndexablePath(relPath) && visiblePaths.has(relPath);
-    if (!wasIndexed && !isCurrentIndexableFile) continue;
-    hasIndexChange = true;
-    if (isCurrentIndexableFile) rebuildPaths.push(relPath);
+    if (!existing && !isCurrentIndexableFile) continue;
+    if (isCurrentIndexableFile) {
+      const text = readFile(join2(cwd, relPath));
+      if (text !== null) {
+        if (existing?.hash === contentHash(text)) continue;
+        currentTexts.set(relPath, text);
+        rebuildPaths.push(relPath);
+      }
+    }
+    changedPathSet.add(relPath);
   }
-  if (!hasIndexChange) return codewiki;
+  if (changedPathSet.size === 0) return codewiki;
   const rebuiltFiles = [];
   if (rebuildPaths.length > 0) {
     const treeSitterExtractor = await loadTreeSitterExtractor();
     await treeSitterExtractor.ensureGrammarsForPaths(rebuildPaths);
     for (const relPath of rebuildPaths) {
       await slicer.tick();
-      const built = buildFile(cwd, relPath, treeSitterExtractor, readFile);
+      const built = buildFile(
+        cwd,
+        relPath,
+        treeSitterExtractor,
+        (path) => currentTexts.get(normalizeRel(cwd, path)) ?? null
+      );
       if (built) rebuiltFiles.push(built);
     }
   }
@@ -1150,7 +1372,7 @@ async function syncCodewiki(cwd, codewiki, options = {}) {
   const currentTexts = /* @__PURE__ */ new Map();
   for (const relPath of currentPaths) {
     await slicer.tick();
-    const text = readFile(join(cwd, relPath));
+    const text = readFile(join2(cwd, relPath));
     if (text !== null) {
       currentFiles.set(relPath, contentHash(text));
       currentTexts.set(relPath, text);
@@ -1164,7 +1386,11 @@ async function syncCodewiki(cwd, codewiki, options = {}) {
   for (const relPath of indexedFiles.keys()) {
     if (!currentFiles.has(relPath)) changedPaths.add(relPath);
   }
-  if (changedPaths.size === 0) return codewiki;
+  if (changedPaths.size === 0) {
+    if (!codewiki.files.some((file) => file.lang === "python")) return codewiki;
+    const edges = await buildEdges(cwd, codewiki.files, slicer);
+    return JSON.stringify(edges) === JSON.stringify(codewiki.edges) ? codewiki : { ...codewiki, edges };
+  }
   const syncOptions = {
     ...options,
     slicer,
@@ -1179,8 +1405,12 @@ function symbolSigFields(kind, sig) {
 }
 
 export {
+  computeFingerprint,
+  computeFingerprintAsync,
+  computeFingerprintCached,
+  isStale,
   buildCodewiki,
   updateCodewikiPaths,
   syncCodewiki
 };
-//# sourceMappingURL=chunk-BWH6N36D.js.map
+//# sourceMappingURL=chunk-VHKTOLEW.js.map

package/dist/{chunk-EXLD33WO.js → chunk-VLPTKCKT.js}

@@ -2,31 +2,39 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   discoverDeclaredChecksAtRoot,
   discoverDeclaredProjectEntriesAtRoot
-} from "./chunk-K6T2ZAMZ.js";
+} from "./chunk-HGSLRG33.js";
 import {
   printError
-} from "./chunk-JCI2ROMZ.js";
+} from "./chunk-3T4DXWP6.js";
 import {
   DISPATCH_INTENT_TIMEOUT_MIN_MS,
   normalizeIntentExpectedOutputs,
   normalizeIntentVerification
-} from "./chunk-IRXAATOX.js";
+} from "./chunk-L4N3DWNW.js";
 import {
   packageDeclaredCheck
-} from "./chunk-DXKJURES.js";
+} from "./chunk-MDU3C27C.js";
 import {
   CLIO_PROJECT_DIR
-} from "./chunk-GYV6VZOC.js";
+} from "./chunk-NTTS3O53.js";
 import {
   atomicWrite
-} from "./chunk-HAXOFFRH.js";
+} from "./chunk-FQOOGXBH.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/cli/tasks.ts
 init_esm_shims();
 
+// src/domains/user-tasks/handoff.ts
+init_esm_shims();
+function formatUserTaskHandoff(task) {
+  const note = task.note ? ` ${task.note}.` : "";
+  const acceptance = task.acceptance ? ` Acceptance: ${JSON.stringify(task.acceptance)}.` : "";
+  return `Operator task ${task.id}: ${task.title}.${note}${acceptance} Before working this task, call tasks action="pick" id="${task.id}" and confirm its durable session/board link. Use the returned linked tN for start and done; do not replace the pickup with a self-created plan or pick unrelated inbox tasks. Respect the task's authorized scope, including proposal-only limits. If pickup fails, report the actual state and stop this task's work. After work and required verification, call tasks done on that linked tN with concrete evidence, then tasks list. Claim ${task.id} completed only if the linked board row is completed and the durable operator task is done with the same session/board link. Report the IDs, actual state, and verification results or limitations; an unpicked or still-handed task is not done.`;
+}
+
 // src/domains/user-tasks/store.ts
 init_esm_shims();
 import { existsSync, readFileSync } from "node:fs";
@@ -364,7 +372,13 @@ function runTasksCommand(args) {
     } else if (action === "list" && rest.length === 0) {
       console.log(JSON.stringify(store.snapshot(), null, 2));
     } else if ((action === "hand" || action === "done" || action === "drop") && rest.length === 1) {
-      console.log(JSON.stringify(store[action](rest[0] ?? ""), null, 2));
+      const task = store[action](rest[0] ?? "");
+      console.log(JSON.stringify(task, null, 2));
+      if (action === "hand") {
+        console.error(
+          "CLI hand records the inbox state only; it does not start a session or submit the interactive /tasks hand turn. Pass this pickup prompt to clio-coder run in the same project:\n" + formatUserTaskHandoff(task)
+        );
+      }
     } else throw new Error(HELP);
     return 0;
   } catch (error) {
@@ -375,7 +389,8 @@ function runTasksCommand(args) {
 
 export {
   createUserTasksStore,
+  formatUserTaskHandoff,
   acceptanceFromTaskFlags,
   runTasksCommand
 };
-//# sourceMappingURL=chunk-EXLD33WO.js.map
+//# sourceMappingURL=chunk-VLPTKCKT.js.map

package/dist/{chunk-336NSSKI.js → chunk-VNBICSS2.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/core/resolve-config-value.ts
 init_esm_shims();
@@ -77,4 +77,4 @@ export {
   expandConfigPath,
   resolveDynamicConfigValue
 };
-//# sourceMappingURL=chunk-336NSSKI.js.map
+//# sourceMappingURL=chunk-VNBICSS2.js.map

package/dist/{chunk-VAVR4IJY.js → chunk-VQD7NH7Z.js}

@@ -1,10 +1,10 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   normalizeClioCoderEventRecord
-} from "./chunk-BTK3SSSK.js";
+} from "./chunk-KMF54VH3.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/worker/protocol.ts
 init_esm_shims();
@@ -353,4 +353,4 @@ export {
   parseControlFrame,
   isReceiptBearingFrame
 };
-//# sourceMappingURL=chunk-VAVR4IJY.js.map
+//# sourceMappingURL=chunk-VQD7NH7Z.js.map

package/dist/{chunk-LBMZMYH2.js → chunk-W2RJEH6Q.js}

@@ -1,10 +1,10 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   safeResourceWrite
-} from "./chunk-WEPFGWHJ.js";
+} from "./chunk-ZZFWWYLX.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/context/codewiki/schema.ts
 init_esm_shims();
@@ -282,4 +282,4 @@ export {
   structuralCodewikiHash,
   codewikiEntries
 };
-//# sourceMappingURL=chunk-LBMZMYH2.js.map
+//# sourceMappingURL=chunk-W2RJEH6Q.js.map

package/dist/{chunk-7CR24IG7.js → chunk-WDV62RKY.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/core/c-header-language.ts
 init_esm_shims();
@@ -239,4 +239,4 @@ export {
   isAmbiguousHeaderPath,
   classifyCHeaderLanguage
 };
-//# sourceMappingURL=chunk-7CR24IG7.js.map
+//# sourceMappingURL=chunk-WDV62RKY.js.map

package/dist/{chunk-S6PYF2XF.js → chunk-WFKDPU7U.js}

@@ -1,13 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   compileExecutionPlan
-} from "./chunk-LTIKRKFL.js";
+} from "./chunk-ONRTXOZY.js";
 import {
   deriveExecutionRole
-} from "./chunk-H7IXIC72.js";
+} from "./chunk-LY4N4TTL.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/dispatch/scout-transition.ts
 init_esm_shims();
@@ -94,4 +94,4 @@ function compileScoutTransition(input) {
 export {
   compileScoutTransition
 };
-//# sourceMappingURL=chunk-S6PYF2XF.js.map
+//# sourceMappingURL=chunk-WFKDPU7U.js.map

package/dist/{chunk-BJVFZO5U.js → chunk-WJIMKGD6.js}

@@ -1,25 +1,25 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   typebox_exports
-} from "./chunk-5B2AEOW5.js";
+} from "./chunk-GH5ZR6JP.js";
 import {
   truncateUtf8
-} from "./chunk-6XLNIQDB.js";
+} from "./chunk-MYI32N4R.js";
 import {
   ToolNames
-} from "./chunk-4NSRCOYP.js";
+} from "./chunk-EHOSNVVM.js";
 import {
   SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES,
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   combineSafeOutput,
   runCommandVector
-} from "./chunk-TOIVGRUX.js";
+} from "./chunk-GJ24ODAX.js";
 import {
   StringEnum
-} from "./chunk-YPC6ZR5L.js";
+} from "./chunk-5CMARGPF.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/tools/safe-exec.ts
 init_esm_shims();
@@ -129,4 +129,4 @@ export {
   runVectorTool,
   gitTool
 };
-//# sourceMappingURL=chunk-BJVFZO5U.js.map
+//# sourceMappingURL=chunk-WJIMKGD6.js.map