dotdog 0.3.6 → 0.4.1

package/README.md

@@ -1,76 +1,130 @@
-# spec-platform
+# dotdog
 
-Monorepo for the Spec Platform — a knowledge graph system where specs ARE the database and LLMs ARE the query engine.
+[![npm version](https://img.shields.io/npm/v/dotdog)](https://www.npmjs.com/package/dotdog)
+[![npm downloads](https://img.shields.io/npm/dm/dotdog)](https://www.npmjs.com/package/dotdog)
+[![License: MIT](https://img.shields.io/npm/l/dotdog)](https://github.com/specdog/dotdog/blob/main/LICENSE)
+[![CI](https://github.com/specdog/dotdog/actions/workflows/test.yml/badge.svg)](https://github.com/specdog/dotdog/actions)
 
-## The Flywheel
+> **Feed the dog. Ship with specs.** Write .dog specs. Dog checks them. AI agents fetch them.
 
-```
-spec → validate → app → data → better spec → better app → ...
+## Install
+
+```bash
+npm install -g dotdog
 ```
 
-The spec describes the platform. The platform validates the spec. The validation report improves the spec. Each cycle adds granularity.
+Requires Node.js >= 20.
 
-## Structure
+## Quick Start
 
+```bash
+dotdog init my-project     # scaffold a spec genome
+dotdog validate            # score completeness (0-100%)
+dotdog analyze             # deep analysis : gaps, suggestions, entity audit
 ```
-spec-platform/
-├── packages/
-│   ├── spec-engine/     # Core types and ontology (shared by everything)
-│   ├── spec-mcp/        # MCP Server — AI agents query specs via stdio
-│   └── spec-cli/        # CLI — spec validate, init, simulate, list
-├── projects/            # Spec genomes (dogfooding)
-│   └── spec-platform/
-│       └── specs/
-│           ├── SPEC.dog          # Product spec — screens, flows, stories
-│           ├── constitution.dog  # Immutable rules
-│           └── data-model.dog    # Graph ontology — nodes, edges, tasks, predictions, vectors
-├── templates/           # Spec genome templates for new projects
-└── package.json         # Bun workspace root
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `dotdog validate [dir]` | Score spec completeness. Checks file existence, entity descriptions, section counts. |
+| `dotdog analyze [dir]` | Deep analysis. Detects domain, stack, gaps with severity, entity quality audit. |
+| `dotdog parse <file>` | Parse a `.dog` file into sections. |
+| `dotdog compile [dir]` | Compile `.dog` files into a `.dag` graph (JSON). |
+| `dotdog visualize [dir]` | Output Mermaid graph from `.dag`. `--save` writes `.md` for GitHub rendering. |
+| `dotdog serve [dir]` | Start MCP server over stdio. AI agents query specs without hallucination. |
+| `dotdog staleness [dir]` | Detect drift between spec and reality. Compares plan.dog tasks against code. |
+| `dotdog generate [dir]` | Generate missing spec files from SPEC.dog (data-model, COPY, INDEX). |
+| `dotdog simulate <scenario>` | Run a simulation scenario. Reads SPEC.dog scenarios, checks pre/postconditions. |
+| `dotdog init <project>` | Scaffold a new spec genome project with templates. |
+| `dotdog list` | List all projects and their `.dog` file counts. |
+
+## File Formats
+
+### `.dog` : Human-Written Spec Genome
+
+Markdown prose + YAML structured blocks. Free and open source. Define entities, relationships, events, predictions, and copy in a single format that both humans and parsers understand.
+
+```markdown
+### Entity: User
+
+A person who uses the app.
+
+` ``yaml
+entity: User
+type: entity
+properties:
+  id:
+    type: string
+    required: true
+  email:
+    type: string
+    required: true
+states: [active, suspended]
+lifecycle: active → suspended
+` ``
 ```
 
-## Quick Start
+### `.dag` : Machine-Compiled Graph
 
-```bash
-bun install
-cd projects/spec-platform/specs
+JSON graph compiled from `.dog` files. Nodes, edges, properties, and states in a deterministic structure. 85% token savings vs raw `.dog` files for AI agents.
 
-# Validate our own spec (dogfood)
-bun ../../../packages/spec-cli/src/index.ts validate ../..
+## MCP Server : AI Agent Integration
 
-# List projects
-bun ../../../packages/spec-cli/src/index.ts list
-```
+`dotdog serve` exposes specs to any MCP-compatible AI agent over stdio. Six tools:
 
-## $0 Stack
+| Tool | Description |
+|------|-------------|
+| `getEntity` | Exact entity with properties, states, lifecycle, and connected edges |
+| `traverse` | BFS subgraph from any starting node to any depth |
+| `search` | Find entities by name or type |
+| `schema` | Property definitions only : zero prose, agent-optimized |
+| `summary` | Node count, edge count, file count, compile time |
+| `listProjects` | Array of project names |
 
-| Component | Technology | Cost |
-|-----------|-----------|------|
-| Runtime | Bun | $0 |
-| Database | bun:sqlite (embedded) | $0 |
-| Types | TypeScript (strict) | $0 |
-| CLI | Commander.js + chalk | $0 |
-| MCP Server | @modelcontextprotocol/sdk (stdio) | $0 |
-| Embeddings | all-MiniLM-L6-v2 (local) | $0 |
-| Hosting | None needed (local-first) | $0 |
+Agent workflow: `listProjects` → `getEntity` → `traverse` graph.
 
-## The Spec Graph
+## Dogfood
 
-The spec is not a document. It's a knowledge graph.
+dotdog validates its own specs. Every PR:
+
+```
+dotdog validate → find gaps → fix spec → PR → merge → tag → CI publish
+```
 
-- **Nodes**: entities, tasks, predictions, screens, constraints, user stories
-- **Edges**: contains, depends_on, implements, references, calls, precedes
-- **Vectors**: every section embedded for semantic search, contradiction detection, staleness checks
-- **Predictions**: forecasts with triggers, timeframes, confidence, and actual outcome tracking
+Eat your own dogfood. The tool is the project.
 
-LLMs traverse the graph at query time. They don't read prose and guess — they get exact typed values.
+## VS Code Extension
 
-## Score
+Syntax highlighting for `.dog` files. Install:
 
+```bash
+cp -r extensions/vscode ~/.vscode/extensions/dotdog
 ```
-spec validate → 43% complete
 
-  ✓ SPEC.dog
-  ✓ constitution.dog
-  ✓ data-model.dog
-  ⚠ COPY.dog, DESIGN-SYSTEM.dog, plan.dog, INDEX.dog
+## Format Specifications
+
+- [`.dog` format spec](spec/format-spec.dog) : language definition, EBNF grammar, validation rules
+- [`.dag` format spec](spec/format-spec-dag.dog) : graph definition, MCP API, token efficiency
+
+## Links
+
+- **GitHub:** [specdog/dotdog](https://github.com/specdog/dotdog)
+- **npm:** [dotdog](https://www.npmjs.com/package/dotdog)
+- **Docs:** [GitHub Pages](https://specdog.github.io/dotdog)
+- **llms.txt:** [llms.txt](llms.txt) : structured for AI agent discovery
+- **AGENTS.md:** [AGENTS.md](AGENTS.md) : instructions for AI coding agents
+
+## Spec-Driven Development
+
+dotdog is built for SDD. Write your spec first. Validate it. Compile it. Let AI agents query it. The spec is the source of truth.
+
+```
+spec → validate → compile → serve → AI agent queries
 ```
+
+No more specs that rot in a wiki. No more agents guessing from prose. One source. Zero ambiguity.
+
+## License
+
+MIT

package/dist/cli.js

@@ -3108,8 +3108,14 @@ function resolvePath(p) {
   }
   return resolved;
 }
+var isV2 = (n) => Array.isArray(n) && typeof n[0] === "number";
 var N = (dag) => dag.n || dag.nodes || [];
+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) {
@@ -3119,21 +3125,31 @@ function E(dag) {
   const seen = new Set;
   for (const node of N(dag)) {
     for (const e of nodeEdges(node)) {
-      const key = `${node.i || node.id}→${e.t}:${e.v}`;
+      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: node.i || node.id, t: e.t, v: e.v, d: e.d, c: e.c, r: e.r });
+        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 = ".") {
@@ -3203,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] || "");
@@ -3221,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)}`;
@@ -3431,6 +3447,12 @@ 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)) {
     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(`
@@ -3555,44 +3577,63 @@ program2.command("compile [dir]").option("-o, --output <file>").action((d = ".",
           }
         }
       }
-      const nodeIds = new Map;
-      nodes.forEach((n, i) => nodeIds.set(n.i, i));
-      const inDegree = new Array(nodes.length).fill(0);
-      const adj = new Array(nodes.length).fill(0).map(() => []);
+      const entityNames = new Set(nodes.map((n) => n.i));
       for (const e of edges) {
-        const si = nodeIds.get(e.s), ti = nodeIds.get(e.t);
-        if (si !== undefined && ti !== undefined) {
-          adj[si].push(ti);
-          inDegree[ti]++;
+        if (e.s && !entityNames.has(e.s)) {
+          console.log(source_default.red(`  ✗ Unknown relationship source "${e.s}" (target: "${e.t}")`));
+          process.exit(1);
         }
-      }
-      const queue = [];
-      for (let j = 0;j < nodes.length; j++)
-        if (inDegree[j] === 0)
-          queue.push(j);
-      const order = [];
-      while (queue.length > 0) {
-        const u = queue.shift();
-        order.push(nodes[u].i);
-        for (const v of adj[u]) {
-          inDegree[v]--;
-          if (inDegree[v] === 0)
-            queue.push(v);
+        if (e.t && !entityNames.has(e.t)) {
+          console.log(source_default.red(`  ✗ Unknown relationship target "${e.t}" (source: "${e.s}")`));
+          process.exit(1);
         }
       }
-      const cycles = order.length !== nodes.length;
+      const nodeIds = new Map;
+      nodes.forEach((n, i) => nodeIds.set(n.i, i));
+      const v2nodes = [];
       for (let j = 0;j < nodes.length; j++) {
-        const id = nodes[j].i;
-        nodes[j].es = edges.filter((e) => e.s === id || e.t === id).map((e) => ({
-          t: e.s === id ? e.t : e.s,
-          v: e.v || "",
-          d: e.d || "",
-          c: e.c,
-          r: e.r,
-          dir: e.s === id ? "out" : "in"
-        }));
+        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: "1.5", p, c: `dotdog@${pkg.version}`, n: nodes, o: order, cy: cycles };
+      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;
@@ -3636,13 +3677,17 @@ program2.command("tokens [dir]").action((d = ".") => {
       }
       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`));
       }
     }
@@ -3663,22 +3708,32 @@ program2.command("visualize [dir]").option("-s, --save").action((d = ".", opts)
         continue;
       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 nodes) {
-        const raw = n.i || n.id || "";
-        const id = raw.replace(/\s+/g, "_").replace(/^[^a-zA-Z]+/, "n_");
+        const raw = isV22(n) ? n[1] || String(n[0]) : n.i || n.id || "";
         if (raw)
-          out += `    ${id}[${raw}]
+          out += `    ${slug(raw)}[${raw}]
 `;
       }
       const seen = new Set;
       for (const n of nodes) {
-        for (const e of n.es || []) {
-          if (e.dir === "in")
-            continue;
-          const src = (n.i || n.id || "").replace(/\s+/g, "_").replace(/^[^a-zA-Z]+/, "n_");
-          const tgt = (e.t || "").replace(/\s+/g, "_").replace(/^[^a-zA-Z]+/, "n_");
-          const verb = e.v || "";
+        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);
@@ -3689,8 +3744,8 @@ program2.command("visualize [dir]").option("-s, --save").action((d = ".", opts)
       }
       const legacyEdges = dag.e || dag.edges || [];
       for (const e of legacyEdges) {
-        const src = (e.s || e.source || "").replace(/\s+/g, "_").replace(/^[^a-zA-Z]+/, "n_");
-        const tgt = (e.t || e.target || "").replace(/\s+/g, "_").replace(/^[^a-zA-Z]+/, "n_");
+        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) {
@@ -3913,6 +3968,12 @@ ${e.description || "No description."}
       dm += "```\n\n";
     }
     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 (!existsSync3(join3(specDir, "COPY.dog")) && uiStrings.length > 0) {
@@ -3925,6 +3986,12 @@ ${e.description || "No description."}
       copy += `| ${s.screen} | ${s.element} | ${s.text} |
 `;
     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 (!existsSync3(join3(specDir, "INDEX.dog"))) {
@@ -3940,6 +4007,12 @@ ${e.description || "No description."}
     idx += `| Designer | SPEC.dog | COPY.dog |
 `;
     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(`
@@ -3974,19 +4047,23 @@ program2.command("simulate <scenario>").description("Walk through a scenario, ch
   let entities = [], relationships = [];
   if (existsSync3(dagFile)) {
     const dag = JSON.parse(readFileSync3(dagFile, "utf-8"));
-    entities = (dag.n || dag.nodes || []).map((n) => (n.i || n.id || "").toLowerCase());
+    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 dag.n || dag.nodes || []) {
-        for (const e of n.es || []) {
-          if (e.dir === "in")
-            continue;
-          const key = `${n.i || n.id}→${e.t}:${e.v}`;
+      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: n.i || n.id, t: e.t, v: e.v, d: e.d, r: e.r });
+            relationships.push({ s: srcName, t: tgtName, v: verb });
           }
         }
       }
@@ -4240,6 +4317,7 @@ program2.command("resolve <name>").description("Mark a prediction as correct, wr
       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) {
@@ -4259,11 +4337,18 @@ program2.command("resolve <name>").description("Mark a prediction as correct, wr
                     } else {
                       newYaml = yamlBlock.replace(/\n\s*(trigger|timeframe|confidence|measurement):/, `
   status: ${status}
-  $1`);
+$&`);
                     }
                     content = content.replace(yamlBlock, newYaml);
-                    writeFileSync2(fp, content, "utf-8");
-                    console.log(source_default.green(`  ✓ ${b.statement || b.name}: ${status}`));
+                    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;
                   }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotdog",
-  "version": "0.3.6",
+  "version": "0.4.1",
   "description": "CLI tool for structured software specifications. Validate .dog files, compile .dag graphs, query via MCP.",
   "type": "module",
   "main": "dist/cli.js",
@@ -16,14 +16,23 @@
     "kits/"
   ],
   "keywords": [
-    "specification",
+    "agent",
+    "ai",
+    "bun",
     "cli",
-    "mcp",
-    "graph",
+    "code-generation",
     "dag",
-    "yaml",
+    "graph",
+    "knowledge-graph",
+    "llm",
     "markdown",
-    "spec-driven-development"
+    "mcp",
+    "spec-driven-development",
+    "spec-genome",
+    "specification",
+    "structured",
+    "typescript",
+    "yaml"
   ],
   "license": "MIT",
   "author": "specdog",
@@ -34,5 +43,9 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "homepage": "https://specdog.github.io/dotdog",
+  "bugs": {
+    "url": "https://github.com/specdog/dotdog/issues"
   }
 }