@mmerterden/multi-agent-pipeline 16.25.0 → 16.27.0

package/pipeline/scripts/triage-memory.mjs

@@ -25,6 +25,11 @@
  *   query    --issue "<text>" [--file-glob "Auth*"] [--top N]
  *               [--repo-slug <slug>] [--json]
  *   show     --id <id> [--repo-slug <slug>]
+ *   timeline --anchor <id> [--before N] [--after N] [--repo-slug <slug>]
+ *               What surrounded a finding when it was recorded. The corpus is
+ *               append-only and written in order, so line adjacency is
+ *               chronological adjacency - the neighbours came from the same
+ *               review pass, and are usually what makes an old row legible.
  *               Print the full row behind a pointer emitted by query/profile.
  *   path     [--repo-slug <slug>]   Print the resolved corpus file path
  *   stats    [--repo-slug <slug>]   Print corpus row counts grouped by classification
@@ -295,8 +300,11 @@ function ingest() {
     }
   }
   process.stdout.write(JSON.stringify({ ok: true, slug, ingested: written }) + "\n");
-  if (written === 0) process.exit(2);
-  process.exit(0);
+  // exitCode, not exit(): even this one-line write is on the same rule, and a
+  // rule with an exception is the one that gets copied into the next branch.
+  // 2 = nothing new, which callers treat as an idempotent success.
+  process.exitCode = written === 0 ? 2 : 0;
+  return;
 }
 
 function query() {
@@ -308,7 +316,8 @@ function query() {
   const corpus = readCorpus(slug);
   if (corpus.length === 0) {
     process.stdout.write(JSON.stringify({ ok: true, slug, hits: [], total: 0 }) + "\n");
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
   const qTerms = tokens(issueText);
   const fileRe = fileGlob ? globToRegExp(fileGlob) : null;
@@ -380,7 +389,8 @@ function query() {
   process.stdout.write(
     JSON.stringify({ ok: true, slug, total: filtered.length, hits: ranked }) + "\n",
   );
-  process.exit(0);
+  process.exitCode = 0;
+  return;
 }
 
 // Drill-down: a compact prior-art line carries only its id, so the agent that
@@ -394,17 +404,65 @@ function showCmd() {
   const row = readCorpus(slug).find((r) => rowId(r) === want);
   if (!row) {
     process.stdout.write(JSON.stringify({ ok: false, slug, id: want, found: false }) + "\n");
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
   process.stdout.write(JSON.stringify({ ok: true, slug, id: want, row }) + "\n");
-  process.exit(0);
+  process.exitCode = 0;
+  return;
+}
+
+/**
+ * Neighbourhood: what surrounded a finding when it was recorded.
+ *
+ * Search answers "which rows match", and that is a different question from
+ * "what else happened around this one". A finding almost never travels alone -
+ * the same review pass produced the ones next to it, and those are often the
+ * context that makes it legible a year later. Without this, the only way to ask
+ * was to fetch the whole corpus and page through it, so nobody asked.
+ *
+ * The corpus is append-only and written in order, so line adjacency IS
+ * chronological adjacency. That is the whole implementation: no index, no
+ * timestamp arithmetic, no second data structure to keep in sync.
+ */
+function timelineCmd() {
+  const id = flags.anchor && flags.anchor !== true ? String(flags.anchor) : null;
+  if (!id) die("timeline needs --anchor <id>", 1);
+  const slug = flags["repo-slug"] ? String(flags["repo-slug"]) : repoSlug();
+  const before = flags.before && flags.before !== true ? Math.max(0, Number(flags.before)) : 3;
+  const after = flags.after && flags.after !== true ? Math.max(0, Number(flags.after)) : 3;
+  const want = id.startsWith("T:") ? id : `T:${id}`;
+  const corpus = readCorpus(slug);
+  const at = corpus.findIndex((r) => rowId(r) === want);
+  if (at === -1) {
+    process.stdout.write(JSON.stringify({ ok: false, slug, anchor: want, found: false }) + "\n");
+    process.exitCode = 2;
+    return;
+  }
+  const from = Math.max(0, at - before);
+  const to = Math.min(corpus.length, at + after + 1);
+  const rows = corpus.slice(from, to).map((r, i) => ({
+    id: rowId(r),
+    offset: from + i - at,
+    task_id: r.task_id,
+    classification: r.classification,
+    severity: r.severity,
+    file: r.file,
+    issue: r.issue,
+  }));
+  process.stdout.write(
+    JSON.stringify({ ok: true, slug, anchor: want, before, after, rows }, null, 2) + "\n",
+  );
+  process.exitCode = 0;
+  return;
 }
 
 function pathCmd() {
   process.stdout.write(
     corpusPath(flags["repo-slug"] ? String(flags["repo-slug"]) : repoSlug()) + "\n",
   );
-  process.exit(0);
+  process.exitCode = 0;
+  return;
 }
 
 function statsCmd() {
@@ -424,7 +482,8 @@ function statsCmd() {
     out.bytes = s.size;
   }
   process.stdout.write(JSON.stringify(out) + "\n");
-  process.exit(0);
+  process.exitCode = 0;
+  return;
 }
 
 switch (SUB) {
@@ -437,6 +496,9 @@ switch (SUB) {
   case "show":
     showCmd();
     break;
+  case "timeline":
+    timelineCmd();
+    break;
   case "path":
     pathCmd();
     break;
@@ -444,6 +506,8 @@ switch (SUB) {
     statsCmd();
     break;
   default:
-    process.stderr.write("usage: triage-memory.mjs <ingest|query|show|path|stats> [flags]\n");
+    process.stderr.write(
+      "usage: triage-memory.mjs <ingest|query|show|timeline|path|stats> [flags]\n",
+    );
     process.exit(64);
 }

package/pipeline/skills/.skill-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": "1.0.0",
-  "generatedAt": "2026-09-09T17:46:50Z",
+  "generatedAt": "2026-09-09T18:15:55Z",
   "skillCount": 207,
   "entries": [
     {

package/pipeline/skills/shared/core/multi-agent-refactor/SKILL.md

@@ -12,7 +12,7 @@ argument-hint: 'bugs | best-practices | drift | multi-agent-toolkit | run-errors
 
 Deep-analyses the current project, extracts the global best-practices worth adopting (adapted to our stack), hunts real bugs and improvement areas, checks whether any skills we derived from an upstream source have drifted, researches the companion multi-agent-toolkit MCP server against current MCP practice, scores everything, drafts a single prioritized plan, asks the user for approval, applies the approved items, and asks about sync at the end.
 
-**Input**: $ARGUMENTS (optional  -  area to focus on: "security", "performance", "tests", "bugs", "best-practices", "drift", "multi-agent-toolkit", etc.)
+**Input**: $ARGUMENTS (optional  -  `backlog` runs Step 0e alone; otherwise an area to focus on: "security", "performance", "tests", "bugs", "best-practices", "drift", "multi-agent-toolkit", etc.)
 
 ## Flow
 
@@ -134,6 +134,14 @@ Each line is one run: `{ t, id, u, c, rp, ph, v, errs[] }`. The `errs[]` entries
 
 This band mirrors the admin dashboard's "Gelişim alanları" panel, but reads the local ledger so it needs no auth and works offline. If `$ARGUMENTS` names a focus area, still read the ledger  -  a recurring run error in that area is the strongest possible signal.
 
+Then read what the transcripts themselves record, which is the half no model noticed:
+
+```bash
+node "$HOME/.claude/scripts/learn-from-transcripts.mjs" --json
+```
+
+It correlates rather than interprets  -  a failed read against the read that then worked, an identical invocation that kept failing, a search that was too narrow, a call the user refused twice, a file too big to read whole. Dry run by default; `--apply` writes them to the learnings ledger as `source: transcript-mining` and renders a marked block in `CLAUDE.local.md`. Zero candidates alongside a non-zero `toolResultsExamined` means there was nothing to find; zero of both means the read is broken.
+
 Output (plan band F):
 
 ```
@@ -149,6 +157,20 @@ Rules for this band:
 - Never quote a user's identity as blame. The `u` field is for counting distinct affected users, not for naming anyone in the plan.
 - If the ledger is empty or absent, skip band F silently  -  it is additive signal, never a gate.
 
+## Step 0e: BACKLOG  -  friction this pipeline already noticed
+
+Every other band in this command derives its findings from scratch, which is right for a sweep and has one consequence nobody chose: a friction noticed mid-task is gone by the next run unless it was fixed within the hour. Most are not, because stopping mid-task to fix them is the wrong call. So they are written down when noticed and decided here.
+
+```bash
+node "$HOME/.claude/scripts/observations.mjs" scan --status open --json
+```
+
+Exit 3 is `SCAN BROKEN`  -  files on disk, none parsed. That is a broken reader, not an empty queue: halt the band and say so rather than reporting "0 open".
+
+Split every open observation into actionable / sibling-propagation / to-decline, and resolve the sibling surfaces mechanically with `skill-siblings.mjs`, never from memory  -  a command is authored in `commands/`, mirrored into `skills/shared/core/`, and installed again into three host trees, so a fix applied to one copy drifts from the rest with every gate still green. Output as plan band G, same table shape as the other bands.
+
+`/multi-agent:refactor backlog` runs this band alone. The full sweep is unchanged and still includes it. Buckets, the status vocabulary, why `parked` needs a named unblocking event, and how to write an observation: `$HOME/.claude/multi-agent-refs/refactor/observations.md`.
+
 ## Step 1: SCAN
 
 ```

package/pipeline/skills/shared/core/multi-agent-search/SKILL.md

@@ -38,6 +38,34 @@ Text (default): colored, `task_id · project · branch · matches` + title + dat
 
 JSON: `{ query, matched_tasks, tasks: [{ task_id, project, branch, date, matches, score, title, snippet }] }`.
 
+## Four layers, and what each one costs
+
+Retrieval is cheap or expensive depending on which layer answers, and the order
+matters more than the query does. Filter first, fetch second - inverting these
+is how a single lookup eats a phase's whole context budget.
+
+| # | Call | Returns | Rough cost per hit |
+|---|---|---|---|
+| 1 | `search` / `--semantic` | pointers: id, file, one-line issue | ~50-100 tokens |
+| 2 | `timeline --anchor <id>` | the rows recorded around one hit | ~50-100 tokens each |
+| 3 | `show --id <id>` | one full row | ~500-1000 tokens |
+| 4 | the offloaded artefact behind a `[[ref:<id>]]` | the raw payload | thousands |
+
+Never start at layer 3 or 4. Narrow at layer 1, widen at layer 2 only around the
+hits that survived, and fetch full rows only for the handful that are actually
+going to be read. A `show` on twenty ids costs as much as the entire search that
+found them and answers a question nobody asked.
+
+Layer 2 is the one that gets forgotten. A finding rarely stands alone: the same
+review pass produced its neighbours, and those are usually what makes an old row
+legible. Both stores answer it, and the corpus is append-only so line adjacency
+IS chronological adjacency:
+
+```bash
+node "$HOME/.claude/scripts/triage-memory.mjs"    timeline --anchor T:<id> --before 3 --after 3
+node "$HOME/.claude/scripts/learnings-ledger.mjs" timeline --anchor L:<id> --before 3 --after 3
+```
+
 ## Steps
 
 1. Script:

package/pipeline/skills/shared/core/multi-agent-setup/SKILL.md

@@ -227,7 +227,7 @@ Standard key names (used when creating NEW tokens). Discovery may find existing
 | `figma` | `${USER}_Figma_Access_Token` | PAT | Figma Developer Settings (max 90 days) |
 | `figma_mcp` | `${USER}_Figma_Mcp_Access_Token` | OAuth | Automatic via Claude Code Figma MCP remote auth |
 | `fortify` | `${USER}_Fortify_Access_Token` | API Token | Fortify SSC -> Token Management (VPN required) |
-| `firebase` | `${USER}_Firebase_Access_Json` | Firebase JSON (base64) | Firebase Console -> Project settings -> Service accounts -> Generate new private key. Project id is parsed from the decoded JSON. |
+| `firebase` | `${USER}_Firebase_Access_Json` | Firebase service-account JSON | Firebase Console -> Project settings -> Service accounts -> Generate new private key. Store the file as issued; project id is read straight out of it. |
 | `jenkins` | `${USER}_Jenkins_Access_Token` | API Token | Jenkins -> User -> Configure -> API Token |
 |  -  | Git Identities | JSON (preferences) | Stored in `$HOME/.claude/multi-agent-preferences.json`  -  not Keychain |
 
@@ -243,14 +243,11 @@ pbcopy < /dev/null  # clear clipboard
 # Plain text (direct value)
 ~/.copilot/lib/credential-store.sh set "<SERVICE_NAME>" "<VALUE>"
 
-# JSON file (base64 encode)
-~/.copilot/lib/credential-store.sh set "<SERVICE_NAME>" "$(base64 < /path/to/file.json)"
+# JSON file (stored as issued  -  the store round-trips newlines byte-exactly)
+~/.copilot/lib/credential-store.sh set "<SERVICE_NAME>" "$(cat /path/to/file.json)"
 
 # Read
 ~/.copilot/lib/credential-store.sh get "<SERVICE_NAME>"
-
-# Decode JSON
-~/.copilot/lib/credential-store.sh get "<SERVICE_NAME>" | base64 -d
 ```
 
 For maximum stdin hygiene (the secret never lands on argv / shell history), use the Python helper directly with the `-` sentinel:
@@ -325,6 +322,40 @@ A credential that resolves but is rejected (401/403) follows the Expired-token
 decision (Regenerate / Use a different token / Skip and continue) rather than
 being silently dropped.
 
+### Firebase / Crashlytics Access (optional, any platform)
+
+Discovery maps a stored service-account JSON like any other credential, but it
+cannot see the thing that decides whether Crashlytics is readable: a freshly
+generated `firebase-adminsdk-*` account authenticates perfectly and holds no
+Crashlytics role. Measure it, do not assume it:
+
+```bash
+bash "$HOME/.claude/lib/fetch-crashlytics.sh" --probe
+```
+
+Ask (picker): **Complete tier 1** / **Set up tier 2** / **Skip**.
+
+**Tier 1 - service account.** Store the JSON exactly as Firebase Console issued
+it; it is multi-line and the store round-trips it byte for byte. Never base64 it -
+a wrapper on the way in that nothing unwraps on the way out is how this path
+stayed broken. When the probe says `tier-1-no-grant`, the fix is one line to an
+Owner: grant `roles/firebasecrashlytics.viewer` on the project to that service
+account. Read-only, and narrower than `roles/firebase.viewer`.
+
+**Tier 2 - interactive session + MCP.** `firebase login` opens a browser and does
+not work from inside an agent harness; the user runs it in their own terminal.
+Both halves are required - a login with no MCP server registered reaches nothing.
+It is the bridge while a role request moves, never the durable answer: autopilot
+and url-enrichment run with nobody at the keyboard.
+
+**appId discovery.** `scripts/firebase-app-discovery.sh <repo> --json` reads the
+bundle-id / appId pairs the repo's `GoogleService-Info*.plist` and
+`google-services.json` already carry, shaped for
+`prefs.global.firebase.accounts[].apps[]`. Merging them saves the fetcher a
+Management API round trip per run; skipping it changes nothing else.
+
+Full mechanics and the v1alpha caveat: `multi-agent-refs/setup/firebase.md`.
+
 ### Security Rules
 
 - Never paste tokens into terminal or chat  -  use `pbpaste` for input

package/pipeline/skills/shared/core/multi-agent-status/SKILL.md

@@ -36,6 +36,15 @@ Show every active and completed task as a table.
    💡 log #1 | resume #N | kill #N
    ```
 
+6. **What is waiting to be learned** (one line, only when non-zero):
+
+   ```bash
+   node "$HOME/.claude/scripts/learn-from-transcripts.mjs" --json 2>/dev/null
+   node "$HOME/.claude/scripts/observations.mjs" scan --status open --json 2>/dev/null
+   ```
+
+   Report `N lesson(s) minable from transcripts  -  /multi-agent:refactor to review` and `N open pipeline observation(s)` when either count is above zero, and print nothing when both are zero. Neither runs a model and neither writes: the miner is dry-run by default. Zero candidates with a non-zero `toolResultsExamined` means nothing to find; zero of both means the read is broken, which is worth saying rather than reporting a clean queue.
+
 5. **Short command suggestions**  -  Based on state:
    - If there is a paused task → suggest `resume #N`
    - If there is a done task → suggest `log #N`