dsh-claude-compat 0.2.0 → 0.6.2

package/src/index.js

@@ -1,14 +1,28 @@
 // dsh-claude-compat — bridge Claude Code's .claude/ into DSH.
 //
-// Two contributions to the live runtime:
-//   1. Skill provider on ctx.skills — scans <projectRoot>/.claude/skills/**/SKILL.md
-//      and <projectRoot>/.claude/commands/*.md, surfaces them as DSH skills so the
-//      `/skill-name` slash trigger, the `skill` tool, and the model-visible catalog
-//      pick them up natively. Only name+description load at discovery; the body
-//      loads on demand — same contract as the shipped filesystem provider.
-//   2. System prompt section — injects <projectRoot>/.claude/rules/*.md as ordered
-//      guidance. CLAUDE.md / AGENTS.md are already handled by dsh-agent-instructions,
+// Contributions to the live runtime:
+//   1. Skill provider on ctx.skills — scans <projectRoot>/.claude/skills/**/SKILL.md,
+//      <projectRoot>/.claude/commands/*.md and <projectRoot>/.claude/agents/*.md
+//      (plus the user-level ~/.claude equivalents), surfaces them as DSH skills
+//      so the `/skill-name` slash trigger, the `skill` tool, and the
+//      model-visible catalog pick them up natively. Only name+description load
+//      at discovery; the body loads on demand — same contract as the shipped
+//      filesystem provider. Agents are a delegation shim: DSH has no markdown
+//      subagent format, so each agent file becomes a skill whose body leads
+//      with an explicit "delegate with this persona" instruction.
+//   2. Rules message-stream injection — injects <projectRoot>/.claude/rules/*.md
+//      and ~/.claude/rules/*.md as ONE user-role <system-reminder> message
+//      prepended at the front of the message array, once per session
+//      (agent/pre-step). This mirrors Claude Code's prependUserContext channel,
+//      which models follow reliably. Same-name rule files are deduped,
+//      project .claude winning over ~/.claude.
+//      CLAUDE.md / AGENTS.md are already handled by dsh-agent-instructions,
 //      so we do NOT re-inject them here.
+//   3. Hooks (Claude Code subset PreToolUse/PostToolUse/UserPromptSubmit) from
+//      .claude/settings.json — bridged onto tools/pre-execute,
+//      tools/post-execute and agent/pre-step (see src/hooks.js).
+//   4. MCP servers from <projectRoot>/.mcp.json — mounted as dsh-mcp-client
+//      plugin instances at startup from the launch workspace (see src/mcp.js).
 //
 // Skill name flattening: .claude/skills/gitnexus/gitnexus-guide/SKILL.md →
 // "gitnexus-gitnexus-guide" (DSH skill names must be kebab-case; the shipped
@@ -17,30 +31,70 @@
 // Commands: .claude/commands/commit-changes.md → skill "commit-changes",
 // user-invocable forced true so `/commit-changes` works in the slash menu.
 //
-// Rules text is re-read every system-prompt assembly (per model step), so rule
-// edits take effect without a DSH restart. No file watcher — the cost of
-// stat'ing a handful of small markdown files is negligible per step.
+// Precedence (DSH registry semantics: candidates sort by rank ascending and
+// duplicate skill names are first-wins — LOWER rank wins). The native ladder
+// is project-dsh 100, project-agents 200, custom 300, user-dsh 400,
+// user-agents 500, DSH bundled 600 (fixed BUNDLED_SKILL_RANK). This plugin
+// emits project .claude at rank 50 and ~/.claude at rank 700, so conflicts
+// resolve as: project .claude > DSH native (600) > ~/.claude.
+//
+// Rules are read once per session (cached per session cwd, from
+// agent.session.header.cwd — NOT process.cwd(), the DSH process may be
+// launched from anywhere). Editing a rule mid-session takes effect in the
+// next session.
 
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { readFile, readdir, stat } from 'node:fs/promises';
-import { join, dirname, resolve } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
 import z from '@deepseek-ai/schemastery';
-import { parse } from 'yaml';
 import { isSkillName } from '@deepseek-ai/dsh-skill';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { discoverAgents, renderAgentContent } from './agents.js';
+import { registerHooks } from './hooks.js';
+import { mountMcpServers, mountMcpConfigs } from './mcp.js';
+import { discoverPluginContent, readInstalledClaudePlugins, translatePluginMcp } from './plugins.js';
+import {
+  findProjectRoot,
+  findProjectRootSync,
+  listMdFilesSync,
+  parseFrontmatter,
+  readTextSafe,
+  resolveUserClaudeDir,
+  stringField,
+} from './lib.js';
 
 export const name = 'claude-compat';
 export const inject = ['skills'];
 
 export const Config = z.object({
   projectRootMarkers: z.array(z.string()).default(['.git']),
-  // 150: between project-dsh (100) and project-agents (200). DSH-native skills
-  // win over Claude skills; Claude skills win over user-level.
-  skillRank: z.number().default(150),
+  // DSH dedupes by rank ascending (lower wins). 50 beats the DSH-native
+  // project roots (100/200) and the bundled root (600) — project .claude wins
+  // every collision. 700 loses to bundled 600 — DSH native wins over
+  // ~/.claude. Final priority: project .claude > DSH native > ~/.claude.
+  skillRank: z.number().default(50),
   skillSource: z.string().default('project-claude'),
+  userSkillRank: z.number().default(700),
+  userSkillSource: z.string().default('user-claude'),
+  userClaudeDir: z.string().default('~/.claude'),
   rulesMaxBytes: z.number().default(65536),
+  userRulesMaxBytes: z.number().default(65536),
   enableRules: z.boolean().default(true),
   enableSkills: z.boolean().default(true),
+  enableMcp: z.boolean().default(true),
+  mcpFailOnStartupError: z.boolean().default(false),
+  enableHooks: z.boolean().default(true),
+  hooksTimeoutMs: z.number().default(60000),
+  enableAgents: z.boolean().default(true),
+  // Claude Code plugin-marketplace installs (~/.claude/plugins). Skills,
+  // commands and agents surface at pluginSkillRank (750: the long tail —
+  // everything else wins collisions). Plugin MCP servers are opt-in via
+  // enablePluginMcp (mounting third-party MCP is a bigger trust step).
+  enablePlugins: z.boolean().default(true),
+  pluginSkillRank: z.number().default(750),
+  pluginSkillSource: z.string().default('claude-plugin'),
+  pluginsRoot: z.string().default('~/.claude/plugins'),
+  enablePluginMcp: z.boolean().default(false),
 });
 
 export function apply(ctx, config = {}) {
@@ -51,6 +105,36 @@ export function apply(ctx, config = {}) {
   if (config.enableRules !== false) {
     registerRulesSection(ctx, config);
   }
+  if (config.enableHooks !== false) {
+    registerHooks(ctx, config);
+  }
+  if (config.enableMcp !== false) {
+    // Process-lifetime mount — deliberately NOT session-scoped (see src/mcp.js).
+    mountMcpServers(ctx, config).catch((error) => {
+      console.warn('dsh-claude-compat: MCP mount failed:', error?.message ?? error);
+    });
+    if (config.enablePlugins !== false && config.enablePluginMcp === true) {
+      mountPluginMcp(ctx, config).catch((error) => {
+        console.warn('dsh-claude-compat: plugin MCP mount failed:', error?.message ?? error);
+      });
+    }
+  }
+}
+
+// Opt-in: translate every installed plugin's MCP config and mount alongside
+// the project .mcp.json servers (see src/mcp.js mountMcpConfigs).
+async function mountPluginMcp(ctx, config) {
+  for (const plugin of readInstalledClaudePlugins(config.pluginsRoot)) {
+    const raw = await readTextSafe(join(plugin.installPath, '.claude-plugin', 'plugin.json'));
+    if (raw === undefined) continue;
+    let manifest;
+    try { manifest = JSON.parse(raw); } catch { continue; }
+    const { servers, warns } = translatePluginMcp(manifest, plugin.installPath, {
+      failOnStartupError: config.mcpFailOnStartupError ?? false,
+    });
+    warns.forEach((w) => console.warn(`dsh-claude-compat: plugin ${plugin.key}: ${w}`));
+    if (servers.length > 0) await mountMcpConfigs(ctx, servers);
+  }
 }
 
 // ─── skill provider ──────────────────────────────────────────────────────────
@@ -60,35 +144,118 @@ class ClaudeCompatSkillProvider {
     this.ctx = ctx;
     this.name = 'claude-compat';
     this.config = config;
-    this.skillRank = config.skillRank ?? 150;
+    this.skillRank = config.skillRank ?? 50;
     this.source = config.skillSource ?? 'project-claude';
+    this.userSkillRank = config.userSkillRank ?? 700;
+    this.userSkillSource = config.userSkillSource ?? 'user-claude';
+    this.userClaudeDir = resolveUserClaudeDir(config.userClaudeDir);
+    this.control = control;
     control.signal.addEventListener('abort', () => {}, { once: true });
   }
 
   async list(options) {
     const cwd = options?.cwd;
-    if (cwd === undefined || cwd === null) return [];
-    const projectRoot = await findProjectRoot(cwd, this.config.projectRootMarkers);
-    if (projectRoot === undefined) return [];
-    const claudeDir = join(projectRoot, '.claude');
-    if (!(await pathExists(claudeDir))) return [];
-
     const candidates = [];
-    for (const c of await discoverSkills(join(claudeDir, 'skills'), this.name, this.source, this.skillRank)) {
-      candidates.push(c);
+    // Project .claude needs a cwd to locate the project root; user ~/.claude
+    // is cwd-independent (mirrors DSH's own user-dsh/user-agents roots, which
+    // are scanned unconditionally).
+    if (cwd !== undefined && cwd !== null) {
+      const projectRoot = await findProjectRoot(cwd, this.config.projectRootMarkers);
+      if (projectRoot !== undefined) {
+        await this.addRootCandidates(candidates, join(projectRoot, '.claude'), this.source, this.skillRank);
+      }
     }
-    for (const c of await discoverCommands(join(claudeDir, 'commands'), this.name, this.source, this.skillRank)) {
-      candidates.push(c);
+    await this.addRootCandidates(candidates, this.userClaudeDir, this.userSkillSource, this.userSkillRank);
+    if (this.config.enablePluginManager !== false) {
+      candidates.push(this.managerSkillCandidate('cc-plugin',
+        'Manage Claude Code plugins and marketplaces: list, install, uninstall, enable, disable, update, search.',
+        'User wants to install, list, enable/disable, update, or uninstall Claude Code plugins, or manage plugin marketplaces. Usage: /cc-plugin, /cc-plugin <name>[@marketplace], /cc-plugin install|uninstall|enable|disable|update|search ..., /cc-plugin marketplace list|add|remove|update.',
+        (await import('./plugin-manager.js')).PLUGIN_SKILL_BODY));
+      candidates.push(this.reloadSkillDef('reload-cc-plugins',
+        'Hot-reload the skill catalog: pick up newly installed/removed Claude Code plugin skills without a new session.'));
+      candidates.push(this.reloadSkillDef('reload-skills',
+        'Hot-reload the skill catalog (alias of /reload-cc-plugins).'));
+    }
+    if (this.config.enablePlugins !== false) {
+      const pluginCandidates = await discoverPluginContent(
+        this.config.pluginsRoot, this.name, this.config.pluginSkillSource ?? 'claude-plugin',
+        this.config.pluginSkillRank ?? 750, { enableAgents: this.config.enableAgents });
+      candidates.push(...pluginCandidates);
     }
     return candidates;
   }
 
+  // Invalidate fires when the definition is actually loaded (get()), not at
+  // list() time — loading the reload skill IS the reload.
+  reloadSkillDef(name, description) {
+    return {
+      name,
+      description,
+      invocation: { modelInvocable: true, userInvocable: true },
+      provider: 'claude-compat',
+      source: 'claude-compat-manager',
+      rank: this.config.pluginManagerRank ?? 40,
+      locator: { kind: 'inline', path: import.meta.url },
+      get: async () => {
+        try { this.control?.invalidate?.(); } catch { /* best-effort */ }
+        return {
+          name,
+          description,
+          body: `# Catalog reloaded ✅
+
+The DSH skill catalog cache was just dropped and observers notified.
+Freshly installed/removed skills are now visible in this session (the skill
+picker refreshes automatically on the next catalog read).
+
+Notes:
+- New skills from \`/plugin install\` or edits under \`.claude\` are live now.
+- MCP servers shipped by plugins still require a DSH restart (process-lifetime mount).
+- \`/reload-cc-plugins\` and \`/reload-skills\` are aliases.`,
+        };
+      },
+    };
+  }
+
+  managerSkillCandidate(name, description, whenToUse, body) {
+    return {
+      name,
+      description,
+      whenToUse,
+      invocation: { modelInvocable: true, userInvocable: true },
+      provider: 'claude-compat',
+      source: 'claude-compat-manager',
+      rank: this.config.pluginManagerRank ?? 40,
+      locator: { kind: 'inline', path: import.meta.url },
+      get: async () => ({ name, description, body }),
+    };
+  }
+
+  async addRootCandidates(candidates, claudeDir, source, rank) {
+    const provider = this.name;
+    const tasks = [discoverSkills(join(claudeDir, 'skills'), provider, source, rank)];
+    for (const [dir, fn] of [
+      ['commands', discoverCommands],
+      ['agents', discoverAgents],
+    ]) {
+      if (dir === 'agents' && this.config.enableAgents === false) continue;
+      tasks.push(fn(join(claudeDir, dir), provider, source, rank));
+    }
+    const batches = await Promise.all(tasks);
+    for (const batch of batches) candidates.push(...batch);
+  }
+
   async get(candidate) {
     const locator = candidate.locator;
     const raw = await readTextSafe(locator.path);
     if (raw === undefined) return undefined;
     const parsed = parseFrontmatter(raw);
-    const content = parsed === undefined ? raw.trim() : parsed.body.trim();
+    let content;
+    if (candidate.agentTools !== undefined) {
+      // Agent-backed candidate: lead the body with the delegation instruction.
+      content = renderAgentContent(candidate, (parsed?.body ?? raw).trim());
+    } else {
+      content = parsed === undefined ? raw.trim() : parsed.body.trim();
+    }
     return {
       name: candidate.name,
       description: candidate.description,
@@ -103,11 +270,12 @@ class ClaudeCompatSkillProvider {
   }
 }
 
-// ─── discovery: .claude/skills (recursive, ≤3 levels) ────────────────────────
+// ─── discovery: <root>/.claude/skills (recursive, ≤3 levels) ─────────────────
 
-async function discoverSkills(rootDir, providerName, source, rank) {
+export async function discoverSkills(rootDir, providerName, source, rank) {
+  const { readdir } = await import('node:fs/promises');
   const out = [];
-  if (!(await pathExists(rootDir))) return out;
+  if (!(await pathExistsSafe(rootDir))) return out;
   await walk(rootDir, '', 0);
   return out;
 
@@ -132,11 +300,12 @@ async function discoverSkills(rootDir, providerName, source, rank) {
   }
 }
 
-// ─── discovery: .claude/commands (flat) ──────────────────────────────────────
+// ─── discovery: <root>/.claude/commands (flat) ───────────────────────────────
 
-async function discoverCommands(rootDir, providerName, source, rank) {
+export async function discoverCommands(rootDir, providerName, source, rank) {
+  const { readdir } = await import('node:fs/promises');
   const out = [];
-  if (!(await pathExists(rootDir))) return out;
+  if (!(await pathExistsSafe(rootDir))) return out;
   let entries;
   try {
     entries = await readdir(rootDir, { withFileTypes: true, encoding: 'utf8' });
@@ -241,22 +410,29 @@ function registerRulesSection(ctx, config) {
 }
 
 function buildRulesText(cwd, config, maxBytes) {
-  const projectRoot = findProjectRootSync(cwd, config.projectRootMarkers);
-  if (projectRoot === undefined) return '';
-  const rulesDir = join(projectRoot, '.claude', 'rules');
-  const files = listMdFilesSync(rulesDir);
-  if (files.length === 0) return '';
   const parts = [];
-  let total = 0;
-  for (const f of files) {
-    let raw;
-    try { raw = readFileSync(f, 'utf8'); } catch { continue; }
-    const basename = f.split('/').pop();
-    const chunk = `## ${basename}\n\n${raw.trim()}\n`;
-    if (total + chunk.length > maxBytes) break;
-    parts.push(chunk);
-    total += chunk.length;
+  const seen = new Set();
+  const pushRoot = (rootDir, cap) => {
+    let remaining = cap;
+    const files = listMdFilesSync(rootDir);
+    for (const f of files) {
+      const basename = f.split('/').pop();
+      if (seen.has(basename)) continue; // higher-priority root already included
+      let raw;
+      try { raw = readFileSync(f, 'utf8'); } catch { continue; }
+      const chunk = `## ${basename}\n\n${raw.trim()}\n`;
+      if (chunk.length > remaining) break;
+      remaining -= chunk.length;
+      seen.add(basename);
+      parts.push(chunk);
+    }
+  };
+  // Project .claude/rules first: wins same-name collisions against ~/.claude.
+  const projectRoot = findProjectRootSync(cwd, config.projectRootMarkers);
+  if (projectRoot !== undefined) {
+    pushRoot(join(projectRoot, '.claude', 'rules'), maxBytes);
   }
+  pushRoot(join(resolveUserClaudeDir(config.userClaudeDir), 'rules'), config.userRulesMaxBytes ?? maxBytes);
   if (parts.length === 0) return '';
   // Exact envelope Claude Code uses in prependUserContext (api.ts):
   // user-role <system-reminder> with "# claudeMd" framing.
@@ -267,99 +443,12 @@ ${parts.join('\n')}
       </system-reminder>`;
 }
 
-function findProjectRootSync(cwd, markers = ['.git']) {
-  let current = resolve(cwd);
-  while (true) {
-    for (const marker of markers) {
-      if (existsSync(join(current, marker))) return current;
-    }
-    const parent = dirname(current);
-    if (parent === current) return undefined;
-    current = parent;
-  }
-}
-
-function listMdFilesSync(dir) {
-  let entries;
-  try { entries = readdirSync(dir); } catch { return []; }
-  const files = [];
-  for (const name of entries) {
-    if (!name.endsWith('.md')) continue;
-    const p = join(dir, name);
-    try { if (statSync(p).isFile()) files.push(p); } catch {}
-  }
-  files.sort();
-  return files;
-}
-
 // ─── helpers ─────────────────────────────────────────────────────────────────
 
-async function findProjectRoot(cwd, markers = ['.git']) {
-  let current = resolve(cwd);
-  while (true) {
-    for (const marker of markers) {
-      if (await pathExists(join(current, marker))) return current;
-    }
-    const parent = dirname(current);
-    if (parent === current) return undefined;
-    current = parent;
-  }
-}
-
-async function pathExists(path) {
+async function pathExistsSafe(path) {
   try { await stat(path); return true; } catch { return false; }
 }
 
-async function readTextSafe(path) {
-  try { return await readFile(path, { encoding: 'utf8' }); }
-  catch { return undefined; }
-}
-
-async function listMdFiles(dir) {
-  let entries;
-  try { entries = await readdir(dir, { withFileTypes: true, encoding: 'utf8' }); }
-  catch { return []; }
-  const files = [];
-  for (const e of entries) {
-    if (e.isFile() && e.name.endsWith('.md')) files.push(join(dir, e.name));
-  }
-  files.sort();
-  return files;
-}
-
-function parseFrontmatter(raw) {
-  const firstLineEnd = raw.indexOf('\n');
-  if (firstLineEnd < 0) return undefined;
-  if (raw.slice(0, firstLineEnd).replace(/\r$/, '') !== '---') return undefined;
-  const start = firstLineEnd + 1;
-  const closing = findClosingFrontmatter(raw, start);
-  if (closing === undefined) return undefined;
-  let parsed;
-  try { parsed = parse(raw.slice(start, closing.start)); }
-  catch { return undefined; }
-  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) return undefined;
-  return { data: parsed, body: raw.slice(closing.bodyStart) };
-}
-
-function findClosingFrontmatter(raw, start) {
-  let lineStart = start;
-  while (lineStart <= raw.length) {
-    const nextNewline = raw.indexOf('\n', lineStart);
-    const lineEnd = nextNewline < 0 ? raw.length : nextNewline;
-    if (raw.slice(lineStart, lineEnd).replace(/\r$/, '') === '---') {
-      return { start: lineStart, bodyStart: nextNewline < 0 ? raw.length : nextNewline + 1 };
-    }
-    if (nextNewline < 0) return undefined;
-    lineStart = nextNewline + 1;
-  }
-  return undefined;
-}
-
-function stringField(data, key) {
-  const v = data[key];
-  return typeof v === 'string' && v.length > 0 ? v : undefined;
-}
-
 function parseInvocationPolicy(data) {
   const miv = data['disable-model-invocation'];
   const uiv = data['user-invocable'];
@@ -377,4 +466,4 @@ function truthy(v) {
   }
   if (typeof v === 'number') return v !== 0;
   return false;
-}
+}

package/src/lib.js

@@ -0,0 +1,123 @@
+// Shared helpers for dsh-claude-compat (path resolution, sync/async root
+// discovery, reader utilities, frontmatter parsing). Extracted from index.js
+// so mcp.js / hooks.js / agents.js can reuse them without circular imports.
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { parse } from 'yaml';
+
+export function resolveUserClaudeDir(dir) {
+  if (dir === undefined || dir === null || dir === '') return join(homedir(), '.claude');
+  if (dir === '~') return homedir();
+  if (dir.startsWith('~/')) return join(homedir(), dir.slice(2));
+  return resolve(dir);
+}
+
+export async function findProjectRoot(cwd, markers = ['.git']) {
+  let current = resolve(cwd);
+  while (true) {
+    for (const marker of markers) {
+      if (await pathExists(join(current, marker))) return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) return undefined;
+    current = parent;
+  }
+}
+
+export function findProjectRootSync(cwd, markers = ['.git']) {
+  let current = resolve(cwd);
+  while (true) {
+    for (const marker of markers) {
+      if (existsSync(join(current, marker))) return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) return undefined;
+    current = parent;
+  }
+}
+
+export async function pathExists(path) {
+  try { await stat(path); return true; } catch { return false; }
+}
+
+export async function readTextSafe(path) {
+  try { return await readFile(path, { encoding: 'utf8' }); }
+  catch { return undefined; }
+}
+
+export function readTextSafeSync(path) {
+  try { return readFileSync(path, 'utf8'); } catch { return undefined; }
+}
+
+export async function listMdFiles(dir) {
+  let entries;
+  try { entries = await readdir(dir, { withFileTypes: true, encoding: 'utf8' }); }
+  catch { return []; }
+  const files = [];
+  for (const e of entries) {
+    if (e.isFile() && e.name.endsWith('.md')) files.push(join(dir, e.name));
+  }
+  files.sort();
+  return files;
+}
+
+export function listMdFilesSync(dir) {
+  let entries;
+  try { entries = readdirSync(dir); } catch { return []; }
+  const files = [];
+  for (const name of entries) {
+    if (!name.endsWith('.md')) continue;
+    const p = join(dir, name);
+    try { if (statSync(p).isFile()) files.push(p); } catch {}
+  }
+  files.sort();
+  return files;
+}
+
+// Frontmatter: `---` line, YAML block, closing `---` line, body after. Returns
+// { data, body } on success, undefined on anything malformed.
+export function parseFrontmatter(raw) {
+  const firstLineEnd = raw.indexOf('\n');
+  if (firstLineEnd < 0) return undefined;
+  if (raw.slice(0, firstLineEnd).replace(/\r$/, '') !== '---') return undefined;
+  const start = firstLineEnd + 1;
+  const closing = findClosingFrontmatter(raw, start);
+  if (closing === undefined) return undefined;
+  let parsed;
+  try { parsed = parse(raw.slice(start, closing.start)); }
+  catch { return undefined; }
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) return undefined;
+  return { data: parsed, body: raw.slice(closing.bodyStart) };
+}
+
+export function stringField(data, key) {
+  const v = data[key];
+  return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+
+export function truthy(v) {
+  if (typeof v === 'boolean') return v;
+  if (typeof v === 'string') {
+    const s = v.toLowerCase();
+    return s === 'true' || s === 'yes' || s === 'on' || s === '1';
+  }
+  if (typeof v === 'number') return v !== 0;
+  return false;
+}
+
+function findClosingFrontmatter(raw, start) {
+  let lineStart = start;
+  while (lineStart <= raw.length) {
+    const nextNewline = raw.indexOf('\n', lineStart);
+    const lineEnd = nextNewline < 0 ? raw.length : nextNewline;
+    if (raw.slice(lineStart, lineEnd).replace(/\r$/, '') === '---') {
+      return { start: lineStart, bodyStart: nextNewline < 0 ? raw.length : nextNewline + 1 };
+    }
+    if (nextNewline < 0) return undefined;
+    lineStart = nextNewline + 1;
+  }
+  return undefined;
+}