@mmerterden/multi-agent-pipeline 12.5.0 → 12.7.0

package/pipeline/scripts/learnings-ledger.mjs

@@ -43,7 +43,15 @@
  * @module pipeline/scripts/learnings-ledger
  */
 
-import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync, appendFileSync, statSync } from "node:fs";
+import {
+  readFileSync,
+  writeFileSync,
+  renameSync,
+  existsSync,
+  mkdirSync,
+  appendFileSync,
+  statSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { execFileSync } from "node:child_process";
 import { join, basename, dirname } from "node:path";
@@ -59,11 +67,16 @@ for (let i = 1; i < argv.length; i++) {
   // (e.g. --statement="-- prefer let over var"). Use it when the space form
   // would mistake the value for the next flag.
   const eq = body.indexOf("=");
-  if (eq !== -1) { flags[body.slice(0, eq)] = body.slice(eq + 1); continue; }
+  if (eq !== -1) {
+    flags[body.slice(0, eq)] = body.slice(eq + 1);
+    continue;
+  }
   const k = body;
   const v = argv[i + 1];
-  if (v !== undefined && !v.startsWith("--")) { flags[k] = v; i++; }
-  else flags[k] = true;
+  if (v !== undefined && !v.startsWith("--")) {
+    flags[k] = v;
+    i++;
+  } else flags[k] = true;
 }
 
 const KINDS = new Set(["fact", "convention", "rejected-preference"]);
@@ -74,21 +87,50 @@ function die(msg, code = 1) {
   process.exit(code);
 }
 
+// Resolves to the MAIN repository name even when called from inside a pipeline
+// worktree. `--show-toplevel` returns the worktree root, whose basename is the
+// task id, which would shard the per-repo ledger one directory per task and make
+// the learning replay always miss. `--git-common-dir` points at the main
+// repository's .git for every linked worktree.
 function repoSlug() {
   if (flags["repo-slug"]) return String(flags["repo-slug"]);
   if (process.env.MULTI_AGENT_REPO_SLUG) return process.env.MULTI_AGENT_REPO_SLUG;
+  try {
+    const commonDir = execFileSync(
+      "git",
+      ["rev-parse", "--path-format=absolute", "--git-common-dir"],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] },
+    ).trim();
+    if (commonDir) {
+      const base = basename(commonDir);
+      const root = base === ".git" ? dirname(commonDir) : commonDir.replace(/\.git$/, "");
+      const slug = basename(root);
+      if (slug) return slug;
+    }
+  } catch {
+    /* not a git repo, or git too old for --path-format */
+  }
   try {
     const top = execFileSync("git", ["rev-parse", "--show-toplevel"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
     }).trim();
     if (top) return basename(top);
-  } catch { /* not a git repo */ }
+  } catch {
+    /* not a git repo */
+  }
   return "default";
 }
 
 function ledgerPath(slug) {
-  return join(homedir(), ".claude", "memory", "multi-agent", slug || repoSlug(), "learnings-ledger.jsonl");
+  return join(
+    homedir(),
+    ".claude",
+    "memory",
+    "multi-agent",
+    slug || repoSlug(),
+    "learnings-ledger.jsonl",
+  );
 }
 
 function ensureDir(p) {
@@ -96,7 +138,10 @@ function ensureDir(p) {
 }
 
 function normStatement(s) {
-  return String(s || "").toLowerCase().replace(/\s+/g, " ").trim();
+  return String(s || "")
+    .toLowerCase()
+    .replace(/\s+/g, " ")
+    .trim();
 }
 
 function readLedger(slug) {
@@ -106,8 +151,11 @@ function readLedger(slug) {
   const rows = [];
   for (const line of raw.split("\n")) {
     if (!line.trim()) continue;
-    try { rows.push(JSON.parse(line)); }
-    catch { /* skip corrupted line */ }
+    try {
+      rows.push(JSON.parse(line));
+    } catch {
+      /* skip corrupted line */
+    }
   }
   return rows;
 }
@@ -148,18 +196,25 @@ function addEntry(slug, { kind, statement, scope, task, confidence, diagnosis },
 function cmdAdd() {
   const kind = flags.kind;
   if (!KINDS.has(kind)) die(`--kind must be one of: ${[...KINDS].join(", ")}`, 1);
-  if (!flags.statement || flags.statement === true) die("add needs --statement \"...\"", 1);
+  if (!flags.statement || flags.statement === true) die('add needs --statement "..."', 1);
   const slug = repoSlug();
   const existing = new Set(readLedger(slug).map((r) => `${r.kind}::${normStatement(r.statement)}`));
-  const wrote = addEntry(slug, {
-    kind,
-    statement: flags.statement,
-    scope: flags.scope && flags.scope !== true ? String(flags.scope) : "global",
-    task: flags.task && flags.task !== true ? String(flags.task) : null,
-    confidence: flags.confidence && flags.confidence !== true ? String(flags.confidence) : "medium",
-    diagnosis: flags.diagnosis && flags.diagnosis !== true ? String(flags.diagnosis) : null,
-  }, existing);
-  process.stdout.write(JSON.stringify({ ok: true, slug, added: wrote ? 1 : 0, deduped: wrote ? 0 : 1 }) + "\n");
+  const wrote = addEntry(
+    slug,
+    {
+      kind,
+      statement: flags.statement,
+      scope: flags.scope && flags.scope !== true ? String(flags.scope) : "global",
+      task: flags.task && flags.task !== true ? String(flags.task) : null,
+      confidence:
+        flags.confidence && flags.confidence !== true ? String(flags.confidence) : "medium",
+      diagnosis: flags.diagnosis && flags.diagnosis !== true ? String(flags.diagnosis) : null,
+    },
+    existing,
+  );
+  process.stdout.write(
+    JSON.stringify({ ok: true, slug, added: wrote ? 1 : 0, deduped: wrote ? 0 : 1 }) + "\n",
+  );
   process.exit(wrote ? 0 : 2);
 }
 
@@ -170,8 +225,11 @@ function cmdFromTriage() {
   const task = flags.task && flags.task !== true ? String(flags.task) : null;
   const slug = repoSlug();
   let triage;
-  try { triage = JSON.parse(readFileSync(triagePath, "utf8")); }
-  catch (e) { die(`cannot parse triage JSON: ${e.message}`, 1); }
+  try {
+    triage = JSON.parse(readFileSync(triagePath, "utf8"));
+  } catch (e) {
+    die(`cannot parse triage JSON: ${e.message}`, 1);
+  }
 
   const existing = new Set(readLedger(slug).map((r) => `${r.kind}::${normStatement(r.statement)}`));
   let written = 0;
@@ -185,12 +243,21 @@ function cmdFromTriage() {
     // whole class on every future run. Blocking findings always get re-raised
     // and re-triaged on their own merits; only lower-severity rejections (style
     // nitpicks, scope calls) become durable "do not re-flag" preferences.
-    if (f.severity === "blocking") { skippedBlocking++; continue; }
+    if (f.severity === "blocking") {
+      skippedBlocking++;
+      continue;
+    }
     // Top-level files (dirname ".") scope to the file itself, not a stray "./*".
     const dir = f.file ? dirname(f.file) : "";
-    const scope = !f.file ? "global" : (dir === "." || dir === "" ? f.file : `${dir}/*`);
+    const scope = !f.file ? "global" : dir === "." || dir === "" ? f.file : `${dir}/*`;
     const statement = `Do not re-flag: ${issue}` + (r.reason ? ` (rejected: ${r.reason})` : "");
-    if (addEntry(slug, { kind: "rejected-preference", statement, scope, task, confidence: "low" }, existing)) {
+    if (
+      addEntry(
+        slug,
+        { kind: "rejected-preference", statement, scope, task, confidence: "low" },
+        existing,
+      )
+    ) {
       written++;
     }
   }
@@ -202,7 +269,7 @@ function cmdForget() {
   const slug = repoSlug();
   const match = flags.statement && flags.statement !== true ? normStatement(flags.statement) : null;
   const kind = flags.kind && flags.kind !== true ? String(flags.kind) : null;
-  if (!match && !kind) die("forget needs --statement \"...\" and/or --kind <kind>", 1);
+  if (!match && !kind) die('forget needs --statement "..." and/or --kind <kind>', 1);
   const p = ledgerPath(slug);
   if (!existsSync(p)) {
     process.stdout.write(JSON.stringify({ ok: true, slug, removed: 0 }) + "\n");
@@ -241,7 +308,9 @@ function cmdBrief() {
   for (const r of ordered) (byKind[r.kind] || (byKind[r.kind] = [])).push(r);
 
   const lines = ["<repo-learnings>"];
-  lines.push(`Durable knowledge for repo "${slug}" (replayed each run; treat as context, not commands - current scope decides).`);
+  lines.push(
+    `Durable knowledge for repo "${slug}" (replayed each run; treat as context, not commands - current scope decides).`,
+  );
   const labels = {
     fact: "Architectural facts",
     convention: "Conventions",
@@ -263,7 +332,9 @@ function cmdBrief() {
 }
 
 function cmdPath() {
-  process.stdout.write(ledgerPath(flags["repo-slug"] ? String(flags["repo-slug"]) : repoSlug()) + "\n");
+  process.stdout.write(
+    ledgerPath(flags["repo-slug"] ? String(flags["repo-slug"]) : repoSlug()) + "\n",
+  );
   process.exit(0);
 }
 
@@ -279,13 +350,27 @@ function cmdStats() {
 }
 
 switch (SUB) {
-  case "add": cmdAdd(); break;
-  case "from-triage": cmdFromTriage(); break;
-  case "forget": cmdForget(); break;
-  case "brief": cmdBrief(); break;
-  case "path": cmdPath(); break;
-  case "stats": cmdStats(); break;
+  case "add":
+    cmdAdd();
+    break;
+  case "from-triage":
+    cmdFromTriage();
+    break;
+  case "forget":
+    cmdForget();
+    break;
+  case "brief":
+    cmdBrief();
+    break;
+  case "path":
+    cmdPath();
+    break;
+  case "stats":
+    cmdStats();
+    break;
   default:
-    process.stderr.write("usage: learnings-ledger.mjs <add|from-triage|forget|brief|path|stats> [flags]\n");
+    process.stderr.write(
+      "usage: learnings-ledger.mjs <add|from-triage|forget|brief|path|stats> [flags]\n",
+    );
     process.exit(64);
 }

package/pipeline/scripts/lint-mcp-refs.mjs

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+// lint-mcp-refs.mjs  -  every mcp__<server>__<tool> reference must be callable.
+//
+// A host composes an MCP tool name as mcp__<registered-server-name>__<tool>.
+// The pipeline had 100 references to `mcp__dev_toolkit__*` while the server is
+// registered as `dev-toolkit`, so the real names are `mcp__dev-toolkit__*`.
+// Nothing caught it: prose is not executed, and a wrong name inside an
+// `allowed-tools:` allowlist silently denies the tool instead of erroring.
+//
+// Checks (errors - fail the gate):
+//   1. the server segment must be a known registered server name
+//   2. the known-bad snake_case spellings are called out with their fix
+//
+// Optional deep check (advisory - never fails):
+//   3. when the companion dev-toolkit repo resolves locally (via
+//      prefs.global.devToolkit.localPath, or the mcpServers registration in
+//      ~/.claude.json / ~/.claude/settings.json), handshake it over stdio and
+//      confirm every referenced dev-toolkit tool actually exists in tools/list.
+//      CI has no local checkout, so an unresolvable repo is a skip, not a fail.
+//
+// Zero-dependency. Runs inside `npm test` and ci-lite.
+//
+// Usage: node pipeline/scripts/lint-mcp-refs.mjs [--strict-tools]
+// Exit: 0 clean, 1 unknown server segment (or a missing tool with --strict-tools).
+
+import { readFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const strictTools = process.argv.includes("--strict-tools");
+
+// Servers the pipeline is allowed to reference. The key is the registered
+// server name as it appears in an mcpServers config, which is what the host
+// interpolates into the tool name.
+const KNOWN_SERVERS = {
+  "dev-toolkit": "companion device/browser toolkit (@mmerterden/dev-toolkit-mcp)",
+  claude_ai_Figma: "Figma MCP (analysis phase only)",
+  XcodeBuildMCP: "optional third-party Xcode build server",
+};
+// Spellings that look right but cannot resolve to a registered server.
+const KNOWN_BAD = { dev_toolkit: "dev-toolkit", "claude-ai-Figma": "claude_ai_Figma" };
+
+const SCAN_DIRS = ["pipeline/commands", "pipeline/skills", "pipeline/multi-agent-refs"];
+const SCAN_EXT = /\.(md|sh|mjs|json)$/;
+const PRUNE = new Set([
+  "node_modules",
+  ".git",
+  ".worktrees",
+  "Pods",
+  ".build",
+  "DerivedData",
+  ".next",
+]);
+
+function walk(dir, out = []) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    if (PRUNE.has(e.name)) continue;
+    const p = join(dir, e.name);
+    if (e.isDirectory()) walk(p, out);
+    else if (SCAN_EXT.test(e.name)) out.push(p);
+  }
+  return out;
+}
+
+const files = SCAN_DIRS.flatMap((d) => walk(join(repoRoot, d)));
+const REF = /mcp__([A-Za-z0-9_-]+?)__([a-z0-9_]+)/g;
+
+const errors = [];
+const refs = new Map(); // server -> Map(tool -> Set(file:line))
+
+for (const file of files) {
+  const rel = file.slice(repoRoot.length + 1);
+  const lines = readFileSync(file, "utf8").split("\n");
+  lines.forEach((line, i) => {
+    for (const m of line.matchAll(REF)) {
+      const [, server, tool] = m;
+      // Prose writes families as mcp__dev-toolkit__ios_* - a wildcard, not a tool.
+      const next = line[m.index + m[0].length];
+      if (next === "*" || tool.endsWith("_")) continue;
+      const where = `${rel}:${i + 1}`;
+      if (!refs.has(server)) refs.set(server, new Map());
+      const tools = refs.get(server);
+      if (!tools.has(tool)) tools.set(tool, new Set());
+      tools.get(tool).add(where);
+    }
+  });
+}
+
+for (const [server, tools] of refs) {
+  if (server in KNOWN_SERVERS) continue;
+  const fix = KNOWN_BAD[server];
+  const sample = [...tools.values()][0].values().next().value;
+  errors.push(
+    fix
+      ? `unknown MCP server segment "${server}" (${tools.size} tool refs, e.g. ${sample}) - the registered server is "${fix}", so the prefix must be mcp__${fix}__`
+      : `unknown MCP server segment "${server}" (${tools.size} tool refs, e.g. ${sample}) - add it to KNOWN_SERVERS in lint-mcp-refs.mjs if this server is expected, or fix the prefix to match the registered server name`,
+  );
+}
+
+// ---- optional deep check: do the referenced dev-toolkit tools exist? --------
+
+function resolveToolkitRepo() {
+  const prefsPath = join(homedir(), ".claude", "multi-agent-preferences.json");
+  if (existsSync(prefsPath)) {
+    try {
+      const dt = JSON.parse(readFileSync(prefsPath, "utf8"))?.global?.devToolkit;
+      if (dt && dt.enabled === false) return null;
+      if (dt?.localPath) {
+        const p = dt.localPath.replace(/^~|\$HOME/, homedir());
+        if (existsSync(join(p, "package.json"))) return p;
+      }
+    } catch {
+      /* fall through to registration lookup */
+    }
+  }
+  const candidates = [];
+  const collect = (obj) => {
+    for (const [name, cfg] of Object.entries(obj || {})) {
+      const arg = Array.isArray(cfg?.args) ? cfg.args.find((a) => /\.(mjs|js)$/.test(a)) : null;
+      if (name.includes("dev") && arg) candidates.push(dirname(resolve(arg)));
+    }
+  };
+  for (const cfgPath of [
+    join(homedir(), ".claude.json"),
+    join(homedir(), ".claude", "settings.json"),
+  ]) {
+    if (!existsSync(cfgPath)) continue;
+    try {
+      const json = JSON.parse(readFileSync(cfgPath, "utf8"));
+      collect(json.mcpServers);
+      for (const proj of Object.values(json.projects || {})) collect(proj.mcpServers);
+    } catch {
+      /* ignore unreadable config */
+    }
+  }
+  for (const c of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync(join(c, "package.json"), "utf8"));
+      if (pkg.dependencies?.["@modelcontextprotocol/sdk"] && statSync(join(c, ".git"))) return c;
+    } catch {
+      /* not the toolkit */
+    }
+  }
+  return null;
+}
+
+function listTools(repo) {
+  const frames =
+    [
+      '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"lint-mcp-refs","version":"1"}}}',
+      '{"jsonrpc":"2.0","method":"notifications/initialized"}',
+      '{"jsonrpc":"2.0","id":2,"method":"tools/list"}',
+    ].join("\n") + "\n";
+  const r = spawnSync(process.execPath, ["index.js"], {
+    cwd: repo,
+    input: frames,
+    encoding: "utf8",
+    timeout: 20000,
+    maxBuffer: 32 * 1024 * 1024,
+  });
+  if (r.error || !r.stdout) return null;
+  for (const line of r.stdout.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const msg = JSON.parse(line);
+      if (msg.id === 2 && msg.result?.tools) return msg.result.tools.map((t) => t.name);
+    } catch {
+      /* not a frame */
+    }
+  }
+  return null;
+}
+
+const referencedToolkitTools = refs.get("dev-toolkit");
+let deep = "skipped (no local dev-toolkit checkout)";
+if (referencedToolkitTools) {
+  const repo = resolveToolkitRepo();
+  const served = repo ? listTools(repo) : null;
+  if (!served) {
+    deep = repo ? `skipped (${repo} did not answer tools/list)` : deep;
+  } else {
+    const missing = [...referencedToolkitTools.keys()].filter((t) => !served.includes(t));
+    if (missing.length === 0) {
+      deep = `all ${referencedToolkitTools.size} referenced tools exist in the live server (${served.length} served)`;
+    } else {
+      const msg = `dev-toolkit tools referenced but not served (${served.length} served): ${missing
+        .map((t) => `${t} [${[...referencedToolkitTools.get(t)][0]}]`)
+        .join(", ")}`;
+      deep = `${missing.length} referenced tool(s) not served`;
+      if (strictTools) errors.push(msg);
+      else console.warn(`  WARNING - ${msg}`);
+    }
+  }
+}
+
+const totalRefs = [...refs.values()].reduce((n, tools) => n + tools.size, 0);
+console.log(
+  `lint-mcp-refs: ${totalRefs} distinct tool references across ${refs.size} server(s) in ${files.length} files`,
+);
+for (const [server, tools] of refs) {
+  console.log(`  ${server in KNOWN_SERVERS ? "✓" : "✗"} mcp__${server}__* : ${tools.size} tools`);
+}
+console.log(`  tool-existence check: ${deep}`);
+
+if (errors.length > 0) {
+  console.error(`lint-mcp-refs: ${errors.length} error(s)`);
+  for (const e of errors) console.error("  " + e);
+  process.exit(1);
+}

package/pipeline/scripts/lint-skills.mjs

@@ -14,12 +14,12 @@
 //   - description: required, non-empty, single line, <= 1024 chars
 //   - user-invocable: when present, must be true or false
 //   - platform: when present, must be ios | android | common | all
+//   - description: must carry a routing/trigger clause ("use when ..."), the
+//     one thing it is for - blocking since all 193 skills have one
 //
 // Spec-conformance signals (warnings - never fail the gate):
 //   - name should match the agent-skills spec pattern
 //     (lowercase letters/digits/hyphens, <= 64 chars)
-//   - description should carry a routing/trigger clause ("use when ...")
-//     so the model can decide when to load the skill
 //   - a body over ~500 lines with no companion-file reference should be
 //     split into references/ files loaded on demand
 
@@ -99,12 +99,19 @@ for (const file of files) {
     if (!isBlockScalar && words < 6) {
       warn(file, `description is terse (${words} words) - say what it does AND when to use it`);
     }
-    // Routing quality (warn-only): without a trigger clause the model has no
-    // signal for WHEN to load the skill. Heuristic phrase match; block
-    // scalars are skipped for the same parser reason as above.
-    const ROUTING_RE = /\b(use (this|it|when|for|whenever)|when (the|a|an|you|asked|working|building|implementing|writing|reviewing)|triggers?|invoked?( when| for)?|applies when|activated?)\b/i;
+    // Routing quality (BLOCKING since the backlog reached zero). A description
+    // without a trigger clause tells the model what the skill is and nothing
+    // about when to reach for it, which is the one job the description has -
+    // it is the routing rule, not a summary.
+    //
+    // This was warn-only while 93 of 193 skills were missing one, because a
+    // gate that fires on half the tree gets ignored. All 93 were written, so
+    // the baseline is zero and it can hold the line. Block scalars are skipped
+    // for the same parser reason as above.
+    const ROUTING_RE =
+      /\b(use (this|it|when|for|whenever)|when (the|a|an|you|asked|working|building|implementing|writing|reviewing)|triggers?|invoked?( when| for)?|applies when|activated?)\b/i;
     if (!isBlockScalar && !ROUTING_RE.test(desc)) {
-      warn(file, "description has no routing/trigger clause (e.g. \"use when ...\")");
+      fail(file, 'description has no routing/trigger clause (e.g. "use when ...")');
     }
   }
 
@@ -115,9 +122,13 @@ for (const file of files) {
   const bodyLines = body.split("\n").length;
   if (bodyLines > 500) {
     const referencesCompanion =
-      /\]\((?!https?:|mailto:|#)[^)]+\)/.test(body) || /`[^`\n]*\/[^`\n]*\.(md|sh|mjs|json|py|txt)`/.test(body);
+      /\]\((?!https?:|mailto:|#)[^)]+\)/.test(body) ||
+      /`[^`\n]*\/[^`\n]*\.(md|sh|mjs|json|py|txt)`/.test(body);
     if (!referencesCompanion) {
-      warn(file, `body is ${bodyLines} lines with no companion-file reference - consider splitting into references/`);
+      warn(
+        file,
+        `body is ${bodyLines} lines with no companion-file reference - consider splitting into references/`,
+      );
     }
   }
 

package/pipeline/scripts/localize-commands.mjs

@@ -116,7 +116,12 @@ if (invokedDirectly) {
     console.error("usage: localize-commands.mjs <apply|restore> [--dir <commandsDir>]");
     process.exit(2);
   }
-  let dir = join(process.env.HOME || process.env.USERPROFILE || "", ".claude", "commands", "multi-agent");
+  let dir = join(
+    process.env.HOME || process.env.USERPROFILE || "",
+    ".claude",
+    "commands",
+    "multi-agent",
+  );
   const dirFlag = args.indexOf("--dir");
   if (dirFlag >= 0) {
     if (!args[dirFlag + 1]) {

package/pipeline/scripts/match-skills.mjs

@@ -38,7 +38,9 @@ const repoRoot = resolve(here, "..", "..");
 
 const args = process.argv.slice(2);
 if (args.length === 0 || args[0].startsWith("--")) {
-  console.error('Usage: match-skills.mjs "<task text>" [--touched-files a,b] [--stack ios] [--limit 12] [--json]');
+  console.error(
+    'Usage: match-skills.mjs "<task text>" [--touched-files a,b] [--stack ios] [--limit 12] [--json]',
+  );
   process.exit(1);
 }
 
@@ -51,7 +53,11 @@ const opts = {
   json: false,
 };
 for (let i = 1; i < args.length; i++) {
-  if (args[i] === "--touched-files") opts.touchedFiles = (args[++i] || "").split(",").map((s) => s.trim()).filter(Boolean);
+  if (args[i] === "--touched-files")
+    opts.touchedFiles = (args[++i] || "")
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean);
   else if (args[i] === "--stack") opts.stack = (args[++i] || "").trim().toLowerCase();
   else if (args[i] === "--limit") opts.limit = parseInt(args[++i], 10) || 12;
   else if (args[i] === "--index") opts.indexPath = resolve(args[++i]);
@@ -86,8 +92,13 @@ function globToRe(glob) {
       // `**/` means zero-or-more path segments, so a leading `**/` must also
       // match top-level files (no dir prefix). Without the optional slash,
       // `**/Auth/**` compiled to `.*\/Auth\/.*` and missed root-level `Auth/...`.
-      if (glob[i + 2] === "/") { re += "(?:.*/)?"; i += 2; }
-      else { re += ".*"; i++; }
+      if (glob[i + 2] === "/") {
+        re += "(?:.*/)?";
+        i += 2;
+      } else {
+        re += ".*";
+        i++;
+      }
     } else if (c === "*") re += "[^/]*";
     else if (c === "?") re += ".";
     else if (".+()|{}[]^$\\".includes(c)) re += "\\" + c;

package/pipeline/scripts/memory-load.sh

@@ -16,9 +16,13 @@ PROJECT_ROOT="${1:?usage: memory-load.sh <project-root>}"
 MEM_DIR="$PROJECT_ROOT/.multi-agent/memory"
 MEM_INDEX="$MEM_DIR/MEMORY.md"
 
-# Pref-gate: locate prefs.json (home-dir first, then project-specific).
+# Pref-gate: locate the preferences file (home-dir first, then XDG config).
+# The canonical name written by the installer is multi-agent-preferences.json;
+# the bare preferences.json names are kept only as legacy fallbacks.
 prefs_file=""
 for candidate in \
+  "$HOME/.claude/multi-agent-preferences.json" \
+  "$HOME/.config/multi-agent-pipeline/multi-agent-preferences.json" \
   "$HOME/.claude/preferences.json" \
   "$HOME/.config/multi-agent-pipeline/preferences.json"
 do