@iowarp/clio-coder 0.4.4 → 0.4.6

package/dist/chunk-USZA7GWL.js

@@ -0,0 +1,341 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  captureWikiSourceContent,
+  captureWikiSourceContentAsync,
+  sanitizeWikiPlan,
+  wikiDir,
+  wikiMarkdownFilesInDir,
+  wikiSourcesMatch
+} from "./chunk-LVFANMOH.js";
+import {
+  safeResourceWrite
+} from "./chunk-ZZFWWYLX.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/context/wiki/meta.ts
+init_esm_shims();
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function compareStrings(a, b) {
+  return a.localeCompare(b);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function nonNegativeSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+var REQUESTED_DEPTHS = ["auto", "simple", "medium", "detailed"];
+var RESOLVED_DEPTHS = ["simple", "medium", "detailed"];
+function parseGeneration(value) {
+  if (!isRecord(value)) return void 0;
+  const { requestedDepth, depth, sourceFiles, sourceLines, pagesPlanned, pagesWritten } = value;
+  if (!REQUESTED_DEPTHS.includes(requestedDepth) || !RESOLVED_DEPTHS.includes(depth) || !nonNegativeSafeInteger(sourceFiles) || !nonNegativeSafeInteger(sourceLines) || !nonNegativeSafeInteger(pagesPlanned) || !nonNegativeSafeInteger(pagesWritten)) {
+    return void 0;
+  }
+  return {
+    requestedDepth,
+    depth,
+    sourceFiles,
+    sourceLines,
+    pagesPlanned,
+    pagesWritten
+  };
+}
+function normalizePages(pages) {
+  return pages.map((page) => ({ path: page.path, title: page.title, ...page.summary ? { summary: page.summary } : {} })).sort((a, b) => a.path.localeCompare(b.path));
+}
+function wikiMetaPath(cwd) {
+  return join(wikiDir(cwd), "meta.json");
+}
+function currentWikiGitHead(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function validateWikiMeta(value) {
+  const problems = [];
+  if (!isRecord(value)) {
+    return { ok: false, problems: ["meta must be a JSON object"] };
+  }
+  if (value.version !== 1) problems.push("version must be 1");
+  const updatedAt = stringValue(value.updatedAt);
+  if (!updatedAt) problems.push("updatedAt must be a non-empty string");
+  const gitHead = value.gitHead;
+  if (gitHead !== null && typeof gitHead !== "string") problems.push("gitHead must be a string or null");
+  const sourceTreeHash = value.sourceTreeHash;
+  if (sourceTreeHash !== void 0 && (typeof sourceTreeHash !== "string" || !/^[a-f0-9]{64}$/.test(sourceTreeHash))) {
+    problems.push("sourceTreeHash must be a sha256 hex string when present");
+  }
+  const model = stringValue(value.model);
+  if (!model) problems.push("model must be a non-empty string");
+  const contentHash = stringValue(value.contentHash);
+  if (!contentHash || !/^[a-f0-9]{64}$/.test(contentHash)) {
+    problems.push("contentHash must be a sha256 hex string");
+  }
+  if (!Array.isArray(value.pages)) {
+    problems.push("pages must be an array");
+  } else {
+    for (const [index, page] of value.pages.entries()) {
+      if (!isRecord(page)) {
+        problems.push(`pages[${index}] must be an object`);
+        continue;
+      }
+      if (!stringValue(page.path)) problems.push(`pages[${index}].path must be a non-empty string`);
+      if (!stringValue(page.title)) problems.push(`pages[${index}].title must be a non-empty string`);
+    }
+  }
+  if (problems.length > 0) return { ok: false, problems };
+  const generation = parseGeneration(value.generation);
+  const plan = sanitizeWikiPlan(value.plan, void 0, { trustStatus: true });
+  return {
+    ok: true,
+    value: {
+      version: 1,
+      updatedAt,
+      gitHead,
+      ...sourceTreeHash !== void 0 ? { sourceTreeHash } : {},
+      model,
+      contentHash,
+      pages: normalizePages(value.pages),
+      ...generation !== void 0 ? { generation } : {},
+      ...plan !== null ? { plan } : {}
+    }
+  };
+}
+function isWikiMeta(value) {
+  return validateWikiMeta(value).ok;
+}
+function readWikiMeta(cwd) {
+  return readWikiMetaInDir(wikiDir(cwd));
+}
+function readWikiMetaInDir(dir) {
+  const filePath = join(dir, "meta.json");
+  if (!existsSync(filePath)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+  const validation = validateWikiMeta(parsed);
+  return validation.ok ? validation.value : null;
+}
+function writeWikiMeta(cwd, meta) {
+  writeWikiMetaInDir(wikiDir(cwd), meta);
+}
+function writeWikiMetaInDir(dir, meta) {
+  const normalized = {
+    version: 1,
+    updatedAt: meta.updatedAt,
+    gitHead: meta.gitHead,
+    ...meta.sourceTreeHash ? { sourceTreeHash: meta.sourceTreeHash } : {},
+    model: meta.model,
+    contentHash: meta.contentHash,
+    pages: normalizePages(meta.pages),
+    ...meta.generation !== void 0 ? { generation: { ...meta.generation } } : {},
+    ...meta.plan !== void 0 ? { plan: meta.plan } : {}
+  };
+  safeResourceWrite(join(dir, "meta.json"), `${JSON.stringify(normalized)}
+`, { encoding: "utf8" });
+}
+function computeWikiContentHashOfDir(dir) {
+  const hash = createHash("sha256");
+  for (const relPath of wikiMarkdownFilesInDir(dir).sort(compareStrings)) {
+    let text = "";
+    try {
+      text = readFileSync(join(dir, relPath), "utf8");
+    } catch {
+      text = "";
+    }
+    hash.update(`${relPath}\0${text.length}\0`);
+    hash.update(text);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+function computeWikiContentHash(cwd) {
+  return computeWikiContentHashOfDir(wikiDir(cwd));
+}
+
+// src/domains/context/wiki/staleness.ts
+init_esm_shims();
+import { execFile, execFileSync as execFileSync2 } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var GIT_DIFF_LINE_CAP = 200;
+function splitNullTerminatedPaths(output) {
+  return output.split("\0").filter((path) => path.length > 0);
+}
+function currentGitHead(cwd) {
+  try {
+    const out = execFileSync2("git", ["rev-parse", "--verify", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out.length > 0 ? out : null;
+  } catch {
+    return null;
+  }
+}
+async function currentGitHeadAsync(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", "HEAD"], { cwd, encoding: "utf8" });
+    const out = stdout.trim();
+    return out.length > 0 ? out : null;
+  } catch {
+    return null;
+  }
+}
+function collectChangedPaths(cwd, gitHead) {
+  const committed = execFileSync2("git", ["diff", "--name-only", "-z", `${gitHead}..HEAD`], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  const trackedWorking = execFileSync2("git", ["diff", "--name-only", "-z", "HEAD"], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  const untracked = execFileSync2("git", ["ls-files", "--others", "--exclude-standard", "-z"], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  return /* @__PURE__ */ new Set([
+    ...splitNullTerminatedPaths(committed),
+    ...splitNullTerminatedPaths(trackedWorking),
+    ...splitNullTerminatedPaths(untracked)
+  ]);
+}
+function changedPathsSince(cwd, gitHead) {
+  if (!gitHead) return null;
+  try {
+    return [...collectChangedPaths(cwd, gitHead)];
+  } catch {
+    return null;
+  }
+}
+async function collectChangedPathsAsync(cwd, gitHead) {
+  const run = async (args) => {
+    const { stdout } = await execFileAsync("git", args, { cwd, encoding: "utf8" });
+    return stdout;
+  };
+  const [committed, trackedWorking, untracked] = await Promise.all([
+    run(["diff", "--name-only", "-z", `${gitHead}..HEAD`]),
+    run(["diff", "--name-only", "-z", "HEAD"]),
+    run(["ls-files", "--others", "--exclude-standard", "-z"])
+  ]);
+  return /* @__PURE__ */ new Set([
+    ...splitNullTerminatedPaths(committed),
+    ...splitNullTerminatedPaths(trackedWorking),
+    ...splitNullTerminatedPaths(untracked)
+  ]);
+}
+function capChangedPaths(paths) {
+  const capped = [...paths].slice(0, GIT_DIFF_LINE_CAP);
+  return {
+    count: capped.length,
+    ...paths.size > capped.length ? { warning: `changed file count capped at ${GIT_DIFF_LINE_CAP}` } : {}
+  };
+}
+var CHANGED_COUNT_FAILURE = "wiki staleness unavailable: git diff failed for the recorded wiki gitHead";
+function changedFileCount(cwd, gitHead) {
+  try {
+    return capChangedPaths(collectChangedPaths(cwd, gitHead));
+  } catch {
+    return { warning: CHANGED_COUNT_FAILURE };
+  }
+}
+async function changedFileCountAsync(cwd, gitHead) {
+  try {
+    return capChangedPaths(await collectChangedPathsAsync(cwd, gitHead));
+  } catch {
+    return { warning: CHANGED_COUNT_FAILURE };
+  }
+}
+function wikiCompletenessFromMeta(meta) {
+  const generation = meta?.generation;
+  if (!generation) return null;
+  return {
+    pagesPlanned: generation.pagesPlanned,
+    pagesWritten: generation.pagesWritten,
+    owed: Math.max(0, generation.pagesPlanned - generation.pagesWritten)
+  };
+}
+function wikiCompleteness(cwd) {
+  return wikiCompletenessFromMeta(readWikiMeta(cwd));
+}
+function pendingRefresh(meta) {
+  const available = new Set(meta.pages.map((page) => page.path));
+  if (!meta.plan?.pages.some((page) => page.status !== "written" && available.has(page.path))) return null;
+  return { state: "stale", changedFiles: 0, warning: "wiki has published pages awaiting successful validation" };
+}
+var MISSING_RECORDED_HEAD = "wiki staleness unavailable: recorded gitHead is missing";
+var MISSING_CURRENT_HEAD = "wiki staleness unavailable: current git HEAD is missing";
+function unavailableStaleness(warning) {
+  return { state: "stale", changedFiles: 0, warning };
+}
+function wikiStaleness(cwd) {
+  const meta = readWikiMeta(cwd);
+  if (!meta) return { state: "absent" };
+  const pending = pendingRefresh(meta);
+  if (pending) return pending;
+  if (!meta.gitHead) return unavailableStaleness(MISSING_RECORDED_HEAD);
+  const head = currentGitHead(cwd);
+  if (!head) return unavailableStaleness(MISSING_CURRENT_HEAD);
+  const diff = changedFileCount(cwd, meta.gitHead);
+  if (!("count" in diff)) return unavailableStaleness(diff.warning);
+  if (wikiSourcesMatch(meta.plan?.sourceContent, captureWikiSourceContent(cwd)) && head === meta.gitHead) {
+    return { state: "fresh" };
+  }
+  return { state: "stale", changedFiles: diff.count, ...diff.warning ? { warning: diff.warning } : {} };
+}
+async function wikiStalenessAsync(cwd) {
+  const meta = readWikiMeta(cwd);
+  if (!meta) return { state: "absent" };
+  const pending = pendingRefresh(meta);
+  if (pending) return pending;
+  if (!meta.gitHead) return unavailableStaleness(MISSING_RECORDED_HEAD);
+  const head = await currentGitHeadAsync(cwd);
+  if (!head) return unavailableStaleness(MISSING_CURRENT_HEAD);
+  const diff = await changedFileCountAsync(cwd, meta.gitHead);
+  if (!("count" in diff)) return unavailableStaleness(diff.warning);
+  if (wikiSourcesMatch(meta.plan?.sourceContent, await captureWikiSourceContentAsync(cwd)) && head === meta.gitHead)
+    return { state: "fresh" };
+  return { state: "stale", changedFiles: diff.count, ...diff.warning ? { warning: diff.warning } : {} };
+}
+
+export {
+  wikiMetaPath,
+  currentWikiGitHead,
+  validateWikiMeta,
+  isWikiMeta,
+  readWikiMeta,
+  readWikiMetaInDir,
+  writeWikiMeta,
+  writeWikiMetaInDir,
+  computeWikiContentHashOfDir,
+  computeWikiContentHash,
+  changedPathsSince,
+  wikiCompletenessFromMeta,
+  wikiCompleteness,
+  wikiStaleness,
+  wikiStalenessAsync
+};
+//# sourceMappingURL=chunk-USZA7GWL.js.map

package/dist/{chunk-ZA4VCIGV.js → chunk-UUQ5G6EZ.js}

@@ -14,21 +14,21 @@ import {
   toolResultPayload,
   toolResultText,
   withoutThinkingBlocks
-} from "./chunk-GTUD2WMY.js";
+} from "./chunk-DBREN25X.js";
 import {
   filterEntriesToActivePath
-} from "./chunk-W6GROXXM.js";
+} from "./chunk-O5F25NIE.js";
 import {
   formatSize
-} from "./chunk-OZNBF4L3.js";
+} from "./chunk-KECNXMDE.js";
 import {
   ceilChars,
   contentChars,
   estimateAgentMessageTokens
-} from "./chunk-NZMNUPZZ.js";
+} from "./chunk-77CZRFTE.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/session/compaction/tokens.ts
 init_esm_shims();
@@ -50,7 +50,15 @@ function estimateCustom(entry) {
   return ceilChars(contentChars(entry.data));
 }
 function estimateSummary(entry) {
-  return ceilChars(entry.summary.length);
+  let tokens = ceilChars(entry.summary.length);
+  if (entry.kind !== "compactionSummary") return tokens;
+  if (entry.userContext) tokens += ceilChars(entry.userContext.text.length + 40) + 4;
+  for (const skill of entry.skillContext?.skills ?? []) {
+    tokens += ceilChars(skill.requestText.length + 40) + 4;
+    tokens += ceilChars(JSON.stringify(skill.activation).length + 32) + 4;
+    for (const block of skill.content) tokens += ceilChars(block.text.length) + 4;
+  }
+  return tokens;
 }
 function estimateTokens(entry) {
   switch (entry.kind) {
@@ -201,7 +209,7 @@ function firstLine(text) {
   return line.trim().slice(0, PREVIEW_LIMIT).replace(/"/g, '\\"');
 }
 function renderMarker(input) {
-  const ref = input.ref.entry;
+  const ref = input.alias ?? input.ref.entry;
   const fields = [`ref=${ref}`, `reason=${input.reason}`];
   if (input.by !== void 0) fields.push(`by=${input.by}`);
   fields.push(`tool=${input.toolName}`);
@@ -268,9 +276,11 @@ function eventIndex(entries, lastEvictionTurnId) {
   const index = entries.findIndex((entry) => entry.turnId === lastEvictionTurnId);
   return index < 0 ? entries.length : index;
 }
-function projectWorkingSet(entries, view) {
-  if (view.evicted.size === 0 && view.evictionEvents === 0) return [...entries];
-  const cutoff = view.evictionEvents > 0 ? eventIndex(entries, view.lastEvictionTurnId) : -1;
+function projectWorkingSet(entries, view, activeLeafTurnId) {
+  const checkpoint = filterEntriesToActivePath(entries, activeLeafTurnId).reverse().find((entry) => entry.kind === "compactionSummary");
+  const compactionIndex = checkpoint ? entries.indexOf(checkpoint) : -1;
+  if (view.evicted.size === 0 && view.evictionEvents === 0 && compactionIndex < 0) return [...entries];
+  const cutoff = Math.max(compactionIndex, view.evictionEvents > 0 ? eventIndex(entries, view.lastEvictionTurnId) : -1);
   const out = [];
   for (let index = 0; index < entries.length; index += 1) {
     const entry = entries[index];
@@ -292,7 +302,7 @@ function projectWorkingSet(entries, view) {
 // src/domains/context/working-set/engine.ts
 var NO_CALL_PATHS = /* @__PURE__ */ new Map();
 var PENDING_EVENT_TURN_ID = "";
-function markerFor(entry, candidate, callPaths) {
+function markerFor(entry, candidate, callPaths, alias) {
   if (entry.kind !== "message") return null;
   if (entry.role === "assistant") return hasThinking(entry.payload) ? "" : null;
   if (entry.role !== "tool_result") return null;
@@ -300,6 +310,7 @@ function markerFor(entry, candidate, callPaths) {
   const toolCallId = typeof payload.obj.toolCallId === "string" ? payload.obj.toolCallId : void 0;
   return renderMarker({
     ref: candidate.ref,
+    ...alias === void 0 ? {} : { alias },
     reason: candidate.reason,
     by: candidate.by,
     toolName: payload.toolName,
@@ -349,8 +360,8 @@ function sumTokens(entries, estimate) {
   for (const entry of entries) total += estimate(entry);
   return total;
 }
-function tokensFreedByEviction(estimateTokens2, entry, candidate, callPaths = NO_CALL_PATHS) {
-  const marker = markerFor(entry, candidate, callPaths);
+function tokensFreedByEviction(estimateTokens2, entry, candidate, callPaths = NO_CALL_PATHS, alias) {
+  const marker = markerFor(entry, candidate, callPaths, alias);
   if (marker === null) return 0;
   const key = refKey(candidate.ref);
   const projected = projectWorkingSet([entry], soloView(key, pendingState(candidate, marker, "")))[0] ?? entry;
@@ -364,17 +375,21 @@ function planEviction(policy, input) {
   const callPaths = callPathsByToolCallId(input.entries);
   const items = [];
   const claimed = /* @__PURE__ */ new Set();
+  let aliasSequence = input.view.recallAliasSequence ?? [...input.view.evicted.values()].reduce((max, state) => Math.max(max, Number(state.alias?.slice(1)) || 0), 0);
   for (const candidate of candidates) {
     const key = refKey(candidate.ref);
     if (input.view.evicted.has(key) || claimed.has(key)) continue;
     const entry = byTurnId.get(key);
     if (entry === void 0) continue;
-    const marker = markerFor(entry, candidate, callPaths);
+    const alias = entry.kind === "message" && entry.role === "tool_result" ? `r${aliasSequence + 1}` : void 0;
+    const marker = markerFor(entry, candidate, callPaths, alias);
     if (marker === null) continue;
-    const tokensFreed = tokensFreedByEviction(input.estimateTokens, entry, candidate, callPaths);
+    const tokensFreed = tokensFreedByEviction(input.estimateTokens, entry, candidate, callPaths, alias);
     if (tokensFreed <= 0) continue;
     claimed.add(key);
+    if (alias !== void 0) aliasSequence += 1;
     items.push({
+      ...alias === void 0 ? {} : { alias },
       ref: candidate.ref,
       reason: candidate.reason,
       tokensFreed,
@@ -563,7 +578,7 @@ function findTurnStartIndex(entries, entryIndex, startIndex = 0) {
 function isValidCutPoint(entry) {
   switch (entry.kind) {
     case "message":
-      return entry.role !== "tool_result";
+      return entry.role !== "tool_result" && entry.role !== "tool_call";
     case "bashExecution":
     case "custom":
     case "skillActivation":
@@ -593,6 +608,29 @@ function findValidCutPoints(entries, startIndex, endIndex) {
   }
   return cuts;
 }
+function findToolBatchStart(entries, resultIndex, startIndex, endIndex) {
+  for (let index = resultIndex - 1; index >= startIndex; index--) {
+    const entry = entries[index];
+    if (entry?.kind !== "message") continue;
+    if (entry.role === "user") break;
+    if (entry.role !== "assistant") continue;
+    const payload = entry.payload;
+    if (!Array.isArray(payload?.content)) break;
+    const callIds = /* @__PURE__ */ new Set();
+    for (const block of payload.content) {
+      if (block?.type === "toolCall" && typeof block.id === "string") callIds.add(block.id);
+    }
+    if (callIds.size === 0) break;
+    for (let tail = index + 1; tail < endIndex; tail++) {
+      const result = entries[tail];
+      if (result?.kind !== "message" || result.role !== "tool_result") continue;
+      const id = result.payload?.toolCallId;
+      if (typeof id !== "string" || !callIds.has(id)) return -1;
+    }
+    return index;
+  }
+  return -1;
+}
 function findCutPoint(entries, keepRecentTokens, opts = {}) {
   const startIndex = opts.startIndex ?? 0;
   const endIndex = opts.endIndex ?? entries.length;
@@ -613,6 +651,9 @@ function findCutPoint(entries, keepRecentTokens, opts = {}) {
           break;
         }
       }
+      if (cutIndex === -1 && entry.kind === "message" && (entry.role === "tool_result" || entry.role === "tool_call")) {
+        cutIndex = findToolBatchStart(entries, i, startIndex, endIndex);
+      }
       break;
     }
   }
@@ -639,40 +680,18 @@ function findCutPoint(entries, keepRecentTokens, opts = {}) {
   };
 }
 
-// src/domains/context/working-set/visible.ts
-init_esm_shims();
-function compactionCut(entries) {
-  let compactionIndex = -1;
-  for (let i = entries.length - 1; i >= 0; i -= 1) {
-    if (entries[i]?.kind === "compactionSummary") {
-      compactionIndex = i;
-      break;
-    }
-  }
-  const compaction = entries[compactionIndex];
-  if (compaction?.kind !== "compactionSummary") return { compactionIndex: -1, visible: [...entries] };
-  const firstKeptIndex = compaction.firstKeptTurnId.length > 0 ? entries.findIndex((entry) => entry.turnId === compaction.firstKeptTurnId) : -1;
-  const kept = firstKeptIndex >= 0 && firstKeptIndex < compactionIndex ? entries.slice(firstKeptIndex, compactionIndex) : [];
-  return { compactionIndex, visible: [...kept, ...entries.slice(compactionIndex + 1)] };
-}
-function selectVisibleEntries(entries, activeLeafTurnId) {
-  return compactionCut(filterEntriesToActivePath(entries, activeLeafTurnId)).visible;
-}
-
 export {
+  projectWorkingSet,
   estimateTokens,
   getLastAssistantUsage,
   calculateContextTokens,
   findCutPoint,
   DEFAULT_RESERVE_TOKENS,
   DEFAULT_KEEP_RECENT_TOKENS,
-  projectWorkingSet,
   tokensFreedByEviction,
   planEviction,
   buildEvictionFields,
   isProtected,
-  resolveWorkingSetPolicy,
-  compactionCut,
-  selectVisibleEntries
+  resolveWorkingSetPolicy
 };
-//# sourceMappingURL=chunk-ZA4VCIGV.js.map
+//# sourceMappingURL=chunk-UUQ5G6EZ.js.map

package/dist/{chunk-VG7TBQIY.js → chunk-V552WL53.js}

@@ -1,15 +1,75 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  toPosixPath
-} from "./chunk-OQE5J4C6.js";
+  canonicalizeExistingPath
+} from "./chunk-KQ6IDQIB.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/tools/ignore-policy.ts
 init_esm_shims();
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
+
+// src/tools/path-utils.ts
+init_esm_shims();
+import { accessSync, constants } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, resolve as resolvePath, sep } from "node:path";
+function toPosixPath(value) {
+  return value.split(sep).join("/");
+}
+var UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+var NARROW_NO_BREAK_SPACE = "\u202F";
+function normalizeUnicodeSpaces(value) {
+  return value.replace(UNICODE_SPACES, " ");
+}
+function fileExists(filePath) {
+  try {
+    accessSync(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeAtPrefix(filePath) {
+  return filePath.startsWith("@") ? filePath.slice(1) : filePath;
+}
+function tryMacOSScreenshotPath(filePath) {
+  return filePath.replace(/ (AM|PM)\./gi, `${NARROW_NO_BREAK_SPACE}$1.`);
+}
+function tryNfdVariant(filePath) {
+  return filePath.normalize("NFD");
+}
+function tryCurlyQuoteVariant(filePath) {
+  return filePath.replace(/'/g, "\u2019");
+}
+function expandPath(filePath) {
+  const normalized = normalizeUnicodeSpaces(normalizeAtPrefix(filePath));
+  if (normalized === "~") return homedir();
+  if (normalized.startsWith("~/")) return homedir() + normalized.slice(1);
+  return normalized;
+}
+function resolveToCwd(filePath, cwd = process.cwd()) {
+  const expanded = expandPath(filePath);
+  const resolved = isAbsolute(expanded) ? resolvePath(expanded) : resolvePath(cwd, expanded);
+  return canonicalizeExistingPath(resolved);
+}
+function resolveReadPath(filePath, cwd = process.cwd()) {
+  const resolved = resolveToCwd(filePath, cwd);
+  if (fileExists(resolved)) return resolved;
+  const amPmVariant = tryMacOSScreenshotPath(resolved);
+  if (amPmVariant !== resolved && fileExists(amPmVariant)) return amPmVariant;
+  const nfdVariant = tryNfdVariant(resolved);
+  if (nfdVariant !== resolved && fileExists(nfdVariant)) return nfdVariant;
+  const curlyVariant = tryCurlyQuoteVariant(resolved);
+  if (curlyVariant !== resolved && fileExists(curlyVariant)) return curlyVariant;
+  const nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
+  if (nfdCurlyVariant !== resolved && fileExists(nfdCurlyVariant)) return nfdCurlyVariant;
+  return resolved;
+}
+
+// src/tools/ignore-policy.ts
 var ALWAYS_EXCLUDED_DIRS = [".clio-coder", ".fallow", ".git"];
 var GENERATED_DIRS = [
   ".cache",
@@ -118,6 +178,10 @@ function compileGlobRegex(pattern) {
 }
 
 export {
+  toPosixPath,
+  expandPath,
+  resolveToCwd,
+  resolveReadPath,
   rgIgnoreArgs,
   fdIgnoreArgs,
   fallbackIgnoredDirs,
@@ -125,4 +189,4 @@ export {
   normalizeGlobInput,
   compileGlobRegex
 };
-//# sourceMappingURL=chunk-VG7TBQIY.js.map
+//# sourceMappingURL=chunk-V552WL53.js.map

package/dist/{chunk-7UGL4MB5.js → chunk-VAHLPXPY.js}

@@ -1,13 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  parseFrontmatter
-} from "./chunk-RKKLTLYB.js";
 import {
   loadSkills
-} from "./chunk-2ZSONWVL.js";
+} from "./chunk-536HXRFE.js";
+import {
+  parseFrontmatter
+} from "./chunk-CXQ37WJH.js";
 import {
   enabledExtensionResourceRoots
-} from "./chunk-TQAHXW6Y.js";
+} from "./chunk-22PQ4TX4.js";
 import {
   assertAgentSpecPolicy,
   isAgentAudience,
@@ -19,16 +19,16 @@ import {
   isShadowAgent,
   normalizeAgentSpec,
   parseResultContract
-} from "./chunk-KFV5L5SK.js";
+} from "./chunk-OQM5IVJY.js";
 import {
   resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
+} from "./chunk-E3LEPLQ2.js";
 import {
   clioConfigDir
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/agents/recipe.ts
 init_esm_shims();
@@ -396,4 +396,4 @@ export {
   parseAgentRecipeSchema,
   discoverAgentRecipes
 };
-//# sourceMappingURL=chunk-7UGL4MB5.js.map
+//# sourceMappingURL=chunk-VAHLPXPY.js.map