@iowarp/clio-coder 0.4.6 → 0.4.7

package/dist/{chunk-6OII3LOK.js → chunk-TLTGZTXI.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   runVectorTool
-} from "./chunk-WJIMKGD6.js";
+} from "./chunk-BAU36233.js";
 import {
   PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
   compareNumeric,
@@ -13,7 +13,7 @@ import {
   renderNumericReport,
   renderPerfBaseline,
   resolveProjectVerifierExecutionCwd
-} from "./chunk-PZN2LQY6.js";
+} from "./chunk-BO4XV5VX.js";
 import {
   declaredVerificationScripts
 } from "./chunk-M4KFUXS7.js";
@@ -401,4 +401,4 @@ export {
   recordPerfBaseline,
   runScriptCheck
 };
-//# sourceMappingURL=chunk-6OII3LOK.js.map
+//# sourceMappingURL=chunk-TLTGZTXI.js.map

package/dist/chunk-TZ6UVP2H.js

@@ -0,0 +1,637 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  expandConfigPath
+} from "./chunk-VNBICSS2.js";
+import {
+  expandPromptTemplateInput,
+  loadPromptTemplates
+} from "./chunk-WB7POC6M.js";
+import {
+  expandSkillInvocationInput,
+  loadSkills,
+  parsePendingSkillRequests
+} from "./chunk-MZNWZUJM.js";
+import {
+  frontmatterRegion,
+  normalizedSkillHash,
+  stripProvenanceLines
+} from "./chunk-DNCE23JJ.js";
+import {
+  resolvePackageRoot
+} from "./chunk-E3LEPLQ2.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  fsyncDirectory
+} from "./chunk-ZZFWWYLX.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/resources/index.ts
+init_esm_shims();
+
+// src/domains/resources/extension.ts
+init_esm_shims();
+
+// src/domains/resources/loader.ts
+init_esm_shims();
+function createResourcesLoader(options = {}) {
+  const defaultCwd = options.cwd ?? process.cwd();
+  const skillOptions2 = () => options.skills?.() ?? {};
+  const promptOptions = (cwd) => ({
+    cwd,
+    ...options.reservedPromptNames !== void 0 ? { reservedNames: options.reservedPromptNames } : {},
+    ...skillOptions2().trustProjectCompatRoots !== void 0 ? { trustProjectCompatRoots: skillOptions2().trustProjectCompatRoots === true } : {}
+  });
+  return {
+    skills(cwd = defaultCwd) {
+      return loadSkills({ cwd, ...skillOptions2() });
+    },
+    expandSkillInvocation(text, cwd = defaultCwd, expansionOptions = {}) {
+      return expandSkillInvocationInput(text, loadSkills({ cwd, ...skillOptions2() }), expansionOptions);
+    },
+    parsePendingSkillRequests(text, cwd = defaultCwd, expansionOptions = {}) {
+      return parsePendingSkillRequests(text, loadSkills({ cwd, ...skillOptions2() }), { cwd, ...expansionOptions });
+    },
+    prompts(cwd = defaultCwd) {
+      return loadPromptTemplates(promptOptions(cwd));
+    },
+    expandPromptTemplate(text, cwd = defaultCwd) {
+      return expandPromptTemplateInput(text, loadPromptTemplates(promptOptions(cwd)));
+    },
+    resolvePath(value, cwd = defaultCwd) {
+      return expandConfigPath(value, { cwd });
+    },
+    async reload() {
+      return void 0;
+    }
+  };
+}
+
+// src/domains/resources/extension.ts
+function createResourcesBundle(context, options = {}) {
+  const config = () => context.getContract("config");
+  const loader = createResourcesLoader({
+    ...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+    ...options.reservedPromptNames !== void 0 ? { reservedPromptNames: options.reservedPromptNames } : {},
+    skills: () => ({
+      ...skillOptions(config()?.get().integrations.projectResources.trustProjectImports === true, options)
+    })
+  });
+  const extension = {
+    start() {
+      return void 0;
+    }
+  };
+  const contract = {
+    skills(cwd) {
+      return loader.skills(cwd);
+    },
+    expandSkillInvocation(text, cwd, options2) {
+      return loader.expandSkillInvocation(text, cwd, options2);
+    },
+    parsePendingSkillRequests(text, cwd, options2) {
+      return loader.parsePendingSkillRequests(text, cwd, options2);
+    },
+    prompts(cwd) {
+      return loader.prompts(cwd);
+    },
+    expandPromptTemplate(text, cwd) {
+      return loader.expandPromptTemplate(text, cwd);
+    },
+    resolvePath(value, cwd) {
+      return loader.resolvePath(value, cwd);
+    },
+    reload() {
+      return loader.reload();
+    }
+  };
+  return { extension, contract };
+}
+function skillOptions(trustProjectCompatRoots, options) {
+  const runtime = options.skills?.() ?? {};
+  return {
+    trustProjectCompatRoots: runtime.trustProjectCompatRoots ?? trustProjectCompatRoots,
+    ...runtime.disableDiscovery !== void 0 ? { disableDiscovery: runtime.disableDiscovery } : {},
+    ...runtime.explicitSkillPaths !== void 0 ? { explicitSkillPaths: runtime.explicitSkillPaths } : {}
+  };
+}
+
+// src/domains/resources/manifest.ts
+init_esm_shims();
+var ResourcesManifest = {
+  name: "resources",
+  dependsOn: ["config"]
+};
+
+// src/domains/resources/prompts/substitute.ts
+init_esm_shims();
+
+// src/domains/resources/skills/evals.ts
+init_esm_shims();
+var SCENARIO_HEADING = /^##\s+([A-Z])(\d+)\s*[-:–—]\s*(.+?)\s*$/;
+function parseSkillEvals(markdown) {
+  const lines = markdown.split("\n");
+  const scenarios = [];
+  const diagnostics = [];
+  let index = 0;
+  while (index < lines.length) {
+    const heading = SCENARIO_HEADING.exec(lines[index] ?? "");
+    if (heading === null) {
+      index += 1;
+      continue;
+    }
+    const blockStart = index + 1;
+    let blockEnd = blockStart;
+    while (blockEnd < lines.length && !/^##\s+/.test(lines[blockEnd] ?? "")) blockEnd += 1;
+    const block = lines.slice(blockStart, blockEnd);
+    const number = Number.parseInt(heading[2] ?? "", 10);
+    const id = `${heading[1] ?? "S"}${number}`;
+    const title = heading[3] ?? "";
+    const setup = extractSetup(block);
+    const fixtureCommands = extractFixtureCommands(block);
+    const expected = extractExpected(block);
+    if (setup === null) diagnostics.push(`${id} (${title}): no "Setup:" or "Prompt:" paragraph found; scenario skipped`);
+    else if (expected.length === 0) diagnostics.push(`${id} (${title}): no "Expected:" bullets found; scenario skipped`);
+    else scenarios.push({ id, number, title, setup, ...fixtureCommands ? { fixtureCommands } : {}, expected });
+    index = blockEnd;
+  }
+  return { scenarios, diagnostics };
+}
+function extractSetup(block) {
+  return extractLabeledParagraph(block, /^Setup:\s*(.*)$/i) ?? extractLabeledParagraph(block, /^(Prompt:.*)$/i);
+}
+function isScenarioLabel(line) {
+  const trimmed = line.trim();
+  return /^(Expected|Fixture|Setup commands):/i.test(trimmed) || /^Expected$/i.test(trimmed);
+}
+function extractLabeledParagraph(block, label) {
+  for (let i = 0; i < block.length; i += 1) {
+    const line = block[i] ?? "";
+    const match = label.exec(line.trim());
+    if (match === null) continue;
+    const parts = [];
+    if ((match[1] ?? "").length > 0) parts.push(match[1] ?? "");
+    for (let j = i + 1; j < block.length; j += 1) {
+      const next = (block[j] ?? "").trim();
+      if (next.length === 0) break;
+      if (isScenarioLabel(next)) break;
+      parts.push(next);
+    }
+    const setup = parts.join(" ").trim();
+    return setup.length > 0 ? setup : null;
+  }
+  return null;
+}
+function extractFixtureCommands(block) {
+  for (let i = 0; i < block.length; i += 1) {
+    const line = (block[i] ?? "").trim();
+    const match = /^(?:Fixture|Setup commands):\s*(.*)$/i.exec(line);
+    if (match === null) continue;
+    const inline = (match[1] ?? "").trim();
+    let cursor = i + 1;
+    while (cursor < block.length && (block[cursor] ?? "").trim().length === 0) cursor += 1;
+    const first = block[cursor] ?? "";
+    const fence = /^```\w*\s*$/.test(first.trim());
+    if (fence) {
+      const commands2 = [];
+      for (let j = cursor + 1; j < block.length; j += 1) {
+        const current = block[j] ?? "";
+        if (/^```\s*$/.test(current.trim())) {
+          const script2 = commands2.join("\n").trim();
+          return script2.length > 0 ? script2 : null;
+        }
+        commands2.push(current);
+      }
+      return null;
+    }
+    const commands = [];
+    if (inline.length > 0) commands.push(inline);
+    for (let j = cursor; j < block.length; j += 1) {
+      const current = block[j] ?? "";
+      const trimmed = current.trim();
+      if (trimmed.length === 0) break;
+      if (isScenarioLabel(trimmed)) break;
+      commands.push(current);
+    }
+    const script = commands.join("\n").trim();
+    return script.length > 0 ? script : null;
+  }
+  return null;
+}
+function extractExpected(block) {
+  let start = -1;
+  for (let i = 0; i < block.length; i += 1) {
+    if (/^Expected:?\s*$/i.test((block[i] ?? "").trim())) {
+      start = i + 1;
+      break;
+    }
+  }
+  if (start < 0) return [];
+  const bullets = [];
+  let current = null;
+  for (let i = start; i < block.length; i += 1) {
+    const raw = block[i] ?? "";
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+      if (current !== null) {
+        bullets.push(current.join(" "));
+        current = null;
+      }
+      continue;
+    }
+    const bullet = /^[-*]\s+(.*)$/.exec(raw);
+    if (bullet !== null) {
+      if (current !== null) bullets.push(current.join(" "));
+      current = [bullet[1] ?? ""];
+      continue;
+    }
+    if (current !== null && /^\s+\S/.test(raw)) {
+      current.push(trimmed);
+      continue;
+    }
+    break;
+  }
+  if (current !== null) bullets.push(current.join(" "));
+  return bullets.map((bullet) => bullet.trim()).filter((bullet) => bullet.length > 0);
+}
+
+// src/domains/resources/skills/install.ts
+init_esm_shims();
+import { execFileSync } from "node:child_process";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import path from "node:path";
+var CLONE_TIMEOUT_MS = 6e4;
+function repoRelativePath(filePath) {
+  if (path.isAbsolute(filePath) || filePath.includes("\0")) return null;
+  const segments = filePath.split("/");
+  if (segments.some((segment) => segment === "..")) return null;
+  const normalized = path.posix.normalize(filePath);
+  if (normalized.startsWith("..") || path.posix.isAbsolute(normalized)) return null;
+  return normalized;
+}
+function parseSkillSourceSpec(source) {
+  const trimmed = source.trim();
+  if (trimmed.length === 0) return null;
+  const browser = trimmed.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/(?:blob|tree)\/([^/]+)\/(.+?)\/?$/);
+  if (browser?.[1] && browser[2] && browser[3] && browser[4]) {
+    const filePath = repoRelativePath(browser[4]);
+    if (!filePath) return null;
+    return {
+      kind: "github",
+      cloneUrl: `https://github.com/${browser[1]}/${browser[2]}.git`,
+      branch: browser[3],
+      filePath,
+      original: trimmed
+    };
+  }
+  const raw = trimmed.match(/^https:\/\/raw\.githubusercontent\.com\/([^/]+)\/([^/]+)\/([^/]+)\/(.+?)\/?$/);
+  if (raw?.[1] && raw[2] && raw[3] && raw[4]) {
+    const filePath = repoRelativePath(raw[4]);
+    if (!filePath) return null;
+    return {
+      kind: "github",
+      cloneUrl: `https://github.com/${raw[1]}/${raw[2]}.git`,
+      branch: raw[3],
+      filePath,
+      original: trimmed
+    };
+  }
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) return null;
+  const expanded = trimmed.startsWith("~/") ? path.join(homedir(), trimmed.slice(2)) : trimmed;
+  return { kind: "local", path: path.resolve(expanded), original: trimmed };
+}
+function yamlQuote(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function canonicalizeProductMetadataBlock(lines) {
+  const hasCanonical = lines.some((line) => /^clio-coder:/.test(line));
+  const canonical = [];
+  let dropLegacyChildren = false;
+  for (const line of lines) {
+    if (/^clio:/.test(line)) {
+      dropLegacyChildren = hasCanonical;
+      if (!hasCanonical) canonical.push(line.replace(/^clio:/, "clio-coder:"));
+      continue;
+    }
+    if (dropLegacyChildren) {
+      if (line.trim().length === 0 || /^[ \t]/.test(line)) continue;
+      dropLegacyChildren = false;
+    }
+    canonical.push(line);
+  }
+  return canonical;
+}
+function injectProvenanceFrontmatter(rawText, fields) {
+  const region = frontmatterRegion(rawText);
+  if (!region) throw new Error("skill file is missing YAML frontmatter");
+  const kept = stripProvenanceLines(region.lines);
+  const stamps = [
+    `source-url: ${yamlQuote(fields.sourceUrl)}`,
+    `installed-at: ${yamlQuote(fields.installedAt)}`,
+    ...fields.updatedAt ? [`updated-at: ${yamlQuote(fields.updatedAt)}`] : [],
+    `installed-hash: ${yamlQuote(fields.installedHash)}`,
+    // Audit is a human decision; installs always land unreviewed.
+    "audit: unknown",
+    ...fields.installedBy ? [`installed-by: ${yamlQuote(fields.installedBy)}`] : []
+  ];
+  const canonicalKept = canonicalizeProductMetadataBlock(kept);
+  const clioIndex = canonicalKept.findIndex((line) => /^clio-coder:/.test(line));
+  if (clioIndex >= 0 && !/^clio-coder:\s*$/.test(canonicalKept[clioIndex])) {
+    return `${region.head}${[...canonicalKept, ...stamps].join("\n")}${region.tail}`;
+  }
+  const nested = stamps.map((line) => `  ${line}`);
+  if (clioIndex < 0) {
+    return `${region.head}${[...canonicalKept, "clio-coder:", ...nested].join("\n")}${region.tail}`;
+  }
+  let blockEnd = clioIndex + 1;
+  while (blockEnd < canonicalKept.length) {
+    const line = canonicalKept[blockEnd];
+    if (line.trim().length > 0 && !/^[ \t]/.test(line)) break;
+    blockEnd += 1;
+  }
+  return `${region.head}${[...canonicalKept.slice(0, blockEnd), ...nested, ...canonicalKept.slice(blockEnd)].join(
+    "\n"
+  )}${region.tail}`;
+}
+function resolveSkillDir(target) {
+  if (!existsSync(target)) throw new Error(`skill source path does not exist: ${target}`);
+  const stat = statSync(target);
+  if (stat.isFile()) {
+    if (!target.endsWith(".md")) throw new Error(`skill source must be a SKILL.md file or directory: ${target}`);
+    return path.dirname(target);
+  }
+  if (!existsSync(path.join(target, "SKILL.md"))) {
+    throw new Error(`skill source directory has no SKILL.md: ${target}`);
+  }
+  return target;
+}
+function fetchSource(spec) {
+  if (spec.kind === "local") {
+    return { skillDir: resolveSkillDir(spec.path), cleanup: () => {
+    } };
+  }
+  const tmp = mkdtempSync(path.join(tmpdir(), "clio-coder-skill-"));
+  const cleanup = () => rmSync(tmp, { recursive: true, force: true });
+  try {
+    execFileSync("git", ["clone", "--depth", "1", "--branch", spec.branch, spec.cloneUrl, tmp], {
+      stdio: "pipe",
+      timeout: CLONE_TIMEOUT_MS
+    });
+    const target = path.join(tmp, spec.filePath);
+    if (!existsSync(target)) {
+      throw new Error(
+        `${spec.cloneUrl} (branch ${spec.branch}) has no ${spec.filePath}; the source-url may name a path that branch does not carry`
+      );
+    }
+    return { skillDir: resolveSkillDir(target), cleanup };
+  } catch (err) {
+    cleanup();
+    throw err instanceof Error ? err : new Error(String(err));
+  }
+}
+function copySkillDir(from, to, exclude = []) {
+  mkdirSync(path.dirname(to), { recursive: true });
+  const excluded = new Set(exclude);
+  cpSync(from, to, {
+    recursive: true,
+    filter: (source) => {
+      const base = path.basename(source);
+      if (base === ".git" || base === "node_modules") return false;
+      return !(excluded.size > 0 && path.dirname(source) === from && excluded.has(base));
+    }
+  });
+}
+function shapeSource(fetched, shaping) {
+  const exclude = shaping.exclude ?? [];
+  if (!shaping.overlay && exclude.length === 0) return fetched;
+  if (shaping.overlay && !existsSync(shaping.overlay)) {
+    fetched.cleanup();
+    throw new Error(`skill overlay directory does not exist: ${shaping.overlay}`);
+  }
+  const tmp = mkdtempSync(path.join(tmpdir(), "clio-coder-skill-shape-"));
+  const shaped = path.join(tmp, "skill");
+  const cleanup = () => {
+    rmSync(tmp, { recursive: true, force: true });
+    fetched.cleanup();
+  };
+  try {
+    copySkillDir(fetched.skillDir, shaped, exclude);
+    if (shaping.overlay) copySkillDir(shaping.overlay, shaped);
+    return { skillDir: resolveSkillDir(shaped), cleanup };
+  } catch (err) {
+    cleanup();
+    throw err instanceof Error ? err : new Error(String(err));
+  }
+}
+var skillSwapSequence = 0;
+function swapSkillDir(stage, dest) {
+  const suffix = `${process.pid}-${++skillSwapSequence}`;
+  const staging = `${dest}.clio-coder-staging-${suffix}`;
+  const backup = `${dest}.clio-coder-backup-${suffix}`;
+  rmSync(staging, { recursive: true, force: true });
+  try {
+    stage(staging);
+  } catch (err) {
+    rmSync(staging, { recursive: true, force: true });
+    throw err;
+  }
+  const hadPrevious = existsSync(dest);
+  if (hadPrevious) renameSync(dest, backup);
+  try {
+    renameSync(staging, dest);
+  } catch (err) {
+    if (hadPrevious) renameSync(backup, dest);
+    rmSync(staging, { recursive: true, force: true });
+    throw err;
+  }
+  if (hadPrevious) rmSync(backup, { recursive: true, force: true });
+  fsyncDirectory(path.dirname(dest));
+}
+function validateSourceSkill(skillDir) {
+  const list = loadSkills({ disableDiscovery: true, explicitSkillPaths: [skillDir] });
+  const errors = list.diagnostics.filter((diag) => diag.type === "error");
+  if (errors.length > 0) {
+    throw new Error(`skill source failed validation: ${errors.map((diag) => diag.message).join("; ")}`);
+  }
+  const skill = list.items[0];
+  if (!skill || list.items.length !== 1) {
+    throw new Error(`skill source did not resolve to exactly one skill: ${skillDir}`);
+  }
+  return { skill, warnings: list.diagnostics.map((diag) => diag.message) };
+}
+function managedSkills(cwd, configDir) {
+  const list = loadSkills({ cwd, ...configDir ? { configDir } : {} });
+  return list.items.filter(
+    (skill) => skill.source === "clio-coder" && (skill.scope === "user" || skill.scope === "project")
+  );
+}
+function updateOne(skill, force, shaping = {}) {
+  const sourceUrl = skill.provenance?.installUrl;
+  if (!sourceUrl) return { name: skill.name, status: "no-source", detail: "no source-url provenance recorded" };
+  const spec = parseSkillSourceSpec(sourceUrl);
+  if (!spec) return { name: skill.name, status: "error", detail: `unsupported source-url: ${sourceUrl}` };
+  let fetched;
+  try {
+    fetched = shapeSource(fetchSource(spec), shaping);
+  } catch (err) {
+    return { name: skill.name, status: "error", detail: err instanceof Error ? err.message : String(err) };
+  }
+  try {
+    validateSourceSkill(fetched.skillDir);
+    const remoteFile = path.join(fetched.skillDir, "SKILL.md");
+    const remoteRaw = readFileSync(remoteFile, "utf8");
+    const remoteHash = normalizedSkillHash(remoteRaw);
+    const localRaw = readFileSync(skill.filePath, "utf8");
+    const localHash = normalizedSkillHash(localRaw);
+    const recordedHash = skill.provenance?.installedHash ?? null;
+    if (remoteHash === localHash) return { name: skill.name, status: "up-to-date" };
+    const locallyModified = recordedHash === null || localHash !== recordedHash;
+    if (locallyModified && !force) {
+      return { name: skill.name, status: "local-changes", detail: "skipped, use --force to overwrite" };
+    }
+    swapSkillDir((staging) => {
+      copySkillDir(fetched.skillDir, staging);
+      writeFileSync(
+        path.join(staging, "SKILL.md"),
+        injectProvenanceFrontmatter(remoteRaw, {
+          sourceUrl,
+          installedAt: skill.provenance?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          installedHash: remoteHash,
+          // Who installed a skill is set once; an update, worker- or
+          // operator-run, does not change who put it there originally.
+          ...skill.provenance?.installedBy ? { installedBy: skill.provenance.installedBy } : {}
+        }),
+        "utf8"
+      );
+    }, skill.baseDir);
+    return { name: skill.name, status: "updated" };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return { name: skill.name, status: "error", detail: reason };
+  } finally {
+    fetched.cleanup();
+  }
+}
+function updateSkills(input = {}) {
+  const cwd = input.cwd ?? process.cwd();
+  const skills = managedSkills(cwd, input.configDir);
+  const shapingFor = (skill) => skill.provenance?.installUrl && input.resolveShaping?.({ name: skill.name, sourceUrl: skill.provenance.installUrl }) || {};
+  if (input.name) {
+    const skill = skills.find((entry) => entry.name === input.name);
+    if (!skill) return [{ name: input.name, status: "error", detail: "not found in Clio-managed skill roots" }];
+    return [updateOne(skill, input.force === true, shapingFor(skill))];
+  }
+  if (input.all !== true) throw new Error("updateSkills requires a name or all=true");
+  return skills.filter((skill) => skill.provenance?.installUrl).map((skill) => updateOne(skill, input.force === true, shapingFor(skill)));
+}
+
+// src/domains/resources/skills/provenance-pin.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+var SKILL_PIN_MANIFEST_FILENAME = "registry.yaml";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveSkillPinManifestPath(cwd) {
+  const fromEnv = process.env.CLIO_CODER_SKILL_CATALOG_DIR;
+  if (fromEnv && fromEnv.trim().length > 0) {
+    const manifestPath = path2.join(path2.resolve(fromEnv.trim()), SKILL_PIN_MANIFEST_FILENAME);
+    return existsSync2(manifestPath) ? manifestPath : null;
+  }
+  const repoLibraryManifest = path2.join(cwd, "library", "skills", SKILL_PIN_MANIFEST_FILENAME);
+  if (existsSync2(repoLibraryManifest)) return repoLibraryManifest;
+  const repoManifest = path2.join(cwd, "skills", SKILL_PIN_MANIFEST_FILENAME);
+  if (existsSync2(repoManifest)) return repoManifest;
+  try {
+    const bundledManifest = path2.join(resolvePackageRoot(), "library", "skills", SKILL_PIN_MANIFEST_FILENAME);
+    if (existsSync2(bundledManifest)) return bundledManifest;
+  } catch {
+  }
+  return null;
+}
+function loadSkillPinManifest(manifestPath) {
+  let parsed;
+  try {
+    parsed = import_yaml.default.parse(readFileSync2(manifestPath, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!isPlainObject(parsed) || !Array.isArray(parsed.skills)) return null;
+  const entries = /* @__PURE__ */ new Map();
+  for (const raw of parsed.skills) {
+    if (!isPlainObject(raw)) continue;
+    const name = typeof raw.name === "string" ? raw.name.trim() : "";
+    const sha256 = typeof raw.sha256 === "string" ? raw.sha256.trim().toLowerCase() : "";
+    if (name.length === 0 || !/^[0-9a-f]{64}$/.test(sha256)) continue;
+    entries.set(name, {
+      name,
+      version: typeof raw.version === "string" && raw.version.trim().length > 0 ? raw.version.trim() : null,
+      sha256
+    });
+  }
+  return entries;
+}
+function checkSkillDrift(skill, cwd) {
+  const actual = skill.normalizedHash.toLowerCase();
+  const manifestPath = resolveSkillPinManifestPath(cwd);
+  const manifest = manifestPath === null ? null : loadSkillPinManifest(manifestPath);
+  const pinned = manifest?.get(skill.name);
+  if (pinned !== void 0) {
+    return {
+      verdict: pinned.sha256 === actual ? "match" : "mismatch",
+      authority: "pinned-manifest",
+      expected: pinned.sha256
+    };
+  }
+  const recorded = skill.provenance?.installedHash?.trim().toLowerCase();
+  if (recorded !== void 0 && /^[0-9a-f]{64}$/.test(recorded)) {
+    return {
+      verdict: recorded === actual ? "match" : "mismatch",
+      authority: "install-record",
+      expected: recorded
+    };
+  }
+  return null;
+}
+
+// src/domains/resources/index.ts
+var ResourcesDomainModule = {
+  manifest: ResourcesManifest,
+  createExtension: createResourcesBundle
+};
+function createResourcesDomainModule(options = {}) {
+  return {
+    manifest: ResourcesManifest,
+    createExtension: (context) => createResourcesBundle(context, options)
+  };
+}
+
+export {
+  createResourcesLoader,
+  ResourcesManifest,
+  parseSkillEvals,
+  parseSkillSourceSpec,
+  updateSkills,
+  checkSkillDrift,
+  ResourcesDomainModule,
+  createResourcesDomainModule
+};
+//# sourceMappingURL=chunk-TZ6UVP2H.js.map