@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/dist/clients/sgconfig.js

@@ -0,0 +1,306 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { load as loadYaml } from "./deps/js-yaml.js";
+import { resolvePackagePath } from "./package-root.js";
+import { findLocalToolConfig } from "./path-utils.js";
+import { getUserRuleRoot, ruleCorpusFingerprintForCycle, _resetRuleCorpusCycleFingerprintsForTests } from "./custom-rule-locations.js";
+const SGCONFIG_NAMES = ["sgconfig.yml", "sgconfig.yaml"];
+export function findLocalSgconfig(startDir) {
+  return findLocalToolConfig(startDir, SGCONFIG_NAMES);
+}
+function canonicalDir(dir) {
+  try {
+    return fs.realpathSync.native(dir);
+  } catch {
+    return path.resolve(dir);
+  }
+}
+export function getAstGrepRuleSources(projectRoot = process.cwd()) {
+  const root = path.resolve(projectRoot || process.cwd());
+  const packageRoot = resolvePackagePath(import.meta.url);
+  const candidates = [];
+  if (canonicalDir(root) !== canonicalDir(packageRoot)) {
+    candidates.push({
+      dir: path.join(root, "rules", "ast-grep-rules", "rules"),
+      origin: "project",
+      tier: "primary"
+    }, {
+      dir: path.join(root, "rules", "ast-grep-rules", "coderabbit", "rules"),
+      origin: "project",
+      tier: "secondary"
+    });
+  }
+  const userRoot = getUserRuleRoot();
+  if (canonicalDir(userRoot) !== canonicalDir(root)) {
+    candidates.push({
+      dir: path.join(userRoot, "ast-grep-rules", "rules"),
+      origin: "user",
+      tier: "primary"
+    }, {
+      dir: path.join(userRoot, "ast-grep-rules", "coderabbit", "rules"),
+      origin: "user",
+      tier: "secondary"
+    });
+  }
+  candidates.push({
+    dir: path.join(packageRoot, "rules", "ast-grep-rules", "rules"),
+    origin: "bundled",
+    tier: "primary"
+  }, {
+    dir: path.join(packageRoot, "rules", "ast-grep-rules", "coderabbit", "rules"),
+    origin: "bundled",
+    tier: "secondary"
+  });
+  const seen = new Set;
+  return candidates.filter((source) => {
+    if (!fs.existsSync(source.dir))
+      return false;
+    const key = canonicalDir(source.dir);
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
+function findYamlFiles(dir) {
+  const files = [];
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return files;
+  }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findYamlFiles(full));
+    } else if (entry.isFile() && /\.ya?ml$/i.test(entry.name)) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+function parseRuleId(raw) {
+  const scalar = raw.match(/^id:\s*(.*?)\s*$/m)?.[1];
+  if (!scalar)
+    return;
+  const withoutComment = scalar.replace(/\s+#.*$/, "").trim();
+  const unquoted = withoutComment.startsWith('"') && withoutComment.endsWith('"') || withoutComment.startsWith("'") && withoutComment.endsWith("'") ? withoutComment.slice(1, -1) : withoutComment;
+  if (/^[A-Za-z0-9_.:-]+$/.test(unquoted))
+    return unquoted;
+  try {
+    const parsed = loadYaml(raw);
+    if (!parsed || typeof parsed !== "object" || !("id" in parsed)) {
+      return;
+    }
+    const id = parsed.id;
+    return typeof id === "string" ? id : undefined;
+  } catch {
+    return;
+  }
+}
+function parseRuleDocuments(content) {
+  return content.split(/^---\s*$/m).filter((document) => document.trim()).map((raw) => ({ raw, id: parseRuleId(raw) }));
+}
+const bundledSnapshots = new Map;
+function snapshotRuleSource(source) {
+  const cacheKey = canonicalDir(source.dir);
+  if (source.origin === "bundled") {
+    const cached = bundledSnapshots.get(cacheKey);
+    if (cached)
+      return cached;
+  }
+  const hash = createHash("sha256");
+  const files = [];
+  for (const file of findYamlFiles(source.dir)) {
+    const relativePath = path.relative(source.dir, file);
+    hash.update(relativePath);
+    hash.update("\x00");
+    let content;
+    try {
+      content = fs.readFileSync(file, "utf8");
+    } catch {
+      hash.update("missing");
+      hash.update("\x00");
+      continue;
+    }
+    hash.update(content);
+    hash.update("\x00");
+    const documents = parseRuleDocuments(content);
+    if (source.origin === "user" && documents.some((document) => !document.id)) {
+      recordDegradationOnce({
+        kind: "ast-grep-rule-invalid",
+        subject: file,
+        reason: "user ast-grep rule has no valid rule id"
+      });
+    }
+    files.push({ file, relativePath, documents });
+  }
+  const snapshot = { ...source, files, digest: hash.digest("hex") };
+  if (source.origin === "bundled")
+    bundledSnapshots.set(cacheKey, snapshot);
+  return snapshot;
+}
+function sourceFingerprint(sources) {
+  const hash = createHash("sha256");
+  for (const source of sources) {
+    hash.update(source.origin);
+    hash.update("\x00");
+    hash.update(source.tier);
+    hash.update("\x00");
+    hash.update(canonicalDir(source.dir));
+    hash.update("\x00");
+    hash.update(source.digest);
+    hash.update("\x00");
+  }
+  return hash.digest("hex");
+}
+export function getAstGrepRuleFingerprint(projectRoot = process.cwd(), options = {}) {
+  const root = path.resolve(projectRoot || process.cwd());
+  return ruleCorpusFingerprintForCycle("ast-grep", root, (fingerprintRoot) => sourceFingerprint(getAstGrepRuleSources(fingerprintRoot).map(snapshotRuleSource)), options.force);
+}
+function materializeMergedRuleDir(sources, mergedDir) {
+  fs.rmSync(mergedDir, { recursive: true, force: true });
+  fs.mkdirSync(mergedDir, { recursive: true });
+  const claimedByEarlierSource = new Set;
+  for (const [sourceIndex, source] of sources.entries()) {
+    const claimedThisSource = new Set;
+    for (const [fileIndex, file] of source.files.entries()) {
+      const survivingDocuments = file.documents.filter((document) => {
+        if (!document.id)
+          return true;
+        if (claimedByEarlierSource.has(document.id))
+          return false;
+        claimedThisSource.add(document.id);
+        return true;
+      });
+      if (survivingDocuments.length === 0)
+        continue;
+      const destination = path.join(mergedDir, `source${sourceIndex}-${String(fileIndex).padStart(5, "0")}.yml`);
+      if (survivingDocuments.length === file.documents.length) {
+        fs.copyFileSync(file.file, destination);
+      } else {
+        fs.writeFileSync(destination, `${survivingDocuments.map((document) => document.raw.trim()).join(`
+---
+`)}
+`);
+      }
+    }
+    for (const id of claimedThisSource)
+      claimedByEarlierSource.add(id);
+  }
+}
+const cachedBaselines = new Map;
+function rootArtifactKey(root) {
+  return createHash("sha256").update(root).digest("hex").slice(0, 12);
+}
+export function resolveBaselineSgconfig(projectRoot = process.cwd()) {
+  const root = canonicalDir(path.resolve(projectRoot || process.cwd()));
+  const fingerprint = getAstGrepRuleFingerprint(root, { force: true });
+  const cached = cachedBaselines.get(root);
+  if (cached?.fingerprint === fingerprint && fs.existsSync(cached.path) && fs.existsSync(cached.mergedDir)) {
+    return cached.path;
+  }
+  const sources = getAstGrepRuleSources(root).map(snapshotRuleSource);
+  if (sources.length === 0)
+    return;
+  const dir = path.join(os.tmpdir(), "dm-lens-ast-grep");
+  fs.mkdirSync(dir, { recursive: true });
+  const artifactKey = rootArtifactKey(root);
+  const file = path.join(dir, `baseline-${process.pid}-${artifactKey}.sgconfig.yml`);
+  const mergedDir = path.join(dir, `baseline-${process.pid}-${artifactKey}.rules`);
+  const protectedArtifacts = new Set([file, mergedDir]);
+  for (const baseline of cachedBaselines.values()) {
+    protectedArtifacts.add(baseline.path);
+    protectedArtifacts.add(baseline.mergedDir);
+  }
+  cleanupStaleBaselines(dir, protectedArtifacts);
+  materializeMergedRuleDir(sources, mergedDir);
+  const ruleDirForYaml = mergedDir.split(path.sep).join("/");
+  fs.writeFileSync(file, `ruleDirs:
+  - ${JSON.stringify(ruleDirForYaml)}
+`);
+  cachedBaselines.set(root, { fingerprint, path: file, mergedDir });
+  enforceBaselineEntryCap(dir, new Set([file, mergedDir]));
+  return file;
+}
+const SG_BASELINE_RETAINED_ENTRIES = 24;
+function enforceBaselineEntryCap(dir, keep) {
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return;
+  }
+  const candidates = [];
+  for (const name of names) {
+    const isConfig = /^baseline(?:-\d+(?:-[a-f0-9]+)?)?\.sgconfig\.yml$/.test(name);
+    const isMergedDir = /^baseline-\d+(?:-[a-f0-9]+)?\.rules$/.test(name);
+    if (!isConfig && !isMergedDir)
+      continue;
+    const full = path.join(dir, name);
+    if (keep.has(full))
+      continue;
+    try {
+      candidates.push({
+        full,
+        mtimeMs: fs.statSync(full).mtimeMs,
+        recursive: isMergedDir
+      });
+    } catch {}
+  }
+  const over = candidates.length + keep.size - SG_BASELINE_RETAINED_ENTRIES;
+  if (over <= 0)
+    return;
+  candidates.sort((a, b) => a.mtimeMs - b.mtimeMs);
+  let evicted = 0;
+  for (const candidate of candidates.slice(0, over)) {
+    try {
+      fs.rmSync(candidate.full, {
+        recursive: candidate.recursive,
+        force: true
+      });
+      evicted += 1;
+      for (const [root, baseline] of cachedBaselines) {
+        if (baseline.path === candidate.full || baseline.mergedDir === candidate.full) {
+          cachedBaselines.delete(root);
+        }
+      }
+    } catch {}
+  }
+  if (evicted > 0) {
+    recordDegradationOnce({
+      kind: "sgconfig-baseline-cap-evict",
+      subject: dir,
+      reason: `evicted ${evicted} oldest baseline entries over the ${SG_BASELINE_RETAINED_ENTRIES}-entry cap`
+    });
+  }
+}
+function cleanupStaleBaselines(dir, keep) {
+  try {
+    const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    for (const name of fs.readdirSync(dir)) {
+      const isConfig = /^baseline(?:-\d+(?:-[a-f0-9]+)?)?\.sgconfig\.yml$/.test(name);
+      const isMergedDir = /^baseline-\d+(?:-[a-f0-9]+)?\.rules$/.test(name);
+      if (!isConfig && !isMergedDir)
+        continue;
+      const full = path.join(dir, name);
+      if (keep.has(full))
+        continue;
+      try {
+        const stat = fs.statSync(full);
+        if (stat.mtimeMs < cutoff) {
+          fs.rmSync(full, { recursive: stat.isDirectory(), force: true });
+        }
+      } catch {}
+    }
+  } catch {}
+}
+export function _resetBaselineSgconfigForTests() {
+  cachedBaselines.clear();
+  bundledSnapshots.clear();
+  _resetRuleCorpusCycleFingerprintsForTests();
+}

package/extensions/dm-lens/dist/clients/shared-checkout-guard.js

@@ -0,0 +1,177 @@
+import { emitBounded } from "./bounded-telemetry.js";
+import { collectGitInvocations, detectGuardedGitVerb, matchGitVerbAtCommandPosition, resolveGitTargetDirectory } from "./git-guard.js";
+import { getInstanceRoots, readInstanceRegistry, selectLivePeerInstances } from "./instance-registry.js";
+import { realIsPidAlive } from "./instance-reaper.js";
+import { logLatency } from "./latency-logger.js";
+import { resolveGitToplevel } from "./opaque-mutation-scan.js";
+import { normalizeFilePath } from "./path-utils.js";
+import { safeSpawnAsync } from "./safe-spawn.js";
+import { truncatedByOutputCap } from "./spawn-output-cap.js";
+const ALWAYS_MUTATING_VERBS = new Set([
+  "checkout",
+  "switch",
+  "restore",
+  "merge",
+  "rebase",
+  "pull",
+  "cherry-pick",
+  "revert"
+]);
+const RESET_WORKTREE_MODES = new Set([
+  "--hard",
+  "--merge",
+  "--keep"
+]);
+const READ_ONLY_STASH_SUBCOMMANDS = new Set([
+  "list",
+  "show"
+]);
+function isCleanDryRun(argsAfterVerb) {
+  return argsAfterVerb.some((arg) => arg === "--dry-run" || arg.startsWith("-") && !arg.startsWith("--") && arg.includes("n"));
+}
+const WORKTREE_MUTATING_GIT_MATCHER = {
+  id: "worktree-mutating",
+  indirectAlwaysMatches: false,
+  suppressPostVerbHelp: true,
+  matchesVerb(verb, argsAfterVerb) {
+    if (ALWAYS_MUTATING_VERBS.has(verb))
+      return true;
+    if (verb === "reset") {
+      return argsAfterVerb.some((arg) => RESET_WORKTREE_MODES.has(arg));
+    }
+    if (verb === "stash") {
+      const subcommand = argsAfterVerb.find((arg) => !arg.startsWith("-"));
+      return subcommand === undefined || !READ_ONLY_STASH_SUBCOMMANDS.has(subcommand);
+    }
+    if (verb === "clean")
+      return !isCleanDryRun(argsAfterVerb);
+    return false;
+  }
+};
+function matchesWorktreeMutatingVerb(gitTokens) {
+  return matchGitVerbAtCommandPosition(gitTokens, WORKTREE_MUTATING_GIT_MATCHER);
+}
+export function isWorktreeMutatingGitAttempt(toolName, input) {
+  return detectGuardedGitVerb(toolName, input, WORKTREE_MUTATING_GIT_MATCHER);
+}
+const MAX_GIT_STATUS_OUTPUT_BYTES = 16 * 1024 * 1024;
+export async function probeWorkingTreeState(root) {
+  const result = await safeSpawnAsync("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: root, timeout: 5000, maxOutputBytes: MAX_GIT_STATUS_OUTPUT_BYTES });
+  if (truncatedByOutputCap(result))
+    return "dirty";
+  if (result.error || result.status !== 0 && result.status !== null) {
+    return "unknown";
+  }
+  return (result.stdout ?? "").trim().length > 0 ? "dirty" : "clean";
+}
+function logAllow(root, reasonCategory) {
+  logLatency({
+    type: "phase",
+    toolName: "shared-checkout-guard",
+    phase: "shared_checkout_guard_allow",
+    filePath: root,
+    durationMs: 0,
+    metadata: { decision: "allowed", reasonCategory }
+  });
+}
+function describePeers(peers) {
+  const pids = peers.slice(0, 4).map((peer) => peer.pid);
+  const suffix = peers.length > pids.length ? ", …" : "";
+  return `${peers.length} other live dm-lens session${peers.length === 1 ? "" : "s"} (pid ${pids.join(", ")}${suffix})`;
+}
+export async function evaluateSharedCheckoutGuard(toolName, input, cwd, deps = {}) {
+  if (!isWorktreeMutatingGitAttempt(toolName, input))
+    return { block: false };
+  const targets = resolveGuardTargets(toolName, input, cwd);
+  let entries;
+  try {
+    entries = await (deps.readRegistry ?? readInstanceRegistry)();
+  } catch {
+    logAllow(normalizeFilePath(cwd), "registry_unreadable");
+    return { block: false };
+  }
+  for (const target of targets) {
+    const decision = await evaluateOneTarget(target, entries, deps);
+    if (decision.block)
+      return decision;
+  }
+  return { block: false };
+}
+function resolveGuardTargets(toolName, input, cwd) {
+  const targets = new Set;
+  for (const gitTokens of collectGitInvocations(toolName, input)) {
+    if (!matchesWorktreeMutatingVerb(gitTokens))
+      continue;
+    targets.add(resolveGitTargetDirectory(gitTokens, cwd));
+  }
+  if (targets.size === 0)
+    targets.add(cwd);
+  return [...targets];
+}
+async function evaluateOneTarget(cwd, entries, deps) {
+  const root = normalizeFilePath(cwd);
+  const resolveToplevel = deps.resolveToplevel ?? resolveGitToplevel;
+  const toplevel = await resolveToplevel(cwd);
+  if (toplevel === undefined) {
+    logAllow(root, "not_a_git_worktree");
+    return { block: false };
+  }
+  const normalizedToplevel = normalizeFilePath(toplevel);
+  const candidates = selectLivePeerInstances(entries, normalizedToplevel, deps.now ?? Date.now(), deps.isPidAlive ?? realIsPidAlive, "containment");
+  const toplevelMemo = new Map;
+  const resolveToplevelOnce = async (dir) => {
+    if (toplevelMemo.has(dir))
+      return toplevelMemo.get(dir);
+    const resolved = await resolveToplevel(dir);
+    toplevelMemo.set(dir, resolved);
+    return resolved;
+  };
+  const peers = [];
+  for (const candidate of candidates) {
+    for (const candidateRoot of getInstanceRoots(candidate)) {
+      const peerToplevel = await resolveToplevelOnce(candidateRoot);
+      if (peerToplevel !== undefined && normalizeFilePath(peerToplevel) === normalizedToplevel) {
+        peers.push(candidate);
+        break;
+      }
+    }
+  }
+  if (peers.length === 0) {
+    logAllow(root, "no_peer_session");
+    return { block: false };
+  }
+  const state = await (deps.probeWorkingTree ?? probeWorkingTreeState)(cwd);
+  if (state === "clean") {
+    logAllow(root, "working_tree_clean");
+    return { block: false };
+  }
+  if (state === "unknown") {
+    emitBounded("shared_checkout_probe_failed", root, {
+      toolName: "shared-checkout-guard",
+      durationMs: 0,
+      metadata: { decision: "blocked", peerCount: peers.length }
+    }, {
+      ledgerKind: "shared-checkout-probe",
+      risingEdgePer: "identity",
+      reason: "git status could not report working-tree state"
+    });
+    return {
+      block: true,
+      unknown: true,
+      reason: "\uD83D\uDD34 WORKING-TREE CHANGE BLOCKED (--lens-checkout-guard): git could not report whether this checkout has uncommitted work, and it is shared with " + `${describePeers(peers)}. Re-run the command once git answers, or take a dedicated git worktree.`
+    };
+  }
+  emitBounded("shared_checkout_switch_blocked", root, {
+    toolName: "shared-checkout-guard",
+    durationMs: 0,
+    metadata: { decision: "blocked", peerCount: peers.length }
+  }, {
+    ledgerKind: "shared-checkout-wip",
+    risingEdgePer: "identity",
+    reason: "worktree-mutating git command declined on a shared checkout"
+  });
+  return {
+    block: true,
+    reason: "\uD83D\uDD34 WORKING-TREE CHANGE BLOCKED (--lens-checkout-guard): this checkout has uncommitted changes and is shared with " + `${describePeers(peers)}. The command would discard work that may not be yours. ` + "Commit the changes first, or run this in a dedicated git worktree."
+  };
+}

package/extensions/dm-lens/dist/clients/single-flight.js

@@ -0,0 +1,52 @@
+export function createSingleFlight(options = {}) {
+  const { generation: readGeneration, coalesceTrailing = false } = options;
+  const flights = new Map;
+  const currentGeneration = () => readGeneration?.() ?? 0;
+  const release = (key, flight) => {
+    if (flights.get(key) !== flight)
+      return;
+    flights.delete(key);
+  };
+  const run = (key, fn) => {
+    const existing = flights.get(key);
+    if (existing && existing.generation === currentGeneration()) {
+      if (coalesceTrailing)
+        existing.rerunRequested = true;
+      return existing.promise;
+    }
+    let settle;
+    let fail;
+    const promise = new Promise((resolve, reject) => {
+      settle = resolve;
+      fail = reject;
+    });
+    const flight = {
+      promise,
+      generation: currentGeneration(),
+      rerunRequested: false
+    };
+    const chain = async () => {
+      let result = await fn();
+      while (flight.rerunRequested) {
+        flight.rerunRequested = false;
+        result = await fn();
+      }
+      return result;
+    };
+    flights.set(key, flight);
+    chain().then((value) => {
+      release(key, flight);
+      settle(value);
+    }, (error) => {
+      release(key, flight);
+      fail(error);
+    });
+    return flight.promise;
+  };
+  return {
+    run,
+    has: (key) => flights.has(key),
+    size: () => flights.size,
+    clear: () => flights.clear()
+  };
+}

package/extensions/dm-lens/dist/clients/situational-tool-telemetry.js

@@ -0,0 +1,85 @@
+import { logExtension } from "./extension-log.js";
+import { TOOL_REGISTRY } from "./tool-config.js";
+const situationalTools = TOOL_REGISTRY.filter((tool) => ("situational" in tool) && tool.situational === true).map((tool) => tool.name);
+const situationalToolSet = new Set(situationalTools);
+const activated = new Set;
+const called = new Set;
+let sessionStarted = false;
+let emitted = false;
+let connectionEnded = false;
+let sessionHost = "mcp";
+function observe(set, name) {
+  if (situationalToolSet.has(name)) {
+    set.add(name);
+  }
+}
+function clearObservations() {
+  activated.clear();
+  called.clear();
+}
+export function observeSituationalToolActivation(names) {
+  for (const name of names)
+    observe(activated, name);
+}
+export function observeSituationalToolCall(name) {
+  observe(called, name);
+}
+export function resetSituationalToolTelemetry() {
+  if (sessionStarted)
+    return;
+  clearObservations();
+  emitted = false;
+}
+export function startSituationalToolTelemetrySession(host) {
+  if (host === "mcp") {
+    if (connectionEnded)
+      return;
+    if (sessionStarted)
+      return;
+    sessionHost = "mcp";
+    clearObservations();
+    emitted = false;
+    sessionStarted = true;
+    return;
+  }
+  if (sessionStarted) {
+    sessionHost = "pi";
+    return;
+  }
+  sessionHost = "pi";
+  clearObservations();
+  emitted = false;
+  sessionStarted = true;
+}
+export function endSituationalToolTelemetry() {
+  if (!sessionStarted)
+    return;
+  emitSituationalDeadWeight();
+  if (sessionHost === "mcp")
+    connectionEnded = true;
+  clearObservations();
+  emitted = false;
+  sessionStarted = false;
+}
+export function emitSituationalDeadWeight() {
+  if (emitted)
+    return;
+  emitted = true;
+  const used = new Set([...activated, ...called]);
+  logExtension({
+    subsystem: "tools",
+    level: "debug",
+    message: "situational tool dead weight",
+    metadata: {
+      tools: situationalTools.filter((name) => !used.has(name))
+    }
+  });
+}
+export function _getSituationalToolTelemetryStateForTests() {
+  return {
+    activated: activated.size,
+    called: called.size,
+    emitted,
+    sessionStarted
+  };
+}

package/extensions/dm-lens/dist/clients/skills-resolver.js

@@ -0,0 +1,38 @@
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as fs from "node:fs";
+import { scanEntriesForSkills } from "../scripts/lib/skills-predicate.mjs";
+import { classifyBundledResourceDir, describeBundledResourceHealth, reportBundledResourceDirHealth } from "./bundled-resource-health.js";
+import { logLatency } from "./latency-logger.js";
+import { getPackageRoot } from "./package-root.js";
+const SKILLS_DIR_MISSING_KIND = "skills-dir-missing";
+function checkSkillsHealth(skillsDir) {
+  return classifyBundledResourceDir(skillsDir, (dir) => {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    return scanEntriesForSkills(dir, entries, true).length;
+  });
+}
+export function resolveSkillPaths(importMetaUrl) {
+  const packageRoot = getPackageRoot(importMetaUrl);
+  const skillsDir = path.join(packageRoot, "skills");
+  const health = checkSkillsHealth(skillsDir);
+  logLatency({
+    type: "phase",
+    phase: "skills_resolved",
+    filePath: skillsDir,
+    durationMs: 0,
+    metadata: {
+      status: health.status,
+      entryCount: health.status === "healthy" ? health.entryCount : 0
+    }
+  });
+  if (health.status !== "healthy") {
+    const entryDir = path.dirname(fileURLToPath(importMetaUrl));
+    const healthDescription = describeBundledResourceHealth(health, skillsDir, `no SKILL.md (or loadable .md) found under ${skillsDir}`);
+    const notifyReason = `${healthDescription} (entry loaded from ${entryDir})`;
+    const classification = health.status === "unreadable" ? `cannot read (${health.fsErrorCode})` : health.status === "empty" ? "no SKILL.md found" : "no such directory";
+    const ledgerReason = `${classification} (entry loaded from ${entryDir})`;
+    reportBundledResourceDirHealth(SKILLS_DIR_MISSING_KIND, skillsDir, health, "skills", ledgerReason, `dm-lens: registers zero skills — ${notifyReason}.`);
+  }
+  return [skillsDir];
+}