@kodevibe/harness 0.11.2 → 0.11.4

package/src/guard.js

@@ -16,6 +16,13 @@
 //   R8  checkPublicBoundary — public package surface does not leak internal refs
 //   R9  checkEnvSeal       — proof records include reproducible environment seal
 //   R10 checkInstructionBudget — instruction files fit model-tier budgets
+//   R11 checkStoryContracts — done Stories must prove their semantic contracts
+//   R12 checkEvaluatorArtifact — evaluator-owned artifacts are not rewritten silently
+//   R13 checkSmokeEvidence — browser/manual proof must leave durable evidence
+//   R14 checkScopeSplitApproval — FR/KPI/ARB split mappings need approval
+//   R15 checkRecentChangesIntegrity — wrap-up must not corrupt state sections
+//   R16 checkSelfVerifyClaim — claimed PASS must match deterministic guard
+//   R16 checkReviewerAuditEvidence — scope audits must cite real deps/imports
 //
 // Severity: 'error' blocks the commit (exit 1). 'warn' is informational.
 
@@ -153,6 +160,12 @@ function parseMarkdownTable(section) {
     });
 }
 
+function markdownTableHeaders(section) {
+  const lines = section.split('\n').map((l) => l.trim()).filter((l) => l.startsWith('|'));
+  if (lines.length < 2) return [];
+  return lines[0].replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.trim());
+}
+
 function storyIdFromRow(row) {
   return row.ID || row.Id || row.Story || row['Story ID'] || row['Story'] || '';
 }
@@ -161,6 +174,56 @@ function rowStatus(row) {
   return row.Status || row.status || '';
 }
 
+function storyContractStatus(row) {
+  return row['Proof Status'] || row.Status || row.status || row.Result || row.result || '';
+}
+
+const RECENT_CHANGES_EVIDENCE_TERMS = /\b(?:scenario|expected|result|observer|url|screenshot|playwright|dropdown|column|color coding|ui elements?)\b|시나리오|기대|결과|관찰|드롭다운|컬럼|색상|스크린샷/i;
+
+/**
+ * Recent Changes is the session changelog. A recurring wrap-up failure is
+ * inserting it in the middle of an evidence/proof section, which silently moves
+ * the rest of that section under "Recent Changes". Catch obvious structure
+ * corruption deterministically.
+ *
+ * @param {string} content project-state.md
+ * @returns {Array}
+ */
+function checkRecentChangesIntegrity(content) {
+  const violations = [];
+  const visible = stripHtmlComments(content);
+  const recent = getSection(visible, 'Recent Changes');
+  if (recent === null) return violations;
+
+  const lines = recent.split('\n');
+  const nestedHeading = lines.find((line) => /^#{3,}\s+/.test(line.trim()));
+  if (nestedHeading) {
+    violations.push({
+      check: 'state-structure',
+      severity: 'error',
+      line: 0,
+      message: `Recent Changes contains nested heading "${nestedHeading.trim()}". It was likely inserted inside an evidence/proof section; move Recent Changes after the completed evidence block (R15).`,
+    });
+  }
+
+  const misplacedEvidence = lines.find((line) => {
+    const trimmed = line.trim();
+    if (!/^[-*]\s+/.test(trimmed)) return false;
+    if (/\d{4}-\d{2}-\d{2}|\bS\d+-\d+\b|session|wrap-up|recent/i.test(trimmed)) return false;
+    return RECENT_CHANGES_EVIDENCE_TERMS.test(trimmed);
+  });
+  if (misplacedEvidence) {
+    violations.push({
+      check: 'state-structure',
+      severity: 'error',
+      line: 0,
+      message: `Recent Changes contains evidence/checklist content (${misplacedEvidence.trim()}). Do not place proof details under Recent Changes; keep durable evidence in its own section (R15).`,
+    });
+  }
+
+  return violations;
+}
+
 /**
  * Validate docs/project-state.md content for handoff + proof-first integrity.
  * @param {string} content
@@ -215,9 +278,145 @@ function checkStateFile(content) {
     }
   }
 
+  violations.push(...checkRecentChangesIntegrity(content));
+
   return violations;
 }
 
+// ─── Story Contract Gate (R11 / semantic acceptance) ────────────────
+
+const STORY_CONTRACT_PASS = /✅|pass(?:ed)?|proven|verified|reviewed|done|ok/i;
+const STORY_CONTRACT_NOT_PROVEN = /❌|fail(?:ed)?|not[_ -]?proven|not[_ -]?verified|pending|todo|tbd|blank|needs[_ -]?user[_ -]?confirmation|needs[_ -]?confirmation|⬜|🚫|blocked/i;
+const STORY_CONTRACT_ALWAYS = /\balways\b|\bevery\b|\ball\b|항상|모든|전체/i;
+const STORY_CONTRACT_SURFACE = /\b(create|list|get|resolve|update|delete|api|ui|endpoint|route|public\s+surface|return\s+path)\b|생성|목록|조회|해결|수정|삭제|반환면|공개\s*표면/i;
+
+/**
+ * Semantic Story Contract gate. This is intentionally project-agnostic:
+ * the harness does not parse the app domain itself; it requires the agent to
+ * write a compact Story Contract table and prove every row before Done.
+ *
+ * Backward compatibility: existing projects with done Stories but no contract
+ * rows receive WARN, not FAIL. Once a contract row exists, an unproven row is
+ * blocking.
+ *
+ * @param {{projectState?: string}|string} input project-state.md content or object
+ * @returns {Array}
+ */
+function checkStoryContracts(input = {}) {
+  const projectState = typeof input === 'string' ? input : (input.projectState || '');
+  const violations = [];
+  const visible = stripHtmlComments(projectState);
+  const doneStories = parseMarkdownTable(getSection(visible, 'Story Status') || '')
+    .filter((row) => /✅\s*done/i.test(rowStatus(row)));
+  if (doneStories.length === 0) return violations;
+
+  const section = getSection(visible, 'Story Contracts');
+  if (section === null) {
+    for (const story of doneStories) {
+      const id = storyIdFromRow(story);
+      violations.push({
+        check: 'story-contract',
+        severity: 'warn',
+        line: 0,
+        message: `Story ${id || '(unknown)'} is done but project-state.md has no Story Contracts section (R11). Add semantic contract rows for new work.`,
+      });
+    }
+    return violations;
+  }
+
+  const headers = markdownTableHeaders(section);
+  const requiredHeaders = ['Story', 'Contract', 'Proof Status'];
+  const hasContractTable = headers.length > 0;
+  const hasRequiredHeaders = requiredHeaders.every((name) => headers.includes(name));
+  if (!hasContractTable || !hasRequiredHeaders) {
+    violations.push({
+      check: 'story-contract',
+      severity: 'error',
+      line: 0,
+      message: 'Story Contracts table is malformed. Required columns: Story, Contract, Proof Status (R11).',
+    });
+    return violations;
+  }
+
+  const rows = parseMarkdownTable(section);
+  for (const story of doneStories) {
+    const id = storyIdFromRow(story);
+    const contracts = rows.filter((row) => {
+      const cell = String(row.Story || row['Story ID'] || '');
+      return id && cell.includes(id);
+    });
+
+    if (contracts.length === 0) {
+      violations.push({
+        check: 'story-contract',
+        severity: 'warn',
+        line: 0,
+        message: `Story ${id || '(unknown)'} is done but has no Story Contract rows (R11). Add semantic acceptance contracts for new work.`,
+      });
+      continue;
+    }
+
+    for (const row of contracts) {
+      const status = storyContractStatus(row);
+      const contract = row.Contract || row['Required Assertion'] || '(unnamed contract)';
+      if (!status || STORY_CONTRACT_NOT_PROVEN.test(status) || !STORY_CONTRACT_PASS.test(status)) {
+        violations.push({
+          check: 'story-contract',
+          severity: 'error',
+          line: 0,
+          message: `Story ${id} is done but Story Contract "${contract}" is not proven (status: ${status || 'blank'}). Prove every contract row before Done (R11).`,
+        });
+      }
+      const assertionText = Object.values(row).filter((v) => typeof v === 'string').join(' ');
+      if (STORY_CONTRACT_ALWAYS.test(assertionText)) {
+        const surfaceMatches = assertionText.match(new RegExp(STORY_CONTRACT_SURFACE.source, 'gi')) || [];
+        const uniqueSurfaces = new Set(surfaceMatches.map((s) => s.toLowerCase()));
+        if (uniqueSurfaces.size < 2) {
+          violations.push({
+            check: 'story-contract',
+            severity: 'error',
+            line: 0,
+            message: `Story ${id} contract "${contract}" uses an always/every assertion but does not enumerate public surfaces (e.g. create/list/get/resolve/API/UI). R16 requires surface-specific proof so one return path cannot drift.`,
+          });
+        }
+      }
+    }
+  }
+
+  return violations;
+}
+
+// ─── Self-Verify Claim Gate (R16) ───────────────────────────────────
+
+const CLEAN_SELF_VERIFY_CLAIM = /\b(?:state-check|harness-guard|guard)\b[\s\S]{0,80}\bPASS\b|\b0\s+FAIL\b[\s,;/|]*\b0\s+WARN\b|\b0\s+error\(s\)\b[\s,;/|]*\b0\s+warning\(s\)\b/i;
+
+/**
+ * Catch the Experiment #6 failure mode: a state file claims state-check/guard
+ * passed cleanly while deterministic checks still find errors or warnings.
+ *
+ * @param {string} content project-state.md
+ * @param {Array} deterministicViolations violations found for the same file
+ * @returns {Array}
+ */
+function checkSelfVerifyClaim(content, deterministicViolations = []) {
+  const visible = stripHtmlComments(content);
+  if (!CLEAN_SELF_VERIFY_CLAIM.test(visible)) return [];
+
+  const relevant = deterministicViolations
+    .filter((v) => v.check !== 'self-verify-claim')
+    .filter((v) => v.severity === 'error' || v.severity === 'warn');
+  if (relevant.length === 0) return [];
+
+  const errors = relevant.filter((v) => v.severity === 'error').length;
+  const warnings = relevant.filter((v) => v.severity === 'warn').length;
+  return [{
+    check: 'self-verify-claim',
+    severity: 'error',
+    line: 0,
+    message: `State file claims clean self-verify/PASS, but deterministic guard found ${errors} error(s) and ${warnings} warning(s). Paste/fix the real guard output before reporting DONE (R16).`,
+  }];
+}
+
 // ─── Reviewer Handoff Gate (R3) ──────────────────────────────────────
 
 /**
@@ -385,6 +584,44 @@ function checkStateSync({ projectState = '', features = '', dependencyMap = '' }
   return violations;
 }
 
+// ─── Scope Split Approval Gate (R14) ────────────────────────────────
+
+const STORY_ID_RE = /\bS\d+-\d+\b/g;
+const TRACKER_ROW_RE = /\b(?:FR|KPI|ARB|ARB-FAIL)[-_]?\d+\b/i;
+const SCOPE_SPLIT_APPROVAL_RE = /\bScope split approved\b|범위\s*분할\s*승인|<!--\s*harness-scope-split-approved:/i;
+
+/**
+ * When a Validation Tracker maps a single FR/KPI/ARB item to multiple Stories,
+ * the split is a product decision. Require an explicit approval marker so a
+ * model cannot silently shrink or repartition scope.
+ *
+ * @param {{projectBrief?: string}|string} input project-brief.md content or object
+ * @returns {Array}
+ */
+function checkScopeSplitApproval(input = {}) {
+  const projectBrief = typeof input === 'string' ? input : (input.projectBrief || '');
+  const visible = stripHtmlComments(projectBrief);
+  if (!/Validation Tracker|FR Coverage|KPI Coverage|ARB Fail Resolution/i.test(visible)) return [];
+  if (SCOPE_SPLIT_APPROVAL_RE.test(projectBrief)) return [];
+
+  const violations = [];
+  const lines = visible.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!TRACKER_ROW_RE.test(line)) continue;
+    const storyIds = [...new Set(line.match(STORY_ID_RE) || [])];
+    if (storyIds.length > 1) {
+      violations.push({
+        check: 'scope-split',
+        severity: 'error',
+        line: i + 1,
+        message: `Validation Tracker maps one item to multiple Stories (${storyIds.join(', ')}) without Scope split approved marker (R14). Add "Scope split approved: <reason>" before Done.`,
+      });
+    }
+  }
+  return violations;
+}
+
 // ─── Integration / Persistence DoD (R4) ──────────────────────────────
 
 // Evidence terms that prove only in-memory/unit behaviour (insufficient alone).
@@ -392,6 +629,11 @@ const UNIT_ONLY_TERMS = /\bunit\b|단위\s*테스트/i;
 // Evidence terms that prove integration / persistence reached real boundaries.
 const INTEGRATION_TERMS = /\bintegration\b|통합|\bpersist|영속|\brow count|적재|\bcontext test|\be2e\b|database|\bdb\b|repository|commit boundary/i;
 
+const SMOKE_EVIDENCE_TERMS = /\b(?:ui|browser|smoke|manual)\b|브라우저|수동|화면/i;
+const DURABLE_SMOKE_ARTIFACT_TERMS = /\b(?:screenshot|playwright|cypress|selenium|trace|video|manual checklist|checklist)\b|\.(?:png|jpe?g|webp|mp4)\b/i;
+const SMOKE_URL_TERMS = /https?:\/\/|localhost(?::\d+)?|127\.0\.0\.1(?::\d+)?/i;
+const SMOKE_OBSERVATION_TERMS = /\b(?:observed|rows?|counts?|items?|open|closed|breached|at-risk|normal|columns?|filters?)\b|렌더|확인|컬럼|필터|개\s*open|\d+/i;
+
 /**
  * Integration/Persistence DoD: a Story marked "✅ done" must have at least one
  * Proof Ledger row whose evidence indicates integration/persistence — not only
@@ -429,6 +671,52 @@ function checkIntegrationDoD(content) {
   return violations;
 }
 
+/**
+ * Browser/manual/smoke proof is too easy to fake as prose. If a done Story has
+ * a passing UI/manual/smoke Proof Ledger row, require a durable artifact or a
+ * URL plus concrete observed UI data.
+ *
+ * @param {string} content project-state.md
+ * @returns {Array}
+ */
+function checkSmokeEvidence(content) {
+  const violations = [];
+  const visible = stripHtmlComments(content);
+  const doneIds = parseMarkdownTable(getSection(visible, 'Story Status') || '')
+    .filter((row) => /✅\s*done/i.test(rowStatus(row)))
+    .map((row) => storyIdFromRow(row))
+    .filter(Boolean);
+  if (doneIds.length === 0) return violations;
+
+  const ledgerRows = parseMarkdownTable(getSection(visible, 'Proof Ledger') || '');
+  for (const row of ledgerRows) {
+    const values = Object.values(row).filter((v) => typeof v === 'string');
+    const raw = values.join(' ');
+    const story = row.Story || row['Story ID'] || '';
+    const result = row.Result || row.result || raw;
+    if (!/(✅|pass)/i.test(result)) continue;
+    if (story && !doneIds.some((id) => story.includes(id))) continue;
+    if (!SMOKE_EVIDENCE_TERMS.test(raw)) continue;
+
+    const artifact = row.Artifact || row.artifact || '';
+    const command = row['Command / Observation'] || row.Command || row.Observation || '';
+    const hasDurableArtifact = artifact.trim() && !/^[-—n/a]*$/i.test(artifact.trim());
+    const hasToolProof = DURABLE_SMOKE_ARTIFACT_TERMS.test(raw);
+    const hasConcreteManualProof = SMOKE_URL_TERMS.test(command || raw) && SMOKE_OBSERVATION_TERMS.test(command || raw);
+
+    if (!(hasDurableArtifact || hasToolProof || hasConcreteManualProof)) {
+      violations.push({
+        check: 'smoke-evidence',
+        severity: 'error',
+        line: 0,
+        message: `Passing UI/manual/smoke proof for Story ${story || '(unknown)'} is not durable. Add screenshot/Playwright artifact, checklist row, or URL plus exact observed UI counts/elements (R13).`,
+      });
+    }
+  }
+
+  return violations;
+}
+
 // ─── Environment Seal Gate (R9) ──────────────────────────────────────
 
 /**
@@ -501,6 +789,154 @@ function checkPublicBoundary(content, filename = '') {
   return violations;
 }
 
+// ─── Evaluator Artifact Protection (R12) ────────────────────────────
+
+const EVALUATOR_ARTIFACT_PATHS = [
+  /^experiment\/(?:kode-harness-scorecard|run-card|evaluator-).*\.md$/i,
+  /^docs\/experiment\/(?:kode-harness-scorecard|run-card|evaluator-).*\.md$/i,
+  /^docs\/evaluator-.*\.md$/i,
+];
+const EVALUATOR_OWNER_MARKER = /<!--\s*harness-owner:\s*evaluator\s*-->/i;
+const EVALUATOR_APPROVAL_MARKER = /<!--\s*harness-edit-approved:\s*[^>]+-->/i;
+
+function isEvaluatorArtifact(file = '') {
+  const normalized = file.replace(/\\/g, '/');
+  return EVALUATOR_ARTIFACT_PATHS.some((re) => re.test(normalized));
+}
+
+/**
+ * Protect evaluator/run-card/scorecard artifacts from model-under-test rewrites.
+ * Ordinary evaluator-looking paths warn. Files explicitly marked
+ * `harness-owner: evaluator` fail unless a human approval marker is present.
+ *
+ * @param {string} content
+ * @param {string} [filename]
+ * @returns {Array}
+ */
+function checkEvaluatorArtifact(content, filename = '') {
+  if (!isEvaluatorArtifact(filename)) return [];
+  const owned = EVALUATOR_OWNER_MARKER.test(content);
+  const approved = EVALUATOR_APPROVAL_MARKER.test(content);
+  if (owned && !approved) {
+    return [{
+      check: 'evaluator-artifact',
+      severity: 'error',
+      line: 0,
+      message: `${filename}: evaluator-owned artifact changed without explicit approval marker (R12). Add <!-- harness-edit-approved: <reason> --> only when the user explicitly requested this edit.`,
+    }];
+  }
+  if (owned && approved) return [];
+  return [{
+    check: 'evaluator-artifact',
+    severity: 'warn',
+    line: 0,
+    message: `${filename}: evaluator/run-card artifact changed. Confirm the user explicitly requested this edit (R12).`,
+  }];
+}
+
+// ─── Reviewer Audit Evidence Gate (R16) ─────────────────────────────
+
+const REVIEWER_AUDIT_MODULE_LINE = /^\s*[-*]?\s*(?:\*\*)?(?:Verified modules|Verified imports|Dependencies verified|검증(?:된)?\s*(?:모듈|의존성)|확인(?:된)?\s*(?:모듈|의존성))(?:\*\*)?\s*:/im;
+const REVIEWER_AUDIT_IGNORE = new Set([
+  'project',
+  'project-local',
+  'local',
+  'internal',
+  'built-in',
+  'builtin',
+  'node',
+  'none',
+  'n/a',
+]);
+
+function packageNamesFromJson(packageJson = '') {
+  if (!packageJson.trim()) return new Set();
+  try {
+    const pkg = JSON.parse(packageJson);
+    return new Set([
+      ...Object.keys(pkg.dependencies || {}),
+      ...Object.keys(pkg.devDependencies || {}),
+      ...Object.keys(pkg.peerDependencies || {}),
+      ...Object.keys(pkg.optionalDependencies || {}),
+    ]);
+  } catch {
+    return new Set();
+  }
+}
+
+function moduleNamesFromSourceFiles(sourceFiles = []) {
+  const names = new Set();
+  for (const { file = '', content = '' } of sourceFiles) {
+    const base = file.split(/[\\/]/).pop() || '';
+    if (base.includes('.')) names.add(base.replace(/\.[^.]+$/, ''));
+    const requireRe = /\brequire\(\s*['"]([^'"]+)['"]\s*\)/g;
+    const importRe = /\bfrom\s+['"]([^'"]+)['"]/g;
+    for (const re of [requireRe, importRe]) {
+      let match;
+      while ((match = re.exec(content)) !== null) {
+        const spec = match[1];
+        if (spec.startsWith('.')) {
+          const local = spec.split('/').pop();
+          if (local) names.add(local.replace(/\.[^.]+$/, ''));
+          continue;
+        }
+        names.add(spec.split('/')[0]);
+      }
+    }
+  }
+  return names;
+}
+
+function extractAuditModuleNames(content) {
+  const names = new Set();
+  const lines = content.split('\n');
+  for (const line of lines) {
+    if (!REVIEWER_AUDIT_MODULE_LINE.test(line)) continue;
+    const codeNames = [...line.matchAll(/`([^`]+)`/g)].map((m) => m[1]);
+    const source = codeNames.length > 0 ? codeNames.join(',') : line.split(':').slice(1).join(':');
+    for (const raw of source.split(/[,\s/]+/)) {
+      const token = raw.replace(/^[`"'(*\-\s]+|[`"',.)*\s]+$/g, '');
+      if (!token || token.length < 2) continue;
+      if (!/^[A-Za-z][A-Za-z0-9_.:-]*$/.test(token)) continue;
+      if (REVIEWER_AUDIT_IGNORE.has(token.toLowerCase())) continue;
+      names.add(token.replace(/^node:/, ''));
+    }
+  }
+  return [...names];
+}
+
+/**
+ * Reviewer scope audits are allowed to be judgmental, but dependency evidence
+ * must be grounded in package.json or actual require/import lines. This catches
+ * hallucinated modules such as "express" in a Node http-only project.
+ *
+ * @param {string} content reviewer.md
+ * @param {{packageJson?: string, sourceFiles?: Array<{file:string, content:string}>, filename?: string}} context
+ * @returns {Array}
+ */
+function checkReviewerAuditEvidence(content, { packageJson = '', sourceFiles = [], filename = '' } = {}) {
+  const asserted = extractAuditModuleNames(content);
+  if (asserted.length === 0) return [];
+
+  const builtins = new Set(require('module').builtinModules.map((name) => name.replace(/^node:/, '')));
+  const deps = packageNamesFromJson(packageJson);
+  const sourceNames = moduleNamesFromSourceFiles(sourceFiles);
+  const allowed = new Set([...builtins, ...deps, ...sourceNames]);
+
+  const violations = [];
+  for (const name of asserted) {
+    const normalized = name.replace(/^node:/, '');
+    if (allowed.has(normalized)) continue;
+    violations.push({
+      check: 'reviewer-audit',
+      severity: 'error',
+      line: 0,
+      message: `${filename ? filename + ': ' : ''}reviewer audit cites "${name}" as a verified module/dependency, but it is not in package.json or actual require/import lines (R16). Cite exact evidence or remove it.`,
+    });
+  }
+  return violations;
+}
+
 // ─── Markdown lint (R6 / L3-8) ───────────────────────────────────────
 
 /**
@@ -640,6 +1076,14 @@ function isStateMarkdownFile(file) {
   return /(?:^|\/)(?:docs|\.harness)\/(?:project-state|features|dependency-map|project-brief|failure-patterns)\.md$/.test(file);
 }
 
+function isProjectBriefFile(file) {
+  return /(?:^|\/)(?:docs|\.harness)\/project-brief\.md$/.test(file);
+}
+
+function isReviewerMemoryFile(file) {
+  return /(?:^|\/)(?:docs|\.harness)\/agent-memory\/reviewer\.md$/.test(file);
+}
+
 function isScannableForSecrets(file) {
   return /\.(js|ts|jsx|tsx|json|jsonc|ya?ml|env|sh|py|java|md|properties|toml)$/i.test(file)
     && !/\.lock$/.test(file);
@@ -650,6 +1094,35 @@ function isPublicPackageFile(file) {
   return PUBLIC_PACKAGE_PATHS.some((re) => re.test(normalized));
 }
 
+function sourceFilesForAudit(cwd) {
+  const files = [];
+  const roots = ['src', 'lib', 'app', 'server.js', 'index.js'];
+  const addFile = (rel) => {
+    const abs = path.join(cwd, rel);
+    if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) return;
+    if (!/\.(?:js|mjs|cjs|ts|tsx|jsx)$/.test(rel)) return;
+    files.push({ file: rel, content: fs.readFileSync(abs, 'utf8') });
+  };
+  const walkSource = (relDir) => {
+    const absDir = path.join(cwd, relDir);
+    if (!fs.existsSync(absDir) || !fs.statSync(absDir).isDirectory()) return;
+    for (const name of fs.readdirSync(absDir)) {
+      if (name.startsWith('.') || name === 'node_modules') continue;
+      const rel = path.join(relDir, name);
+      const abs = path.join(cwd, rel);
+      if (fs.statSync(abs).isDirectory()) walkSource(rel);
+      else addFile(rel);
+    }
+  };
+  for (const root of roots) {
+    const abs = path.join(cwd, root);
+    if (!fs.existsSync(abs)) continue;
+    if (fs.statSync(abs).isDirectory()) walkSource(root);
+    else addFile(root);
+  }
+  return files;
+}
+
 /**
  * Run all guard checks over a set of files.
  * @param {{files: string[], cwd?: string}} opts
@@ -665,6 +1138,7 @@ function runGuard({ files, cwd = process.cwd() }) {
     const content = fs.readFileSync(abs, 'utf8');
     const rel = path.relative(cwd, abs);
     scanned++;
+    const beforeFile = all.length;
 
     if (isScannableForSecrets(file)) {
       all.push(...scanSecrets(content, rel));
@@ -672,6 +1146,7 @@ function runGuard({ files, cwd = process.cwd() }) {
     if (isPublicPackageFile(rel)) {
       all.push(...checkPublicBoundary(content, rel));
     }
+    all.push(...checkEvaluatorArtifact(content, rel));
     if (file.endsWith('.md') && isStateMarkdownFile(file)) {
       all.push(...lintMarkdownTables(content, rel));
     }
@@ -682,11 +1157,25 @@ function runGuard({ files, cwd = process.cwd() }) {
       const base = path.basename(file);
       all.push(...checkStateFile(content));
       all.push(...checkReviewerHandoff(content));
+      all.push(...checkStoryContracts({ projectState: content }));
       all.push(...checkIntegrationDoD(content));
+      all.push(...checkSmokeEvidence(content));
       all.push(...checkEnvSeal(content));
       if (STATE_LINE_LIMITS[base]) {
         all.push(...lintLineLimit(content, STATE_LINE_LIMITS[base], rel));
       }
+      all.push(...checkSelfVerifyClaim(content, all.slice(beforeFile)));
+    }
+    if (isProjectBriefFile(file)) {
+      all.push(...checkScopeSplitApproval({ projectBrief: content }));
+    }
+    if (isReviewerMemoryFile(file)) {
+      const pkgPath = path.join(cwd, 'package.json');
+      all.push(...checkReviewerAuditEvidence(content, {
+        filename: rel,
+        packageJson: fs.existsSync(pkgPath) ? fs.readFileSync(pkgPath, 'utf8') : '',
+        sourceFiles: sourceFilesForAudit(cwd),
+      }));
     }
   }
 
@@ -699,11 +1188,18 @@ module.exports = {
   scanSecrets,
   checkStateFile,
   checkReviewerHandoff,
+  checkStoryContracts,
   checkLearnCompletion,
   checkStateSync,
+  checkScopeSplitApproval,
+  checkRecentChangesIntegrity,
+  checkSelfVerifyClaim,
   checkIntegrationDoD,
+  checkSmokeEvidence,
   checkEnvSeal,
   checkPublicBoundary,
+  checkEvaluatorArtifact,
+  checkReviewerAuditEvidence,
   lintMarkdownTables,
   lintLineLimit,
   checkInstructionBudget,