@bitcobblers/wod-wiki-engine 0.11.43 → 0.35.2116

package/dist/bin/wod.cjs

@@ -2,15 +2,858 @@
 'use strict';
 
 var wodWikiLang = require('@bitcobblers/wod-wiki-lang');
+var child_process = require('child_process');
+var fs = require('fs');
+var path = require('path');
 var wodWikiCore = require('@bitcobblers/wod-wiki-core');
 var wodWikiWql = require('@bitcobblers/wod-wiki-wql');
+var crypto = require('crypto');
 
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cli/seedbuild/contract.ts
+function canvasRouteSlug2(content) {
+  const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+  if (fm?.[1] && !/^template:\s*canvas\s*$/m.test(fm[1])) return null;
+  const route = fm?.[1]?.match(/^route:\s*(\S+)\s*$/m)?.[1];
+  if (!route) return null;
+  return route.replace(/^\//, "") || null;
+}
+var SEED_SCHEMA2, TEMPLATE_CHUNK_ID2, DASHBOARDS_CHUNK_ID2, BLOCK_INDEX_CHUNK_PREFIX, BLOCK_EFFORTS_CHUNK_PREFIX;
+var init_contract = __esm({
+  "src/cli/seedbuild/contract.ts"() {
+    SEED_SCHEMA2 = 7;
+    TEMPLATE_CHUNK_ID2 = "template";
+    DASHBOARDS_CHUNK_ID2 = "dashboards";
+    BLOCK_INDEX_CHUNK_PREFIX = "block-index.";
+    BLOCK_EFFORTS_CHUNK_PREFIX = "block-efforts.";
+  }
+});
+
+// src/cli/seedbuild/effort-slugs.ts
+function extractEffortSlugs2(statements) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const statement of statements) {
+    if (statement.exerciseId) {
+      slugs.add(statement.exerciseId);
+    } else {
+      const effortMetric = statement.metrics?.getMetric?.("effort");
+      const effort = effortMetric && typeof effortMetric.value === "string" ? effortMetric.value : void 0;
+      if (effort) {
+        const slug = effort.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+        if (slug) slugs.add(slug);
+      }
+    }
+  }
+  return Array.from(slugs);
+}
+var init_effort_slugs = __esm({
+  "src/cli/seedbuild/effort-slugs.ts"() {
+  }
+});
+
+// src/cli/seedbuild/filename.ts
+function fileToDisplayName(filename) {
+  const base = filename.replace(/\.md$/, "");
+  if (base.toUpperCase() === "README") return "Overview";
+  const cleaned = base.replace(/^day-\d+-/, "");
+  const tokens = cleaned.split(/[-_]/);
+  const titled = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const next = tokens[i + 1];
+    const after = tokens[i + 2];
+    const prev = tokens[i - 1];
+    if (/^\d{1,2}$/.test(token) && /^\d{1,2}$/.test(next ?? "") && !/^\d+$/.test(prev ?? "") && !/^\d+$/.test(after ?? "")) {
+      titled.push(`${token}.${next}`);
+      i++;
+      continue;
+    }
+    if (titled.length > 0 && FILE_TITLE_STOP_WORDS[token.toLowerCase()]) {
+      titled.push(token.toLowerCase());
+      continue;
+    }
+    titled.push(token.charAt(0).toUpperCase() + token.slice(1));
+  }
+  return titled.join(" ");
+}
+var FILE_TITLE_STOP_WORDS;
+var init_filename = __esm({
+  "src/cli/seedbuild/filename.ts"() {
+    FILE_TITLE_STOP_WORDS = {
+      and: true,
+      or: true,
+      of: true,
+      for: true,
+      to: true,
+      in: true,
+      on: true,
+      at: true,
+      by: true,
+      with: true,
+      the: true,
+      a: true,
+      an: true
+    };
+  }
+});
+
+// src/cli/seedbuild/frontmatter.ts
+function unquote(value) {
+  return value.replace(
+    /^(['"])(.*)\1$/,
+    (_match, quote, inner) => quote === '"' ? inner.replace(/\\(["\\])/g, "$1") : inner
+  );
+}
+function parseFrontmatter(raw) {
+  const match = raw.match(FRONTMATTER_RE);
+  if (!match) return { meta: {}, body: raw };
+  return { meta: parseMetaLines(match[1].split(/\r?\n/)), body: raw.slice(match[0].length) };
+}
+function parseMetaLines(lines) {
+  const meta = {};
+  for (let i = 0; i < lines.length; i++) {
+    const keyMatch = lines[i].match(/^([A-Za-z][\w.-]*)\s*:(.*)$/);
+    if (!keyMatch) continue;
+    const key = keyMatch[1];
+    const rawVal = keyMatch[2].trim();
+    if (rawVal === "") {
+      const items = [];
+      while (i + 1 < lines.length) {
+        const itemMatch = lines[i + 1].match(/^\s+-\s+(.+)$/);
+        if (!itemMatch) break;
+        items.push(itemMatch[1].trim());
+        i++;
+      }
+      meta[key] = items.length > 0 ? items : "";
+    } else {
+      const wasQuoted = /^(['"])(.*)\1$/.test(rawVal);
+      const value = unquote(rawVal);
+      const num2 = Number(value);
+      meta[key] = !wasQuoted && value !== "" && !isNaN(num2) ? num2 : value;
+    }
+  }
+  return meta;
+}
+function getScalar(meta, key) {
+  const value = meta[key];
+  return typeof value === "string" || typeof value === "number" ? value : void 0;
+}
+function getList(meta, key) {
+  const value = meta[key];
+  return Array.isArray(value) ? value : [];
+}
+var FRONTMATTER_RE;
+var init_frontmatter = __esm({
+  "src/cli/seedbuild/frontmatter.ts"() {
+    FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+  }
+});
+function parseDiscipline(val) {
+  if (!val) return void 0;
+  const normalized = unquoteYaml(val.trim()).toLowerCase();
+  if (wodWikiLang.isEffortDiscipline(normalized)) return normalized;
+  console.warn(`[effort-file] unknown discipline '${val}' \u2014 treating as unset`);
+  return void 0;
+}
+function unquoteYaml(val) {
+  if (val.startsWith('"') && val.endsWith('"')) {
+    return val.slice(1, -1).replace(/\\(["\\])/g, "$1");
+  }
+  if (val.startsWith("'") && val.endsWith("'")) {
+    return val.slice(1, -1).replace(/\\'/g, "'");
+  }
+  return val;
+}
+function coerceNestedScalar(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw !== "" && !Number.isNaN(Number(raw))) return Number(raw);
+  return raw;
+}
+function readNestedSection(lines, key) {
+  const start = lines.findIndex((l) => new RegExp(`^${key}:\\s*$`).test(l));
+  if (start === -1) return void 0;
+  const result = {};
+  let subKey = null;
+  for (let i = start + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\S/.test(line)) break;
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    const m = trimmed.match(/^([\w.-]+):\s*(.*)$/);
+    if (!m) continue;
+    const [, k, rawVal] = m;
+    if (indent === 2) {
+      if (rawVal === "") {
+        subKey = k;
+        result[k] = {};
+      } else {
+        subKey = null;
+        result[k] = coerceNestedScalar(rawVal);
+      }
+    } else if (indent >= 4 && subKey !== null) {
+      result[subKey][k] = coerceNestedScalar(rawVal);
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function parseEffortFile(raw) {
+  const blockMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!blockMatch) return null;
+  const { meta, body } = parseFrontmatter(raw);
+  const innerLines = blockMatch[1].split(/\r?\n/);
+  const id = getScalar(meta, "id");
+  const slug = getScalar(meta, "slug");
+  const label = getScalar(meta, "label");
+  const aliases = getList(meta, "aliases");
+  const baseAttrs = readNestedSection(innerLines, "baseAttributes");
+  const hints = readNestedSection(innerLines, "hints");
+  const derivation = readNestedSection(innerLines, "derivation");
+  const metRaw = baseAttrs?.met;
+  const met = typeof metRaw === "number" ? metRaw : Number(metRaw);
+  if (!id || !slug || !label || metRaw === void 0 || Number.isNaN(met)) return null;
+  const discipline = parseDiscipline(
+    typeof baseAttrs?.discipline === "string" ? baseAttrs.discipline : void 0
+  );
+  const intensityTier = baseAttrs?.intensityTier;
+  const trimmedBody = body.trim();
+  return {
+    id: String(id),
+    slug: String(slug),
+    label: String(label),
+    aliases,
+    baseAttributes: {
+      met,
+      ...discipline ? { discipline } : {},
+      ...intensityTier ? { intensityTier } : {}
+    },
+    registrySource: "bundled",
+    ...trimmedBody ? { body: trimmedBody } : {},
+    ...hints ? { hints } : {},
+    ...derivation ? { derivation } : {}
+  };
+}
+var init_effort_file = __esm({
+  "src/cli/seedbuild/effort-file.ts"() {
+    init_frontmatter();
+  }
+});
+function resolveGitVersion(repoRoot) {
+  try {
+    const run = (args) => child_process.execSync(`git ${args}`, { cwd: repoRoot, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const count = Number(run("rev-list --count HEAD"));
+    return {
+      version: Number.isFinite(count) && count > 0 ? count : 0,
+      versionLabel: run("describe --tags --long --always --dirty"),
+      commit: run("rev-parse HEAD"),
+      dirty: run("status --porcelain") !== ""
+    };
+  } catch {
+    return UNKNOWN_GIT_VERSION;
+  }
+}
+var UNKNOWN_GIT_VERSION;
+var init_git_version = __esm({
+  "src/cli/seedbuild/git-version.ts"() {
+    UNKNOWN_GIT_VERSION = {
+      version: 0,
+      versionLabel: "unknown",
+      commit: "",
+      dirty: false
+    };
+  }
+});
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function rowHtml(c) {
+  const kind = c.kind ?? "notes";
+  return `<tr><td>${escapeHtml(c.id)}</td><td>${kind}</td><td>${c.count}</td><td>${(c.bytes / 1024).toFixed(1)} KB</td><td><code>${c.sha256.slice(0, 8)}</code></td></tr>`;
+}
+function writeBuildReport(outDir, data) {
+  const { manifest, totalMs, passMs, fileCount } = data;
+  const totalBytes = manifest.chunks.reduce((s, c) => s + c.bytes, 0);
+  const dirtyBadge = manifest.dirty ? ' <strong style="color:#b45309">(dirty working tree \u2014 not reproducible from <code>' + escapeHtml(manifest.commit ?? "") + "</code>)</strong>" : "";
+  const html = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<title>Seed build report</title>
+<style>
+  body { font-family: system-ui, sans-serif; max-width: 960px; margin: 2rem auto; padding: 0 1rem; color: #1f2937; }
+  h1 { font-size: 1.4rem; } h2 { font-size: 1.1rem; margin-top: 2rem; }
+  table { border-collapse: collapse; width: 100%; font-size: 0.9rem; }
+  th, td { text-align: left; padding: 0.3rem 0.6rem; border-bottom: 1px solid #e5e7eb; }
+  code { font-size: 0.85em; }
+  dl { display: grid; grid-template-columns: max-content 1fr; gap: 0.2rem 1rem; font-size: 0.95rem; }
+  dt { font-weight: 600; }
+</style>
+</head>
+<body>
+<h1>Seed build report</h1>
+<h2>Version</h2>
+<dl>
+  <dt>version</dt><dd>${manifest.version} <code>${escapeHtml(manifest.versionLabel ?? "")}</code>${dirtyBadge}</dd>
+  <dt>commit</dt><dd><code>${escapeHtml(manifest.commit ?? "unknown")}</code></dd>
+  <dt>built at</dt><dd>${escapeHtml(manifest.builtAt)}</dd>
+  <dt>schema</dt><dd>v${manifest.schema}</dd>
+</dl>
+<h2>Benchmarks</h2>
+<dl>
+  <dt>total</dt><dd>${totalMs} ms</dd>
+  <dt>corpus scan + partition</dt><dd>${passMs.scan} ms (${fileCount} files)</dd>
+  <dt>block-index derivation</dt><dd>${passMs.blockIndex} ms</dd>
+  <dt>block-efforts derivation</dt><dd>${passMs.blockEfforts} ms</dd>
+  <dt>chunk writes</dt><dd>${passMs.write} ms</dd>
+</dl>
+<h2>Chunks (${manifest.chunks.length}, ${(totalBytes / 1024).toFixed(0)} KB total)</h2>
+<table>
+<thead><tr><th>id</th><th>kind</th><th>rows</th><th>size</th><th>sha256</th></tr></thead>
+<tbody>
+${manifest.chunks.map(rowHtml).join("\n")}
+</tbody>
+</table>
+</body>
+</html>
+`;
+  const file = path.join(outDir, "report.html");
+  fs.writeFileSync(file, html, "utf8");
+  return file;
+}
+var init_report = __esm({
+  "src/cli/seedbuild/report.ts"() {
+  }
+});
+
+// src/cli/seedbuild/compiler.ts
+var compiler_exports = {};
+__export(compiler_exports, {
+  buildBlockEffortRows: () => buildBlockEffortRows,
+  buildBlockIndexRows: () => buildBlockIndexRows,
+  buildStaticParentMap: () => buildStaticParentMap,
+  chunkIdFor: () => chunkIdFor,
+  collectCorpusMarkdown: () => collectCorpusMarkdown,
+  discoverUncatalogedEfforts: () => discoverUncatalogedEfforts,
+  feedDateToCreatedAt: () => feedDateToCreatedAt,
+  generateSeed: () => generateSeed,
+  loadExistingEffortMap: () => loadExistingEffortMap,
+  partitionIntoChunks: () => partitionIntoChunks,
+  scaffoldDiscoveredEfforts: () => scaffoldDiscoveredEfforts,
+  validateDashboardNote: () => validateDashboardNote
+});
+function listMarkdownFiles(dir, prefix = "") {
+  if (!fs.existsSync(dir)) return [];
+  const out = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) out.push(...listMarkdownFiles(path.join(dir, entry.name), rel));
+    else if (entry.isFile() && entry.name.endsWith(".md")) out.push(rel);
+  }
+  return out.sort();
+}
+function chunkIdFor(relPath) {
+  const parts = relPath.split("/");
+  if (parts[0] !== "markdown" || parts.length < 2) return null;
+  const corpus = parts[1];
+  if (parts.length === 2) return null;
+  const slug = parts[2]?.replace(/\.md$/, "");
+  switch (corpus) {
+    case "canvas":
+    case "dashboards":
+    case "efforts":
+      return corpus;
+    case "collections":
+      return parts.length === 3 ? `collection._root` : `collection.${slug}`;
+    case "feeds":
+      return parts.length === 3 ? `feed._root` : `feed.${slug}`;
+    default:
+      return null;
+  }
+}
+function collectCorpusMarkdown(markdownDir) {
+  return listMarkdownFiles(markdownDir).map((p) => `markdown/${p}`);
+}
+function partitionIntoChunks(paths) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const id = chunkIdFor(p);
+    if (id === null) {
+      throw new Error(
+        `[generate-seed] Parity failure: '${p}' is not part of any known corpus (canvas | dashboards | efforts | collections | feeds). Extend chunkIdFor() if this is a new corpus.`
+      );
+    }
+    const list = byId.get(id);
+    if (list) list.push(p);
+    else byId.set(id, [p]);
+  }
+  return [...byId.entries()].sort(([a], [b]) => a < b ? -1 : 1).map(([id, files]) => ({ id, files }));
+}
+function validateDashboardNote(raw) {
+  const problems = [];
+  const { meta } = parseFrontmatter(raw);
+  const { sections } = wodWikiWql.parseDashboardNote(raw);
+  const doc = wodWikiWql.buildDashboardDocument(sections, meta);
+  if (!doc.isDashboard) return ["file is not a dashboard note (missing dashboard frontmatter)"];
+  if (doc.title === void 0) problems.push("dashboard has no title");
+  if (doc.widgets.length < 3) problems.push(`dashboard has only ${doc.widgets.length} widgets (the locked format has \u2265 3)`);
+  const declared = new Set(doc.tokens.map((t) => t.name));
+  for (const widget of doc.widgets) {
+    const where = `widget '${widget.title ?? widget.body.slice(0, 40)}'`;
+    if (widget.title === void 0) problems.push(`${where}: missing title`);
+    if (!wodWikiWql.isDashboardWidgetType(wodWikiWql.resolveWidgetType(widget.type))) {
+      problems.push(`${where}: unknown widget type '${widget.type}'`);
+    }
+    const parsed = wodWikiWql.parseQuery(widget.body);
+    if (parsed.error !== void 0) problems.push(`${where}: WQL parse error: ${parsed.error}`);
+    for (const ref of [
+      ...widget.body.matchAll(/\$([A-Za-z][\w-]*)/g),
+      ...Object.values(widget.attributes).flatMap((v) => [...String(v).matchAll(/\$([A-Za-z][\w-]*)/g)])
+    ]) {
+      if (!declared.has(ref[1])) problems.push(`${where}: undeclared token $${ref[1]}`);
+    }
+  }
+  return problems;
+}
+function gateDashboards(groups, corpusRoot) {
+  for (const group of groups) {
+    if (group.id !== DASHBOARDS_CHUNK_ID2) continue;
+    for (const p of group.files) {
+      const problems = validateDashboardNote(fs.readFileSync(path.join(corpusRoot, p), "utf8"));
+      if (problems.length > 0) {
+        throw new Error(`[generate-seed] Dashboard validation failed for '${p}':
+  - ${problems.join("\n  - ")}`);
+      }
+    }
+  }
+}
+function toSegmentDataType2(section) {
+  switch (section.type) {
+    case "time":
+    case "log":
+      return "wod";
+    case "title": {
+      const l = section.level ?? 1;
+      return `h${Math.min(Math.max(l, 1), 6)}`;
+    }
+    case "frontmatter":
+      return "frontmatter";
+    case "markdown":
+    case "widget":
+    case "embed":
+    case "code":
+      return "markdown";
+    default:
+      return "markdown";
+  }
+}
+function getFileCreatedAt(file, repoRoot) {
+  try {
+    const out = child_process.execSync(`git log -1 --format=%ct -- '${file}'`, { cwd: repoRoot, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const ts = Number(out) * 1e3;
+    return Number.isFinite(ts) && ts > 0 ? ts : 0;
+  } catch {
+    return 0;
+  }
+}
+function feedDateToCreatedAt(dateKey) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(dateKey)) return 0;
+  const ts = Date.parse(`${dateKey}T00:00:00Z`);
+  return Number.isNaN(ts) ? 0 : ts;
+}
+function buildBlockIndexRows(markdownDir, corpusRoot) {
+  const index = [];
+  for (const file of listMarkdownFiles(path.join(markdownDir, "collections"))) {
+    const rel = `markdown/collections/${file}`;
+    const parts = rel.split("/");
+    if (parts.length < 4) continue;
+    const dirName = parts[parts.length - 2];
+    const fileNameExt = parts[parts.length - 1];
+    const isReadme = fileNameExt.toLowerCase() === "readme.md";
+    const fileName = fileNameExt.replace(/\.md$/, "");
+    const noteId = isReadme ? dirName : `${dirName}/${fileName}`;
+    const content = fs.readFileSync(path.join(corpusRoot, rel), "utf8");
+    const headingMatch = isReadme ? content.match(/^#\s+(.+)$/m) : null;
+    const noteTitle = headingMatch?.[1]?.trim() || fileToDisplayName(isReadme ? dirName : fileNameExt);
+    const createdAt = getFileCreatedAt(rel, corpusRoot);
+    const sections = wodWikiCore.parseDocumentSections(content);
+    let position = 0;
+    for (const section of sections) {
+      const blockContentId = section.scriptBlock?.contentId ?? void 0;
+      index.push({
+        id: `static:${noteId}:${section.id}:1`,
+        noteId,
+        segmentId: section.id,
+        segmentVersion: 1,
+        position: position++,
+        dataType: toSegmentDataType2(section),
+        blockContentId,
+        rawContent: section.displayContent,
+        noteTitle,
+        createdAt,
+        isStatic: true,
+        sourceId: isReadme ? `collection:${dirName}` : `collection:${noteId}`,
+        sourcePath: rel
+      });
+    }
+  }
+  for (const file of listMarkdownFiles(path.join(markdownDir, "feeds"))) {
+    const rel = `markdown/feeds/${file}`;
+    const parts = rel.split("/");
+    if (parts.length < 5) continue;
+    const dirName = parts[parts.length - 3];
+    const dateKey = parts[parts.length - 2];
+    const fileNameExt = parts[parts.length - 1];
+    if (fileNameExt.toLowerCase() === "readme.md") continue;
+    const fileName = fileNameExt.replace(/\.md$/, "");
+    const noteId = `feeds/${dirName}/${dateKey}/${fileName}`;
+    const noteTitle = fileToDisplayName(fileNameExt);
+    const content = fs.readFileSync(path.join(corpusRoot, rel), "utf8");
+    const sections = wodWikiCore.parseDocumentSections(content);
+    let position = 0;
+    for (const section of sections) {
+      const blockContentId = section.scriptBlock?.contentId ?? void 0;
+      index.push({
+        id: `static:${noteId}:${section.id}:1`,
+        noteId,
+        segmentId: section.id,
+        segmentVersion: 1,
+        position: position++,
+        dataType: toSegmentDataType2(section),
+        blockContentId,
+        rawContent: section.displayContent,
+        noteTitle,
+        createdAt: feedDateToCreatedAt(dateKey),
+        isStatic: true,
+        sourceId: `feed:${noteId}`,
+        sourcePath: rel
+      });
+    }
+  }
+  for (const file of listMarkdownFiles(path.join(markdownDir, "canvas"))) {
+    const rel = `markdown/canvas/${file}`;
+    const content = fs.readFileSync(path.join(corpusRoot, rel), "utf8");
+    const noteId = canvasRouteSlug2(content);
+    if (!noteId) continue;
+    const fileNameExt = file.split("/").pop() ?? file;
+    const noteTitle = fileToDisplayName(fileNameExt);
+    const createdAt = getFileCreatedAt(rel, corpusRoot);
+    const sections = wodWikiCore.parseDocumentSections(content);
+    let position = 0;
+    for (const section of sections) {
+      const blockContentId = section.scriptBlock?.contentId ?? void 0;
+      index.push({
+        id: `static:${noteId}:${section.id}:1`,
+        noteId,
+        segmentId: section.id,
+        segmentVersion: 1,
+        position: position++,
+        dataType: toSegmentDataType2(section),
+        blockContentId,
+        rawContent: section.displayContent,
+        noteTitle,
+        createdAt,
+        isStatic: true,
+        sourceId: `guides:${noteId}`,
+        sourcePath: rel
+      });
+    }
+  }
+  return index;
+}
+function formatDiscoveredLabel(raw) {
+  const clean = raw.replace(/[-_]+/g, " ").trim();
+  return clean.split(/\s+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+}
+function loadExistingEffortMap(markdownDir) {
+  const slugs = /* @__PURE__ */ new Set();
+  const aliasToCanonical = /* @__PURE__ */ new Map();
+  const effortsDir = path.join(markdownDir, "efforts");
+  for (const file of listMarkdownFiles(effortsDir)) {
+    const raw = fs.readFileSync(path.join(effortsDir, file), "utf8");
+    const parsed = parseEffortFile(raw);
+    if (!parsed) continue;
+    slugs.add(parsed.slug);
+    aliasToCanonical.set(parsed.slug, parsed.slug);
+    aliasToCanonical.set(parsed.label.toLowerCase(), parsed.slug);
+    aliasToCanonical.set(parsed.slug.replace(/-/g, " "), parsed.slug);
+    for (const alias of parsed.aliases) {
+      aliasToCanonical.set(alias.toLowerCase(), parsed.slug);
+      aliasToCanonical.set(alias.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, ""), parsed.slug);
+    }
+  }
+  return { slugs, aliasToCanonical };
+}
+function discoverUncatalogedEfforts(markdownDir, corpusRoot) {
+  const { slugs, aliasToCanonical } = loadExistingEffortMap(markdownDir);
+  const blocks = buildBlockIndexRows(markdownDir, corpusRoot);
+  const discovered = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (block.dataType !== "wod" || !block.rawContent) continue;
+    const script = wodWikiLang.parseScript(block.rawContent);
+    for (const statement of script.statements) {
+      const effortMetric = statement.metrics?.getMetric?.("effort");
+      const effortLabel = (effortMetric && typeof effortMetric.value === "string" ? effortMetric.value : void 0) ?? statement.exerciseId;
+      if (!effortLabel) continue;
+      const slugified = effortLabel.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+      if (!slugified || NON_EFFORT_SLUGS[slugified]) continue;
+      const canonical = aliasToCanonical.get(slugified) ?? aliasToCanonical.get(effortLabel.toLowerCase());
+      if (canonical && slugs.has(canonical)) continue;
+      const existing = discovered.get(slugified);
+      if (existing) {
+        existing.rawLabels.add(effortLabel);
+      } else {
+        discovered.set(slugified, {
+          label: formatDiscoveredLabel(effortLabel),
+          rawLabels: /* @__PURE__ */ new Set([effortLabel])
+        });
+      }
+    }
+  }
+  return Array.from(discovered.entries()).map(([slug, data]) => ({
+    slug,
+    label: data.label,
+    rawLabels: Array.from(data.rawLabels)
+  }));
+}
+function scaffoldDiscoveredEfforts(discovered, markdownDir) {
+  const targetDir = path.join(markdownDir, "efforts", "discovered");
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+  const createdPaths = [];
+  for (const effort of discovered) {
+    const filePath = path.join(targetDir, `${effort.slug}.md`);
+    if (fs.existsSync(filePath)) continue;
+    const aliases = effort.rawLabels.filter((l) => l.toLowerCase() !== effort.label.toLowerCase()).map((l) => `  - "${l.replace(/"/g, '\\"')}"`);
+    const content = [
+      "---",
+      `id: effort-bundled-${effort.slug}`,
+      `slug: ${effort.slug}`,
+      `label: "${effort.label.replace(/"/g, '\\"')}"`,
+      aliases.length > 0 ? `aliases:
+${aliases.join("\n")}` : "aliases: []",
+      "baseAttributes:",
+      "  met: 5.0",
+      "  discipline: general",
+      "  intensityTier: moderate",
+      "registrySource: bundled",
+      "---",
+      ""
+    ].join("\n");
+    fs.writeFileSync(filePath, content, "utf8");
+    createdPaths.push(filePath);
+  }
+  return createdPaths;
+}
+function buildBlockEffortRows(markdownDir, corpusRoot) {
+  const efforts = [];
+  const { aliasToCanonical } = loadExistingEffortMap(markdownDir);
+  const blocks = buildBlockIndexRows(markdownDir, corpusRoot);
+  for (const block of blocks) {
+    if (block.dataType !== "wod" || !block.rawContent) continue;
+    const script = wodWikiLang.parseScript(block.rawContent);
+    const effortSlugs = extractEffortSlugs2(script.statements);
+    for (const rawSlug of effortSlugs) {
+      const norm = rawSlug.toLowerCase().trim();
+      const canonicalSlug = aliasToCanonical.get(norm) ?? aliasToCanonical.get(norm.replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "")) ?? norm.replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+      if (!canonicalSlug || NON_EFFORT_SLUGS[canonicalSlug] || NON_EFFORT_SLUGS[norm]) {
+        continue;
+      }
+      efforts.push({
+        id: `${block.id}:${canonicalSlug}`,
+        noteId: block.noteId,
+        blockId: block.segmentId,
+        blockContentId: block.blockContentId,
+        effortSlug: canonicalSlug,
+        isStatic: block.isStatic,
+        sourcePath: block.sourcePath,
+        createdAt: block.createdAt
+      });
+    }
+  }
+  return efforts;
+}
+function buildStaticParentMap(blockRows) {
+  const map = {};
+  for (const row of blockRows) {
+    if (!row.sourcePath) continue;
+    const prev = map[row.noteId];
+    if (prev && prev.sourcePath !== row.sourcePath) {
+      throw new Error(
+        `[generate-seed] ambiguous static parent '${row.noteId}' maps to both '${prev.sourcePath}' and '${row.sourcePath}'`
+      );
+    }
+    map[row.noteId] = { sourcePath: row.sourcePath, sourceId: row.sourceId };
+  }
+  return map;
+}
+function sha256Hex(data) {
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+function generateSeed(options = {}) {
+  const t0 = Date.now();
+  const passMs = { scan: 0, blockIndex: 0, blockEfforts: 0, write: 0 };
+  const corpusRoot = options.corpusRoot ?? process.cwd();
+  const markdownDir = options.markdownDir ?? path.join(corpusRoot, "markdown");
+  const outDir = options.outDir ?? path.join(corpusRoot, "dist");
+  const gitVersion = options.version !== void 0 ? { ...resolveGitVersion(corpusRoot), version: options.version } : resolveGitVersion(corpusRoot);
+  if (options.scaffoldDiscoveredEfforts) {
+    const discovered = discoverUncatalogedEfforts(markdownDir, corpusRoot);
+    if (discovered.length > 0) {
+      scaffoldDiscoveredEfforts(discovered, markdownDir);
+    }
+  }
+  const tScan = Date.now();
+  const paths = collectCorpusMarkdown(markdownDir);
+  const groups = partitionIntoChunks(paths);
+  gateDashboards(groups, corpusRoot);
+  if (options.templateFile && fs.existsSync(options.templateFile)) {
+    const templateRowPath = options.templateRowPath ?? path.relative(corpusRoot, options.templateFile).split("\\").join("/");
+    groups.push({ id: TEMPLATE_CHUNK_ID2, files: [templateRowPath] });
+  }
+  passMs.scan = Date.now() - tScan;
+  const chunksDir = path.join(outDir, "chunks");
+  fs.rmSync(outDir, { recursive: true, force: true });
+  fs.mkdirSync(chunksDir, { recursive: true });
+  const manifestChunks = [];
+  let totalFiles = 0;
+  const tWrite = Date.now();
+  for (const { id, files } of groups) {
+    const templateSource = id === TEMPLATE_CHUNK_ID2 ? options.templateFile : void 0;
+    const rows = files.map((p) => ({
+      path: p,
+      content: fs.readFileSync(templateSource ?? path.join(corpusRoot, p), "utf8")
+    }));
+    const bytes = Buffer.from(JSON.stringify(rows), "utf8");
+    const sha = sha256Hex(bytes);
+    const file = `chunks/${id}.${sha.slice(0, 8)}.json`;
+    fs.writeFileSync(path.join(outDir, file), bytes);
+    manifestChunks.push({ id, path: file, sha256: sha, bytes: bytes.length, count: rows.length });
+    totalFiles += rows.length;
+  }
+  const tBlockIndex = Date.now();
+  const blockRows = buildBlockIndexRows(markdownDir, corpusRoot);
+  passMs.blockIndex = Date.now() - tBlockIndex;
+  fs.writeFileSync(
+    path.join(outDir, "block-parent-map.json"),
+    JSON.stringify(buildStaticParentMap(blockRows), null, 2) + "\n"
+  );
+  for (let i = 0; blockRows.length > 0 && i * BLOCK_INDEX_ROWS_PER_CHUNK < blockRows.length; i++) {
+    const part = blockRows.slice(i * BLOCK_INDEX_ROWS_PER_CHUNK, (i + 1) * BLOCK_INDEX_ROWS_PER_CHUNK);
+    if (part.length === 0) break;
+    const id = `${BLOCK_INDEX_CHUNK_PREFIX}${i}`;
+    const bytes = Buffer.from(JSON.stringify(part), "utf8");
+    const sha = sha256Hex(bytes);
+    const file = `chunks/${id}.${sha.slice(0, 8)}.json`;
+    fs.writeFileSync(path.join(outDir, file), bytes);
+    manifestChunks.push({ id, path: file, sha256: sha, bytes: bytes.length, count: part.length, kind: "block-index" });
+  }
+  const tBlockEfforts = Date.now();
+  const effortRows = buildBlockEffortRows(markdownDir, corpusRoot);
+  passMs.blockEfforts = Date.now() - tBlockEfforts;
+  for (let i = 0; effortRows.length > 0 && i * BLOCK_INDEX_ROWS_PER_CHUNK < effortRows.length; i++) {
+    const part = effortRows.slice(i * BLOCK_INDEX_ROWS_PER_CHUNK, (i + 1) * BLOCK_INDEX_ROWS_PER_CHUNK);
+    if (part.length === 0) break;
+    const id = `${BLOCK_EFFORTS_CHUNK_PREFIX}${i}`;
+    const bytes = Buffer.from(JSON.stringify(part), "utf8");
+    const sha = sha256Hex(bytes);
+    const file = `chunks/${id}.${sha.slice(0, 8)}.json`;
+    fs.writeFileSync(path.join(outDir, file), bytes);
+    manifestChunks.push({ id, path: file, sha256: sha, bytes: bytes.length, count: part.length, kind: "block-efforts" });
+  }
+  passMs.write = Date.now() - tWrite;
+  const manifest = {
+    schema: SEED_SCHEMA2,
+    version: gitVersion.version,
+    versionLabel: gitVersion.versionLabel,
+    commit: gitVersion.commit,
+    dirty: gitVersion.dirty,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    chunks: manifestChunks
+  };
+  fs.writeFileSync(path.join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+  const reportPath = writeBuildReport(outDir, {
+    manifest,
+    totalMs: Date.now() - t0,
+    passMs,
+    fileCount: paths.length});
+  return { manifest, outDir, totalFiles, reportPath, passMs };
+}
+var BLOCK_INDEX_ROWS_PER_CHUNK, NON_EFFORT_SLUGS;
+var init_compiler = __esm({
+  "src/cli/seedbuild/compiler.ts"() {
+    init_contract();
+    init_effort_slugs();
+    init_filename();
+    init_effort_file();
+    init_git_version();
+    init_report();
+    init_frontmatter();
+    BLOCK_INDEX_ROWS_PER_CHUNK = 4e3;
+    NON_EFFORT_SLUGS = {
+      "amrap": true,
+      "emom": true,
+      "tabata": true,
+      "for-time": true,
+      "rounds": true,
+      "sets": true,
+      "repetitions": true,
+      "count-down": true,
+      "total-reps": true,
+      "warmup": true,
+      "cooldown": true,
+      "cool-down": true,
+      "transition": true,
+      "rest": true,
+      "break": true,
+      "work": true,
+      "i-suck-at-this": true,
+      "isuckatthis": true,
+      "movement": true,
+      "movement-you": true,
+      "selected-exercise": true,
+      "training-setup": true,
+      "grade-system": true,
+      "hangs": true,
+      "warm-light-wind": true,
+      "basin": true,
+      "rock-canyon": true,
+      "b-onsight": true,
+      "a-redpoint": true,
+      "d-redpoint": true,
+      "v0-flash": true,
+      "v2-flash": true,
+      "v7-redpoint": true,
+      "avgrpe-mean": true,
+      "calculate": true,
+      "totalload-sum": true,
+      "query": true,
+      "by": true,
+      "": true,
+      "-": true,
+      "...": true,
+      "x": true,
+      "s": true,
+      "bw": true
+    };
+  }
+});
 var activePacks = /* @__PURE__ */ new Map();
 function registerLanguagePack(pack) {
   const packId = pack.identity?.id ?? pack.identity?.name ?? "anonymous-pack";
@@ -35,11 +878,13 @@ function registerLanguagePack(pack) {
 
 // src/cli/loader.ts
 function getPathUtils() {
-  if (typeof globalThis.process?.versions?.node === "undefined" && typeof globalThis.Bun === "undefined") {
+  if (typeof globalThis.process?.versions?.node === "undefined" && !("Bun" in globalThis)) {
     throw new Error("Path resolution is only supported in Node / Bun environments");
   }
   return {
+    // eslint-disable-next-line no-restricted-syntax -- lazy CJS require keeps node builtins out of browser bundles
     resolve: __require("path").resolve,
+    // eslint-disable-next-line no-restricted-syntax -- lazy CJS require keeps node builtins out of browser bundles
     pathToFileURL: __require("url").pathToFileURL
   };
 }
@@ -237,36 +1082,6 @@ async function runExecution(source, options = {}) {
 }
 
 // src/store.ts
-function factRowsToEventRows(facts) {
-  return facts.map((f, i) => {
-    const metricKey = f.metricKey ?? f.type;
-    return {
-      id: `fact:${f.resultId}:${metricKey}:${i}`,
-      resultId: f.resultId,
-      noteId: f.noteId,
-      blockContentId: f.blockContentId,
-      pageId: f.pageId,
-      origin: f.origin,
-      timestamp: f.timestamp,
-      grain: f.grain === "event" ? "event" : "summary",
-      outputType: "analytics",
-      effortSlug: f.effortSlug,
-      metrics: [{
-        type: metricKey,
-        value: f.value,
-        ...f.unit ? { unit: f.unit } : {},
-        metadata: {
-          canonicalKey: metricKey,
-          ...f.effortSlug ? { effortSlug: f.effortSlug } : {},
-          ...f.discipline ? { effortDiscipline: f.discipline } : {},
-          ...f.intensityTier ? { effortIntensityTier: f.intensityTier } : {}
-        }
-      }],
-      segmentId: f.segmentId,
-      segmentVersion: f.segmentVersion
-    };
-  });
-}
 function inMemoryEventStore(events) {
   const rows = [...events];
   return {
@@ -309,190 +1124,1456 @@ var WqlSyntaxError = class extends Error {
   query;
   syntaxError;
 };
-function factsFromExecutionLog(log, resultId = "stdin-result-1") {
-  const facts = [];
-  for (const s of log.logs) {
-    const started = s.timeSpan?.started ?? s.timestamp ?? Date.now();
-    for (const m of s.metrics) {
-      const mType = m.type || "metric";
-      const numVal = typeof m.value === "number" ? m.value : Number(m.value);
-      facts.push({
-        id: `fact-${s.id ?? 0}-${mType}-${facts.length + 1}`,
-        noteId: "stdin-note-1",
-        blockContentId: s.sourceBlockKey || "stdin-block-1",
-        segmentId: s.sourceBlockKey || "stdin-seg-1",
-        segmentVersion: 1,
-        resultId,
-        grain: s.outputType === "analytics" ? "summary" : "event",
-        type: mType,
-        value: Number.isNaN(numVal) ? 0 : numVal,
-        unit: m.unit,
-        label: m.label || mType,
-        metricKey: mType,
-        metricLabel: m.label || mType,
-        timestamp: started,
-        createdAt: started
+function legacyLogsOf(result) {
+  const legacy = result;
+  return legacy.data?.logs ?? [];
+}
+function extractPayload(rawJson) {
+  try {
+    const parsed = JSON.parse(rawJson);
+    if (isIRFile(parsed)) {
+      return parsed.data;
+    }
+    return parsed;
+  } catch (err) {
+    throw new Error(`Failed to parse JSON input: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+  }
+}
+function buildStoresFromData(data) {
+  const identity = (r) => ({
+    noteId: r.noteId,
+    resultId: r.id,
+    segmentId: r.segmentId,
+    segmentVersion: r.segmentVersion,
+    blockContentId: r.blockContentId,
+    origin: r.origin,
+    pageId: r.pageId,
+    workoutTimestamp: r.createdAt
+  });
+  const events = [
+    ...data.eventRecords,
+    ...data.facts.map((f, i) => ({
+      id: `fact:${f.resultId ?? "stdin"}:${f.metricKey ?? f.type}:${i}`,
+      resultId: f.resultId ?? "stdin-result-1",
+      noteId: f.noteId ?? "stdin-note-1",
+      blockContentId: f.blockContentId,
+      pageId: f.pageId,
+      origin: f.origin,
+      timestamp: f.timestamp,
+      grain: f.grain === "event" ? "event" : "summary",
+      outputType: "analytics",
+      effortSlug: f.effortSlug,
+      metrics: [{
+        type: f.metricKey ?? f.type,
+        value: f.value,
+        ...f.unit ? { unit: f.unit } : {},
+        origin: "engine"
+      }],
+      segmentId: f.segmentId,
+      segmentVersion: f.segmentVersion
+    })),
+    ...data.results.flatMap((r) => {
+      const logs = legacyLogsOf(r);
+      return [...wodWikiWql.toEventRows(logs, identity(r)), ...wodWikiWql.toSummaryEventRows(logs, identity(r))];
+    })
+  ];
+  const eventStore = inMemoryEventStore(events);
+  const noteStore = {
+    getAllNotes: async () => [...data.notes],
+    getNoteIdsForTag: async (tag) => {
+      const matching = /* @__PURE__ */ new Set();
+      for (const [noteId, tags] of Object.entries(data.noteTags)) {
+        if (tags.includes(tag)) matching.add(noteId);
+      }
+      return matching;
+    },
+    getNoteTagLabels: async (noteId) => [...data.noteTags[noteId] ?? []]
+  };
+  const blockStore = {
+    getAllBlocks: async () => [...data.blocks]
+  };
+  const effortStore = {
+    getAllEfforts: async () => [...data.efforts]
+  };
+  return { eventStore, noteStore, blockStore, effortStore };
+}
+function loadQueryData(options) {
+  const data = {
+    eventRecords: [],
+    facts: [],
+    results: [],
+    notes: [],
+    blocks: [],
+    efforts: [...wodWikiLang.bundledEfforts],
+    noteTags: {}
+  };
+  if (options.corpusPath) {
+    const fs = getFs();
+    if (!fs.existsSync(options.corpusPath)) {
+      throw new Error(`Corpus file not found at path: ${options.corpusPath}`);
+    }
+    const raw = fs.readFileSync(options.corpusPath, "utf-8");
+    const payload = extractPayload(raw);
+    if (Array.isArray(payload)) {
+      data.facts = payload;
+    } else if (payload && typeof payload === "object") {
+      const obj = payload;
+      if (obj.kind === "event-journal" || Array.isArray(obj.records)) {
+        if (Array.isArray(obj.records)) {
+          data.eventRecords = obj.records;
+        }
+        if (Array.isArray(obj.notes)) {
+          data.notes = obj.notes;
+          for (const n of obj.notes) {
+            if (n && typeof n === "object" && n.id && Array.isArray(n.tags)) {
+              data.noteTags[n.id] = n.tags;
+            }
+          }
+        }
+      } else if (obj.facts || obj.results || obj.notes || obj.blocks || obj.efforts || obj.tags || obj.logs) {
+        const corpus = payload;
+        if (corpus.facts) data.facts = corpus.facts;
+        if (corpus.results) data.results = corpus.results;
+        if (corpus.notes) data.notes = corpus.notes;
+        if (corpus.blocks) data.blocks = corpus.blocks;
+        if (corpus.efforts) data.efforts = corpus.efforts;
+        if (corpus.tags) data.noteTags = corpus.tags;
+        if (corpus.logs && (!corpus.results || corpus.results.length === 0)) {
+          const syntheticResult = {
+            id: "corpus-result-1",
+            noteId: "corpus-note-1",
+            blockContentId: "corpus-block-1",
+            origin: "journal",
+            createdAt: corpus.logs[0]?.timeSpan?.started ?? Date.now(),
+            startTime: corpus.logs[0]?.timeSpan?.started ?? Date.now(),
+            endTime: corpus.logs[corpus.logs.length - 1]?.timeSpan?.ended ?? Date.now(),
+            duration: 0,
+            completed: true
+          };
+          data.results = [syntheticResult];
+        }
+      } else {
+        throw new Error(`Unrecognized corpus payload shape in "${options.corpusPath}" (expected event-journal, fact-set, or CorpusIRData)`);
+      }
+    }
+  } else if (options.stdinLog) {
+    const payload = extractPayload(options.stdinLog);
+    let executionLog;
+    const rawLogs = payload.logs ?? ("statements" in payload ? payload.statements : void 0) ?? [];
+    if ("results" in payload) {
+      executionLog = { results: payload.results, logs: rawLogs, statements: rawLogs };
+    } else {
+      executionLog = { results: payload, logs: rawLogs, statements: rawLogs };
+    }
+    const resultId = "stdin-result-1";
+    const workoutResult = {
+      id: resultId,
+      noteId: "stdin-note-1",
+      blockContentId: "stdin-block-1",
+      origin: "journal",
+      createdAt: executionLog.results.startTime,
+      startTime: executionLog.results.startTime,
+      endTime: executionLog.results.endTime,
+      duration: executionLog.results.duration ?? 0,
+      completed: executionLog.results.completed
+    };
+    data.results = [workoutResult];
+    data.eventRecords = wodWikiWql.toEventRows(executionLog.logs, {
+      noteId: workoutResult.noteId,
+      resultId: workoutResult.id,
+      segmentId: workoutResult.segmentId,
+      segmentVersion: workoutResult.segmentVersion,
+      blockContentId: workoutResult.blockContentId,
+      origin: workoutResult.origin,
+      pageId: workoutResult.pageId,
+      workoutTimestamp: workoutResult.createdAt
+    });
+  } else if (options.stdinFacts) {
+    const payload = extractPayload(options.stdinFacts);
+    if (Array.isArray(payload)) {
+      data.facts = payload;
+    } else if (payload && typeof payload === "object" && "facts" in payload) {
+      data.facts = payload.facts;
+    }
+  } else {
+    throw new Error("No input dataset provided. Specify --corpus <path>, --stdin-log, or --stdin-facts.");
+  }
+  return data;
+}
+async function runQueryCli(wqlString, options = {}) {
+  const parsed = wodWikiWql.parseQuery(wqlString);
+  if (parsed.error) {
+    throw new WqlSyntaxError(wqlString, parsed.error);
+  }
+  const stores = options.stores ?? buildStoresFromData(loadQueryData(options));
+  const service = new wodWikiWql.QueryService(stores);
+  if (wodWikiWql.isPipelineQuery(parsed)) {
+    const result2 = await service.runPipeline(wqlString, {
+      preferredUnit: options.preferredUnit
+    });
+    return createIRFile("pipeline-result", result2, { source: options.sourceLabel ?? "cli:wod query" });
+  }
+  if (wodWikiWql.isFindQuery(parsed)) {
+    const result2 = await service.runFind(parsed);
+    const kind = parsed.target === "session" ? "rows-result" : "find-result";
+    return createIRFile(kind, result2, { source: options.sourceLabel ?? "cli:wod query" });
+  }
+  const result = await service.runQuery(wqlString, {
+    preferredUnit: options.preferredUnit
+  });
+  return createIRFile("query-result", result, { source: options.sourceLabel ?? "cli:wod query" });
+}
+var nodePath = () => nodeRequire()("node:path");
+var nodeFs = () => nodeRequire()("node:fs");
+var nodeCrypto = () => nodeRequire()("node:crypto");
+function nodeRequire() {
+  const g = globalThis;
+  if (typeof g.process?.versions?.node === "undefined" && typeof g.Bun === "undefined") {
+    throw new Error("SQLite operations are only supported in Node / Bun environments");
+  }
+  const req = g.require ?? (typeof __require === "function" ? __require : void 0);
+  if (!req) throw new Error("SQLite operations require a CJS require shim (missing tsup banner?)");
+  return req;
+}
+var sqlModulePromise;
+function loadSql() {
+  sqlModulePromise ??= import(
+    /* @vite-ignore */
+    '@bitcobblers/wod-wiki-storage/sql'
+  );
+  return sqlModulePromise;
+}
+function resolveDbPath(dbPath) {
+  const chosen = dbPath ?? process.env.WOD_WIKI_DB ?? "./wodwiki.db";
+  return nodePath().resolve(process.cwd(), chosen);
+}
+async function openCliDb(dbPath) {
+  const [{ createClient }, sql] = await Promise.all([
+    import(
+      /* @vite-ignore */
+      '@libsql/client'
+    ),
+    loadSql()
+  ]);
+  const resolved = resolveDbPath(dbPath);
+  nodeFs().mkdirSync(nodePath().dirname(resolved), { recursive: true });
+  const db = sql.libsqlDatabase(createClient({ url: `file:${resolved}` }));
+  await sql.initializeStore(db);
+  await sql.initializeDomain(db);
+  return { db, path: resolved, close: () => db.close() };
+}
+function formatV5Digest(digest) {
+  const bytes = digest.slice(0, 16);
+  bytes[6] = bytes[6] & 15 | 80;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0"));
+  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+}
+function uuid5(namespace, name) {
+  return formatV5Digest(nodeCrypto().createHash("sha1").update(namespace).update(name).digest());
+}
+var CLI_UUID_NAMESPACE = "c0ffee00-8b1a-4e2c-9d3f-5a6b7c8d9e0f";
+function stableNoteId(sourceLabel, content) {
+  if (sourceLabel && sourceLabel !== "-") {
+    return uuid5(CLI_UUID_NAMESPACE, `wod-cli:${nodePath().resolve(process.cwd(), sourceLabel)}`);
+  }
+  return uuid5(CLI_UUID_NAMESPACE, `wod-cli:stdin:${content.length}:${content.slice(0, 256)}`);
+}
+function randomId() {
+  return nodeCrypto().randomUUID();
+}
+async function allRows(sql, db, store) {
+  return sql.listRows(db, sql.storeDefinition(store));
+}
+async function rowsByIndex(sql, db, store, index, only) {
+  return sql.listRows(db, sql.storeDefinition(store), { only }, void 0, index);
+}
+function sqliteEventStore(db) {
+  const all = async () => await allRows(await loadSql(), db, "events");
+  return {
+    getEventsByTimeRange: async (start, end) => (await all()).filter((r) => r.timestamp >= start && r.timestamp <= end),
+    getEventsByResult: async (resultId) => (await all()).filter((r) => r.resultId === resultId),
+    getEventsForNote: async (noteId) => (await all()).filter((r) => r.noteId === noteId),
+    getEventsByContent: async (blockContentId) => (await all()).filter((r) => r.blockContentId === blockContentId),
+    scanAll: all,
+    appendEvents: async (appended) => {
+      const sql = await loadSql();
+      await db.transaction(async (tx) => {
+        const eventsDef = sql.storeDefinition("events");
+        for (const row of appended) await sql.putRow(tx, eventsDef, row);
+      });
+    },
+    finalizeSummaries: async (resultId, finals) => {
+      const sql = await loadSql();
+      await db.transaction(async (tx) => {
+        const eventsDef = sql.storeDefinition("events");
+        const existing = (await sql.listRows(tx, eventsDef)).filter(
+          (r) => r.resultId === resultId && r.grain === "summary" && r.origin !== "user"
+        );
+        for (const row of existing) await sql.deleteRows(tx, eventsDef, row.id);
+        for (const row of finals) await sql.putRow(tx, eventsDef, row);
+      });
+    },
+    deleteEvents: async (ids) => {
+      const sql = await loadSql();
+      await db.transaction(async (tx) => {
+        const eventsDef = sql.storeDefinition("events");
+        for (const id of ids) await sql.deleteRows(tx, eventsDef, id);
       });
     }
+  };
+}
+function sqliteNoteStore(db) {
+  return {
+    getAllNotes: async () => await allRows(await loadSql(), db, "notes"),
+    getNoteIdsForTag: async (label) => {
+      const sql = await loadSql();
+      const tags = (await allRows(sql, db, "tags")).filter((t) => t.label === label);
+      const ids = {};
+      for (const tag of tags) {
+        for (const row of await rowsByIndex(sql, db, "note_tags", "by-tag", tag.id)) {
+          ids[row.noteId] = true;
+        }
+      }
+      return new Set(Object.keys(ids));
+    },
+    getNoteTagLabels: async (noteId) => {
+      const sql = await loadSql();
+      const tagRows = await allRows(sql, db, "tags");
+      const labelById = {};
+      for (const t of tagRows) labelById[t.id] = t.label;
+      const links = await rowsByIndex(sql, db, "note_tags", "by-note", noteId);
+      return links.map((l) => labelById[l.tagId]).filter((l) => typeof l === "string");
+    },
+    queryDomain: async (request) => {
+      const result = await (await loadSql()).handleDomainQuery(db, request);
+      return result;
+    }
+  };
+}
+function sqliteBlockStore(db) {
+  return {
+    getAllBlocks: async () => await allRows(await loadSql(), db, "block_index"),
+    queryDomain: async (request) => {
+      const result = await (await loadSql()).handleDomainQuery(db, { ...request, plan: "blocks" });
+      return result;
+    }
+  };
+}
+function sqliteEffortStore(db) {
+  return {
+    getAllEfforts: async () => {
+      const stored = await allRows(await loadSql(), db, "efforts");
+      const bySlug = {};
+      for (const effort of stored) bySlug[effort.slug] = effort;
+      for (const effort of wodWikiLang.bundledEfforts) {
+        bySlug[effort.slug] ??= effort;
+      }
+      return Object.values(bySlug);
+    }
+  };
+}
+function sqliteIndexStore(db, store) {
+  return {
+    getAllFromIndex: async (index, key) => rowsByIndex(await loadSql(), db, store, index, key)
+  };
+}
+async function getNoteBundle(db, noteId) {
+  const sql = await loadSql();
+  const notes = await allRows(sql, db, "notes");
+  const note = notes.find((n) => n.id === noteId);
+  const segments = await rowsByIndex(sql, db, "segments", "by-note", noteId);
+  return { note, segments };
+}
+async function getSessionBundle(db, resultId) {
+  const sql = await loadSql();
+  const sessions = await allRows(sql, db, "sessions");
+  const session = sessions.find((s) => s.id === resultId);
+  if (!session) return void 0;
+  const events = (await allRows(sql, db, "events")).filter((e) => e.resultId === resultId);
+  return { session, events };
+}
+async function getEffortBySlug(db, slug) {
+  const sql = await loadSql();
+  const efforts = await allRows(sql, db, "efforts");
+  return efforts.find((e) => e.slug === slug);
+}
+async function listTagsByType(db, type) {
+  const sql = await loadSql();
+  const tags = await allRows(sql, db, "tags");
+  return tags.filter((t) => t.type === type);
+}
+function toSegmentDataType(section) {
+  switch (section.type) {
+    case "time":
+    case "log":
+      return "wod";
+    case "title": {
+      const level = Math.min(6, Math.max(1, section.level ?? 1));
+      return `h${level}`;
+    }
+    case "frontmatter":
+      return "frontmatter";
+    case "markdown":
+    default:
+      return "markdown";
+  }
+}
+function sectionSourceFragments(content, sections) {
+  const starts = [0];
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "\n") starts.push(i + 1);
+  }
+  return sections.map((section, index) => content.slice(
+    starts[section.startLine],
+    index + 1 < sections.length ? starts[sections[index + 1].startLine] : content.length
+  ));
+}
+function scriptBlockContentId(data) {
+  if (data && typeof data === "object" && "contentId" in data && typeof data.contentId === "string") {
+    return data.contentId;
+  }
+  return void 0;
+}
+function extractEffortSlugs(statements) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const statement of statements) {
+    if (statement.exerciseId) {
+      slugs.add(statement.exerciseId);
+    } else {
+      const effortMetric = statement.metrics?.getMetric?.("effort");
+      const effort = effortMetric && "effort" in effortMetric ? effortMetric.effort : void 0;
+      if (typeof effort === "string") {
+        const slug = effort.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+        if (slug) slugs.add(slug);
+      }
+    }
+  }
+  return [...slugs];
+}
+async function rowsByNote(sql, db, store, noteId) {
+  return sql.listRows(db, sql.storeDefinition(store), { only: noteId }, void 0, "by-note");
+}
+function titleFromLabel(sourceLabel) {
+  if (!sourceLabel || sourceLabel === "-") return "stdin";
+  const stem = sourceLabel.split("/").pop() ?? sourceLabel;
+  return stem.replace(/\.[^.]+$/, "") || sourceLabel;
+}
+async function persistNote(db, options) {
+  const sql = await loadSql();
+  const now = options.now ?? Date.now();
+  const noteId = options.noteId ?? stableNoteId(options.sourceLabel, options.source);
+  const title = options.title ?? titleFromLabel(options.sourceLabel);
+  const sections = wodWikiCore.parseDocumentSections(options.source);
+  const fragments = sectionSourceFragments(options.source, sections);
+  const existingNote = await noteById(sql, db.db, noteId);
+  const priorSegments = await rowsByNote(sql, db.db, "segments", noteId);
+  const versionBySegmentId = {};
+  for (const segment of priorSegments) {
+    versionBySegmentId[segment.id] = Math.max(versionBySegmentId[segment.id] ?? 0, segment.version);
+  }
+  const createdAt = existingNote?.createdAt ?? now;
+  const note = {
+    id: noteId,
+    title,
+    type: existingNote?.type ?? "note",
+    date: existingNote?.date ?? now,
+    createdAt
+  };
+  const ops = [];
+  const segments = sections.map((section, position) => {
+    const id = `${noteId}:${section.id}`;
+    const version = (versionBySegmentId[id] ?? 0) + 1;
+    return {
+      id,
+      version,
+      noteId,
+      position,
+      dataType: toSegmentDataType(section),
+      data: section.scriptBlock || null,
+      rawContent: section.displayContent,
+      sourceContent: fragments[position],
+      createdAt: version === 1 ? createdAt : now,
+      updatedAt: now,
+      isHistory: false
+    };
+  });
+  for (const segment of priorSegments) {
+    if (segment.isHistory !== true) {
+      ops.push({ op: "put", store: "segments", value: { ...segment, isHistory: true, updatedAt: now } });
+    }
+  }
+  ops.push({ op: "put", store: "notes", value: note });
+  for (const segment of segments) ops.push({ op: "put", store: "segments", value: segment });
+  const priorBlocks = await rowsByNote(sql, db.db, "block_index", noteId);
+  const priorBlockEfforts = await rowsByNote(sql, db.db, "block_efforts", noteId);
+  for (const row of priorBlocks) ops.push({ op: "delete", store: "block_index", key: row.id });
+  for (const row of priorBlockEfforts) ops.push({ op: "delete", store: "block_efforts", key: row.id });
+  let blockCount = 0;
+  let effortCount = 0;
+  for (const segment of segments) {
+    const blockContentId = segment.dataType === "wod" ? scriptBlockContentId(segment.data) : void 0;
+    ops.push({
+      op: "put",
+      store: "block_index",
+      value: {
+        id: `${noteId}:${segment.id}:${segment.version}`,
+        noteId,
+        segmentId: segment.id,
+        segmentVersion: segment.version,
+        position: segment.position,
+        dataType: segment.dataType,
+        blockContentId,
+        rawContent: segment.rawContent,
+        noteTitle: title,
+        createdAt: segment.createdAt
+      }
+    });
+    blockCount += 1;
+    if (segment.dataType === "wod" && segment.rawContent) {
+      const script = wodWikiLang.parseScript(segment.rawContent);
+      for (const effortSlug of extractEffortSlugs(script.statements)) {
+        ops.push({
+          op: "put",
+          store: "block_efforts",
+          value: {
+            id: `${noteId}:${segment.id}:${effortSlug}`,
+            noteId,
+            blockId: segment.id,
+            blockContentId,
+            effortSlug,
+            createdAt: segment.createdAt
+          }
+        });
+        effortCount += 1;
+      }
+    }
+  }
+  let tagCount = 0;
+  if (options.tags) {
+    const priorLinks = await rowsByNote(sql, db.db, "note_tags", noteId);
+    for (const link of priorLinks) ops.push({ op: "delete", store: "note_tags", key: link.id });
+    const tagByLabel = new Map(
+      (await sql.listRows(db.db, sql.storeDefinition("tags"))).map((t) => [t.label, t])
+    );
+    for (const item of options.tags) {
+      const label = item.label.trim();
+      if (!label) continue;
+      let tag = tagByLabel.get(label);
+      if (!tag) {
+        tag = { id: randomId(), label, type: item.type, createdAt: now };
+        tagByLabel.set(label, tag);
+        ops.push({ op: "put", store: "tags", value: tag });
+      } else if (item.type && !tag.type) {
+        tag = { ...tag, type: item.type };
+        tagByLabel.set(label, tag);
+        ops.push({ op: "put", store: "tags", value: tag });
+      }
+      tagCount += 1;
+      ops.push({
+        op: "put",
+        store: "note_tags",
+        // Deterministic junction id (unique [noteId, tagId] index).
+        value: { id: uuid5(CLI_UUID_NAMESPACE, `note-tag:${noteId}:${tag.id}`), noteId, tagId: tag.id }
+      });
+    }
+  }
+  await db.db.transaction(async (tx) => {
+    await sql.refreshDomain(tx, ops);
+  });
+  return {
+    noteId,
+    note,
+    segments: segments.length,
+    blocks: blockCount,
+    efforts: effortCount,
+    tags: tagCount,
+    created: !existingNote
+  };
+}
+async function noteById(sql, db, noteId) {
+  const rows = await sql.listRows(db, sql.storeDefinition("notes"));
+  return rows.find((row) => row.id === noteId);
+}
+async function persistRun(db, options) {
+  const sql = await loadSql();
+  const results = options.executionLog.results;
+  const logs = options.executionLog.logs ?? [];
+  const noteState = await persistNote(db, {
+    source: options.source,
+    sourceLabel: options.sourceLabel,
+    title: options.title,
+    now: options.now
+  });
+  const segments = (await rowsByNote(sql, db.db, "segments", noteState.noteId)).filter((s) => s.isHistory !== true && s.dataType === "wod").sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
+  const runSegment = segments[0];
+  const blockContentId = runSegment ? scriptBlockContentId(runSegment.data) : void 0;
+  const resultId = randomId();
+  const session = {
+    id: resultId,
+    segmentId: runSegment?.id,
+    segmentVersion: runSegment?.version,
+    noteId: noteState.noteId,
+    blockId: runSegment?.id,
+    blockContentId,
+    origin: "journal",
+    status: results.completed === false ? "in-progress" : "completed",
+    startTime: results.startTime,
+    endTime: results.endTime,
+    duration: results.duration ?? 0,
+    completed: results.completed,
+    createdAt: results.endTime || Date.now()
+  };
+  const identity = {
+    noteId: noteState.noteId,
+    resultId,
+    segmentId: session.segmentId,
+    segmentVersion: session.segmentVersion,
+    blockContentId,
+    origin: session.origin,
+    pageId: session.pageId,
+    workoutTimestamp: session.createdAt
+  };
+  const eventRows = wodWikiWql.toEventRows(logs, identity);
+  const summaryRows = wodWikiWql.toSummaryEventRows(logs, identity);
+  await db.db.transaction(async (tx) => {
+    await sql.putRow(tx, sql.storeDefinition("sessions"), session);
+    const eventsDef = sql.storeDefinition("events");
+    for (const row of [...eventRows, ...summaryRows]) await sql.putRow(tx, eventsDef, row);
+  });
+  return {
+    noteId: noteState.noteId,
+    resultId,
+    session,
+    events: eventRows.length,
+    summaries: summaryRows.length,
+    noteCreated: noteState.created
+  };
+}
+async function persistSessionBundle(db, session, events) {
+  const sql = await loadSql();
+  const existing = await noteById(sql, db.db, session.noteId);
+  let noteCreated = false;
+  if (!existing) {
+    noteCreated = true;
+    const now = session.createdAt || Date.now();
+    await db.db.transaction(async (tx) => {
+      await sql.putRow(tx, sql.storeDefinition("notes"), {
+        id: session.noteId,
+        title: `imported-${session.noteId.slice(0, 8)}`,
+        createdAt: now,
+        type: "note"
+      });
+    });
+  }
+  await db.db.transaction(async (tx) => {
+    await sql.putRow(tx, sql.storeDefinition("sessions"), session);
+    const eventsDef = sql.storeDefinition("events");
+    for (const row of events) await sql.putRow(tx, eventsDef, row);
+  });
+  return { events: events.length, noteCreated };
+}
+async function persistEffort(db, effort) {
+  const sql = await loadSql();
+  await db.db.transaction(async (tx) => {
+    await sql.putRow(tx, sql.storeDefinition("efforts"), effort);
+  });
+}
+async function persistTypedTags(db, labels, type) {
+  const sql = await loadSql();
+  const now = Date.now();
+  const tagByLabel = new Map(
+    (await sql.listRows(db.db, sql.storeDefinition("tags"))).map((t) => [t.label, t])
+  );
+  const ops = [];
+  let added = 0;
+  for (const raw of labels) {
+    const label = raw.trim();
+    if (!label) continue;
+    const tag = tagByLabel.get(label);
+    if (!tag) {
+      ops.push({ op: "put", store: "tags", value: { id: randomId(), label, type, createdAt: now } });
+      added += 1;
+    } else if (!tag.type) {
+      ops.push({ op: "put", store: "tags", value: { ...tag, type } });
+    }
+  }
+  if (ops.length > 0) {
+    await db.db.transaction(async (tx) => {
+      await sql.refreshDomain(tx, ops);
+    });
+  }
+  return added;
+}
+var NOTE_ID_FRONTMATTER_KEY = "wod-note-id";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function extractNoteIdentity(markdown) {
+  const block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdown);
+  if (!block) return void 0;
+  let noteId;
+  let title;
+  for (const line of block[1].split(/\r?\n/)) {
+    const kv = line.match(/^([^:]+):\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1].trim();
+    const value = kv[2].trim();
+    if (key === NOTE_ID_FRONTMATTER_KEY && UUID_RE.test(value)) noteId = value;
+    if (key === "title" && value) title = value;
+  }
+  return noteId ? { noteId, title } : void 0;
+}
+var FRONTMATTER_SAFE = /^[^:#\[\]{}'"*&,!?|>%@`\s][^:#\[\]{}"']*$/;
+function injectIdentityFrontmatter(markdown, identity) {
+  const stamp = (lines2) => {
+    const replaceOrInsert = (key, value) => {
+      if (value === void 0 || !FRONTMATTER_SAFE.test(value)) return;
+      const idx = lines2.findIndex((l) => l.startsWith(`${key}:`));
+      if (idx >= 0) lines2[idx] = `${key}: ${value}`;
+      else lines2.push(`${key}: ${value}`);
+    };
+    replaceOrInsert("title", identity.title);
+    replaceOrInsert(NOTE_ID_FRONTMATTER_KEY, identity.noteId);
+    return lines2;
+  };
+  const block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdown);
+  if (block) {
+    const lines2 = stamp(block[1].split(/\r?\n/));
+    return `---
+${lines2.join("\n")}
+---${markdown.slice(block[0].length)}`;
+  }
+  const lines = stamp([]);
+  return `---
+${lines.join("\n")}
+---
+
+${markdown}`;
+}
+function segmentToFragment(segment) {
+  if (segment.sourceContent !== void 0) return segment.sourceContent;
+  if (segment.dataType === "wod") {
+    const block = segment.data;
+    const dialect = block?.dialect ?? "time";
+    const fenceTag = block?.sport ? `${dialect}:${block.sport}` : dialect;
+    return `\`\`\`${fenceTag}
+${segment.rawContent}
+\`\`\``;
+  }
+  if (segment.dataType === "frontmatter") {
+    return `---
+${segment.rawContent}
+---`;
+  }
+  return segment.rawContent;
+}
+function composeNoteMarkdown(note, segments, version) {
+  const pool = version === void 0 ? segments.filter((s) => s.isHistory !== true) : segments;
+  const cap = version ?? Number.MAX_SAFE_INTEGER;
+  const bySegmentId = {};
+  for (const segment of pool) {
+    if (segment.version > cap) continue;
+    const current = bySegmentId[segment.id];
+    if (!current || segment.version > current.version) bySegmentId[segment.id] = segment;
+  }
+  const picked = Object.values(bySegmentId).sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
+  const markdown = picked.map(segmentToFragment).join("");
+  return injectIdentityFrontmatter(markdown, { noteId: note.id, title: note.title });
+}
+var FRONTMATTER_BLOCK_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+function readFrontmatterMeta(markdown) {
+  const match = FRONTMATTER_BLOCK_RE.exec(markdown);
+  if (!match) return {};
+  const meta = {};
+  const lines = match[1].split(/\r?\n/);
+  let currentListKey;
+  for (const rawLine of lines) {
+    const line = rawLine.trimEnd();
+    const item = line.match(/^\s+-\s+(.*)$/);
+    if (item && currentListKey) {
+      meta[currentListKey].push(item[1].trim());
+      continue;
+    }
+    const kv = line.match(/^([^:]+):\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1].trim().toLowerCase();
+    const value = kv[2].trim();
+    if (value === "") {
+      meta[key] = [];
+      currentListKey = key;
+    } else if (value.startsWith("[") && value.endsWith("]")) {
+      meta[key] = value.slice(1, -1).split(",").map((v) => v.trim().replace(/^['"]|['"]$/g, "")).filter((v) => v.length > 0);
+      currentListKey = void 0;
+    } else {
+      meta[key] = value;
+      currentListKey = void 0;
+    }
+  }
+  return meta;
+}
+var asList = (value) => Array.isArray(value) ? value : typeof value === "string" ? value.split(",").map((v) => v.trim()).filter((v) => v.length > 0) : [];
+function extractTypedTags(markdown, typedKeys = wodWikiWql.WQL_TYPED_TAG_KEYS) {
+  const meta = readFrontmatterMeta(markdown);
+  const results = asList(meta["tags"]).map((label) => ({ label }));
+  const metaKeys = Object.keys(meta);
+  for (const typeName of typedKeys) {
+    if (typeName === "tags") continue;
+    const matchedKey = metaKeys.find((k) => k === typeName.toLowerCase());
+    if (!matchedKey) continue;
+    for (const label of asList(meta[matchedKey])) {
+      results.push({ label, type: typeName });
+    }
+  }
+  return results.filter((t) => t.label.length > 0);
+}
+function markdownToEffort(raw) {
+  const match = FRONTMATTER_BLOCK_RE.exec(raw);
+  if (!match) return null;
+  const meta = readFrontmatterMeta(raw);
+  const body = raw.slice(match[0].length).trim();
+  const id = scalarOf(meta["id"]);
+  const slug = scalarOf(meta["slug"]);
+  const label = scalarOf(meta["label"]);
+  if (!id || !slug || !label) return null;
+  const baseAttributes = {};
+  const blockRe = /^\s{2,}([^:]+):\s*(.+)$/;
+  let inAttrs = false;
+  for (const line of match[1].split(/\r?\n/)) {
+    if (/^baseAttributes:/.test(line)) {
+      inAttrs = true;
+      continue;
+    }
+    if (inAttrs) {
+      const attr = blockRe.exec(line);
+      if (attr && /^ {2,}/.test(line)) {
+        const v = attr[2].trim();
+        baseAttributes[attr[1].trim()] = /^\d+(\.\d+)?$/.test(v) ? Number(v) : v;
+      } else if (/^\S/.test(line)) {
+        inAttrs = false;
+      }
+    }
+  }
+  if (typeof baseAttributes["met"] !== "number") return null;
+  return {
+    id,
+    slug,
+    label,
+    aliases: asList(meta["aliases"]),
+    baseAttributes,
+    ...body ? { body } : {}
+  };
+}
+function effortToMarkdown(effort) {
+  const lines = ["---", `id: ${effort.id}`, `slug: ${effort.slug}`, `label: ${effort.label}`];
+  if (effort.aliases && effort.aliases.length > 0) {
+    lines.push("aliases:");
+    for (const alias of effort.aliases) lines.push(`  - ${alias}`);
+  }
+  const attrs = Object.entries(effort.baseAttributes).filter(([, v]) => typeof v === "number" || typeof v === "string");
+  if (attrs.length > 0) {
+    lines.push("baseAttributes:");
+    for (const [k, v] of attrs) lines.push(`  ${k}: ${String(v)}`);
+  }
+  lines.push("---", "");
+  return `${lines.join("\n")}
+${(effort.body ?? "").trim()}`.trimEnd() + "\n";
+}
+function scalarOf(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function equipmentToCsv(labels) {
+  return ["label", ...labels].map((l) => escapeCsvField(l)).join("\n") + "\n";
+}
+function csvToEquipmentLabels(csv) {
+  const lines = splitCsvRecords(csv);
+  if (lines.length === 0) return [];
+  const header = parseCsvLine(lines[0]);
+  const labelIdx = header[0] === "label" ? 0 : -1;
+  const start = labelIdx >= 0 ? 1 : 0;
+  const labels = [];
+  for (const line of lines.slice(start)) {
+    const cells = parseCsvLine(line);
+    const label = (labelIdx >= 0 ? cells[0] : cells.join(",")).trim();
+    if (label) labels.push(label);
+  }
+  return [...new Set(labels)];
+}
+var SESSION_HEADER = [
+  "sessionId",
+  "noteId",
+  "segmentId",
+  "segmentVersion",
+  "blockId",
+  "blockContentId",
+  "origin",
+  "status",
+  "startTime",
+  "endTime",
+  "duration",
+  "completed",
+  "sessionCreatedAt"
+];
+var EVENT_HEADER = [
+  "eventId",
+  "grain",
+  "outputType",
+  "timestamp",
+  "pageId",
+  "effortSlug",
+  "eventSegmentId",
+  "eventSegmentVersion",
+  "eventBlockContentId",
+  "eventOrigin",
+  "timeSpan",
+  "sourceBlockKey",
+  "sourceStatementId",
+  "line",
+  "text",
+  "dialect",
+  "stackLevel",
+  "completionReason",
+  "representationKind",
+  "metricType",
+  "metricValue",
+  "metricUnit",
+  "metricImage",
+  "metricOrigin",
+  "metricMetadata",
+  "metricTemporal",
+  // Verbatim JSON backstops: make the machine round-trip lossless across
+  // schema fields that have no dedicated spreadsheet column. Explicit cells
+  // above still win on import, so hand-edited values are honored.
+  "metricJson",
+  "eventExtraJson"
+];
+var SESSION_CSV_HEADER = [...SESSION_HEADER, ...EVENT_HEADER];
+function escapeCsvField(field) {
+  if (field === void 0 || field === null) return "";
+  const str = typeof field === "object" ? JSON.stringify(field) : String(field);
+  if (str.includes(",") || str.includes('"') || str.includes("\n") || str.includes("\r")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+var metricValueToCell = (value) => {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+};
+var metricValueFromCell = (cell) => {
+  if (cell === "") return void 0;
+  if (/^-?\d+(\.\d+)?$/.test(cell)) return Number(cell);
+  if (cell === "true" || cell === "false") return cell === "true";
+  if (cell.startsWith("{") || cell.startsWith("[")) {
+    try {
+      return JSON.parse(cell);
+    } catch {
+      return cell;
+    }
+  }
+  return cell;
+};
+function sessionCells(session) {
+  return [
+    session.id,
+    session.noteId,
+    session.segmentId,
+    session.segmentVersion,
+    session.blockId,
+    session.blockContentId,
+    session.origin,
+    session.status,
+    session.startTime,
+    session.endTime,
+    session.duration,
+    session.completed,
+    session.createdAt
+  ].map(escapeCsvField);
+}
+function metricCells(event, metric, index) {
+  return [
+    event.id,
+    event.grain,
+    event.outputType,
+    event.timestamp,
+    event.pageId,
+    event.effortSlug,
+    event.segmentId,
+    event.segmentVersion,
+    event.blockContentId,
+    event.origin,
+    event.timeSpan,
+    event.sourceBlockKey,
+    event.sourceStatementId,
+    event.line,
+    event.text,
+    event.dialect,
+    event.stackLevel,
+    event.completionReason,
+    event.representationKind,
+    metric.type,
+    metricValueToCell(metric.value),
+    metric.unit,
+    metric.image,
+    metric.origin,
+    metric.metadata === void 0 ? "" : JSON.stringify(metric.metadata),
+    event.metricTemporal?.[index] === void 0 ? "" : JSON.stringify(event.metricTemporal[index]),
+    JSON.stringify(metric)
+  ].map(escapeCsvField);
+}
+function eventExtraCells(event) {
+  const { metrics: _metrics, ...rest } = event;
+  return escapeCsvField(JSON.stringify(rest));
+}
+function sessionToCsv(session, events) {
+  const lines = [SESSION_CSV_HEADER.join(",")];
+  lines.push([...sessionCells(session), ...EVENT_HEADER.map(() => "")].join(","));
+  const ordered = [...events].sort((a, b) => a.id.localeCompare(b.id));
+  for (const event of ordered) {
+    const extra = eventExtraCells(event);
+    const metrics = event.metrics ?? [];
+    if (metrics.length === 0) {
+      lines.push([...sessionCells(session), ...metricCells(event, { type: "" }, 0), extra].join(","));
+      continue;
+    }
+    for (let i = 0; i < metrics.length; i++) {
+      lines.push([...sessionCells(session), ...metricCells(event, metrics[i], i), extra].join(","));
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function parseCsvLine(line) {
+  const cells = [];
+  let current = "";
+  let quoted = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (quoted) {
+      if (ch === '"') {
+        if (line[i + 1] === '"') {
+          current += '"';
+          i += 1;
+        } else {
+          quoted = false;
+        }
+      } else {
+        current += ch;
+      }
+    } else if (ch === '"' && current === "") {
+      quoted = true;
+    } else if (ch === ",") {
+      cells.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  cells.push(current);
+  return cells;
+}
+function splitCsvRecords(csv) {
+  const records = [];
+  let current = "";
+  let quoted = false;
+  for (let i = 0; i < csv.length; i++) {
+    const ch = csv[i];
+    if (ch === '"') {
+      if (quoted && csv[i + 1] === '"') {
+        current += '""';
+        i += 1;
+        continue;
+      }
+      quoted = !quoted;
+      current += ch;
+    } else if (!quoted && (ch === "\n" || ch === "\r")) {
+      if (ch === "\r" && csv[i + 1] === "\n") i += 1;
+      if (current.length > 0) records.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
   }
-  return facts;
+  if (current.length > 0) records.push(current);
+  return records;
 }
-function extractPayload(rawJson) {
+var num = (cell) => cell === "" ? void 0 : Number(cell);
+var nonempty = (cell) => cell === "" ? void 0 : cell;
+function jsonCell(cell) {
+  if (!cell) return void 0;
   try {
-    const parsed = JSON.parse(rawJson);
-    if (isIRFile(parsed)) {
-      return parsed.data;
+    return JSON.parse(cell);
+  } catch {
+    return void 0;
+  }
+}
+function csvToSessionRows(csv) {
+  const lines = splitCsvRecords(csv);
+  if (lines.length < 2) throw new Error("[wod import] Session CSV has no data rows");
+  const header = parseCsvLine(lines[0]);
+  const col = (name) => {
+    const idx = header.indexOf(name);
+    if (idx < 0) throw new Error(`[wod import] Session CSV missing column "${name}"`);
+    return idx;
+  };
+  const at = (cells, name) => cells[col(name)] ?? "";
+  const eventRows = /* @__PURE__ */ new Map();
+  let session;
+  const ensureSession = (cells) => {
+    if (session) return session;
+    session = {
+      id: at(cells, "sessionId"),
+      noteId: at(cells, "noteId"),
+      segmentId: at(cells, "segmentId") || void 0,
+      segmentVersion: num(at(cells, "segmentVersion")),
+      blockId: at(cells, "blockId") || void 0,
+      blockContentId: at(cells, "blockContentId") || void 0,
+      origin: at(cells, "origin") || void 0,
+      status: at(cells, "status") || void 0,
+      startTime: Number(at(cells, "startTime") || 0),
+      endTime: Number(at(cells, "endTime") || 0),
+      duration: Number(at(cells, "duration") || 0),
+      completed: at(cells, "completed") === "true",
+      createdAt: Number(at(cells, "sessionCreatedAt") || 0)
+    };
+    return session;
+  };
+  for (const line of lines.slice(1)) {
+    const cells = parseCsvLine(line);
+    if (cells.length === 1 && cells[0] === "") continue;
+    const currentSession = ensureSession(cells);
+    const eventId = at(cells, "eventId");
+    if (!eventId) continue;
+    let event = eventRows.get(eventId);
+    if (!event) {
+      const extra = jsonCell(at(cells, "eventExtraJson")) ?? {};
+      event = {
+        ...extra,
+        id: eventId,
+        resultId: currentSession.id,
+        noteId: nonempty(at(cells, "noteId")) ?? extra.noteId ?? currentSession.noteId,
+        blockContentId: nonempty(at(cells, "eventBlockContentId")) ?? extra.blockContentId,
+        pageId: nonempty(at(cells, "pageId")) ?? extra.pageId,
+        origin: nonempty(at(cells, "eventOrigin")) ?? extra.origin,
+        timestamp: Number(at(cells, "timestamp") || extra.timestamp || 0),
+        grain: nonempty(at(cells, "grain")) ?? extra.grain ?? "event",
+        effortSlug: nonempty(at(cells, "effortSlug")) ?? extra.effortSlug,
+        outputType: nonempty(at(cells, "outputType")) ?? extra.outputType ?? "event",
+        segmentId: nonempty(at(cells, "eventSegmentId")) ?? extra.segmentId,
+        segmentVersion: num(at(cells, "eventSegmentVersion")) ?? extra.segmentVersion,
+        timeSpan: jsonCell(at(cells, "timeSpan")) ?? extra.timeSpan,
+        sourceBlockKey: nonempty(at(cells, "sourceBlockKey")) ?? extra.sourceBlockKey,
+        sourceStatementId: num(at(cells, "sourceStatementId")) ?? extra.sourceStatementId,
+        line: num(at(cells, "line")) ?? extra.line,
+        text: nonempty(at(cells, "text")) ?? extra.text,
+        dialect: nonempty(at(cells, "dialect")) ?? extra.dialect,
+        stackLevel: num(at(cells, "stackLevel")) ?? extra.stackLevel,
+        completionReason: nonempty(at(cells, "completionReason")) ?? extra.completionReason,
+        representationKind: nonempty(at(cells, "representationKind")) ?? extra.representationKind,
+        metrics: [],
+        // Rebuilt per-row from the metricTemporal column below — never
+        // inherited from the backstop, or rows would double-collect.
+        metricTemporal: void 0
+      };
+      eventRows.set(eventId, event);
+    }
+    const metricType = at(cells, "metricType");
+    if (!metricType) continue;
+    const baseMetric = jsonCell(at(cells, "metricJson")) ?? {};
+    const metric = {
+      ...baseMetric,
+      type: metricType,
+      ...at(cells, "metricValue") !== "" ? { value: metricValueFromCell(at(cells, "metricValue")) } : {},
+      ...nonempty(at(cells, "metricUnit")) ? { unit: at(cells, "metricUnit") } : {},
+      ...nonempty(at(cells, "metricImage")) ? { image: at(cells, "metricImage") } : {},
+      ...nonempty(at(cells, "metricOrigin")) ? { origin: at(cells, "metricOrigin") } : {},
+      ...at(cells, "metricMetadata") !== "" ? { metadata: jsonCell(at(cells, "metricMetadata")) } : {}
+    };
+    event.metrics.push(metric);
+    const temporal = jsonCell(at(cells, "metricTemporal"));
+    if (temporal !== void 0) {
+      (event.metricTemporal ??= []).push(temporal);
     }
-    return parsed;
-  } catch (err) {
-    throw new Error(`Failed to parse JSON input: ${err instanceof Error ? err.message : String(err)}`);
   }
+  if (!session) throw new Error("[wod import] Session CSV did not contain session columns");
+  return { session, events: [...eventRows.values()] };
 }
-function buildStoresFromData(data) {
-  const identity = (r) => ({
-    noteId: r.noteId,
-    resultId: r.id,
-    segmentId: r.segmentId,
-    segmentVersion: r.segmentVersion,
-    blockContentId: r.blockContentId,
-    origin: r.origin,
-    pageId: r.pageId,
-    workoutTimestamp: r.createdAt
-  });
-  const events = [
-    ...factRowsToEventRows(data.facts),
-    ...data.results.flatMap((r) => {
-      const logs = r.data.logs ?? [];
-      return [...wodWikiWql.toEventRows(logs, identity(r)), ...wodWikiWql.toSummaryEventRows(logs, identity(r))];
-    })
-  ];
-  const eventStore = inMemoryEventStore(events);
-  const noteStore = {
-    getAllNotes: async () => [...data.notes],
-    getNoteIdsForTag: async (tag) => {
-      const matching = /* @__PURE__ */ new Set();
-      for (const [noteId, tags] of Object.entries(data.noteTags)) {
-        if (tags.includes(tag)) matching.add(noteId);
-      }
-      return matching;
+
+// src/cli/seed.ts
+var SEED_NAMESPACE = "1b671a64-40d5-491e-99b0-da01ff1f3341";
+var SEED_SCHEMA = 7;
+var CANVAS_CHUNK_ID = "canvas";
+var DASHBOARDS_CHUNK_ID = "dashboards";
+var EFFORTS_CHUNK_ID = "efforts";
+var TEMPLATE_CHUNK_ID = "template";
+var scalarOf2 = (value) => typeof value === "string" ? value : void 0;
+function seedNoteId(path) {
+  return formatV5Digest(nodeCrypto().createHash("sha1").update(`${SEED_NAMESPACE}:${path}`).digest());
+}
+function titleFromPath(path) {
+  const stem = path.split("/").pop() ?? path;
+  return stem.replace(/\.md$/, "").replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function catalogForChunkId(chunkId) {
+  const match = /^(?:collection|feed)\.(.+)$/.exec(chunkId);
+  const value = match?.[1];
+  return value && value !== "_root" ? value : void 0;
+}
+function canvasRouteSlug(content) {
+  const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+  if (fm?.[1] && !/^template:\s*canvas\s*$/m.test(fm[1])) return null;
+  const route = fm?.[1]?.match(/^route:\s*(\S+)\s*$/m)?.[1];
+  if (!route) return null;
+  return route.replace(/^\//, "") || null;
+}
+function seedNoteSourceId(path, content, chunkId) {
+  const parts = path.split("/");
+  const stem = (parts[parts.length - 1] ?? "").replace(/\.md$/i, "");
+  const under = parts.slice(2).map((p) => p.replace(/\.md$/i, "")).join("/");
+  if (chunkId === CANVAS_CHUNK_ID) {
+    const route = canvasRouteSlug(content);
+    return route ? `guides:${route}` : `guides:${under}`;
+  }
+  if (chunkId === DASHBOARDS_CHUNK_ID) return "dashboards";
+  if (chunkId === EFFORTS_CHUNK_ID) return "efforts";
+  if (chunkId === TEMPLATE_CHUNK_ID) return "playground";
+  if (chunkId.startsWith("collection.")) {
+    const catalog = catalogForChunkId(chunkId);
+    if (!catalog) return "collection:_root";
+    return stem.toLowerCase() === "readme" ? `collection:${catalog}` : `collection:${catalog}/${stem}`;
+  }
+  if (chunkId.startsWith("feed.")) return `feed:feeds/${under}`;
+  return void 0;
+}
+function buildNoteRecord(row, chunkId, seedVersion) {
+  const id = seedNoteId(row.path);
+  const createdAt = seedVersion;
+  const meta = readFrontmatterMeta(row.content);
+  const tags = extractTypedTags(row.content);
+  let date;
+  let page;
+  let pageNote;
+  const rawDate = scalarOf2(meta["date"]);
+  if (rawDate && /^\d{4}-\d{2}-\d{2}$/.test(rawDate)) {
+    date = (/* @__PURE__ */ new Date(`${rawDate}T12:00:00Z`)).getTime();
+  }
+  const slug = scalarOf2(meta["slug"]);
+  if (slug) {
+    const pageId = seedNoteId(`page:${slug}`);
+    page = { id: pageId, slug, title: titleFromPath(row.path), createdAt };
+    pageNote = { id: seedNoteId(`pagenote:${slug}:${row.path}`), pageId, noteId: id, createdAt };
+  }
+  const sourceId = seedNoteSourceId(row.path, row.content, chunkId);
+  if (!sourceId) {
+    throw new Error(`[wod seed] chunk "${chunkId}" row "${row.path}" has no source family \u2014 refusing to import it as journal`);
+  }
+  const metaTitle = scalarOf2(meta["title"]);
+  return {
+    note: {
+      id,
+      title: metaTitle?.trim() || titleFromPath(row.path),
+      date,
+      createdAt,
+      type: chunkId === DASHBOARDS_CHUNK_ID ? "dashboard" : "note",
+      sourceId,
+      catalog: catalogForChunkId(chunkId),
+      seedOrigin: "seed",
+      seedVersion,
+      seedChunkId: chunkId,
+      sourcePath: row.path
     },
-    getNoteTagLabels: async (noteId) => [...data.noteTags[noteId] ?? []]
-  };
-  const blockStore = {
-    getAllBlocks: async () => [...data.blocks]
+    segment: {
+      id: `seed:${id}`,
+      version: 1,
+      noteId: id,
+      position: 0,
+      dataType: "markdown",
+      data: null,
+      rawContent: row.content,
+      createdAt
+    },
+    tags,
+    page,
+    pageNote,
+    rawContent: row.content,
+    sourcePath: row.path
   };
-  const effortStore = {
-    getAllEfforts: async () => [...data.efforts]
+}
+async function metaRecord(sql, db, sourceId) {
+  const rows = await sql.listRows(db, sql.storeDefinition("meta"));
+  const existing = rows.find((r) => r.key === `seed:${sourceId}`);
+  return existing ?? {
+    key: `seed:${sourceId}`,
+    schema: SEED_SCHEMA,
+    seedVersion: 0,
+    builtAt: "",
+    importedAt: 0,
+    chunks: {},
+    claim: null
   };
-  return { eventStore, noteStore, blockStore, effortStore };
 }
-function loadQueryData(options) {
-  const data = {
-    facts: [],
-    results: [],
-    notes: [],
-    blocks: [],
-    efforts: [...wodWikiLang.bundledEfforts],
-    noteTags: {}
+async function applyOps(db, ops) {
+  if (ops.length === 0) return;
+  const sql = await loadSql();
+  await db.db.transaction(async (tx) => {
+    await sql.refreshDomain(tx, ops);
+  });
+}
+async function importSeedDir(db, dir, sourceId) {
+  const sql = await loadSql();
+  const fs = nodeFs();
+  const source = sourceId || nodePath().basename(dir);
+  const manifest = JSON.parse(fs.readFileSync(nodePath().resolve(dir, "manifest.json"), "utf-8"));
+  const prior = await metaRecord(sql, db.db, source);
+  const notesById = new Map(
+    (await sql.listRows(db.db, sql.storeDefinition("notes"))).map((row) => [row.id, row])
+  );
+  const tagRowByLabel = new Map(
+    (await sql.listRows(db.db, sql.storeDefinition("tags"))).map((t) => [t.label, t])
+  );
+  const summary = {
+    sourceId: source,
+    version: manifest.version,
+    notes: 0,
+    efforts: 0,
+    blocks: 0,
+    blockEfforts: 0,
+    deleted: 0,
+    skippedUserOwned: 0
   };
-  if (options.corpusPath) {
-    const fs = getFs();
-    if (!fs.existsSync(options.corpusPath)) {
-      throw new Error(`Corpus file not found at path: ${options.corpusPath}`);
-    }
-    const raw = fs.readFileSync(options.corpusPath, "utf-8");
-    const payload = extractPayload(raw);
-    if (Array.isArray(payload)) {
-      data.facts = payload;
-    } else if (payload && typeof payload === "object") {
-      const corpus = payload;
-      if (corpus.facts) data.facts = corpus.facts;
-      if (corpus.results) data.results = corpus.results;
-      if (corpus.notes) data.notes = corpus.notes;
-      if (corpus.blocks) data.blocks = corpus.blocks;
-      if (corpus.efforts) data.efforts = corpus.efforts;
-      if (corpus.tags) data.noteTags = corpus.tags;
-      if (corpus.logs && (!corpus.results || corpus.results.length === 0)) {
-        const syntheticResult = {
-          id: "corpus-result-1",
-          noteId: "corpus-note-1",
-          blockContentId: "corpus-block-1",
-          origin: "journal",
-          createdAt: corpus.logs[0]?.timeSpan?.started ?? Date.now(),
-          data: {
-            startTime: corpus.logs[0]?.timeSpan?.started ?? Date.now(),
-            endTime: corpus.logs[corpus.logs.length - 1]?.timeSpan?.ended ?? Date.now(),
-            duration: 0,
-            completed: true,
-            logs: corpus.logs
+  const nextMeta = {
+    ...prior,
+    schema: SEED_SCHEMA,
+    seedVersion: manifest.version,
+    builtAt: manifest.builtAt,
+    importedAt: Date.now(),
+    chunks: {}
+  };
+  const ordered = [
+    ...manifest.chunks.filter((c) => (c.kind ?? "notes") === "notes"),
+    ...manifest.chunks.filter((c) => c.kind === "block-index"),
+    ...manifest.chunks.filter((c) => c.kind === "block-efforts")
+  ];
+  const bySourcePath = /* @__PURE__ */ new Map();
+  const noteIdsByChunk = {};
+  const blockIdsByChunk = {};
+  for (const chunk of ordered) {
+    const payload = JSON.parse(fs.readFileSync(nodePath().resolve(dir, chunk.path), "utf-8"));
+    const ops = [];
+    if ((chunk.kind ?? "notes") === "notes") {
+      const rows2 = payload;
+      const built = rows2.map((row) => buildNoteRecord(row, chunk.id, manifest.version));
+      const noteIds = [];
+      for (const record of built) {
+        bySourcePath.set(record.sourcePath, record.note.id);
+        const existing = notesById.get(record.note.id);
+        if (existing && existing.seedOrigin !== "seed") {
+          summary.skippedUserOwned += 1;
+          continue;
+        }
+        noteIds.push(record.note.id);
+        ops.push({ op: "put", store: "notes", value: record.note });
+        ops.push({ op: "put", store: "segments", value: record.segment });
+        if (record.page) ops.push({ op: "put", store: "page", value: record.page });
+        if (record.pageNote) ops.push({ op: "put", store: "page_notes", value: record.pageNote });
+        for (const item of record.tags) {
+          const label = item.label;
+          let tag = tagRowByLabel.get(label);
+          if (!tag) {
+            tag = { id: randomId(), label, type: item.type, createdAt: Date.now() };
+            tagRowByLabel.set(label, tag);
+            ops.push({ op: "put", store: "tags", value: tag });
+          } else if (item.type && !tag.type) {
+            tag = { ...tag, type: item.type };
+            tagRowByLabel.set(label, tag);
+            ops.push({ op: "put", store: "tags", value: tag });
+          }
+          const tagId = tag.id;
+          ops.push({
+            op: "put",
+            store: "note_tags",
+            // Deterministic junction id — re-seeds must upsert the same row
+            // (note_tags has a unique [noteId, tagId] index).
+            value: { id: uuid5(CLI_UUID_NAMESPACE, `note-tag:${record.note.id}:${tagId}`), noteId: record.note.id, tagId }
+          });
+        }
+        if (chunk.id === EFFORTS_CHUNK_ID) {
+          const effort = markdownToEffort(record.rawContent);
+          if (effort) {
+            ops.push({ op: "put", store: "efforts", value: { ...effort, registrySource: "bundled" } });
+            summary.efforts += 1;
           }
-        };
-        data.results = [syntheticResult];
+        }
       }
+      const priorIds = prior.chunks[chunk.id]?.noteIds ?? [];
+      const goneIds = priorIds.filter((id) => !noteIds.includes(id) && notesById.get(id)?.seedOrigin === "seed");
+      for (const id of goneIds) {
+        ops.push(...await noteCascadeOps(sql, db, id));
+        summary.deleted += 1;
+      }
+      noteIdsByChunk[chunk.id] = rows2.map((row) => seedNoteId(row.path));
+      nextMeta.chunks[chunk.id] = { sha256: chunk.sha256, noteIds: noteIdsByChunk[chunk.id] };
+      summary.notes += noteIds.length;
+      await applyOps(db, ops);
+      continue;
     }
-  } else if (options.stdinLog) {
-    const payload = extractPayload(options.stdinLog);
-    let executionLog;
-    const rawLogs = payload.logs ?? payload.statements ?? [];
-    if ("results" in payload) {
-      executionLog = { results: payload.results, logs: rawLogs, statements: rawLogs };
-    } else {
-      executionLog = { results: payload, logs: rawLogs, statements: rawLogs };
-    }
-    const resultId = "stdin-result-1";
-    const workoutResult = {
-      id: resultId,
-      noteId: "stdin-note-1",
-      blockContentId: "stdin-block-1",
-      origin: "journal",
-      createdAt: executionLog.results.startTime,
-      data: {
-        ...executionLog.results,
-        logs: executionLog.logs
+    const rows = payload.filter((row) => row.isStatic === true);
+    const rekeyed = rows.map((row) => {
+      const noteId = row.sourcePath ? bySourcePath.get(row.sourcePath) : void 0;
+      if (!noteId) {
+        throw new Error(
+          `[wod seed] static row ${row.id}: sourcePath "${row.sourcePath ?? ""}" has no imported note \u2014 chunk aborted`
+        );
+      }
+      return chunk.kind === "block-efforts" ? { ...row, noteId } : { ...row, noteId, routeId: row.noteId };
+    });
+    const store = chunk.kind === "block-index" ? "block_index" : "block_efforts";
+    for (const row of rekeyed) ops.push({ op: "put", store, value: row });
+    const priorBlockIds = prior.chunks[chunk.id]?.blockIds ?? [];
+    const writtenIds = new Set(rekeyed.map((row) => row.id));
+    const goneBlocks = priorBlockIds.filter((id) => !writtenIds.has(id));
+    for (const id of goneBlocks) ops.push({ op: "delete", store, key: id });
+    summary.deleted += goneBlocks.length;
+    blockIdsByChunk[chunk.id] = payload.map((row) => row.id);
+    nextMeta.chunks[chunk.id] = { sha256: chunk.sha256, blockIds: blockIdsByChunk[chunk.id] };
+    if (chunk.kind === "block-index") summary.blocks += rekeyed.length;
+    else summary.blockEfforts += rekeyed.length;
+    await applyOps(db, ops);
+  }
+  const manifestIds = new Set(manifest.chunks.map((c) => c.id));
+  for (const [chunkId, checkpoint] of Object.entries(prior.chunks)) {
+    if (manifestIds.has(chunkId)) continue;
+    const sweep = [];
+    for (const id of checkpoint.noteIds ?? []) {
+      if (notesById.get(id)?.seedOrigin === "seed") {
+        sweep.push(...await noteCascadeOps(sql, db, id));
+        summary.deleted += 1;
       }
-    };
-    data.results = [workoutResult];
-    data.facts = factsFromExecutionLog(executionLog, resultId);
-  } else if (options.stdinFacts) {
-    const payload = extractPayload(options.stdinFacts);
-    if (Array.isArray(payload)) {
-      data.facts = payload;
-    } else if (payload && typeof payload === "object" && "facts" in payload) {
-      data.facts = payload.facts;
     }
-  } else {
-    throw new Error("No input dataset provided. Specify --corpus <path>, --stdin-log, or --stdin-facts.");
+    for (const id of checkpoint.blockIds ?? []) {
+      sweep.push({ op: "delete", store: "block_index", key: id });
+      summary.deleted += 1;
+    }
+    await applyOps(db, sweep);
   }
-  return data;
+  await applyOps(db, [{ op: "put", store: "meta", value: nextMeta }]);
+  return summary;
 }
-async function runQueryCli(wqlString, options = {}) {
-  const parsed = wodWikiWql.parseQuery(wqlString);
-  if (parsed.error) {
-    throw new WqlSyntaxError(wqlString, parsed.error);
-  }
-  const stores = buildStoresFromData(loadQueryData(options));
-  const service = new wodWikiWql.QueryService(
-    stores.eventStore,
-    stores.noteStore,
-    stores.blockStore,
-    stores.effortStore
-  );
-  if (wodWikiWql.isFindQuery(parsed)) {
-    const result2 = await service.runFind(parsed);
-    return createIRFile("find-result", result2, { source: options.sourceLabel ?? "cli:wod query" });
-  }
-  if (wodWikiWql.isRowsQuery(parsed)) {
-    const result2 = await service.runRows(parsed);
-    return createIRFile("rows-result", result2, { source: options.sourceLabel ?? "cli:wod query" });
+async function noteCascadeOps(sql, db, noteId) {
+  const ops = [{ op: "delete", store: "notes", key: noteId }];
+  for (const store of ["segments", "block_index", "block_efforts", "note_tags"]) {
+    const rows = await sql.listRows(db.db, sql.storeDefinition(store), { only: noteId }, void 0, "by-note");
+    for (const row of rows) {
+      ops.push({ op: "delete", store, key: store === "segments" ? [row.id, row.version ?? 1] : row.id });
+    }
   }
-  const result = await service.runQuery(wqlString, {
-    preferredUnit: options.preferredUnit
-  });
-  return createIRFile("query-result", result, { source: options.sourceLabel ?? "cli:wod query" });
+  return ops;
+}
+function defaultSeedDirs(cwd) {
+  const base = nodePath().resolve(cwd, "apps", "playground", "public", "seed");
+  return ["core", "community"].map((id) => nodePath().resolve(base, id)).filter((dir) => nodeFs().existsSync(nodePath().resolve(dir, "manifest.json")));
 }
 
 // src/cli/formatters.ts
-function escapeCsvField(field) {
+function escapeCsvField2(field) {
   if (field === void 0 || field === null) return "";
   const str = String(field);
   if (str.includes(",") || str.includes('"') || str.includes("\n") || str.includes("\r")) {
@@ -538,9 +2619,9 @@ function formatParseOutput(ir, format, pretty = true) {
         n.type,
         n.from,
         n.to,
-        escapeCsvField(n.raw),
-        escapeCsvField(n.metrics.map(formatMetric).join("; ")),
-        escapeCsvField(n.hints?.join("; ") ?? "")
+        escapeCsvField2(n.raw),
+        escapeCsvField2(n.metrics.map(formatMetric).join("; ")),
+        escapeCsvField2(n.hints?.join("; ") ?? "")
       ].join(",")
     );
     return [header, ...rows].join("\n");
@@ -581,11 +2662,11 @@ function formatExecutionOutput(ir, format, pretty = true) {
         s.outputType,
         s.timeSpan?.started ?? s.timestamp ?? 0,
         s.timeSpan?.ended ?? "",
-        escapeCsvField(s.sourceBlockKey),
+        escapeCsvField2(s.sourceBlockKey),
         s.stackLevel,
-        escapeCsvField(s.completionReason ?? ""),
-        escapeCsvField(s.metrics.map(formatMetric).join("; ")),
-        escapeCsvField(s.hints?.join("; ") ?? "")
+        escapeCsvField2(s.completionReason ?? ""),
+        escapeCsvField2(s.metrics.map(formatMetric).join("; ")),
+        escapeCsvField2(s.hints?.join("; ") ?? "")
       ].join(",")
     );
     return [header, ...rows].join("\n");
@@ -634,7 +2715,7 @@ function formatQueryOutput(ir, format, pretty = true) {
               run.timestamp,
               event.outputType,
               event.id,
-              escapeCsvField(event.metrics.map(formatMetric).join("; "))
+              escapeCsvField2(event.metrics.map(formatMetric).join("; "))
             ].join(",")
           );
         }
@@ -666,13 +2747,13 @@ function formatQueryOutput(ir, format, pretty = true) {
       const header = "target,id,title_or_label,sourceId";
       const rows = [];
       for (const n of data2.notes) {
-        rows.push(["note", n.id, escapeCsvField(n.title), escapeCsvField(n.sourceId ?? "")].join(","));
+        rows.push(["note", n.id, escapeCsvField2(n.title), escapeCsvField2(n.sourceId ?? "")].join(","));
       }
       for (const b of data2.blocks) {
-        rows.push(["block", b.id, escapeCsvField(b.noteTitle), escapeCsvField(b.sourceId ?? "")].join(","));
+        rows.push(["block", b.id, escapeCsvField2(b.noteTitle), escapeCsvField2(b.sourceId ?? "")].join(","));
       }
       for (const e of data2.efforts ?? []) {
-        rows.push(["effort", e.id, escapeCsvField(e.label), escapeCsvField(e.slug)].join(","));
+        rows.push(["effort", e.id, escapeCsvField2(e.label), escapeCsvField2(e.slug)].join(","));
       }
       return [header, ...rows].join("\n");
     }
@@ -694,11 +2775,48 @@ function formatQueryOutput(ir, format, pretty = true) {
     }
     return lines2.join("\n");
   }
+  if (kind === "pipeline-result") {
+    const data2 = ir.data;
+    const sink = data2.chart ? `:${data2.chart.head}` : "data";
+    if (format === "csv") {
+      const header = "series,timestamp,date,value,unit";
+      const rows = [];
+      for (const s of data2.series ?? []) {
+        for (const pt of s.points) {
+          rows.push(
+            [
+              escapeCsvField2(s.label || s.key),
+              pt.ts,
+              formatDate(pt.ts),
+              pt.value,
+              escapeCsvField2(s.unit ?? data2.unit ?? "")
+            ].join(",")
+          );
+        }
+      }
+      return [header, ...rows].join("\n");
+    }
+    const lines2 = [];
+    if (data2.error) lines2.push(`Pipeline Error: ${data2.error}`);
+    lines2.push(`Pipeline Result (\u2192 ${sink}):`);
+    lines2.push("\u2500".repeat(80));
+    if (data2.table) {
+      lines2.push(`Table: ${data2.table.rows.length} of ${data2.table.totalCount} rows`);
+    }
+    for (const s of data2.series ?? []) {
+      lines2.push(`${s.label || s.key}: ${s.points.length} points${s.unit ? ` (${s.unit})` : ""}`);
+    }
+    if (data2.notes?.length) lines2.push(`notes: ${data2.notes.length}`);
+    if (data2.blocks?.length) lines2.push(`blocks: ${data2.blocks.length}`);
+    if (data2.efforts?.length) lines2.push(`efforts: ${data2.efforts.length}`);
+    if (data2.runs?.length) lines2.push(`runs: ${data2.runs.length}`);
+    return lines2.join("\n");
+  }
   const data = ir.data;
   if (data.scalar !== void 0 && data.series.length === 0) {
     if (format === "csv") {
       return `metric,scalar,unit
-${escapeCsvField(data.parsed.metric)},${data.scalar},${escapeCsvField(data.unit ?? "")}`;
+${escapeCsvField2(data.parsed.metric)},${data.scalar},${escapeCsvField2(data.unit ?? "")}`;
     }
     return `Scalar Result: ${data.scalar}${data.unit ? " " + data.unit : ""}`;
   }
@@ -709,11 +2827,11 @@ ${escapeCsvField(data.parsed.metric)},${data.scalar},${escapeCsvField(data.unit
       for (const pt of s.points) {
         rows.push(
           [
-            escapeCsvField(s.label || s.key),
+            escapeCsvField2(s.label || s.key),
             pt.ts,
             formatDate(pt.ts),
             pt.value,
-            escapeCsvField(s.unit ?? data.unit ?? "")
+            escapeCsvField2(s.unit ?? data.unit ?? "")
           ].join(",")
         );
       }
@@ -754,7 +2872,8 @@ var VERSION = "0.6.0";
 function parseCliArgs(args) {
   const result = {
     format: "json",
-    packs: []
+    packs: [],
+    sources: []
   };
   let i = 0;
   while (i < args.length) {
@@ -805,8 +2924,54 @@ function parseCliArgs(args) {
     } else if (arg === "--unit") {
       result.unit = args[++i];
       i++;
+    } else if (arg === "--db") {
+      result.db = args[++i];
+      i++;
+    } else if (arg.startsWith("--db=")) {
+      result.db = arg.slice("--db=".length);
+      i++;
+    } else if (arg === "--debug") {
+      result.debug = "";
+      i++;
+    } else if (arg.startsWith("--debug=")) {
+      result.debug = arg.slice("--debug=".length);
+      i++;
+    } else if (arg === "--at") {
+      result.at = args[++i];
+      i++;
+    } else if (arg.startsWith("--at=")) {
+      result.at = arg.slice("--at=".length);
+      i++;
+    } else if (arg === "--source") {
+      const source = args[++i];
+      if (source) result.sources.push(source);
+      i++;
+    } else if (arg.startsWith("--source=")) {
+      result.sources.push(arg.slice("--source=".length));
+      i++;
+    } else if (arg === "--scaffold") {
+      result.scaffold = true;
+      i++;
+    } else if (arg === "--template") {
+      result.template = args[++i];
+      i++;
+    } else if (arg.startsWith("--template=")) {
+      result.template = arg.slice("--template=".length);
+      i++;
+    } else if (arg === "--out") {
+      result.output = args[++i];
+      i++;
+    } else if (arg.startsWith("--out=")) {
+      result.output = arg.slice("--out=".length);
+      i++;
+    } else if (arg === "--dir") {
+      result.dir = args[++i];
+      i++;
+    } else if (arg.startsWith("--dir=")) {
+      result.dir = arg.slice("--dir=".length);
+      i++;
     } else if (!result.subcommand) {
-      if (arg === "parse" || arg === "run" || arg === "query" || arg === "help" || arg === "version") {
+      if (arg === "parse" || arg === "run" || arg === "query" || arg === "download" || arg === "import" || arg === "build" || arg === "seed" || arg === "reset" || arg === "help" || arg === "version") {
         result.subcommand = arg;
       } else {
         result.target = arg;
@@ -815,16 +2980,32 @@ function parseCliArgs(args) {
     } else if (!result.target) {
       result.target = arg;
       i++;
+    } else if (!result.target2) {
+      result.target2 = arg;
+      i++;
     } else {
       i++;
     }
   }
   return result;
 }
-async function readStdin() {
-  if (typeof globalThis.Bun?.stdin?.text === "function") {
-    return globalThis.Bun.stdin.text();
+function readBunStdinText() {
+  const g = globalThis;
+  if (g && typeof g === "object" && "Bun" in g) {
+    const bun = g.Bun;
+    if (bun && typeof bun === "object" && "stdin" in bun) {
+      const stdin = bun.stdin;
+      if (stdin && typeof stdin === "object" && "text" in stdin) {
+        const text = stdin.text;
+        if (typeof text === "function") return text;
+      }
+    }
   }
+  return void 0;
+}
+async function readStdin() {
+  const bunText = readBunStdinText();
+  if (bunText) return bunText();
   return new Promise((resolve, reject) => {
     const chunks = [];
     process.stdin.on("data", (chunk) => {
@@ -846,20 +3027,84 @@ USAGE:
   wod parse <file | -> [options]
   wod run <file | -> [options]
   wod query '<wql-string>' [options]
+  wod download <note|session|effort|equipment> <id> [options]
+  wod import <note|session|effort|equipment> <file> [options]
+  wod build [dir] [options]
+  wod seed [options]
+  wod reset [options]
 
 SUBCOMMANDS:
-  parse <file | ->    Parse Whiteboard Script into AST StatementNode IR (kind: 'parse-tree')
-  run <file | ->      Execute Whiteboard Script state machine and emit ExecutionLog IR (kind: 'execution-log')
-  query '<wql>'       Evaluate WQL query and emit QueryResult / RowsQueryResult / FindQueryResult IR
+  parse <file | ->    Parse Whiteboard Script, create a note in the database
+                     (segments + block index), optionally emit parse-tree IR.
+                     Markdown carrying a 'wod-note-id' frontmatter stamp
+                     (see download) imports back into that same note.
+  run <file | ->      Execute the script state machine, record a session +
+                     event/summary rows in the database, optionally emit
+                     execution-log IR
+  query '<wql>'       Evaluate WQL against the database (or an explicit
+                     dataset) and emit QueryResult / RowsQueryResult IR
+  download note <id>  Compose the note's markdown from its segment rows and
+                     write it to <id>.md. Use --at <version> to compose
+                     as-of a segment version (default: latest). The stamp
+                     in the frontmatter makes 'wod parse' re-import it.
+                     Frontmatter tags (general + typed equipment/quality/\u2026)
+                     are materialized into the tag graph on parse/import.
+  download session <id>
+                     Write the session's generated metrics (event + summary
+                     rows, one CSV row per metric) to <id>.csv. Import back
+                     with 'wod import session'.
+  download effort <slug>
+                     Write the effort registry row as corpus-style markdown
+                     (frontmatter id/slug/label/aliases/baseAttributes + body)
+                     to <slug>.md. Import back with 'wod import effort'.
+  download equipment
+                     Write every equipment tag as a one-column CSV to
+                     equipment.csv. Import back with 'wod import equipment'.
+  import note <file>  Re-import exported note markdown (same as parse with
+                     the stamped identity).
+  import session <file>
+                     Recreate a session + its events from a downloaded CSV
+                     into the same or a clean database (id-keyed upsert).
+  import effort <file>
+                     Upsert an effort registry row from corpus-style markdown.
+  import equipment <file>
+                     Create/upgrade equipment tags (CSV, one label per row).
+  build [dir]         Compile a seed corpus: validate every .md under
+                     <dir>/markdown (parity gate + dashboard format gate) and
+                     write manifest.json + content-hashed chunks/ +
+                     block-parent-map.json + report.html to <dir>/dist
+                     (override with -o/--output). Version stamps derive from
+                     <dir>'s git history (full checkout required).
+
+BUILD OPTIONS (for 'build'):
+  --scaffold          Also scaffold markdown/efforts/discovered/*.md stubs for
+                      workout effort labels missing from the registry.
+  --template <file>   Compile an extra markdown file as the 'template' chunk
+                      (the host's playground intake template).
 
-INPUT SOURCING (for 'query'):
+INPUT SOURCING (for 'query'; without these, the database is queried):
   -c, --corpus <path> Load historical corpus dataset from a versioned JSON file
   --stdin-log         Read kind: 'execution-log' JSON payload from stdin
   --stdin-facts       Read raw kind: 'fact-set' JSON payload from stdin
 
+DATABASE (parse / run / query / download / import / seed / reset):
+  --db <path>         SQLite database file (default: $WOD_WIKI_DB or
+                      ./wodwiki.db). Created on demand by parse/run/seed.
+
+SEED SOURCING (for 'seed'):
+  --source <dir>      Extra compiled seed directory (manifest.json + chunks);
+                      repeatable. Defaults to the bundled core + community
+                      artifacts under apps/playground/public/seed.
+
 OPTIONS:
   --format <fmt>      Output format: json (default), table, csv
-  -o, --output <path> Write output to a file instead of stdout
+  -o, --output <path> Write the IR payload (or download) to a path instead of
+                      the default; '-' writes to stdout
+  --at <version>      With 'download note': compose the markdown as-of the
+                      given segment version (default: latest)
+  --debug[=name]      Also write the IR payload to <name> (default
+                      wod-<subcommand>-debug.json); without it, parse/run
+                      print a one-line summary of what was persisted
   --pack <module>     Dynamically load and register a Language Pack (repeatable)
   --sport <sport>     Target sport fence dialect (e.g. climbing, crossfit)
   --unit <unit>       Preferred display unit for queries (e.g. lb, kg)
@@ -878,7 +3123,7 @@ function printUsage(writer) {
   if (writer) {
     writer(text);
   } else {
-    console.log(text);
+    process.stdout.write(text.endsWith("\n") ? text : text + "\n");
   }
 }
 async function cliMain(argv = process.argv.slice(2), io = {}) {
@@ -917,6 +3162,13 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
       writeOut(formattedText);
     }
   };
+  const debugTarget = (subcommand) => parsed.debug === void 0 ? void 0 : parsed.debug || `wod-${subcommand}-debug.json`;
+  const writeDebugFile = (subcommand, ir) => {
+    const target = debugTarget(subcommand);
+    if (target !== void 0) {
+      getFs2().writeFileSync(target, JSON.stringify(ir, null, 2) + "\n", "utf-8");
+    }
+  };
   try {
     if (parsed.subcommand === "parse") {
       if (!parsed.target) {
@@ -935,9 +3187,28 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         source = fs.readFileSync(parsed.target, "utf-8");
       }
       const ir = runParse(source, { sport: parsed.sport, sourceLabel: `cli:wod parse ${parsed.target}` });
-      const pretty = !parsed.output && Boolean(process.stdout.isTTY);
-      const formatted = formatParseOutput(ir, parsed.format, pretty);
-      deliverOutput(formatted);
+      const identity = extractNoteIdentity(source);
+      const tags = extractTypedTags(source);
+      const db = await openCliDb(parsed.db);
+      try {
+        const persisted = await persistNote(db, {
+          source,
+          sourceLabel: parsed.target,
+          noteId: identity?.noteId,
+          title: identity?.title,
+          tags
+        });
+        writeOut(
+          `[wod parse] note ${persisted.noteId}${persisted.created ? "" : " (updated)"} \u2014 ${persisted.segments} segments, ${persisted.blocks} blocks, ${persisted.efforts} efforts${persisted.tags > 0 ? `, ${persisted.tags} tags` : ""} \u2192 ${db.path}`
+        );
+      } finally {
+        await db.close();
+      }
+      if (parsed.output) {
+        const pretty = Boolean(process.stdout.isTTY);
+        deliverOutput(formatParseOutput(ir, parsed.format, pretty));
+      }
+      writeDebugFile("parse", ir);
       return 0;
     }
     if (parsed.subcommand === "run") {
@@ -957,9 +3228,24 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         source = fs.readFileSync(parsed.target, "utf-8");
       }
       const ir = await runExecution(source, { sport: parsed.sport, sourceLabel: `cli:wod run ${parsed.target}` });
-      const pretty = !parsed.output && Boolean(process.stdout.isTTY);
-      const formatted = formatExecutionOutput(ir, parsed.format, pretty);
-      deliverOutput(formatted);
+      const db = await openCliDb(parsed.db);
+      try {
+        const persisted = await persistRun(db, {
+          source,
+          sourceLabel: parsed.target,
+          executionLog: ir.data
+        });
+        writeOut(
+          `[wod run] session ${persisted.resultId} \u2014 ${persisted.events} events, ${persisted.summaries} summaries on note ${persisted.noteId} \u2192 ${db.path}`
+        );
+      } finally {
+        await db.close();
+      }
+      if (parsed.output) {
+        const pretty = Boolean(process.stdout.isTTY);
+        deliverOutput(formatExecutionOutput(ir, parsed.format, pretty));
+      }
+      writeDebugFile("run", ir);
       return 0;
     }
     if (parsed.subcommand === "query") {
@@ -967,26 +3253,269 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         writeErr("[wod query] Error: Missing WQL query argument");
         return 1;
       }
+      const useDb = !parsed.corpus && !parsed.stdinLog && !parsed.stdinFacts;
       let stdinLogContent;
       let stdinFactsContent;
       if (parsed.stdinLog) {
         stdinLogContent = await getStdin();
       } else if (parsed.stdinFacts) {
         stdinFactsContent = await getStdin();
-      } else if (!parsed.corpus) {
-        writeErr("[wod query] Error: Query requires input data. Specify --corpus <file>, --stdin-log, or --stdin-facts.");
-        return 1;
       }
-      const ir = await runQueryCli(parsed.target, {
-        corpusPath: parsed.corpus,
-        stdinLog: stdinLogContent,
-        stdinFacts: stdinFactsContent,
-        preferredUnit: parsed.unit,
-        sourceLabel: `cli:wod query "${parsed.target}"`
-      });
+      let ir;
+      if (useDb) {
+        const dbPath = resolveDbPath(parsed.db);
+        if (!nodeFs().existsSync(dbPath)) {
+          writeErr(
+            `[wod query] No input dataset and no database at ${dbPath}. Specify --corpus <file>, --stdin-log, --stdin-facts, or run \`wod seed\` first.`
+          );
+          return 1;
+        }
+        const db = await openCliDb(parsed.db);
+        try {
+          ir = await runQueryCli(parsed.target, {
+            preferredUnit: parsed.unit,
+            sourceLabel: `cli:wod query "${parsed.target}"`,
+            stores: {
+              eventStore: sqliteEventStore(db.db),
+              noteStore: sqliteNoteStore(db.db),
+              blockStore: sqliteBlockStore(db.db),
+              effortStore: sqliteEffortStore(db.db),
+              blockEffortsStore: sqliteIndexStore(db.db, "block_efforts"),
+              tagsStore: sqliteIndexStore(db.db, "tags"),
+              noteTagsStore: sqliteIndexStore(db.db, "note_tags")
+            }
+          });
+        } finally {
+          await db.close();
+        }
+      } else {
+        if (!parsed.corpus && !stdinLogContent && !stdinFactsContent) {
+          writeErr("[wod query] Error: Query requires input data. Specify --corpus <file>, --stdin-log, or --stdin-facts.");
+          return 1;
+        }
+        ir = await runQueryCli(parsed.target, {
+          corpusPath: parsed.corpus,
+          stdinLog: stdinLogContent,
+          stdinFacts: stdinFactsContent,
+          preferredUnit: parsed.unit,
+          sourceLabel: `cli:wod query "${parsed.target}"`
+        });
+      }
       const pretty = !parsed.output && Boolean(process.stdout.isTTY);
       const formatted = formatQueryOutput(ir, parsed.format, pretty);
       deliverOutput(formatted);
+      writeDebugFile("query", ir);
+      return 0;
+    }
+    if (parsed.subcommand === "download") {
+      const kind = parsed.target;
+      const id = parsed.target2;
+      const DOWNLOAD_KINDS = ["note", "session", "effort", "equipment"];
+      if (!id && kind !== "equipment" || !DOWNLOAD_KINDS.includes(kind ?? "")) {
+        writeErr("[wod download] Usage: wod download <note|session|effort|equipment> <id> [--at <version>] [-o <path>]");
+        return 1;
+      }
+      const targetId = id;
+      const db = await openCliDb(parsed.db);
+      try {
+        if (kind === "note") {
+          const bundle = await getNoteBundle(db.db, targetId);
+          if (!bundle.note) {
+            writeErr(`[wod download] Note not found in ${db.path}: ${id}`);
+            return 1;
+          }
+          const at = parsed.at === void 0 ? void 0 : Number(parsed.at);
+          if (parsed.at !== void 0 && (!Number.isInteger(at) || at < 1)) {
+            writeErr(`[wod download] Invalid --at version: ${parsed.at}`);
+            return 1;
+          }
+          const markdown = composeNoteMarkdown(bundle.note, bundle.segments, at);
+          const target = parsed.output && parsed.output !== "-" ? parsed.output : `${id}${at ? `.v${at}` : ""}.md`;
+          if (parsed.output === "-") {
+            writeOut(markdown);
+          } else {
+            nodeFs().writeFileSync(target, markdown, "utf-8");
+          }
+          writeOut(
+            `[wod download] note ${id}${at ? ` v${at}` : ""} \u2192 ${target} (${bundle.segments.length} segment rows)`
+          );
+        } else if (kind === "session") {
+          const bundle = await getSessionBundle(db.db, targetId);
+          if (!bundle) {
+            writeErr(`[wod download] Session not found in ${db.path}: ${id}`);
+            return 1;
+          }
+          const csv = sessionToCsv(bundle.session, bundle.events);
+          const target = parsed.output && parsed.output !== "-" ? parsed.output : `${id}.csv`;
+          if (parsed.output === "-") {
+            writeOut(csv);
+          } else {
+            nodeFs().writeFileSync(target, csv, "utf-8");
+          }
+          writeOut(`[wod download] session ${id} \u2192 ${target} (${bundle.events.length} events)`);
+        } else if (kind === "effort") {
+          const effort = await getEffortBySlug(db.db, targetId);
+          if (!effort) {
+            writeErr(`[wod download] Effort not found in ${db.path}: ${id}`);
+            return 1;
+          }
+          const markdown = effortToMarkdown(effort);
+          const target = parsed.output && parsed.output !== "-" ? parsed.output : `${id}.md`;
+          if (parsed.output === "-") {
+            writeOut(markdown);
+          } else {
+            nodeFs().writeFileSync(target, markdown, "utf-8");
+          }
+          writeOut(`[wod download] effort ${id} \u2192 ${target}`);
+        } else {
+          const labels = (await listTagsByType(db.db, "equipment")).map((t) => t.label).sort();
+          const csv = equipmentToCsv(labels);
+          const target = parsed.output && parsed.output !== "-" ? parsed.output : "equipment.csv";
+          if (parsed.output === "-") {
+            writeOut(csv);
+          } else {
+            nodeFs().writeFileSync(target, csv, "utf-8");
+          }
+          writeOut(`[wod download] equipment \u2192 ${target} (${labels.length} labels)`);
+        }
+      } finally {
+        await db.close();
+      }
+      return 0;
+    }
+    if (parsed.subcommand === "import") {
+      const kind = parsed.target;
+      const file = parsed.target2;
+      const IMPORT_KINDS = ["note", "session", "effort", "equipment"];
+      if (!file || !IMPORT_KINDS.includes(kind ?? "")) {
+        writeErr("[wod import] Usage: wod import <note|session|effort|equipment> <file>");
+        return 1;
+      }
+      const fs = nodeFs();
+      if (!fs.existsSync(file)) {
+        writeErr(`[wod import] File not found: ${file}`);
+        return 1;
+      }
+      if (kind === "note") {
+        const source = fs.readFileSync(file, "utf-8");
+        const identity = extractNoteIdentity(source);
+        const tags = extractTypedTags(source);
+        const db2 = await openCliDb(parsed.db);
+        try {
+          const persisted = await persistNote(db2, {
+            source,
+            sourceLabel: file,
+            noteId: identity?.noteId,
+            title: identity?.title,
+            tags
+          });
+          writeOut(
+            `[wod import] note ${persisted.noteId}${persisted.created ? "" : " (updated)"} \u2014 ${persisted.segments} segments${persisted.tags > 0 ? `, ${persisted.tags} tags` : ""} \u2192 ${db2.path}`
+          );
+        } finally {
+          await db2.close();
+        }
+        return 0;
+      }
+      if (kind === "effort") {
+        const effort = markdownToEffort(fs.readFileSync(file, "utf-8"));
+        if (!effort) {
+          writeErr(`[wod import] Unparseable effort file (need frontmatter id/slug/label + numeric baseAttributes.met): ${file}`);
+          return 1;
+        }
+        const db2 = await openCliDb(parsed.db);
+        try {
+          await persistEffort(db2, { ...effort, registrySource: "user" });
+          writeOut(`[wod import] effort ${effort.slug} \u2014 ${effort.label} \u2192 ${db2.path}`);
+        } finally {
+          await db2.close();
+        }
+        return 0;
+      }
+      if (kind === "equipment") {
+        const labels = csvToEquipmentLabels(fs.readFileSync(file, "utf-8"));
+        if (labels.length === 0) {
+          writeErr(`[wod import] No equipment labels found in ${file}`);
+          return 1;
+        }
+        const db2 = await openCliDb(parsed.db);
+        try {
+          const added = await persistTypedTags(db2, labels, "equipment");
+          writeOut(`[wod import] equipment \u2014 ${labels.length} labels (${added} new) \u2192 ${db2.path}`);
+        } finally {
+          await db2.close();
+        }
+        return 0;
+      }
+      const { session, events } = csvToSessionRows(fs.readFileSync(file, "utf-8"));
+      const db = await openCliDb(parsed.db);
+      try {
+        const result = await persistSessionBundle(db, session, events);
+        writeOut(
+          `[wod import] session ${session.id} \u2014 ${result.events} events${result.noteCreated ? " (stub note created)" : ""} \u2192 ${db.path}`
+        );
+      } finally {
+        await db.close();
+      }
+      return 0;
+    }
+    if (parsed.subcommand === "build") {
+      const cwd = process.cwd();
+      const root = nodePath().resolve(cwd, parsed.dir ?? parsed.target ?? ".");
+      if (!nodeFs().existsSync(nodePath().resolve(root, "markdown"))) {
+        writeErr(`[wod build] No markdown/ corpus under ${root} \u2014 run from the content repo root (or pass its directory).`);
+        return 1;
+      }
+      const { generateSeed: generateSeed2 } = await Promise.resolve().then(() => (init_compiler(), compiler_exports));
+      try {
+        const result = generateSeed2({
+          corpusRoot: root,
+          ...parsed.output ? { outDir: nodePath().resolve(cwd, parsed.output) } : {},
+          ...parsed.template ? { templateFile: nodePath().resolve(cwd, parsed.template) } : {},
+          scaffoldDiscoveredEfforts: parsed.scaffold === true
+        });
+        const kb = (n) => `${(n / 1024).toFixed(0)} KB`;
+        const totalBytes = result.manifest.chunks.reduce((s, c) => s + c.bytes, 0);
+        writeOut(`[wod build] schema v${result.manifest.schema} version ${result.manifest.version} (${result.manifest.versionLabel}) \u2192 ${result.outDir}`);
+        for (const c of result.manifest.chunks) {
+          writeOut(`  ${c.id.padEnd(48)} ${String(c.count).padStart(4)} ${c.kind === "block-index" ? "rows " : "files"}  ${kb(c.bytes).padStart(8)}`);
+        }
+        writeOut(`[wod build] ${result.manifest.chunks.length} chunks, ${result.totalFiles} files, ${kb(totalBytes)} total \u2014 scan ${result.passMs.scan}ms, block-index ${result.passMs.blockIndex}ms, block-efforts ${result.passMs.blockEfforts}ms, write ${result.passMs.write}ms`);
+        return 0;
+      } catch (error) {
+        writeErr(`[wod build] ${error.message}`);
+        return 1;
+      }
+    }
+    if (parsed.subcommand === "seed") {
+      const dirs = parsed.sources.length > 0 ? parsed.sources.map((s) => nodePath().resolve(process.cwd(), s)) : defaultSeedDirs(process.cwd());
+      if (dirs.length === 0) {
+        writeErr(
+          "[wod seed] No seed sources found. Run `bun scripts/sync-seed.ts` to build the bundled artifacts, or pass --source <dir> pointing at a compiled seed directory (manifest.json + chunks)."
+        );
+        return 1;
+      }
+      const db = await openCliDb(parsed.db);
+      try {
+        for (const dir of dirs) {
+          const summary = await importSeedDir(db, dir, "");
+          writeOut(
+            `[wod seed] ${summary.sourceId}: v${summary.version} \u2014 ${summary.notes} notes, ${summary.efforts} efforts, ${summary.blocks} blocks, ${summary.blockEfforts} block-efforts (${summary.deleted} deleted, ${summary.skippedUserOwned} user-owned skipped) \u2192 ${db.path}`
+          );
+        }
+      } finally {
+        await db.close();
+      }
+      return 0;
+    }
+    if (parsed.subcommand === "reset") {
+      const target = resolveDbPath(parsed.db);
+      if (nodeFs().existsSync(target)) {
+        nodeFs().unlinkSync(target);
+        writeOut(`[wod reset] removed ${target}`);
+      } else {
+        writeOut(`[wod reset] nothing to reset \u2014 ${target} does not exist`);
+      }
       return 0;
     }
     writeErr(`[wod] Unknown subcommand "${parsed.subcommand}"`);