session-orchestrator 3.16.0

package/scripts/migrate-cold-start-seed.mjs

@@ -0,0 +1,404 @@
+#!/usr/bin/env node
+/**
+ * migrate-cold-start-seed.mjs — one-shot seeder for the welcome-banner-pending marker.
+ *
+ * Part of the Learning-Memory Modernization initiative (epic #498, issue #507).
+ *
+ * Seeds a zero-byte `.orchestrator/welcome-banner-pending` marker file in dormant
+ * repos so the cold-start detector can emit a welcome banner on the next
+ * Claude Code open. The marker is intentionally untracked (lives under
+ * `.orchestrator/`, which is typically gitignored) and auto-deletes on first
+ * session-end.
+ *
+ * Idempotency rules — a repo is SKIPPED when any of these hold:
+ *   - The marker file already exists (`.orchestrator/welcome-banner-pending`).
+ *   - The repo has at least one session recorded in
+ *     `.orchestrator/metrics/sessions.jsonl` (i.e. it is not dormant).
+ *   - The `.orchestrator/` directory is missing entirely (defensive — the
+ *     bootstrap-gate has not run yet, marker would land in the wrong place).
+ *
+ * Repos missing a `.git/` directory are still seeded — the marker lives
+ * outside git anyway.
+ *
+ * Usage:
+ *   node scripts/migrate-cold-start-seed.mjs [--dry-run|--apply] [--repos <comma,list>] [--json] [--help]
+ *
+ * Target repo resolution (in priority order):
+ *   1. --repos <comma,list>             (explicit CLI override)
+ *   2. dormant-repos: [...] in
+ *      ~/.config/session-orchestrator/vault-migration-rules.yaml
+ *   3. <none> → fail with non-zero exit and a hint to the config file.
+ *
+ * Flags:
+ *   --dry-run        Classify each target repo, do not write anything (DEFAULT).
+ *   --apply          Write the marker file to each eligible repo.
+ *   --repos <list>   Comma-separated repo paths (absolute or ~-prefixed).
+ *   --json           Emit one JSON record per repo plus a final summary record.
+ *   --help, -h       Print this help text to stderr and exit 0.
+ *
+ * Exit codes:
+ *   0  Success (even when 0 repos were seeded — idempotent NO-OP is fine).
+ *   1  Input/argument error (incl. no targets given anywhere).
+ *   2  I/O error (filesystem failure mid-apply).
+ *
+ * Output (stdout — unless --json):
+ *   migrate-cold-start-seed: <abbrev-path>: <status> [dry-run|applied]
+ *
+ * Summary line (stderr):
+ *   migrate-cold-start-seed: N seeded, M already-seeded, K skipped [dry-run|applied]
+ */
+
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { promises as fs } from 'node:fs';
+import {
+  loadVaultMigrationRules,
+  VAULT_MIGRATION_RULES_PATH,
+} from './lib/vault-migration-rules.mjs';
+import { parseColumnFlags, CliFlagError } from './lib/cli-flags.mjs';
+
+const MARKER_REL = '.orchestrator/welcome-banner-pending';
+const ORCH_REL = '.orchestrator';
+const SESSIONS_REL = '.orchestrator/metrics/sessions.jsonl';
+
+// ---------------------------------------------------------------------------
+// Arg parsing
+// ---------------------------------------------------------------------------
+
+// CLI parsing via the shared helper (#510). Migrated from the previous
+// ad-hoc args.includes()/knownFlags-Set pattern — same behaviour, single
+// source for unknown-flag rejection (exit 1) and `--json`/`--dry-run`/`--apply`
+// conventions. Per-script semantics (mutex check, --repos comma-split done
+// at the use site) remain in this file.
+let parsedFlags;
+try {
+  parsedFlags = parseColumnFlags({
+    knownBool: {
+      apply: false,
+      'dry-run': false,
+      json: false,
+      help: { short: 'h', default: false },
+    },
+    knownString: { repos: null },
+  });
+} catch (err) {
+  if (err instanceof CliFlagError) {
+    // Preserve the legacy "unknown flag" prose (the prior knownFlags-Set
+    // implementation used that wording; tests at
+    // tests/scripts/migrate-cold-start-seed.test.mjs assert against it).
+    // node:util parseArgs emits "Unknown option '--foo'" — map to legacy.
+    const legacy = err.message.replace(/^Unknown option/, 'unknown flag');
+    process.stderr.write(`migrate-cold-start-seed: ${legacy}\n`);
+    process.exit(1);
+  }
+  throw err;
+}
+
+const helpFlag = parsedFlags.values.help === true;
+if (helpFlag) {
+  process.stderr.write(`Usage: migrate-cold-start-seed.mjs [--dry-run|--apply] [--repos <comma,list>] [--json] [--help]
+
+Seeds a zero-byte .orchestrator/welcome-banner-pending marker in dormant repos
+so the cold-start detector can emit a welcome banner on the next Claude Code
+open. The marker is untracked and auto-deletes on first session-end.
+
+Options:
+  --dry-run        Classify each target repo, do not write anything (DEFAULT).
+  --apply          Write the marker file to each eligible repo.
+  --repos <list>   Comma-separated repo paths (absolute or ~-prefixed).
+                   When omitted, falls back to dormant-repos: [...] in
+                   ~/.config/session-orchestrator/vault-migration-rules.yaml.
+  --json           Emit one JSON record per repo plus a final summary record.
+  --help, -h       Print this help text to stderr and exit 0.
+
+Idempotency — a repo is SKIPPED when any of these hold:
+  - The marker already exists.
+  - sessions.jsonl has at least one line (repo is not dormant).
+  - The .orchestrator/ directory is missing (bootstrap-gate has not run).
+
+Repos without a .git/ directory are still seeded — the marker lives outside
+git anyway.
+
+Examples:
+  # Default dry-run against the 6 hardcoded repos
+  node scripts/migrate-cold-start-seed.mjs
+
+  # Apply to the default repo list
+  node scripts/migrate-cold-start-seed.mjs --apply
+
+  # Dry-run against a custom repo list, JSON output
+  node scripts/migrate-cold-start-seed.mjs --repos ~/foo,~/bar --json
+
+Exit codes:  0 success  1 input error  2 I/O error
+`);
+  process.exit(0);
+}
+
+const applyFlag = parsedFlags.values.apply === true;
+const dryRunFlag = parsedFlags.values['dry-run'] === true;
+const jsonFlag = parsedFlags.values.json === true;
+
+if (applyFlag && dryRunFlag) {
+  process.stderr.write('migrate-cold-start-seed: --dry-run and --apply are mutually exclusive\n');
+  process.exit(1);
+}
+
+// Default is dry-run (matches scripts/migrate-learnings-jsonl.mjs convention).
+const dryRun = !applyFlag;
+
+// `--repos` is kept as the raw comma-separated string here (split later, at
+// the use site below). Preserves the legacy "null when omitted" contract that
+// downstream branches depend on.
+const reposArg = parsedFlags.values.repos ?? null;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function resolveHome(p) {
+  if (p === '~') return homedir();
+  if (p.startsWith('~/')) return join(homedir(), p.slice(2));
+  return p;
+}
+
+function abbrevPath(p) {
+  const home = homedir();
+  if (p === home) return '~';
+  if (p.startsWith(home + '/')) return '~' + p.slice(home.length);
+  return p;
+}
+
+async function pathExists(p) {
+  try {
+    await fs.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function isDir(p) {
+  try {
+    const st = await fs.stat(p);
+    return st.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function sessionsHasContent(sessionsPath) {
+  try {
+    const raw = await fs.readFile(sessionsPath, 'utf8');
+    return raw.split('\n').some((l) => l.trim().length > 0);
+  } catch (err) {
+    if (err.code === 'ENOENT') return false;
+    throw err;
+  }
+}
+
+/**
+ * Classify a single repo and (when applying) write the marker atomically.
+ * Returns { repo, status, gitTracked, reason? }.
+ *
+ * Possible statuses:
+ *   already-seeded            marker already exists
+ *   skip-active               sessions.jsonl has ≥1 line
+ *   skip-not-bootstrapped     .orchestrator/ missing
+ *   skip-permission-denied    fs error reading/writing
+ *   skip-missing              repo path itself does not exist
+ *   would-seed                dry-run, marker absent and eligible
+ *   seeded                    --apply, marker successfully written
+ */
+async function processRepo(repo, { apply }) {
+  const repoExists = await isDir(repo);
+  if (!repoExists) {
+    return { repo, status: 'skip-missing', gitTracked: false, reason: 'repo path does not exist' };
+  }
+
+  const gitTracked = await isDir(join(repo, '.git'));
+
+  const orchDir = join(repo, ORCH_REL);
+  const orchExists = await isDir(orchDir);
+  if (!orchExists) {
+    return { repo, status: 'skip-not-bootstrapped', gitTracked, reason: '.orchestrator/ missing' };
+  }
+
+  const markerPath = join(repo, MARKER_REL);
+  let markerExists;
+  try {
+    markerExists = await pathExists(markerPath);
+  } catch (err) {
+    return {
+      repo,
+      status: 'skip-permission-denied',
+      gitTracked,
+      reason: `stat marker: ${err.message}`,
+    };
+  }
+
+  if (markerExists) {
+    return { repo, status: 'already-seeded', gitTracked };
+  }
+
+  // Sessions.jsonl liveness check — even if marker is absent, an active repo
+  // should not get a "welcome" banner.
+  const sessionsPath = join(repo, SESSIONS_REL);
+  try {
+    if (await sessionsHasContent(sessionsPath)) {
+      return { repo, status: 'skip-active', gitTracked, reason: 'sessions.jsonl has ≥1 line' };
+    }
+  } catch (err) {
+    if (err.code === 'EACCES' || err.code === 'EPERM') {
+      return {
+        repo,
+        status: 'skip-permission-denied',
+        gitTracked,
+        reason: `read sessions.jsonl: ${err.message}`,
+      };
+    }
+    // Any other error: surface as I/O failure.
+    throw err;
+  }
+
+  if (!apply) {
+    return { repo, status: 'would-seed', gitTracked };
+  }
+
+  // --apply: write zero-byte marker atomically (tmp + rename).
+  try {
+    await fs.mkdir(dirname(markerPath), { recursive: true });
+    const tmp = `${markerPath}.tmp-${process.pid}-${Date.now()}`;
+    await fs.writeFile(tmp, '', { encoding: 'utf8', flag: 'wx' });
+    await fs.rename(tmp, markerPath);
+  } catch (err) {
+    if (err.code === 'EACCES' || err.code === 'EPERM') {
+      return {
+        repo,
+        status: 'skip-permission-denied',
+        gitTracked,
+        reason: `write marker: ${err.message}`,
+      };
+    }
+    // Hard I/O failure — abort with exit 2.
+    process.stderr.write(
+      `migrate-cold-start-seed: ERROR failed to write ${markerPath}: ${err.message}\n`
+    );
+    process.exit(2);
+  }
+
+  return { repo, status: 'seeded', gitTracked };
+}
+
+// ---------------------------------------------------------------------------
+// Resolve target repo list
+// ---------------------------------------------------------------------------
+
+let targetRepos;
+if (reposArg) {
+  targetRepos = reposArg
+    .split(',')
+    .map((r) => r.trim())
+    .filter((r) => r.length > 0)
+    .map(resolveHome);
+
+  if (targetRepos.length === 0) {
+    process.stderr.write('migrate-cold-start-seed: --repos given but empty after parsing\n');
+    process.exit(1);
+  }
+} else {
+  const { config, errors } = loadVaultMigrationRules();
+  for (const e of errors) {
+    process.stderr.write(`migrate-cold-start-seed: config: ${e}\n`);
+  }
+  if (config.dormantRepos.length === 0) {
+    process.stderr.write(
+      'migrate-cold-start-seed: no target repos.\n' +
+        `  Either pass --repos <comma,list>, or list paths under 'dormant-repos:' in\n` +
+        `  ${VAULT_MIGRATION_RULES_PATH}\n`
+    );
+    process.exit(1);
+  }
+  targetRepos = config.dormantRepos.map(resolveHome);
+}
+
+// ---------------------------------------------------------------------------
+// Main loop
+// ---------------------------------------------------------------------------
+
+const modeLabel = dryRun ? 'dry-run' : 'applied';
+const results = [];
+
+for (const repo of targetRepos) {
+  const result = await processRepo(repo, { apply: !dryRun });
+  results.push(result);
+
+  const shortPath = abbrevPath(result.repo);
+  const reasonSuffix = result.reason ? ` (${result.reason})` : '';
+
+  if (jsonFlag) {
+    process.stdout.write(
+      JSON.stringify({
+        kind: 'repo',
+        repo: result.repo,
+        short: shortPath,
+        status: result.status,
+        gitTracked: result.gitTracked,
+        reason: result.reason ?? null,
+        mode: modeLabel,
+      }) + '\n'
+    );
+  } else {
+    process.stdout.write(
+      `migrate-cold-start-seed: ${shortPath}: ${result.status}${reasonSuffix} [${modeLabel}]\n`
+    );
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Summary
+// ---------------------------------------------------------------------------
+
+const counts = {
+  seeded: 0,
+  'would-seed': 0,
+  'already-seeded': 0,
+  'skip-active': 0,
+  'skip-not-bootstrapped': 0,
+  'skip-permission-denied': 0,
+  'skip-missing': 0,
+};
+for (const r of results) {
+  counts[r.status] = (counts[r.status] ?? 0) + 1;
+}
+
+// "seeded" reflects actual writes in --apply mode; in --dry-run we surface
+// "would-seed" as the actionable count.
+const seededCount = dryRun ? counts['would-seed'] : counts['seeded'];
+const alreadySeeded = counts['already-seeded'];
+const skipped =
+  counts['skip-active'] +
+  counts['skip-not-bootstrapped'] +
+  counts['skip-permission-denied'] +
+  counts['skip-missing'];
+
+const summaryLine =
+  `migrate-cold-start-seed: ${seededCount} ${dryRun ? 'would-seed' : 'seeded'}, ` +
+  `${alreadySeeded} already-seeded, ${skipped} skipped [${modeLabel}]`;
+
+if (jsonFlag) {
+  process.stdout.write(
+    JSON.stringify({
+      kind: 'summary',
+      mode: modeLabel,
+      counts,
+      seeded: seededCount,
+      alreadySeeded,
+      skipped,
+      total: results.length,
+    }) + '\n'
+  );
+}
+
+process.stderr.write(summaryLine + '\n');
+
+process.exit(0);

package/scripts/migrate-learnings-jsonl.mjs

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+/**
+ * migrate-learnings-jsonl.mjs — one-shot migration helper for learnings.jsonl.
+ *
+ * Fixes schema drift described in issue #303:
+ *   - description | recommendation → insight
+ *   - missing id → crypto.randomUUID()
+ *   - missing schema_version → 1
+ *
+ * Usage:
+ *   node scripts/migrate-learnings-jsonl.mjs [--source <path>] [--dry-run] [--apply]
+ *
+ * Flags:
+ *   --source <path>   Path to learnings.jsonl (default: .orchestrator/metrics/learnings.jsonl)
+ *   --dry-run         Preview changes without writing (DEFAULT)
+ *   --apply           Write migrated records back to the file
+ *
+ * Exit codes:
+ *   0  Success (including no-op if everything is already canonical)
+ *   1  Input/validation error
+ *   2  I/O error
+ *
+ * Idempotent: running --apply a second time produces no further changes.
+ *
+ * Output (stdout — one JSON object per line):
+ *   {"action":"migrated"|"already-canonical","id":"...","changes":[...]}
+ *
+ * Summary line (stderr):
+ *   migrate-learnings: N migrated, M already-canonical, K failed-validation [dry-run|applied]
+ */
+
+import { existsSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import {
+  migrateLegacyLearning,
+  validateLearning,
+  ValidationError,
+} from './lib/learnings.mjs';
+
+// ---------------------------------------------------------------------------
+// Arg parsing
+// ---------------------------------------------------------------------------
+
+const args = process.argv.slice(2);
+const helpFlag = args.includes('--help') || args.includes('-h');
+if (helpFlag) {
+  process.stdout.write(`Usage: migrate-learnings-jsonl.mjs [--source <path>] [--dry-run] [--apply]
+
+Options:
+  --source <path>   Path to learnings.jsonl (default: .orchestrator/metrics/learnings.jsonl)
+  --dry-run         Preview changes without writing (DEFAULT)
+  --apply           Write migrated records back to the file
+
+Exit codes:  0 success  1 input error  2 I/O error
+`);
+  process.exit(0);
+}
+
+const applyFlag = args.includes('--apply');
+const dryRun = !applyFlag; // default is --dry-run
+
+const sourceIdx = args.indexOf('--source');
+const sourcePath =
+  sourceIdx !== -1 && args[sourceIdx + 1]
+    ? args[sourceIdx + 1]
+    : '.orchestrator/metrics/learnings.jsonl';
+
+// ---------------------------------------------------------------------------
+// Load
+// ---------------------------------------------------------------------------
+
+if (!existsSync(sourcePath)) {
+  process.stderr.write(`migrate-learnings: source file not found: ${sourcePath}\n`);
+  process.exit(1);
+}
+
+let raw;
+try {
+  raw = readFileSync(sourcePath, 'utf8');
+} catch (err) {
+  process.stderr.write(`migrate-learnings: failed to read ${sourcePath}: ${err.message}\n`);
+  process.exit(2);
+}
+
+const lines = raw.split('\n').filter((l) => l.trim().length > 0);
+
+// ---------------------------------------------------------------------------
+// Migrate
+// ---------------------------------------------------------------------------
+
+let countMigrated = 0;
+let countCanonical = 0;
+let countFailedValidation = 0;
+let countMalformed = 0;
+
+const outputLines = [];
+
+for (const line of lines) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    countMalformed++;
+    process.stderr.write(`migrate-learnings: WARN skipping malformed JSON line: ${line.slice(0, 80)}\n`);
+    // Preserve the original malformed line as-is (do not discard data)
+    outputLines.push(line);
+    continue;
+  }
+
+  // Detect which fields need migration
+  const changes = [];
+  if (!parsed.id) changes.push('id:added');
+  if (!parsed.insight) {
+    if (typeof parsed.description === 'string') changes.push('description→insight');
+    else if (typeof parsed.recommendation === 'string') changes.push('recommendation→insight');
+  }
+  if (parsed.schema_version === undefined || parsed.schema_version === null) {
+    changes.push('schema_version:1');
+  }
+
+  const migrated = migrateLegacyLearning(parsed);
+
+  // Validate after migration — records that still fail after migration are
+  // preserved in-place (no data loss) but flagged in the summary.
+  let validated;
+  try {
+    // Stamp schema_version before validation so appendLearning-style stamping
+    // is mimicked (migrateLegacyLearning already does this, but be explicit).
+    validated = validateLearning({
+      ...migrated,
+      schema_version: migrated.schema_version ?? 1,
+    });
+  } catch (err) {
+    countFailedValidation++;
+    const reason = err instanceof ValidationError ? err.message : String(err);
+    process.stderr.write(
+      `migrate-learnings: WARN record id=${parsed.id ?? '<no id>'} still fails validation after migration: ${reason}\n`
+    );
+    // Preserve original line — do not destroy unmigratable records
+    outputLines.push(line);
+    process.stdout.write(
+      JSON.stringify({ action: 'failed-validation', id: parsed.id ?? null, reason, changes }) + '\n'
+    );
+    continue;
+  }
+
+  if (changes.length === 0) {
+    countCanonical++;
+    outputLines.push(JSON.stringify(validated));
+    process.stdout.write(JSON.stringify({ action: 'already-canonical', id: validated.id }) + '\n');
+  } else {
+    countMigrated++;
+    outputLines.push(JSON.stringify(validated));
+    process.stdout.write(JSON.stringify({ action: 'migrated', id: validated.id, changes }) + '\n');
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Write (--apply only)
+// ---------------------------------------------------------------------------
+
+const modeLabel = dryRun ? 'dry-run' : 'applied';
+
+if (!dryRun) {
+  const body = outputLines.join('\n') + '\n';
+  const tmp = `${sourcePath}.migrate-tmp-${process.pid}-${Date.now()}`;
+  try {
+    mkdirSync(dirname(sourcePath), { recursive: true });
+    writeFileSync(tmp, body, 'utf8');
+    renameSync(tmp, sourcePath);
+  } catch (err) {
+    process.stderr.write(`migrate-learnings: ERROR failed to write ${sourcePath}: ${err.message}\n`);
+    // Attempt cleanup of tmp
+    try { if (existsSync(tmp)) renameSync(tmp, tmp + '.failed'); } catch { /* ignore */ }
+    process.exit(2);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Summary
+// ---------------------------------------------------------------------------
+
+process.stderr.write(
+  `migrate-learnings: ${countMigrated} migrated, ${countCanonical} already-canonical, ` +
+  `${countFailedValidation} failed-validation, ${countMalformed} malformed [${modeLabel}]\n`
+);
+
+process.exit(countFailedValidation > 0 ? 1 : 0);

package/scripts/migrate-legacy-learnings.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+set -euo pipefail
+# Migrate learnings from platform-specific paths (.claude/.codex/.cursor) to the
+# canonical .orchestrator/metrics/learnings.jsonl. Idempotent; backs up each
+# legacy file as <path>.migrated-YYYY-MM-DD.bak.
+
+ROOT="${1:-$(pwd)}"
+CANONICAL="$ROOT/.orchestrator/metrics/learnings.jsonl"
+TODAY="$(date +%Y-%m-%d)"
+LEGACY_PATHS=("$ROOT/.claude/metrics/learnings.jsonl" "$ROOT/.codex/metrics/learnings.jsonl" "$ROOT/.cursor/metrics/learnings.jsonl")
+
+tmp=""
+cleanup() { [[ -n "$tmp" && -f "$tmp" ]] && rm -f "$tmp"; [[ -f "${CANONICAL}.tmp" ]] && rm -f "${CANONICAL}.tmp"; return 0; }
+trap cleanup EXIT
+
+existing_legacy=()
+for p in "${LEGACY_PATHS[@]}"; do [[ -f "$p" ]] && existing_legacy+=("$p"); done
+
+canonical_before=0
+[[ -f "$CANONICAL" ]] && canonical_before=$(wc -l < "$CANONICAL" | tr -d ' ')
+
+if [[ ${#existing_legacy[@]} -eq 0 ]]; then
+  printf '{"canonical_before":%d,"legacy":0,"canonical_after":%d,"backup":null,"status":"no_legacy"}\n' \
+    "$canonical_before" "$canonical_before"
+  exit 0
+fi
+
+legacy_total=0
+for p in "${existing_legacy[@]}"; do legacy_total=$(( legacy_total + $(wc -l < "$p" | tr -d ' ') )); done
+
+# Dedupe contract: collapse by id (keep one), then by (type, subject) keeping the
+# entry with higher confidence — created_at breaks ties (later wins).
+DEDUP_JQ='group_by(.id) | map(max_by(.confidence))
+  | group_by([.type, .subject])
+  | map(if length == 1 then .[0] else sort_by(.confidence, .created_at) | last end)
+  | .[]'
+
+mkdir -p "$(dirname "$CANONICAL")"
+tmp="$CANONICAL.merge.tmp"
+: > "$tmp"
+[[ -f "$CANONICAL" ]] && cat "$CANONICAL" >> "$tmp"
+for p in "${existing_legacy[@]}"; do cat "$p" >> "$tmp"; done
+jq -sc "$DEDUP_JQ" "$tmp" > "$CANONICAL.tmp"
+mv "$CANONICAL.tmp" "$CANONICAL"
+rm -f "$tmp"
+canonical_after=$(wc -l < "$CANONICAL" | tr -d ' ')
+
+# Back up each legacy file, then emit the list as a JSON array
+bak_list=()
+for p in "${existing_legacy[@]}"; do
+  bak="${p}.migrated-${TODAY}.bak"
+  mv "$p" "$bak"
+  bak_list+=("$bak")
+done
+bak_json=$(printf '%s\n' "${bak_list[@]}" | jq -Rs 'split("\n") | map(select(. != ""))')
+
+status="merged"
+[[ "$canonical_before" -eq 0 ]] && status="copied"
+
+printf '{"canonical_before":%d,"legacy":%d,"canonical_after":%d,"backup":%s,"status":"%s"}\n' \
+  "$canonical_before" "$legacy_total" "$canonical_after" "$bak_json" "$status"