@iowarp/clio-coder 0.4.3 → 0.4.5

package/dist/chunk-LVFANMOH.js

@@ -0,0 +1,466 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  createSlicer
+} from "./chunk-KPRLAMP4.js";
+import {
+  WORKSPACE_EXCLUDED_DIRS,
+  enumerateWorkspaceFiles,
+  enumerateWorkspaceFilesAsync
+} from "./chunk-PPEZJWUG.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  safeResourceWrite
+} from "./chunk-ZZFWWYLX.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/context/wiki/frontmatter.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { isAbsolute, join, normalize, relative } from "node:path";
+var FRONTMATTER_BLOCK = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+var LIST_FIELDS = ["sources", "symbols", "tests", "invariants", "validate", "decisions"];
+var SUMMARY_MAX_CHARS = 240;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function usableString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function stringList(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    const usable = usableString(entry);
+    if (usable) seen.add(usable);
+  }
+  return [...seen];
+}
+function wikiPageHeading(text) {
+  return usableString(/^#\s+(.+?)\s*$/m.exec(stripFrontmatter(text).body)?.[1]);
+}
+function titleFromPagePath(pagePath) {
+  const base = pagePath.replace(/^.*\//, "").replace(/\.md$/i, "");
+  const spaced = base.replace(/[-_]+/g, " ").trim();
+  return spaced.length > 0 ? spaced.charAt(0).toUpperCase() + spaced.slice(1) : base;
+}
+function stripFrontmatter(content) {
+  const match = FRONTMATTER_BLOCK.exec(content);
+  if (!match) return { block: null, body: content };
+  return { block: match[1] ?? "", body: content.slice(match[0].length) };
+}
+function summaryFromBody(body) {
+  const skipped = ["#", "|", "```", "-", "*", ">", "<!--"];
+  const paragraphs = body.split(/\r?\n\s*\r?\n/).map((paragraph) => paragraph.replace(/\s+/g, " ").trim()).filter((paragraph) => paragraph.length > 0 && !skipped.some((prefix) => paragraph.startsWith(prefix)));
+  const first = paragraphs[0] ?? "";
+  return first.length > SUMMARY_MAX_CHARS ? `${first.slice(0, SUMMARY_MAX_CHARS - 1).trimEnd()}\u2026` : first;
+}
+function isWithin(root, candidate) {
+  const rel = relative(root, candidate);
+  return rel.length === 0 || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function resolveSourcePath(sourceRoot, cited) {
+  if (cited.length === 0 || isAbsolute(cited) || /[*?{}<>]/.test(cited)) return null;
+  const direct = normalize(join(sourceRoot, cited));
+  if (!isWithin(sourceRoot, direct)) return null;
+  if (existsSync(direct)) return direct;
+  if (cited.endsWith(".js")) {
+    for (const extension of [".ts", ".tsx"]) {
+      const authored = normalize(join(sourceRoot, `${cited.slice(0, -3)}${extension}`));
+      if (isWithin(sourceRoot, authored) && existsSync(authored)) return authored;
+    }
+  }
+  return null;
+}
+function readWikiPage(input) {
+  const { block, body } = stripFrontmatter(input.content);
+  let fields;
+  if (block !== null) {
+    try {
+      fields = (0, import_yaml.parse)(`
+${block}`, { schema: "core", uniqueKeys: true });
+    } catch {
+      fields = void 0;
+    }
+  }
+  const authored = isRecord(fields) ? fields : {};
+  const metadata = {
+    title: usableString(authored.title) ?? wikiPageHeading(body) ?? titleFromPagePath(input.pagePath),
+    summary: usableString(authored.summary) ?? summaryFromBody(body),
+    sources: [],
+    symbols: stringList(authored.symbols),
+    tests: [],
+    invariants: stringList(authored.invariants),
+    validate: stringList(authored.validate),
+    ...authored.decisions === void 0 ? {} : { decisions: stringList(authored.decisions) }
+  };
+  const unresolvedPaths = [];
+  for (const field of ["sources", "tests"]) {
+    for (const cited of stringList(authored[field])) {
+      if (input.sourceRoot === void 0 || resolveSourcePath(input.sourceRoot, cited) !== null) {
+        metadata[field].push(cited);
+      } else {
+        unresolvedPaths.push(cited);
+      }
+    }
+  }
+  return { metadata, body, unresolvedPaths };
+}
+function renderList(name, values) {
+  if (values.length === 0) return [];
+  return [`${name}:`, ...values.map((value) => `  - ${JSON.stringify(value)}`)];
+}
+function renderFrontmatter(metadata) {
+  const lines = [`title: ${JSON.stringify(metadata.title)}`];
+  if (metadata.summary.length > 0) lines.push(`summary: ${JSON.stringify(metadata.summary)}`);
+  for (const field of LIST_FIELDS) lines.push(...renderList(field, metadata[field] ?? []));
+  return `---
+${lines.join("\n")}
+---
+`;
+}
+function renderWikiPage(metadata, body) {
+  const trimmed = body.replace(/^\s+/, "").replace(/\s+$/, "");
+  const hasHeading = /^#\s+\S/m.test(trimmed);
+  const withHeading = hasHeading ? trimmed : `# ${metadata.title}
+
+${trimmed}`;
+  return `${renderFrontmatter(metadata)}
+${withHeading}
+`;
+}
+
+// src/domains/context/wiki/layout.ts
+init_esm_shims();
+import { readdirSync, readFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+var WIKI_QUICKSTART = "quickstart.md";
+var WIKI_INDEX = "index.md";
+var WIKI_PLAN_FILE = "_plan.json";
+var NON_PAGE_FILES = /* @__PURE__ */ new Set(["meta.json", WIKI_PLAN_FILE]);
+function compareStrings(a, b) {
+  return a.localeCompare(b);
+}
+function wikiDir(cwd) {
+  return join2(cwd, ".clio-coder", "wiki");
+}
+function wikiMarkdownFilesInDir(dir, prefix = "") {
+  let entries;
+  try {
+    entries = readdirSync(join2(dir, prefix), { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    const relPath = prefix.length > 0 ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...wikiMarkdownFilesInDir(dir, relPath));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".md") && !NON_PAGE_FILES.has(entry.name)) {
+      files.push(relPath);
+    }
+  }
+  return files.sort(compareStrings);
+}
+function isGeneratedWikiFile(relPath) {
+  return relPath === WIKI_QUICKSTART || relPath === WIKI_INDEX || relPath.endsWith(`/${WIKI_INDEX}`);
+}
+function listWikiPagesInDir(dir) {
+  const pages = [];
+  for (const relPath of wikiMarkdownFilesInDir(dir)) {
+    if (relPath !== WIKI_QUICKSTART && isGeneratedWikiFile(relPath)) continue;
+    let content = "";
+    try {
+      content = readFileSync(join2(dir, relPath), "utf8");
+    } catch {
+      content = "";
+    }
+    const { metadata } = readWikiPage({ pagePath: relPath, content });
+    pages.push({
+      path: relPath,
+      title: metadata.title,
+      ...metadata.summary.length > 0 ? { summary: metadata.summary } : {}
+    });
+  }
+  return pages;
+}
+function listWikiPages(cwd) {
+  return listWikiPagesInDir(wikiDir(cwd));
+}
+
+// src/domains/context/wiki/plan-store.ts
+init_esm_shims();
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+
+// src/domains/context/wiki/source-content.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+import { closeSync, constants, fstatSync, openSync, readSync } from "node:fs";
+import { join as join3 } from "node:path";
+var MAX_FILES = 2e4;
+var MAX_BYTES = 128 * 1024 * 1024;
+function parseWikiSourceContent(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entries = Object.entries(value);
+  if (entries.length > MAX_FILES) return void 0;
+  if (entries.some(([path, hash]) => !path || hash !== null && (typeof hash !== "string" || !/^[a-f0-9]{64}$/.test(hash))))
+    return void 0;
+  return Object.fromEntries(entries);
+}
+function capture(cwd, files) {
+  const content = /* @__PURE__ */ Object.create(null);
+  let remainingBytes = MAX_BYTES;
+  const buffer = Buffer.alloc(64 * 1024);
+  return {
+    content,
+    add(path) {
+      if (files.length > MAX_FILES) return;
+      let fd;
+      content[path] = null;
+      try {
+        fd = openSync(join3(cwd, path), constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        const before = fstatSync(fd);
+        if (!before.isFile() || before.size > remainingBytes) return;
+        remainingBytes -= before.size;
+        const hash = createHash("sha256");
+        let remaining = before.size;
+        while (remaining > 0) {
+          const count = readSync(fd, buffer, 0, Math.min(buffer.length, remaining), null);
+          if (count === 0) return;
+          hash.update(buffer.subarray(0, count));
+          remaining -= count;
+        }
+        const after = fstatSync(fd);
+        if (after.size === before.size && after.mtimeMs === before.mtimeMs && after.ctimeMs === before.ctimeMs)
+          content[path] = hash.digest("hex");
+      } catch {
+      } finally {
+        if (fd !== void 0) closeSync(fd);
+      }
+    }
+  };
+}
+function captureWikiSourceContent(cwd) {
+  try {
+    const files = enumerateWorkspaceFiles(cwd, WORKSPACE_EXCLUDED_DIRS);
+    const snapshot = capture(cwd, files);
+    for (const path of files) snapshot.add(path);
+    return snapshot.content;
+  } catch {
+    return {};
+  }
+}
+async function captureWikiSourceContentAsync(cwd) {
+  try {
+    const slicer = createSlicer();
+    const files = await enumerateWorkspaceFilesAsync(cwd, WORKSPACE_EXCLUDED_DIRS, void 0, slicer);
+    const snapshot = capture(cwd, files);
+    for (const path of files) {
+      snapshot.add(path);
+      await slicer.tick();
+    }
+    return snapshot.content;
+  } catch {
+    return {};
+  }
+}
+function wikiSourcesMatch(previous, current, sources) {
+  if (!previous || Object.keys(previous).length === 0 || Object.keys(current).length === 0) return false;
+  const claimed = sources?.map((path) => path.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, ""));
+  const paths = [.../* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(current)])].filter(
+    (path) => !claimed || claimed.some((source) => path === source || path.startsWith(`${source}/`))
+  );
+  if (claimed?.some((source) => !paths.some((path) => path === source || path.startsWith(`${source}/`)))) return false;
+  return paths.length > 0 && paths.every((path) => previous[path] != null && previous[path] === current[path]);
+}
+
+// src/domains/context/wiki/plan-store.ts
+var MAX_PAGE_ATTEMPTS = 3;
+var MAX_INTENT_CHARS = 600;
+var MAX_PLAN_PAGES = 200;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function usableString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function stringList2(value, limit) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const entry of value) {
+    const usable = usableString2(entry);
+    if (usable && !out.includes(usable)) out.push(usable);
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+function sanitizePagePath(value) {
+  const raw = usableString2(value);
+  if (raw === null) return null;
+  const normalized = raw.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
+  if (!normalized.endsWith(".md") || normalized.length > 200) return null;
+  const segments = normalized.split("/");
+  if (segments.some((segment) => segment.length === 0 || segment === "." || segment === ".." || segment.startsWith("."))) {
+    return null;
+  }
+  if (isGeneratedWikiFile(normalized)) return null;
+  return normalized;
+}
+function wikiPlanPath(dir) {
+  return join4(dir, WIKI_PLAN_FILE);
+}
+function parsedStatus(value) {
+  return value === "written" || value === "pending" ? value : null;
+}
+function parsedAttempts(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function parsedFailure(value) {
+  if (!isRecord2(value)) return void 0;
+  const phase = value.phase;
+  if (phase !== "admission" && phase !== "writer" && phase !== "validation") return void 0;
+  const detail = usableString2(value.detail)?.replace(/\s+/gu, " ").slice(0, 500);
+  if (!detail) return void 0;
+  const runId = usableString2(value.runId)?.slice(0, 120);
+  return { phase, detail, ...runId ? { runId } : {} };
+}
+function sanitizeWikiPlan(value, previous, options = { trustStatus: true }) {
+  if (!isRecord2(value) || !Array.isArray(value.pages)) return null;
+  const priorByPath = new Map((previous?.pages ?? []).map((page) => [page.path, page]));
+  const pages = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value.pages) {
+    if (pages.length >= MAX_PLAN_PAGES) break;
+    if (!isRecord2(entry)) continue;
+    const path = sanitizePagePath(entry.path);
+    if (path === null || seen.has(path)) continue;
+    const intent = (usableString2(entry.intent) ?? "").slice(0, MAX_INTENT_CHARS);
+    const title = usableString2(entry.title) ?? path.replace(/\.md$/, "");
+    const sources = stringList2(entry.sources, 16);
+    const prior = priorByPath.get(path);
+    const changedSpec = prior !== void 0 && (prior.title !== title || prior.intent !== intent || JSON.stringify([...prior.sources].sort()) !== JSON.stringify([...sources].sort()));
+    const recorded = options.trustStatus ? parsedStatus(entry.status) : null;
+    const recordedAttempts = options.trustStatus ? parsedAttempts(entry.attempts) : null;
+    const lastFailure = prior?.lastFailure ?? (options.trustStatus ? parsedFailure(entry.lastFailure) : void 0);
+    const dependencies = prior?.dependencies ?? (options.trustStatus ? stringList2(entry.dependencies, Number.POSITIVE_INFINITY) : []);
+    seen.add(path);
+    pages.push({
+      path,
+      title,
+      intent,
+      sources,
+      ...dependencies.length > 0 ? { dependencies } : {},
+      status: changedSpec ? "pending" : prior?.status ?? recorded ?? "pending",
+      attempts: changedSpec ? 0 : prior?.attempts ?? recordedAttempts ?? 0,
+      ...!changedSpec && (prior?.status ?? recorded) !== "written" && lastFailure ? { lastFailure } : {}
+    });
+  }
+  if (pages.length === 0) return null;
+  const retiredPages = [
+    .../* @__PURE__ */ new Set([
+      ...previous?.retiredPages ?? (options.trustStatus ? stringList2(value.retiredPages, MAX_PLAN_PAGES) : []),
+      ...previous?.pages.filter((page) => !seen.has(page.path)).map((page) => page.path) ?? []
+    ])
+  ].map(sanitizePagePath).filter((path) => path !== null && !seen.has(path));
+  const sourceContent = previous?.sourceContent ?? (options.trustStatus ? parseWikiSourceContent(value.sourceContent) : void 0);
+  const sourceTreeHash = previous?.sourceTreeHash ?? (options.trustStatus ? value.sourceTreeHash : void 0);
+  const sourceGitHead = previous?.sourceGitHead ?? (options.trustStatus ? value.sourceGitHead : void 0);
+  const depth = previous?.depth ?? (options.trustStatus ? value.depth : void 0);
+  const requestedDepth = previous?.requestedDepth ?? (options.trustStatus ? value.requestedDepth : void 0);
+  return {
+    version: 1,
+    ...depth === "simple" || depth === "medium" || depth === "detailed" ? { depth } : {},
+    ...requestedDepth === "auto" || requestedDepth === "simple" || requestedDepth === "medium" || requestedDepth === "detailed" ? { requestedDepth } : {},
+    ...sourceContent ? { sourceContent } : {},
+    ...retiredPages.length ? { retiredPages } : {},
+    ...typeof sourceTreeHash === "string" && /^[a-f0-9]{64}$/.test(sourceTreeHash) ? { sourceTreeHash } : {},
+    ...typeof sourceGitHead === "string" && /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(sourceGitHead) ? { sourceGitHead } : {},
+    overview: usableString2(value.overview) ?? previous?.overview ?? "",
+    pages
+  };
+}
+function readPlanDocument(dir) {
+  const filePath = wikiPlanPath(dir);
+  if (!existsSync2(filePath)) return void 0;
+  try {
+    return JSON.parse(readFileSync2(filePath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function readWikiPlanFile(dir, previous) {
+  const document = readPlanDocument(dir);
+  return document === void 0 ? null : sanitizeWikiPlan(document, previous, { trustStatus: true });
+}
+function readAuthoredWikiPlan(dir, previous) {
+  const document = readPlanDocument(dir);
+  return document === void 0 ? null : sanitizeWikiPlan(document, previous, { trustStatus: false });
+}
+function writeWikiPlanFile(dir, plan) {
+  safeResourceWrite(wikiPlanPath(dir), `${JSON.stringify(plan, null, 2)}
+`, { encoding: "utf8" });
+}
+function unclaimedCandidates(plan, candidate, pageSources = /* @__PURE__ */ new Map()) {
+  const knownPaths = new Set(plan.pages.map((page) => page.path));
+  const claimed = /* @__PURE__ */ new Set();
+  for (const page of plan.pages) {
+    for (const source of [...page.sources, ...page.dependencies ?? [], ...pageSources.get(page.path) ?? []])
+      claimed.add(source);
+  }
+  return candidate.pages.filter(
+    (page) => !knownPaths.has(page.path) && !page.sources.some((source) => claimed.has(source))
+  );
+}
+function scopePlanForUpdate(input) {
+  const changedPrefixes = [...input.changedPaths];
+  const pages = input.plan.pages.map((page) => {
+    if (page.status !== "written") return page;
+    if (!input.existingPages.has(page.path)) return { ...page, status: "pending", attempts: 0 };
+    const claimed = [...input.pageSources.get(page.path) ?? [], ...page.sources, ...page.dependencies ?? []];
+    const touched = claimed.some(
+      (source) => changedPrefixes.some((changed) => changed === source || changed.startsWith(`${source}/`))
+    );
+    return touched ? { ...page, status: "pending", attempts: 0 } : { ...page, status: "written" };
+  });
+  return { ...input.plan, pages };
+}
+function pendingPages(plan, retryExhausted = false) {
+  return plan.pages.filter((page) => page.status !== "written" && (retryExhausted || page.attempts < MAX_PAGE_ATTEMPTS));
+}
+
+export {
+  stripFrontmatter,
+  resolveSourcePath,
+  readWikiPage,
+  renderWikiPage,
+  WIKI_QUICKSTART,
+  WIKI_INDEX,
+  WIKI_PLAN_FILE,
+  wikiDir,
+  wikiMarkdownFilesInDir,
+  isGeneratedWikiFile,
+  listWikiPagesInDir,
+  listWikiPages,
+  captureWikiSourceContent,
+  captureWikiSourceContentAsync,
+  wikiSourcesMatch,
+  MAX_PAGE_ATTEMPTS,
+  sanitizePagePath,
+  sanitizeWikiPlan,
+  readWikiPlanFile,
+  readAuthoredWikiPlan,
+  writeWikiPlanFile,
+  unclaimedCandidates,
+  scopePlanForUpdate,
+  pendingPages
+};
+//# sourceMappingURL=chunk-LVFANMOH.js.map

package/dist/{chunk-H7IXIC72.js → chunk-LY4N4TTL.js}

@@ -1,7 +1,10 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  withResultSummaryAllowance
+} from "./chunk-OQM5IVJY.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/dispatch/execution-role.ts
 init_esm_shims();
@@ -53,6 +56,17 @@ function gateDeciderAgentId(requested) {
 function appliesRecipeResultContract(gateRole) {
   return gateRole !== "reviewer" && gateRole !== "judge" && gateRole !== "synthesis";
 }
+function dispatchResultContract(req, recipe) {
+  if (!appliesRecipeResultContract(req.gate?.role)) return void 0;
+  const base = req.resultContractOverride ?? recipe?.resultContract;
+  const allowance = req.resultSummary;
+  if (allowance === void 0) return base;
+  if (base?.kind === "mutation-report") return withResultSummaryAllowance(base, allowance.maxBytes);
+  if (req.resultContractOverride !== void 0 || allowance.scope === "batch") return base;
+  throw new Error(
+    `dispatch: result_summary_max_bytes applies only to a mutation-report result contract; agent '${req.agentId}' declares ${base === void 0 ? "no result contract" : base.kind}`
+  );
+}
 function routeCorrelationFactsForRun(run) {
   return {
     agentId: run.agentId,
@@ -96,8 +110,8 @@ export {
   requestExecutionRole,
   withAttemptRole,
   gateDeciderAgentId,
-  appliesRecipeResultContract,
+  dispatchResultContract,
   routeCorrelationFactsForRun,
   gateRouteCorrelation
 };
-//# sourceMappingURL=chunk-H7IXIC72.js.map
+//# sourceMappingURL=chunk-LY4N4TTL.js.map

package/dist/{chunk-VKPAQYEB.js → chunk-LZBMXNLP.js}

@@ -2,17 +2,17 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   createRedactionTally,
   redactSecretsText
-} from "./chunk-4BJ5BYCE.js";
+} from "./chunk-O3VV6IVK.js";
 import {
   normalizeClioCoderEventType
-} from "./chunk-BTK3SSSK.js";
+} from "./chunk-KMF54VH3.js";
 import {
   processAlive,
   processBirthToken
-} from "./chunk-3I7MS7N2.js";
+} from "./chunk-TK2BMCBZ.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/observability/trace-store.ts
 init_esm_shims();
@@ -1193,4 +1193,4 @@ export {
   createDispatchTraceMirror,
   assertTraceSelectOnly
 };
-//# sourceMappingURL=chunk-VKPAQYEB.js.map
+//# sourceMappingURL=chunk-LZBMXNLP.js.map

package/dist/{chunk-UL3WSD3F.js → chunk-M4KFUXS7.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/verification-scripts.ts
 init_esm_shims();
@@ -24,4 +24,4 @@ export {
   isProjectVerifierCheckId,
   declaredVerificationScripts
 };
-//# sourceMappingURL=chunk-UL3WSD3F.js.map
+//# sourceMappingURL=chunk-M4KFUXS7.js.map

package/dist/{chunk-I7ZPNEJM.js → chunk-M6TAYK66.js}

@@ -1,19 +1,19 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  canonicalizeExistingPath
+} from "./chunk-KQ6IDQIB.js";
 import {
   artifactDefaultPath
-} from "./chunk-GYV6VZOC.js";
+} from "./chunk-NTTS3O53.js";
 import {
   isVerificationScriptName
-} from "./chunk-UL3WSD3F.js";
-import {
-  canonicalizeExistingPath
-} from "./chunk-ECH6PKUQ.js";
+} from "./chunk-M4KFUXS7.js";
 import {
   ToolNames
-} from "./chunk-K6BSR66V.js";
+} from "./chunk-EHOSNVVM.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/safety/protected-artifacts.ts
 init_esm_shims();
@@ -804,4 +804,4 @@ export {
   commandArgumentSegments,
   scanShellLike
 };
-//# sourceMappingURL=chunk-I7ZPNEJM.js.map
+//# sourceMappingURL=chunk-M6TAYK66.js.map

package/dist/{chunk-NEKRRTYW.js → chunk-MC3JSVR6.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/domains/providers/probe/fingerprint.ts
 init_esm_shims();
@@ -53,4 +53,4 @@ async function fingerprintNativeRuntime(baseUrl) {
 export {
   fingerprintNativeRuntime
 };
-//# sourceMappingURL=chunk-NEKRRTYW.js.map
+//# sourceMappingURL=chunk-MC3JSVR6.js.map

package/dist/{chunk-CFGTUFWB.js → chunk-MCJKEGHO.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/engine/strip-tokenizer-sentinels.ts
 init_esm_shims();
@@ -64,4 +64,4 @@ export {
   stripTokenizerSentinels,
   createSentinelStripper
 };
-//# sourceMappingURL=chunk-CFGTUFWB.js.map
+//# sourceMappingURL=chunk-MCJKEGHO.js.map