comprehende 0.2.0 → 0.4.0

package/dist/git/diff.js

@@ -1,5 +1,8 @@
+import { isImagePath, isLfsPointerText } from "../schema/image.js";
+import { isLockfilePath } from "../schema/lockfile.js";
 import { git } from "./exec.js";
-import { rangeLabel, resolveCommit } from "./repo.js";
+import { parseNameStatus, parseNumstat } from "./name-status.js";
+import { assertSafePath, rangeLabel, resolveCommit } from "./repo.js";
 const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
 export async function resolveSource(cwd, baseRef, headRef) {
     const baseSha = await resolveCommit(cwd, baseRef);
@@ -11,6 +14,53 @@ export async function resolveSource(cwd, baseRef, headRef) {
     };
 }
 export async function readDiff(cwd, baseRef, headRef) {
+    await resolveCommit(cwd, baseRef);
+    await resolveCommit(cwd, headRef);
+    const range = `${baseRef}...${headRef}`;
+    const entries = parseNameStatus(await git(cwd, ["diff", "--find-renames", "--find-copies", "--name-status", "-z", "--end-of-options", range]));
+    const lockEntries = entries.filter((entry) => isLockfilePath(entry.path));
+    const diffArgs = [
+        "diff",
+        "--find-renames",
+        "--find-copies",
+        "-U3",
+        "--no-color",
+        "--no-ext-diff",
+        "--end-of-options",
+        range,
+    ];
+    if (lockEntries.length > 0) {
+        const excludes = [
+            ...new Set(lockEntries.flatMap((entry) => {
+                const paths = [`:(exclude)${entry.path}`];
+                if (entry.oldPath !== undefined) {
+                    paths.push(`:(exclude)${entry.oldPath}`);
+                }
+                return paths;
+            })),
+        ];
+        diffArgs.push("--", ".", ...excludes);
+    }
+    const files = classifyDiffFiles(parseUnifiedDiff(await git(cwd, diffArgs))).filter((file) => !isLockfilePath(file.path));
+    if (lockEntries.length === 0) {
+        return files;
+    }
+    const stats = parseNumstat(await git(cwd, [
+        "diff",
+        "--find-renames",
+        "--find-copies",
+        "--numstat",
+        "-z",
+        "--end-of-options",
+        range,
+        "--",
+        ...lockEntries.map((entry) => entry.path),
+    ]));
+    const stubs = lockEntries.map((entry) => lockfileDiffFile(entry, stats.get(entry.path)));
+    return mergeDiffFiles(entries, files, stubs);
+}
+export async function readPathDiff(cwd, baseRef, headRef, path) {
+    assertSafePath(path);
     await resolveCommit(cwd, baseRef);
     await resolveCommit(cwd, headRef);
     const stdout = await git(cwd, [
@@ -22,8 +72,11 @@ export async function readDiff(cwd, baseRef, headRef) {
         "--no-ext-diff",
         "--end-of-options",
         `${baseRef}...${headRef}`,
+        "--",
+        path,
     ]);
-    return parseUnifiedDiff(stdout);
+    const files = classifyDiffFiles(parseUnifiedDiff(stdout));
+    return files.find((file) => file.path === path || file.oldPath === path);
 }
 export async function readHunkIndex(cwd, baseRef, headRef) {
     const { source } = await resolveSource(cwd, baseRef, headRef);
@@ -31,10 +84,20 @@ export async function readHunkIndex(cwd, baseRef, headRef) {
     const hunks = [];
     const skipped = [];
     for (const file of files) {
+        if (file.image) {
+            for (const hunk of file.hunks) {
+                hunks.push(toHunkRef(hunk));
+            }
+            continue;
+        }
         if (file.binary) {
             skipped.push({ path: file.path, reason: "binary" });
             continue;
         }
+        if (isLockfilePath(file.path)) {
+            skipped.push({ path: file.path, reason: "lockfile" });
+            continue;
+        }
         for (const hunk of file.hunks) {
             hunks.push(toHunkRef(hunk));
         }
@@ -196,6 +259,7 @@ class FileBuilder {
             path,
             status,
             binary: this.binary,
+            image: false,
             headerPatch: this.headerPatch,
             patch: this.patch,
             hunks,
@@ -282,14 +346,91 @@ function stripDiffPath(raw) {
 export function flattenHunks(files) {
     const hunks = [];
     for (const file of files) {
-        if (file.binary) {
+        if (file.binary && !file.image) {
+            continue;
+        }
+        if (isLockfilePath(file.path)) {
             continue;
         }
         hunks.push(...file.hunks);
     }
     return hunks;
 }
+export function classifyDiffFiles(files) {
+    return files.map(classifyDiffFile);
+}
+function classifyDiffFile(file) {
+    if (!isImagePath(file.path) && (file.oldPath === undefined || !isImagePath(file.oldPath))) {
+        return file;
+    }
+    if (file.binary || isLfsPointerText(file.patch)) {
+        return asImageFile(file);
+    }
+    return file;
+}
+function asImageFile(file) {
+    return { ...file, image: true, hunks: [imageLiveHunk(file.path, file.oldPath)] };
+}
+export function imageLiveHunk(path, oldPath) {
+    const hunk = {
+        path,
+        oldStart: 0,
+        oldLines: 0,
+        newStart: 0,
+        newLines: 0,
+        header: "image",
+        lines: [],
+        patch: "",
+    };
+    if (oldPath !== undefined) {
+        hunk.oldPath = oldPath;
+    }
+    return hunk;
+}
+function lockfileDiffFile(entry, stat) {
+    const binary = stat === undefined || stat.added === null || stat.removed === null;
+    const file = {
+        path: entry.path,
+        status: entry.status,
+        binary,
+        image: false,
+        headerPatch: "",
+        patch: "",
+        hunks: [],
+    };
+    if (entry.oldPath !== undefined) {
+        file.oldPath = entry.oldPath;
+    }
+    if (!binary && stat !== undefined && stat.added !== null && stat.removed !== null) {
+        file.added = stat.added;
+        file.removed = stat.removed;
+    }
+    return file;
+}
+function mergeDiffFiles(entries, files, stubs) {
+    const filesByPath = new Map(files.map((file) => [file.path, file]));
+    const stubsByPath = new Map(stubs.map((file) => [file.path, file]));
+    const out = [];
+    const seen = new Set();
+    for (const entry of entries) {
+        const file = stubsByPath.get(entry.path) ?? filesByPath.get(entry.path);
+        if (file === undefined || seen.has(file.path)) {
+            continue;
+        }
+        seen.add(file.path);
+        out.push(file);
+    }
+    for (const file of files) {
+        if (!seen.has(file.path)) {
+            out.push(file);
+        }
+    }
+    return out;
+}
 export function fileLanguage(path) {
+    if (isImagePath(path)) {
+        return "image";
+    }
     const ext = path.split(".").pop()?.toLowerCase();
     switch (ext) {
         case "ts":

package/dist/git/exec.js

@@ -27,7 +27,21 @@ export async function git(cwd, args, opts) {
         if (opts?.allowFail) {
             return failure.stdout;
         }
-        throw new GitError(`git ${args.join(" ")} failed: ${failure.stderr.trim() || failure.message}`, args, failure.stderr, failure.code);
+        throw gitFailure(args, failure);
+    }
+}
+export async function gitBuffer(cwd, args, opts) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-c", "core.quotepath=false", ...args], {
+            cwd,
+            encoding: "buffer",
+            maxBuffer: 64 * 1024 * 1024,
+            ...(opts?.input !== undefined ? { input: Buffer.from(opts.input) } : {}),
+        });
+        return stdout;
+    }
+    catch (error) {
+        throw gitFailure(args, asExecFailure(error));
     }
 }
 export async function gitOk(cwd, args) {
@@ -44,10 +58,22 @@ function asExecFailure(error) {
         const record = error;
         return {
             message: typeof record.message === "string" ? record.message : "git failed",
-            stdout: typeof record.stdout === "string" ? record.stdout : "",
-            stderr: typeof record.stderr === "string" ? record.stderr : "",
+            stdout: bufferText(record.stdout),
+            stderr: bufferText(record.stderr),
             code: typeof record.code === "number" ? record.code : null,
         };
     }
     return { message: "git failed", stdout: "", stderr: "", code: null };
 }
+function bufferText(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value instanceof Buffer) {
+        return value.toString("utf8");
+    }
+    return "";
+}
+function gitFailure(args, failure) {
+    return new GitError(`git ${args.join(" ")} failed: ${failure.stderr.trim() || failure.message}`, args, failure.stderr, failure.code);
+}

package/dist/git/lfs.js

@@ -0,0 +1,39 @@
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { LFS_POINTER_VERSION } from "../schema/image.js";
+import { git } from "./exec.js";
+const POINTER_MAX = 1024;
+export function parseLfsPointer(bytes) {
+    if (bytes.length === 0 || bytes.length > POINTER_MAX) {
+        return undefined;
+    }
+    if (bytes.includes(0)) {
+        return undefined;
+    }
+    const text = new TextDecoder("utf8").decode(bytes);
+    if (!text.startsWith(`${LFS_POINTER_VERSION}\n`)) {
+        return undefined;
+    }
+    const oid = /^oid sha256:([a-f0-9]{64})$/m.exec(text)?.[1];
+    const sizeRaw = /^size (\d+)$/m.exec(text)?.[1];
+    if (oid === undefined || sizeRaw === undefined) {
+        return undefined;
+    }
+    return { oid, size: Number(sizeRaw) };
+}
+export function lfsObjectPath(gitCommonDir, oid) {
+    return join(gitCommonDir, "lfs", "objects", oid.slice(0, 2), oid.slice(2, 4), oid);
+}
+export async function gitCommonDir(cwd) {
+    const raw = (await git(cwd, ["rev-parse", "--git-common-dir"])).trim();
+    return isAbsolute(raw) ? raw : resolve(cwd, raw);
+}
+export async function readLfsObject(cwd, pointer) {
+    const common = await gitCommonDir(cwd);
+    const stored = lfsObjectPath(common, pointer.oid);
+    if (!existsSync(stored)) {
+        return undefined;
+    }
+    return readFile(stored);
+}

package/dist/git/log.js

@@ -1,8 +1,10 @@
 import { git } from "./exec.js";
+const RECORD_SEP = "\x1e";
+const FIELD_SEP = "\0";
 export async function listCommits(cwd, baseRef, headRef) {
     const stdout = await git(cwd, [
         "log",
-        "--format=%H%x00%h%x00%s%x00%an%x00%ad",
+        "--format=%H%x00%h%x00%s%x00%an%x00%ad%x00%b%x1e",
         "--date=short",
         "--end-of-options",
         `${baseRef}...${headRef}`,
@@ -11,16 +13,19 @@ export async function listCommits(cwd, baseRef, headRef) {
         return [];
     }
     return stdout
-        .split("\n")
-        .filter((line) => line.length > 0)
-        .map((line) => {
-        const [sha, shortSha, subject, author, date] = line.split("\0");
-        return {
-            sha: sha ?? "",
-            shortSha: shortSha ?? "",
-            subject: subject ?? "",
-            author: author ?? "",
-            date: date ?? "",
-        };
-    });
+        .split(RECORD_SEP)
+        .map((record) => record.replace(/^\n/, ""))
+        .filter((record) => record.length > 0)
+        .map(parseCommitRecord);
+}
+function parseCommitRecord(record) {
+    const [sha, shortSha, subject, author, date, ...bodyParts] = record.split(FIELD_SEP);
+    return {
+        sha: sha ?? "",
+        shortSha: shortSha ?? "",
+        subject: subject ?? "",
+        author: author ?? "",
+        date: date ?? "",
+        body: (bodyParts.join(FIELD_SEP) ?? "").replace(/\n+$/u, ""),
+    };
 }

package/dist/git/name-status.js

@@ -0,0 +1,73 @@
+export function parseNameStatus(stdout) {
+    const parts = stdout.split("\0").filter((part) => part !== "");
+    const entries = [];
+    let index = 0;
+    while (index < parts.length) {
+        const code = parts[index];
+        index += 1;
+        if (code === undefined) {
+            break;
+        }
+        if (code.startsWith("R") || code.startsWith("C")) {
+            const oldPath = parts[index];
+            const path = parts[index + 1];
+            index += 2;
+            if (oldPath === undefined || path === undefined) {
+                break;
+            }
+            entries.push({ status: "renamed", path, oldPath });
+            continue;
+        }
+        const path = parts[index];
+        index += 1;
+        if (path === undefined) {
+            break;
+        }
+        entries.push({ status: statusFrom(code), path });
+    }
+    return entries;
+}
+/** Git `--numstat -z`: `added\\tdeleted\\tpath\\0`, or `added\\tdeleted\\t\\0old\\0new\\0` for a rename. */
+export function parseNumstat(stdout) {
+    const parts = stdout.split("\0");
+    const out = new Map();
+    let index = 0;
+    while (index < parts.length) {
+        const field = parts[index];
+        if (field === undefined || field === "") {
+            index += 1;
+            continue;
+        }
+        const match = /^(-|\d+)\t(-|\d+)\t(.*)$/.exec(field);
+        if (match === null || match[1] === undefined || match[2] === undefined || match[3] === undefined) {
+            break;
+        }
+        index += 1;
+        const added = parseCount(match[1]);
+        const removed = parseCount(match[2]);
+        if (match[3] !== "") {
+            out.set(match[3], { path: match[3], added, removed });
+            continue;
+        }
+        const oldPath = parts[index];
+        const path = parts[index + 1];
+        index += 2;
+        if (oldPath === undefined || path === undefined || oldPath === "" || path === "") {
+            break;
+        }
+        out.set(path, { path, oldPath, added, removed });
+    }
+    return out;
+}
+function parseCount(value) {
+    return value === "-" ? null : Number(value);
+}
+function statusFrom(code) {
+    if (code.startsWith("A")) {
+        return "added";
+    }
+    if (code.startsWith("D")) {
+        return "deleted";
+    }
+    return "modified";
+}

package/dist/review/coverage.js

@@ -1,5 +1,6 @@
 import { flattenHunks, readDiff, toHunkRef } from "../git/diff.js";
 import { hunkKey } from "../schema/identity.js";
+import { isLockfilePath } from "../schema/lockfile.js";
 export async function coverReview(cwd, document) {
     const files = await readDiff(cwd, document.source.baseRef, document.source.headRef);
     const live = flattenHunks(files);
@@ -16,6 +17,9 @@ export function joinCoverage(document, live) {
         const hunks = [];
         const stale = [];
         for (const ref of group.hunkRefs) {
+            if (isLockfilePath(ref.path)) {
+                continue;
+            }
             const match = liveByKey.get(hunkKey(ref));
             if (match === undefined) {
                 stale.push(ref);
@@ -23,7 +27,7 @@ export function joinCoverage(document, live) {
                 continue;
             }
             hunks.push(match);
-            assignedKeys.add(hunkKey(ref));
+            assignedKeys.add(hunkKey(match));
         }
         return { group, hunks, stale };
     });

package/dist/schema/image-diff.js

@@ -0,0 +1,51 @@
+const UNCHANGED_KEEP = 0.35;
+const THRESHOLD = 8;
+/** Paint a same-size RGBA pair. Unchanged pixels go gray; changed pixels go magenta. */
+export function diffRgba(oldPixels, newPixels, width, height, threshold = THRESHOLD) {
+    const total = width * height;
+    const pixels = new Uint8ClampedArray(total * 4);
+    let changed = 0;
+    for (let i = 0; i < total; i += 1) {
+        const o = i * 4;
+        const oldA = oldPixels[o + 3] ?? 0;
+        const newA = newPixels[o + 3] ?? 0;
+        const empty = oldA === 0 && newA === 0;
+        const dr = Math.abs((oldPixels[o] ?? 0) - (newPixels[o] ?? 0));
+        const dg = Math.abs((oldPixels[o + 1] ?? 0) - (newPixels[o + 1] ?? 0));
+        const db = Math.abs((oldPixels[o + 2] ?? 0) - (newPixels[o + 2] ?? 0));
+        const da = Math.abs(oldA - newA);
+        const delta = Math.max(dr, dg, db, da);
+        if (empty || delta <= threshold) {
+            const gray = grayOf(newPixels[o] ?? 0, newPixels[o + 1] ?? 0, newPixels[o + 2] ?? 0);
+            const faded = Math.round(gray * UNCHANGED_KEEP);
+            pixels[o] = faded;
+            pixels[o + 1] = faded;
+            pixels[o + 2] = faded;
+            pixels[o + 3] = 255;
+            continue;
+        }
+        changed += 1;
+        if (oldA === 0 && newA > 0) {
+            pixels[o] = 26;
+            pixels[o + 1] = 127;
+            pixels[o + 2] = 55;
+            pixels[o + 3] = 255;
+            continue;
+        }
+        if (newA === 0 && oldA > 0) {
+            pixels[o] = 207;
+            pixels[o + 1] = 34;
+            pixels[o + 2] = 46;
+            pixels[o + 3] = 255;
+            continue;
+        }
+        pixels[o] = 200;
+        pixels[o + 1] = 40;
+        pixels[o + 2] = 160;
+        pixels[o + 3] = 255;
+    }
+    return { pixels, changed, total };
+}
+function grayOf(r, g, b) {
+    return Math.round(0.2126 * r + 0.7152 * g + 0.0722 * b);
+}

package/dist/schema/image.js

@@ -0,0 +1,35 @@
+export const IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "avif", "ico"];
+const IMAGE_EXT = new Set(IMAGE_EXTENSIONS);
+export const LFS_POINTER_VERSION = "version https://git-lfs.github.com/spec/v1";
+const MEDIA = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    bmp: "image/bmp",
+    avif: "image/avif",
+    ico: "image/x-icon",
+};
+export function imageExtension(path) {
+    const base = path.split("/").pop() ?? path;
+    const dot = base.lastIndexOf(".");
+    if (dot <= 0) {
+        return undefined;
+    }
+    const ext = base.slice(dot + 1).toLowerCase();
+    return IMAGE_EXT.has(ext) ? ext : undefined;
+}
+export function isImagePath(path) {
+    return imageExtension(path) !== undefined;
+}
+export function imageMediaType(path) {
+    const ext = imageExtension(path);
+    return ext === undefined ? "application/octet-stream" : MEDIA[ext];
+}
+export function isLfsPointerText(text) {
+    return text.includes(LFS_POINTER_VERSION) && /oid sha256:[a-f0-9]{64}/.test(text);
+}
+export function isImageHunkRef(ref) {
+    return ref.oldStart === 0 && ref.oldLines === 0 && ref.newStart === 0 && ref.newLines === 0;
+}

package/dist/schema/lockfile.js

@@ -0,0 +1,38 @@
+const LOCKFILE_NAMES = new Set([
+    ".terraform.lock.hcl",
+    "bun.lock",
+    "bun.lockb",
+    "cabal.project.freeze",
+    "Cargo.lock",
+    "Cartfile.resolved",
+    "composer.lock",
+    "conda-lock.yml",
+    "deno.lock",
+    "flake.lock",
+    "Gemfile.lock",
+    "go.sum",
+    "go.work.sum",
+    "Gopkg.lock",
+    "gradle.lockfile",
+    "lazy-lock.json",
+    "mix.lock",
+    "npm-shrinkwrap.json",
+    "package-lock.json",
+    "Package.resolved",
+    "pdm.lock",
+    "Pipfile.lock",
+    "pixi.lock",
+    "pnpm-lock.yaml",
+    "Podfile.lock",
+    "poetry.lock",
+    "pubspec.lock",
+    "renv.lock",
+    "shrinkwrap.yaml",
+    "stack.yaml.lock",
+    "uv.lock",
+    "yarn.lock",
+]);
+export function isLockfilePath(path) {
+    const base = path.split("/").pop() ?? path;
+    return LOCKFILE_NAMES.has(base) || base.endsWith(".gradle.lockfile");
+}

package/dist/schema/parse.js

@@ -1,8 +1,8 @@
 import { isReviewSize, REVIEW_SIZES } from "./types.js";
-const DOCUMENT_KEYS = new Set(["version", "source", "size", "walkthrough", "tickets", "groups"]);
+const DOCUMENT_KEYS = new Set(["version", "source", "size", "summary", "why", "tickets", "groups"]);
 const SOURCE_KEYS = new Set(["baseRef", "headRef", "range"]);
-const TICKET_KEYS = new Set(["id", "url", "title"]);
-const GROUP_KEYS = new Set(["id", "title", "summary", "lookFor", "dependsOn", "part", "suggestedOrder", "hunkRefs"]);
+const TICKET_KEYS = new Set(["id", "url", "title", "part"]);
+const GROUP_KEYS = new Set(["id", "title", "why", "summary", "lookFor", "dependsOn", "part", "suggestedOrder", "hunkRefs"]);
 const HUNK_KEYS = new Set(["path", "oldPath", "oldStart", "oldLines", "newStart", "newLines"]);
 export function parseReviewDocument(input) {
     const errors = [];
@@ -15,20 +15,22 @@ export function parseReviewDocument(input) {
     }
     const source = parseSource(input.source, errors);
     const size = parseSize(input.size, errors);
+    const summary = requiredString(input.summary, "summary", errors);
     const tickets = parseTickets(input.tickets, errors);
     const groups = parseGroups(input.groups, errors);
-    const walkthrough = input.walkthrough === undefined ? undefined : requiredString(input.walkthrough, "walkthrough", errors);
-    if (errors.length > 0 || source === undefined || size === undefined) {
+    const why = input.why === undefined ? undefined : requiredString(input.why, "why", errors);
+    if (errors.length > 0 || source === undefined || size === undefined || summary === undefined) {
         return { ok: false, errors };
     }
     const document = {
         version: 1,
         source,
         size,
+        summary,
         groups,
     };
-    if (walkthrough !== undefined) {
-        document.walkthrough = walkthrough;
+    if (why !== undefined) {
+        document.why = why;
     }
     if (tickets !== undefined) {
         document.tickets = tickets;
@@ -105,6 +107,12 @@ function parseTickets(value, errors) {
                 ticket.title = title;
             }
         }
+        if (item.part !== undefined) {
+            const part = requiredString(item.part, `tickets[${i}].part`, errors);
+            if (part !== undefined) {
+                ticket.part = part;
+            }
+        }
         tickets.push(ticket);
     });
     return tickets;
@@ -124,20 +132,21 @@ function parseGroups(value, errors) {
         extraKeys(item, GROUP_KEYS, `groups[${i}]`, errors);
         const id = requiredString(item.id, `groups[${i}].id`, errors);
         const title = requiredString(item.title, `groups[${i}].title`, errors);
+        const why = requiredString(item.why, `groups[${i}].why`, errors);
         const summary = requiredString(item.summary, `groups[${i}].summary`, errors, { allowEmpty: true });
         const suggestedOrder = requiredNumber(item.suggestedOrder, `groups[${i}].suggestedOrder`, errors);
         const hunkRefs = parseHunkRefs(item.hunkRefs, `groups[${i}].hunkRefs`, errors);
         const lookFor = parseStringList(item.lookFor, `groups[${i}].lookFor`, errors);
         const dependsOn = parseStringList(item.dependsOn, `groups[${i}].dependsOn`, errors);
         const part = item.part === undefined ? undefined : requiredString(item.part, `groups[${i}].part`, errors);
-        if (id === undefined || title === undefined || summary === undefined || suggestedOrder === undefined) {
+        if (id === undefined || title === undefined || why === undefined || summary === undefined || suggestedOrder === undefined) {
             return;
         }
         if (ids.has(id)) {
             errors.push(`duplicate group id "${id}"`);
         }
         ids.add(id);
-        const group = { id, title, summary, suggestedOrder, hunkRefs };
+        const group = { id, title, why, summary, suggestedOrder, hunkRefs };
         if (lookFor !== undefined) {
             group.lookFor = lookFor;
         }

package/dist/schema/skill-paths.js

@@ -3,9 +3,9 @@ import { findPackageRoot } from "../package-root.js";
 export function skillPaths(root = findPackageRoot()) {
     return {
         canonicalSchema: join(root, "src/schema/review.schema.json"),
+        nextSkill: join(root, "skills-next/comprehende"),
         publishedSkill: join(root, "skills/comprehende"),
         installedSkill: join(root, ".agents/skills/comprehende"),
-        publishedSchema: join(root, "skills/comprehende/references/review.schema.json"),
-        installedSchema: join(root, ".agents/skills/comprehende/references/review.schema.json"),
+        nextSchema: join(root, "skills-next/comprehende/references/review.schema.json"),
     };
 }