connections-arkitect 0.3.4 → 0.3.5

package/bin/arkitect.mjs

@@ -90,7 +90,38 @@ if (config.update?.autoUpdate === true && !config.update?.pinnedVersion) {
 
 const { audits, loadErrors, shadowed } = await discoverAudits([coreRoot, ...userRoots]);
 for (const le of loadErrors) console.error(`[architect] FAILED TO LOAD check ${le.file}: ${le.error}`); // load failures are NEVER quiet
-if (!quiet) for (const s of shadowed) console.error(`[architect] your-checks override: '${s.id}' shadows the core check`);
+// Same-root duplicate ids are corpus corruption (two files fight over one id, one silently
+// wins) — NEVER quiet, and gated below exactly like a load error. Cross-root shadowing
+// (your-checks patching a core check) is the designed seam — informational only.
+const sameRootDupes = shadowed.filter((s) => s.prevRoot === s.root);
+for (const s of sameRootDupes) console.error(`[architect] DUPLICATE CHECK ID '${s.id}': ${s.by} silently shadows ${s.prevFile}`);
+if (!quiet)
+  for (const s of shadowed.filter((x) => x.prevRoot !== x.root))
+    console.error(`[architect] your-checks override: '${s.id}' shadows the core check`);
+
+// Corpus-integrity failures run as synthetic CRASHED checks: they ride the normal
+// runner machinery (manifest row, FIX_QUEUE [CRASH] line, gatingErrors++, non-zero exit
+// under --fail-on-drift) instead of being a stderr note a green exit code contradicts.
+// They are appended to EVERY selection — a corrupted corpus fails single-check runs too;
+// that is the "crash ≠ silent pass" doctrine, not collateral damage.
+const corpusIntegrityAudits = [
+  ...loadErrors.map((le) => ({
+    id: `corpus-load-error:${le.file.replace(/[\\/]/g, "_").slice(-60)}`,
+    title: `Check file failed to load: ${le.file}`,
+    gating: true,
+    async run() {
+      throw new Error(`FAILED TO LOAD ${le.file}: ${le.error}`);
+    },
+  })),
+  ...sameRootDupes.map((s) => ({
+    id: `corpus-duplicate-id:${s.id}`,
+    title: `Duplicate check id '${s.id}' inside one corpus`,
+    gating: true,
+    async run() {
+      throw new Error(`DUPLICATE CHECK ID '${s.id}': ${s.by} silently shadows ${s.prevFile} — rename one.`);
+    },
+  })),
+];
 
 if (wantList) {
   for (const a of audits.sort((x, y) => x.id.localeCompare(y.id))) {
@@ -113,23 +144,31 @@ let selected = onlyIds ? audits.filter((a) => onlyIds.has(a.id)) : audits;
 if (group) selected = selected.filter((a) => a.__group === group);
 if (excludeGroups.length) selected = selected.filter((a) => !excludeGroups.includes(a.__group));
 if (onlyIds && selected.length < onlyIds.size) {
+  // An explicitly named check that doesn't exist is a HARD failure, not a note: a
+  // renamed check would otherwise silently drop out of its gate lane forever while
+  // the lane kept exiting 0 (verified live 2026-07-05).
   const found = new Set(selected.map((a) => a.id));
   for (const id of onlyIds) if (!found.has(id)) console.error(`[architect] no check with id '${id}'. Try: architect list`);
+  process.exit(2);
 }
 if ((only || group) && selected.length === 0) {
   console.error(`[architect] no check matching ${only ? `id(s) '${only}'` : `group '${group}'`}. Try: architect list`);
   process.exit(2);
 }
+selected = [...selected, ...corpusIntegrityAudits]; // corpus corruption fails EVERY run, loudly
 
 const project = detectProject(root);
-const ctxBase = { root, config, project, options: { failOnDrift, failOnBounty, checkArgs }, vault: null };
+// selectedCount lets umbrella checks (whose sections ALSO run standalone) self-skip in
+// suite runs instead of literally double-executing their members (design-token-compliance
+// alone was ~22s of pure duplication per --all).
+const ctxBase = { root, config, project, options: { failOnDrift, failOnBounty, checkArgs, selectedCount: selected.length }, vault: null };
 const outDir = resolve(root, opt("--out", join("tmp", "arkitect"))); // --out: shard-safe output dir (harness/CI)
 const { manifest } = await runAudits(selected, ctxBase, { outDir });
 
 const t = manifest.telemetry || {};
 const fmtMs = (ms) => (ms >= 10_000 ? `${(ms / 1000).toFixed(1)}s` : `${Math.round(ms || 0)}ms`);
-const line = `Architect · ${manifest.checks.length} checks · ${manifest.gatingErrors} gating error(s) · ${manifest.advisoryFindings ?? 0} advisory finding(s) · ${manifest.warnings} warning(s) · ${manifest.crashed} crash(es) · ${fmtMs(t.totalDurationMs)} · ${t.totalBounces ?? 0} bounce(s) · nextAction=${manifest.pass.nextAction}`;
+const line = `Architect · ${manifest.checks.length} checks · ${manifest.gatingErrors} gating error(s) · ${manifest.advisoryFindings ?? 0} advisory finding(s) · ${manifest.warnings} warning(s) · ${manifest.crashed} crash(es)${manifest.noData ? ` · ${manifest.noData} no-data` : ""} · ${fmtMs(t.totalDurationMs)} · ${t.totalBounces ?? 0} bounce(s) · nextAction=${manifest.pass.nextAction}`;
 console.log(manifest.pass.clean ? `✅ ${line}` : `⚠️  ${line}`);
-console.log("   → tmp/arkitect/FIX_QUEUE.md  ·  tmp/arkitect/manifest.json");
+console.log(`   → ${join(outDir, "FIX_QUEUE.md")}  ·  ${join(outDir, "manifest.json")}`);
 
 process.exit(failOnDrift && manifest.gatingErrors > 0 ? 1 : 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "connections-arkitect",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "type": "module",
   "description": "The Connections Arkitect — a portable, self-updating checks-and-balances framework. Ships a generic core of checks; you add your own in your-checks/ (the core never touches them); it keeps your codebase (and, via the Connections MCP, your hosted cloud) from drifting. Zero runtime dependencies.",
   "bin": {

package/src/checks/code/dependency-freshness.mjs

@@ -3,15 +3,32 @@
 // your build is not reproducible; missing lockfiles mean you can't prove it either. Advisory by default
 // so it never blocks a fork whose own dep conventions differ.
 import { existsSync, readFileSync } from "node:fs";
-import { relative, basename, dirname, join } from "node:path";
+import { relative, basename, dirname, join, resolve } from "node:path";
 import { createFinding } from "../../core/finding.mjs";
 import { walkFiles } from "../../core/fs-walk.mjs";
 
 /** Unpinned range patterns — `*`, `latest`, `>=x`, `>x`. Does NOT flag `^` / `~` (those are pinned ranges). */
 const UNPINNED_RE = /^(\*|latest|>=?)/;
 
-/** Lockfile names we recognize. */
-const LOCKFILES = ["package-lock.json", "bun.lockb", "yarn.lock", "pnpm-lock.yaml"];
+/** Lockfile names we recognize (bun.lock is Bun ≥1.2's text lockfile; bun.lockb the older binary). */
+const LOCKFILES = ["package-lock.json", "bun.lock", "bun.lockb", "yarn.lock", "pnpm-lock.yaml", "npm-shrinkwrap.json"];
+
+/**
+ * A workspace member's installs are locked by the ROOT lockfile — a lockfile anywhere on the
+ * ancestor chain up to the scanned root covers this package.json (same-dir-only was a false
+ * positive on every bun/npm/pnpm workspace member, found 2026-07-05 auditing external repos).
+ */
+function lockfileCovers(dir, root) {
+  const rootAbs = resolve(root);
+  let d = resolve(dir);
+  for (;;) {
+    if (LOCKFILES.some((lf) => existsSync(join(d, lf)))) return true;
+    if (d === rootAbs) return false;
+    const parent = dirname(d);
+    if (parent === d) return false; // filesystem root — package.json outside the scanned root's chain
+    d = parent;
+  }
+}
 
 export const audit = {
   id: "dependency-freshness",
@@ -57,20 +74,17 @@ export const audit = {
 
       // 2. Check for missing lockfile when any deps are declared.
       const hasDeps = Object.keys(pkg.dependencies || {}).length > 0 || Object.keys(pkg.devDependencies || {}).length > 0;
-      if (hasDeps) {
-        const hasLockfile = LOCKFILES.some((lf) => existsSync(join(dir, lf)));
-        if (!hasLockfile) {
-          findings.push(
-            createFinding({
-              id: "missing-lockfile",
-              title: "No lockfile found alongside package.json",
-              severity: "warning",
-              file: relFile,
-              message: `${relFile} declares dependencies but has no lockfile (${LOCKFILES.join(" / ")}) — installs are not reproducible`,
-              fix: "Run your package manager (npm install / bun install / yarn / pnpm install) to generate a lockfile and commit it.",
-            }),
-          );
-        }
+      if (hasDeps && !lockfileCovers(dir, root)) {
+        findings.push(
+          createFinding({
+            id: "missing-lockfile",
+            title: "No lockfile found for package.json",
+            severity: "warning",
+            file: relFile,
+            message: `${relFile} declares dependencies but no lockfile (${LOCKFILES.join(" / ")}) exists beside it or in any ancestor up to the repo root — installs are not reproducible`,
+            fix: "Run your package manager (npm install / bun install / yarn / pnpm install) to generate a lockfile and commit it.",
+          }),
+        );
       }
     }
 

package/src/checks/code/lockfile-manifest-parity.mjs

@@ -0,0 +1,190 @@
+// lockfile-manifest-parity — a bun.lock must be IN SYNC with its package.json.
+//
+// The incident this generalizes (Connections, 2026-07-05): a plane web app's package.json
+// pinned vite 8.1.0, but the plane's own bun.lock was never reinstalled after the bump — its
+// node_modules silently resolved a pre-Rolldown vite 6.4.3, the fleet's `rolldownOptions`
+// vendor-splitting was silently ignored, and the plane shipped a 267.8 KB gz boot entry
+// (2× the fleet budget) for twelve days with every offline gate green. Version drift between
+// what the manifest DECLARES and what the lockfile RECORDED is invisible to typecheck, lint,
+// and bundlers — the build "works", it just isn't the build you pinned.
+//
+// The invariant is purely offline: bun.lock's `workspaces` section mirrors each workspace
+// manifest's dependency sections AS OF THE LAST INSTALL. If a manifest declares a (name,
+// specifier) the mirror doesn't record identically — or the mirror records one the manifest
+// no longer declares — the lockfile is stale and `bun install` in that directory is owed.
+// (This is the same contract `bun install --frozen-lockfile` enforces, checked without
+// running installs or touching the network.)
+//
+// Scope: every directory in the project that holds BOTH a bun.lock and a package.json
+// (standalone-lockfile apps like Connections' `services/<plane>/web` trees, plus the repo
+// root). Multi-workspace lockfiles are compared per workspace entry.
+import fs from "node:fs";
+import path from "node:path";
+
+import { createFinding } from "../../core/finding.mjs";
+import { isIgnoredDir } from "../../core/project-detect.mjs";
+
+const SECTIONS = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
+
+/** bun.lock is JSONC-ish (trailing commas). Tolerant parse (incl. UTF-8 BOM); null on failure. */
+export function parseBunLock(text) {
+  try {
+    return JSON.parse(text.replace(/^\uFEFF/, "").replace(/,\s*([}\]])/g, "$1"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Pure comparison — exported for tests. Returns mismatch records:
+ * { section, name, manifest: spec|null, lock: spec|null } where null = absent on that side.
+ */
+export function compareManifestToLockMirror(manifest, lockWorkspaceEntry) {
+  const mismatches = [];
+  for (const section of SECTIONS) {
+    const m = manifest?.[section] ?? {};
+    const l = lockWorkspaceEntry?.[section] ?? {};
+    for (const [name, spec] of Object.entries(m)) {
+      if (!(name in l)) mismatches.push({ section, name, manifest: String(spec), lock: null });
+      else if (String(l[name]) !== String(spec)) mismatches.push({ section, name, manifest: String(spec), lock: String(l[name]) });
+    }
+    for (const [name, spec] of Object.entries(l)) {
+      if (!(name in m)) mismatches.push({ section, name, manifest: null, lock: String(spec) });
+    }
+  }
+  return mismatches;
+}
+
+function walkForLockfiles(rootAbs) {
+  const out = [];
+  const stack = [rootAbs];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const child = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        // Canonical generated/ignored gate (Architect-internal idiom) — never
+        // treat node_modules/build output as source.
+        if (!isIgnoredDir(entry.name, child)) stack.push(child);
+        continue;
+      }
+      if (entry.name === "bun.lock") out.push(current);
+    }
+  }
+  return out.sort((a, b) => a.localeCompare(b));
+}
+
+// "missing" and "unparseable" are DIFFERENT findings (a BOM'd-but-present manifest
+// mis-reported as absent cost a debugging round on 2026-07-05) — so this returns a
+// tagged result, and parsing tolerates a UTF-8 BOM (Windows tooling writes them).
+function readJsonFile(file) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return { state: "missing", value: null };
+  }
+  try {
+    return { state: "ok", value: JSON.parse(text.replace(/^\uFEFF/, "")) };
+  } catch {
+    return { state: "unparseable", value: null };
+  }
+}
+
+export const audit = {
+  id: "lockfile-manifest-parity",
+  title: "Lockfile ↔ manifest parity (a stale bun.lock ships versions you didn't pin)",
+  category: "code",
+  defaultConfig: { includeInAll: true },
+  async run({ root, checkConfig = {} }) {
+    const rootAbs = path.resolve(root ?? process.cwd());
+    const findings = [];
+    const rows = [];
+
+    for (const dirAbs of walkForLockfiles(rootAbs)) {
+      const relDir = path.relative(rootAbs, dirAbs).replace(/\\/g, "/") || ".";
+      const lockRel = relDir === "." ? "bun.lock" : `${relDir}/bun.lock`;
+      const lock = parseBunLock(fs.readFileSync(path.join(dirAbs, "bun.lock"), "utf8"));
+      if (!lock || typeof lock.workspaces !== "object" || lock.workspaces === null) {
+        findings.push(
+          createFinding({
+            ruleId: "lockfile-unparseable",
+            severity: "error",
+            filePath: lockRel,
+            line: 1,
+            message: `bun.lock could not be parsed (or has no workspaces section) — regenerate it with \`bun install\` in ${relDir}.`,
+          }),
+        );
+        continue;
+      }
+
+      for (const [wsKey, wsEntry] of Object.entries(lock.workspaces)) {
+        const wsDirAbs = wsKey ? path.join(dirAbs, wsKey) : dirAbs;
+        const wsRel = path.relative(rootAbs, wsDirAbs).replace(/\\/g, "/") || ".";
+        const manifestRead = readJsonFile(path.join(wsDirAbs, "package.json"));
+        if (manifestRead.state !== "ok") {
+          findings.push(
+            createFinding({
+              ruleId: "lockfile-orphan-workspace",
+              severity: "error",
+              filePath: lockRel,
+              line: 1,
+              message:
+                manifestRead.state === "missing"
+                  ? `bun.lock records workspace "${wsKey || "."}" but ${wsRel}/package.json does not exist — the lockfile is stale; run \`bun install\` in ${relDir} (or delete the orphan lock).`
+                  : `${wsRel}/package.json exists but is not valid JSON — fix the manifest (check for a UTF-16/mangled encoding), then \`bun install\` in ${relDir}.`,
+            }),
+          );
+          continue;
+        }
+        const manifest = manifestRead.value;
+        const mismatches = compareManifestToLockMirror(manifest, wsEntry);
+        rows.push({ dir: wsRel, mismatches: mismatches.length });
+        for (const mm of mismatches) {
+          const detail =
+            mm.lock === null
+              ? `declares ${mm.name}@${mm.manifest} (${mm.section}) but the lockfile never recorded it`
+              : mm.manifest === null
+                ? `no longer declares ${mm.name} (${mm.section}) but the lockfile still records ${mm.name}@${mm.lock}`
+                : `declares ${mm.name}@${mm.manifest} (${mm.section}) but the lockfile recorded ${mm.name}@${mm.lock} at its last install`;
+          findings.push(
+            createFinding({
+              ruleId: "lockfile-manifest-drift",
+              severity: "error",
+              filePath: `${wsRel === "." ? "" : `${wsRel}/`}package.json`,
+              line: 1,
+              message:
+                `${wsRel}/package.json ${detail} — node_modules is resolving versions you did not pin ` +
+                `(the silent-vite-6 class). Run \`bun install\` in ${relDir} and commit the lockfile.`,
+              metadata: mm,
+            }),
+          );
+        }
+      }
+    }
+
+    const report = [
+      "# Lockfile ↔ manifest parity",
+      "",
+      "Every dir holding both bun.lock + package.json, compared per workspace entry (offline `--frozen-lockfile` contract).",
+      "",
+      ...rows.map((r) => `- \`${r.dir}\` — ${r.mismatches === 0 ? "in sync" : `**${r.mismatches} drift(s)**`}`),
+      "",
+    ].join("\n");
+
+    return {
+      failed: findings.length > 0,
+      findings,
+      jsonPayload: { workspaces: rows, findingCount: findings.length },
+      outputPath: checkConfig.outputPath ?? "tmp/audits/LOCKFILE_MANIFEST_PARITY.md",
+      report,
+    };
+  },
+};

package/src/checks/code/tsconfig-conformance.mjs

@@ -26,7 +26,10 @@ export const audit = {
   domain: "code",
   requires: { ecosystems: ["npm"] },
   gating: false,
-  defaultConfig: { referenceFile: "tsconfig.json" }, // relative to root
+  // referenceFile is relative to root. ignoreKeys: compilerOptions keys deliberately NOT judged —
+  // for axes that legitimately differ per sub-project (e.g. `types` between a Bun daemon and a DOM
+  // SPA) the knob beats removing the key from the reference (which would stop enforcing it locally).
+  defaultConfig: { referenceFile: "tsconfig.json", ignoreKeys: [] },
   async run(ctx) {
     const { root, checkConfig } = ctx;
     const refPath = join(root, checkConfig.referenceFile);
@@ -34,16 +37,26 @@ export const audit = {
     // Parse the reference to extract its compilerOptions keys — these are the axes we judge.
     const refParsed = parseTsconfig(refPath);
     const refCompilerOptions = refParsed?.compilerOptions || {};
-    const refKeys = Object.keys(refCompilerOptions);
+    const ignoreKeys = new Set(checkConfig.ignoreKeys || []);
+    const refKeys = Object.keys(refCompilerOptions).filter((k) => !ignoreKeys.has(k));
     if (refKeys.length === 0) {
       // No compilerOptions in reference — nothing to judge.
       return { failed: false, findings: [], report: "" };
     }
 
+    // A solution-style SHELL (`files: []` + project references) compiles nothing itself — its
+    // compilerOptions are residual/organizational, and judging it against the reference produces
+    // one false "got undefined" per reference key (hit live 2026-07-05). The referenced projects
+    // are judged directly instead.
+    const isSolutionShell = (parsed) =>
+      Array.isArray(parsed?.files) && parsed.files.length === 0 && Array.isArray(parsed?.references) && parsed.references.length > 0;
+
     // Collect all tsconfig.json files (including the reference — the oracle skips it).
     const members = [];
     for (const file of walkFiles(root)) {
-      if (basename(file) === "tsconfig.json") members.push({ path: file });
+      if (basename(file) !== "tsconfig.json") continue;
+      if (isSolutionShell(parseTsconfig(file))) continue;
+      members.push({ path: file });
     }
     if (members.length === 0) return { failed: false, findings: [], report: "" };
 

package/src/checks/code/veteran-would-mock.mjs

@@ -21,6 +21,23 @@
 //     same line, or attached directly above the statement — is a documented decision; only the
 //     wordless swallow is flagged.
 //
+// The 2026-07-05 expansion (web-research pass: Reddit/HN "AI code tells" threads + the platform
+// release notes an AI trained before them keeps missing) added two families:
+//   - AI-slop signatures: chat narration committed as comments ("rest of the code remains the
+//     same", "here's the updated…", "as an AI model", "in a real application"), emoji-decorated
+//     comments (a documented LLM signature — netcraft.com/blog/excessive-emojis-as-an-ai-indicator),
+//     rewrite-artifact identifiers (fooImproved/fooEnhanced), and inference-redundant literal
+//     annotations (`const x: string = "…"`).
+//   - platform fossils — old idioms whose modern replacement clears this repo's floor (Node 24
+//     Lambdas, Bun 1.3 tooling, Vue 3.5, Tailwind 4, evergreen browsers): indexOf-sentinels
+//     (includes, ES2016), arr[arr.length-1] (.at(-1), ES2022), hasOwnProperty (Object.hasOwn,
+//     ES2022), slice().sort() ( toSorted/toReversed, ES2023), hand-rolled deferreds
+//     (Promise.withResolvers, ES2024), Object.assign({},…) (spread), TS `namespace`,
+//     ref<HTMLElement>(null) (useTemplateRef, Vue 3.5), and Tailwind utilities REMOVED in v4
+//     (the *-opacity-* family, flex-shrink/grow-*, overflow-ellipsis, decoration-slice/clone —
+//     silently inert classes, i.e. live rendering bugs; the official removed table at
+//     tailwindcss.com/docs/upgrade-guide).
+//
 // Considered and deliberately NOT rules (so nobody re-proposes them):
 //   - TODO/FIXME/HACK — owned by the `stale-todos` check.
 //   - `await new Promise(r => setTimeout(r, n))` — legitimate backoff/polling is mechanically
@@ -28,6 +45,17 @@
 //   - `setTimeout(fn, 0)` — sometimes the correct macrotask deferral in UI code.
 //   - `x == null` — the one idiomatic loose equality (null-or-undefined).
 //   - complexity / file size / duplication — owned by the codeRisk group.
+//   - markdown fences (```) — legitimate in JSDoc @example blocks and md-generating template
+//     literals; a fence at CODE position breaks the build and typecheck already catches it.
+//   - reduce-as-groupBy → Object.groupBy — the reduce shape is too polymorphic to match without
+//     an AST; mostly false positives.
+//   - Temporal / Uint8Array.fromBase64 — not baseline yet (Temporal absent from Node 24).
+//   - Bun.* API pushes (Bun.$, Bun.SQL, Bun.Glob) — Lambdas run Node, and Node-API code in
+//     dual-context files is correct, not a fossil.
+//   - Vue defineModel / Tailwind v4 RENAMED utilities (shadow-sm, rounded, ring, outline-none) —
+//     the old forms still work (renames changed meaning, so flagging them would assert false
+//     semantics); only utilities v4 REMOVED are flagged.
+//   - unused imports / docstring-overload / naming inconsistency — eslint's lane or semantic.
 //
 //   bun packages/connections-arkitect/bin/arkitect.mjs --root . --check veteran-would-mock
 import { readFileSync } from "node:fs";
@@ -276,6 +304,9 @@ const CODE_RULES = [
     id: "redundant-boolean-ternary",
     severity: "error",
     re: /\?\s*true\s*:\s*false\b|\?\s*false\s*:\s*true\b/g,
+    // TS conditional TYPES (`T extends U ? true : false`) are the idiomatic type-level boolean —
+    // required syntax, not a launderable value ternary. Guarded via `extends` on/near the match line.
+    typeContextGuard: true,
     what: "`cond ? true : false` — a boolean laundered through a ternary",
     fix: "Use the condition itself (negate it for the inverted form).",
   },
@@ -362,8 +393,132 @@ const CODE_RULES = [
     what: "`as unknown as` double-cast — the type system asked a question and was told to shut up",
     fix: "Prefer a real type guard or a narrower seam type; keep only genuinely unavoidable boundary casts.",
   },
+  // ── 2026-07-05 expansion: AI-slop signatures ────────────────────────────────
+  {
+    id: "redundant-literal-annotation",
+    severity: "error",
+    extKey: "tsExtensions",
+    re: /\b(?:const|let)\s+[\w$]+\s*:\s*(?:string|number|boolean)\s*=/g,
+    rawLineRe: /=\s*(?:["'`]|-?\d|true\b|false\b)/,
+    what: '`const x: string = "…"` — annotating what inference already knows; the classic AI-generated tell',
+    fix: "Drop the annotation (use `satisfies` when you genuinely need to check against a wider type).",
+  },
+  {
+    id: "rewrite-suffix-identifier",
+    severity: "error",
+    re: /\b(?:function|const|let)\s+[\w$]*(?:Improved|Enhanced|Refactored|Optimized)\b/g,
+    what: "an `…Improved`/`…Enhanced` identifier — the AI-rewrite artifact whose name still argues with a predecessor",
+    fix: "Name the thing for what it does; delete the predecessor the name implies.",
+  },
+  {
+    id: "redundant-null-undefined-check",
+    severity: "error",
+    re: /([A-Za-z_$][\w$]*)\s*!==\s*null\s*&&\s*\1\s*!==\s*undefined|([A-Za-z_$][\w$]*)\s*!==\s*undefined\s*&&\s*\2\s*!==\s*null/g,
+    what: "`x !== null && x !== undefined` — over-defensive AI boilerplate; `x != null` says exactly this in one clause",
+    fix: "Use `x != null` (the one idiomatic loose equality) or `??`.",
+  },
+  // ── 2026-07-05 expansion: platform fossils (repo floor: Node 24 / Vue 3.5 / evergreen) ──────
+  {
+    id: "ts-namespace-fossil",
+    severity: "error",
+    extKey: "tsExtensions",
+    re: /(?<![.\w$])(?:export\s+)?namespace\s+[A-Za-z]/g,
+    what: "TS `namespace` — the pre-ES-modules module system",
+    fix: "Use ES module files and exports.",
+  },
+  {
+    id: "indexof-sentinel",
+    severity: "error",
+    re: /\.indexOf\((?:[^()]|\([^()]*\))*\)\s*(?:!==?\s*-1|>\s*-1|>=\s*0|===?\s*0(?![.\d]))/g,
+    what: "`indexOf(…) !== -1` / `=== 0` — `.includes()` and `.startsWith()` shipped in 2016",
+    fix: "Use `.includes(…)` for the sentinel form, `.startsWith(…)` for `=== 0` (position-arithmetic uses of indexOf are fine and not matched).",
+  },
+  {
+    // INFO, not error: under this repo's TS config `arr[arr.length - 1]` types as T while
+    // `.at(-1)` types as T | undefined, so the swap is not mechanically safe — harvest
+    // opportunistically where the undefined-widening is absorbed anyway.
+    id: "last-index-fossil",
+    severity: "info",
+    re: /([A-Za-z_$][\w$]*)\[\1\.length\s*-\s*1\]/g,
+    what: "`arr[arr.length - 1]` — `.at(-1)` has existed since ES2022",
+    fix: "Use `.at(-1)` where the T|undefined return type is acceptable.",
+  },
+  {
+    id: "object-assign-empty-fossil",
+    severity: "error",
+    re: /Object\.assign\(\s*\{\s*\}\s*,/g,
+    what: "`Object.assign({}, …)` — the pre-spread shallow copy",
+    fix: "Use spread: `{ ...source }`.",
+  },
+  {
+    id: "deferred-promise-fossil",
+    severity: "error",
+    re: /new\s+Promise\s*(?:<[^>]*>)?\s*\(\s*\(?([\w$]+)(?:\s*,\s*[\w$]+)?\)?\s*=>\s*\{?\s*[\w$][\w$.]*\s*=\s*\1\b/g,
+    what: "a hand-rolled deferred (executor param captured to an outer variable) — `Promise.withResolvers()` is ES2024",
+    fix: "const { promise, resolve, reject } = Promise.withResolvers() (Node 22+ / evergreen; this repo's floor is Node 24).",
+  },
+  {
+    id: "hasownproperty-fossil",
+    severity: "info",
+    re: /\.hasOwnProperty\b/g,
+    what: "hasOwnProperty gymnastics (including the `Object.prototype.hasOwnProperty.call` dance) — `Object.hasOwn()` is ES2022",
+    fix: "Object.hasOwn(obj, key).",
+  },
+  {
+    // Deliberately NOT matching `[...x].sort()`: the spread already made the copy (sorting it
+    // in place is a legitimate single-copy idiom) and the spread source may be a Set/iterable
+    // with no .toSorted at all. Only the two-step `.slice().sort()` chain is the fossil.
+    id: "slice-sort-fossil",
+    severity: "info",
+    re: /\.slice\(\)\s*\.\s*(?:sort|reverse)\s*\(/g,
+    what: "`.slice().sort()` copy-then-mutate ordering — `.toSorted()`/`.toReversed()` are ES2023",
+    fix: "Use .toSorted(…) / .toReversed().",
+  },
+  {
+    // .vue SFCs only: a NAME-bound template ref in <script setup> is the convertible class.
+    // Element refs held in .ts composables are REFERENCE-bound (the component wires them via
+    // :ref binding), where useTemplateRef's string lookup does not apply — legit, not fossil.
+    id: "vue-element-ref-fossil",
+    severity: "info",
+    extKey: "vueExtensions",
+    re: /\bref<(?:HTML|SVG)\w*\s*(?:\|\s*null\s*)?>\s*\(\s*null\s*\)/g,
+    what: "element ref via `ref<HTMLElement…>(null)` — Vue 3.5's `useTemplateRef()` is the purpose-built API",
+    fix: "useTemplateRef('name') (Vue ≥ 3.5) when the ref is name-bound in this SFC's template.",
+  },
 ];
 
+// Comment-view rules — chat narration and LLM decoration committed as comments.
+const COMMENT_RULES = [
+  {
+    id: "ai-paste-artifact",
+    severity: "error",
+    re: /rest of (?:the )?(?:code|file|function|component|implementation) (?:remains|stays|is) (?:the same|unchanged)|\.\.\. ?existing code|existing code (?:remains|unchanged)|as an ai (?:language )?model|here'?s the (?:updated|corrected|complete|fixed) (?:code|version|file|implementation)|in a real (?:app|application|production system)\b|implementation goes here|rest of your code/gi,
+    what: "an AI paste artifact — chat narration committed as a comment",
+    fix: "Delete the narration (and make sure the code it elides actually made it into the file).",
+  },
+  {
+    id: "emoji-comment",
+    severity: "info",
+    oncePerLine: true,
+    re: /[\u{1F000}-\u{1FAFF}\u{2705}\u{274C}\u{2728}\u{2757}\u{2764}]/gu,
+    what: "emoji in a code comment — a documented LLM signature (engineers annotate; models decorate)",
+    fix: "Say it in words. (CLI status output and product copy are out of scope; doctrine markers like ⚠/⛔ are deliberately not matched.)",
+  },
+];
+
+// Tailwind utilities REMOVED in v4 — in a v4 build these classes are silently inert, i.e. live
+// rendering bugs. Token-anchored (a repo-own `gc-flex-shrink` class must never match) after
+// stripping variant prefixes (`md:`, `hover:`). Renamed-but-still-valid utilities are deliberately
+// NOT here (they changed meaning; flagging them would assert false semantics).
+const TAILWIND_V4_DEAD =
+  /^(?:(?:bg|text|border|divide|placeholder|ring)-opacity-\d+|flex-(?:shrink|grow)(?:-\d+)?|overflow-ellipsis|decoration-(?:slice|clone))$/;
+const TAILWIND_DEAD_RULE = {
+  id: "tailwind-v4-dead-utility",
+  severity: "error",
+  what: "a Tailwind utility REMOVED in v4 sits in a class attribute — it compiles to nothing, the element silently mis-renders",
+  fix: "Per the v4 upgrade guide: *-opacity-N → color/N modifiers (bg-black/50), flex-shrink/grow → shrink/grow, overflow-ellipsis → text-ellipsis, decoration-slice/clone → box-decoration-*.",
+};
+
 const RAW_RULES = [
   {
     id: "merge-conflict-marker",
@@ -450,9 +605,11 @@ export const audit = {
   domain: "code",
   requires: {},
   defaultConfig: {
-    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".vue"],
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".vue", ".html"],
     varDeclarationExtensions: [".ts", ".tsx", ".vue"],
     doubleCastExtensions: [".ts", ".tsx", ".vue"],
+    tsExtensions: [".ts", ".tsx", ".vue"],
+    vueExtensions: [".vue"],
     // Rules that only make sense in browser-shipped code fire only under these path markers.
     frontendPathMarkers: ["/web/src/"],
     // Per-rule canonical homes (declared, not silenced): the ONE shared wrapper allowed to fall
@@ -553,7 +710,7 @@ export const audit = {
         while ((m = rule.re.exec(raw))) push(rule, m.index);
       }
 
-      const views = buildViews(raw, ext === ".vue");
+      const views = buildViews(raw, ext === ".vue" || ext === ".html");
       const sanctionedHomes = cfg.sanctionedHomes || {};
       for (const rule of CODE_RULES) {
         if (rule.extKey && !cfg[rule.extKey].includes(ext)) continue;
@@ -562,6 +719,24 @@ export const audit = {
         rule.re.lastIndex = 0;
         let m;
         while ((m = rule.re.exec(views.code))) {
+          // Some rules confirm against the RAW line (the code view blanks string content, so a
+          // literal-RHS test must look at the original text).
+          if (rule.rawLineRe && !rule.rawLineRe.test(rawLines[lineAt(starts, m.index) - 1] || "")) continue;
+          // typeContextGuard: a bare `extends` on the match line or up to 3 lines above marks a
+          // TS conditional TYPE (`T extends U ? true : false`) — required type-level syntax, not a
+          // value ternary. Bias toward false negatives: a suppressed real ternary costs one nitpick;
+          // a flagged conditional type is a gating false positive (hit live 2026-07-05).
+          if (rule.typeContextGuard) {
+            const matchLine = lineAt(starts, m.index);
+            let typeCtx = false;
+            for (let k = matchLine; k >= Math.max(1, matchLine - 3); k--) {
+              if (/(?<![.\w$])extends\b/.test(rawLines[k - 1] || "")) {
+                typeCtx = true;
+                break;
+              }
+            }
+            if (typeCtx) continue;
+          }
           // A guarded rule is skipped when a comment documents the decision: in the RAW match
           // span, on the rest of its line, or attached directly above the statement (up to 3
           // lines up, a blank line breaks attachment) — `catch { /* best-effort */ }`,
@@ -588,6 +763,35 @@ export const audit = {
         }
       }
 
+      // Comment-view rules: chat narration + LLM decoration committed as comments.
+      for (const rule of COMMENT_RULES) {
+        rule.re.lastIndex = 0;
+        let m;
+        let lastFlaggedLine = -1;
+        while ((m = rule.re.exec(views.comment))) {
+          const line = lineAt(starts, m.index);
+          if (rule.oncePerLine && line === lastFlaggedLine) continue;
+          lastFlaggedLine = line;
+          push(rule, m.index);
+        }
+      }
+
+      // Tailwind v4 REMOVED utilities in class attributes (.vue/.html templates): token-anchored
+      // after variant-prefix strip, so a repo-own `gc-flex-shrink` class never matches.
+      if (ext === ".vue" || ext === ".html") {
+        const CLASS_ATTR = /\bclass\s*=\s*(["'])([\s\S]*?)\1/g;
+        let cm;
+        while ((cm = CLASS_ATTR.exec(raw))) {
+          for (const tokenRaw of cm[2].split(/\s+/)) {
+            const token = tokenRaw.replace(/^(?:[\w-]+:)+/, "");
+            if (TAILWIND_V4_DEAD.test(token)) {
+              push(TAILWIND_DEAD_RULE, cm.index);
+              break;
+            }
+          }
+        }
+      }
+
       // Commented-out code: runs of ≥ N consecutive code-shaped comment lines.
       const commentLines = views.comment.split("\n");
       let runStart = -1;

package/src/core/discovery.mjs

@@ -29,7 +29,13 @@ export async function discoverAudits(roots) {
       for (const audit of candidates) {
         if (!audit || typeof audit !== "object" || typeof audit.id !== "string" || typeof audit.run !== "function") continue;
         if (byId.get(audit.id) === audit) continue; // same object exported under two names
-        if (byId.has(audit.id)) shadowed.push({ id: audit.id, by: file });
+        if (byId.has(audit.id)) {
+          const prev = byId.get(audit.id);
+          // Cross-root shadowing (your-checks over core) is the designed patch seam;
+          // SAME-root duplication is corpus corruption — two files fighting over one id,
+          // one silently winning. Record the roots so the CLI can gate the latter.
+          shadowed.push({ id: audit.id, by: file, prevFile: prev.__file, prevRoot: prev.__root, root });
+        }
         audit.__file = file;
         audit.__group = basename(dirname(file));
         audit.__root = root;

package/src/core/fs-walk.mjs

@@ -1,8 +1,27 @@
 // One filesystem walker, reused by discovery + every check (DRY). Skips the usual build/vendor dirs.
 import { readdirSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { IGNORE_DIRS, isIgnoredDir } from "./project-detect.mjs";
 
+// Workspace-level scan exclusions (config `scan.excludeDirs`): repo-relative paths the TARGET
+// workspace declares as non-source — generated run output (an `output/` of AI-produced HTML),
+// imported data, vendored-in trees (a generated shadcn `components/ui/`) that the generic
+// IGNORE set can't know by name. Set once per run by the runner from the workspace config, and
+// scoped by ABSOLUTE path prefix — so walks over other roots (e.g. check discovery inside the
+// core package itself) are never affected.
+let SCAN_EXCLUDE_PREFIXES = [];
+export function setScanExcludes(root, dirs = []) {
+  const rootPosix = resolve(root).replace(/\\/g, "/").replace(/\/+$/, "");
+  SCAN_EXCLUDE_PREFIXES = (Array.isArray(dirs) ? dirs : [])
+    .filter((d) => typeof d === "string" && d.trim())
+    .map((d) => `${rootPosix}/${d.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "")}`);
+}
+function isScanExcluded(p) {
+  if (SCAN_EXCLUDE_PREFIXES.length === 0) return false;
+  const posix = p.replace(/\\/g, "/");
+  return SCAN_EXCLUDE_PREFIXES.some((pre) => posix === pre || posix.startsWith(`${pre}/`));
+}
+
 export function* walkFiles(dir, { ignore = IGNORE_DIRS, includeDotfiles = false } = {}) {
   let entries;
   try {
@@ -13,6 +32,7 @@ export function* walkFiles(dir, { ignore = IGNORE_DIRS, includeDotfiles = false
   for (const e of entries) {
     if (!includeDotfiles && e.name.startsWith(".")) continue;
     const p = join(dir, e.name);
+    if (isScanExcluded(p)) continue; // workspace-declared non-source (files and dirs alike)
     if (e.isDirectory()) {
       // isIgnoredDir is the canonical generated-output matcher (names + dist-* family + Capacitor
       // webDir copies); a custom `ignore` set ADDS to it, never re-admits build output.

package/src/core/init.mjs

@@ -17,9 +17,10 @@ import { join, dirname } from "node:path";
 
 const DEFAULT_CONFIG = {
   $note:
-    "The Architect's per-workspace config. YOUR files are this one + your-checks/ + spines/ — a core update never touches them. hosted.targets take NON-SECRET coordinates only (ARNs, database names); credentials stay in the Connections vault (hosted checks run credential-blind through the MCP).",
+    "The Architect's per-workspace config. YOUR files are this one + your-checks/ + spines/ — a core update never touches them. scan.excludeDirs lists repo-relative dirs that are data/generated/vendored, not source — every check's file walk skips them. checks.<id> tunes one check (its defaultConfig keys, plus gating/enabled/includeInAll). hosted.targets take NON-SECRET coordinates only (ARNs, database names); credentials stay in the Connections vault (hosted checks run credential-blind through the MCP).",
   version: 1,
   update: { channel: "stable", pinnedVersion: null, autoUpdate: true },
+  scan: { excludeDirs: [] },
   checks: {},
   hosted: { failOnBounty: false, targets: [] },
 };

package/src/core/runner.mjs

@@ -14,10 +14,11 @@
 // every run is archived to `.arkitect/reports/<stamp>/` — manifest + FIX_QUEUE + telemetry + each
 // check's full report — so "what did it find last Tuesday" is a folder, not a memory. Pruned to
 // `reports.keep` (default 20). No `.arkitect/` ⇒ no archive (a bare run stays stateless).
-import { mkdirSync, writeFileSync, existsSync, readdirSync, rmSync, copyFileSync } from "node:fs";
+import { mkdirSync, writeFileSync, existsSync, readdirSync, readFileSync, rmSync, copyFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { countSeverities } from "./finding.mjs";
 import { checkAppliesToProject } from "./project-detect.mjs";
+import { setScanExcludes } from "./fs-walk.mjs";
 import { toSarif } from "./sarif.mjs";
 
 const now = () => globalThis.performance?.now?.() ?? Date.now();
@@ -83,6 +84,9 @@ function instrumentVault(vault, tel) {
 
 export async function runAudits(audits, ctxBase, { outDir }) {
   mkdirSync(outDir, { recursive: true });
+  // Workspace scan exclusions (config `scan.excludeDirs`) apply to EVERY check's walk of this
+  // root — set here so both doors (CLI + the MCP in-process runner) honor them identically.
+  setScanExcludes(ctxBase.root, ctxBase.config?.scan?.excludeDirs);
   const results = [];
   for (const audit of audits) {
     if (!checkAppliesToProject(audit.requires, ctxBase.project)) {
@@ -96,7 +100,15 @@ export async function runAudits(audits, ctxBase, { outDir }) {
     const checkConfig = { ...(audit.defaultConfig || {}), ...((ctxBase.config?.checks || {})[audit.id] || {}) };
     // A workspace may override a check's gating in config (checks.<id>.gating: false ⇒ advisory) —
     // the visible, reviewable way to acknowledge known findings without silencing the check.
-    const effectiveGating = typeof checkConfig.gating === "boolean" ? checkConfig.gating : audit.gating;
+    // A check also declares its own posture via `enabled: false` / `includeInAll: false` in
+    // defaultConfig/config: it still RUNS (visibility), but never gates. This is the corpus's
+    // long-standing contract (~150 checks declare it; the check-gating-integrity oracle governs
+    // it via the advisory-allowlist) — this runner ignoring those keys made every one of those
+    // declarations silently dead until 2026-07-05.
+    const effectiveGating =
+      (typeof checkConfig.gating === "boolean" ? checkConfig.gating : audit.gating) !== false &&
+      checkConfig.enabled !== false &&
+      checkConfig.includeInAll !== false;
 
     // Telemetry seams for THIS check: instrumented vault + instrumented global fetch. The runner is
     // sequential, so the fetch swap cannot bleed across checks; it is ALWAYS restored.
@@ -153,6 +165,7 @@ export async function runAudits(audits, ctxBase, { outDir }) {
     // Normalize severity dialects ONCE, here — every consumer downstream (counts, gating, SARIF,
     // DECISION_BRIEF ordering) then agrees. "warn"/"review"→warning, "err"/"fatal"→error, "note"→info.
     // (Only adjudicated dialects are mapped — domain scales like axe's minor/serious pass through.)
+    const unknownSeverities = new Set();
     for (const f of findings) {
       if (f && typeof f.severity === "string") {
         const s = f.severity.toLowerCase();
@@ -164,26 +177,49 @@ export async function runAudits(audits, ctxBase, { outDir }) {
               : s === "note" || s === "information"
                 ? "info"
                 : s;
+        if (f.severity !== "error" && f.severity !== "warning" && f.severity !== "info") unknownSeverities.add(f.severity);
       }
     }
+    // A non-canonical severity silently counts as info (i.e. as nothing) downstream —
+    // that may be a domain scale (axe) or a typo'd "error"; either way say so once.
+    if (unknownSeverities.size) {
+      console.error(`[architect] ${audit.id}: non-canonical severity value(s) counted as info: ${[...unknownSeverities].join(", ")}`);
+    }
     const counts = findings.length ? countSeverities(findings) : out?.report ? countsFromReport(out.report) : countSeverities(findings);
     const failed = out?.failed ?? counts.errors > 0;
     // Write the report whenever the check surfaced ANYTHING — including the thermometer shape
     // (error-severity findings from a check that chose not to fail): an advisory finding with no
     // report on disk is invisible to the AI-first reader, which is the disarmed-check failure mode.
+    const reportPath = out?.outputPath || join(outDir, `${audit.id}.md`);
     if (out?.report && (failed || counts.errors > 0 || counts.warnings > 0)) {
-      const path = out.outputPath || join(outDir, `${audit.id}.md`);
       try {
-        mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, out.report);
+        mkdirSync(dirname(reportPath), { recursive: true });
+        writeFileSync(reportPath, out.report);
       } catch {
         /* best-effort report write */
       }
+    } else if (out) {
+      // Clean run: actively remove the PRIOR run's report at this check's path so a
+      // stale failing report can't be mistaken for current findings.
+      try {
+        rmSync(reportPath, { force: true });
+      } catch {
+        /* best-effort stale-report cleanup */
+      }
     }
+    // A check whose INPUT is absent (no capture/build/registry to audit) returns
+    // { status: "no-data", reason } — first-class, never "clean": a gate must not
+    // report green for a check that verified nothing (the vacuous-green class,
+    // 13 checks found 2026-07-05). Visible in the manifest + FIX_QUEUE, non-gating.
+    // A check may also return { status: "skipped", reason } to self-skip (e.g. an
+    // umbrella whose sections run standalone in the same suite) — recorded exactly
+    // like a requires-not-met skip.
+    const selfStatus = out?.status === "no-data" || out?.status === "skipped" ? out.status : null;
     results.push({
       id: audit.id,
       audit,
-      status: failed ? "failed" : counts.warnings ? "warned" : "clean",
+      status: selfStatus ?? (failed ? "failed" : counts.warnings ? "warned" : "clean"),
+      ...(selfStatus && out?.reason ? { reason: out.reason } : {}),
       gating: effectiveGating,
       findings,
       counts,
@@ -200,7 +236,8 @@ export async function runAudits(audits, ctxBase, { outDir }) {
 function rank(r) {
   if (r.status === "crashed") return 0;
   if (r.status === "failed") return 1;
-  return 2;
+  if (r.status === "warned") return 2;
+  return 3; // no-data last — visible, but below actionable findings
 }
 
 const SEV_ORDER = { error: 0, warning: 1, info: 2 };
@@ -211,13 +248,21 @@ function summarize(results, outDir, ctxBase = {}) {
     gatingErrors = 0,
     advisoryFindings = 0,
     warnings = 0,
-    crashed = 0;
+    crashed = 0,
+    noData = 0;
   for (const r of results) {
     if (r.status === "crashed") {
       crashed++;
       gatingErrors++;
       continue;
     }
+    if (r.status === "no-data") {
+      // Input absent — the check verified NOTHING. Never counted clean, never gates;
+      // surfaced in the manifest + FIX_QUEUE so absent coverage is visible, not green.
+      noData++;
+      continue;
+    }
+    if (r.status === "skipped") continue; // requires-not-met or self-skip — no counts to add
     const c = r.counts || { errors: 0, warnings: 0 };
     totalErrors += c.errors;
     warnings += c.warnings;
@@ -248,7 +293,7 @@ function summarize(results, outDir, ctxBase = {}) {
       ? `  [${fmtMs(r.durationMs)}${r.bounces?.count ? ` · ${r.bounces.count} bounce${r.bounces.count === 1 ? "" : "s"}` : ""}]`
       : "";
   const offenders = results
-    .filter((r) => r.status === "failed" || r.status === "crashed" || r.status === "warned")
+    .filter((r) => r.status === "failed" || r.status === "crashed" || r.status === "warned" || r.status === "no-data")
     .sort((a, b) => rank(a) - rank(b));
   const queue = offenders.map((r) => {
     const configAdvisory = (r.gating ?? r.audit.gating) === false;
@@ -256,11 +301,22 @@ function summarize(results, outDir, ctxBase = {}) {
     // count "a", never "e", so a scan of the queue for `e/` finds only genuinely blocking work
     // (the same AI-first legibility rule as the summary counts).
     const nonBlocking = configAdvisory || (r.status !== "failed" && r.status !== "crashed");
-    const tag = r.status === "crashed" ? "CRASH" : configAdvisory ? "ADVISORY" : r.status === "warned" ? "WARN" : "ERROR";
+    const tag =
+      r.status === "crashed"
+        ? "CRASH"
+        : r.status === "no-data"
+          ? "NO-DATA"
+          : configAdvisory
+            ? "ADVISORY"
+            : r.status === "warned"
+              ? "WARN"
+              : "ERROR";
     const detail =
       r.status === "crashed"
         ? `  ${r.error?.split("\n")[0] || ""}`
-        : `  (${r.counts?.errors || 0}${nonBlocking ? "a" : "e"}/${r.counts?.warnings || 0}w)`;
+        : r.status === "no-data"
+          ? `  ${r.reason || "input artifact absent — nothing verified"}`
+          : `  (${r.counts?.errors || 0}${nonBlocking ? "a" : "e"}/${r.counts?.warnings || 0}w)`;
     return `- [${tag}] ${r.id} — ${r.audit.title}${detail}${telLine(r)}`;
   });
   writeFileSync(
@@ -276,6 +332,8 @@ function summarize(results, outDir, ctxBase = {}) {
     advisoryFindings,
     warnings,
     crashed,
+    // Checks whose input artifact was absent — they verified nothing (never "clean").
+    noData,
     telemetry: { totalDurationMs, totalBounces, slowest },
     checks: results.map((r) => ({
       id: r.id,
@@ -355,10 +413,26 @@ function summarize(results, outDir, ctxBase = {}) {
         }
       }
       // Prune to reports.keep (default 20), oldest first — an archive that grows forever is a leak.
+      // COMPREHENSIVE (~full-suite) archives get extra protection: in a multi-agent repo a
+      // flood of 1-check runs evicts the one archive that matters within seconds (observed
+      // live 2026-07-05: a fresh --all archive gone in ~45s). The newest reports.keepFull
+      // (default 3) archives with ≥100 checks survive the window regardless.
       const keep = Number(ctxBase.config?.reports?.keep ?? 20);
-      const runs = readdirSync(join(root, ".arkitect", "reports")).sort();
+      const keepFull = Number(ctxBase.config?.reports?.keepFull ?? 3);
+      const reportsDir = join(root, ".arkitect", "reports");
+      const runs = readdirSync(reportsDir).sort();
+      const isComprehensive = (d) => {
+        try {
+          return (JSON.parse(readFileSync(join(reportsDir, d, "manifest.json"), "utf8")).checks?.length ?? 0) >= 100;
+        } catch {
+          return false;
+        }
+      };
+      const fullRuns = runs.filter(isComprehensive);
+      const protectedFull = new Set(fullRuns.slice(Math.max(0, fullRuns.length - keepFull)));
       for (const old of runs.slice(0, Math.max(0, runs.length - keep))) {
-        rmSync(join(root, ".arkitect", "reports", old), { recursive: true, force: true });
+        if (protectedFull.has(old)) continue;
+        rmSync(join(reportsDir, old), { recursive: true, force: true });
       }
     }
   } catch {