token-goat 2.9.29 → 2.9.31

package/dist/token-goat-chunk-SAMFDIS2.mjs

@@ -0,0 +1,712 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  claudeConfigDir
+} from "./token-goat-chunk-BPGCUMR7.mjs";
+import {
+  DEFAULT_MAX_AGE_MS,
+  DEFAULT_MAX_COUNT
+} from "./token-goat-chunk-4ZBFWLXF.mjs";
+import {
+  recordStat
+} from "./token-goat-chunk-U4WHMG6Y.mjs";
+import {
+  redactSecrets
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  shortFingerprint
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-YZAAZU2S.mjs";
+import {
+  atomicWriteText,
+  ensureDirSync,
+  isCodeFenceDelimiter,
+  stripLower
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  dataDir
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/skill_cache.ts
+init_define_import_meta_env();
+import * as fs from "fs/promises";
+import { resolve } from "path";
+import { readdirSync, readFileSync, existsSync, statSync, unlinkSync } from "node:fs";
+var COMPACT_END_MARKER = "<!-- COMPACT_END -->";
+var SKILLS_OUTPUT_SUBDIR = "skills";
+var _skillOutputsDirOverride = null;
+var _skillsSourceDirOverride = null;
+var _pluginsManifestPathOverride = null;
+registerReset(() => {
+  _skillOutputsDirOverride = null;
+  _skillsSourceDirOverride = null;
+  _pluginsManifestPathOverride = null;
+  inProcessHitLockQueues.clear();
+});
+function skillOutputsDir() {
+  if (_skillOutputsDirOverride) return _skillOutputsDirOverride;
+  return resolve(dataDir(), SKILLS_OUTPUT_SUBDIR);
+}
+function skillsSourceDir() {
+  if (_skillsSourceDirOverride) return _skillsSourceDirOverride;
+  return resolve(claudeConfigDir(), "skills");
+}
+async function ensureSkillsDir() {
+  try {
+    ensureDirSync(skillOutputsDir());
+  } catch {
+  }
+}
+function contentHash(content) {
+  return shortFingerprint(content);
+}
+function safeSessionFragment(sessionId) {
+  let result = "";
+  for (const c of sessionId) {
+    if (result.length >= 16) break;
+    if (/[a-zA-Z0-9_-]/.test(c)) {
+      result += c;
+    }
+  }
+  return result.slice(0, 16);
+}
+function safeSkillName(skillName) {
+  if (!skillName || skillName.length > 128) return null;
+  if (!/^[A-Za-z0-9_:-]+$/.test(skillName)) return null;
+  return skillName.replace(/[^a-zA-Z0-9_:-]/g, "_");
+}
+function sanitizeSkillId(name) {
+  return name.replace(/:/g, "~");
+}
+function sessionSkillPrefix(sessionId, skillName) {
+  const safeSession = safeSessionFragment(sessionId);
+  return `${safeSession}-${sanitizeSkillId(skillName)}-`;
+}
+function outputIdFor(sessionId, skillName, contentSha) {
+  return `${sessionSkillPrefix(sessionId, skillName)}${contentSha}`;
+}
+var LOAD_RECORD_EXT = ".load";
+function readLoadRecordsSync(dir) {
+  const records = [];
+  let files;
+  try {
+    files = readdirSync(dir);
+  } catch {
+    return records;
+  }
+  for (const file of files) {
+    if (!file.endsWith(LOAD_RECORD_EXT)) continue;
+    try {
+      const parsed = JSON.parse(readFileSync(resolve(dir, file), "utf-8"));
+      if (typeof parsed.skillName !== "string" || typeof parsed.bodyOutputId !== "string") continue;
+      records.push({ ...parsed, loadId: file.slice(0, -LOAD_RECORD_EXT.length) });
+    } catch {
+      continue;
+    }
+  }
+  return records;
+}
+async function sessionLoads(safeSession, name) {
+  const metas = await listOutputs();
+  const own = metas.filter((m) => m.skillName === name && m.outputId.startsWith(`${safeSession}-`));
+  const storedIds = new Set(metas.map((m) => m.outputId));
+  const recorded = readLoadRecordsSync(skillOutputsDir()).filter(
+    (r) => r.skillName === name && r.loadId.startsWith(`${safeSession}-`) && storedIds.has(r.bodyOutputId)
+  );
+  return [...own, ...recorded].map((e) => ({ bodyBytes: e.bodyBytes, ts: e.ts }));
+}
+function* contentLineEntries(lines) {
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const stripped = lines[i].trim();
+    if (isCodeFenceDelimiter(stripped)) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (!inCodeBlock) yield [i, stripped];
+  }
+}
+function headingLevel(stripped) {
+  const match = stripped.match(/^(#{1,6}) (.*)$/);
+  if (!match) return 0;
+  return match[2].trim() ? match[1].length : 0;
+}
+function collectSectionBody(lines, startIdx, matchedLevel) {
+  const bodyLines = [];
+  let inBodyCodeBlock = false;
+  for (let j = startIdx; j < lines.length; j++) {
+    const stripped = lines[j].trim();
+    if (isCodeFenceDelimiter(stripped)) {
+      inBodyCodeBlock = !inBodyCodeBlock;
+    }
+    if (!inBodyCodeBlock) {
+      const level = headingLevel(stripped);
+      if (level >= 1 && level <= matchedLevel) break;
+    }
+    bodyLines.push(lines[j]);
+  }
+  return bodyLines;
+}
+function extractCompactFromMarker(body) {
+  if (!body || !body.includes(COMPACT_END_MARKER)) {
+    return null;
+  }
+  const lines = body.split("\n");
+  for (const [i, stripped] of contentLineEntries(lines)) {
+    if (stripped === COMPACT_END_MARKER) {
+      const preMarker = lines.slice(0, i).join("\n").trim();
+      return preMarker || null;
+    }
+  }
+  return null;
+}
+function parseSectionOrdinal(heading) {
+  const match = heading.match(/^(.*?)(?:#(\d+))?$/);
+  if (!match) return [heading, 1];
+  const baseHeading = match[1] || heading;
+  const ordinal = match[2] ? Math.max(1, parseInt(match[2], 10)) : 1;
+  return [baseHeading, ordinal];
+}
+function extractNamedSection(body, heading) {
+  if (!body || !heading) return null;
+  const [baseHeading, ordinal] = parseSectionOrdinal(heading);
+  const headingLower = stripLower(baseHeading);
+  const lines = body.split("\n");
+  let matchCount = 0;
+  let startIdx = -1;
+  let matchedLevel = 0;
+  for (const [i, stripped] of contentLineEntries(lines)) {
+    const level = headingLevel(stripped);
+    if (level >= 1 && level <= 3) {
+      const headingText = stripLower(stripped.slice(level));
+      if (headingText === headingLower) {
+        matchCount++;
+        if (matchCount === ordinal) {
+          startIdx = i + 1;
+          matchedLevel = level;
+          break;
+        }
+      }
+    }
+  }
+  if (startIdx === -1) return null;
+  const text = collectSectionBody(lines, startIdx, matchedLevel).join("\n").trim();
+  return text || null;
+}
+function extractChecklistSection(body) {
+  if (!body) return null;
+  const checklistHeadings = ["checklist", "check list", "to-do", "todo"];
+  const lines = body.split("\n");
+  let bestPriority = checklistHeadings.length;
+  let bestStart = -1;
+  for (const [i, stripped] of contentLineEntries(lines)) {
+    if (stripped.startsWith("## ") && stripped.length > 3) {
+      const headingText = stripLower(stripped.slice(3));
+      for (let p = 0; p < checklistHeadings.length; p++) {
+        if (headingText.startsWith(checklistHeadings[p])) {
+          if (p < bestPriority) {
+            bestPriority = p;
+            bestStart = i;
+          }
+          break;
+        }
+      }
+    }
+  }
+  if (bestStart === -1) return null;
+  const bodyLines = collectSectionBody(lines, bestStart + 1, 2);
+  let text = bodyLines.join("\n").trim();
+  const maxChars = 2e3;
+  if (text.length > maxChars) {
+    const cut = maxChars - 1;
+    text = text.slice(0, cut).trimEnd() + "\u2026";
+  }
+  return text || null;
+}
+async function listOutputs() {
+  try {
+    const dir = skillOutputsDir();
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const metas = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".meta")) {
+        continue;
+      }
+      try {
+        const content = await fs.readFile(resolve(dir, entry.name), "utf-8");
+        const meta = JSON.parse(content);
+        metas.push(meta);
+      } catch {
+        continue;
+      }
+    }
+    return metas;
+  } catch {
+    return [];
+  }
+}
+async function hasSessionOutput(sessionId, skillName) {
+  try {
+    if (!sessionId) return false;
+    const name = safeSkillName(skillName);
+    if (!name) return false;
+    return (await sessionLoads(safeSessionFragment(sessionId), name)).length > 0;
+  } catch {
+    return false;
+  }
+}
+async function sessionOutputBodyBytes(sessionId, skillName) {
+  try {
+    if (!sessionId) return null;
+    const name = safeSkillName(skillName);
+    if (!name) return null;
+    const matches = await sessionLoads(safeSessionFragment(sessionId), name);
+    if (matches.length === 0) return null;
+    matches.sort((a, b) => b.ts - a.ts);
+    return matches[0].bodyBytes;
+  } catch {
+    return null;
+  }
+}
+async function findCrossSessionEntry(skillName, contentSha) {
+  const name = safeSkillName(skillName);
+  if (!name || !contentSha) return null;
+  try {
+    const metas = await listOutputs();
+    for (const meta of metas) {
+      if (meta.skillName !== name || meta.contentSha !== contentSha) {
+        continue;
+      }
+      const dir = skillOutputsDir();
+      const bodyPath = resolve(dir, `${meta.outputId}.txt`);
+      try {
+        const bodyExists = await fs.access(bodyPath).then(() => true).catch(() => false);
+        if (bodyExists) {
+          return meta;
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+var lastStoreTs = 0;
+function nextStoreTs() {
+  lastStoreTs = Math.max(Date.now(), lastStoreTs + 1);
+  return lastStoreTs;
+}
+async function storeOutput(sessionId, skillName, body, opts) {
+  try {
+    await ensureSkillsDir();
+    const name = safeSkillName(skillName);
+    if (!name) return null;
+    const sha = contentHash(body);
+    const outId = outputIdFor(sessionId, skillName, sha);
+    const dir = skillOutputsDir();
+    const ts = nextStoreTs();
+    const existing = await findCrossSessionEntry(skillName, sha);
+    if (existing) {
+      if (existing.outputId !== outId && sessionId) {
+        const record = {
+          skillName: name,
+          contentSha: sha,
+          bodyOutputId: existing.outputId,
+          bodyBytes: Buffer.byteLength(body, "utf-8"),
+          ts
+        };
+        await atomicWriteText(resolve(dir, `${outId}${LOAD_RECORD_EXT}`), JSON.stringify(record, null, 2));
+      }
+      return existing;
+    }
+    const bodyBytes = Buffer.byteLength(body, "utf-8");
+    const truncated = bodyBytes > 256 * 1024;
+    const redactedBody = redactSecrets(body);
+    if (redactedBody.count > 0) recordStat("secret_redacted", 0, redactedBody.count, void 0, SKILLS_OUTPUT_SUBDIR);
+    let storedBody = redactedBody.text;
+    if (truncated) {
+      const buf = Buffer.from(redactedBody.text, "utf-8");
+      let truncStart = Math.max(0, buf.length - 262144);
+      if (truncStart < buf.length) {
+        const byte = buf[truncStart];
+        if ((byte & 192) === 128) {
+          let charStart = truncStart - 1;
+          while (charStart >= 0 && (buf[charStart] & 192) === 128) {
+            charStart--;
+          }
+          if (charStart >= 0) {
+            const leadByte = buf[charStart];
+            let charLen = 1;
+            if ((leadByte & 128) === 0) charLen = 1;
+            else if ((leadByte & 224) === 192) charLen = 2;
+            else if ((leadByte & 240) === 224) charLen = 3;
+            else if ((leadByte & 248) === 240) charLen = 4;
+            truncStart = charStart + charLen;
+          }
+        }
+      }
+      const truncBuf = buf.slice(truncStart);
+      storedBody = truncBuf.toString("utf-8");
+    }
+    await atomicWriteText(resolve(dir, `${outId}.txt`), storedBody);
+    const meta = {
+      outputId: outId,
+      skillName: name,
+      contentSha: sha,
+      bodyBytes,
+      ts,
+      truncated,
+      sourcePath: opts?.sourcePath || ""
+    };
+    await atomicWriteText(resolve(dir, `${outId}.meta`), JSON.stringify(meta, null, 2));
+    pruneSkillOutputs();
+    return meta;
+  } catch {
+    return null;
+  }
+}
+async function storeCompact(sessionId, skillName, compactText, sourceSha) {
+  try {
+    await ensureSkillsDir();
+    const name = safeSkillName(skillName);
+    if (!name) return;
+    const safeSession = safeSessionFragment(sessionId);
+    const fileId = `${safeSession}@${sanitizeSkillId(name)}@compact`;
+    const dir = skillOutputsDir();
+    const redacted = redactSecrets(compactText);
+    if (redacted.count > 0) recordStat("secret_redacted", 0, redacted.count, void 0, SKILLS_OUTPUT_SUBDIR);
+    let text = redacted.text;
+    if (sourceSha) {
+      text = `<!-- source_sha: ${sourceSha.slice(0, 12)} -->
+${text}`;
+    }
+    await atomicWriteText(resolve(dir, fileId), text);
+  } catch {
+  }
+}
+function compactSessionSuffix(skillName) {
+  const name = safeSkillName(skillName);
+  return name ? `@${sanitizeSkillId(name)}@compact` : null;
+}
+function matchesCompactSuffix(entryName, isFile, suffix) {
+  return isFile && entryName.endsWith("@compact") && entryName.endsWith(suffix);
+}
+function getCompactAnySessionSync(skillName) {
+  try {
+    const suffix = compactSessionSuffix(skillName);
+    if (!suffix) return null;
+    const dir = skillOutputsDir();
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!matchesCompactSuffix(entry.name, entry.isFile(), suffix)) continue;
+      try {
+        const text = readFileSync(resolve(dir, entry.name), "utf-8");
+        if (text.trim()) return text;
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function extractSourceShaFromCompact(compactText) {
+  if (!compactText) return null;
+  const match = compactText.match(/<!--\s*source_sha:\s*([a-f0-9]{12})\s*-->/);
+  return match ? match[1] : null;
+}
+function isCompactStale(compactText, skillName, currentBodySha) {
+  if (!compactText) return null;
+  const embeddedSha = extractSourceShaFromCompact(compactText);
+  if (!embeddedSha) return null;
+  const currentSha = currentBodySha.slice(0, 12);
+  return embeddedSha !== currentSha;
+}
+async function readSkillHits(skillName) {
+  try {
+    const name = safeSkillName(skillName);
+    if (!name) return { count: 0, lastTs: 0 };
+    const dir = skillOutputsDir();
+    const hitsFile = resolve(dir, `${sanitizeSkillId(name)}.hits`);
+    const content = await fs.readFile(hitsFile, "utf-8").catch(() => null);
+    if (content) {
+      const parsed = JSON.parse(content);
+      return parsed;
+    }
+  } catch {
+  }
+  return { count: 0, lastTs: 0 };
+}
+var SKILL_HIT_LOCK_RETRY_MS = 5;
+var SKILL_HIT_LOCK_STALE_MS = 5e3;
+var SKILL_HIT_LOCK_MAX_ATTEMPTS = Math.ceil(SKILL_HIT_LOCK_STALE_MS / SKILL_HIT_LOCK_RETRY_MS);
+var inProcessHitLockQueues = /* @__PURE__ */ new Map();
+function runExclusiveInProcess(key, fn) {
+  const prior = inProcessHitLockQueues.get(key) ?? Promise.resolve();
+  const run = prior.then(fn, fn);
+  inProcessHitLockQueues.set(
+    key,
+    run.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return run;
+}
+async function acquireSkillHitLock(lockPath) {
+  for (let attempt = 0; attempt < SKILL_HIT_LOCK_MAX_ATTEMPTS; attempt++) {
+    try {
+      await fs.mkdir(lockPath);
+      return true;
+    } catch (err) {
+      if (err.code !== "EEXIST") return false;
+      try {
+        const st = await fs.stat(lockPath);
+        if (Date.now() - st.mtimeMs > SKILL_HIT_LOCK_STALE_MS) {
+          await fs.rmdir(lockPath).catch(() => {
+          });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      await new Promise((r) => setTimeout(r, SKILL_HIT_LOCK_RETRY_MS));
+    }
+  }
+  return false;
+}
+async function incrementSkillHit(skillName) {
+  try {
+    const name = safeSkillName(skillName);
+    if (!name) return;
+    await ensureSkillsDir();
+    const dir = skillOutputsDir();
+    const hitsFile = resolve(dir, `${sanitizeSkillId(name)}.hits`);
+    const lockPath = `${hitsFile}.lock`;
+    await runExclusiveInProcess(lockPath, async () => {
+      const locked = await acquireSkillHitLock(lockPath);
+      if (!locked) return;
+      try {
+        const hits = await readSkillHits(name);
+        hits.count++;
+        hits.lastTs = Date.now();
+        await atomicWriteText(hitsFile, JSON.stringify(hits, null, 2));
+      } finally {
+        await fs.rmdir(lockPath).catch(() => {
+        });
+      }
+    });
+  } catch {
+  }
+}
+function formatAge(ageMs) {
+  const s = Math.floor(ageMs / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h`;
+  const d = Math.floor(h / 24);
+  return `${d}d`;
+}
+async function listSkills(sessionId) {
+  try {
+    const metas = (await listOutputs()).sort((a, b) => b.ts - a.ts);
+    const results = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const meta of metas) {
+      if (sessionId && !meta.outputId.startsWith(`${safeSessionFragment(sessionId)}-`)) {
+        continue;
+      }
+      if (seen.has(meta.skillName)) continue;
+      seen.add(meta.skillName);
+      const dir = skillOutputsDir();
+      const sanitizedName = sanitizeSkillId(meta.skillName);
+      const outputSuffix = `-${sanitizedName}-${meta.contentSha}`;
+      const safeSession = meta.outputId.endsWith(outputSuffix) ? meta.outputId.slice(0, meta.outputId.length - outputSuffix.length) : safeSessionFragment(meta.outputId.split("-")[0]);
+      const compactFileId = `${safeSession}@${sanitizedName}@compact`;
+      let compactLen = 0;
+      let compactText = "";
+      try {
+        const stat2 = await fs.stat(resolve(dir, compactFileId));
+        compactLen = stat2.size;
+        compactText = await fs.readFile(resolve(dir, compactFileId), "utf-8").catch(() => "");
+      } catch {
+        compactLen = 0;
+      }
+      const hasMarker = extractCompactFromMarker(
+        await fs.readFile(resolve(dir, `${meta.outputId}.txt`), "utf-8").catch(() => "")
+      ) !== null;
+      const compactStale = isCompactStale(compactText, meta.skillName, meta.contentSha);
+      const { count: hitCount } = await readSkillHits(meta.skillName);
+      const ageMs = Date.now() - meta.ts;
+      results.push({
+        name: meta.skillName,
+        bodyLen: meta.bodyBytes,
+        compactLen,
+        hasMarker,
+        compactStale,
+        hitCount,
+        ageMs
+      });
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+async function getSkillFilePath(skillName) {
+  try {
+    const name = safeSkillName(skillName);
+    if (!name) return null;
+    const metas = await listOutputs();
+    for (const meta of metas) {
+      if (meta.skillName === name && meta.sourcePath) {
+        return meta.sourcePath;
+      }
+    }
+    return await installedSkillPath(name);
+  } catch {
+    return null;
+  }
+}
+async function resolvePluginSkillPath(pluginName, skillSlug) {
+  const manifestPath = _pluginsManifestPathOverride ?? resolve(claudeConfigDir(), "plugins", "installed_plugins.json");
+  let raw;
+  try {
+    raw = await fs.readFile(manifestPath, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const plugins = parsed["plugins"];
+  if (typeof plugins !== "object" || plugins === null) return null;
+  for (const [key, entries] of Object.entries(plugins)) {
+    if (key !== pluginName && !key.startsWith(pluginName + "@")) continue;
+    if (!Array.isArray(entries)) continue;
+    for (const entry of entries) {
+      if (typeof entry !== "object" || entry === null) continue;
+      const installPath = entry["installPath"];
+      if (typeof installPath !== "string" || installPath === "") continue;
+      const diskPath = resolve(installPath, "skills", skillSlug, "SKILL.md");
+      try {
+        await fs.access(diskPath);
+        return diskPath;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+async function installedSkillPath(skillName) {
+  const name = safeSkillName(skillName);
+  if (!name) return null;
+  const colonIdx = name.indexOf(":");
+  if (colonIdx > 0 && colonIdx < name.length - 1) {
+    const pluginPath = await resolvePluginSkillPath(name.slice(0, colonIdx), name.slice(colonIdx + 1));
+    if (pluginPath !== null) return pluginPath;
+  }
+  const diskPath = resolve(skillsSourceDir(), name, "SKILL.md");
+  try {
+    await fs.access(diskPath);
+    return diskPath;
+  } catch {
+    return null;
+  }
+}
+function pruneSkillOutputs(maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_AGE_MS) {
+  const dir = skillOutputsDir();
+  let removed = 0;
+  try {
+    if (!existsSync(dir)) return 0;
+    const cutoff = Date.now() - maxAgeMs;
+    const entries = [];
+    for (const file of readdirSync(dir)) {
+      if (!file.endsWith(".meta")) continue;
+      const outputId = file.slice(0, -".meta".length);
+      let ts;
+      try {
+        const parsed = JSON.parse(readFileSync(resolve(dir, file), "utf-8"));
+        ts = parsed.ts;
+      } catch {
+        try {
+          ts = statSync(resolve(dir, file)).mtimeMs;
+        } catch {
+          continue;
+        }
+      }
+      entries.push({ outputId, ts });
+    }
+    const removeEntry = (outputId) => {
+      for (const ext of [".meta", ".txt"]) {
+        try {
+          unlinkSync(resolve(dir, `${outputId}${ext}`));
+        } catch {
+        }
+      }
+      removed++;
+    };
+    const kept = [];
+    for (const entry of entries) {
+      if (entry.ts < cutoff) {
+        removeEntry(entry.outputId);
+      } else {
+        kept.push(entry);
+      }
+    }
+    if (kept.length > maxCount) {
+      kept.sort((a, b) => a.ts - b.ts);
+      for (const entry of kept.slice(0, kept.length - maxCount)) {
+        removeEntry(entry.outputId);
+      }
+    }
+    for (const record of readLoadRecordsSync(dir)) {
+      if (record.ts >= cutoff && existsSync(resolve(dir, `${record.bodyOutputId}.meta`))) continue;
+      try {
+        unlinkSync(resolve(dir, `${record.loadId}${LOAD_RECORD_EXT}`));
+      } catch {
+      }
+    }
+  } catch {
+    return removed;
+  }
+  return removed;
+}
+
+export {
+  SKILLS_OUTPUT_SUBDIR,
+  skillOutputsDir,
+  contentHash,
+  safeSkillName,
+  extractCompactFromMarker,
+  extractNamedSection,
+  extractChecklistSection,
+  listOutputs,
+  hasSessionOutput,
+  sessionOutputBodyBytes,
+  storeOutput,
+  storeCompact,
+  getCompactAnySessionSync,
+  isCompactStale,
+  incrementSkillHit,
+  formatAge,
+  listSkills,
+  getSkillFilePath,
+  installedSkillPath,
+  pruneSkillOutputs
+};