codeloop-mcp-server 0.1.50 → 0.1.52

package/dist/evidence/change_manifest.js

@@ -0,0 +1,830 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync, } from "fs";
+import { dirname, isAbsolute, join, relative, resolve as resolvePath, sep, posix } from "path";
+import { execSync } from "child_process";
+import { homedir } from "os";
+import { readLoopState } from "./loop_state.js";
+import { listRuns, getRunDir, getArtifactsBaseDir } from "./artifacts.js";
+import { loadRunIndex } from "./run_lineage.js";
+/** Source-tree directories we never scan. */
+const EXCLUDE_DIR_NAMES = new Set([
+    "node_modules",
+    ".git",
+    ".vs",
+    ".idea",
+    ".vscode",
+    ".codeloop",
+    "artifacts",
+    "dist",
+    "build",
+    "out",
+    "bin",
+    "obj",
+    ".next",
+    ".turbo",
+    ".cache",
+    ".gradle",
+    "DerivedData",
+    "__pycache__",
+    "target",
+    ".venv",
+    "venv",
+    "Pods",
+]);
+/** File-name patterns we ignore even when their mtime is newer. */
+const EXCLUDE_FILE_PATTERNS = [
+    /^\.DS_Store$/,
+    /^Thumbs\.db$/,
+    /^package-lock\.json$/,
+    /^pnpm-lock\.yaml$/,
+    /^yarn\.lock$/,
+    /^poetry\.lock$/,
+    /^Cargo\.lock$/,
+    /\.log$/,
+    /\.lock$/,
+    /\.Designer\.cs$/, // EF migration designer files are auto-generated
+    /\.pb\.go$/,
+    /\.generated\.\w+$/,
+];
+/** File extensions whose contents we know how to parse for feature-shape. */
+const PARSEABLE_EXTS = new Set([
+    ".xaml",
+    ".axaml",
+    ".html",
+    ".jsx",
+    ".tsx",
+    ".vue",
+    ".cs",
+    ".ts",
+    ".dart",
+    ".swift",
+    ".kt",
+    ".sql",
+]);
+function gitAvailable(cwd) {
+    if (!existsSync(join(cwd, ".git")))
+        return false;
+    try {
+        execSync("git rev-parse --is-inside-work-tree", {
+            cwd,
+            stdio: "ignore",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function gitHeadSha(cwd) {
+    try {
+        return execSync("git rev-parse HEAD", { cwd, encoding: "utf-8" }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Git's well-known SHA for the empty tree. Diffing `EMPTY_TREE..HEAD`
+ * universally returns the entire HEAD tree as adds, which is what we
+ * want as the absolute fallback when there's no prior verify SHA AND
+ * no `HEAD~1` reachable (e.g. a single-commit repo on first verify).
+ */
+const EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+function gitDiffNameStatus(cwd, fromSha) {
+    const out = [];
+    // We try a sequence of ranges from "most precise" to "always-works".
+    // The first range that produces output wins. The key invariant: the
+    // function MUST return a non-empty list whenever the working tree
+    // contains any committed file, because the C3 gate scores against
+    // these entries.
+    const ranges = [];
+    if (fromSha)
+        ranges.push(`${fromSha}..HEAD`);
+    ranges.push("HEAD~1..HEAD");
+    ranges.push(`${EMPTY_TREE_SHA}..HEAD`);
+    for (const range of ranges) {
+        try {
+            const raw = execSync(`git diff --name-status ${range}`, {
+                cwd,
+                encoding: "utf-8",
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+            for (const line of raw.split("\n")) {
+                const m = /^([AMDRCTU])\d*\s+(.+)$/.exec(line.trim());
+                if (!m)
+                    continue;
+                const status = m[1];
+                const path = m[2].split("\t").pop() || m[2];
+                out.push({ status, path });
+            }
+            if (out.length > 0)
+                return out;
+        }
+        catch {
+            /* try next range */
+        }
+    }
+    return out;
+}
+function gitStatusPorcelain(cwd) {
+    const out = [];
+    try {
+        const raw = execSync("git status --porcelain=v1 -uall", {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        for (const line of raw.split("\n")) {
+            if (!line)
+                continue;
+            // `XY path` where XY is the index/worktree status. Untracked is `??`.
+            const head = line.slice(0, 2);
+            const path = line.slice(3).trim();
+            if (!path)
+                continue;
+            let status = "M";
+            if (head === "??")
+                status = "?";
+            else if (head.includes("A"))
+                status = "A";
+            else if (head.includes("D"))
+                status = "D";
+            else if (head.includes("R"))
+                status = "R";
+            else if (head.includes("M"))
+                status = "M";
+            out.push({ status, path });
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return out;
+}
+function toFileChange(cwd, e) {
+    const rel = e.path.replace(/\\/g, "/");
+    return {
+        relPath: rel,
+        status: e.status,
+        absPath: join(cwd, rel.split("/").join(sep)),
+    };
+}
+function deduplicate(changes) {
+    const seen = new Map();
+    for (const c of changes) {
+        const existing = seen.get(c.relPath);
+        if (!existing) {
+            seen.set(c.relPath, c);
+            continue;
+        }
+        // Prefer A (newest authored content) > M > others, so an uncommitted
+        // ADD beats a committed M from earlier in the same diff range.
+        const rank = {
+            A: 5,
+            "?": 5,
+            M: 4,
+            R: 3,
+            C: 3,
+            T: 2,
+            U: 1,
+            D: 0,
+        };
+        if (rank[c.status] >= rank[existing.status]) {
+            seen.set(c.relPath, c);
+        }
+    }
+    return [...seen.values()];
+}
+function isExcluded(relPath) {
+    const parts = relPath.split("/");
+    for (const p of parts) {
+        if (EXCLUDE_DIR_NAMES.has(p))
+            return true;
+    }
+    const fname = parts[parts.length - 1] ?? "";
+    if (EXCLUDE_FILE_PATTERNS.some((re) => re.test(fname)))
+        return true;
+    return false;
+}
+function listProjectFiles(cwd, depth = 6) {
+    const out = [];
+    function walk(dir, d) {
+        if (d > depth)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            const name = ent.name;
+            if (EXCLUDE_DIR_NAMES.has(name))
+                continue;
+            const full = join(dir, name);
+            if (ent.isDirectory()) {
+                walk(full, d + 1);
+            }
+            else if (ent.isFile()) {
+                if (EXCLUDE_FILE_PATTERNS.some((re) => re.test(name)))
+                    continue;
+                out.push(full);
+            }
+        }
+    }
+    walk(cwd, 0);
+    return out;
+}
+function filesNewerThanMs(cwd, sinceMs) {
+    const out = [];
+    for (const abs of listProjectFiles(cwd)) {
+        try {
+            const st = statSync(abs);
+            if (st.mtimeMs > sinceMs) {
+                const rel = relative(cwd, abs).split(sep).join(posix.sep);
+                out.push({ relPath: rel, status: "M", absPath: abs });
+            }
+        }
+        catch {
+            /* skip unreadable */
+        }
+    }
+    return out;
+}
+function lastVerifyMs(cwd) {
+    try {
+        const idx = loadRunIndex(getArtifactsBaseDir(cwd));
+        let max = 0;
+        for (const e of idx.entries) {
+            const ts = e.finished_at ?? e.started_at;
+            if (!ts)
+                continue;
+            const ms = Date.parse(ts);
+            if (Number.isFinite(ms) && ms > max)
+                max = ms;
+        }
+        return max;
+    }
+    catch {
+        return 0;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────
+// Per-file parsers
+// ─────────────────────────────────────────────────────────────────────
+function readSafe(absPath) {
+    try {
+        return readFileSync(absPath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function classNameForFile(filePath) {
+    const base = filePath.split("/").pop() ?? filePath;
+    const dot = base.lastIndexOf(".");
+    return dot > 0 ? base.slice(0, dot) : base;
+}
+function pushUnique(arr, entry) {
+    // Idempotent push — protects against "the same property" emerging
+    // from both the diff parser and the structural parser.
+    const key = JSON.stringify(entry);
+    for (const e of arr) {
+        if (JSON.stringify(e) === key)
+            return;
+    }
+    arr.push(entry);
+}
+/** Header / Content / x:Name attribute extractor for a single XAML element. */
+function readXamlAttr(elementText, attr) {
+    const re = new RegExp(`${attr}\\s*=\\s*"([^"]+)"`);
+    const m = re.exec(elementText);
+    return m ? m[1] : null;
+}
+/**
+ * Parse XAML / AXAML for added DataGridTextColumn / DataGridCheckBoxColumn /
+ * Button / MenuItem / TabItem / TextBox / ComboBox / CheckBox elements.
+ * For added files we report every match; for modified files we diff the
+ * element list against the old content to surface only adds.
+ */
+function parseXaml(filePath, newContent, oldContent, out) {
+    const elementRe = /<(DataGridTextColumn|DataGridCheckBoxColumn|DataGridTemplateColumn|DataGridComboBoxColumn|Button|MenuItem|TabItem|TextBox|ComboBox|CheckBox)\b[^/>]*\/?>/g;
+    function collectFromText(text) {
+        const list = [];
+        let m;
+        elementRe.lastIndex = 0;
+        while ((m = elementRe.exec(text))) {
+            const tag = m[1];
+            const raw = m[0];
+            const header = readXamlAttr(raw, "Header") ??
+                readXamlAttr(raw, "Content") ??
+                readXamlAttr(raw, "x:Name") ??
+                readXamlAttr(raw, "Name") ??
+                "";
+            if (!header)
+                continue;
+            list.push({ tag, name: header, raw });
+        }
+        return list;
+    }
+    const newEls = collectFromText(newContent);
+    const oldEls = oldContent ? collectFromText(oldContent) : [];
+    const oldKey = new Set(oldEls.map((e) => `${e.tag}::${e.name}`));
+    for (const el of newEls) {
+        const k = `${el.tag}::${el.name}`;
+        if (oldKey.has(k))
+            continue;
+        let element;
+        if (el.tag.startsWith("DataGrid"))
+            element = "datagrid_column";
+        else if (el.tag === "Button")
+            element = "button";
+        else if (el.tag === "MenuItem" || el.tag === "TabItem")
+            element = "menu_item";
+        else
+            element = "input";
+        pushUnique(out, {
+            kind: "ui_element_added",
+            element,
+            name: el.name,
+            file: filePath,
+        });
+    }
+    // Detect a top-level layout-container restructure: when the OUTERMOST
+    // grouping element type changes (e.g. Grid → StackPanel) at the same
+    // depth, surface a single layout_restructure entry. This catches the
+    // exact Photometry-DB buttons-below-title fix.
+    if (oldContent !== null) {
+        const newRoot = firstStructuralContainer(newContent);
+        const oldRoot = firstStructuralContainer(oldContent);
+        if (newRoot && oldRoot && newRoot !== oldRoot) {
+            pushUnique(out, {
+                kind: "layout_restructure",
+                file: filePath,
+                from: oldRoot,
+                to: newRoot,
+            });
+        }
+    }
+}
+function firstStructuralContainer(text) {
+    // Scan for the first <Grid|StackPanel|DockPanel|WrapPanel|Canvas> after
+    // the root document element. Used purely for layout-restructure detection.
+    const re = /<(Grid|StackPanel|DockPanel|WrapPanel|Canvas|Border|UniformGrid)\b/;
+    const m = re.exec(text);
+    return m ? m[1] : null;
+}
+function parseHtmlOrJsx(filePath, newContent, oldContent, out) {
+    // For HTML / JSX / TSX / Vue we look for added <button>, <a>, <input>,
+    // <select>, <textarea> elements with discriminating identifiers.
+    const elementRe = /<(button|a|input|select|textarea)\b([^>]*)>(?:([^<]{0,200}?)<\/\1>)?/gi;
+    function collect(text) {
+        const list = [];
+        let m;
+        elementRe.lastIndex = 0;
+        while ((m = elementRe.exec(text))) {
+            const tag = m[1].toLowerCase();
+            const attrs = m[2];
+            const inner = (m[3] ?? "").trim();
+            const aria = readXamlAttr(attrs, "aria-label") ??
+                readXamlAttr(attrs, "data-testid") ??
+                readXamlAttr(attrs, "id") ??
+                readXamlAttr(attrs, "name") ??
+                readXamlAttr(attrs, "placeholder") ??
+                "";
+            const name = aria || inner;
+            if (!name)
+                continue;
+            list.push({ tag, name: name.slice(0, 60) });
+        }
+        return list;
+    }
+    const newEls = collect(newContent);
+    const oldEls = oldContent ? collect(oldContent) : [];
+    const oldKey = new Set(oldEls.map((e) => `${e.tag}::${e.name}`));
+    for (const el of newEls) {
+        if (oldKey.has(`${el.tag}::${el.name}`))
+            continue;
+        let element;
+        if (el.tag === "button" || el.tag === "a")
+            element = "button";
+        else
+            element = "input";
+        pushUnique(out, {
+            kind: "ui_element_added",
+            element,
+            name: el.name,
+            file: filePath,
+        });
+    }
+}
+const CSHARP_PROPERTY_RE = /^\s*public\s+(?:virtual\s+|override\s+|static\s+|readonly\s+)*[\w<>?,\s[\]]+?\s+(\w+)\s*\{\s*get\s*;/;
+const CSHARP_METHOD_RE = /^\s*public\s+(?:virtual\s+|override\s+|static\s+|async\s+)*[\w<>?,\s[\]]+?\s+(\w+)\s*\(/;
+const FEATURE_METHOD_RE = /^(Propagate|On|Update|Add|Delete|Save|Load|Refresh|Handle|Toggle|Open|Close|Submit|Apply)\w*$/;
+function parseCsharp(filePath, newContent, oldContent, out) {
+    const className = classNameForFile(filePath);
+    function members(text) {
+        const properties = [];
+        const methods = [];
+        for (const line of text.split("\n")) {
+            const propMatch = CSHARP_PROPERTY_RE.exec(line);
+            if (propMatch) {
+                properties.push(propMatch[1]);
+                continue;
+            }
+            const methodMatch = CSHARP_METHOD_RE.exec(line);
+            if (methodMatch && FEATURE_METHOD_RE.test(methodMatch[1])) {
+                methods.push(methodMatch[1]);
+            }
+        }
+        return { properties, methods };
+    }
+    const cur = members(newContent);
+    const prev = oldContent ? members(oldContent) : { properties: [], methods: [] };
+    const prevProps = new Set(prev.properties);
+    const prevMethods = new Set(prev.methods);
+    for (const p of cur.properties) {
+        if (prevProps.has(p))
+            continue;
+        pushUnique(out, {
+            kind: "property_added",
+            class: className,
+            name: p,
+            file: filePath,
+        });
+    }
+    for (const m of cur.methods) {
+        if (prevMethods.has(m))
+            continue;
+        pushUnique(out, {
+            kind: "method_added",
+            class: className,
+            name: m,
+            file: filePath,
+        });
+    }
+}
+function parseTs(filePath, newContent, oldContent, out) {
+    const className = classNameForFile(filePath);
+    const propRe = /^\s*(?:public\s+|export\s+(?:public\s+)?)?(?:readonly\s+)?(\w+)\s*(?:[:?]\s*[\w<>|[\],\s'"]+)?\s*=\s*(?!\s*function|\s*\()/;
+    const methodRe = /^\s*(?:public\s+|export\s+(?:async\s+)?function\s+|async\s+)?(?:async\s+)?(\w+)\s*\(/;
+    function members(text) {
+        const properties = [];
+        const methods = [];
+        for (const line of text.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("//") || trimmed.startsWith("*"))
+                continue;
+            const pm = propRe.exec(line);
+            if (pm) {
+                properties.push(pm[1]);
+                continue;
+            }
+            const mm = methodRe.exec(line);
+            if (mm && FEATURE_METHOD_RE.test(mm[1])) {
+                methods.push(mm[1]);
+            }
+        }
+        return { properties, methods };
+    }
+    const cur = members(newContent);
+    const prev = oldContent ? members(oldContent) : { properties: [], methods: [] };
+    const prevProps = new Set(prev.properties);
+    const prevMethods = new Set(prev.methods);
+    for (const p of cur.properties) {
+        if (prevProps.has(p))
+            continue;
+        pushUnique(out, { kind: "property_added", class: className, name: p, file: filePath });
+    }
+    for (const m of cur.methods) {
+        if (prevMethods.has(m))
+            continue;
+        pushUnique(out, { kind: "method_added", class: className, name: m, file: filePath });
+    }
+}
+function parseSwiftKtDart(filePath, newContent, oldContent, out) {
+    // Light shared regex — Swift `var/let name: Type`, Kotlin `val/var name`,
+    // Dart `final Type name` / `Type get name`. We only flag public-looking
+    // identifiers (not _-prefixed) and feature-shape methods.
+    const className = classNameForFile(filePath);
+    const propRe = /^\s*(?:public\s+|open\s+)?(?:final\s+|var\s+|let\s+|val\s+)\s*(\w+)/;
+    const methodRe = /^\s*(?:public\s+|open\s+|fun\s+|func\s+|void\s+|Future\b)\s*(\w+)\s*\(/;
+    function members(text) {
+        const properties = [];
+        const methods = [];
+        for (const line of text.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("//") || trimmed.startsWith("*"))
+                continue;
+            const pm = propRe.exec(line);
+            if (pm && !pm[1].startsWith("_"))
+                properties.push(pm[1]);
+            const mm = methodRe.exec(line);
+            if (mm && FEATURE_METHOD_RE.test(mm[1]))
+                methods.push(mm[1]);
+        }
+        return { properties, methods };
+    }
+    const cur = members(newContent);
+    const prev = oldContent ? members(oldContent) : { properties: [], methods: [] };
+    const prevProps = new Set(prev.properties);
+    const prevMethods = new Set(prev.methods);
+    for (const p of cur.properties) {
+        if (prevProps.has(p))
+            continue;
+        pushUnique(out, { kind: "property_added", class: className, name: p, file: filePath });
+    }
+    for (const m of cur.methods) {
+        if (prevMethods.has(m))
+            continue;
+        pushUnique(out, { kind: "method_added", class: className, name: m, file: filePath });
+    }
+}
+/**
+ * Parse EF Core migration C# files for `migrationBuilder.AddColumn` /
+ * `CreateTable` calls, plus standalone .sql DDL files.
+ */
+function parseMigration(filePath, newContent, out) {
+    // EF: migrationBuilder.AddColumn<...>(name: "ProductCode", table: "Products", ...)
+    const efAddColRe = /AddColumn\s*<[^>]+>\s*\(\s*name\s*:\s*"([^"]+)"\s*,\s*table\s*:\s*"([^"]+)"/g;
+    let m;
+    while ((m = efAddColRe.exec(newContent))) {
+        pushUnique(out, {
+            kind: "migration_column_added",
+            table: m[2],
+            column: m[1],
+            file: filePath,
+        });
+    }
+    const efCreateTableRe = /migrationBuilder\.CreateTable\s*\(\s*name\s*:\s*"([^"]+)"/g;
+    while ((m = efCreateTableRe.exec(newContent))) {
+        pushUnique(out, { kind: "migration_table_added", table: m[1], file: filePath });
+    }
+    // Plain SQL DDL — `ALTER TABLE x ADD COLUMN y …` and `CREATE TABLE x …`.
+    const sqlAlterRe = /ALTER\s+TABLE\s+["`[]?(\w+)["`\]]?\s+ADD\s+(?:COLUMN\s+)?["`[]?(\w+)["`\]]?/gi;
+    while ((m = sqlAlterRe.exec(newContent))) {
+        pushUnique(out, {
+            kind: "migration_column_added",
+            table: m[1],
+            column: m[2],
+            file: filePath,
+        });
+    }
+    const sqlCreateRe = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["`[]?(\w+)["`\]]?/gi;
+    while ((m = sqlCreateRe.exec(newContent))) {
+        pushUnique(out, { kind: "migration_table_added", table: m[1], file: filePath });
+    }
+}
+function isMigrationFile(relPath) {
+    // EF-style: any .cs under a Migrations folder (Designer.cs is excluded
+    // earlier). SQL DDL: any .sql file. We do NOT treat .ts/.js typeorm
+    // migration files specifically; the parseTs property/method extractor
+    // catches Add* / Create* feature-shaped methods in those.
+    if (/(?:^|\/)Migrations\//i.test(relPath) && relPath.endsWith(".cs"))
+        return true;
+    if (relPath.endsWith(".sql"))
+        return true;
+    return false;
+}
+function parseFileChange(change, oldGetter, out) {
+    if (change.status === "D")
+        return;
+    const relPosix = change.relPath;
+    const ext = (() => {
+        const dot = relPosix.lastIndexOf(".");
+        return dot > 0 ? relPosix.slice(dot).toLowerCase() : "";
+    })();
+    if (!PARSEABLE_EXTS.has(ext) && !isMigrationFile(relPosix))
+        return;
+    const newContent = readSafe(change.absPath);
+    if (newContent === null)
+        return;
+    const oldContent = oldGetter(relPosix);
+    if (isMigrationFile(relPosix)) {
+        parseMigration(relPosix, newContent, out);
+        return;
+    }
+    switch (ext) {
+        case ".xaml":
+        case ".axaml":
+            parseXaml(relPosix, newContent, oldContent, out);
+            return;
+        case ".html":
+        case ".vue":
+        case ".jsx":
+        case ".tsx":
+            parseHtmlOrJsx(relPosix, newContent, oldContent, out);
+            // .tsx also has TS code — extract added properties/methods.
+            if (ext === ".tsx" || ext === ".jsx")
+                parseTs(relPosix, newContent, oldContent, out);
+            return;
+        case ".cs":
+            parseCsharp(relPosix, newContent, oldContent, out);
+            return;
+        case ".ts":
+            parseTs(relPosix, newContent, oldContent, out);
+            return;
+        case ".dart":
+        case ".swift":
+        case ".kt":
+            parseSwiftKtDart(relPosix, newContent, oldContent, out);
+            return;
+    }
+}
+/**
+ * Build a ChangeManifest for the project at `cwd`. The result is also
+ * written to `<runDir>/change_manifest.json` when `runDir` is provided.
+ */
+export function buildChangeManifest(cwd, runDir) {
+    const entries = [];
+    const changedFiles = [];
+    const excluded = [];
+    // Track the verified SHA per project so the next run knows where to
+    // start the diff. Stored alongside H7's loop-state under the same key.
+    let baseline = "mtime";
+    let verifiedSha = null;
+    const useGit = gitAvailable(cwd);
+    let priorSha = null;
+    if (useGit) {
+        baseline = "git+uncommitted";
+        priorSha = readVerifiedSha(cwd);
+        verifiedSha = gitHeadSha(cwd);
+        const committed = gitDiffNameStatus(cwd, priorSha);
+        const uncommitted = gitStatusPorcelain(cwd);
+        const merged = deduplicate([
+            ...committed.map((e) => toFileChange(cwd, e)),
+            ...uncommitted.map((e) => toFileChange(cwd, e)),
+        ]);
+        const oldContentCache = new Map();
+        function gitOldContent(relPath) {
+            if (!priorSha)
+                return null;
+            if (oldContentCache.has(relPath))
+                return oldContentCache.get(relPath) ?? null;
+            let v = null;
+            try {
+                v = execSync(`git show ${priorSha}:${quoteForShell(relPath)}`, {
+                    cwd,
+                    encoding: "utf-8",
+                    stdio: ["ignore", "pipe", "ignore"],
+                });
+            }
+            catch {
+                v = null;
+            }
+            oldContentCache.set(relPath, v);
+            return v;
+        }
+        for (const c of merged) {
+            if (isExcluded(c.relPath)) {
+                excluded.push(c.relPath);
+                continue;
+            }
+            changedFiles.push(c.relPath);
+            parseFileChange(c, gitOldContent, entries);
+        }
+    }
+    else {
+        baseline = "mtime";
+        const sinceMs = lastVerifyMs(cwd);
+        const merged = filesNewerThanMs(cwd, sinceMs);
+        for (const c of merged) {
+            if (isExcluded(c.relPath)) {
+                excluded.push(c.relPath);
+                continue;
+            }
+            changedFiles.push(c.relPath);
+            // No prior content available outside git — feed null.
+            parseFileChange(c, () => null, entries);
+        }
+    }
+    const manifest = {
+        schema_version: 1,
+        baseline,
+        verified_sha: verifiedSha,
+        generated_at: new Date().toISOString(),
+        changed_files: changedFiles,
+        excluded_files: excluded,
+        entries,
+    };
+    if (runDir) {
+        try {
+            mkdirSync(runDir, { recursive: true });
+            writeFileSync(join(runDir, "change_manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    return manifest;
+}
+function quoteForShell(arg) {
+    // We pass refs of the form `<sha>:<path>` to `git show`, so we can't
+    // wrap the whole arg in quotes. Just escape spaces — paths with quotes
+    // are vanishingly rare in source trees and would have other problems.
+    return arg.replace(/(["'\s])/g, "\\$1");
+}
+function shaStatePath() {
+    if (process.env.CODELOOP_LOOP_STATE_DIR) {
+        return join(process.env.CODELOOP_LOOP_STATE_DIR, "verified-sha.json");
+    }
+    // Mirror loop_state.ts's homedir fallback. We deliberately use a
+    // separate file so the existing loop_state.json schema doesn't grow.
+    return join(homedir(), ".codeloop", "verified-sha.json");
+}
+function readShaState() {
+    const path = shaStatePath();
+    if (!existsSync(path))
+        return { schema_version: 1, projects: {} };
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (parsed && typeof parsed === "object" && parsed.projects) {
+            return { schema_version: 1, projects: parsed.projects };
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    return { schema_version: 1, projects: {} };
+}
+function projectKey(cwd) {
+    return isAbsolute(cwd) ? cwd : resolvePath(cwd);
+}
+export function readVerifiedSha(cwd) {
+    // The H7 loop-state file is the source-of-truth for the rest of the
+    // counter machinery. We READ from it via the shared key (resolving
+    // the project) so manual `codeloop_doctor --reset-loop-state` doesn't
+    // have to know about a second file. Storage lives in its own file.
+    void readLoopState; // keep the import — the H7 module side-effects
+    const all = readShaState();
+    const key = projectKey(cwd);
+    return all.projects[key]?.verified_sha ?? null;
+}
+export function writeVerifiedSha(cwd, sha) {
+    if (!sha)
+        return;
+    const all = readShaState();
+    const key = projectKey(cwd);
+    all.projects[key] = { verified_sha: sha, updated_at: new Date().toISOString() };
+    try {
+        const path = shaStatePath();
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, JSON.stringify(all, null, 2), "utf-8");
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/**
+ * Convenience helper used by gate_check / capture_screenshot to load the
+ * latest manifest for a run. Returns null when the file is missing.
+ */
+export function loadChangeManifest(runDir) {
+    const path = join(runDir, "change_manifest.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Returns the most recent change manifest across all runs in the project,
+ * preferring the one tied to `preferredRunId` when present. Used by
+ * gate_check / change-coverage to score against the same manifest the
+ * verify run produced even when the user re-runs gate_check standalone.
+ */
+export function loadMostRecentChangeManifest(cwd, preferredRunId) {
+    const baseDir = getArtifactsBaseDir(cwd);
+    if (preferredRunId) {
+        const m = loadChangeManifest(getRunDir(preferredRunId, baseDir));
+        if (m)
+            return { manifest: m, runId: preferredRunId };
+    }
+    for (const rid of listRuns(baseDir)) {
+        const m = loadChangeManifest(getRunDir(rid, baseDir));
+        if (m)
+            return { manifest: m, runId: rid };
+    }
+    return { manifest: null, runId: null };
+}
+/** Used by C5 + C7 to enumerate the entries an agent must exercise. */
+export function manifestEntryDisplayName(e) {
+    switch (e.kind) {
+        case "ui_element_added":
+            return `${e.element}: "${e.name}"`;
+        case "property_added":
+            return `${e.class}.${e.name}`;
+        case "method_added":
+            return `${e.class}.${e.name}()`;
+        case "migration_column_added":
+            return `${e.table}.${e.column}`;
+        case "migration_table_added":
+            return `table ${e.table}`;
+        case "layout_restructure":
+            return `layout ${e.from} → ${e.to} in ${e.file}`;
+    }
+}
+//# sourceMappingURL=change_manifest.js.map