docguard-cli 0.30.1 → 0.31.0

package/cli/validators/diff-suspicion.mjs

@@ -0,0 +1,178 @@
+/**
+ * Diff-Overlap Suspicion validator (DSP) — v0.31.0.
+ *
+ * Research basis: the outdated-comment work (arXiv 2010.01625) found that a
+ * purely deterministic rule — "flag the prose as suspect if its tokens overlap
+ * a Delete/ReplaceOld span of the code change" — hits F1 74.7, beating every
+ * post-hoc neural model. We apply it to DOCS instead of comments.
+ *
+ * Precision-first pairing (two independent signals must BOTH hold):
+ *   1. the doc REFERENCES the changed code file (path / basename / `module`),
+ *   2. the doc's wording OVERLAPS tokens that were REMOVED from that file.
+ * Requiring both is what keeps this from firing on every doc that happens to
+ * share a common word with a diff. All findings are confidence:'low' (soft /
+ * reportable) — this is a "review this" signal, never a hard failure.
+ *
+ * Change-driven: reads `config.changedSinceRef` (set by `guard --changed-only`)
+ * or falls back to HEAD~1. Returns applicable:false when there's no git history
+ * or no code change carries removed tokens, so it stays silent off-CI.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { resolve, basename } from 'node:path';
+import { isGitRepo, getDiffText } from '../shared-git.mjs';
+import { parseUnifiedDiff, removedTokens, tokenize, tokenOverlap } from '../shared-diff.mjs';
+import { mkFinding, resultFromFindings } from '../findings.mjs';
+
+const CODE_EXTENSIONS = /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|rb|php|cs|swift|scala|dart)$/;
+
+// Generic framework / language noise that overlaps between ANY React/TS doc and
+// ANY diff — empirically the residual false-positive source (v0.31.0 corpus:
+// "SECURITY.md ↔ page.tsx: page,set,use,state,active"). We require the shared
+// tokens to contain DOMAIN identifiers, so these are stripped before counting.
+const GENERIC_TOKENS = new Set([
+  'page', 'components', 'component', 'shared', 'nav', 'state', 'use', 'set',
+  'active', 'tab', 'react', 'props', 'prop', 'string', 'type', 'types', 'value',
+  'values', 'data', 'status', 'config', 'client', 'none', 'all', 'com', 'https',
+  'http', 'url', 'text', 'download', 'request', 'response', 'error', 'index',
+  'item', 'items', 'list', 'name', 'key', 'map', 'log', 'update', 'updated',
+  'version', 'content', 'document', 'description', 'service', 'services',
+  'object', 'array', 'number', 'boolean', 'async', 'await', 'promise', 'void',
+  'render', 'component', 'element', 'style', 'styles', 'class', 'div', 'span',
+  'button', 'input', 'form', 'label', 'title', 'header', 'footer', 'main',
+  // presentational / CSS — styling churn is not API-contract drift
+  'font', 'color', 'colors', 'tracking', 'surface', 'auto', 'full', 'next',
+  'body', 'sans', 'blue', 'accent', 'size', 'spacing', 'margin', 'padding',
+  'width', 'height', 'flex', 'grid', 'bold', 'bg', 'rounded',
+  // HTTP / REST / handler plumbing — generic across any API route (globalshares
+  // corpus: a route-inventory doc + heavy rewrites flooded findings with these)
+  'code', 'json', 'err', 'error', 'message', 'auth', 'get', 'put', 'post',
+  'patch', 'delete', 'req', 'res', 'route', 'routes', 'handler', 'endpoint',
+  'method', 'headers', 'query', 'params', 'param', 'cron', 'process', 'api',
+  'path', 'lib', 'util', 'utils', 'helper', 'helpers', 'admin', 'roles', 'role',
+  'user', 'users', 'email', 'price', 'json', 'fetch', 'axios', 'send', 'call',
+]);
+
+function escapeRegex(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+// Index canonical docs + root agent-instruction files → Map<name, {lines, tokens}>.
+function indexDocs(projectDir) {
+  const docs = new Map();
+  const add = (name, full) => {
+    try {
+      const content = readFileSync(full, 'utf-8');
+      docs.set(name, { lines: content.split('\n'), tokens: tokenize(content) });
+    } catch { /* skip unreadable */ }
+  };
+  const docsDir = resolve(projectDir, 'docs-canonical');
+  if (existsSync(docsDir)) {
+    try {
+      for (const f of readdirSync(docsDir)) {
+        if (f.endsWith('.md')) add(f, resolve(docsDir, f));
+      }
+    } catch { /* skip */ }
+  }
+  // Agent-instruction files are documentation too — they routinely name code.
+  for (const agent of ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md']) {
+    const p = resolve(projectDir, agent);
+    if (existsSync(p)) add(agent, p);
+  }
+  return docs;
+}
+
+// Does the doc reference this file? We deliberately accept ONLY `path` (the
+// doc wrote the real file path) and `module` (the doc backticked the module
+// stem) references. We DROP bare `basename` matches: empirical corpus testing
+// (v0.31.0) showed basename refs pair an architecture doc that lists every
+// `page.tsx` with framework-noise tokens (page/components/state/use/nav),
+// producing false positives. path/module refs are intentional and high-signal.
+function referenceKind(docLines, file) {
+  const normalized = file.replace(/^\.\//, '');
+  const base = basename(normalized);
+  const stem = base.replace(/\.[^.]+$/, '');
+  const stemRe = new RegExp(`\`${escapeRegex(stem)}\``);
+  for (const line of docLines) {
+    if (line.includes(normalized)) return 'path';
+    if (stemRe.test(line)) return 'module';
+  }
+  return null;
+}
+
+export function validateDiffSuspicion(projectDir, config = {}) {
+  const cfg = config.diffSuspicion || {};
+  const minOverlap = Number.isInteger(cfg.minOverlap) ? cfg.minOverlap : 2;
+  const ref = cfg.since || config.changedSinceRef || 'HEAD~1';
+
+  if (!isGitRepo(projectDir)) {
+    return resultFromFindings([], { passed: 0, total: 0, applicable: false });
+  }
+
+  const diffText = getDiffText(projectDir, ref);
+  const changedFiles = parseUnifiedDiff(diffText).filter(
+    f => f.newPath && CODE_EXTENSIONS.test(f.newPath) && f.status !== 'deleted'
+  );
+  // Precompute removed-token sets; drop files whose change removed nothing.
+  const changed = changedFiles
+    .map(f => ({ path: f.newPath, removed: removedTokens(f) }))
+    .filter(f => f.removed.size > 0);
+
+  if (changed.length === 0) {
+    return resultFromFindings([], { passed: 0, total: 0, applicable: false });
+  }
+
+  const docs = indexDocs(projectDir);
+  if (docs.size === 0) {
+    return resultFromFindings([], { passed: 0, total: 0, applicable: false });
+  }
+
+  const maxPerDoc = Number.isInteger(cfg.maxPerDoc) ? cfg.maxPerDoc : 5;
+  const findings = [];
+  let pairsChecked = 0;
+  for (const [docName, doc] of docs) {
+    // Collect this doc's suspect pairs, strongest overlap first, so a doc that
+    // inventories many changed files (e.g. an API-route reference) is capped
+    // with an elision note rather than flooding — the same discipline SPK008 uses.
+    const hits = [];
+    for (const cf of changed) {
+      const kind = referenceKind(doc.lines, cf.path);
+      if (!kind) continue; // signal 1: doc must reference the changed file (path|module)
+      pairsChecked++;
+      const { shared: rawShared } = tokenOverlap(doc.tokens, cf.removed);
+      // signal 2: doc must share DOMAIN (non-generic) removed tokens
+      const shared = rawShared.filter(t => !GENERIC_TOKENS.has(t));
+      if (shared.length < minOverlap) continue;
+      hits.push({ path: cf.path, kind, shared });
+    }
+    hits.sort((a, b) => b.shared.length - a.shared.length);
+    for (const h of hits.slice(0, maxPerDoc)) {
+      findings.push(mkFinding({
+        code: 'DSP001',
+        validator: 'diff-suspicion',
+        severity: 'warn',
+        confidence: 'low',
+        message: `${docName} describes ${h.path} (${h.kind} ref), which just had ${h.shared.slice(0, 5).join(', ')}${h.shared.length > 5 ? '…' : ''} removed/changed (${ref}..HEAD) — verify the doc still matches.`,
+        location: { file: docName },
+        suggestion: {
+          summary: `Re-read ${docName} against the current ${h.path}; the removed symbols (${h.shared.slice(0, 8).join(', ')}) may now be wrong.`,
+        },
+      }));
+    }
+    if (hits.length > maxPerDoc) {
+      findings.push(mkFinding({
+        code: 'DSP001',
+        validator: 'diff-suspicion',
+        severity: 'warn',
+        confidence: 'low',
+        message: `${docName} references ${hits.length - maxPerDoc} more changed file(s) with removed domain symbols (${ref}..HEAD) — a broad change; review ${docName} as a whole.`,
+        location: { file: docName },
+        suggestion: { summary: `${docName} looks broadly affected by this change set — review it end-to-end rather than line by line.` },
+      }));
+    }
+  }
+
+  return resultFromFindings(findings, {
+    passed: pairsChecked - findings.length,
+    total: pairsChecked,
+    applicable: true,
+  });
+}

package/cli/validators/reference-existence.mjs

@@ -0,0 +1,157 @@
+/**
+ * Two-Revision Reference-Existence validator (REF001) — v0.31.0.
+ *
+ * Method (arXiv 2212.01479, field-tested at ~50% maintainer acceptance):
+ * extract code-element references from a doc, then compare their existence in
+ * the source tree at TWO revisions — the commit where the doc was LAST UPDATED
+ * vs HEAD. A reference that matched source when the doc was written but matches
+ * ZERO source instances now is flagged outdated. Fully deterministic.
+ *
+ * Performance: the "present now?" gate is answered from ONE in-memory identifier
+ * set built by a single source walk (not a git grep per symbol — that was ~7s
+ * on a 167-ref repo). The walk skips dot-directories (.github, .specify), so a
+ * symbol the walk misses is CONFIRMED absent with an authoritative `git grep` at
+ * HEAD before we trust it — otherwise a symbol living in a dot-dir reads as a
+ * false "removed" (caught dogfooding DocGuard's own AGENTS.md). Only symbols
+ * absent from BOTH the walk and HEAD git grep — the rare case — pay for the
+ * historical `git grep` at the doc's last-update revision.
+ *
+ * Precision guards:
+ *   - Only PURE COMPOUND identifiers (camelCase / snake_case / Pascal-multiword)
+ *     from backticks are checked — never prose words ("`token`" is ignored), and
+ *     dotted member/file refs are out of scope for v1 (documented).
+ *   - CLI/config flags (`--foo`) excluded — the "removed but still relevant"
+ *     false-positive mode (a) from the paper.
+ *   - present-then-AND-absent-now is required, so a symbol that never existed
+ *     at doc-time (a typo, an external lib) is not accused — false-positive
+ *     mode (b) ("literal deleted but logic remains") is bounded by compound
+ *     shape + the two-revision gate.
+ * All findings are confidence:'low' / soft — "verify", never a hard failure.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { resolve, extname } from 'node:path';
+import { isGitRepo, lastCommitHash, symbolExistsAtRev } from '../shared-git.mjs';
+import { walkFiles } from '../shared-ignore.mjs';
+import { readScannable } from '../shared-source.mjs';
+import { mkFinding, resultFromFindings } from '../findings.mjs';
+
+const CODE_EXT = new Set([
+  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs', '.java',
+  '.kt', '.rb', '.php', '.cs', '.swift', '.scala', '.dart', '.c', '.cpp', '.h',
+]);
+const IDENT = /[A-Za-z_][A-Za-z0-9_]*/g;
+
+// Compound = clearly a code symbol, not a prose word: camelCase, snake_case,
+// or PascalCase-multiword. Pure lowercase single words are excluded.
+const COMPOUND = /[a-z][A-Z]|_|^[A-Z][a-z]+[A-Z]/;
+function isCodeIdentifier(s) {
+  if (s.length < 4 || s.length > 80) return false;
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(s)) return false; // pure identifier (no dots)
+  return COMPOUND.test(s);
+}
+
+// One pass over the current source tree → Set of every whole identifier present.
+function buildHeadIdentifierSet(projectDir) {
+  const set = new Set();
+  walkFiles(projectDir, (full) => {
+    if (!CODE_EXT.has(extname(full))) return;
+    const content = readScannable(full);
+    if (!content) return;
+    const m = content.match(IDENT);
+    if (m) for (const id of m) set.add(id);
+  });
+  return set;
+}
+
+function extractRefs(content) {
+  const refs = new Set();
+  const backtick = /`([^`\n]{2,80})`/g;
+  let m;
+  while ((m = backtick.exec(content)) !== null) {
+    let tok = m[1].trim().replace(/\(.*$/, '').replace(/[.,;:]+$/, '').trim();
+    if (/^-/.test(tok)) continue;              // CLI flag → FP mode (a)
+    if (isCodeIdentifier(tok)) refs.add(tok);
+  }
+  return [...refs];
+}
+
+function indexDocs(projectDir) {
+  const docs = [];
+  const push = (name, full) => {
+    try {
+      const content = readFileSync(full, 'utf-8');
+      docs.push({ name, path: full, refs: extractRefs(content) });
+    } catch { /* skip */ }
+  };
+  const docsDir = resolve(projectDir, 'docs-canonical');
+  if (existsSync(docsDir)) {
+    try {
+      for (const f of readdirSync(docsDir)) if (f.endsWith('.md')) push(f, resolve(docsDir, f));
+    } catch { /* skip */ }
+  }
+  for (const agent of ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md']) {
+    const p = resolve(projectDir, agent);
+    if (existsSync(p)) push(agent, p);
+  }
+  return docs;
+}
+
+export function validateReferenceExistence(projectDir, config = {}) {
+  const cfg = config.referenceExistence || {};
+  const maxRefsPerDoc = cfg.maxRefsPerDoc || 80;
+
+  if (!isGitRepo(projectDir)) {
+    return resultFromFindings([], { passed: 0, total: 0, applicable: false });
+  }
+  const docs = indexDocs(projectDir);
+  if (docs.length === 0 || docs.every(d => d.refs.length === 0)) {
+    return resultFromFindings([], { passed: 0, total: 0, applicable: false });
+  }
+
+  const headIds = buildHeadIdentifierSet(projectDir); // cheap gate, built once
+  const revPresence = new Map(); // `${sym}\0${rev}` → bool
+  // Authoritative HEAD absence (covers dot-dirs the walk skipped). Cached.
+  const headAbsent = new Map();
+  const confirmedAbsentAtHead = (sym) => {
+    if (!headAbsent.has(sym)) headAbsent.set(sym, !symbolExistsAtRev(projectDir, sym, 'HEAD'));
+    return headAbsent.get(sym);
+  };
+
+  const findings = [];
+  let totalChecked = 0;
+  let absentAtHead = 0;
+  for (const doc of docs) {
+    let rev = null; // resolve lazily — only if a ref is actually absent now
+    for (const sym of doc.refs.slice(0, maxRefsPerDoc)) {
+      totalChecked++;
+      if (headIds.has(sym)) continue;            // in the walked tree → present (cheap)
+      if (!confirmedAbsentAtHead(sym)) continue; // walk missed it but git finds it (dot-dir) → present
+      absentAtHead++;
+      if (rev === null) rev = lastCommitHash(projectDir, doc.path) || '';
+      if (!rev) continue;                        // untracked doc → no "then" snapshot
+      const key = `${sym}\0${rev}`;
+      if (!revPresence.has(key)) revPresence.set(key, symbolExistsAtRev(projectDir, sym, rev));
+      if (!revPresence.get(key)) continue;       // never existed at doc-time → not our signal
+      findings.push(mkFinding({
+        code: 'REF001',
+        validator: 'reference-existence',
+        severity: 'warn',
+        confidence: 'low',
+        message: `${doc.name} references \`${sym}\`, which existed in the code when the doc was last updated but has ZERO matches at HEAD — likely renamed or removed.`,
+        location: { file: doc.name },
+        suggestion: {
+          summary: `Update or remove the \`${sym}\` reference in ${doc.name} (or suppress if it is a still-relevant user-facing name).`,
+        },
+      }));
+    }
+  }
+
+  const res = resultFromFindings(findings, {
+    passed: totalChecked - findings.length,
+    total: totalChecked,
+    applicable: true,
+  });
+  res.absentAtHead = absentAtHead; // instrumentation: proves the pipeline reaches the rev check
+  return res;
+}

package/cli/validators/traceability.mjs

@@ -18,6 +18,25 @@ import { resolve, join, relative, basename, extname } from 'node:path';
 import { TRACE_MAP, TEST_PATTERNS, isTraceableSource } from '../shared-trace-patterns.mjs';
 import { walkFiles as sharedWalkFiles } from '../shared-ignore.mjs';
 import { mkFinding, resultFromFindings } from '../findings.mjs';
+import { tokenize } from '../shared-diff.mjs';
+import { rankBySimilarity } from '../shared-ir.mjs';
+
+// IR soft-link recovery (feat 5): tokenize test files once so an untraced
+// requirement can be matched to the test that most likely already covers it
+// (TF-IDF cosine, VSM). Capped so a huge test suite can't blow up guard.
+function buildTestCorpus(projectDir, projectFiles, { maxFiles = 250, maxTokens = 400 } = {}) {
+  const testFiles = projectFiles.filter(f =>
+    TEST_PATTERNS.some(p => p.test(f)) || /__tests__\//.test(f) || /tests?\//.test(f)
+  ).slice(0, maxFiles);
+  const corpus = [];
+  for (const relPath of testFiles) {
+    try {
+      const content = readFileSync(resolve(projectDir, relPath), 'utf-8');
+      corpus.push({ id: relPath, tokens: tokenize(content).slice(0, maxTokens) });
+    } catch { /* skip unreadable */ }
+  }
+  return corpus;
+}
 
 const IGNORE_DIRS = new Set([
   'node_modules', '.git', '.next', 'dist', 'build', 'coverage',
@@ -208,20 +227,40 @@ function validateRequirementTraceability(projectDir, config, projectFiles) {
 
   // ── Step 3: Report traceability results ──
 
+  // IR soft-link recovery (feat 5): build the tokenized test corpus once, only
+  // if there are untraced requirements to match. Threshold is deliberately low
+  // — short requirement text vs a whole test file yields modest cosine scores;
+  // the hint is a suggestion, not proof.
+  const softThreshold = config.traceability?.irSoftThreshold ?? 0.10;
+  let testCorpus = null;
+
   // Check each documented requirement has at least one test reference
   for (const [reqId, location] of reqIds) {
     total++;
     if (testRefs.has(reqId)) {
       passed++;
     } else {
+      // Try to recover a likely-but-unannotated test via TF-IDF cosine.
+      let softHint = '';
+      let softText = `Add an @req ${reqId} comment to the test that verifies this requirement`;
+      const queryText = location.text && location.text.length > reqId.length ? location.text : reqId;
+      if (testCorpus === null) testCorpus = buildTestCorpus(projectDir, projectFiles);
+      if (testCorpus.length > 0) {
+        const ranked = rankBySimilarity(tokenize(queryText), testCorpus);
+        const top = ranked[0];
+        if (top && top.score >= softThreshold) {
+          const pct = (top.score * 100).toFixed(0);
+          softHint = ` — IR soft-match: ${top.id} (${pct}% similar) may already cover it`;
+          softText = `${top.id} looks like it already tests this (${pct}% similar) — add @req ${reqId} there, or if unrelated, write the missing test`;
+        }
+      }
       findings.push(mkFinding({
         code: 'TRC004',
         validator: 'traceability',
         severity: 'warn',
-        message: `Requirement ${reqId} (${location.file}:${location.line}) has no test coverage. ` +
-          `Add @req ${reqId} comment to the test that verifies this requirement`,
+        message: `Requirement ${reqId} (${location.file}:${location.line}) has no test coverage.${softHint || ' Add @req ' + reqId + ' comment to the test that verifies this requirement'}`,
         location: `${location.file}:${location.line}`,
-        suggestion: { kind: 'fix', text: `Add an @req ${reqId} comment to the test that verifies this requirement` },
+        suggestion: { kind: 'fix', text: softText },
       }));
     }
   }
@@ -269,7 +308,8 @@ function collectRequirementIds(projectDir, config, patterns) {
         while ((match = pattern.exec(lines[i])) !== null) {
           const reqId = match[0]; // e.g., "REQ-001"
           if (!reqIds.has(reqId)) {
-            reqIds.set(reqId, { file: docName, line: i + 1 });
+            // capture the line text (the requirement description) for IR soft-match
+            reqIds.set(reqId, { file: docName, line: i + 1, text: lines[i].trim() });
           }
         }
       }

package/docs/quickstart.md

@@ -68,7 +68,7 @@ diagnose  →  AI reads prompts  →  AI fixes docs  →  guard verifies
 ## Verify
 
 ```bash
-npx docguard-cli guard        # Pass/fail check (24 validators)
+npx docguard-cli guard        # Pass/fail check (27 validators)
 npx docguard-cli score        # 0-100 maturity score
 ```
 

package/extensions/spec-kit-docguard/extension.yml

@@ -3,7 +3,7 @@ schema_version: "1.0"
 extension:
   id: "docguard"
   name: "DocGuard — CDD Enforcement"
-  version: "0.30.0"
+  version: "0.31.0"
   description: "Canonical-Driven Development enforcement as a true spec-kit extension. LLM-first design with automated validators, 4 AI behavior skills, spec-kit skill chaining, and workflow hooks. One pinned runtime dependency (@babel/parser); pure Node.js otherwise."
   author: "Ricardo Accioly"
   repository: "https://github.com/raccioly/docguard"

package/extensions/spec-kit-docguard/skills/docguard-fix/SKILL.md

@@ -6,10 +6,10 @@ description: AI-driven documentation repair with structured research workflow, t
 compatibility: Requires DocGuard CLI installed (npm i -g docguard-cli or npx docguard-cli)
 metadata:
   author: docguard
-  version: 0.30.0
+  version: 0.31.0
   source: extensions/spec-kit-docguard/skills/docguard-fix
 ---
-<!-- docguard:version: 0.30.0 -->
+<!-- docguard:version: 0.31.0 -->
 
 # DocGuard Fix Skill
 

package/extensions/spec-kit-docguard/skills/docguard-guard/SKILL.md

@@ -7,10 +7,10 @@ description: Run DocGuard guard validation against Canonical-Driven Development
 compatibility: Requires DocGuard CLI installed (npm i -g docguard-cli or npx docguard-cli)
 metadata:
   author: docguard
-  version: 0.30.0
+  version: 0.31.0
   source: extensions/spec-kit-docguard/skills/docguard-guard
 ---
-<!-- docguard:version: 0.30.0 -->
+<!-- docguard:version: 0.31.0 -->
 
 # DocGuard Guard Skill
 

package/extensions/spec-kit-docguard/skills/docguard-review/SKILL.md

@@ -6,10 +6,10 @@ description: Cross-document consistency analysis and quality assessment. Perform
 compatibility: Requires DocGuard CLI installed (npm i -g docguard-cli or npx docguard-cli)
 metadata:
   author: docguard
-  version: 0.30.0
+  version: 0.31.0
   source: extensions/spec-kit-docguard/skills/docguard-review
 ---
-<!-- docguard:version: 0.30.0 -->
+<!-- docguard:version: 0.31.0 -->
 
 # DocGuard Review Skill
 

package/extensions/spec-kit-docguard/skills/docguard-score/SKILL.md

@@ -6,10 +6,10 @@ description: CDD maturity assessment with category-aware improvement roadmap. Ru
 compatibility: Requires DocGuard CLI installed (npm i -g docguard-cli or npx docguard-cli)
 metadata:
   author: docguard
-  version: 0.30.0
+  version: 0.31.0
   source: extensions/spec-kit-docguard/skills/docguard-score
 ---
-<!-- docguard:version: 0.30.0 -->
+<!-- docguard:version: 0.31.0 -->
 
 # DocGuard Score Skill
 

package/extensions/spec-kit-docguard/skills/docguard-sync/SKILL.md

@@ -4,10 +4,10 @@ description: Keep canonical documentation ALWAYS UP TO DATE. Refreshes code-trut
 compatibility: Requires DocGuard CLI installed (npm i -g docguard-cli or npx docguard-cli)
 metadata:
   author: docguard
-  version: 0.30.0
+  version: 0.31.0
   source: extensions/spec-kit-docguard/skills/docguard-sync
 ---
-<!-- docguard:version: 0.30.0 -->
+<!-- docguard:version: 0.31.0 -->
 
 # DocGuard Sync Skill
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docguard-cli",
-  "version": "0.30.1",
+  "version": "0.31.0",
   "description": "The enforcement tool for Canonical-Driven Development (CDD). Audit, generate, and guard your project documentation.",
   "type": "module",
   "bin": {