@mmerterden/multi-agent-pipeline 20.33.0 → 20.35.0

package/pipeline/lib/qr-code.mjs

@@ -0,0 +1,360 @@
+/**
+ * qr-code.mjs  -  a QR Code Model 2 encoder (ISO/IEC 18004), byte mode only.
+ *
+ * Used by office-pair to show the pairing link on the machine's own screen.
+ * Byte mode covers any UTF-8 text; the smallest version that fits the text at
+ * the requested error-correction level is chosen, and the mask with the lowest
+ * penalty score is applied.
+ *
+ * Zero runtime dependencies (ADR-0004).
+ *
+ * @module pipeline/lib/qr-code
+ */
+
+const ECC_FORMAT_BITS = { L: 1, M: 0, Q: 3, H: 2 };
+
+// Per version (index 1..40): error-correction codewords per block, and the
+// number of blocks, for each level (ISO/IEC 18004 table 9).
+const ECC_PER_BLOCK = {
+  L: [
+    -1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30,
+    30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+  ],
+  M: [
+    -1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28,
+    28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+  ],
+  Q: [
+    -1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30,
+    30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+  ],
+  H: [
+    -1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30,
+    30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+  ],
+};
+const BLOCKS = {
+  L: [
+    -1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14,
+    15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25,
+  ],
+  M: [
+    -1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23,
+    25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49,
+  ],
+  Q: [
+    -1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34,
+    34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68,
+  ],
+  H: [
+    -1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35,
+    37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81,
+  ],
+};
+
+/** Modules available for data and error correction in a version. */
+export function rawDataModules(version) {
+  let n = (16 * version + 128) * version + 64;
+  if (version >= 2) {
+    const align = Math.floor(version / 7) + 2;
+    n -= (25 * align - 10) * align - 55;
+    if (version >= 7) n -= 36;
+  }
+  return n;
+}
+
+/** Data codewords of a version at a level. */
+export function dataCodewords(version, ecc) {
+  return (
+    Math.floor(rawDataModules(version) / 8) - ECC_PER_BLOCK[ecc][version] * BLOCKS[ecc][version]
+  );
+}
+
+// GF(256) with the QR polynomial x^8 + x^4 + x^3 + x^2 + 1.
+function gfMul(x, y) {
+  let z = 0;
+  for (let i = 7; i >= 0; i--) {
+    z = (z << 1) ^ ((z >>> 7) * 0x11d);
+    z ^= ((y >>> i) & 1) * x;
+  }
+  return z & 0xff;
+}
+
+function rsDivisor(degree) {
+  const result = new Array(degree).fill(0);
+  result[degree - 1] = 1;
+  let root = 1;
+  for (let i = 0; i < degree; i++) {
+    for (let j = 0; j < degree; j++) {
+      result[j] = gfMul(result[j], root);
+      if (j + 1 < degree) result[j] ^= result[j + 1];
+    }
+    root = gfMul(root, 0x02);
+  }
+  return result;
+}
+
+/** Reed-Solomon error-correction codewords for one block. */
+export function reedSolomon(data, degree) {
+  const divisor = rsDivisor(degree);
+  const result = new Array(degree).fill(0);
+  for (const b of data) {
+    const factor = b ^ result.shift();
+    result.push(0);
+    divisor.forEach((coef, i) => {
+      result[i] ^= gfMul(coef, factor);
+    });
+  }
+  return result;
+}
+
+function alignmentPositions(version) {
+  if (version === 1) return [];
+  const count = Math.floor(version / 7) + 2;
+  const size = version * 4 + 17;
+  const step = version === 32 ? 26 : Math.ceil((version * 4 + 4) / (count * 2 - 2)) * 2;
+  const out = [6];
+  for (let pos = size - 7; out.length < count; pos -= step) out.splice(1, 0, pos);
+  return out;
+}
+
+function bch(value, bits, poly, polyDegree) {
+  let rem = value << polyDegree;
+  for (let i = bits + polyDegree - 1; i >= polyDegree; i--) {
+    if ((rem >>> i) & 1) rem ^= poly << (i - polyDegree);
+  }
+  return (value << polyDegree) | rem;
+}
+
+/** The 15 format bits for a level and mask, already XORed with the fixed mask. */
+export function formatBits(ecc, mask) {
+  return bch((ECC_FORMAT_BITS[ecc] << 3) | mask, 5, 0x537, 10) ^ 0x5412;
+}
+
+function codewords(bytes, version, ecc) {
+  const capacityBits = dataCodewords(version, ecc) * 8;
+  const bits = [];
+  const put = (value, length) => {
+    for (let i = length - 1; i >= 0; i--) bits.push((value >>> i) & 1);
+  };
+  put(0b0100, 4);
+  put(bytes.length, version < 10 ? 8 : 16);
+  for (const b of bytes) put(b, 8);
+  put(0, Math.min(4, capacityBits - bits.length));
+  put(0, (8 - (bits.length % 8)) % 8);
+  for (let pad = 0xec; bits.length < capacityBits; pad ^= 0xec ^ 0x11) put(pad, 8);
+  const data = [];
+  for (let i = 0; i < bits.length; i += 8) {
+    data.push(bits.slice(i, i + 8).reduce((a, b) => (a << 1) | b, 0));
+  }
+
+  const blocks = BLOCKS[ecc][version];
+  const eccLen = ECC_PER_BLOCK[ecc][version];
+  const raw = Math.floor(rawDataModules(version) / 8);
+  const shortBlocks = blocks - (raw % blocks);
+  const shortLen = Math.floor(raw / blocks);
+  const groups = [];
+  for (let i = 0, k = 0; i < blocks; i++) {
+    const len = shortLen - eccLen + (i < shortBlocks ? 0 : 1);
+    const chunk = data.slice(k, k + len);
+    k += len;
+    groups.push({ data: chunk, ecc: reedSolomon(chunk, eccLen) });
+  }
+  const out = [];
+  for (let i = 0; i <= shortLen - eccLen; i++) {
+    for (const g of groups) if (i < g.data.length) out.push(g.data[i]);
+  }
+  for (let i = 0; i < eccLen; i++) for (const g of groups) out.push(g.ecc[i]);
+  return out;
+}
+
+const MASKS = [
+  (x, y) => (x + y) % 2 === 0,
+  (x, y) => y % 2 === 0,
+  (x) => x % 3 === 0,
+  (x, y) => (x + y) % 3 === 0,
+  (x, y) => (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0,
+  (x, y) => ((x * y) % 2) + ((x * y) % 3) === 0,
+  (x, y) => (((x * y) % 2) + ((x * y) % 3)) % 2 === 0,
+  (x, y) => (((x + y) % 2) + ((x * y) % 3)) % 2 === 0,
+];
+
+function baseMatrix(version) {
+  const size = version * 4 + 17;
+  const dark = Array.from({ length: size }, () => new Array(size).fill(false));
+  const fixed = Array.from({ length: size }, () => new Array(size).fill(false));
+  const set = (x, y, v) => {
+    dark[y][x] = v;
+    fixed[y][x] = true;
+  };
+  for (let i = 0; i < size; i++) {
+    set(6, i, i % 2 === 0);
+    set(i, 6, i % 2 === 0);
+  }
+  const finder = (cx, cy) => {
+    for (let dy = -4; dy <= 4; dy++) {
+      for (let dx = -4; dx <= 4; dx++) {
+        const x = cx + dx;
+        const y = cy + dy;
+        if (x < 0 || y < 0 || x >= size || y >= size) continue;
+        const d = Math.max(Math.abs(dx), Math.abs(dy));
+        set(x, y, d !== 2 && d !== 4);
+      }
+    }
+  };
+  finder(3, 3);
+  finder(size - 4, 3);
+  finder(3, size - 4);
+  const align = alignmentPositions(version);
+  for (const ay of align) {
+    for (const ax of align) {
+      const corner =
+        (ax === 6 && ay === 6) || (ax === 6 && ay === size - 7) || (ax === size - 7 && ay === 6);
+      if (corner) continue;
+      for (let dy = -2; dy <= 2; dy++) {
+        for (let dx = -2; dx <= 2; dx++) {
+          set(ax + dx, ay + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+        }
+      }
+    }
+  }
+  for (let i = 0; i < 9; i++) {
+    fixed[8][i] = fixed[i][8] = true;
+    if (i < 8) fixed[8][size - 1 - i] = fixed[size - 1 - i][8] = true;
+  }
+  set(8, size - 8, true);
+  if (version >= 7) {
+    const v = bch(version, 6, 0x1f25, 12);
+    for (let i = 0; i < 18; i++) {
+      const bit = ((v >>> i) & 1) === 1;
+      const a = size - 11 + (i % 3);
+      const b = Math.floor(i / 3);
+      set(a, b, bit);
+      set(b, a, bit);
+    }
+  }
+  return { size, dark, fixed };
+}
+
+function drawFormat(dark, size, ecc, mask) {
+  const f = formatBits(ecc, mask);
+  const bit = (i) => ((f >>> i) & 1) === 1;
+  for (let i = 0; i <= 5; i++) dark[i][8] = bit(i);
+  dark[7][8] = bit(6);
+  dark[8][8] = bit(7);
+  dark[8][7] = bit(8);
+  for (let i = 9; i < 15; i++) dark[8][14 - i] = bit(i);
+  for (let i = 0; i < 8; i++) dark[8][size - 1 - i] = bit(i);
+  for (let i = 8; i < 15; i++) dark[size - 15 + i][8] = bit(i);
+  dark[size - 8][8] = true;
+}
+
+function placeData(dark, fixed, size, words) {
+  let i = 0;
+  const total = words.length * 8;
+  for (let right = size - 1; right >= 1; right -= 2) {
+    if (right === 6) right = 5;
+    for (let vert = 0; vert < size; vert++) {
+      for (let j = 0; j < 2; j++) {
+        const x = right - j;
+        const upward = ((right + 1) & 2) === 0;
+        const y = upward ? size - 1 - vert : vert;
+        if (fixed[y][x] || i >= total) continue;
+        dark[y][x] = ((words[i >>> 3] >>> (7 - (i & 7))) & 1) === 1;
+        i++;
+      }
+    }
+  }
+}
+
+/** The ISO penalty score of a finished matrix: runs, 2x2 blocks, finder-like patterns, balance. */
+export function penalty(dark) {
+  const size = dark.length;
+  let score = 0;
+  const lineScore = (get) => {
+    let s = 0;
+    for (let a = 0; a < size; a++) {
+      let run = 1;
+      for (let b = 1; b <= size; b++) {
+        if (b < size && get(a, b) === get(a, b - 1)) {
+          run++;
+        } else {
+          if (run >= 5) s += run - 2;
+          run = 1;
+        }
+      }
+      for (let b = 0; b + 10 < size; b++) {
+        const seq = Array.from({ length: 11 }, (_, k) => get(a, b + k));
+        const p1 = [1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0];
+        const p2 = [0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1];
+        if (seq.every((v, k) => v === Boolean(p1[k])) || seq.every((v, k) => v === Boolean(p2[k])))
+          s += 40;
+      }
+    }
+    return s;
+  };
+  score += lineScore((a, b) => dark[a][b]);
+  score += lineScore((a, b) => dark[b][a]);
+  let darkCount = 0;
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      if (dark[y][x]) darkCount++;
+      if (
+        y + 1 < size &&
+        x + 1 < size &&
+        dark[y][x] === dark[y][x + 1] &&
+        dark[y][x] === dark[y + 1][x] &&
+        dark[y][x] === dark[y + 1][x + 1]
+      )
+        score += 3;
+    }
+  }
+  const total = size * size;
+  score += (Math.ceil(Math.abs(darkCount * 20 - total * 10) / total) - 1) * 10;
+  return score;
+}
+
+/**
+ * Encode text as a QR code.
+ *
+ * @param {string} text
+ * @param {{ecc?: "L"|"M"|"Q"|"H", mask?: number}} [opts]  mask forces one of 0..7
+ * @returns {{version: number, size: number, ecc: string, mask: number, modules: boolean[][]}}
+ */
+export function encodeQr(text, { ecc = "M", mask } = {}) {
+  if (!ECC_PER_BLOCK[ecc]) throw new Error(`unknown error-correction level ${ecc}`);
+  const bytes = [...Buffer.from(String(text), "utf8")];
+  let version = 1;
+  const fits = (v) => 4 + (v < 10 ? 8 : 16) + bytes.length * 8 <= dataCodewords(v, ecc) * 8;
+  while (version <= 40 && !fits(version)) version++;
+  if (version > 40) throw new Error("text is too long for a QR code");
+  const words = codewords(bytes, version, ecc);
+  const { size, dark, fixed } = baseMatrix(version);
+  placeData(dark, fixed, size, words);
+  const candidates = Number.isInteger(mask) ? [mask] : [0, 1, 2, 3, 4, 5, 6, 7];
+  let best = null;
+  for (const m of candidates) {
+    const grid = dark.map((row, y) => row.map((v, x) => (fixed[y][x] ? v : v !== MASKS[m](x, y))));
+    drawFormat(grid, size, ecc, m);
+    const score = penalty(grid);
+    if (!best || score < best.score) best = { score, grid, mask: m };
+  }
+  return { version, size, ecc, mask: best.mask, modules: best.grid };
+}
+
+/** The code as one SVG path (one unit per module, a four-module quiet zone). */
+export function qrSvg(qr, { scale = 6 } = {}) {
+  const q = 4;
+  const n = qr.size + q * 2;
+  let d = "";
+  qr.modules.forEach((row, y) =>
+    row.forEach((on, x) => {
+      if (on) d += `M${x + q} ${y + q}h1v1h-1z`;
+    }),
+  );
+  return (
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${n} ${n}" width="${n * scale}" ` +
+    `height="${n * scale}" shape-rendering="crispEdges"><rect width="${n}" height="${n}" ` +
+    `fill="#fff"/><path d="${d}" fill="#000"/></svg>`
+  );
+}

package/pipeline/lib/repo-hygiene.sh

@@ -41,6 +41,7 @@ MA_HYGIENE_END='# <<< multi-agent pipeline (managed) <<<'
 ma_hygiene_patterns() {
   cat <<'PATTERNS'
 .worktrees/
+.DerivedData/
 .pipeline/
 .multi-agent/
 triage-output.json

package/pipeline/lib/run-completion.mjs

@@ -11,6 +11,8 @@
  *      `commit.sha`, a `pr`, a runner `publish` record, a `projects[].commit`
  *      or `projects[].pr`, or an explicit no-commit decision
  *      (`phases["4"].status: "skipped"` with a `notes` reason).
+ *      A repo commit counts as delivered once its push outcome is recorded
+ *      (`projects[].pushStatus`) or it has a pull request.
  *   3. The plan's coverage was judged, unless the mode declares
  *      `commits: false`: a `plan-coverage` entry in `gates[]` with a passing
  *      verdict. plan-coverage-gate.mjs records it attended and unattended.
@@ -101,6 +103,16 @@ export function phase4Evidence(state) {
   return Boolean(p4 && p4.status === "skipped" && typeof p4.notes === "string" && p4.notes.trim());
 }
 
+const PUSH_RECORDED = new Set(["pushed", "rebase-pushed", "skipped"]);
+
+/** Repos whose commit has neither a recorded push outcome nor a pull request. */
+export function unpushedRepos(state) {
+  const projects = Array.isArray(state.projects) ? state.projects : [];
+  return projects
+    .filter((p) => p && hasSha(p.commit) && !hasPr(p.pr) && !PUSH_RECORDED.has(p.pushStatus))
+    .map((p, i) => p.project || p.name || `#${i + 1}`);
+}
+
 /** True when a passing plan-coverage verdict is in the gate ledger. */
 export function planCoverageRecorded(state) {
   const gates = Array.isArray(state.gates) ? state.gates : [];
@@ -138,6 +150,11 @@ export function completionGaps(state) {
         'no Phase 4 evidence: record commit.sha (or pr), or the no-commit decision as phases["4"] = {status: "skipped", notes: "<why>"}',
       );
     }
+    for (const name of unpushedRepos(state)) {
+      gaps.push(
+        `repo ${name} has a commit with no recorded push: set projects[].pushStatus to "pushed" or "rebase-pushed", or "skipped" when the push is left to the user (Phase 4 push policy)`,
+      );
+    }
     if (!planCoverageRecorded(state)) {
       gaps.push(
         "no passing plan-coverage verdict in gates[]: run plan-coverage-gate.mjs --state <agent-state.json> (Phase 4 Step 0a)",

package/pipeline/multi-agent-refs/channels/generator.md

@@ -0,0 +1,146 @@
+# Channels - Generator (Step 5 section bodies)
+
+> Loaded by `channels/SKILL.md` Step 5. The SKILL keeps the Jira-vs-PR body rule, the section-order rule and the target length rule; this file carries the content-option table, the aggregated output template, the store-compliance augmentation, and the work-summary and cost-summary generators. Read it before generating any section body.
+
+## Content options
+
+| Content option | Generated section |
+|---|---|
+| Normal analiz | `### Analysis`  -  impact summary from Phase 1, risks from Phase 4 (pipeline-log source, high-level only) |
+| Teknik analiz | `### Technical Details`  -  Changes (what/why per file group), Architecture (structural decisions, pattern changes), Dependencies (new imports/frameworks/packages). Source: Phase 1 planning + Phase 2 dev log + `git diff --stat`. **PR and Confluence only** - never rendered into a Jira comment. |
+| Test senaryoları | `### Test Scenarios`  -  precondition / steps / expected table (4-8 rows), user perspective |
+| Test Koşumu (Xray) | `### Test Koşumu`  -  Xray Test Execution of the task's UI scenario run (`channels/test-run.md`) |
+| Auto-diff | Old enrich Output Template verbatim  -  Root Cause / Solution / Changed Files / Test Scenarios |
+| Manuel not | `### Notes`  -  user-provided paragraph, or LLM-split into subsections if `--message` is plain text and long |
+| Cost özeti | `### Cost Summary`  -  per-phase token tally + est. USD table. Source: `phase-tracker.sh` phase status + optional OTel spans. See "Cost summary generation" below. |
+| Yapılan iş özeti | `### Work Summary`  -  executive one-screen summary: task + branch + base + PR, scope delivered (done/[pending] per Phase 2 task), changed files with +/- counts (capped at 20 rows), review outcome (accepted/deferred/rejected + approved), phase tick strip. Source: `agent-state.json` + `phase-tracker.json` + `git diff --numstat base...HEAD`. See "Work summary generation" below. |
+
+## Output template
+
+**Output template (aggregated across selected content options):**
+
+```markdown
+### Analysis                        ← if "Normal analiz" selected
+{impact summary, risks  -  from pipeline log, high-level}
+
+### Technical Details               ← if "Teknik analiz" selected
+#### Changes
+{Per changed-file-group, what changed + why  -  from Phase 2 dev log}
+#### Architecture
+{Structural decisions, pattern changes, new file layouts  -  from Phase 1 plan}
+#### Dependencies
+{New imports / frameworks / packages  -  from git diff --stat, or "None"}
+
+### Root Cause                      ← if "Auto-diff" selected
+{single paragraph  -  from diff}
+
+- `path/to/File.ext → funcName`: {why it broke}
+
+### Solution                        ← if "Auto-diff" selected
+- `path/to/File.ext:LINE-LINE`  -  {change, one line}
+
+### Changed Files                   ← if "Auto-diff" selected
+| File | +/- |
+|------|-----|
+| `path/to/File.ext` | +N / -M |
+
+### Test Scenarios                  ← if "Test senaryoları" OR "Auto-diff" selected
+**1. {what this scenario exercises}**
+1. {step the tester performs}
+2. **Expected:** {what they should see}
+
+**2. {regression scenario}**
+1. {step}
+2. **Expected:** {what should still behave as before}
+
+### Test Koşumu                     ← if "Test Koşumu (Xray)" selected
+
+### Notes                           ← if "Manuel not" selected
+{user message}
+
+### Work Summary                    ← if "Yapılan iş özeti" selected
+{executive scope + files + review + phases block  -  see "Work summary generation" below}
+
+### Cost Summary                    ← if "Cost özeti" selected
+{per-phase token + USD table  -  see "Cost summary generation" below}
+
+### Store compliance                ← auto-appended if cached compliance report exists
+{summary line  -  see below}
+
+Ref: {jiraId}
+```
+
+**Store compliance auto-augmentation:**
+
+After the content-selected sections are generated, check for a recent compliance report cached from `/multi-agent:test "store-ready"`:
+
+```bash
+# Cache locations (newest wins; expire after 6h to avoid stale cross-branch reports)
+find /tmp -maxdepth 1 -name 'archiveguard-*.json' -o -name 'play-compliance-*.json' \
+  -newermt "-6 hours" -print 2>/dev/null | head -1
+```
+
+If a cached report exists AND any of the selected channels is PR / Jira / Confluence, append an auto-summary section:
+
+| Blocker count | Appended line |
+|---|---|
+| `errors > 0` | `### Store compliance` + `{N} blocker(s), {M} warning(s)  -  run /multi-agent:test "store-ready" for the full report.`  -  per-blocker: `- \`{ruleID}\`  -  {Apple ITMS / Play ref}: {message}` (capped at 5 rows, rest collapsed to `+N more`) |
+| `errors == 0, warnings > 0` | `### Store compliance` + `[done] No blockers. {M} warning(s)  -  see /multi-agent:test "store-ready" for detail.` |
+| `errors == 0, warnings == 0` | Skip section entirely  -  don't pollute PR body |
+
+The section references `ruleID` + policy ref from the compliance skill catalogs (`apple-archive-compliance` / `google-play-compliance`) verbatim. No translation  -  global identifiers stay as-is.
+
+If no cached report exists, skip silently  -  this is augmentation, not a gate.
+
+**Work summary generation:**
+
+Emitted only when `reportContent.workSummary === true` and at least one of (`agent-state.json`, `--branch` flag) is available. The shell adapter is `$HOME/.claude/scripts/render-work-summary.sh <taskId>`, and that script's own header is the spec for what it emits - task header, scope delivered, changed files, review outcome, phase strip - including the caps and the hidden-when-empty rules. Exit 2 means the state was unreadable: skip the section, do not substitute a hand-written one.
+
+**Output template:**
+
+```markdown
+### Work Summary
+**Task**: `PROJ-1099`  |  **Branch**: `bugfix/PROJ-1099-dark-mode`  |  **Base**: `develop`  |  **PR**: #104
+
+#### Scope delivered
+- [done] T1 Add failing dark-mode snapshot test
+- [done] T2 Replace Color.white with design token
+
+#### Changed files (3 files · +48 / -12)
+- `Sources/Auth/LoginView.swift` (+24 / -8)
+- `Sources/Auth/LoginViewTests.swift` (+22 / -4)
+- `Sources/DesignSystem/Color+Tokens.swift` (+2 / -0)
+
+#### Review outcome
+- 1 accepted · 0 deferred · 0 rejected · approved=true
+
+#### Phases
+- 0 Init [done] · 1 Plan [done] · 2 Dev [done] · 3 Review [done] · 4 Commit [done] · 5 Report active
+```
+
+**Post-hoc invocation** (task already finished, agent-state.json may be archived): pass `--branch` + `--base-branch` explicitly  -  the script still emits task header + changed-files + phases sections (scope + review outcome are state-dependent and will be absent if state is gone).
+
+**Cost summary generation:**
+
+Emitted only when `reportContent.costSummary === true` and tracker data is available. Source of truth is `phase-tracker.sh`:
+
+1. **Token tallies per phase**  -  `render-cost-summary.sh <taskId>` resolves the tracker JSON itself: worktree candidates (`.worktrees/{taskPath}/phase-tracker.json`) first, then the standard location `$HOME/.claude/logs/multi-agent/{taskId}/tracker-state.json` that `phase-tracker.sh` actually writes. Each phase row carries `{tokens_in, tokens_out}`.
+2. **Fallback to OTel spans**  -  if tracker JSON has no token columns but `otel-spans.jsonl` exists (set `MULTI_AGENT_OTEL_SPANS=1` beforehand), aggregate `phase.tokens` spans by phase ID.
+3. **USD estimate**  -  uses a static price table in `$HOME/.claude/scripts/cost-table.json` (model → $/Mtok_in, $/Mtok_out). Missing model → show ` - ` for USD, never block.
+
+**Output template:**
+
+```markdown
+### Cost Summary
+| Phase | Model | Tokens in | Tokens out | Est. USD |
+|-------|-------|-----------|------------|----------|
+| 1. Analysis | opus   | 12,480 | 3,210 | $0.42 |
+| 2. Planning | opus   | 18,904 | 5,120 | $0.66 |
+| 3. Dev      | sonnet | 42,310 | 9,880 | $0.27 |
+| 4. Review   | opus   | 21,050 | 4,720 | $0.66 |
+| **Total**   |        | **94,744** | **22,930** | **$2.04** |
+```
+
+Generated by `$HOME/.claude/scripts/render-cost-summary.sh <task-id>` using prices from `$HOME/.claude/scripts/cost-table.json`. The channels adapter shells out to this renderer  -  doc table is illustrative only, runtime is authoritative.
+
+**Precision rules:** tokens as thousand-separated integers. USD rounded to 2 dp (`printf '$%.2f'`). Rows with zero tokens dropped. If total USD is ` - ` (no price for any model), replace the total row USD cell with ` - ` and add a one-line footnote: `*USD unavailable  -  add model to cost-table.json*`.

package/pipeline/multi-agent-refs/channels/issue-comment.md

@@ -132,7 +132,7 @@ gh issue comment "$ISSUE_NUMBER" --repo "$ORG/$REPO" --body-file /tmp/channels-$
 bash $HOME/.claude/scripts/update-issue-progress.sh "$TASK_ID"
 ```
 
-If either call fails, the channel adapter MUST NOT mark the issue channel as completed in `agent-state.json`. The user sees a clear error and can retry.
+If either call fails, the channel adapter MUST NOT mark the issue channel as completed in `agent-state.json`. The user sees a clear error and can retry. The order is enforced: `update-issue-progress.sh` exits 5 and leaves the body unchanged unless the authenticated account has a comment on the issue since `state.startedAt` that carries the `Ref: #N` footer.
 
 ## Drift detection
 

package/pipeline/multi-agent-refs/channels/menu.md

@@ -0,0 +1,55 @@
+# Channels - Menu (Step 2 sources, Step 3a preview, Step 3b picker rules)
+
+> Loaded by `channels/SKILL.md` Step 2. The SKILL keeps the step order and the autopilot rule; this file carries the context-source table, the summary-first preview logic, the greyed-out rules and the first-run defaults. Read it before Step 2.
+
+## Step 2  -  Context sources
+
+Automatic. The generator picks the best-available source:
+
+| Source | Available when | Used for |
+|---|---|---|
+| **Pipeline log** | `$HOME/.claude/logs/multi-agent/<project>/<task-id>/agent-log.md` exists AND matches `jiraId` | "Normal analiz" + "Test senaryoları" content options  -  uses Phase 1/2/4 output verbatim |
+| **PR diff** | PR exists, diff fetchable (`gh pr diff` or Bitbucket `/diff?contextLines=5`) | "Auto-diff summary" content option  -  old enrich behavior |
+| **Manual message** | `--message` / `--message-file` provided | Replaces both sources  -  user text is canonical |
+
+## Step 3a  -  Work Summary preview (summary-first flow)
+
+**Runs only when** (a) `agent-state.json` exists for the task AND (b) a Work Summary can be generated (same availability rule as the "Yapılan iş özeti" content row). Purpose: give the user an instant "what did this ship?" answer BEFORE they pick channels. They see the outcome first, then decide where to route it  -  instead of the reverse.
+
+```bash
+preview=$(bash $HOME/.claude/scripts/render-work-summary.sh "$TASK_ID" 2>/dev/null || true)
+[ -n "$preview" ] && {
+  printf '%s\n\n' "$preview"
+  # Auto-tick workSummary content row when preview was shown.
+  # Users can still untick it in 3b if they don't want to re-send the same
+  # block to remote channels (useful when preview was enough for a look).
+  content_defaults.workSummary=true
+}
+```
+
+When the preview renders:
+- **workSummary** row in 3b is **auto-ticked** (user can still uncheck).
+- Previous `prefs.global.reportContent.workSummary` value is respected  -  if the user had explicitly unticked in a prior run, the auto-tick is **suppressed** and the ticked state matches the pref.
+
+When the preview does NOT render (no state, or pref explicitly off at global level with no override):
+- Skip 3a silently, go straight to the channels picker. The workSummary row in 3b stays at its pref default (`false`).
+
+After the preview prints, 3b renders the two pickers: **Channels** (PR description, Jira comment, Confluence page, Wiki, Board; each unavailable one greyed with its reason) and **Content** (normal analysis, technical analysis, test scenarios, test run, PR auto-diff, manual note, cost summary, work summary).
+
+**Why auto-tick:** the user just saw the summary and is most likely sending it; the explicit pref still wins.
+
+## Step 3b  -  Channel + content picker
+
+**Greyed-out rules:**
+- "Wiki" unselectable unless `state.taskType === "component"` AND `figmaConfig.wiki.enabled === true`. If greyed, show reason: `"(no figma-config or taskType != component)"`.
+- "Board" unselectable unless `figmaConfig.board.enabled === true` AND `figmaConfig.board.provider === "github-projects-v2"` AND `figmaConfig.github.projectV2Id` set. If greyed, show reason: `"(no figma-config.board or projectV2Id missing)"`. Default target column: `inReview`.
+- "Normal analiz" + "Test senaryoları" unselectable if no pipeline log found. Reason: `"(no pipeline log for PROJ-12345)"`.
+- "Teknik analiz" unselectable if no Phase 1 planning log AND no PR diff available. Reason: `"(no technical source  -  need Phase 1 plan or PR diff)"`.
+- "Auto-diff" unselectable if no PR found. Reason: `"(no PR linked to this target)"`.
+- "Manuel not" always available. "Test Koşumu (Xray)": `channels/test-run.md`.
+- "Cost özeti" unselectable if `phase-tracker.sh cost total` prints `-` (no priced token tallies; there is no `status` action) AND no `otel-spans.jsonl` exists for the task. Reason: `"(no tracker data  -  set MULTI_AGENT_OTEL_SPANS=1 or enable token tracking)"`.
+- "Yapılan iş özeti" unselectable if no `agent-state.json` exists for the task (post-hoc call with `--branch` + `--base-branch` flags restores partial availability). Reason: `"(no agent-state.json for {taskId})"`. **Auto-ticked** when Step 3a preview was shown  -  user can still uncheck before confirming the menu.
+
+**Defaults (first run):** PR + Jira ticked, Confluence + Wiki unticked. Content: auto-diff if pipeline log missing; otherwise normal-analiz + test-senaryoları.
+
+Saved to `prefs.global.reportChannels` and `prefs.global.reportContent`  -  next run uses these as defaults.

package/pipeline/multi-agent-refs/channels/multi-repo.md

@@ -13,3 +13,9 @@
 **Target enumeration:** `channels-multi-repo.sh targets <state>` returns a JSON array `[{repoName, prUrl, prNumber, isPrimary, crossLinks}]` for the dispatch loop. Single-repo tasks return one entry with empty `crossLinks`  -  every render-* call falls through to the body unchanged, so the loop is uniform across single-repo and multi-repo paths.
 
 **Logging hint:** `channels-multi-repo.sh summary <state>` produces a one-line autopilot log entry (`1 primary (foo) + 2 extras: <url> <url>` or `single-repo task`).
+
+## Target resolution (Step 1)
+
+**Multi-repo:** when `agent-state.json` `projects[].length > 1`, Step 1 builds **one target per project**. Each project's PR is resolved via `pr` field in its projects[] entry; if missing, the Jira/Issue link query returns multiple PRs (one per repo)  -  all are added to `targets[]`. The project at `projects[0]` (or whose name matches `state.project`) is marked `isPrimary: true`; others are `isPrimary: false`.
+
+For single-repo tasks, `targets` has exactly one entry. The rest of the flow is target-aware: Step 5 generates one body, Step 7 dispatches to each target, with cross-links (see the dispatch table above).

package/pipeline/multi-agent-refs/channels/preview.md

@@ -0,0 +1,25 @@
+# Channels - Preview render (Step 6)
+
+> Loaded by `channels/SKILL.md` Step 6. The SKILL keeps the approval gate, its skip cases, its options and the byte-identical rule; this file carries the per-channel markup conversion, the preview block layout and the secondary-artifact intents. Read it before rendering the Step 6 preview.
+
+Conversion is per-channel; two channels have none:
+
+| Channel | Conversion after approval | Table |
+|---|---|---|
+| PR description | **none**  -  posted as Markdown, verbatim | GitHub / Bitbucket / GitLab all render Markdown; see `channels/pr.md` "Markup dialect" |
+| GitHub issue comment | **none**  -  posted as Markdown, verbatim |  -  |
+| Jira comment | markdown → Jira wiki markup | `channels/jira.md` "Wiki markup conversion" |
+| Confluence page | markdown → storage format | `channels/confluence.md` "Body conversion" |
+
+The Jira table is the only *text* markup table in the doc set and never applies to the PR body: `h2.`, `{{code}}` or `#`-numbered lists render there as raw wiki markup.
+
+```
+── PR description  ({repoName} #{prNumber}, replace) ─────────
+{body}
+── Jira comment  ({jiraId}) ──────────────────────────────────
+{body}
+── Confluence page  ("{title}" under {parentUrl}) ────────────
+{body}
+```
+
+Secondary artifacts ride along as one-line intents at the bottom of the preview: Wiki page list, wiki → Jira triad comment (when Wiki is selected and the triad is active per `$HOME/.claude/multi-agent-refs/issue-jira-triad.md`), Board status move (`{from} → {to}`), GitHub issue comment + Progress-flag sync (Phase 5 Step 1.5  -  same gate, see `$HOME/.claude/multi-agent-refs/phases/phase-5-report.md`), test-run candidates to untick (`channels/test-run.md`), the Jira body's `--measure` (`render-jira-evidence.mjs`).