minnimemory 1.0.0-beta.1

package/dist/rules.js

@@ -0,0 +1,651 @@
+/**
+ * The MM001-MM010 rule set.
+ *
+ * Every rule is pure: it reads a Workspace and returns Findings. Nothing here touches the
+ * filesystem or the network, which is what makes the whole engine testable from fixtures.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { COMPILED_DIR_NAME, driftHash, verbatimHash } from "./compile.js";
+import { blocks, GRANULARITY_TOKENS, isEpisodicBody, normalise, sections, sectionVolatilityReasons, stripGeneratedRegions, } from "./text.js";
+import { estimateTokens, formatTokens } from "./tokenizer.js";
+import { alwaysLoaded } from "./types.js";
+// ---------------------------------------------------------------------------
+// shared helpers
+// ---------------------------------------------------------------------------
+/** Sections of a memory file, adapted to the MemoryFile wrapper. */
+function fileSections(file) {
+    return sections(file.lines);
+}
+function sectionText(file, s) {
+    return file.lines.slice(s.startLine - 1, s.endLine).join("\n");
+}
+function fileBlocks(file) {
+    return blocks(file.lines);
+}
+/**
+ * Rules return every finding they have. Truncation is a display concern and lives in the human
+ * renderer (report.ts), so `--json` and the exit code always see the complete list: capping here
+ * made the overflow marker's own "re-run with --json for the full list" hint false, and put the
+ * findings it hid out of reach of every output mode.
+ */
+// ---------------------------------------------------------------------------
+// MM001  always-loaded memory exceeds the token budget
+// ---------------------------------------------------------------------------
+const mm001 = {
+    id: "MM001",
+    severity: "high",
+    title: "always-loaded memory exceeds the token budget",
+    run({ workspace, config }) {
+        const loaded = alwaysLoaded(workspace);
+        const total = loaded.reduce((n, f) => n + f.tokens, 0);
+        if (total <= config.budget)
+            return [];
+        const biggest = [...loaded].sort((a, b) => b.tokens - a.tokens)[0];
+        const where = loaded.length === 1
+            ? `${biggest?.rel} is ${formatTokens(total)} tokens`
+            : `${loaded.length} always-loaded files total ${formatTokens(total)} tokens`;
+        return [
+            {
+                rule: "MM001",
+                severity: "high",
+                message: `${where}, resent every turn`,
+                file: biggest?.rel ?? ".",
+                tokens: total,
+                hint: `budget is ${formatTokens(config.budget)}; move task-specific content into routed OnDemandMemory files`,
+            },
+        ];
+    },
+};
+// ---------------------------------------------------------------------------
+// MM002  content derivable from the repo itself
+// ---------------------------------------------------------------------------
+const TREE_CHAR = /[│├└┌┐┘┬┴┼]/;
+/**
+ * One line of a directory listing, in any of the shapes real memory files use:
+ * a bare path, a tree-drawn path, either of those with a trailing "# comment" or "- comment",
+ * or a table row whose first cell is a path. Found by the 2026-09-02 sweep: the most common
+ * real-world shape is a Markdown table of directories, which the old bare-path pattern missed.
+ */
+const PATH_TOKEN = /`?([\w.@+\-<>]+(?:[/\\][\w.@+\-<>*]*)*[/\\]?)`?/;
+// No `^\s*` before a class that also contains `\s`: two adjacent whitespace quantifiers made the
+// old PATHY pattern quadratic on a line of spaces (security audit 2026-09-02, finding 3).
+const TREE_LINE = new RegExp(`^[│├└─|\\s]*${PATH_TOKEN.source}\\s*(?:(?:#|//|-|—|:)\\s.*)?$`);
+const TABLE_ROW = new RegExp(`^\\s*\\|\\s*${PATH_TOKEN.source}\\s*\\|`);
+/** Does the path token look like a path rather than a plain word: a slash, or a file extension. */
+function pathLike(token) {
+    return /[/\\]/.test(token) || /\.[a-z]{1,5}$/i.test(token);
+}
+function treeRuns(file) {
+    const out = [];
+    let start = -1;
+    let treeChars = 0;
+    let paths = 0;
+    let tableRows = 0;
+    const close = (end) => {
+        if (start >= 0) {
+            const len = end - start + 1;
+            if (len >= 6 && (treeChars > 0 || paths >= 3)) {
+                const text = file.lines.slice(start - 1, end).join("\n");
+                const what = tableRows > len / 2 ? "a directory listing" : "a directory tree";
+                out.push({
+                    rule: "MM002",
+                    severity: "med",
+                    message: `lines ${start}-${end} are ${what} derivable from the repo itself`,
+                    file: file.rel,
+                    startLine: start,
+                    endLine: end,
+                    tokens: estimateTokens(text),
+                    hint: "delete it; the agent can list the directory, and this copy goes stale silently",
+                });
+            }
+        }
+        start = -1;
+        treeChars = 0;
+        paths = 0;
+        tableRows = 0;
+    };
+    file.lines.forEach((line, i) => {
+        const n = i + 1;
+        if (line.trim() === "")
+            return close(i);
+        const row = TABLE_ROW.exec(line);
+        const tree = row ? null : TREE_LINE.exec(line);
+        const token = row?.[1] ?? tree?.[1];
+        const isTree = tree !== null && tree !== undefined && TREE_CHAR.test(line);
+        if (token && (isTree || pathLike(token))) {
+            if (start < 0)
+                start = n;
+            if (isTree)
+                treeChars++;
+            if (pathLike(token))
+                paths++;
+            if (row)
+                tableRows++;
+        }
+        else {
+            close(i);
+        }
+    });
+    close(file.lines.length);
+    return out;
+}
+function duplicatedScripts(file, root) {
+    const pkgPath = path.join(root, "package.json");
+    if (!fs.existsSync(pkgPath))
+        return [];
+    let names = [];
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        names = Object.keys(pkg.scripts ?? {});
+    }
+    catch {
+        return [];
+    }
+    if (names.length === 0)
+        return [];
+    const hits = names.filter((n) => file.content.includes(`npm run ${n}`));
+    if (hits.length < 3)
+        return [];
+    return [
+        {
+            rule: "MM002",
+            severity: "med",
+            message: `${hits.length} npm scripts are restated here and already exist in package.json`,
+            file: file.rel,
+            hint: "point the agent at package.json instead of copying the script list",
+        },
+    ];
+}
+const mm002 = {
+    id: "MM002",
+    severity: "med",
+    title: "content derivable from the repo itself",
+    run({ workspace }) {
+        const out = [];
+        for (const file of workspace.files) {
+            out.push(...treeRuns(file));
+            if (file.alwaysLoaded)
+                out.push(...duplicatedScripts(file, workspace.root));
+        }
+        return out.sort((a, b) => (b.tokens ?? 0) - (a.tokens ?? 0));
+    },
+};
+// ---------------------------------------------------------------------------
+// MM003  volatile content in the always-loaded prefix
+// ---------------------------------------------------------------------------
+const mm003 = {
+    id: "MM003",
+    severity: "high",
+    title: "volatile content in the always-loaded prefix",
+    run({ workspace }) {
+        const out = [];
+        for (const file of alwaysLoaded(workspace)) {
+            // The generated OnDemandMemory list is a routing manifest, not prose: its labels are not status.
+            const lines = stripGeneratedRegions(file.lines);
+            for (const s of sections(lines)) {
+                const sectionLines = lines.slice(s.startLine - 1, s.endLine);
+                const reasons = sectionVolatilityReasons(sectionLines);
+                if (reasons.length === 0)
+                    continue;
+                const text = sectionLines.join("\n");
+                out.push({
+                    rule: "MM003",
+                    severity: "high",
+                    message: `"${s.heading}" (lines ${s.startLine}-${s.endLine}) holds ${reasons.join(" and ")} in the always-loaded prefix`,
+                    file: file.rel,
+                    startLine: s.startLine,
+                    endLine: s.endLine,
+                    tokens: estimateTokens(text),
+                    hint: "move it to an OnDemandMemory file; editing it here invalidates the prompt cache every time",
+                });
+            }
+        }
+        return out.sort((a, b) => (b.tokens ?? 0) - (a.tokens ?? 0));
+    },
+};
+// ---------------------------------------------------------------------------
+// MM004  an OnDemandMemory file exists but is unreferenced by any OnDemandMemory list
+// ---------------------------------------------------------------------------
+/**
+ * Does `source` name one of `candidates` in a way an agent could actually open: by relative
+ * path, or by filename including its extension.
+ *
+ * The bare filename stem does NOT count. It used to, and it made the rule near-useless on real
+ * corpora: an OnDemandMemory file called `safety.md` was treated as routed by any file
+ * containing the word "safety" in ordinary prose, so an orphan went unreported the moment its
+ * topic was mentioned anywhere. That is the same false positive the 2026-09-04 list rewrite hit
+ * from the other side, when list prose containing the word "core" was read as a link to core.md.
+ *
+ * One pass over `source.content` per source file, not one `.includes()` scan per candidate:
+ * builds a single regex alternation of every candidate's rel path and basename, escaped, then
+ * matches it once. The original pairwise version (`source.content.includes(target.rel) ||
+ * source.content.includes(base)`, called once per source/candidate pair) measured MM004 alone at
+ * ~320ms wall time against a real 68-file personal memory directory, over the 250ms bar this
+ * rewrite was measured against (2026-09-13 audit round 2, D9).
+ */
+function referencedIn(source, candidates) {
+    const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const byName = new Map();
+    for (const c of candidates) {
+        for (const name of new Set([c.rel, path.basename(c.rel)])) {
+            const list = byName.get(name);
+            if (list)
+                list.push(c);
+            else
+                byName.set(name, [c]);
+        }
+    }
+    const found = new Set();
+    if (byName.size === 0)
+        return found;
+    const pattern = new RegExp([...byName.keys()].map(escapeRegExp).join("|"), "g");
+    for (const match of source.content.matchAll(pattern)) {
+        for (const c of byName.get(match[0]) ?? [])
+            found.add(c);
+    }
+    return found;
+}
+/**
+ * Auto-memory topic files and compiled OnDemandMemory files are routed by different lists, so a
+ * reference only counts inside its own routing domain.
+ */
+function sameDomain(a, b) {
+    return a.rel.startsWith("(auto-memory)/") === b.rel.startsWith("(auto-memory)/");
+}
+/**
+ * Every file reachable from `list`, following references transitively.
+ *
+ * Reachability, not list membership, is what routing actually requires. A file the list names
+ * directly is reachable in one hop; a file named only by a file the list names is reachable in
+ * two, and the agent gets there just as reliably. Splitting an append-only changelog out of a
+ * topic file and leaving a pointer behind produces exactly that shape, and treating the result as
+ * orphaned would make the rule fire on a correct reorganization.
+ *
+ * The reference pairs are computed once, in a single pass, before the walk: doing `includes`
+ * inside the fixpoint loop instead is quadratic over file contents on every round.
+ */
+function reachableFrom(list, files) {
+    const candidates = files.filter((f) => f !== list && sameDomain(f, list));
+    const sources = [list, ...candidates];
+    const edges = new Map();
+    for (const source of sources) {
+        const targets = candidates.filter((target) => target !== source);
+        edges.set(source, [...referencedIn(source, targets)]);
+    }
+    const reached = new Set([list]);
+    const queue = [list];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        for (const next of edges.get(current) ?? []) {
+            if (reached.has(next))
+                continue;
+            reached.add(next);
+            queue.push(next);
+        }
+    }
+    return reached;
+}
+const mm004 = {
+    id: "MM004",
+    severity: "low",
+    title: "OnDemandMemory file unreachable from any OnDemandMemory list",
+    run({ workspace }) {
+        const out = [];
+        const cache = new Map();
+        for (const file of workspace.files) {
+            // Each on-demand file is checked against the OnDemandMemory list that routes to it:
+            // auto-memory topic files against the auto-memory MEMORY.md, compiled OnDemandMemory
+            // files against index.md.
+            const list = file.rel.startsWith("(auto-memory)/") ? workspace.autoMemoryList : workspace.onDemandList;
+            if (!list || file === list || file.alwaysLoaded)
+                continue;
+            // AlwaysOnMemory.md's alwaysOn/onDemandList views are the prefix, not routed content: when
+            // the stub inlines them they are not always-loaded as files, but nothing routes to them
+            // either. Until the 2026-09-04 list rewrite they passed only because the list prose
+            // happened to contain the word "core", which referencesFile() took as a link.
+            if (file.generated || file.kind === "alwaysOn" || file.kind === "onDemandList")
+                continue;
+            let reached = cache.get(list);
+            if (!reached) {
+                reached = reachableFrom(list, workspace.files);
+                cache.set(list, reached);
+            }
+            if (reached.has(file))
+                continue;
+            out.push({
+                rule: "MM004",
+                severity: "low",
+                message: `${file.rel} is not reachable from ${list.rel}`,
+                file: file.rel,
+                tokens: file.tokens,
+                hint: "reference it from the OnDemandMemory list, or from a file the list already routes to; unroutable content is invisible to the agent",
+            });
+        }
+        return out.sort((a, b) => (b.tokens ?? 0) - (a.tokens ?? 0));
+    },
+};
+// ---------------------------------------------------------------------------
+// MM005  substantially duplicated content
+// ---------------------------------------------------------------------------
+const MIN_DUPLICATE_CHARS = 80;
+/**
+ * Blocks repeated verbatim (modulo list-marker/heading-hash/whitespace normalisation) across two
+ * or more files. Shared by MM005 and the multi-file scan (scan.ts) so both see the same picture
+ * of what a reorganize plan should merge.
+ */
+export function findDuplicateBlocks(files) {
+    const seen = new Map();
+    for (const file of files) {
+        // A generated mirror duplicates its stub on purpose.
+        if (file.generated)
+            continue;
+        for (const block of fileBlocks(file)) {
+            const key = normalise(block.text);
+            if (key.length < MIN_DUPLICATE_CHARS)
+                continue;
+            const list = seen.get(key) ?? [];
+            list.push({ file, block });
+            seen.set(key, list);
+        }
+    }
+    const out = [];
+    for (const occurrences of seen.values()) {
+        if (occurrences.length < 2)
+            continue;
+        const first = occurrences[0];
+        if (!first)
+            continue;
+        const wastedTokens = estimateTokens(first.block.text) * (occurrences.length - 1);
+        out.push({ occurrences, wastedTokens });
+    }
+    return out.sort((a, b) => b.wastedTokens - a.wastedTokens);
+}
+const mm005 = {
+    id: "MM005",
+    severity: "med",
+    title: "duplicated content across memory files",
+    run({ workspace }) {
+        const groups = findDuplicateBlocks(workspace.files);
+        const out = groups.map(({ occurrences, wastedTokens }) => {
+            const first = occurrences[0];
+            const where = occurrences
+                .slice(1)
+                .map((o) => `${o.file.rel}:${o.block.startLine}`)
+                .join(", ");
+            return {
+                rule: "MM005",
+                severity: "med",
+                message: `this block appears ${occurrences.length} times, also at ${where}`,
+                file: first.file.rel,
+                startLine: first.block.startLine,
+                endLine: first.block.endLine,
+                tokens: wastedTokens,
+                hint: "keep one copy and reference it; duplicates drift apart over time",
+            };
+        });
+        return out;
+    },
+};
+// ---------------------------------------------------------------------------
+// MM006  OnDemandMemory list line exceeds the character cap
+// ---------------------------------------------------------------------------
+/**
+ * The hook is the descriptive text, with the list marker, any leading markdown link, and a
+ * separator dash stripped. That is the part a human writes and the part worth budgeting;
+ * the link is structural overhead the author cannot shorten much.
+ */
+export function hookText(line) {
+    return line
+        .replace(/^\s*[-*+]\s+/, "")
+        .replace(/^\[[^\]]*\]\([^)]*\)\s*/, "")
+        .replace(/^[—–:-]\s*/, "")
+        .trim();
+}
+const mm006 = {
+    id: "MM006",
+    severity: "low",
+    title: "OnDemandMemory list line exceeds the character cap",
+    run({ workspace, config }) {
+        const lists = [workspace.onDemandList, workspace.autoMemoryList].filter((f, i, all) => f !== undefined && all.indexOf(f) === i);
+        const out = [];
+        for (const list of lists) {
+            list.lines.forEach((line, i) => {
+                if (!/^\s*[-*+]\s+/.test(line))
+                    return;
+                const hook = hookText(line);
+                if (hook.length <= config.maxListLine)
+                    return;
+                out.push({
+                    rule: "MM006",
+                    severity: "low",
+                    message: `OnDemandMemory list hook is ${hook.length} characters, over the ${config.maxListLine} cap (line is ${line.length})`,
+                    file: list.rel,
+                    startLine: i + 1,
+                    endLine: i + 1,
+                    hint: "an OnDemandMemory list line is a hook, not a summary, and it is charged every turn",
+                });
+            });
+        }
+        return out;
+    },
+};
+// ---------------------------------------------------------------------------
+// MM007  flat memory directory with no OnDemandMemory list
+// ---------------------------------------------------------------------------
+const mm007 = {
+    id: "MM007",
+    severity: "med",
+    title: "flat memory directory with no OnDemandMemory list",
+    run({ workspace }) {
+        if ((workspace.shape !== "memory-dir" && workspace.shape !== "auto-memory") || workspace.onDemandList)
+            return [];
+        if (workspace.files.length < 5)
+            return [];
+        const total = workspace.files.reduce((n, f) => n + f.tokens, 0);
+        return [
+            {
+                rule: "MM007",
+                severity: "med",
+                message: `${workspace.files.length} memory files with no OnDemandMemory list, so all ${formatTokens(total)} tokens get read`,
+                file: ".",
+                tokens: total,
+                hint: "add an OnDemandMemory list with one routing line per file so the agent can load on demand",
+            },
+        ];
+    },
+};
+// ---------------------------------------------------------------------------
+// MM008  credential-shaped string in a memory file
+// ---------------------------------------------------------------------------
+const SECRETS = [
+    { re: /\bsk-ant-[A-Za-z0-9_-]{16,}/g, what: "an Anthropic API key" },
+    { re: /\bsk-[A-Za-z0-9]{32,}/g, what: "an OpenAI-style API key" },
+    { re: /\bnvapi-[A-Za-z0-9_-]{16,}/g, what: "an NVIDIA API key" },
+    { re: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}/g, what: "a GitHub token" },
+    { re: /\bgithub_pat_[A-Za-z0-9_]{20,}/g, what: "a GitHub fine-grained token" },
+    { re: /\bAKIA[0-9A-Z]{16}\b/g, what: "an AWS access key id" },
+    { re: /\bAIza[A-Za-z0-9_-]{35}\b/g, what: "a Google API key" },
+    { re: /\bxox[abprs]-[A-Za-z0-9-]{10,}/g, what: "a Slack token" },
+    // Stripe: underscore-separated, so the OpenAI-style `sk-` pattern above never matched these.
+    { re: /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}/g, what: "a Stripe secret key" },
+    { re: /\bwhsec_[A-Za-z0-9]{16,}/g, what: "a Stripe webhook secret" },
+    { re: /-----BEGIN (?:RSA |EC |OPENSSH |PGP )?PRIVATE KEY-----/g, what: "a private key block" },
+    { re: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, what: "a JSON Web Token" },
+    { re: /\brnd_[A-Za-z0-9]{20,}\b/g, what: "a Render API key" },
+];
+/** Never print a credential back out. Show just enough to locate it. */
+function redact(match) {
+    const head = match.slice(0, Math.min(8, match.length));
+    return `${head}${"*".repeat(6)}`;
+}
+/** MM008 for one file. Exported so `init` can refuse to copy a credential into new files. */
+export function secretFindings(file) {
+    const out = [];
+    file.lines.forEach((line, i) => {
+        for (const { re, what } of SECRETS) {
+            re.lastIndex = 0;
+            // Every match on the line, not just the first: two keys assigned on one line are two
+            // credentials to rotate, and reporting one of them reads as though the other is fine.
+            let m;
+            while ((m = re.exec(line)) !== null) {
+                if (!m[0])
+                    break;
+                out.push({
+                    rule: "MM008",
+                    severity: "high",
+                    message: `looks like ${what}: ${redact(m[0])}`,
+                    file: file.rel,
+                    startLine: i + 1,
+                    endLine: i + 1,
+                    hint: "memory files get committed and pasted into prompts; rotate it and remove it",
+                });
+            }
+        }
+    });
+    return out;
+}
+const mm008 = {
+    id: "MM008",
+    severity: "high",
+    title: "credential-shaped string in a memory file",
+    run({ workspace }) {
+        return workspace.files.flatMap(secretFindings);
+    },
+};
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// MM009  a flat section over the granularity threshold in a long-term file
+// ---------------------------------------------------------------------------
+export { GRANULARITY_TOKENS };
+/**
+ * sections() yields leaves: a section ends where the next heading of any level starts, so a
+ * leaf this large has no subheading by construction. An episodic section (mostly dated
+ * bullets) is exempt because the router already addresses it one entry at a time (O4).
+ * The 2026-09-04 audit found a 4,467-token "Current state" with no subheading; any recall
+ * that touched it paid all of it.
+ */
+const mm009 = {
+    id: "MM009",
+    severity: "low",
+    title: "flat section over the granularity threshold",
+    run({ workspace }) {
+        const out = [];
+        for (const file of workspace.files) {
+            if (file.alwaysLoaded || file === workspace.onDemandList || file === workspace.autoMemoryList)
+                continue;
+            if (file.generated || file.kind === "alwaysOn" || file.kind === "onDemandList")
+                continue;
+            for (const s of sections(file.lines)) {
+                if (s.level === 0)
+                    continue;
+                const tokens = estimateTokens(file.lines.slice(s.startLine - 1, s.endLine).join("\n"));
+                if (tokens < GRANULARITY_TOKENS)
+                    continue;
+                const body = file.lines.slice(s.startLine, s.endLine);
+                if (isEpisodicBody(body))
+                    continue;
+                out.push({
+                    rule: "MM009",
+                    severity: "low",
+                    message: `"${s.heading}" is ${formatTokens(tokens)} tokens with no subheading, so a recall that touches it pays all of it`,
+                    file: file.rel,
+                    startLine: s.startLine,
+                    endLine: s.endLine,
+                    tokens,
+                    hint: "add H3 subheadings so retrieval can return the part the task needs (O7)",
+                });
+            }
+        }
+        return out.sort((a, b) => (b.tokens ?? 0) - (a.tokens ?? 0));
+    },
+};
+// ---------------------------------------------------------------------------
+// MM010  a compiled workspace has drifted from what init wrote
+// ---------------------------------------------------------------------------
+/** CRLF-normalised, because a checkout can rewrite line endings without anyone editing. */
+function normalised(content) {
+    return content.replace(/\r\n/g, "\n");
+}
+/**
+ * The re-apply case: someone comes back to a memory they optimised earlier. `doctor` is the
+ * front door for that, so it compares every OnDemandMemory file, the AlwaysOnMemory body and the
+ * OnDemandMemory list on disk against the hashes `init` recorded in manifest.json and names each
+ * file that moved, was removed, or appeared. The remedy is always the same and is printed with
+ * every finding. Read-only, as every rule is; the writing hand stays `init --update`.
+ *
+ * OnDemandMemory file hashes were taken over the trimmed content and the file is written with
+ * one trailing newline, so the OnDemandMemory file side compares trimmed; AlwaysOnMemory.md was
+ * written verbatim.
+ */
+const mm010 = {
+    id: "MM010",
+    severity: "med",
+    title: "compiled workspace has drifted since init",
+    run({ workspace }) {
+        const manifest = workspace.manifest;
+        if (workspace.shape !== "compiled" || !manifest)
+            return [];
+        const out = [];
+        const remedy = "re-apply with: minnimemory init --update  (keeps every OnDemandMemory file, rewrites the OnDemandMemory list, manifest and stub)";
+        const byRel = new Map(workspace.files.map((f) => [f.rel.replace(/\\/g, "/"), f]));
+        const compiledDir = COMPILED_DIR_NAME;
+        const seen = new Set();
+        for (const m of manifest.onDemandFiles) {
+            const rel = `${compiledDir}/${m.file}`;
+            seen.add(rel);
+            const file = byRel.get(rel);
+            if (!file) {
+                out.push({ rule: "MM010", severity: "med", message: `${rel} is in the manifest but missing on disk`, file: rel, hint: remedy });
+                continue;
+            }
+            if (driftHash(file.content) !== m.hash) {
+                out.push({
+                    rule: "MM010",
+                    severity: "med",
+                    message: `${rel} was edited since init wrote it`,
+                    file: rel,
+                    tokens: file.tokens,
+                    hint: remedy,
+                });
+            }
+        }
+        for (const f of workspace.files) {
+            const rel = f.rel.replace(/\\/g, "/");
+            if (f.kind === "onDemand" && !seen.has(rel)) {
+                out.push({ rule: "MM010", severity: "med", message: `${rel} is on disk but not in the manifest`, file: rel, tokens: f.tokens, hint: remedy });
+            }
+        }
+        {
+            const entry = manifest.always;
+            const rel = `${compiledDir}/${entry.file}`;
+            const file = byRel.get(rel);
+            if (file && verbatimHash(normalised(file.content)) !== entry.hash) {
+                out.push({ rule: "MM010", severity: "med", message: `${rel} was edited since init wrote it`, file: rel, tokens: file.tokens, hint: remedy });
+            }
+        }
+        // The stub is the always-loaded prefix, so content appended to it is the drift that costs
+        // most: it is paid on every turn and routed by nothing. Without this check doctor reported
+        // "no drift since init. Nothing to re-apply." with un-routed content sitting in the host
+        // file, and MM001 only noticed once the regrown prefix crossed the budget.
+        if (manifest.stub) {
+            const rel = manifest.stub.file;
+            const file = byRel.get(rel);
+            if (file && verbatimHash(normalised(file.content)) !== manifest.stub.hash) {
+                out.push({
+                    rule: "MM010",
+                    severity: "med",
+                    message: `${rel} was edited since init wrote it`,
+                    file: rel,
+                    tokens: file.tokens,
+                    hint: remedy,
+                });
+            }
+        }
+        return out;
+    },
+};
+export const RULES = [mm001, mm002, mm003, mm004, mm005, mm006, mm007, mm008, mm009, mm010];
+export function ruleById(id) {
+    return RULES.find((r) => r.id.toLowerCase() === id.toLowerCase());
+}