@mmerterden/multi-agent-pipeline 8.6.1 → 10.0.6

package/pipeline/scripts/learnings-ledger.mjs

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+
+/**
+ * @file learnings-ledger.mjs  -  v9.3.0
+ *
+ * Zero-dep, append-only persistent LEARNINGS store, one file per repo:
+ *   $HOME/.claude/memory/multi-agent/<repo-slug>/learnings-ledger.jsonl
+ *
+ * Distinct from triage-corpus.jsonl (which holds per-task review FINDINGS):
+ * the ledger holds DURABLE knowledge that should be replayed into every future
+ * run of the same repo  -  architectural facts, conventions, and explicitly
+ * rejected review preferences. It directly targets the most-cited 2026
+ * complaint about coding agents: cold-boot amnesia + subagent silos, where each
+ * run re-discovers the same structure and reviewers re-flag preferences the team
+ * already rejected.
+ *
+ * Each line conforms to pipeline/schemas/learnings-ledger.schema.json.
+ *
+ * Subcommands:
+ *   add        --kind <fact|convention|rejected-preference> --statement "..."
+ *                 [--scope <path-glob|global>] [--task <id>] [--confidence low|medium|high]
+ *                 [--repo-slug <slug>]
+ *   brief      [--max N] [--repo-slug <slug>]   Emit a compact <repo-learnings> block
+ *                                               for injection into a phase prompt.
+ *                                               Exit 2 when the ledger is empty.
+ *   from-triage --triage <path> --task <id> [--repo-slug <slug>]
+ *                 Distill the triage's rejected[] findings into rejected-preference
+ *                 entries so reviewers stop re-raising them. SAFETY: blocking-
+ *                 severity rejections are NOT distilled - a wrong rejection of a
+ *                 blocking issue must never permanently suppress that class.
+ *   forget     [--statement "..."] [--kind <kind>] [--repo-slug <slug>]
+ *                 Remove ledger entries matching the statement substring and/or
+ *                 kind (rewrites the file). Use to clear a bad/stale learning.
+ *   path       [--repo-slug <slug>]
+ *   stats      [--repo-slug <slug>]
+ *
+ * Repo slug resolution order (identical to triage-memory.mjs so both stores
+ * live in the same per-repo directory):
+ *   1. --repo-slug   2. $MULTI_AGENT_REPO_SLUG   3. basename(git toplevel)   4. "default"
+ *
+ * Exit codes: 0 success; 1 usage/IO; 2 empty (brief) or nothing to add.
+ *
+ * @module pipeline/scripts/learnings-ledger
+ */
+
+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";
+
+const argv = process.argv.slice(2);
+const SUB = argv[0];
+const flags = {};
+for (let i = 1; i < argv.length; i++) {
+  const a = argv[i];
+  if (!a.startsWith("--")) continue;
+  const body = a.slice(2);
+  // --key=value form accepts ANY value, including one that starts with "--"
+  // (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; }
+  const k = body;
+  const v = argv[i + 1];
+  if (v !== undefined && !v.startsWith("--")) { flags[k] = v; i++; }
+  else flags[k] = true;
+}
+
+const KINDS = new Set(["fact", "convention", "rejected-preference"]);
+const CONFIDENCES = new Set(["low", "medium", "high"]);
+
+function die(msg, code = 1) {
+  process.stderr.write(`learnings-ledger: ${msg}\n`);
+  process.exit(code);
+}
+
+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 top = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    if (top) return basename(top);
+  } catch { /* not a git repo */ }
+  return "default";
+}
+
+function ledgerPath(slug) {
+  return join(homedir(), ".claude", "memory", "multi-agent", slug || repoSlug(), "learnings-ledger.jsonl");
+}
+
+function ensureDir(p) {
+  mkdirSync(dirname(p), { recursive: true });
+}
+
+function normStatement(s) {
+  return String(s || "").toLowerCase().replace(/\s+/g, " ").trim();
+}
+
+function readLedger(slug) {
+  const p = ledgerPath(slug);
+  if (!existsSync(p)) return [];
+  const raw = readFileSync(p, "utf8");
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try { rows.push(JSON.parse(line)); }
+    catch { /* skip corrupted line */ }
+  }
+  return rows;
+}
+
+function writeRow(slug, row) {
+  const p = ledgerPath(slug);
+  ensureDir(p);
+  appendFileSync(p, JSON.stringify(row) + "\n", "utf8");
+}
+
+/** Append one entry unless an entry with the same kind + normalized statement
+ *  already exists (idempotent). Returns true when written. */
+function addEntry(slug, { kind, statement, scope, task, confidence }, existing) {
+  const stmt = String(statement || "").trim();
+  if (!stmt) return false;
+  const seenKey = `${kind}::${normStatement(stmt)}`;
+  if (existing.has(seenKey)) return false;
+  const row = {
+    v: "1.0.0",
+    ts: new Date().toISOString(),
+    repo_slug: slug,
+    kind,
+    scope: scope || "global",
+    statement: stmt,
+    source_task: task || null,
+    confidence: CONFIDENCES.has(confidence) ? confidence : "medium",
+  };
+  writeRow(slug, row);
+  existing.add(seenKey);
+  return true;
+}
+
+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);
+  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",
+  }, existing);
+  process.stdout.write(JSON.stringify({ ok: true, slug, added: wrote ? 1 : 0, deduped: wrote ? 0 : 1 }) + "\n");
+  process.exit(wrote ? 0 : 2);
+}
+
+function cmdFromTriage() {
+  const triagePath = flags.triage;
+  if (!triagePath || triagePath === true) die("from-triage needs --triage <path>", 1);
+  if (!existsSync(triagePath)) die(`triage file not found: ${triagePath}`, 1);
+  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); }
+
+  const existing = new Set(readLedger(slug).map((r) => `${r.kind}::${normStatement(r.statement)}`));
+  let written = 0;
+  let skippedBlocking = 0;
+  for (const r of triage.rejected || []) {
+    const f = r.finding || {};
+    const issue = (f.issue || "").trim();
+    if (!issue) continue;
+    // SAFETY: never auto-suppress a rejected BLOCKING finding. A single wrong
+    // rejection of a blocking issue must not teach the ledger to silence that
+    // 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; }
+    // 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 statement = `Do not re-flag: ${issue}` + (r.reason ? ` (rejected: ${r.reason})` : "");
+    if (addEntry(slug, { kind: "rejected-preference", statement, scope, task, confidence: "low" }, existing)) {
+      written++;
+    }
+  }
+  process.stdout.write(JSON.stringify({ ok: true, slug, added: written, skippedBlocking }) + "\n");
+  process.exit(0);
+}
+
+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);
+  const p = ledgerPath(slug);
+  if (!existsSync(p)) {
+    process.stdout.write(JSON.stringify({ ok: true, slug, removed: 0 }) + "\n");
+    process.exit(0);
+  }
+  const rows = readLedger(slug);
+  const kept = rows.filter((r) => {
+    const stmtHit = match ? normStatement(r.statement).includes(match) : true;
+    const kindHit = kind ? r.kind === kind : true;
+    // Remove rows that match BOTH provided filters (statement substring + kind).
+    return !(stmtHit && kindHit);
+  });
+  const removed = rows.length - kept.length;
+  // Rewrite the file (the only non-append operation). Write to a temp file then
+  // rename so the rewrite is atomic - a crash or a concurrent reader never sees
+  // a half-written ledger.
+  const body = kept.map((r) => JSON.stringify(r)).join("\n");
+  ensureDir(p);
+  const tmp = `${p}.tmp-${process.pid}`;
+  writeFileSync(tmp, kept.length ? body + "\n" : "", "utf8");
+  renameSync(tmp, p);
+  process.stdout.write(JSON.stringify({ ok: true, slug, removed, remaining: kept.length }) + "\n");
+  process.exit(0);
+}
+
+function cmdBrief() {
+  const slug = flags["repo-slug"] ? String(flags["repo-slug"]) : repoSlug();
+  const max = flags.max ? Math.max(1, Number(flags.max)) : 20;
+  const rows = readLedger(slug);
+  if (rows.length === 0) {
+    process.exit(2); // nothing to inject; caller skips silently
+  }
+  // Most-recent first, capped. Group by kind for a scannable brief.
+  const ordered = rows.slice().reverse().slice(0, max);
+  const byKind = { fact: [], convention: [], "rejected-preference": [] };
+  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).`);
+  const labels = {
+    fact: "Architectural facts",
+    convention: "Conventions",
+    "rejected-preference": "Rejected review preferences (do not re-raise)",
+  };
+  for (const kind of ["fact", "convention", "rejected-preference"]) {
+    const items = byKind[kind] || [];
+    if (items.length === 0) continue;
+    lines.push("", `## ${labels[kind]}`);
+    for (const r of items) {
+      const scope = r.scope && r.scope !== "global" ? ` [${r.scope}]` : "";
+      lines.push(`- ${r.statement}${scope}`);
+    }
+  }
+  lines.push("</repo-learnings>");
+  process.stdout.write(lines.join("\n") + "\n");
+  process.exit(0);
+}
+
+function cmdPath() {
+  process.stdout.write(ledgerPath(flags["repo-slug"] ? String(flags["repo-slug"]) : repoSlug()) + "\n");
+  process.exit(0);
+}
+
+function cmdStats() {
+  const slug = flags["repo-slug"] ? String(flags["repo-slug"]) : repoSlug();
+  const rows = readLedger(slug);
+  const counts = { fact: 0, convention: 0, "rejected-preference": 0 };
+  for (const r of rows) if (counts[r.kind] !== undefined) counts[r.kind]++;
+  const out = { ok: true, slug, path: ledgerPath(slug), rows: rows.length, counts };
+  if (existsSync(out.path)) out.bytes = statSync(out.path).size;
+  process.stdout.write(JSON.stringify(out) + "\n");
+  process.exit(0);
+}
+
+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;
+  default:
+    process.stderr.write("usage: learnings-ledger.mjs <add|from-triage|forget|brief|path|stats> [flags]\n");
+    process.exit(64);
+}

package/pipeline/scripts/lint-skills.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// Frontmatter linter for every SKILL.md shipped by the pipeline.
+//
+// Until v10.0.0 the 217 SKILL.md files were counted by smokes but never
+// content-checked, so a skill could ship without the frontmatter that
+// Claude Code / Copilot CLI need to register it. This gate enforces the
+// minimal contract; it is zero-dependency (line-based YAML subset) so it
+// runs inside `npm test` and ci-lite without installs.
+//
+// Contract per SKILL.md:
+//   - frontmatter block present (--- ... ---) starting at line 1
+//   - name: required, lowercase kebab-case (underscores tolerated for
+//     legacy skills already published under a snake_case name)
+//   - 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
+
+import { readFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const files = execSync("find pipeline -name SKILL.md", { cwd: repoRoot, encoding: "utf-8" })
+  .trim()
+  .split("\n")
+  .filter(Boolean)
+  .sort();
+
+const errors = [];
+const fail = (file, msg) => errors.push(`${file}: ${msg}`);
+
+for (const file of files) {
+  const raw = readFileSync(join(repoRoot, file), "utf-8");
+
+  if (!raw.startsWith("---\n")) {
+    fail(file, "missing frontmatter block at line 1");
+    continue;
+  }
+  const end = raw.indexOf("\n---", 4);
+  if (end === -1) {
+    fail(file, "frontmatter block never closed");
+    continue;
+  }
+
+  const fields = {};
+  for (const line of raw.slice(4, end).split("\n")) {
+    const m = line.match(/^([a-zA-Z][a-zA-Z0-9-]*):\s*(.*)$/);
+    if (m) fields[m[1]] = m[2].replace(/^["']|["']$/g, "").trim();
+  }
+
+  if (!fields.name) {
+    fail(file, "missing required field: name");
+  } else if (!/^[a-z0-9]+([-_][a-z0-9]+)*$/.test(fields.name)) {
+    fail(file, `name is not lowercase kebab/snake-case: "${fields.name}"`);
+  }
+
+  if (!("description" in fields)) {
+    fail(file, "missing required field: description");
+  } else if (fields.description.length === 0) {
+    fail(file, "description is empty");
+  } else if (fields.description.length > 1024) {
+    fail(file, `description exceeds 1024 chars (${fields.description.length})`);
+  }
+
+  if ("user-invocable" in fields && !["true", "false"].includes(fields["user-invocable"])) {
+    fail(file, `user-invocable must be true|false, got "${fields["user-invocable"]}"`);
+  }
+
+  if ("platform" in fields && !["ios", "android", "common", "all"].includes(fields.platform)) {
+    fail(file, `platform must be ios|android|common|all, got "${fields.platform}"`);
+  }
+}
+
+if (errors.length > 0) {
+  console.error(`lint-skills: ${errors.length} error(s) across ${files.length} SKILL.md files`);
+  for (const e of errors) console.error("  " + e);
+  process.exit(1);
+}
+console.log(`lint-skills: ${files.length} SKILL.md files OK`);

package/pipeline/scripts/log-metric.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# log-metric.sh — append a single event to the pipeline metrics log.
+# log-metric.sh  -  append a single event to the pipeline metrics log.
 #
 # Append-only JSONL at $METRICS_FILE (default $HOME/.claude/logs/multi-agent/metrics.jsonl).
 # One event per line. Schema:
@@ -42,7 +42,7 @@ METRICS_FILE="${METRICS_FILE:-$HOME/.claude/logs/multi-agent/metrics.jsonl}"
 METRICS_DIR="$(dirname "$METRICS_FILE")"
 
 mkdir -p "$METRICS_DIR" 2>/dev/null || {
-  echo "warn: log-metric: cannot create $METRICS_DIR — telemetry skipped" >&2
+  echo "warn: log-metric: cannot create $METRICS_DIR  -  telemetry skipped" >&2
   exit 0
 }
 
@@ -52,7 +52,7 @@ SEP=""
 for kv in "$@"; do
   KEY="${kv%%=*}"
   VAL="${kv#*=}"
-  # Decide if value is bool / int / string. Keep simple — anything not parseable as
+  # Decide if value is bool / int / string. Keep simple  -  anything not parseable as
   # int or true/false becomes a JSON string.
   case "$VAL" in
     true|false) JSON_VAL="$VAL" ;;
@@ -69,7 +69,7 @@ LINE="{\"ts\":\"${TS}\",\"task_id\":\"${TASK_ID}\",\"phase\":\"${PHASE}\",\"even
 
 # Atomic append (one line, well under PIPE_BUF).
 echo "$LINE" >> "$METRICS_FILE" 2>/dev/null || {
-  echo "warn: log-metric: cannot write to $METRICS_FILE — telemetry skipped" >&2
+  echo "warn: log-metric: cannot write to $METRICS_FILE  -  telemetry skipped" >&2
   exit 0
 }
 
@@ -78,18 +78,27 @@ echo "$LINE" >> "$METRICS_FILE" 2>/dev/null || {
 # so the cost block stays in sync with metrics.jsonl from a single call site.
 # Best-effort: never fails the pipeline.
 if [ "${LOG_METRIC_FORWARD_TO_TRACKER:-0}" = "1" ]; then
-  TI=""; TO=""; MODEL=""
+  TI=""; TO=""; TC=""; MODEL=""
   for kv in "$@"; do
     case "${kv%%=*}" in
-      tokens_in)  TI="${kv#*=}" ;;
-      tokens_out) TO="${kv#*=}" ;;
-      model)      MODEL="${kv#*=}" ;;
+      tokens_in)     TI="${kv#*=}" ;;
+      tokens_out)    TO="${kv#*=}" ;;
+      tokens_cached) TC="${kv#*=}" ;;
+      model)         MODEL="${kv#*=}" ;;
     esac
   done
   if [ -n "$TI" ] && [ -n "$TO" ]; then
     SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+    # Sanitize the optional cached count: a non-integer (quoted, float, empty)
+    # must NOT poison the whole tokens call and lose the valid in/out counts.
+    # phase-tracker rejects the call on any bad arg, so drop a bad cached to 0.
+    case "$TC" in
+      ''|*[!0-9]*) TC=0 ;;
+    esac
     if [ -x "$SCRIPT_DIR/phase-tracker.sh" ]; then
-      TRACKER_QUIET=1 "$SCRIPT_DIR/phase-tracker.sh" tokens "$PHASE" "$TI" "$TO" >/dev/null 2>&1 || true
+      # tokens_cached is optional (4th arg); when the host reports prompt-cache
+      # reads, forwarding it lets the cost ledger price them at the cheaper rate.
+      TRACKER_QUIET=1 "$SCRIPT_DIR/phase-tracker.sh" tokens "$PHASE" "$TI" "$TO" "$TC" >/dev/null 2>&1 || true
       if [ -n "$MODEL" ]; then
         TRACKER_QUIET=1 "$SCRIPT_DIR/phase-tracker.sh" model "$PHASE" "$MODEL" >/dev/null 2>&1 || true
       fi

package/pipeline/scripts/match-skills.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// match-skills.mjs — v7.0.I
+// match-skills.mjs  -  v7.0.I
 //
 // Given a task description and optionally a list of touched files, score
 // each SKILL.md in the index by relevance. Used by dynamic-skill-loading
@@ -8,13 +8,13 @@
 //
 // Usage:
 //   match-skills.mjs "<task description>" [--touched-files a.swift,b.kt]
-//                                          [--stack ios|android|backend|…]
+//                                          [--stack ios|android|backend|...]
 //                                          [--limit N]                       # default 12
 //                                          [--index <path>]                  # default pipeline/skills/.skills-index.json
 //                                          [--json]                          # machine output
 //
 // Output (default human):
-//   <score> <name> [group/platform]  — <description>
+//   <score> <name> [group/platform]   -  <description>
 //
 // Output (--json):
 //   { "matches": [ {name, score, reasons, group, relativePath}, ... ] }
@@ -76,14 +76,19 @@ const taskWords = new Set(
 );
 
 // Very light glob: "*.swift" / "**/Auth/**" style. We avoid adding a full
-// glob lib dependency — zero-dep is a load-bearing project value. Implement
+// glob lib dependency  -  zero-dep is a load-bearing project value. Implement
 // a small glob-to-regex translator.
 function globToRe(glob) {
   let re = "^";
   for (let i = 0; i < glob.length; i++) {
     const c = glob[i];
-    if (c === "*" && glob[i + 1] === "*") { re += ".*"; i++; }
-    else if (c === "*") re += "[^/]*";
+    if (c === "*" && glob[i + 1] === "*") {
+      // `**/` 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++; }
+    } else if (c === "*") re += "[^/]*";
     else if (c === "?") re += ".";
     else if (".+()|{}[]^$\\".includes(c)) re += "\\" + c;
     else re += c;
@@ -108,7 +113,7 @@ for (const entry of index.entries) {
     reasons.push({ rule: "desc-keyword", add, detail: `${descHits} term(s)` });
   }
 
-  // trigger-keywords (max +30, weighted heavier — authors opted in)
+  // trigger-keywords (max +30, weighted heavier  -  authors opted in)
   let kwHits = 0;
   for (const kw of entry.triggerKeywords || []) {
     if (taskLower.includes(kw)) kwHits++;
@@ -139,7 +144,7 @@ for (const entry of index.entries) {
     reasons.push({ rule: "platform", add: 10, detail: `platform=${entry.platform}` });
   }
 
-  // core-always hint (+5) — only when task text mentions the orchestrator
+  // core-always hint (+5)  -  only when task text mentions the orchestrator
   if (entry.group === "core" && /\b(multi[- ]agent|pipeline|orchestrator)\b/i.test(taskText)) {
     score += 5;
     reasons.push({ rule: "core-hint", add: 5, detail: "core orchestration mentioned" });

package/pipeline/scripts/memory-load.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# memory-load.sh — v6.2.E
+# memory-load.sh  -  v6.2.E
 #
 # Reads the per-repo memory at $PROJECT_ROOT/.multi-agent/memory/ and prints
 # a compact markdown block suitable for Phase 0 context injection. Falls back
@@ -29,13 +29,13 @@ if [ -n "$prefs_file" ] && command -v jq >/dev/null 2>&1; then
   enabled=$(jq -r '.global.perRepoMemory // false' "$prefs_file" 2>/dev/null || echo "false")
   [ "$enabled" = "true" ] || exit 0
 else
-  # No prefs file or no jq — treat as opt-out to avoid surprising new users.
+  # No prefs file or no jq  -  treat as opt-out to avoid surprising new users.
   exit 0
 fi
 
 [ -f "$MEM_INDEX" ] || exit 0
 
-# Emit Phase 0 injection block — capped at 30 lines to stay within token budget.
+# Emit Phase 0 injection block  -  capped at 30 lines to stay within token budget.
 # If MEMORY.md is larger, the first 30 pointer lines are printed; individual
 # memory files are NOT inlined (caller reads them on-demand when a pointer
 # looks relevant).

package/pipeline/scripts/memory-save.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# memory-save.sh — v6.2.E
+# memory-save.sh  -  v6.2.E
 #
 # Writes a single per-repo memory file and updates the MEMORY.md index.
 # Called by Phase 7's synthesis step (or any user skill that wants to
@@ -14,7 +14,7 @@
 #              (or "-" to read body from stdin)
 #
 # Writes to $PROJECT_ROOT/.multi-agent/memory/<type>_<slug>.md and prepends
-# a bullet to MEMORY.md. Idempotent — overwriting an existing slug replaces
+# a bullet to MEMORY.md. Idempotent  -  overwriting an existing slug replaces
 # the file but leaves the index entry position unchanged.
 
 set -euo pipefail
@@ -37,11 +37,11 @@ FILE="$MEM_DIR/${TYPE}_${SLUG}.md"
 
 mkdir -p "$MEM_DIR"
 
-# Gitignore guard — never commit memory to the repo.
+# Gitignore guard  -  never commit memory to the repo.
 GITIGNORE="$PROJECT_ROOT/.multi-agent/.gitignore"
 if [ ! -f "$GITIGNORE" ]; then
   cat > "$GITIGNORE" <<'GI'
-# Per-repo memory is local-only — never commit.
+# Per-repo memory is local-only  -  never commit.
 memory/
 GI
 fi
@@ -70,7 +70,7 @@ fi
 title=$(awk '/^name:/ {sub(/^name: */, ""); gsub(/^"|"$/, ""); print; exit}' "$FILE" || true)
 [ -n "$title" ] || title="$SLUG"
 
-printf -- '- [%s](%s_%s.md) — %s\n' "$title" "$TYPE" "$SLUG" "$description" >> "$MEM_INDEX"
+printf -- '- [%s](%s_%s.md)  -  %s\n' "$title" "$TYPE" "$SLUG" "$description" >> "$MEM_INDEX"
 
 printf 'memory-save: wrote %s\n' "$FILE"
 exit 0