@mmerterden/multi-agent-pipeline 16.25.0 → 16.27.0

package/pipeline/scripts/capture-flush.sh

@@ -0,0 +1,158 @@
+#!/usr/bin/env bash
+#
+# capture-flush.sh  -  write what a run has already learned into the durable
+# stores, without needing the run to reach its end.
+#
+# WHY THIS EXISTS
+#
+# Every persistent write used to live in Phase 7: triage ingest, the learnings
+# ledger distill, the knowledge-base append, the code-graph refresh. And Phase 7
+# is, by the pipeline's own admission in features/code-graph.md, the phase a run
+# is LEAST likely to reach. A run killed in Phase 3, a session that hits its
+# context ceiling, a crash after review - each one threw away everything it had
+# established, and the next run on the same repo rediscovered it from scratch.
+#
+# So the writes move here, and Phase 7 becomes the LAST flush rather than the
+# only one. Phase boundaries call this, and so does SessionEnd. Nothing about
+# the trigger depends on a model noticing that a moment qualifies: it hangs on
+# a phase transition and on process exit, both objectively visible without any
+# agent's cooperation.
+#
+# What it does NOT do: call a model. Everything here is derived from artefacts
+# already on disk (triage-output.json) plus agent-state.json. The parts of
+# Phase 7 that genuinely need a model - the knowledge-base extraction, the
+# per-repo memory synthesis - stay in Phase 7, because a hook cannot think.
+#
+# Usage:
+#   ./capture-flush.sh [--state <agent-state.json>] [--if-stale] [--json] [--quiet]
+#
+#   --state     the run to flush. Default: resolved from the newest task dir
+#               under $HOME/.claude/logs/multi-agent (see resolve_state).
+#   --if-stale  flush only when the run did NOT complete Phase 7 - the
+#               SessionEnd case. A finished run has already flushed.
+#   --json      machine-readable result for a caller that wants to count rows.
+#   --quiet     no stdout. Exit status still distinguishes the outcomes.
+#
+# Exit codes:
+#   0  flushed, or nothing to flush (both are fine outcomes)
+#   1  bad usage
+#
+# It never exits non-zero because a store rejected a row. This runs from a hook,
+# and a hook that fails a session over a bookkeeping write is worse than the
+# bookkeeping it protects. Every failure is reported and swallowed.
+
+set -uo pipefail
+
+STATE=""
+IF_STALE=0
+JSON=0
+QUIET=0
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --state)    STATE="${2:-}"; shift 2 || shift ;;
+    --if-stale) IF_STALE=1; shift ;;
+    --json)     JSON=1; shift ;;
+    --quiet)    QUIET=1; shift ;;
+    -h|--help)
+      echo "usage: $0 [--state <agent-state.json>] [--if-stale] [--json] [--quiet]" >&2
+      exit 1 ;;
+    *)
+      echo "ERR: unexpected arg $1" >&2; exit 1 ;;
+  esac
+done
+
+LOGS="$HOME/.claude/logs/multi-agent"
+SCRIPTS="$HOME/.claude/scripts"
+[ -d "$SCRIPTS" ] || SCRIPTS="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+
+say() { [ "$QUIET" -eq 1 ] && return 0; printf '%s\n' "$1"; }
+
+# Resolve the run to flush.
+#
+# Newest by mtime of agent-state.json, not by directory name: task ids do not
+# sort chronologically (PROJ-1002 can run before PROJ-1001 does) and a
+# name-sorted pick would flush the wrong run.
+resolve_state() {
+  [ -d "$LOGS" ] || return 0
+  find "$LOGS" -name agent-state.json -type f -maxdepth 4 -print0 2>/dev/null \
+    | xargs -0 ls -t 2>/dev/null | head -1
+}
+
+if [ -z "$STATE" ]; then
+  STATE="$(resolve_state)"
+fi
+
+if [ -z "$STATE" ] || [ ! -f "$STATE" ]; then
+  say "capture-flush: no run state found - nothing to flush"
+  [ "$JSON" -eq 1 ] && printf '{"status":"noop","reason":"no-state"}\n'
+  exit 0
+fi
+
+if ! command -v jq >/dev/null 2>&1; then
+  say "capture-flush: jq unavailable - skipped"
+  [ "$JSON" -eq 1 ] && printf '{"status":"skipped","reason":"no-jq"}\n'
+  exit 0
+fi
+
+TASK_ID=$(jq -r '.taskId // .jiraId // empty' "$STATE" 2>/dev/null)
+ARTIFACTS=$(jq -r '.artifactsPath // empty' "$STATE" 2>/dev/null)
+WORKTREE=$(jq -r '.worktreePath // empty' "$STATE" 2>/dev/null)
+PHASE7=$(jq -r '[.phases[]? | select((.id // "") == "7") | .status] | first // ""' "$STATE" 2>/dev/null)
+
+if [ "$IF_STALE" -eq 1 ] && [ "$PHASE7" = "completed" ]; then
+  say "capture-flush: ${TASK_ID:-run} already completed Phase 7 - nothing stale"
+  [ "$JSON" -eq 1 ] && printf '{"status":"noop","reason":"already-flushed","taskId":"%s"}\n' "$TASK_ID"
+  exit 0
+fi
+
+# The triage artefact is the only input either store needs, and it has two homes:
+# Phase 6 removes the worktree once the PR is open, so the salvaged copy under
+# artifactsPath is tried FIRST. Reading the worktree path first would degrade
+# silently for exactly the runs this script exists to rescue.
+TRIAGE=""
+for cand in "${ARTIFACTS:+$ARTIFACTS/triage-output.json}" "${WORKTREE:+$WORKTREE/triage-output.json}"; do
+  [ -n "$cand" ] && [ -f "$cand" ] && { TRIAGE="$cand"; break; }
+done
+
+INGESTED="skipped"
+DISTILLED="skipped"
+
+# Both writes are idempotent by contract, which is what makes calling this at
+# every phase boundary safe: the second call through writes 0 rows.
+#
+# And 0 rows is a SUCCESS here. Both tools exit 2 on "nothing new", which is the
+# normal outcome of every flush after the first - so exit 2 is folded into ok
+# rather than reported as failure. Treating it as failure would have made the
+# steady state of this script look broken.
+run_store() {
+  local label="$1"; shift
+  local rc=0
+  "$@" >/dev/null 2>&1 || rc=$?
+  case "$rc" in
+    0) printf 'ok' ;;
+    2) printf 'ok-nothing-new' ;;
+    *) printf 'failed(%s)' "$rc" ;;
+  esac
+}
+
+if [ -n "$TRIAGE" ]; then
+  INGESTED=$(run_store ingest \
+    node "$SCRIPTS/triage-memory.mjs" ingest --triage "$TRIAGE" --state "$STATE")
+  if [ -n "$TASK_ID" ]; then
+    DISTILLED=$(run_store distill \
+      node "$SCRIPTS/learnings-ledger.mjs" from-triage --triage "$TRIAGE" --task "$TASK_ID")
+  fi
+fi
+
+if [ "$JSON" -eq 1 ]; then
+  printf '{"status":"flushed","taskId":"%s","triage":"%s","ingest":"%s","distill":"%s"}\n' \
+    "$TASK_ID" "${TRIAGE:-none}" "$INGESTED" "$DISTILLED"
+fi
+
+if [ -z "$TRIAGE" ]; then
+  say "capture-flush: ${TASK_ID:-run} has no triage output yet - nothing to flush"
+else
+  say "capture-flush: ${TASK_ID:-run} triage=$INGESTED ledger=$DISTILLED"
+fi
+exit 0

package/pipeline/scripts/capture-resume.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+#
+# capture-resume.sh  -  one line at session start when a run was left unfinished.
+#
+# Runs from the SessionStart hook. Its whole job is to say what is pending and
+# then get out of the way, so it is bound by three rules:
+#
+#   1. It never blocks. Exit 0 always, whatever it finds.
+#   2. It never calls a model, and it never reads a transcript.
+#   3. It prints at most a few lines. A session banner that scrolls is a banner
+#      the user learns to skip, which costs more than it saves.
+#
+# It answers two questions:
+#   - Is there a pipeline run that stopped before Phase 7? Name it and the resume
+#     command, because that run's work is recoverable and its findings are not
+#     yet in the durable stores until it flushes.
+#   - Is the pipeline's own observation queue stale? (>= REVIEW_DAYS since the
+#     last review, with at least one open observation.) Offer one line. The
+#     user's own work is never made to wait on it.
+#
+# Usage: ./capture-resume.sh [--json]
+
+set -uo pipefail
+
+JSON=0
+[ "${1:-}" = "--json" ] && JSON=1
+
+LOGS="$HOME/.claude/logs/multi-agent"
+PIPELINE_MEM="$HOME/.claude/memory/multi-agent/_pipeline"
+REVIEW_DAYS=7
+
+STALE_TASK=""
+STALE_PHASE=""
+
+if [ -d "$LOGS" ] && command -v jq >/dev/null 2>&1; then
+  # Newest by mtime, not by name: task ids do not sort chronologically.
+  NEWEST=$(find "$LOGS" -name agent-state.json -type f -maxdepth 4 -print0 2>/dev/null \
+    | xargs -0 ls -t 2>/dev/null | head -1)
+  if [ -n "$NEWEST" ] && [ -f "$NEWEST" ]; then
+    P7=$(jq -r '[.phases[]? | select((.id // "") == "7") | .status] | first // ""' "$NEWEST" 2>/dev/null)
+    STATUS=$(jq -r '.status // ""' "$NEWEST" 2>/dev/null)
+    if [ "$P7" != "completed" ] && [ "$STATUS" != "completed" ]; then
+      STALE_TASK=$(jq -r '.taskId // .jiraId // ""' "$NEWEST" 2>/dev/null)
+      STALE_PHASE=$(jq -r '.currentPhase // "?"' "$NEWEST" 2>/dev/null)
+    fi
+  fi
+fi
+
+REVIEW_DUE=0
+OPEN_OBS=0
+if [ -d "$PIPELINE_MEM/observations" ]; then
+  OPEN_OBS=$(grep -l '^status: open' "$PIPELINE_MEM/observations"/*.md 2>/dev/null | wc -l | tr -d ' ')
+  LAST_REVIEW_FILE="$PIPELINE_MEM/last-review-date.txt"
+  LAST=$(cat "$LAST_REVIEW_FILE" 2>/dev/null || echo "never")
+  if [ "${OPEN_OBS:-0}" -gt 0 ]; then
+    if [ "$LAST" = "never" ] || [ -z "$LAST" ]; then
+      REVIEW_DUE=1
+    else
+      # Date arithmetic without GNU date: compare epoch seconds, and treat an
+      # unparseable stamp as "due" rather than silently never reviewing again.
+      LAST_EPOCH=$(date -j -f "%Y-%m-%d" "$LAST" +%s 2>/dev/null \
+                || date -d "$LAST" +%s 2>/dev/null || echo "")
+      if [ -z "$LAST_EPOCH" ]; then
+        REVIEW_DUE=1
+      else
+        AGE_DAYS=$(( ( $(date +%s) - LAST_EPOCH ) / 86400 ))
+        [ "$AGE_DAYS" -ge "$REVIEW_DAYS" ] && REVIEW_DUE=1
+      fi
+    fi
+  fi
+fi
+
+if [ "$JSON" -eq 1 ]; then
+  printf '{"staleTask":"%s","stalePhase":"%s","openObservations":%s,"reviewDue":%s}\n' \
+    "$STALE_TASK" "$STALE_PHASE" "${OPEN_OBS:-0}" "$REVIEW_DUE"
+  exit 0
+fi
+
+if [ -n "$STALE_TASK" ]; then
+  printf 'multi-agent: %s stopped at Phase %s - `/multi-agent:resume` to continue, `/multi-agent:kill` to drop it.\n' \
+    "$STALE_TASK" "$STALE_PHASE"
+fi
+if [ "$REVIEW_DUE" -eq 1 ]; then
+  printf 'multi-agent: %s open pipeline observation(s), last review %s+ days ago - `/multi-agent:refactor backlog` when convenient.\n' \
+    "$OPEN_OBS" "$REVIEW_DAYS"
+fi
+exit 0

package/pipeline/scripts/crush-json.mjs

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+/**
+ * @file crush-json.mjs  -  summarise a JSON payload instead of truncating it.
+ *
+ * WHY THIS EXISTS
+ *
+ * `offload-ref.sh` writes a big payload to a file and leaves a stub in its
+ * place: a pointer plus the last N lines. For a log that is the right stub - the
+ * tail is where the failure is. For JSON it is close to worthless: the last
+ * twenty lines of a 200-element array are the final element and some closing
+ * brackets, which say nothing about the 199 above them. The reader gets a
+ * pointer and no shape, so either they open the whole file (paying for what the
+ * offload was meant to avoid) or they proceed uninformed.
+ *
+ * So: keep the shape and the outliers, drop the repetition.
+ *
+ * WHAT IS ALWAYS KEPT, whatever the budget
+ *
+ *   - anything whose text carries error, exception, failed, failure, critical,
+ *     fatal, denied, timeout - a summary that averages away the one failing
+ *     element is worse than no summary
+ *   - numeric outliers beyond two standard deviations, and length outliers
+ *   - the first and last elements, which is where a reader looks for the shape
+ *
+ * WHAT IS NEVER TOUCHED
+ *
+ *   - anything that is not JSON. Invalid input is returned byte-identical.
+ *   - arrays under 5 elements, and payloads under ~200 tokens: there is nothing
+ *     to win and a summary reads worse than the thing itself.
+ *   - code. Detected by extension and by content shape, and passed through.
+ *
+ * FAIL-OPEN, ALWAYS
+ *
+ * Any error, any parse failure, and - critically - any result that is not
+ * smaller than the input returns the ORIGINAL unchanged. A compressor that can
+ * grow its input is a compressor that will, on the one payload nobody tested.
+ *
+ * Usage:
+ *   ./crush-json.mjs <file>            summary on stdout
+ *   ./crush-json.mjs < payload.json    same, from stdin
+ *   ./crush-json.mjs <file> --stats    report the before/after sizes only
+ *
+ * Exit codes are the contract, because a caller cannot tell a summary from a
+ * passthrough by looking at the bytes:
+ *   0  crushed - the output is a summary
+ *   3  passed through - the output IS the input, unchanged
+ *   1  unusable arguments
+ *
+ * offload-ref.sh used to infer this by comparing lengths, and command
+ * substitution strips trailing newlines - so every non-JSON payload looked
+ * "shorter" and therefore crushed, and the stub would have carried the entire
+ * log it was meant to replace.
+ */
+
+import { readFileSync } from "node:fs";
+
+const argv = process.argv.slice(2);
+const STATS = argv.includes("--stats");
+const file = argv.find((a) => !a.startsWith("--"));
+
+const MIN_ARRAY = 5;
+const MIN_CHARS = 800; // ~200 tokens
+const SAMPLE = 3;
+const ALWAYS_KEEP =
+  /\b(error|errors|exception|failed|failure|critical|fatal|denied|timeout|refused)\b/i;
+
+function read() {
+  if (file) {
+    try {
+      return readFileSync(file, "utf8");
+    } catch {
+      return null;
+    }
+  }
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+/** Code is passed through: it has no repeated structure to summarise. */
+function looksLikeCode(text) {
+  if (file && /\.(swift|kt|java|js|mjs|ts|tsx|py|rb|go|rs|c|h|cpp|sh)$/i.test(file)) return true;
+  const codeish =
+    /^\s*(import |func |class |struct |def |function |const |let |var |package |#include)/m;
+  return codeish.test(text) && !/^\s*[[{]/.test(text.trim());
+}
+
+const isPrimitive = (v) => v === null || ["string", "number", "boolean"].includes(typeof v);
+
+function mean(ns) {
+  return ns.reduce((a, b) => a + b, 0) / ns.length;
+}
+function stdev(ns) {
+  const m = mean(ns);
+  return Math.sqrt(mean(ns.map((n) => (n - m) ** 2)));
+}
+
+/** Indices that must survive whatever else is dropped. */
+function protectedIndices(arr) {
+  const keep = new Set([0, arr.length - 1]);
+  const texts = arr.map((v) => (typeof v === "string" ? v : (JSON.stringify(v) ?? "")));
+  texts.forEach((t, i) => {
+    if (ALWAYS_KEEP.test(t)) keep.add(i);
+  });
+
+  const nums = arr.filter((v) => typeof v === "number");
+  if (nums.length >= MIN_ARRAY) {
+    const m = mean(nums);
+    const sd = stdev(nums);
+    if (sd > 0)
+      arr.forEach((v, i) => {
+        if (typeof v === "number" && Math.abs(v - m) > 2 * sd) keep.add(i);
+      });
+  }
+
+  const lens = texts.map((t) => t.length);
+  if (lens.length >= MIN_ARRAY) {
+    const m = mean(lens);
+    const sd = stdev(lens);
+    if (sd > 0)
+      lens.forEach((l, i) => {
+        if (Math.abs(l - m) > 2 * sd) keep.add(i);
+      });
+  }
+  return keep;
+}
+
+function crushNumberArray(arr, keep) {
+  const sorted = arr.slice().sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return {
+    _crushed: `${arr.length} numbers`,
+    min: sorted[0],
+    max: sorted[sorted.length - 1],
+    mean: Number(mean(arr).toFixed(3)),
+    median: sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2,
+    kept: [...keep].sort((a, b) => a - b).map((i) => arr[i]),
+  };
+}
+
+function crushStringArray(arr, keep) {
+  const counts = new Map();
+  for (const s of arr) counts.set(s, (counts.get(s) || 0) + 1);
+  const distinct = [...counts.entries()].sort((a, b) => b[1] - a[1]);
+  return {
+    _crushed: `${arr.length} strings, ${counts.size} distinct`,
+    top: distinct.slice(0, SAMPLE).map(([v, n]) => (n > 1 ? `${v} (x${n})` : v)),
+    kept: [...keep].sort((a, b) => a - b).map((i) => arr[i]),
+  };
+}
+
+/**
+ * Object arrays are the common shape (a gh api page, an accessibility tree, a
+ * findings list). Fields whose value is the same everywhere are stated once;
+ * fields that vary are sampled.
+ */
+function crushObjectArray(arr, keep) {
+  const fields = new Map();
+  for (const o of arr) {
+    for (const [k, v] of Object.entries(o || {})) {
+      if (!fields.has(k)) fields.set(k, { vals: new Set(), seen: 0 });
+      const f = fields.get(k);
+      f.seen += 1;
+      if (f.vals.size <= 4) f.vals.add(isPrimitive(v) ? String(v) : "«nested»");
+    }
+  }
+  const constant = {};
+  const varying = [];
+  const sparse = {};
+  for (const [k, { vals, seen }] of fields) {
+    // "Constant" has to mean constant ACROSS THE WHOLE ARRAY. One value seen
+    // once is not a property of 60 rows: a `message` field that existed only on
+    // the single failing element was being reported as though every row carried
+    // it, which is the exact way a summary misleads worse than a truncation.
+    if (vals.size === 1 && seen === arr.length) constant[k] = [...vals][0];
+    else if (seen < arr.length) sparse[k] = `${seen}/${arr.length}`;
+    else varying.push(k);
+  }
+  const out = {
+    _crushed: `${arr.length} objects`,
+    constantFields: constant,
+    varyingFields: varying,
+    kept: [...keep].sort((a, b) => a - b).map((i) => arr[i]),
+  };
+  // Fields only some elements carry, with how many carry them - the presence
+  // itself is often the signal (only failures have `message`).
+  if (Object.keys(sparse).length) out.partialFields = sparse;
+  return out;
+}
+
+function crushValue(v) {
+  if (Array.isArray(v)) {
+    if (v.length < MIN_ARRAY) return v.map(crushValue);
+    const keep = protectedIndices(v);
+    if (v.every((x) => typeof x === "number")) return crushNumberArray(v, keep);
+    if (v.every((x) => typeof x === "string")) return crushStringArray(v, keep);
+    if (v.every((x) => typeof x === "boolean")) return v; // nothing to win
+    if (v.every((x) => x && typeof x === "object" && !Array.isArray(x))) {
+      return crushObjectArray(v, keep);
+    }
+    return {
+      _crushed: `${v.length} mixed items`,
+      kept: [...keep].sort((a, b) => a - b).map((i) => crushValue(v[i])),
+    };
+  }
+  if (v && typeof v === "object") {
+    const out = {};
+    for (const [k, val] of Object.entries(v)) out[k] = crushValue(val);
+    return out;
+  }
+  return v;
+}
+
+const original = read();
+if (original === null) {
+  process.stderr.write(`ERR: cannot read ${file}\n`);
+  process.exit(1);
+}
+
+function emit(text, note) {
+  const crushed = note === "crushed";
+  if (STATS) {
+    process.stdout.write(
+      JSON.stringify({
+        before: original.length,
+        after: text.length,
+        crushed,
+        reason: note || null,
+      }) + "\n",
+    );
+  } else if (crushed) {
+    process.stdout.write(text.endsWith("\n") ? text : text + "\n");
+  } else {
+    // Passthrough means byte-identical. Adding a trailing newline the input did
+    // not have is a small lie, and it is the kind that makes a caller's diff
+    // disagree with its own contract.
+    process.stdout.write(text);
+  }
+  // `process.exitCode`, never `process.exit()`. stdout to a PIPE is async, and
+  // exiting immediately after a large write truncates it at the pipe buffer -
+  // a 271 KB summary arrived as exactly 65536 bytes, silently, and only when
+  // the caller piped rather than redirected. Setting the code lets the write
+  // drain and the process end on its own.
+  process.exitCode = crushed ? 0 : 3;
+}
+
+// The decision chain lives in a function so each branch can RETURN. emit() no
+// longer exits - it cannot, without truncating a large write to a pipe - so a
+// straight-line version would fall through every branch and crush a payload it
+// had already decided to pass through.
+function main() {
+  if (!original.trim()) return emit(original, "empty");
+  if (original.length < MIN_CHARS) return emit(original, "below-threshold");
+  if (looksLikeCode(original)) return emit(original, "code-passthrough");
+
+  let parsed;
+  try {
+    parsed = JSON.parse(original);
+  } catch {
+    return emit(original, "not-json");
+  }
+
+  let out;
+  try {
+    out = JSON.stringify(crushValue(parsed), null, 2);
+  } catch {
+    return emit(original, "crush-threw");
+  }
+
+  // Never hand back something bigger than what came in - and never claim a
+  // crush for a saving too small to matter. A deeply nested payload with few
+  // arrays came back one byte shorter, which is not a summary, it is a rewrite
+  // of a readable thing for nothing.
+  const MIN_GAIN = 0.15;
+  if (!out || out.length >= original.length * (1 - MIN_GAIN)) {
+    return emit(original, "no-gain");
+  }
+  return emit(out, "crushed");
+}
+
+main();

package/pipeline/scripts/firebase-app-discovery.sh

@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+#
+# firebase-app-discovery.sh  -  read the Firebase app ids a repo already carries.
+#
+# Every Crashlytics call needs the opaque appId (1:<number>:<platform>:<hex>), and
+# a console URL only ever carries the bundle id. fetch-crashlytics.sh resolves the
+# pair through the Firebase Management API on every run, which works and costs a
+# round trip plus a resolved project. The repo has already been told the answer:
+# GoogleService-Info*.plist (iOS) and google-services.json (Android) are generated
+# by the console and carry both ids.
+#
+# Usage:
+#   ./firebase-app-discovery.sh [repo-dir]            # table
+#   ./firebase-app-discovery.sh [repo-dir] --json     # {"accounts":[...]}
+#
+# --json prints entries shaped for prefs.global.firebase.accounts[]: one per
+# projectId, each with an apps[] of {bundleId, appId, platform}. keychainKey is
+# left out on purpose - which credential covers a project is the user's mapping to
+# make, not this script's to guess.
+#
+# A repo with several targets has several plists and they do not all point at one
+# Firebase project: every match is read, never just the first. Build outputs are
+# skipped, because a copied plist under DerivedData or build/ is the same app
+# counted twice.
+#
+# Exit 0 always: finding nothing is an answer, not a failure.
+
+set -uo pipefail
+
+DIR="."
+MODE="table"
+for a in "$@"; do
+  case "$a" in
+    --json) MODE="json" ;;
+    -h|--help) echo "usage: $0 [repo-dir] [--json]" >&2; exit 0 ;;
+    *) DIR="$a" ;;
+  esac
+done
+
+if [ ! -d "$DIR" ]; then
+  echo "ERR: not a directory: $DIR" >&2
+  exit 0
+fi
+
+FILES=$(find "$DIR" \
+  \( -name node_modules -o -name Pods -o -name .build -o -name DerivedData \
+     -o -name build -o -name .git -o -name .next \) -prune -o \
+  \( -name 'GoogleService-Info*.plist' -o -name 'google-services.json' \) -print 2>/dev/null)
+
+# The file list travels as an env var, not on stdin: `python3 - <<SCRIPT` already
+# takes its program from stdin, and a second redirection silently wins, feeding
+# the interpreter the paths as if they were source.
+MODE="$MODE" FB_FILES="$FILES" python3 - "$DIR" <<'PY'
+import json, os, plistlib, sys
+
+repo = sys.argv[1]
+paths = [p for p in os.environ.get("FB_FILES", "").split("\n") if p.strip()]
+
+# projectId -> {bundleId: (appId, platform)}; a dict per project because the same
+# target can appear twice (a Debug and a Release plist naming one app), and the
+# second read must not double the row.
+projects = {}
+
+def record(project, bundle, app_id, platform):
+    if not (project and bundle and app_id):
+        return
+    projects.setdefault(project, {})[bundle] = (app_id, platform)
+
+for path in paths:
+    try:
+        if path.endswith(".plist"):
+            with open(path, "rb") as fh:
+                d = plistlib.load(fh)
+            app_id = d.get("GOOGLE_APP_ID") or ""
+            platform = "android" if ":android:" in app_id else "ios"
+            record(d.get("PROJECT_ID"), d.get("BUNDLE_ID"), app_id, platform)
+        else:
+            with open(path, encoding="utf-8") as fh:
+                d = json.load(fh)
+            project = ((d.get("project_info") or {}).get("project_id")) or ""
+            for client in d.get("client") or []:
+                info = client.get("client_info") or {}
+                app_id = info.get("mobilesdk_app_id") or ""
+                bundle = ((info.get("android_client_info") or {}).get("package_name")) or ""
+                record(project, bundle, app_id, "android")
+    except Exception:
+        # A malformed or unreadable file is one app not discovered, never a reason
+        # to abandon the ones that parsed.
+        continue
+
+accounts = [
+    {
+        "projectId": pid,
+        "apps": [
+            {"bundleId": b, "appId": a, "platform": pf}
+            for b, (a, pf) in sorted(apps.items())
+        ],
+    }
+    for pid, apps in sorted(projects.items())
+]
+
+if os.environ.get("MODE") == "json":
+    print(json.dumps({"accounts": accounts}, indent=2))
+    sys.exit(0)
+
+if not accounts:
+    print("no Firebase config found under %s" % repo)
+    sys.exit(0)
+
+for acc in accounts:
+    print(acc["projectId"])
+    for app in acc["apps"]:
+        print("  %-8s %-45s %s" % (app["platform"], app["bundleId"], app["appId"]))
+PY

package/pipeline/scripts/keychain-save.sh

@@ -39,13 +39,15 @@ case "$CHOICE" in
             echo "Hata: Dosya bulunamadı: $JSON_PATH"
             exit 1
         fi
-        # JSON'ı tek satıra sıkıştırıp base64'le
-        SECRET=$(base64 < "$JSON_PATH")
+        # JSON olduğu gibi saklanır. Kimlik deposu çok satırlı değeri
+        # bayt bayt geri verir; base64 sarmalı okuma tarafında çözülmeyen
+        # bir katman ekliyordu.
+        SECRET=$(cat "$JSON_PATH")
         if [ -z "$SECRET" ]; then
             echo "Hata: Dosya okunamadı."
             exit 1
         fi
-        echo "JSON base64 olarak encode edildi."
+        echo "JSON olduğu gibi saklanacak."
         ;;
     *)
         echo "Geçersiz seçim."
@@ -89,11 +91,6 @@ if printf '%s' "$SECRET" | "$CRED" set "$SERVICE_NAME" -; then
     echo ""
     echo "Okumak icin:"
     echo "  $CRED get \"$SERVICE_NAME\""
-    if [ "$CHOICE" = "2" ]; then
-        echo ""
-        echo "JSON'a geri cevirmek icin:"
-        echo "  $CRED get \"$SERVICE_NAME\" | base64 -d"
-    fi
 else
     echo "Hata: Kaydedilemedi."
     exit 1