@deeeed/metamask-harness 0.51.5 → 0.51.6

package/dist/mm-harness-cli.js

@@ -35,9 +35,77 @@ const REAL = [
   --target <path>                    Checkout path (default: cwd)
   --json                             Load the same guide as structured agent context
 
+  help review [--domain <name>] prints the review guide: the base review every PR
+  gets, plus the team library's anti-pattern families, parity rule, and shared
+  package notes when --domain names a library (see mm-harness review --help).
+
 Example:
   mm-harness help
-  mm-harness help --json`
+  mm-harness help --json
+  mm-harness help review --domain perps`
+  },
+  {
+    name: "review",
+    summary: "Materialize a review checklist: base review + team library patterns + parity + verdict.",
+    example: "mm-harness review checklist --domain perps",
+    helpText: `mm-harness review checklist [flags]
+
+  Writes a phase-structured checklist (Setup, Base review, Domain patterns,
+  Parity, Verdict) that mm-harness checklist mark can track. Domain patterns are
+  one line per "##" section of the library's review/antipatterns.md; Parity names
+  the other platform's checkout when one resolves and says "not checked" otherwise.
+
+  Library resolution for --domain <name>: RECIPE_LIBRARY_PATH entry \u2192 engineer
+  config (mm-harness config) \u2192 sibling directory beside the checkout \u2192 shallow
+  fetch into <checkout>/.skills-cache/<name> (known libraries only). Reference
+  checkout resolution: MM_HARNESS_REF_<ADAPTER> \u2192 engineer config \u2192 sibling
+  checkout of that adapter.
+
+  --domain <name>   Team library to compose (default: MM_HARNESS_DOMAIN; none = base review only)
+  --since <sha>     Incremental re-review: scope the checklist to <sha>..HEAD
+  --base <ref>      Base ref for the diff range (default: origin/main when present)
+  --out <file>      Also write the checklist to <file>
+  --adapter, --target, --json
+
+Example:
+  mm-harness review checklist --domain perps
+  mm-harness review checklist --domain perps --since 4dd9be9 --out temp/tasks/review/CHECKLIST.md
+  mm-harness review checklist --json`
+  },
+  {
+    name: "domain",
+    summary: "Which team library owns the change: declared value first, else owned-paths.json against the changed files.",
+    example: "mm-harness domain",
+    helpText: `mm-harness domain [flags]
+
+  Prints the domain name (or "none"). A declared --domain / MM_HARNESS_DOMAIN wins;
+  otherwise the changed files (base...HEAD, working tree, untracked) are matched
+  against owned-paths.json in every reachable library (RECIPE_LIBRARY_PATH,
+  mm-harness config, sibling directories, .skills-cache).
+
+  --domain <name>   Declared domain (skips classification)
+  --base <ref>      Base ref for the changed-file range (default: origin/main when present)
+  --adapter, --target, --json
+
+Example:
+  mm-harness domain
+  mm-harness domain --json`
+  },
+  {
+    name: "config",
+    summary: "Per-engineer machine locations for team libraries and reference checkouts.",
+    example: "mm-harness config set references.extension ~/dev/metamask-extension",
+    helpText: `mm-harness config <list|path|get <key>|set <key> <path>|unset <key>> [--json]
+
+  Stored outside every repo in ~/.mm-harness/config.json (override: MM_HARNESS_CONFIG).
+  Keys: libraries.<name> (team library checkout), references.<mobile|extension|core>
+  (the checkout used as the parity reference). Env always wins over config:
+  RECIPE_LIBRARY_PATH for libraries, MM_HARNESS_REF_<ADAPTER> for references.
+
+Example:
+  mm-harness config set libraries.perps ~/dev/experimental-metamask-recipe-perps
+  mm-harness config set references.extension ~/dev/metamask-extension
+  mm-harness config list`
   },
   {
     name: "tutorial",
@@ -783,12 +851,12 @@ const HELP_GROUPS = [
   {
     title: "DISCOVER",
     blurb: "discover atomic actions and reusable recipes (--json is the agent-primary form)",
-    commands: ["help", "tutorial", "actions", "call", "execution-template"]
+    commands: ["help", "tutorial", "actions", "call", "execution-template", "domain", "config"]
   },
   {
     title: "PROVE",
     blurb: "run recipes and inspect readiness",
-    commands: ["run", "last", "doctor", "check", "checklist", "recipe-quality"]
+    commands: ["run", "last", "doctor", "check", "checklist", "review", "recipe-quality"]
   },
   {
     title: "RUNTIME OVERLAY",

package/dist/review/knowledge.js

@@ -0,0 +1,513 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { detectAdapter } from "../harness.js";
+import { usageError } from "../commands/parse-args.js";
+const REVIEW_ADAPTERS = ["mobile", "extension", "core"];
+const KNOWN_LIBRARIES = {
+  perps: { url: "https://github.com/MetaMask/experimental-metamask-recipe-perps.git" },
+  "money-movement": { url: "https://github.com/Consensys/money-movement-recipe-library.git" }
+};
+const SKILLS_CACHE_DIR = ".skills-cache";
+const REFERENCE_ENV_PREFIX = "MM_HARNESS_REF_";
+function referenceEnvName(adapter) {
+  return `${REFERENCE_ENV_PREFIX}${adapter.toUpperCase()}`;
+}
+function configPath(env = process.env, homeDir = os.homedir()) {
+  return env.MM_HARNESS_CONFIG ? path.resolve(env.MM_HARNESS_CONFIG) : path.join(homeDir, ".mm-harness", "config.json");
+}
+function readConfig(file) {
+  if (!fs.existsSync(file)) return {};
+  const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`mm-harness config must be a JSON object: ${file}`);
+  }
+  const record = parsed;
+  const config = {};
+  if (record.libraries !== void 0) config.libraries = stringMap(record.libraries, `${file}: libraries`);
+  if (record.references !== void 0) {
+    const references = stringMap(record.references, `${file}: references`);
+    for (const key of Object.keys(references)) {
+      if (!REVIEW_ADAPTERS.includes(key)) {
+        throw new Error(`${file}: references.${key} is not one of ${REVIEW_ADAPTERS.join(", ")}`);
+      }
+    }
+    config.references = references;
+  }
+  return config;
+}
+function stringMap(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry !== "string" || entry.trim() === "") throw new Error(`${label}.${key} must be a non-empty string`);
+    out[key] = entry;
+  }
+  return out;
+}
+function writeConfig(file, config) {
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 448 });
+  fs.writeFileSync(file, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+}
+function parseLibraryPathEnv(value) {
+  if (!value) return [];
+  return value.split(":").map((entry) => entry.trim()).filter(Boolean).map((entry) => {
+    const equals = entry.indexOf("=");
+    if (equals === -1) return { root: path.resolve(entry) };
+    return { name: entry.slice(0, equals).trim(), root: path.resolve(entry.slice(equals + 1).trim()) };
+  });
+}
+function isDir(candidate) {
+  try {
+    return fs.statSync(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function looksLikeLibrary(root) {
+  return isDir(root) && (fs.existsSync(path.join(root, "owned-paths.json")) || isDir(path.join(root, "review")));
+}
+function gitRevision(root) {
+  try {
+    return execFileSync("git", ["-C", root, "rev-parse", "--short", "HEAD"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function withRevision(location) {
+  const revision = gitRevision(location.root);
+  return revision ? { ...location, revision } : location;
+}
+function siblingRoots(context) {
+  const home = context.homeDir ?? os.homedir();
+  const parents = [path.dirname(path.resolve(context.target)), path.join(home, "shared-library")];
+  const roots = [];
+  for (const parent of parents) {
+    if (!isDir(parent)) continue;
+    for (const entry of fs.readdirSync(parent, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      roots.push(path.join(parent, entry.name));
+    }
+  }
+  return roots;
+}
+function siblingLibrary(name, context) {
+  const candidates = siblingRoots(context).filter((root) => {
+    const base = path.basename(root);
+    return base === name || base.endsWith(`recipe-${name}`) || base === `${name}-recipe-library`;
+  }).filter(looksLikeLibrary).sort((a, b) => path.basename(a).length - path.basename(b).length);
+  return candidates[0];
+}
+function libraryCachePath(target, name) {
+  return path.join(path.resolve(target), SKILLS_CACHE_DIR, name);
+}
+function gitExcludeFile(target) {
+  try {
+    const gitPath = execFileSync("git", ["-C", target, "rev-parse", "--git-path", "info/exclude"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return path.resolve(target, gitPath);
+  } catch {
+    return void 0;
+  }
+}
+function excludeCacheDir(target) {
+  const excludeFile = gitExcludeFile(target);
+  if (!excludeFile) return;
+  fs.mkdirSync(path.dirname(excludeFile), { recursive: true });
+  const line = `${SKILLS_CACHE_DIR}/`;
+  const current = fs.existsSync(excludeFile) ? fs.readFileSync(excludeFile, "utf8") : "";
+  if (current.split("\n").some((entry) => entry.trim() === line)) return;
+  fs.appendFileSync(excludeFile, `${current.endsWith("\n") || current === "" ? "" : "\n"}${line}
+`);
+}
+function fetchLibrary(name, target) {
+  const known = KNOWN_LIBRARIES[name];
+  if (!known) {
+    throw usageError(
+      `No location for library "${name}" and it is not a known library (${Object.keys(KNOWN_LIBRARIES).join(", ")}). Set RECIPE_LIBRARY_PATH="${name}=<path>" or run: mm-harness config set libraries.${name} <path>`
+    );
+  }
+  const root = libraryCachePath(target, name);
+  fs.mkdirSync(path.dirname(root), { recursive: true });
+  execFileSync("git", ["clone", "--quiet", "--depth", "1", known.url, root], { stdio: ["ignore", "pipe", "inherit"] });
+  excludeCacheDir(path.resolve(target));
+  return withRevision({ name, root, source: "cache" });
+}
+function resolveLibrary(name, options) {
+  const env = options.env ?? process.env;
+  const fromEnv = parseLibraryPathEnv(env.RECIPE_LIBRARY_PATH).find(
+    (entry) => isDir(entry.root) && (entry.name === name || entry.name === void 0 && loadOwnedPaths(entry.root)?.domain === name)
+  );
+  if (fromEnv) return withRevision({ name, root: fromEnv.root, source: "env" });
+  const fromConfig = options.config?.libraries?.[name];
+  if (fromConfig && isDir(path.resolve(fromConfig))) {
+    return withRevision({ name, root: path.resolve(fromConfig), source: "config" });
+  }
+  const sibling = siblingLibrary(name, options);
+  if (sibling) return withRevision({ name, root: sibling, source: "sibling" });
+  const cached = libraryCachePath(options.target, name);
+  if (isDir(cached)) return withRevision({ name, root: cached, source: "cache" });
+  if (options.fetch) return fetchLibrary(name, options.target);
+  return void 0;
+}
+function discoverLibraries(context) {
+  const env = context.env ?? process.env;
+  const seenRoots = /* @__PURE__ */ new Set();
+  const seenNames = /* @__PURE__ */ new Set();
+  const found = [];
+  const add = (name, root, source) => {
+    const resolved = path.resolve(root);
+    if (seenRoots.has(resolved) || !looksLikeLibrary(resolved)) return;
+    const libraryName = name ?? loadOwnedPaths(resolved)?.domain ?? path.basename(resolved);
+    if (seenNames.has(libraryName)) return;
+    seenRoots.add(resolved);
+    seenNames.add(libraryName);
+    found.push(withRevision({ name: libraryName, root: resolved, source }));
+  };
+  for (const entry of parseLibraryPathEnv(env.RECIPE_LIBRARY_PATH)) add(entry.name, entry.root, "env");
+  for (const [name, root] of Object.entries(context.config?.libraries ?? {})) add(name, root, "config");
+  const siblingNames = /* @__PURE__ */ new Set();
+  for (const root of siblingRoots(context)) {
+    if (!looksLikeLibrary(root)) continue;
+    siblingNames.add(loadOwnedPaths(root)?.domain ?? path.basename(root));
+  }
+  for (const name of siblingNames) {
+    const chosen = siblingLibrary(name, context);
+    if (chosen) add(name, chosen, "sibling");
+  }
+  const cacheRoot = path.join(path.resolve(context.target), SKILLS_CACHE_DIR);
+  if (isDir(cacheRoot)) {
+    for (const entry of fs.readdirSync(cacheRoot)) add(entry, path.join(cacheRoot, entry), "cache");
+  }
+  return found;
+}
+function resolveReference(adapter, context) {
+  const env = context.env ?? process.env;
+  const fromEnv = env[referenceEnvName(adapter)];
+  if (fromEnv && isDir(path.resolve(fromEnv))) return { adapter, root: path.resolve(fromEnv), source: "env" };
+  const fromConfig = context.config?.references?.[adapter];
+  if (fromConfig && isDir(path.resolve(fromConfig))) return { adapter, root: path.resolve(fromConfig), source: "config" };
+  const target = path.resolve(context.target);
+  const siblings = siblingRoots(context).filter((root) => root !== target && detectAdapter(root) === adapter).sort((a, b) => {
+    const refA = path.basename(a).endsWith("-ref") ? 0 : 1;
+    const refB = path.basename(b).endsWith("-ref") ? 0 : 1;
+    return refA - refB || path.basename(a).length - path.basename(b).length || a.localeCompare(b);
+  });
+  if (siblings[0]) return { adapter, root: siblings[0], source: "sibling" };
+  return void 0;
+}
+function referenceHint(adapter) {
+  return `set ${referenceEnvName(adapter)} or run: mm-harness config set references.${adapter} <path>`;
+}
+function loadOwnedPaths(root) {
+  const file = path.join(root, "owned-paths.json");
+  if (!fs.existsSync(file)) return void 0;
+  const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+  if (!parsed || typeof parsed !== "object") throw new Error(`owned-paths.json must be an object: ${file}`);
+  const record = parsed;
+  if (typeof record.domain !== "string" || !record.domain) throw new Error(`owned-paths.json needs a "domain": ${file}`);
+  if (!record.repos || typeof record.repos !== "object") throw new Error(`owned-paths.json needs "repos": ${file}`);
+  const repos = {};
+  for (const [repo, globs] of Object.entries(record.repos)) {
+    if (!Array.isArray(globs) || globs.some((glob) => typeof glob !== "string")) {
+      throw new Error(`owned-paths.json repos.${repo} must be a string array: ${file}`);
+    }
+    repos[repo] = globs;
+  }
+  return { domain: record.domain, repos };
+}
+function globToRegExp(glob) {
+  let out = "^";
+  for (let i = 0; i < glob.length; i += 1) {
+    const char = glob[i];
+    if (char === "*") {
+      if (glob[i + 1] === "*") {
+        const slashAfter = glob[i + 2] === "/";
+        out += slashAfter ? "(?:.*/)?" : ".*";
+        i += slashAfter ? 2 : 1;
+      } else {
+        out += "[^/]*";
+      }
+    } else if (char === "?") {
+      out += "[^/]";
+    } else if (char === "[") {
+      const negated = glob[i + 1] === "!";
+      const bodyStart = i + 1 + (negated ? 1 : 0);
+      const close = glob.indexOf("]", glob[bodyStart] === "]" ? bodyStart + 1 : bodyStart);
+      if (close === -1) {
+        out += "\\[";
+      } else {
+        out += `[${negated ? "^" : ""}${glob.slice(bodyStart, close).replace(/[\\\]]/g, "\\$&")}]`;
+        i = close;
+      }
+    } else {
+      out += char.replace(/[.+^${}()|\\]/g, "\\$&");
+    }
+  }
+  return new RegExp(`${out}$`);
+}
+function matchOwnedFiles(files, globs) {
+  const patterns = globs.map(globToRegExp);
+  return files.filter((file) => patterns.some((pattern) => pattern.test(file)));
+}
+function classifyDomain(files, adapter, libraries) {
+  const matches = [];
+  for (const library of libraries) {
+    const owned = loadOwnedPaths(library.root);
+    if (!owned) continue;
+    const matched = matchOwnedFiles(files, owned.repos[adapter] ?? []);
+    if (matched.length > 0) matches.push({ domain: owned.domain, library, matched });
+  }
+  return matches.sort((a, b) => b.matched.length - a.matched.length);
+}
+function git(target, args) {
+  return execFileSync("git", ["-C", target, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+}
+function defaultBaseRef(target) {
+  for (const candidate of ["origin/main", "main", "origin/develop", "develop"]) {
+    try {
+      git(target, ["rev-parse", "--verify", "--quiet", `${candidate}^{commit}`]);
+      return candidate;
+    } catch {
+    }
+  }
+  return "HEAD";
+}
+function changedFiles(target, base) {
+  const ref = base ?? defaultBaseRef(target);
+  const lists = [
+    ref === "HEAD" ? "" : git(target, ["diff", "--name-only", `${ref}...HEAD`]),
+    git(target, ["diff", "--name-only", "HEAD"]),
+    git(target, ["ls-files", "--others", "--exclude-standard"])
+  ];
+  const files = /* @__PURE__ */ new Set();
+  for (const list of lists) for (const line of list.split("\n")) if (line.trim()) files.add(line.trim());
+  return { base: ref, files: [...files].sort() };
+}
+function parseSections(markdown) {
+  const lines = markdown.split("\n");
+  const introLines = [];
+  const sections = [];
+  let current;
+  let inFence = false;
+  for (const line of lines) {
+    if (/^```/.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    const heading = /^## +(.+?)\s*$/.exec(line);
+    if (heading) {
+      if (current) sections.push(finishSection(current));
+      current = { title: heading[1].trim(), body: [] };
+      continue;
+    }
+    if (current) current.body.push(line);
+    else if (!/^# /.test(line)) introLines.push(line);
+  }
+  if (current) sections.push(finishSection(current));
+  return { intro: introLines.join("\n").trim(), sections };
+}
+function finishSection(section) {
+  const lines = section.body.map((line) => line.trim());
+  const firstBulletStart = lines.findIndex((line) => line.startsWith("- "));
+  const proseLines = firstBulletStart === -1 ? lines : lines.slice(0, firstBulletStart);
+  const proseStart = proseLines.findIndex((line) => line && !line.startsWith("#"));
+  let firstProse;
+  if (proseStart !== -1) {
+    const paragraph = [];
+    for (const line of proseLines.slice(proseStart)) {
+      if (!line || line.startsWith("#")) break;
+      paragraph.push(line);
+    }
+    firstProse = paragraph.join(" ");
+  }
+  let firstBullet;
+  if (firstBulletStart !== -1) {
+    const bullet = [lines[firstBulletStart].replace(/^- /, "")];
+    for (const line of lines.slice(firstBulletStart + 1)) {
+      if (!line || line.startsWith("- ") || line.startsWith("#")) break;
+      bullet.push(line);
+    }
+    firstBullet = bullet.join(" ");
+  }
+  const raw = firstProse ?? firstBullet ?? "";
+  return { title: section.title, summary: firstSentences(plainText(raw), SUMMARY_LIMIT) };
+}
+const SUMMARY_LIMIT = 220;
+function firstSentences(text, limit) {
+  if (text.length <= limit) return text;
+  const sentences = text.split(/(?<=[.!?])\s+/);
+  let out = "";
+  for (const sentence of sentences) {
+    if (out && `${out} ${sentence}`.length > limit) break;
+    out = out ? `${out} ${sentence}` : sentence;
+  }
+  if (out.length > limit) out = `${out.slice(0, limit).replace(/\s+\S*$/, "")}\u2026`;
+  return out || text.slice(0, limit);
+}
+function plainText(markdown) {
+  return markdown.replace(/\*\*([^*]+)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\s+/g, " ").trim();
+}
+function loadDomainKnowledge(library, adapter) {
+  const knowledge = { library };
+  const antipatternsFile = path.join(library.root, "review", "antipatterns.md");
+  if (fs.existsSync(antipatternsFile)) {
+    const parsed = parseSections(fs.readFileSync(antipatternsFile, "utf8"));
+    knowledge.antipatterns = { ...parsed, file: antipatternsFile };
+  }
+  const platformFile = adapter ? path.join(library.root, "review", `antipatterns.${adapter}.md`) : void 0;
+  if (platformFile && fs.existsSync(platformFile)) {
+    const parsed = parseSections(fs.readFileSync(platformFile, "utf8"));
+    knowledge.antipatterns = knowledge.antipatterns ? { ...knowledge.antipatterns, sections: [...knowledge.antipatterns.sections, ...parsed.sections], platformFile } : { ...parsed, file: platformFile, platformFile };
+  }
+  const parityFile = path.join(library.root, "review", "parity.md");
+  if (fs.existsSync(parityFile)) {
+    knowledge.parity = { intro: parseSections(fs.readFileSync(parityFile, "utf8")).intro, file: parityFile };
+  }
+  const sharedFile = path.join(library.root, "review", "shared-packages.md");
+  if (fs.existsSync(sharedFile)) {
+    knowledge.sharedPackages = { intro: parseSections(fs.readFileSync(sharedFile, "utf8")).intro, file: sharedFile };
+  }
+  const owned = loadOwnedPaths(library.root);
+  if (owned) knowledge.ownedPaths = owned;
+  return knowledge;
+}
+const BASE_REVIEW_STEPS = [
+  "Correctness: trace every changed code path end to end, including error and empty states; confirm the change does what the task or PR says and nothing else.",
+  "Tests: each behavior change has a test at its best-fit layer (view, integration, unit); no mocked-away logic that hides the change under test.",
+  "Safety: no secrets, no widened permissions or network surface, no logging of user data; new dependencies justified.",
+  "Product wiring: i18n keys, telemetry events, feature flags, and error messages follow the repo conventions for the touched area.",
+  "Scope and hygiene: diff is minimal for the ask, no unrelated refactors or reformatting, commit and PR title follow conventional commits."
+];
+const VERDICT_STEP = "Post the verdict: APPROVE or REQUEST CHANGES, findings ordered by severity with file:line, nits listed separately; state what was not checked and why.";
+function parityAdapter(adapter) {
+  if (adapter === "mobile") return "extension";
+  if (adapter === "extension") return "mobile";
+  return void 0;
+}
+function renderReviewChecklist(input) {
+  const diffRange = input.since ? `${input.since}..HEAD` : `${input.base}...HEAD`;
+  const lines = [];
+  const scope = input.domain ? `${input.domain} (${input.adapter})` : input.adapter;
+  lines.push(`# Review checklist \u2014 ${scope}`, "");
+  lines.push(`Materialized by mm-harness ${input.harnessVersion} for ${input.target}.`);
+  if (input.knowledge) {
+    const { library } = input.knowledge;
+    lines.push(`Domain knowledge: ${library.name}${library.revision ? ` @ ${library.revision}` : ""} (${library.root}, via ${library.source}).`);
+  }
+  if (input.reference) {
+    lines.push(`Parity reference: ${input.reference.adapter} checkout at ${input.reference.root} (via ${input.reference.source}).`);
+  } else if (input.referenceMissing) {
+    lines.push(`Parity reference: not checked \u2014 ${input.referenceMissing}.`);
+  }
+  lines.push(`Scope: \`git diff ${diffRange}\`${input.since ? " (incremental re-review since the last verdict)" : ""}.`, "");
+  let step = 0;
+  const item = (text) => {
+    step += 1;
+    lines.push(`- [ ] ${step}. ${text}`);
+  };
+  lines.push("## Setup");
+  if (input.since) {
+    item(`Re-read the previous findings, then list only the files changed in \`git diff --name-only ${diffRange}\`; confirm each earlier finding is addressed or explicitly declined.`);
+  } else {
+    item(`Read the task or PR description and the linked ticket, then list the changed files with \`git diff --name-only ${diffRange}\`.`);
+  }
+  item(
+    input.domain ? `Confirm the domain is ${input.domain} (\`mm-harness domain\`) and open ${input.knowledge?.antipatterns ? "review/antipatterns.md" : "the domain library"} once before reading the diff.` : "Run `mm-harness domain` to check whether a team library owns the changed files; if one does, re-run with --domain."
+  );
+  lines.push("", "## Base review");
+  for (const text of BASE_REVIEW_STEPS) item(text);
+  if (input.knowledge?.antipatterns) {
+    lines.push("", `## Domain patterns (${input.domain})`);
+    for (const section of input.knowledge.antipatterns.sections) {
+      item(`${section.title}: ${section.summary}`);
+    }
+  }
+  lines.push("", "## Parity");
+  const parity = parityAdapter(input.adapter);
+  if (input.reference && parity) {
+    item(
+      `For each touched screen, hook, or formatter, compare it with its ${parity} counterpart at ${input.reference.root}` + (input.knowledge?.parity ? " using review/parity.md" : "") + `; record every divergence, and apply the library's parity rule to decide which platform must change (the reference platform is never changed to match the other).`
+    );
+  } else if (parity) {
+    item(`Parity with ${parity}: not checked \u2014 ${input.referenceMissing ?? "no reference checkout"}. Record this in the verdict.`);
+  } else {
+    item("Parity: core changes are consumed by both mobile and extension; confirm both consumers still compile against the public surface.");
+  }
+  lines.push("", "## Verdict");
+  item(VERDICT_STEP);
+  return `${lines.join("\n")}
+`;
+}
+function renderReviewHelp(input) {
+  const lines = [];
+  lines.push(`mm-harness ${input.harnessVersion} review guide${input.domain ? ` \u2014 ${input.domain}` : ""}`, "");
+  lines.push("Base review (every PR, any domain):");
+  for (const [index, text] of BASE_REVIEW_STEPS.entries()) lines.push(`  ${index + 1}. ${text}`);
+  lines.push(`  ${BASE_REVIEW_STEPS.length + 1}. ${VERDICT_STEP}`, "");
+  if (input.knowledge) {
+    const { library, antipatterns, parity, sharedPackages } = input.knowledge;
+    lines.push(`Domain knowledge: ${library.name}${library.revision ? ` @ ${library.revision}` : ""} at ${library.root} (via ${library.source})`);
+    if (antipatterns) {
+      lines.push("", antipatterns.intro, "", "Anti-pattern families (one checklist line each):");
+      for (const section of antipatterns.sections) lines.push(`  - ${section.title}`);
+      lines.push(`  full text: ${antipatterns.file}${antipatterns.platformFile ? ` + ${antipatterns.platformFile}` : ""}`);
+    }
+    if (parity) lines.push("", "Parity:", `  ${parity.intro.split("\n").join("\n  ")}`, `  map: ${parity.file}`);
+    if (sharedPackages) lines.push("", "Shared packages:", `  ${sharedPackages.intro.split("\n").join("\n  ")}`, `  detail: ${sharedPackages.file}`);
+    lines.push("");
+  } else if (input.domain) {
+    lines.push(
+      `Domain knowledge: no library resolved for ${input.domain} on this machine (help never fetches).`,
+      `  Set RECIPE_LIBRARY_PATH="${input.domain}=<path>", run mm-harness config set libraries.${input.domain} <path>, or run review checklist --domain ${input.domain} to fetch a known library.`,
+      ""
+    );
+  } else {
+    lines.push("Add --domain <name> to compose a team library on top of the base review; `mm-harness domain` infers it from the changed files.", "");
+  }
+  if (input.reference) lines.push(`Parity reference: ${input.reference.adapter} at ${input.reference.root} (via ${input.reference.source})`);
+  else if (input.referenceMissing) lines.push(`Parity reference: not checked \u2014 ${input.referenceMissing}`);
+  lines.push("", `Materialize: mm-harness review checklist${input.domain ? ` --domain ${input.domain}` : ""} [--since <sha>]`);
+  return `${lines.join("\n")}
+`;
+}
+export {
+  BASE_REVIEW_STEPS,
+  KNOWN_LIBRARIES,
+  REFERENCE_ENV_PREFIX,
+  REVIEW_ADAPTERS,
+  SKILLS_CACHE_DIR,
+  VERDICT_STEP,
+  changedFiles,
+  classifyDomain,
+  configPath,
+  defaultBaseRef,
+  discoverLibraries,
+  excludeCacheDir,
+  fetchLibrary,
+  gitExcludeFile,
+  globToRegExp,
+  libraryCachePath,
+  loadDomainKnowledge,
+  loadOwnedPaths,
+  matchOwnedFiles,
+  parityAdapter,
+  parseLibraryPathEnv,
+  parseSections,
+  readConfig,
+  referenceEnvName,
+  referenceHint,
+  renderReviewChecklist,
+  renderReviewHelp,
+  resolveLibrary,
+  resolveReference,
+  writeConfig
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.51.5",
+  "version": "0.51.6",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"