dotdog 0.3.5 → 0.4.0

package/dist/cli.js

@@ -2534,8 +2534,150 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // src/cli.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, mkdirSync, writeFileSync } from "fs";
-import { join as join2, resolve as resolve2 } from "path";
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync3, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
+
+// src/index.ts
+import { readFileSync, readdirSync } from "fs";
+import { join } from "path";
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 2 && !stopWords.has(t));
+}
+var stopWords = new Set([
+  "the",
+  "and",
+  "for",
+  "are",
+  "but",
+  "not",
+  "you",
+  "all",
+  "can",
+  "had",
+  "her",
+  "was",
+  "one",
+  "our",
+  "out",
+  "has",
+  "have",
+  "been",
+  "some",
+  "than",
+  "that",
+  "this",
+  "with",
+  "from",
+  "they",
+  "will",
+  "would",
+  "which",
+  "their",
+  "there",
+  "about",
+  "into",
+  "each",
+  "said",
+  "does",
+  "also",
+  "after",
+  "before",
+  "other",
+  "more",
+  "only",
+  "over",
+  "such",
+  "when",
+  "where",
+  "what",
+  "who",
+  "how",
+  "then",
+  "just",
+  "very",
+  "much",
+  "well",
+  "should",
+  "could",
+  "through",
+  "between"
+]);
+function buildIndex(projectDir, projectName) {
+  const files = readdirSync(projectDir).filter((f) => f.endsWith(".dog"));
+  const entries = [];
+  const docFreq = new Map;
+  for (const file of files) {
+    const content = readFileSync(join(projectDir, file), "utf-8");
+    const sections = content.split(/\n(?=##\s)/);
+    for (const section of sections) {
+      const lines = section.split(`
+`);
+      const heading = lines[0]?.replace(/^#+\s*/, "") || "(root)";
+      const body = lines.slice(1).join(`
+`);
+      if (body.trim().length < 20)
+        continue;
+      const terms = tokenize(body);
+      if (terms.length < 5)
+        continue;
+      const tf = new Map;
+      for (const t of terms) {
+        tf.set(t, (tf.get(t) || 0) + 1);
+        docFreq.set(t, (docFreq.get(t) || 0) + 1);
+      }
+      entries.push({
+        section: heading,
+        heading,
+        file,
+        content: body.slice(0, 500),
+        vector: []
+      });
+    }
+  }
+  const vocabulary = [...docFreq.entries()].filter(([_, df2]) => df2 >= 2).sort((a, b) => b[1] - a[1]).slice(0, 1000).map(([term]) => term);
+  const df = vocabulary.map((t) => docFreq.get(t) || 0);
+  const N = entries.length;
+  for (const entry of entries) {
+    const terms = tokenize(entry.content);
+    const tf = new Map;
+    for (const t of terms)
+      tf.set(t, (tf.get(t) || 0) + 1);
+    entry.vector = vocabulary.map((term) => {
+      const termFreq = tf.get(term) || 0;
+      if (termFreq === 0)
+        return 0;
+      const docFreqTerm = docFreq.get(term) || 1;
+      return termFreq / terms.length * Math.log(N / docFreqTerm);
+    });
+  }
+  return {
+    version: "1.0",
+    project: projectName,
+    built: new Date().toISOString(),
+    entries,
+    vocabulary,
+    df
+  };
+}
+function searchIndex(index, query, limit = 10) {
+  const queryTerms = tokenize(query);
+  const queryVec = index.vocabulary.map((term) => queryTerms.includes(term) ? 1 : 0);
+  const results = index.entries.map((entry) => {
+    let dot = 0;
+    let entryMag = 0;
+    let queryMag = 0;
+    for (let j = 0;j < queryVec.length; j++) {
+      dot += queryVec[j] * entry.vector[j];
+      queryMag += queryVec[j] * queryVec[j];
+      entryMag += entry.vector[j] * entry.vector[j];
+    }
+    const score = queryMag > 0 && entryMag > 0 ? dot / (Math.sqrt(queryMag) * Math.sqrt(entryMag)) : 0;
+    return { entry, score };
+  });
+  return results.filter((r) => r.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+}
+
+// src/cli.ts
 import { homedir as homedir2 } from "os";
 
 // src/parser.ts
@@ -2809,12 +2951,11 @@ function buildPredictionNode(name, description, yaml, lineStart, lineEnd) {
     description,
     trigger: yaml.trigger || "",
     timeframe: yaml.timeframe || "",
-    confidence: typeof yaml.confidence === "number" ? yaml.confidence : 0,
+    confidence: yaml.confidence || 0,
     measurement: yaml.measurement || "",
-    preconditions: Array.isArray(yaml.preconditions) ? yaml.preconditions : [],
-    postconditions: Array.isArray(yaml.postconditions) ? yaml.postconditions : [],
+    status: yaml.status || "pending",
     yaml,
-    lineStart: lineStart + 1,
+    lineStart,
     lineEnd
   };
 }
@@ -2946,14 +3087,14 @@ function parseInlineObject(value) {
   return obj;
 }
 // src/serve.ts
-import { existsSync, readdirSync, readFileSync } from "fs";
-import { join, resolve } from "path";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2, resolve } from "path";
 import { homedir } from "os";
 import * as readline from "readline";
 function resolvePath(p) {
   if (p.startsWith("~"))
-    p = join(homedir(), p.slice(1));
-  const resolved = p.startsWith("/") ? p : join(process.cwd(), p);
+    p = join2(homedir(), p.slice(1));
+  const resolved = p.startsWith("/") ? p : join2(process.cwd(), p);
   if (!p.startsWith("/") && !p.startsWith("~")) {
     const rel = resolve(process.cwd(), p);
     const cwd = process.cwd();
@@ -2967,29 +3108,63 @@ function resolvePath(p) {
   }
   return resolved;
 }
+var isV2 = (n) => Array.isArray(n) && typeof n[0] === "number";
 var N = (dag) => dag.n || dag.nodes || [];
-var E = (dag) => dag.e || dag.edges || [];
+function edgeToObj(n, tgtIdx, v2e) {
+  return { t: String(tgtIdx), v: v2e[1] || "", c: v2e[2] || "", r: v2e[3] || 0 };
+}
+function nodeEdges(n) {
+  if (isV2(n))
+    return (n[6] || []).map((e) => edgeToObj(n, e[0], e));
+  return n.es || [];
+}
+function E(dag) {
+  if (dag.e)
+    return dag.e;
+  const edges = [];
+  const seen = new Set;
+  for (const node of N(dag)) {
+    for (const e of nodeEdges(node)) {
+      const src = isV2(node) ? String(node[0]) : node.i || node.id || "";
+      const key = `${src}→${e.t}:${e.v}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        edges.push({ s: src, t: e.t, v: e.v, d: e.d, c: e.c, r: e.r });
+      }
+    }
+  }
+  return edges;
+}
 var P = (dag) => dag.p || dag.project || "";
-var ni = (n) => n.i || n.id || "";
-var nt = (n) => n.t || n.type || "";
-var np = (n) => n.p || n.properties || {};
-var ns = (n) => n.s || n.states || [];
-var nl = (n) => n.l || n.lifecycle || [];
+var ni = (n) => isV2(n) ? String(n[0]) : n.i || n.id || "";
+var nt = (n) => isV2(n) ? n[2] || "" : n.t || n.type || "";
+function np(n) {
+  if (isV2(n)) {
+    const flat = n[4] || [];
+    const obj = {};
+    for (let i = 0;i < flat.length; i += 2)
+      obj[flat[i]] = flat[i + 1] || "";
+    return obj;
+  }
+  return n.p || n.properties || {};
+}
+var ns = (n) => isV2(n) ? n[5] || [] : n.s || n.states || [];
+var nl = (n) => isV2(n) ? [] : n.l || n.lifecycle || [];
 var es = (e) => e.s || e.source || "";
 var et = (e) => e.t || e.target || "";
 function serve(dir = ".") {
   const root = resolvePath(dir);
   const dagCache = new Map;
   function loadDags() {
-    const dirs = [join(root, "projects"), join(root, "specs"), root];
+    const dirs = [join2(root, "projects"), join2(root, "specs"), root];
     for (const dd of dirs) {
-      if (!existsSync(dd))
+      if (!existsSync2(dd))
         continue;
-      const projects = readdirSync(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+      const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
       for (const p of projects) {
-        const dagFile = join(dd, p, `${p}.dag`);
-        if (existsSync(dagFile)) {
-          dagCache.set(p, JSON.parse(readFileSync(dagFile, "utf-8")));
+        const dagFile = join2(dd, p, `${p}.dag`);
+        if (existsSync2(dagFile)) {
+          dagCache.set(p, JSON.parse(readFileSync2(dagFile, "utf-8")));
         }
       }
     }
@@ -3044,7 +3219,7 @@ function serve(dir = ".") {
         if (!node)
           return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: "{}" }] } };
         const edges = E(dag).filter((e) => es(e).toLowerCase() === ni(node).toLowerCase() || et(e).toLowerCase() === ni(node).toLowerCase());
-        return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify({ ...node, edges }) }] } };
+        return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(isV2(node) ? { id: String(node[0]), name: node[1] || "", type: node[2] || "", description: node[3] || "", properties: np(node), states: ns(node), edges } : { ...node, edges }) }] } };
       }
       if (name === "traverse") {
         const dag = dagCache.get(args.project || [...dagCache.keys()][0] || "");
@@ -3062,7 +3237,7 @@ function serve(dir = ".") {
           visitedNodes.add(curr.id);
           const node = N(dag).find((n) => ni(n).toLowerCase() === curr.id.toLowerCase());
           if (node)
-            subgraph.nodes.push(node);
+            subgraph.nodes.push(isV2(node) ? { id: String(node[0]), name: node[1] || "", type: node[2] || "", description: node[3] || "", properties: np(node), states: ns(node), edges: nodeEdges(node) } : node);
           const edges = E(dag).filter((e) => es(e).toLowerCase() === curr.id.toLowerCase() || et(e).toLowerCase() === curr.id.toLowerCase());
           for (const e of edges) {
             const edgeKey = `${es(e)}→${et(e)}`;
@@ -3096,6 +3271,8 @@ function serve(dir = ".") {
           nodes: N(dag).length,
           edges: E(dag).length,
           version: dag.v || dag.version || "",
+          order: dag.o || [],
+          cycles: dag.cy !== undefined ? dag.cy : null,
           savings: tk.sv || tk.savings_pct || 0,
           method: tk.m || tk.method || ""
         };
@@ -3138,8 +3315,8 @@ function serve(dir = ".") {
 // src/cli.ts
 function resolvePath2(p) {
   if (p.startsWith("~"))
-    p = join2(homedir2(), p.slice(1));
-  const resolved = p.startsWith("/") ? p : join2(process.cwd(), p);
+    p = join3(homedir2(), p.slice(1));
+  const resolved = p.startsWith("/") ? p : join3(process.cwd(), p);
   if (!p.startsWith("/") && !p.startsWith("~")) {
     const rel = resolve2(process.cwd(), p);
     const cwd = process.cwd();
@@ -3185,22 +3362,22 @@ function parseSections2(markdown) {
   return sections;
 }
 var program2 = new Command;
-var pkg = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf-8"));
+var pkg = JSON.parse(readFileSync3(new URL("../package.json", import.meta.url), "utf-8"));
 program2.name("spec").alias("dotdog").description("CLI for structured software specs : validate .dog, compile .dag, query via MCP").version(pkg.version);
 program2.command("validate [dir]").action((d = ".") => {
   const dir = resolvePath2(d);
-  const dirs = [join2(dir, "projects"), join2(dir, "specs")];
+  const dirs = [join3(dir, "projects"), join3(dir, "specs")];
   let found = false, hasErrors = false;
   for (const dd of dirs) {
-    if (!existsSync2(dd))
+    if (!existsSync3(dd))
       continue;
-    const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const projects = readdirSync3(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const p of projects) {
       found = true;
-      const pd = join2(dd, p);
-      if (!existsSync2(join2(pd, "SPEC.dog")))
+      const pd = join3(dd, p);
+      if (!existsSync3(join3(pd, "SPEC.dog")))
         continue;
-      const files = existsSync2(pd) ? readdirSync2(pd).filter((f) => f.endsWith(".dog")) : [];
+      const files = existsSync3(pd) ? readdirSync3(pd).filter((f) => f.endsWith(".dog")) : [];
       const missing = ["SPEC.dog", "constitution.dog", "data-model.dog"].filter((f) => !files.includes(f));
       const optional = ["COPY.dog", "plan.dog", "DESIGN-SYSTEM.dog", "INDEX.dog"].filter((f) => !files.includes(f));
       console.log(source_default.bold(`
@@ -3221,7 +3398,7 @@ program2.command("validate [dir]").action((d = ".") => {
     process.exit(1);
 });
 program2.command("init <project>").option("-m, --minimal", "Only SPEC.dog + data-model.dog").action((p, opts) => {
-  const d = join2(process.cwd(), "specs", p);
+  const d = join3(process.cwd(), "specs", p);
   mkdirSync(d, { recursive: true });
   const full = {
     "SPEC.dog": `# Project
@@ -3269,7 +3446,13 @@ program2.command("init <project>").option("-m, --minimal", "Only SPEC.dog + data
   };
   const tmpl = opts.minimal ? minimal : full;
   for (const [f, c] of Object.entries(tmpl)) {
-    writeFileSync(join2(d, f), c);
+    writeFileSync2(join3(d, f), c);
+    try {
+      parse(c);
+    } catch (_) {
+      console.log(source_default.red(`  ✗ Template ${f} is invalid`));
+      process.exit(1);
+    }
     console.log(source_default.green(`  ✓ ${f}`));
   }
   console.log(source_default.bold(`
@@ -3277,23 +3460,23 @@ Project "${p}" initialized. Fill in SPEC.dog then run spec validate.`));
 });
 program2.command("list").action(() => {
   for (const d of ["projects", "specs"]) {
-    const dd = join2(process.cwd(), d);
-    if (!existsSync2(dd))
+    const dd = join3(process.cwd(), d);
+    if (!existsSync3(dd))
       continue;
-    const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const projects = readdirSync3(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     if (!projects.length)
       continue;
     console.log(source_default.bold(`
 ${d}/`));
     for (const p of projects) {
-      const sp = join2(dd, p);
-      const n = existsSync2(sp) ? readdirSync2(sp).filter((f) => f.endsWith(".dog")).length : 0;
+      const sp = join3(dd, p);
+      const n = existsSync3(sp) ? readdirSync3(sp).filter((f) => f.endsWith(".dog")).length : 0;
       console.log(`  ${source_default.cyan(p)} : ${n} .dog files`);
     }
   }
 });
 program2.command("parse <file>").action((f) => {
-  const c = readFileSync2(f, "utf-8");
+  const c = readFileSync3(f, "utf-8");
   const s = parseSections2(c);
   console.log(source_default.bold(`
 ${s.length} sections`));
@@ -3302,26 +3485,26 @@ ${s.length} sections`));
 });
 program2.command("compile [dir]").option("-o, --output <file>").action((d = ".", opts) => {
   const dir = resolvePath2(d);
-  const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];
+  const dirs = [join3(dir, "projects"), join3(dir, "specs"), dir];
   let found = false;
   for (const dd of dirs) {
-    if (!existsSync2(dd))
+    if (!existsSync3(dd))
       continue;
-    const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const projects = readdirSync3(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const p of projects) {
-      const pd = join2(dd, p);
-      if (!existsSync2(join2(pd, "SPEC.dog")))
+      const pd = join3(dd, p);
+      if (!existsSync3(join3(pd, "SPEC.dog")))
         continue;
-      if (!existsSync2(pd))
+      if (!existsSync3(pd))
         continue;
-      const files = readdirSync2(pd).filter((f) => f.endsWith(".dog")).sort();
+      const files = readdirSync3(pd).filter((f) => f.endsWith(".dog")).sort();
       if (!files.length)
         continue;
       found = true;
       const sources = {};
       let sourceBytes = 0, contentBytes = 0;
       for (const f of files) {
-        const content = readFileSync2(join2(pd, f), "utf-8");
+        const content = readFileSync3(join3(pd, f), "utf-8");
         sources[f] = content;
         const bytes = Buffer.byteLength(content, "utf-8");
         sourceBytes += bytes;
@@ -3394,16 +3577,72 @@ program2.command("compile [dir]").option("-o, --output <file>").action((d = ".",
           }
         }
       }
-      const dag = { v: "1.4", p, c: `dotdog@${pkg.version}`, n: nodes, e: edges };
+      const entityNames = new Set(nodes.map((n) => n.i));
+      for (const e of edges) {
+        if (e.s && !entityNames.has(e.s)) {
+          console.log(source_default.red(`  ✗ Unknown relationship source "${e.s}" (target: "${e.t}")`));
+          process.exit(1);
+        }
+        if (e.t && !entityNames.has(e.t)) {
+          console.log(source_default.red(`  ✗ Unknown relationship target "${e.t}" (source: "${e.s}")`));
+          process.exit(1);
+        }
+      }
+      const nodeIds = new Map;
+      nodes.forEach((n, i) => nodeIds.set(n.i, i));
+      const v2nodes = [];
+      for (let j = 0;j < nodes.length; j++) {
+        const nd = nodes[j];
+        const props = [];
+        if (nd.p)
+          for (const [k, v] of Object.entries(nd.p))
+            props.push(k, v);
+        const states = nd.s || [];
+        const outEdges = [];
+        const seen = new Set;
+        for (const e of edges) {
+          if (e.s !== nd.i && e.t !== nd.i)
+            continue;
+          const tid = nodeIds.get(e.s === nd.i ? e.t : e.s);
+          if (tid === undefined)
+            continue;
+          const key = `${j}→${tid}:${e.v}`;
+          if (seen.has(key))
+            continue;
+          seen.add(key);
+          const ee = [tid, e.v || ""];
+          if (e.c)
+            ee.push(e.c);
+          if (e.r)
+            ee.push(1);
+          outEdges.push(ee);
+        }
+        const entry = [j, nd.i || "", nd.t || "", nd.d || "", props, states, outEdges];
+        if (nd.g === "prediction") {
+          const f = [];
+          if (nd.cf)
+            f.push(nd.cf);
+          if (nd.tf)
+            f.push(nd.tf);
+          if (nd.tg)
+            f.push(nd.tg);
+          if (nd.ms)
+            f.push(nd.ms);
+          if (f.length)
+            entry.push(f);
+        }
+        v2nodes.push(entry);
+      }
+      const dag = { v: 2, p, n: v2nodes };
       const dagJson = JSON.stringify(dag);
       const dagTokens = Math.round(Buffer.byteLength(dagJson, "utf-8") / 4);
       const allSavingsPct = sourceTokens > 0 ? Math.round((1 - dagTokens / sourceTokens) * 1000) / 10 : 0;
       const contentSavingsPct = contentTokens > 0 ? Math.round((1 - dagTokens / contentTokens) * 1000) / 10 : 0;
       const savingsTokens = sourceTokens - dagTokens;
-      const outPath = opts.output || join2(pd, `${p}.dag`);
+      const outPath = opts.output || join3(pd, `${p}.dag`);
       const tokens = { m: "chars/4", st: sourceTokens, ct: contentTokens, dt: dagTokens, sv: allSavingsPct, cs: contentSavingsPct, saved: savingsTokens };
       const report = { ...dag, tk: tokens };
-      writeFileSync(outPath, JSON.stringify(report, null, 2));
+      writeFileSync2(outPath, JSON.stringify(report, null, 2));
       console.log(source_default.green(`  ✓ ${outPath}`));
       console.log(source_default.gray(`    ${nodes.length} nodes, ${edges.length} edges, ${files.length} files`));
       console.log(source_default.gray(`    ${sourceTokens} → ${dagTokens} tokens (${allSavingsPct}% savings, ${contentSavingsPct}% content-only, ${savingsTokens} saved)`));
@@ -3414,37 +3653,41 @@ program2.command("compile [dir]").option("-o, --output <file>").action((d = ".",
 });
 program2.command("tokens [dir]").action((d = ".") => {
   const dir = resolvePath2(d);
-  const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];
+  const dirs = [join3(dir, "projects"), join3(dir, "specs"), dir];
   let found = false;
   for (const dd of dirs) {
-    if (!existsSync2(dd))
+    if (!existsSync3(dd))
       continue;
-    const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const projects = readdirSync3(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const p of projects) {
-      const pd = join2(dd, p);
-      if (!existsSync2(join2(pd, "SPEC.dog")))
+      const pd = join3(dd, p);
+      if (!existsSync3(join3(pd, "SPEC.dog")))
         continue;
-      const dagFile = join2(pd, `${p}.dag`);
-      if (!existsSync2(dagFile))
+      const dagFile = join3(pd, `${p}.dag`);
+      if (!existsSync3(dagFile))
         continue;
       found = true;
-      const dogFiles = readdirSync2(pd).filter((f) => f.endsWith(".dog"));
+      const dogFiles = readdirSync3(pd).filter((f) => f.endsWith(".dog"));
       let sourceBytes = 0, contentBytes = 0;
       for (const f of dogFiles) {
-        const bytes = Buffer.byteLength(readFileSync2(join2(pd, f), "utf-8"), "utf-8");
+        const bytes = Buffer.byteLength(readFileSync3(join3(pd, f), "utf-8"), "utf-8");
         sourceBytes += bytes;
         if (bytes >= 100)
           contentBytes += bytes;
       }
-      const dagBytes = Buffer.byteLength(readFileSync2(dagFile, "utf-8"), "utf-8");
+      const dagBytes = Buffer.byteLength(readFileSync3(dagFile, "utf-8"), "utf-8");
       const savings = sourceBytes > 0 ? Math.round((1 - dagBytes / sourceBytes) * 1000) / 10 : 0;
+      const dag = JSON.parse(readFileSync3(dagFile, "utf-8"));
+      const dagOnly = JSON.stringify({ v: dag.v, p: dag.p, n: dag.n });
+      const dagOnlyBytes = Buffer.byteLength(dagOnly, "utf-8");
+      const dagOnlyPct = sourceBytes > 0 ? Math.round((1 - dagOnlyBytes / sourceBytes) * 1000) / 10 : 0;
       console.log(source_default.bold(`
   ${p}`));
       console.log(source_default.gray(`    ${dogFiles.length} .dog files: ${sourceBytes} bytes`));
-      console.log(source_default.gray(`    .dag file: ${dagBytes} bytes`));
-      console.log(source_default.green(`    ${savings}% smaller (${sourceBytes - dagBytes} bytes saved)`));
+      console.log(source_default.gray(`    .dag on disk: ${dagBytes} bytes (${savings}% savings, includes metadata)`));
+      console.log(source_default.green(`    .dag payload: ${dagOnlyBytes} bytes (${dagOnlyPct}% savings, graph only)`));
       if (contentBytes && contentBytes !== sourceBytes) {
-        const cs = Math.round((1 - dagBytes / contentBytes) * 1000) / 10;
+        const cs = Math.round((1 - dagOnlyBytes / contentBytes) * 1000) / 10;
         console.log(source_default.gray(`    content-only: ${contentBytes} bytes → ${cs}% savings`));
       }
     }
@@ -3454,27 +3697,67 @@ program2.command("tokens [dir]").action((d = ".") => {
 });
 program2.command("visualize [dir]").option("-s, --save").action((d = ".", opts) => {
   const dir = resolvePath2(d);
-  const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];
+  const dirs = [join3(dir, "projects"), join3(dir, "specs"), dir];
   for (const dd of dirs) {
-    if (!existsSync2(dd))
+    if (!existsSync3(dd))
       continue;
-    const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const projects = readdirSync3(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const p of projects) {
-      const dagFile = join2(dd, p, `${p}.dag`);
-      if (!existsSync2(dagFile))
+      const dagFile = join3(dd, p, `${p}.dag`);
+      if (!existsSync3(dagFile))
         continue;
-      const dag = JSON.parse(readFileSync2(dagFile, "utf-8"));
+      const dag = JSON.parse(readFileSync3(dagFile, "utf-8"));
+      const nodes = dag.n || dag.nodes || [];
+      const isV22 = (n) => Array.isArray(n) && typeof n[0] === "number";
+      const nodeName = (n) => isV22(n) ? nodes[n[0]] ? nodes[n[0]][1] || String(n[0]) : String(n[0]) : n.i || n.id || "";
+      const slug = (s) => s.replace(/\s+/g, "_").replace(/^[^a-zA-Z]+/, "n_");
       let out = "```mermaid\ngraph LR\n";
-      for (const n of dag.nodes || [])
-        out += `    ${n.id.replace(/\s+/g, "_")}[${n.id}]
+      for (const n of nodes) {
+        const raw = isV22(n) ? n[1] || String(n[0]) : n.i || n.id || "";
+        if (raw)
+          out += `    ${slug(raw)}[${raw}]
 `;
-      for (const e of dag.edges || [])
-        out += `    ${e.source.replace(/\s+/g, "_")} -->|${e.verb || ""}| ${e.target.replace(/\s+/g, "_")}
+      }
+      const seen = new Set;
+      for (const n of nodes) {
+        const edges = isV22(n) ? n[6] || [] : n.es || [];
+        for (const e of edges) {
+          const srcName = isV22(n) ? n[1] || String(n[0]) : n.i || n.id || "";
+          const src = slug(srcName);
+          let tgtName, verb;
+          if (isV22(n)) {
+            const tgtNode = nodes[e[0]];
+            tgtName = tgtNode ? tgtNode[1] || String(tgtNode[0]) : String(e[0]);
+            verb = e[1] || "";
+          } else {
+            tgtName = e.t || "";
+            verb = e.v || "";
+          }
+          const tgt = slug(tgtName);
+          const key = `${src}→${tgt}:${verb}`;
+          if (!seen.has(key) && src && tgt) {
+            seen.add(key);
+            out += `    ${src} -->|${verb}| ${tgt}
 `;
+          }
+        }
+      }
+      const legacyEdges = dag.e || dag.edges || [];
+      for (const e of legacyEdges) {
+        const src = slug(e.s || e.source || "");
+        const tgt = slug(e.t || e.target || "");
+        const verb = e.v || e.verb || "";
+        const key = `${src}→${tgt}:${verb}`;
+        if (!seen.has(key) && src && tgt) {
+          seen.add(key);
+          out += `    ${src} -->|${verb}| ${tgt}
+`;
+        }
+      }
       out += "```\n";
       if (opts.save) {
-        const outFile = join2(dd, p, "..", `${p}.md`);
-        writeFileSync(outFile, `# ${p} : Spec Graph
+        const outFile = join3(dd, p, `${p}.md`);
+        writeFileSync2(outFile, `# ${p} : Spec Graph
 
 ${out}`);
         console.log(source_default.green(`  ✓ ${outFile}`));
@@ -3486,24 +3769,24 @@ ${out}`);
 program2.command("serve [dir]").description("MCP server : expose .dag graph to AI agents over stdio").action((d = ".") => serve(resolvePath2(d)));
 program2.command("analyze [dir]").description("Analyze a spec project : score, gaps, suggestions").option("-p, --project <name>").action((d = ".", opts) => {
   const dir = resolvePath2(d);
-  const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];
+  const dirs = [join3(dir, "projects"), join3(dir, "specs"), dir];
   console.log(source_default.bold(`
 Spec Analysis
 `));
   let found = false, hasGaps = false;
   for (const dd of dirs) {
-    if (!existsSync2(dd))
+    if (!existsSync3(dd))
       continue;
-    const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const projects = readdirSync3(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const p of projects) {
       if (opts.project && p !== opts.project)
         continue;
-      const pd = join2(dd, p);
-      if (!existsSync2(join2(pd, "SPEC.dog")))
+      const pd = join3(dd, p);
+      if (!existsSync3(join3(pd, "SPEC.dog")))
         continue;
-      if (!existsSync2(pd))
+      if (!existsSync3(pd))
         continue;
-      const files = readdirSync2(pd).filter((f) => f.endsWith(".dog"));
+      const files = readdirSync3(pd).filter((f) => f.endsWith(".dog"));
       if (!files.length)
         continue;
       found = true;
@@ -3514,7 +3797,7 @@ Spec Analysis
       const allRelationships = [];
       const analyses = [];
       for (const f of files) {
-        const content = readFileSync2(join2(pd, f), "utf-8");
+        const content = readFileSync3(join3(pd, f), "utf-8");
         const ast = parse(content);
         const entities = ast.sections.flatMap((s) => s.blocks.filter((b) => b.kind === "entity"));
         const rels = ast.sections.flatMap((s) => s.blocks.filter((b) => b.kind === "relationship"));
@@ -3556,6 +3839,39 @@ Spec Analysis
         if (r.target && !entityNames.has(r.target))
           gaps.push(`\uD83D\uDFE1 Relationship: unknown target "${r.target}"`);
       }
+      const contradictions = [];
+      const relMap = new Map;
+      for (const r of allRelationships) {
+        const key = `${r.source}→${r.target}`;
+        if (!relMap.has(key))
+          relMap.set(key, []);
+        relMap.get(key).push(r);
+      }
+      for (const [key, rels] of relMap) {
+        if (rels.length > 1) {
+          const verbs = [...new Set(rels.map((r) => r.verb))];
+          if (verbs.length > 1)
+            contradictions.push(`\uD83D\uDD34 Contradiction: "${key}" has conflicting verbs: ${verbs.join(", ")}`);
+          else
+            contradictions.push(`\uD83D\uDFE1 Duplicate: "${key}" appears ${rels.length} times with same verb "${verbs[0]}"`);
+        }
+      }
+      for (const r of allRelationships) {
+        const reverse = allRelationships.find((r2) => r2.source === r.target && r2.target === r.source);
+        if (reverse && r.verb !== reverse.verb && r.source < r.target) {
+          contradictions.push(`\uD83D\uDFE1 Bidirectional: "${r.source}→${r.target}" verb "${r.verb}" vs "${reverse.source}→${reverse.target}" verb "${reverse.verb}"`);
+        }
+      }
+      for (const c of contradictions) {
+        if (c.startsWith("\uD83D\uDD34"))
+          hasGaps = true;
+      }
+      if (contradictions.length > 0) {
+        console.log(source_default.bold(`
+  Contradictions (${contradictions.length})`));
+        for (const c of contradictions)
+          console.log(`  ${c}`);
+      }
       if (gaps.length > 0) {
         console.log(source_default.bold(`
   Gaps (${gaps.length})`));
@@ -3575,19 +3891,19 @@ Spec Analysis
 });
 program2.command("generate [dir]").description("Generate missing spec files from SPEC.dog").option("-p, --project <name>").action((d = ".", opts) => {
   const dir = resolvePath2(d);
-  const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];
+  const dirs = [join3(dir, "projects"), join3(dir, "specs"), dir];
   let specContent = "", specDir = "";
   for (const dd of dirs) {
-    if (!existsSync2(dd))
+    if (!existsSync3(dd))
       continue;
-    const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const projects = readdirSync3(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const p of projects) {
       if (opts.project && p !== opts.project)
         continue;
-      const pd = join2(dd, p);
-      const sp = join2(pd, "SPEC.dog");
-      if (existsSync2(sp)) {
-        specContent = readFileSync2(sp, "utf-8");
+      const pd = join3(dd, p);
+      const sp = join3(pd, "SPEC.dog");
+      if (existsSync3(sp)) {
+        specContent = readFileSync3(sp, "utf-8");
         specDir = pd;
         break;
       }
@@ -3618,7 +3934,7 @@ Spec Generator
         uiStrings.push({ screen: section.heading, element: "label", text: m });
     }
   }
-  if (!existsSync2(join2(specDir, "data-model.dog")) && entities.length > 0) {
+  if (!existsSync3(join3(specDir, "data-model.dog")) && entities.length > 0) {
     let dm = `# Data Model
 
 ## Core Entities
@@ -3651,10 +3967,16 @@ ${e.description || "No description."}
 `;
       dm += "```\n\n";
     }
-    writeFileSync(join2(specDir, "data-model.dog"), dm);
+    writeFileSync2(join3(specDir, "data-model.dog"), dm);
+    try {
+      parse(dm);
+    } catch (_) {
+      console.log(source_default.red("  ✗ Generated data-model.dog is invalid"));
+      process.exit(1);
+    }
     console.log(source_default.green(`  ✓ data-model.dog (${entities.length} entities)`));
   }
-  if (!existsSync2(join2(specDir, "COPY.dog")) && uiStrings.length > 0) {
+  if (!existsSync3(join3(specDir, "COPY.dog")) && uiStrings.length > 0) {
     let copy = `# App Copy
 
 | Screen | Element | Copy |
@@ -3663,10 +3985,16 @@ ${e.description || "No description."}
     for (const s of uiStrings)
       copy += `| ${s.screen} | ${s.element} | ${s.text} |
 `;
-    writeFileSync(join2(specDir, "COPY.dog"), copy);
+    writeFileSync2(join3(specDir, "COPY.dog"), copy);
+    try {
+      parse(copy);
+    } catch (_) {
+      console.log(source_default.red("  ✗ Generated COPY.dog is invalid"));
+      process.exit(1);
+    }
     console.log(source_default.green(`  ✓ COPY.dog (${uiStrings.length} strings)`));
   }
-  if (!existsSync2(join2(specDir, "INDEX.dog"))) {
+  if (!existsSync3(join3(specDir, "INDEX.dog"))) {
     let idx = `# INDEX
 
 | You are... | Start here | Then... |
@@ -3678,41 +4006,149 @@ ${e.description || "No description."}
 `;
     idx += `| Designer | SPEC.dog | COPY.dog |
 `;
-    writeFileSync(join2(specDir, "INDEX.dog"), idx);
+    writeFileSync2(join3(specDir, "INDEX.dog"), idx);
+    try {
+      parse(idx);
+    } catch (_) {
+      console.log(source_default.red("  ✗ Generated INDEX.dog is invalid"));
+      process.exit(1);
+    }
     console.log(source_default.green("  ✓ INDEX.dog"));
   }
   console.log(source_default.bold(`
 Run dotdog validate to verify.
 `));
 });
-program2.command("simulate <scenario>").description("Run a simulation scenario (phase 1 stub)").option("-p, --project <name>", "Project name", "default").action((scenario, opts) => {
+program2.command("simulate <scenario>").description("Walk through a scenario, check pre/postconditions").option("-p, --project <name>").action((scenario, opts) => {
+  const dir = resolvePath2(".");
+  const dirs = [join3(dir, "projects"), join3(dir, "specs"), dir];
+  let projectDir = "";
+  for (const dd of dirs) {
+    if (!existsSync3(dd))
+      continue;
+    const projects = readdirSync3(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    for (const p of projects) {
+      if (opts.project && p !== opts.project)
+        continue;
+      const pd = join3(dd, p);
+      if (existsSync3(join3(pd, "SPEC.dog"))) {
+        projectDir = pd;
+        break;
+      }
+    }
+    if (projectDir)
+      break;
+  }
+  if (!projectDir) {
+    console.log(source_default.red("Project not found."));
+    return;
+  }
+  const dagFile = join3(projectDir, `${opts.project || projectDir.split("/").pop()}.dag`);
+  let entities = [], relationships = [];
+  if (existsSync3(dagFile)) {
+    const dag = JSON.parse(readFileSync3(dagFile, "utf-8"));
+    const simNodes = dag.n || dag.nodes || [];
+    const isV22 = (n) => Array.isArray(n) && typeof n[0] === "number";
+    entities = simNodes.map((n) => (isV22(n) ? n[1] || String(n[0]) : n.i || n.id || "").toLowerCase());
+    if (dag.e || dag.edges) {
+      relationships = dag.e || dag.edges || [];
+    } else {
+      const seen = new Set;
+      for (const n of simNodes) {
+        const edges = isV22(n) ? n[6] || [] : n.es || [];
+        for (const e of edges) {
+          const srcName = isV22(n) ? n[1] || String(n[0]) : n.i || n.id || "";
+          const tgtName = isV22(n) ? (simNodes[e[0]] ? simNodes[e[0]][2] : "") || String(e[0]) : e.t || "";
+          const verb = isV22(n) ? e[1] || "" : e.v || "";
+          const key = `${srcName}→${tgtName}:${verb}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            relationships.push({ s: srcName, t: tgtName, v: verb });
+          }
+        }
+      }
+    }
+  }
+  const specFile = join3(projectDir, "SPEC.dog");
+  const specContent = existsSync3(specFile) ? readFileSync3(specFile, "utf-8") : "";
   console.log(source_default.bold(`
-Simulation: ${scenario} (project: ${opts.project})
-`));
-  console.log(source_default.gray("Simulation engine : reads SPEC.dog scenarios, walks through steps, checks pre/postconditions."));
-  console.log(source_default.gray("Full engine coming in a future release."));
+Simulation: ${scenario}`));
+  console.log(source_default.gray(`Project: ${projectDir.split("/").pop()} | Entities: ${entities.length} | Relationships: ${relationships.length}`));
+  const steps = [];
+  const stepMatches = specContent.match(/\[(\d+)\/\d+\]\s*(.+)/g);
+  if (stepMatches) {
+    for (const m of stepMatches) {
+      const step = m.replace(/\[\d+\/\d+\]\s*/, "");
+      if (step)
+        steps.push(step);
+    }
+  }
+  if (steps.length === 0) {
+    console.log(source_default.yellow(`
+  No scenario steps found in SPEC.dog.`));
+    console.log(source_default.gray("  Add steps like: [1/3] User taps button"));
+    return;
+  }
+  let passed = 0, failed = 0;
+  for (let i = 0;i < steps.length; i++) {
+    const step = steps[i];
+    console.log(source_default.cyan(`
+  [${i + 1}/${steps.length}] ${step}`));
+    let foundRef = false;
+    for (const e of entities) {
+      if (step.toLowerCase().includes(e)) {
+        console.log(source_default.green(`    ✓ References entity: ${e}`));
+        foundRef = true;
+      }
+    }
+    for (const r of relationships) {
+      const src = (r.s || r.source || "").toLowerCase();
+      const tgt = (r.t || r.target || "").toLowerCase();
+      const verb = (r.v || r.verb || "").toLowerCase();
+      if (step.toLowerCase().includes(src) && step.toLowerCase().includes(tgt)) {
+        console.log(source_default.green(`    ✓ References relationship: ${src} → ${tgt}`));
+        foundRef = true;
+      }
+      if (verb && step.toLowerCase().includes(verb)) {
+        console.log(source_default.green(`    ✓ References verb: ${verb}`));
+        foundRef = true;
+      }
+    }
+    if (!foundRef) {
+      console.log(source_default.yellow(`    ⚠ No entity or relationship references found`));
+      failed++;
+    } else {
+      passed++;
+    }
+  }
+  console.log(source_default.bold(`
+  RESULT: ${failed === 0 ? source_default.green("Success") : source_default.yellow("Partial")} (${passed}/${steps.length} steps passed)`));
+  if (failed > 0)
+    console.log(source_default.red(`  ${failed} steps have no spec references — entities or relationships may be missing.`));
+  if (failed === 0)
+    console.log(source_default.green("  All steps reference known entities and relationships."));
 });
 program2.command("staleness [dir]").action((d = ".") => {
   const dir = resolvePath2(d);
-  const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];
+  const dirs = [join3(dir, "projects"), join3(dir, "specs"), dir];
   console.log(source_default.bold(`Staleness Audit
 `));
   for (const dd of dirs) {
-    if (!existsSync2(dd))
+    if (!existsSync3(dd))
       continue;
-    const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const projects = readdirSync3(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const p of projects) {
-      const pd = join2(dd, p);
-      if (!existsSync2(join2(pd, "SPEC.dog")))
+      const pd = join3(dd, p);
+      if (!existsSync3(join3(pd, "SPEC.dog")))
         continue;
-      if (!existsSync2(pd))
+      if (!existsSync3(pd))
         continue;
-      const planFile = join2(pd, "plan.dog");
-      if (!existsSync2(planFile)) {
+      const planFile = join3(pd, "plan.dog");
+      if (!existsSync3(planFile)) {
         console.log(source_default.yellow(`  ${p}: No plan.dog`));
         continue;
       }
-      const plan = readFileSync2(planFile, "utf-8");
+      const plan = readFileSync3(planFile, "utf-8");
       const tasks = [...plan.matchAll(/^\s*- \[([ x])\]\s+(.+)/gm)];
       let issues = 0;
       for (const m of tasks) {
@@ -3723,14 +4159,15 @@ program2.command("staleness [dir]").action((d = ".") => {
         const phase = phaseMatch ? parseInt(phaseMatch[1]) : 99;
         if (phase > 3)
           continue;
-        if (text.includes("npm publish") || text.includes("npm install")) {
-          try {
-            const pkg2 = JSON.parse(readFileSync2(join2(resolvePath2("."), "packages/dotdog/package.json"), "utf-8"));
-            if (pkg2.version && !done) {
+        if ((text.includes("npm publish") || text.includes("npm install")) && !done) {
+          const pkgPath = join3(resolvePath2("."), "packages/dotdog/package.json");
+          if (existsSync3(pkgPath)) {
+            const pkg2 = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+            if (pkg2.version) {
               console.log(source_default.yellow(`  ⚠ Should be [x]: ${m[2].trim()}`));
               issues++;
             }
-          } catch {}
+          }
         }
         if (text.includes("compile")) {
           if (!done) {
@@ -3739,7 +4176,7 @@ program2.command("staleness [dir]").action((d = ".") => {
           }
         }
         if (text.includes("generate") && !done) {
-          if (existsSync2(join2(dir, "packages/dotdog/src/cli.ts")) || existsSync2(join2(dir, "packages/spec-cli/src/generate.ts"))) {
+          if (existsSync3(join3(dir, "packages/dotdog/src/cli.ts")) || existsSync3(join3(dir, "packages/spec-cli/src/generate.ts"))) {
             console.log(source_default.yellow(`  ⚠ Should be [x]: ${m[2].trim()}`));
             issues++;
           }
@@ -3759,6 +4196,214 @@ program2.command("woof").action(() => {
   console.log(" /   (_____/");
   console.log("/_____/   U");
 });
+program2.command("index [dir]").description("Build search index for semantic queries").action((d = ".") => {
+  const dir = resolvePath2(d);
+  const dirs = [join3(dir, "projects"), join3(dir, "specs"), dir];
+  let built = 0;
+  for (const dd of dirs) {
+    if (!existsSync3(dd))
+      continue;
+    const projects = readdirSync3(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    for (const p of projects) {
+      const pd = join3(dd, p);
+      if (!existsSync3(join3(pd, "SPEC.dog")))
+        continue;
+      const idx = buildIndex(pd, p);
+      writeFileSync2(join3(pd, `${p}.idx`), JSON.stringify(idx));
+      console.log(source_default.green(`  ✓ ${p} : ${idx.entries.length} sections indexed (${idx.vocabulary.length} terms)`));
+      built++;
+    }
+  }
+  if (!built)
+    console.log(source_default.yellow("No projects found. Run dotdog init first."));
+});
+program2.command("search <query>").description("Semantic search across compiled specs").option("-p, --project <name>").action((query, opts) => {
+  console.log(source_default.bold(`
+Search: "${query}"
+`));
+  const dir = resolvePath2(".");
+  const dirs = [join3(dir, "projects"), join3(dir, "specs"), dir];
+  let found = false;
+  for (const dd of dirs) {
+    if (!existsSync3(dd))
+      continue;
+    const projects = readdirSync3(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    for (const p of projects) {
+      if (opts.project && p !== opts.project)
+        continue;
+      const pd = join3(dd, p);
+      const idxFile = join3(pd, `${p}.idx`);
+      if (!existsSync3(idxFile))
+        continue;
+      found = true;
+      const idx = JSON.parse(readFileSync3(idxFile, "utf-8"));
+      const results = searchIndex(idx, query, 8);
+      if (results.length === 0) {
+        console.log(source_default.gray(`  ${p}: No matches`));
+        continue;
+      }
+      console.log(source_default.green(`  ${p} — ${results.length} results:`));
+      for (const r of results) {
+        const preview = r.entry.content.replace(/\n/g, " ").slice(0, 100);
+        console.log(source_default.gray(`    ${Math.round(r.score * 100)}%  [${r.entry.file}] ${r.entry.heading}`));
+        console.log(source_default.gray(`         ${preview}...`));
+      }
+    }
+  }
+  if (!found)
+    console.log(source_default.yellow("No index found. Run dotdog index first."));
+});
+program2.command("predictions [dir]").description("List all predictions with status").option("-p, --project <name>").action((d = ".", opts) => {
+  const dir = resolvePath2(d);
+  const dirs = [join3(dir, "projects"), join3(dir, "specs"), dir];
+  console.log(source_default.bold(`
+Predictions
+`));
+  let found = false;
+  for (const dd of dirs) {
+    if (!existsSync3(dd))
+      continue;
+    const projects = readdirSync3(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    for (const p of projects) {
+      if (opts.project && p !== opts.project)
+        continue;
+      const pd = join3(dd, p);
+      if (!existsSync3(join3(pd, "SPEC.dog")))
+        continue;
+      const files = readdirSync3(pd).filter((f) => f.endsWith(".dog"));
+      for (const f of files) {
+        const content = readFileSync3(join3(pd, f), "utf-8");
+        const ast = parse(content);
+        for (const section of ast.sections) {
+          for (const block of section.blocks) {
+            if (block.kind === "prediction") {
+              found = true;
+              const b = block;
+              const status = b.status || "pending";
+              const icon = status === "correct" ? "✅" : status === "wrong" ? "❌" : status === "partial" ? "⚠️" : "⏳";
+              console.log(`  ${icon} ${b.statement || b.name} (${(b.confidence * 100).toFixed(0)}% confidence, ${status})`);
+              if (b.measurement)
+                console.log(source_default.gray(`    Measurement: ${b.measurement}`));
+              if (b.timeframe)
+                console.log(source_default.gray(`    Timeframe: ${b.timeframe}`));
+            }
+          }
+        }
+      }
+    }
+  }
+  if (!found)
+    console.log(source_default.yellow("No predictions found."));
+});
+program2.command("resolve <name>").description("Mark a prediction as correct, wrong, or partial").option("-p, --project <name>").option("--correct", "Prediction was correct").option("--wrong", "Prediction was wrong").option("--partial", "Prediction was partially correct").action((name, opts) => {
+  const dir = resolvePath2(".");
+  const dirs = [join3(dir, "projects"), join3(dir, "specs"), dir];
+  const status = opts.correct ? "correct" : opts.wrong ? "wrong" : opts.partial ? "partial" : null;
+  if (!status) {
+    console.log(source_default.red("Specify --correct, --wrong, or --partial"));
+    return;
+  }
+  for (const dd of dirs) {
+    if (!existsSync3(dd))
+      continue;
+    const projects = readdirSync3(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    for (const p of projects) {
+      if (opts.project && p !== opts.project)
+        continue;
+      const pd = join3(dd, p);
+      if (!existsSync3(join3(pd, "SPEC.dog")))
+        continue;
+      const files = readdirSync3(pd).filter((f) => f.endsWith(".dog"));
+      for (const f of files) {
+        const fp = join3(pd, f);
+        let content = readFileSync3(fp, "utf-8");
+        const originalContent = readFileSync3(fp, "utf-8");
+        const ast = parse(content);
+        for (const section of ast.sections) {
+          for (const block of section.blocks) {
+            if (block.kind === "prediction") {
+              const b = block;
+              if ((b.statement || b.name || "").toLowerCase().includes(name.toLowerCase())) {
+                const searchFor = `### Prediction: ${b.statement || b.name}`;
+                const headingIdx = content.indexOf(searchFor);
+                if (headingIdx >= 0) {
+                  const blockStart = content.indexOf("```yaml", headingIdx);
+                  const blockEnd = content.indexOf("```", blockStart + 7);
+                  if (blockStart >= 0 && blockEnd >= 0) {
+                    const yamlBlock = content.slice(blockStart, blockEnd + 3);
+                    let newYaml = yamlBlock;
+                    if (yamlBlock.includes("status:")) {
+                      newYaml = yamlBlock.replace(/status:\s*\w+/, `status: ${status}`);
+                    } else {
+                      newYaml = yamlBlock.replace(/\n\s*(trigger|timeframe|confidence|measurement):/, `
+  status: ${status}
+$&`);
+                    }
+                    content = content.replace(yamlBlock, newYaml);
+                    try {
+                      parse(content);
+                      writeFileSync2(fp, content, "utf-8");
+                      console.log(source_default.green(`  ✓ ${b.statement || b.name}: ${status}`));
+                    } catch (_) {
+                      writeFileSync2(fp, originalContent, "utf-8");
+                      console.log(source_default.red(`  ✗ resolve produced invalid output for "${name}" — reverted`));
+                      process.exit(1);
+                    }
+                    return;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  console.log(source_default.yellow(`Prediction "${name}" not found.`));
+});
+var kitDir = join3(resolve2(import.meta.dirname || "."), "..", "kits");
+var builtInKits = existsSync3(kitDir) ? readdirSync3(kitDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) : [];
+var kitCmd = program2.command("kit").description("Manage spec kits");
+kitCmd.command("list").description("List available kits").action(() => {
+  console.log(source_default.bold(`
+Available kits
+`));
+  if (builtInKits.length === 0) {
+    console.log(source_default.gray("  No built-in kits found."));
+  } else {
+    for (const k of builtInKits) {
+      const specFile = join3(kitDir, k, "SPEC.dog");
+      const desc = existsSync3(specFile) ? readFileSync3(specFile, "utf-8").split(`
+`)[1]?.replace(/^>\s*/, "") || "" : "";
+      console.log(`  ${source_default.green(k)}  ${source_default.gray(desc)}`);
+    }
+  }
+  console.log(source_default.gray(`
+  Community kits: npm install @scope/kit-<name> then dotdog kit install <name>`));
+});
+kitCmd.command("init <kit>").description("Init a project from a kit").option("-p, --project <name>").action((kit, opts) => {
+  const src = join3(kitDir, kit);
+  if (!existsSync3(src)) {
+    console.log(source_default.red(`Kit "${kit}" not found. Available: ${builtInKits.join(", ")}`));
+    return;
+  }
+  const projectName = opts.project || kit;
+  const dir = resolvePath2(".");
+  const dest = join3(dir, "specs", projectName);
+  if (existsSync3(dest)) {
+    console.log(source_default.yellow(`Project "${projectName}" already exists.`));
+    return;
+  }
+  mkdirSync(dest, { recursive: true });
+  const files = readdirSync3(src).filter((f) => f.endsWith(".dog"));
+  for (const f of files) {
+    writeFileSync2(join3(dest, f), readFileSync3(join3(src, f), "utf-8"));
+    console.log(source_default.green(`  ✓ ${f}`));
+  }
+  console.log(source_default.gray(`
+  Kit "${kit}" initialized in specs/${projectName}/`));
+  console.log(source_default.gray(`  Run: dotdog validate`));
+});
 program2.parse();
 export {
   parseToJSON,