verderer 0.4.0 → 0.5.0

package/README.md

@@ -21,6 +21,8 @@ npx verderer verdict 9f2c dead --evidence "derived it from neighboring code"
 npx verderer probe                       # the ablation recipe (automation is the roadmap)
 ```
 
+A rule is a top-level list item (`-`, `*`, `+`, `1.`) or a paragraph that opens with a bold lead (`**Never trust a merged schema.** Every module…`). Code blocks and spec-kit's generated sections (`Active Technologies`, `Recent Changes`) are skipped.
+
 `scan` is idempotent and append-only: known rules keep their provenance and verdicts, new rules are dated, rules that left the file are marked retired — never deleted. The ledger is the history of your harness's law.
 
 Rewording a rule doesn't reset it. A rule edited in place (same spot, mostly the same words, or a trim of them) keeps its provenance and verdict, and its old wording goes into `revisions`. The verdict judged the old wording, so it shows as stale until you re-run the inquest.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "verderer",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A rule ledger for AI agent harnesses: per-rule provenance for CLAUDE.md/AGENTS.md, plus ablation inquests that tell you which rules still earn their place after a model upgrade.",
   "type": "module",
   "bin": {

package/src/parse.js

@@ -1,49 +1,89 @@
 import { createHash } from 'node:crypto';
 
-// A "rule" is a top-level bullet in a harness file. Continuation lines
-// (indented 2+ spaces) belong to the bullet above; nested bullets too —
-// they qualify the rule, they are not rules of their own.
+// spec-kit rewrites these sections from feature plans on every run (its
+// update-agent-context script finds them by heading): tool output, not rules.
+const GENERATED_SECTIONS = new Set(['Active Technologies', 'Recent Changes']);
+
+const LIST_ITEM = /^(?:[-*+]|\d+[.)])\s+/;
+const BOLD_LEAD = /^\*\*[^*]+\*\*/;
+const BOLD_LABEL = /^\*\*[^*]+\*\*:?$/; // "**Why this matters:**" heads what follows
+const FENCE = /^\s*(?:```|~~~)/;
+const THEMATIC_BREAK = /^([-*_])(?:\s*\1){2,}\s*$/;
+const CONTINUATION = /^\s{2,}\S/;
+
+// A "rule" is a top-level list item (-, *, +, 1., 1)) or a paragraph that
+// opens with a bold lead ("**Never trust a merged schema.** Every module…");
+// a bold label alone ("**Quick Tips:**") is a heading in disguise, not a rule.
+// Indented lines belong to the item above, nested lists too: they qualify the
+// rule, they are not rules of their own. Plain prose and code are not rules.
 export function parseRules(markdown, source) {
   const rules = [];
   let section = '';
   let current = null;
+  let fence = null;
+  let afterBlank = true;
 
   const flush = () => {
     if (!current) return;
     const text = current.lines.join('\n').trim();
-    rules.push({
-      id: ruleId(text),
-      text,
-      source,
-      section,
-      line: current.line,
-    });
+    if (!(current.paragraph && BOLD_LABEL.test(text))) {
+      rules.push({ id: ruleId(text), text, source, section, line: current.line });
+    }
     current = null;
   };
 
   const lines = markdown.split('\n');
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    const heading = line.match(/^#{1,6}\s+(.*)/);
+    const blank = line.trim() === '';
+
+    // Code: skipped, unless it is indented under a rule (an example inside it).
+    if (fence) {
+      if (fence.owner && !blank) fence.owner.lines.push(line.trim());
+      if (FENCE.test(line)) {
+        fence = null;
+        afterBlank = true;
+      }
+      continue;
+    }
 
+    if (FENCE.test(line)) {
+      const owner = current && CONTINUATION.test(line) ? current : null;
+      if (owner) owner.lines.push(line.trim());
+      else flush();
+      fence = { owner };
+      continue;
+    }
+
+    const heading = line.match(/^#{1,6}\s+(.*)/);
     if (heading) {
       flush();
       section = heading[1].trim();
+      afterBlank = true;
       continue;
     }
 
-    if (/^- /.test(line)) {
+    if (GENERATED_SECTIONS.has(section)) continue;
+
+    const item = line.match(LIST_ITEM);
+    if (item && !THEMATIC_BREAK.test(line)) {
       flush();
-      current = { lines: [line.slice(2)], line: i + 1 };
+      current = { lines: [line.slice(item[0].length)], line: i + 1, paragraph: false };
+      afterBlank = false;
       continue;
     }
 
-    if (current && /^\s{2,}\S/.test(line)) {
+    if (current && (CONTINUATION.test(line) || (current.paragraph && !blank))) {
       current.lines.push(line.trim());
       continue;
     }
 
     flush();
+
+    if (afterBlank && BOLD_LEAD.test(line)) {
+      current = { lines: [line], line: i + 1, paragraph: true };
+    }
+    afterBlank = blank;
   }
   flush();