@tekyzinc/gsd-t 5.20.10 → 5.20.12

package/CHANGELOG.md

@@ -2,6 +2,52 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.20.12] - 2026-09-21
+
+### Fixed — estimate writer proven end-to-end; two-month remainder formula
+
+First live run of `gsd-t estimate-sheet write` on a copy of the Tekyz template (David's
+"E2E test of the estimator" sheet): 11 items in 4 sections, a 6-person / 2-month Team Mix,
+and a 4-row Technology Stack, then all 33 read-back audit checks pass — 8 seconds, no hand edits.
+
+- `bin/gsd-t-estimate-sheet.cjs`: with exactly two month columns the remainder was written
+  as `=F3-SUM(I3:I3)`; Google canonicalises a one-cell range to `SUM(I3)`, so the audit's
+  read-back never matched. New `remainderFormula()` emits `=F3-I3` for two months, the
+  `SUM(first:second-to-last)` form for three or more; writer and audit share it.
+- `test/estimate-sheet-writer.test.js`: the two-month case, including the writer's own
+  output passing its own audit.
+
+### Changed — David's review of the first live sheet (2026-09-21)
+
+- T-Shirt: no blank row above or below the totals row; the totals row is the template's grey
+  band (`#D8DDE8`, bold) across A:L; the summary labels (Total Days / Hrs / Cost) are bold and
+  Total Cost is formatted as dollars. Audit checks added for each.
+- Team Mix: **one grid per phase with hours** (MVP, Phase 1, …) stacked on the one tab with
+  exactly 2 blank rows between grids; each grid reconciles to its phase's T-Shirt days (read
+  from the phase rollups) and the grids together to Total Days. `teamMix.phases.<phase>.fte`
+  overrides the mix for one phase. `Mths` is written at full precision (displayed 0.00) so
+  Σ Days reconciles exactly instead of drifting with the roster size.
+- Section heading blue stays `#1C4F8B` (confirmed); template copies stay a manual step (the
+  service account has no Drive quota; domain-wide delegation rejected as a master-key risk).
+
+## [5.20.11] - 2026-09-17
+
+### Fixed — `update-all` treated a downgrade as an upgrade and rolled 34 projects back
+
+Releasing 5.20.10, npm's cached package listing still named 5.19.11 as `@latest` for
+several minutes after publish. `upgradeGlobalBinary()` installed the older release over
+the running one, printed "upgraded: v5.20.10 → v5.19.11", handed off to the OLD binary,
+and that binary rewrote `~/.claude/commands` and every registered project with the
+previous version. It happened twice in one release.
+
+- `bin/gsd-t.js`: numeric `versionCmp`; a downgrade now HALTS (exit 1) before the
+  "upgraded" branch and names the fix (`npm cache clean --force`, wait for the tarball
+  to serve 200, reinstall the current release). Never hands off to an older binary.
+- `commands/cpua.md`: Step 6 polls the tarball URL until it returns 200, cleans the npm
+  cache, installs, and checks `dist-tags.latest` equals the new version BEFORE `update-all`.
+- `test/update-all-downgrade-halt.test.js`: the compare is numeric (5.9 < 5.10) and the
+  downgrade branch exits instead of re-exec'ing.
+
 ## [5.20.10] - 2026-09-17
 
 ### Changed — `/gsd-t-estimate` is the sheet only, and the sheet now has a written spec

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v5.20.10** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
+**v5.20.12** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
 
 **Eliminates context rot** — task-level fresh dispatch (one subagent per task, ~10-20% context each) means compaction never triggers.
 **Compaction-proof debug loops** — `gsd-t headless --debug-loop` runs test-fix-retest cycles as separate `claude -p` sessions. A JSONL debug ledger persists all hypothesis/fix/learning history across fresh sessions. Anti-repetition preamble injection prevents retrying failed hypotheses. Escalation tiers (sonnet → opus → human) and a hard iteration ceiling enforced externally.

package/bin/gsd-t-estimate-sheet.cjs

@@ -52,6 +52,7 @@ const COLOR = {
   sage: "#D6E2DD",
   totalBg: "#E5E5E5",
   totalDaysBg: "#9EC1EF",
+  tshirtTotalBg: "#D8DDE8",
   white: "#FFFFFF",
 };
 
@@ -472,7 +473,9 @@ function monthPlan(totalDays, people) {
   const sumCount = people.reduce((s, p) => s + p.count, 0);
   if (!(sumCount > 0)) throw new Halt("Team Mix: total Count is 0");
   if (!(totalDays > 0)) throw new Halt(`Team Mix: total days is ${totalDays}`);
-  const months = round2(totalDays / (sumCount * 20));
+  // Full precision: the sheet DISPLAYS Mths as 0.00 but computes with the exact value, so
+  // Σ Days reconciles to the T-Shirt total instead of drifting by ΣCount × 20 × 0.005.
+  const months = totalDays / (sumCount * 20);
   const whole = Math.floor(months);
   const frac = months - whole;
   const n = whole >= 1 && frac < FOLD_THRESHOLD ? whole : Math.ceil(months);
@@ -526,10 +529,10 @@ function buildRoster(plan, totalDays, mfList) {
   const rows = people.map((p) => {
     const days = round2(months * 20 * p.count);
     const hours = round2(days * 8);
-    return { ...p, months, days, hours, monthHours: rampHours(hours, p.discipline, n) };
+    return { ...p, months: round2(months), monthsExact: months, days, hours, monthHours: rampHours(hours, p.discipline, n) };
   });
   const sumDays = round2(rows.reduce((s, r) => s + r.days, 0));
-  return { people: rows, months, sumCount, n, sumDays };
+  return { people: rows, months: round2(months), monthsExact: months, sumCount, n, sumDays };
 }
 
 // ───────────────────────── T-Shirt totals (pure) ─────────────────────────
@@ -589,18 +592,17 @@ function tshirtRows(plan, firstRow0) {
     }
   }
   const lastItem1 = r1 - 1;
-  const totalRow1 = lastItem1 + 2;
+  const totalRow1 = lastItem1 + 1; // directly under the last item — no blank row (David, 2026-09-21)
   const f1 = firstRow0 + 1;
-  out.push({ kind: "blank", row1: lastItem1 + 1, values: Array(12).fill("") });
   out.push({
     kind: "total", row1: totalRow1,
     values: ["Total (Days)", "", "", "", "", "", "",
       `=SUM(H${f1}:H${lastItem1})`, `=SUM(I${f1}:I${lastItem1})`, `=SUM(J${f1}:J${lastItem1})`, `=SUM(K${f1}:K${lastItem1})`, `=SUM(L${f1}:L${lastItem1})`],
   });
-  out.push({ kind: "blank", row1: totalRow1 + 1, values: Array(12).fill("") });
-  out.push({ kind: "summary", row1: totalRow1 + 2, values: ["", "", "", "", "", "", "", "", "", "Total Days", `=J${totalRow1}`, `=J${totalRow1}*$G$4`] });
-  out.push({ kind: "summary", row1: totalRow1 + 3, values: ["", "", "", "", "", "", "", "", "", "Total Hrs", `=J${totalRow1}*8`, `=J${totalRow1}*$G$4*8`] });
-  out.push({ kind: "summary", row1: totalRow1 + 4, values: ["", "", "", "", "", "", "", "", "", "Total Cost", `=K${totalRow1}`, `=L${totalRow1}`] });
+  // summary block directly under the totals row — no blank row
+  out.push({ kind: "summary", row1: totalRow1 + 1, values: ["", "", "", "", "", "", "", "", "", "Total Days", `=J${totalRow1}`, `=J${totalRow1}*$G$4`] });
+  out.push({ kind: "summary", row1: totalRow1 + 2, values: ["", "", "", "", "", "", "", "", "", "Total Hrs", `=J${totalRow1}*8`, `=J${totalRow1}*$G$4*8`] });
+  out.push({ kind: "summary-cost", row1: totalRow1 + 3, values: ["", "", "", "", "", "", "", "", "", "Total Cost", `=K${totalRow1}`, `=L${totalRow1}`] });
   return { rows: out, firstItem1: f1, lastItem1, totalRow1 };
 }
 
@@ -659,10 +661,11 @@ async function writeTshirt(api, plan, opts) {
   }
   // 4. formats — item area defaults, then per-row kinds
   const reqs = [];
-  reqs.push(fmtReq(sheetId, first0, lastWritten1, 0, 12, FMT_ITEM_TEXT, "userEnteredFormat(textFormat,horizontalAlignment)"));
-  reqs.push(fmtReq(sheetId, first0, lastWritten1, 4, 7, FMT_ITEM_SIZE, "userEnteredFormat(horizontalAlignment,textFormat)"));
-  reqs.push(fmtReq(sheetId, first0, lastWritten1, 7, 10, FMT_ITEM_NUM, FMT_FIELDS_ALL));
-  reqs.push(fmtReq(sheetId, first0, lastWritten1, 10, 12, FMT_ITEM_CUR, FMT_FIELDS_ALL));
+  const lastItem0 = built.lastItem1; // exclusive end for item-area formats (0-based end = lastItem1)
+  reqs.push(fmtReq(sheetId, first0, lastItem0, 0, 12, FMT_ITEM_TEXT, "userEnteredFormat(textFormat,horizontalAlignment)"));
+  reqs.push(fmtReq(sheetId, first0, lastItem0, 4, 7, FMT_ITEM_SIZE, "userEnteredFormat(horizontalAlignment,textFormat)"));
+  reqs.push(fmtReq(sheetId, first0, lastItem0, 7, 10, FMT_ITEM_NUM, FMT_FIELDS_ALL));
+  reqs.push(fmtReq(sheetId, first0, lastItem0, 10, 12, FMT_ITEM_CUR, FMT_FIELDS_ALL));
   for (const row of built.rows) {
     const r0 = row.row1 - 1;
     if (row.kind === "section") {
@@ -671,9 +674,14 @@ async function writeTshirt(api, plan, opts) {
         { backgroundColor: hexToColor(COLOR.sectionBg), textFormat: { fontFamily: "Arial", fontSize: 10, bold: true, foregroundColor: hexToColor(COLOR.white) }, horizontalAlignment: "LEFT" },
         "userEnteredFormat(backgroundColor,textFormat,horizontalAlignment)"));
     } else if (row.kind === "total") {
-      reqs.push(fmtReq(sheetId, r0, r0 + 1, 0, 12, { textFormat: { fontFamily: "Calibri", fontSize: 10, bold: true } }, "userEnteredFormat.textFormat"));
-    } else if (row.kind === "summary") {
-      reqs.push(fmtReq(sheetId, r0, r0 + 1, 9, 12, { textFormat: { fontFamily: "Calibri", fontSize: 10, bold: true } }, "userEnteredFormat.textFormat"));
+      // the template's totals row: grey band across A:L, bold 10, numbers in General format, right-aligned
+      reqs.push(fmtReq(sheetId, r0, r0 + 1, 0, 12, { backgroundColor: hexToColor(COLOR.tshirtTotalBg), textFormat: { fontSize: 10, bold: true }, horizontalAlignment: "LEFT" }, "userEnteredFormat(backgroundColor,textFormat,horizontalAlignment)"));
+      reqs.push(fmtReq(sheetId, r0, r0 + 1, 7, 12, { horizontalAlignment: "RIGHT" }, "userEnteredFormat.horizontalAlignment"));
+    } else if (row.kind === "summary" || row.kind === "summary-cost") {
+      reqs.push(fmtReq(sheetId, r0, r0 + 1, 9, 12, { textFormat: { fontSize: 10, bold: true } }, "userEnteredFormat.textFormat"));
+      reqs.push(fmtReq(sheetId, r0, r0 + 1, 10, 12,
+        row.kind === "summary-cost" ? { horizontalAlignment: "RIGHT", numberFormat: { type: "CURRENCY", pattern: "$#,##0.00" } } : { horizontalAlignment: "RIGHT", numberFormat: { type: "NUMBER", pattern: "0.00" } },
+        "userEnteredFormat(horizontalAlignment,numberFormat)"));
     } else if (row.kind === "item") {
       reqs.push(copyPhaseReq(sheetId, phaseSrc, r0)); // carries validation + chip format; value re-put below
     }
@@ -732,7 +740,42 @@ async function writeTshirtSizes(api, grid, sheetId, layout, plan, totals, phaseS
 
 // ───────────────────────── write: Team Mix (spec §2) ─────────────────────────
 
-function teamMixValues(plan, roster) {
+/** Per-phase T-Shirt totals in PHASES order — only phases with hours > 0 (spec §2.6). */
+function phaseTotals(plan, layout) {
+  const raw = {};
+  for (const s of plan.tshirt.sections) for (const it of s.items) {
+    raw[it.phase] = (raw[it.phase] ? raw[it.phase] : 0) + sizeDays(it.fe, layout.legend) + sizeDays(it.be, layout.legend);
+  }
+  return PHASES.filter((ph) => raw[ph] > 0).map((ph) => ({ phase: ph, rawDays: round2(raw[ph]), totalDays: round2(raw[ph] * (1 + layout.mfTotal)) }));
+}
+
+/** One roster per phase with hours. FTE comes from teamMix.phases[<phase>].fte when given, else teamMix.fte. */
+function buildRosters(plan, layout) {
+  const phases = phaseTotals(plan, layout);
+  if (!phases.length) throw new Halt("no phase has any hours — nothing to staff");
+  return phases.map((ph) => {
+    const override = plan.teamMix.phases && plan.teamMix.phases[ph.phase] && plan.teamMix.phases[ph.phase].fte;
+    const sub = override ? { ...plan, teamMix: { ...plan.teamMix, fte: override } } : plan;
+    return { ...ph, roster: buildRoster(sub, ph.totalDays, layout.mf) };
+  });
+}
+
+/**
+ * The last month's REMAINDER formula (spec §2.1). n=1: the whole total; n=2: `=F-I`
+ * (Google rewrites a one-cell range `SUM(I3:I3)` to `SUM(I3)`, so the read-back
+ * would never match — write the canonical form); n>2: `=F-SUM(first:second-to-last)`.
+ */
+function remainderFormula(r1, firstMonthC, n) {
+  if (n === 1) return `=F${r1}`;
+  if (n === 2) return `=F${r1}-${colLetter(firstMonthC)}${r1}`;
+  return `=F${r1}-SUM(${colLetter(firstMonthC)}${r1}:${colLetter(firstMonthC + n - 2)}${r1})`;
+}
+
+/**
+ * The cell values of ONE Team Mix grid starting at 0-based row `top` (spec §2.1):
+ * title, header, one row per person, Total, Total Days. Formulas use absolute rows.
+ */
+function teamMixValues(plan, roster, phase, top) {
   const n = roster.n;
   const firstMonthC = 8; // I
   const totalC = firstMonthC + n; // Total Hrs column index — derived, never remembered
@@ -742,18 +785,18 @@ function teamMixValues(plan, roster) {
   for (let m = 1; m <= n; m++) header.push(`Mon ${m}`);
   header.push("Total Hrs");
   const rows = [];
-  rows.push([plan.title, ...Array(width - 1).fill("")]);
+  rows.push([phase ? `${plan.title} — ${phase}` : plan.title, ...Array(width - 1).fill("")]);
   rows.push(header);
+  const firstP = top + 3; // 1-based row of the first person
   roster.people.forEach((p, i) => {
-    const r1 = 3 + i;
-    const row = [p.label, p.count, "", roster.months, `=D${r1}*20*B${r1}`, `=E${r1}*8`, "", p.label];
+    const r1 = firstP + i;
+    const row = [p.label, p.count, "", roster.monthsExact, `=D${r1}*20*B${r1}`, `=E${r1}*8`, "", p.label];
     for (let m = 0; m < n - 1; m++) row.push(p.monthHours[m]);
-    row.push(n === 1 ? `=F${r1}` : `=F${r1}-SUM(${L(firstMonthC)}${r1}:${L(firstMonthC + n - 2)}${r1})`);
+    row.push(remainderFormula(r1, firstMonthC, n));
     row.push(`=SUM(${L(firstMonthC)}${r1}:${L(totalC - 1)}${r1})`);
     rows.push(row);
   });
-  const firstP = 3;
-  const lastP = 2 + roster.people.length;
+  const lastP = firstP + roster.people.length - 1;
   const totalR = lastP + 1;
   const total = ["Total", `=SUM(B${firstP}:B${lastP})`, "", "", `=SUM(E${firstP}:E${lastP})`, `=SUM(F${firstP}:F${lastP})`, "", "Total Hours"];
   for (let c = firstMonthC; c <= totalC; c++) total.push(`=SUM(${L(c)}${firstP}:${L(c)}${lastP})`);
@@ -761,45 +804,65 @@ function teamMixValues(plan, roster) {
   const totalDays = ["", "", "", "", "", "", "", "Total Days"];
   for (let c = firstMonthC; c <= totalC; c++) totalDays.push(`=${L(c)}${totalR}/8`);
   rows.push(totalDays);
-  return { rows, width, totalC, firstMonthC, totalR, firstP, lastP };
+  return { rows, width, totalC, firstMonthC, top, titleR: top + 1, headerR: top + 2, firstP, lastP, totalR, totalDaysR: totalR + 1, bottom: totalR + 1 };
+}
+
+const GRID_GAP = 2; // blank rows between phase grids (spec §2.6)
+
+/** Format requests for one grid (spec §2.1 styling), computed from the grid's own shape. */
+function teamMixFormatReqs(sheetId, v) {
+  const W = v.width;
+  const arial = (bold) => ({ fontFamily: "Arial", fontSize: 10, bold });
+  const white = { backgroundColor: hexToColor(COLOR.white) };
+  const reqs = [];
+  const t0 = v.titleR - 1, h0 = v.headerR - 1, p0 = v.firstP - 1, p1 = v.lastP, tot0 = v.totalR - 1;
+  reqs.push({ mergeCells: { range: gridRange(sheetId, t0, t0 + 1, 0, W), mergeType: "MERGE_ALL" } });
+  reqs.push(fmtReq(sheetId, t0, t0 + 1, 0, W, { backgroundColor: hexToColor(COLOR.teamTitleBg), textFormat: { fontFamily: "Montserrat", fontSize: 20, bold: true, foregroundColor: hexToColor(COLOR.white) }, horizontalAlignment: "CENTER" }, "userEnteredFormat(backgroundColor,textFormat,horizontalAlignment)"));
+  reqs.push(fmtReq(sheetId, h0, v.bottom, 0, W, { textFormat: arial(false), horizontalAlignment: "RIGHT", numberFormat: { type: "NUMBER", pattern: "0.00" } }, FMT_FIELDS_ALL));
+  reqs.push(fmtReq(sheetId, h0, h0 + 1, 0, W, { backgroundColor: hexToColor(COLOR.teamHeaderBg), textFormat: { ...arial(true), foregroundColor: hexToColor(COLOR.white) } }, "userEnteredFormat(backgroundColor,textFormat)"));
+  reqs.push(fmtReq(sheetId, h0, h0 + 1, 2, 3, white, "userEnteredFormat.backgroundColor"));
+  reqs.push(fmtReq(sheetId, h0, h0 + 1, 6, 7, white, "userEnteredFormat.backgroundColor"));
+  reqs.push(fmtReq(sheetId, h0, v.bottom, 0, 1, { horizontalAlignment: "LEFT" }, "userEnteredFormat.horizontalAlignment"));
+  reqs.push(fmtReq(sheetId, h0, v.bottom, 7, 8, { horizontalAlignment: "LEFT" }, "userEnteredFormat.horizontalAlignment"));
+  reqs.push(fmtReq(sheetId, h0, h0 + 1, v.totalC, v.totalC + 1, { horizontalAlignment: "LEFT" }, "userEnteredFormat.horizontalAlignment"));
+  const sage = { backgroundColor: hexToColor(COLOR.sage), textFormat: arial(true) };
+  reqs.push(fmtReq(sheetId, p0, p1, 4, 6, sage, "userEnteredFormat(backgroundColor,textFormat)"));
+  reqs.push(fmtReq(sheetId, p0, p1, v.totalC, v.totalC + 1, sage, "userEnteredFormat(backgroundColor,textFormat)"));
+  reqs.push(fmtReq(sheetId, tot0, tot0 + 1, 0, W, { backgroundColor: hexToColor(COLOR.totalBg), textFormat: arial(true) }, "userEnteredFormat(backgroundColor,textFormat)"));
+  reqs.push(fmtReq(sheetId, tot0, tot0 + 1, 2, 3, white, "userEnteredFormat.backgroundColor"));
+  reqs.push(fmtReq(sheetId, tot0, tot0 + 1, 6, 7, white, "userEnteredFormat.backgroundColor"));
+  reqs.push(fmtReq(sheetId, tot0 + 1, tot0 + 2, 7, W, { backgroundColor: hexToColor(COLOR.totalDaysBg), textFormat: arial(true) }, "userEnteredFormat(backgroundColor,textFormat)"));
+  return reqs;
 }
 
-async function writeTeamMix(api, plan, roster) {
+/** Write every phase grid on the one Team Mix tab: clear-then-paint, GRID_GAP blank rows between grids. */
+async function writeTeamMix(api, plan, rosters) {
   const grid = await api.grid(TAB_TEAM);
   const sheetId = grid.properties.sheetId;
-  const v = teamMixValues(plan, roster);
-  const clearRows = Math.max(60, rowCount(grid) + 2);
+  const grids = [];
+  let top = 0;
+  for (const r of rosters) {
+    const v = teamMixValues(plan, r.roster, rosters.length > 1 || r.phase ? r.phase : "", top);
+    grids.push({ phase: r.phase, v });
+    top = v.bottom + GRID_GAP;
+  }
+  const lastRow = grids[grids.length - 1].v.bottom;
+  const clearRows = Math.max(60, rowCount(grid) + 2, lastRow + 10);
   await api.clearValues(TAB_TEAM, `A1:Z${clearRows}`);
   await api.batch([
     { unmergeCells: { range: gridRange(sheetId, 0, clearRows, 0, 26) } },
     fmtReq(sheetId, 0, clearRows, 0, 26, {}, "userEnteredFormat"),
   ]);
-  await api.putValues(TAB_TEAM, `A1:${colLetter(v.width - 1)}${v.rows.length}`, v.rows);
-  const W = v.width;
-  const arial = (bold) => ({ fontFamily: "Arial", fontSize: 10, bold });
-  const white = { backgroundColor: hexToColor(COLOR.white) };
   const reqs = [];
-  reqs.push({ mergeCells: { range: gridRange(sheetId, 0, 1, 0, W), mergeType: "MERGE_ALL" } });
-  reqs.push(fmtReq(sheetId, 0, 1, 0, W, { backgroundColor: hexToColor(COLOR.teamTitleBg), textFormat: { fontFamily: "Montserrat", fontSize: 20, bold: true, foregroundColor: hexToColor(COLOR.white) }, horizontalAlignment: "CENTER" }, "userEnteredFormat(backgroundColor,textFormat,horizontalAlignment)"));
-  reqs.push(fmtReq(sheetId, 1, v.rows.length, 0, W, { textFormat: arial(false), horizontalAlignment: "RIGHT", numberFormat: { type: "NUMBER", pattern: "0.00" } }, FMT_FIELDS_ALL));
-  reqs.push(fmtReq(sheetId, 1, 2, 0, W, { backgroundColor: hexToColor(COLOR.teamHeaderBg), textFormat: { ...arial(true), foregroundColor: hexToColor(COLOR.white) } }, "userEnteredFormat(backgroundColor,textFormat)"));
-  reqs.push(fmtReq(sheetId, 1, 2, 2, 3, white, "userEnteredFormat.backgroundColor"));
-  reqs.push(fmtReq(sheetId, 1, 2, 6, 7, white, "userEnteredFormat.backgroundColor"));
-  reqs.push(fmtReq(sheetId, 1, v.rows.length, 0, 1, { horizontalAlignment: "LEFT" }, "userEnteredFormat.horizontalAlignment"));
-  reqs.push(fmtReq(sheetId, 1, v.rows.length, 7, 8, { horizontalAlignment: "LEFT" }, "userEnteredFormat.horizontalAlignment"));
-  reqs.push(fmtReq(sheetId, 1, 2, v.totalC, v.totalC + 1, { horizontalAlignment: "LEFT" }, "userEnteredFormat.horizontalAlignment"));
-  const p0 = v.firstP - 1, p1 = v.lastP;
-  const sage = { backgroundColor: hexToColor(COLOR.sage), textFormat: arial(true) };
-  reqs.push(fmtReq(sheetId, p0, p1, 4, 6, sage, "userEnteredFormat(backgroundColor,textFormat)"));
-  reqs.push(fmtReq(sheetId, p0, p1, v.totalC, v.totalC + 1, sage, "userEnteredFormat(backgroundColor,textFormat)"));
-  const t0 = v.totalR - 1;
-  reqs.push(fmtReq(sheetId, t0, t0 + 1, 0, W, { backgroundColor: hexToColor(COLOR.totalBg), textFormat: arial(true) }, "userEnteredFormat(backgroundColor,textFormat)"));
-  reqs.push(fmtReq(sheetId, t0, t0 + 1, 2, 3, white, "userEnteredFormat.backgroundColor"));
-  reqs.push(fmtReq(sheetId, t0, t0 + 1, 6, 7, white, "userEnteredFormat.backgroundColor"));
-  reqs.push(fmtReq(sheetId, t0 + 1, t0 + 2, 7, W, { backgroundColor: hexToColor(COLOR.totalDaysBg), textFormat: arial(true) }, "userEnteredFormat(backgroundColor,textFormat)"));
-  reqs.push(...widthReqs(sheetId, [...TEAM_WIDTHS_FIXED, ...Array(roster.n).fill(TEAM_MONTH_WIDTH), TEAM_TOTAL_WIDTH]));
+  let maxN = 0;
+  for (const g of grids) {
+    await api.putValues(TAB_TEAM, `A${g.v.titleR}:${colLetter(g.v.width - 1)}${g.v.bottom}`, g.v.rows);
+    reqs.push(...teamMixFormatReqs(sheetId, g.v));
+    maxN = Math.max(maxN, g.v.totalC - g.v.firstMonthC);
+  }
+  reqs.push(...widthReqs(sheetId, [...TEAM_WIDTHS_FIXED, ...Array(maxN).fill(TEAM_MONTH_WIDTH), TEAM_TOTAL_WIDTH]));
   await api.batch(reqs);
-  return v;
+  return { grids: grids.map((g) => ({ phase: g.phase, titleR: g.v.titleR, bottom: g.v.bottom, rows: g.v.rows.length })), lastRow };
 }
 
 // ───────────────────────── write: Technology Stack (spec §3) ─────────────────────────
@@ -865,7 +928,22 @@ function auditTshirt(grid) {
   check(out, "T-Shirt: section rows are styled (bg #1C4F8B)", !badSectionFmt.length, badSectionFmt.join(", "));
   check(out, "T-Shirt: 'Total (Days)' row exists below the items", totalRow0 > lastItem0 && lastItem0 >= 0, "not found");
   let totalDaysCell = NaN;
+  const phaseDays = {};
+  for (const rr of layout.rollupRows) {
+    const hrs = numAt(grid, rr, 11); // L = Low Hrs for that phase
+    phaseDays[textAt(grid, rr, 9).trim()] = Number.isNaN(hrs) ? NaN : round2(hrs / 8);
+  }
   if (totalRow0 > lastItem0 && lastItem0 >= 0) {
+    check(out, "T-Shirt: totals row sits directly under the last item (no blank row)", totalRow0 === lastItem0 + 1, `last item row ${lastItem0 + 1}, totals row ${totalRow0 + 1}`);
+    const totFont = fontAt(grid, totalRow0, 0);
+    check(out, "T-Shirt: totals row is the template band (bg #D8DDE8, bold) across A:L", [0, 4, 9, 11].every((c) => bgAt(grid, totalRow0, c) === COLOR.tshirtTotalBg) && totFont.bold, `A bg ${bgAt(grid, totalRow0, 0)}, L bg ${bgAt(grid, totalRow0, 11)}, bold ${totFont.bold}`);
+    const sumRows = [totalRow0 + 1, totalRow0 + 2, totalRow0 + 3];
+    const labels = sumRows.map((r) => textAt(grid, r, 9));
+    check(out, "T-Shirt: summary block (Total Days / Total Hrs / Total Cost) sits directly under the totals row", labels[0] === "Total Days" && labels[1] === "Total Hrs" && labels[2] === "Total Cost", `J${sumRows[0] + 1}..J${sumRows[2] + 1} = [${labels.join(", ")}]`);
+    check(out, "T-Shirt: summary labels are bold", sumRows.every((r) => fontAt(grid, r, 9).bold), "");
+    const costCell = cellAt(grid, sumRows[2], 10);
+    const costFmt = costCell && costCell.userEnteredFormat && costCell.userEnteredFormat.numberFormat;
+    check(out, "T-Shirt: Total Cost is formatted as dollars", !!costFmt && costFmt.type === "CURRENCY", `K${sumRows[2] + 1} numberFormat ${JSON.stringify(costFmt)}`);
     const want = `=SUM(J${first0 + 1}:J${lastItem0 + 1})`;
     check(out, "T-Shirt: totals row sums the full item range", formulaAt(grid, totalRow0, 9) === want, `J${totalRow0 + 1} is '${formulaAt(grid, totalRow0, 9)}', want '${want}'`);
     totalDaysCell = numAt(grid, totalRow0, 9);
@@ -876,7 +954,7 @@ function auditTshirt(grid) {
     check(out, "T-Shirt: phase rollups (K4:N7) reference the full item range", !badRoll.length, badRoll.join(", "));
     let summaryAbove = false;
     for (let r = first0; r < totalRow0; r++) if (/^Total (Days|Hrs|Cost)$/i.test(textAt(grid, r, 9))) summaryAbove = true;
-    check(out, "T-Shirt: summary block is below the totals row", !summaryAbove, "a Total Days/Hrs/Cost label sits inside the summed range");
+    check(out, "T-Shirt: no summary label inside the summed range", !summaryAbove, "a Total Days/Hrs/Cost label sits inside the summed range");
     let raw = 0;
     for (let r = first0; r <= lastItem0; r++) {
       for (const c of [5, 6]) { const v = textAt(grid, r, c).trim(); if (v && layout.legend[v] != null) raw += layout.legend[v]; }
@@ -884,7 +962,7 @@ function auditTshirt(grid) {
     const recomputed = round2(raw * (1 + layout.mfTotal));
     check(out, "T-Shirt: Σ raw sizes × (1+MF) == Total Days cell", Math.abs(recomputed - totalDaysCell) < 0.02, `recomputed ${recomputed}, cell ${totalDaysCell}`);
   }
-  return { checks: out, layout, totalDays: totalDaysCell, lastItem1: lastItem0 + 1 };
+  return { checks: out, layout, totalDays: totalDaysCell, lastItem1: lastItem0 + 1, phaseDays };
 }
 
 function disciplineOfLabel(label) {
@@ -899,95 +977,132 @@ function disciplineOfLabel(label) {
   return "";
 }
 
-/** Team Mix audit. mfList (from the T-Shirt tab) is REQUIRED; tshirtTotalDays may be NaN only when the T-Shirt has no totals row. */
-function auditTeamMix(grid, mfList, tshirtTotalDays) {
+/**
+ * Team Mix audit — one grid per phase with hours (spec §2.6). mfList (from the T-Shirt
+ * tab) is REQUIRED. phaseDays = { phase: days } read from the T-Shirt rollups (the
+ * independent figure each grid must reconcile to); tshirtTotalDays for the sum.
+ */
+function auditTeamMix(grid, mfList, tshirtTotalDays, phaseDays) {
   const out = [];
-  const hdr = [];
-  for (let c = 0; c < 30; c++) hdr.push(textAt(grid, 1, c));
-  check(out, "Team Mix: row 2 is the header (A2='Skill set')", hdr[0] === "Skill set", `A2='${hdr[0]}'`);
-  check(out, "Team Mix: row 3 is a person, not a second header", textAt(grid, 2, 0) !== "Skill set" && textAt(grid, 2, 0) !== "", `A3='${textAt(grid, 2, 0)}'`);
-  const monthCols = [];
-  hdr.forEach((h, c) => { if (/^Mon \d+$/.test(h)) monthCols.push(c); });
-  const totalC = hdr.indexOf("Total Hrs");
-  const lastM = monthCols.length ? monthCols[monthCols.length - 1] : -1;
-  check(out, "Team Mix: month headers are Mon 1..N, contiguous, then Total Hrs", monthCols.length > 0 && totalC === lastM + 1 && monthCols.every((c, i) => hdr[c] === `Mon ${i + 1}` && c === monthCols[0] + i), `months [${monthCols.map((c) => hdr[c]).join(",")}], Total Hrs at column ${totalC}`);
-  check(out, "Team Mix: header columns are Skill set/Count/Mths/Days/Hrs/Resource", hdr[1] === "Count" && hdr[3] === "Mths" && hdr[4] === "Days" && hdr[5] === "Hrs" && hdr[7] === "Resource", hdr.slice(0, 8).join("|"));
-  const people = [];
-  let totalR = -1;
-  for (let r = 2; r < rowCount(grid); r++) {
-    const a = textAt(grid, r, 0);
-    if (/^Total$/i.test(a)) { totalR = r; break; }
-    if (a === "") break;
-    people.push({ r, label: a, count: numAt(grid, r, 1), discipline: disciplineOfLabel(a) });
-  }
-  check(out, "Team Mix: a 'Total' row follows the people", totalR > 2, "no Total row");
-  check(out, "Team Mix: every person has a numeric Count", people.every((p) => !Number.isNaN(p.count)), people.filter((p) => Number.isNaN(p.count)).map((p) => p.label).join(", "));
-  check(out, "Team Mix: no Count > 1.00", people.every((p) => p.count <= 1 + 1e-9), people.filter((p) => p.count > 1).map((p) => `${p.label}=${p.count}`).join(", "));
-  const groups = {};
-  people.forEach((p) => { const k = p.label.replace(/\s+\d+$/, ""); (groups[k] = groups[k] ? groups[k] : []).push(p); });
-  const smeared = [];
-  for (const [k, rows] of Object.entries(groups)) rows.slice(0, -1).forEach((p) => { if (Math.abs(p.count - 1) > 1e-9) smeared.push(`${k}: ${p.count} before a later row`); });
-  check(out, "Team Mix: per discipline, all rows but the last are 1.00 (saturate then spill)", !smeared.length, smeared.join("; "));
-  const cov = mfCoverageViolations(mfList, people.filter((p) => p.discipline));
-  check(out, "Team Mix: every non-zero MF factor has a person", !cov.length, cov.join("; "));
-  const badF = [], negative = [], over = [];
-  if (monthCols.length && totalC > 0) {
-    const firstM = monthCols[0];
-    for (const p of people) {
-      const r1 = p.r + 1;
-      if (formulaAt(grid, p.r, 4) !== `=D${r1}*20*B${r1}`) badF.push(`E${r1}`);
-      if (formulaAt(grid, p.r, 5) !== `=E${r1}*8`) badF.push(`F${r1}`);
-      if (monthCols.length > 1) {
-        const want = `=F${r1}-SUM(${colLetter(firstM)}${r1}:${colLetter(lastM - 1)}${r1})`;
-        if (formulaAt(grid, p.r, lastM) !== want) badF.push(`${colLetter(lastM)}${r1} (remainder)`);
+  // locate grids: every row whose A == 'Skill set' is a header; its title is the row above
+  const headers = [];
+  for (let r = 0; r < rowCount(grid); r++) if (textAt(grid, r, 0) === "Skill set") headers.push(r);
+  check(out, "Team Mix: at least one grid (a 'Skill set' header row)", headers.length > 0, "no header row found");
+  const expectedPhases = phaseDays ? Object.keys(phaseDays).filter((ph) => phaseDays[ph] > 0) : [];
+  if (expectedPhases.length) check(out, "Team Mix: one grid per phase with hours", headers.length === expectedPhases.length, `${headers.length} grid(s) for phases [${expectedPhases.join(", ")}]`);
+  let sumDaysAll = 0;
+  let tolAll = 0;
+  let prevBottom = -1;
+  headers.forEach((h, gi) => {
+    const label = headers.length > 1 ? `Team Mix grid ${gi + 1}` : "Team Mix";
+    const title = textAt(grid, h - 1, 0);
+    check(out, `${label}: title row directly above the header`, h >= 1 && title !== "" && title !== "Skill set", `row ${h} above header is '${title}'`);
+    if (gi > 0) {
+      const gap = h - 1 - (prevBottom + 1);
+      check(out, `${label}: exactly ${GRID_GAP} blank rows before it`, gap === GRID_GAP, `${gap} row(s) between the previous grid and this title`);
+      let strayGap = [];
+      for (let r = prevBottom + 1; r < h - 1; r++) for (let c = 0; c < 26; c++) if (textAt(grid, r, c) !== "" || bgAt(grid, r, c) !== COLOR.white) strayGap.push(`${colLetter(c)}${r + 1}`);
+      check(out, `${label}: the gap rows are empty and unformatted`, !strayGap.length, strayGap.slice(0, 6).join(", "));
+    }
+    const hdr = [];
+    for (let c = 0; c < 30; c++) hdr.push(textAt(grid, h, c));
+    check(out, `${label}: row after the header is a person, not a second header`, textAt(grid, h + 1, 0) !== "Skill set" && textAt(grid, h + 1, 0) !== "", `A${h + 2}='${textAt(grid, h + 1, 0)}'`);
+    const monthCols = [];
+    hdr.forEach((x, c) => { if (/^Mon \d+$/.test(x)) monthCols.push(c); });
+    const totalC = hdr.indexOf("Total Hrs");
+    const lastM = monthCols.length ? monthCols[monthCols.length - 1] : -1;
+    check(out, `${label}: month headers are Mon 1..N, contiguous, then Total Hrs`, monthCols.length > 0 && totalC === lastM + 1 && monthCols.every((c, i) => hdr[c] === `Mon ${i + 1}` && c === monthCols[0] + i), `months [${monthCols.map((c) => hdr[c]).join(",")}], Total Hrs at column ${totalC}`);
+    check(out, `${label}: header columns are Skill set/Count/Mths/Days/Hrs/Resource`, hdr[1] === "Count" && hdr[3] === "Mths" && hdr[4] === "Days" && hdr[5] === "Hrs" && hdr[7] === "Resource", hdr.slice(0, 8).join("|"));
+    const people = [];
+    let totalR = -1;
+    for (let r = h + 1; r < rowCount(grid); r++) {
+      const a = textAt(grid, r, 0);
+      if (/^Total$/i.test(a)) { totalR = r; break; }
+      if (a === "") break;
+      people.push({ r, label: a, count: numAt(grid, r, 1), discipline: disciplineOfLabel(a) });
+    }
+    check(out, `${label}: a 'Total' row follows the people`, totalR > h, "no Total row");
+    check(out, `${label}: every person has a numeric Count`, people.every((p) => !Number.isNaN(p.count)), people.filter((p) => Number.isNaN(p.count)).map((p) => p.label).join(", "));
+    check(out, `${label}: no Count > 1.00`, people.every((p) => p.count <= 1 + 1e-9), people.filter((p) => p.count > 1).map((p) => `${p.label}=${p.count}`).join(", "));
+    const groups = {};
+    people.forEach((p) => { const k = p.label.replace(/\s+\d+$/, ""); (groups[k] = groups[k] ? groups[k] : []).push(p); });
+    const smeared = [];
+    for (const [k, rows] of Object.entries(groups)) rows.slice(0, -1).forEach((p) => { if (Math.abs(p.count - 1) > 1e-9) smeared.push(`${k}: ${p.count} before a later row`); });
+    check(out, `${label}: per discipline, all rows but the last are 1.00 (saturate then spill)`, !smeared.length, smeared.join("; "));
+    const cov = mfCoverageViolations(mfList, people.filter((p) => p.discipline));
+    check(out, `${label}: every non-zero MF factor has a person`, !cov.length, cov.join("; "));
+    const badF = [], negative = [], over = [];
+    if (monthCols.length && totalC > 0) {
+      const firstM = monthCols[0];
+      for (const p of people) {
+        const r1 = p.r + 1;
+        if (formulaAt(grid, p.r, 4) !== `=D${r1}*20*B${r1}`) badF.push(`E${r1}`);
+        if (formulaAt(grid, p.r, 5) !== `=E${r1}*8`) badF.push(`F${r1}`);
+        if (monthCols.length > 1 && formulaAt(grid, p.r, lastM) !== remainderFormula(r1, firstM, monthCols.length)) badF.push(`${colLetter(lastM)}${r1} (remainder)`);
+        if (!formulaAt(grid, p.r, totalC).startsWith("=")) badF.push(`${colLetter(totalC)}${r1}`);
+        for (const c of monthCols) {
+          const hv = numAt(grid, p.r, c);
+          if (Number.isNaN(hv)) negative.push(`${colLetter(c)}${r1}=not a number`);
+          else if (hv < -1e-9) negative.push(`${colLetter(c)}${r1}=${hv}`);
+          else if (hv > SOFT_CEILING + 1e-9) over.push(`${colLetter(c)}${r1}=${hv}`);
+        }
       }
-      if (!formulaAt(grid, p.r, totalC).startsWith("=")) badF.push(`${colLetter(totalC)}${r1}`);
-      for (const c of monthCols) {
-        const h = numAt(grid, p.r, c);
-        if (Number.isNaN(h)) negative.push(`${colLetter(c)}${r1}=not a number`);
-        else if (h < -1e-9) negative.push(`${colLetter(c)}${r1}=${h}`);
-        else if (h > SOFT_CEILING + 1e-9) over.push(`${colLetter(c)}${r1}=${h}`);
+    }
+    check(out, `${label}: Days/Hrs/remainder/Total Hrs are formulas`, !badF.length, badF.join(", "));
+    check(out, `${label}: no negative or non-numeric month`, !negative.length, negative.join(", "));
+    check(out, `${label}: no month cell above ${SOFT_CEILING} hrs`, !over.length, over.join(", "));
+    if (monthCols.length > 1 && people.length) {
+      const flat = people.filter((p) => p.discipline !== "pm").every((p) => {
+        const vals = monthCols.map((c) => round1(numAt(grid, p.r, c)));
+        return vals.every((x) => Math.abs(x - vals[0]) < 0.05);
+      });
+      check(out, `${label}: ramp applied (roles are not all flat)`, !flat, "every non-PM role has identical hours each month");
+    }
+    const badFont = [], badSage = [], whiteMissing = [];
+    for (const p of people) {
+      for (let c = 0; c <= totalC; c++) {
+        const f = fontAt(grid, p.r, c);
+        if (f.family && f.family !== "Arial") badFont.push(`${colLetter(c)}${p.r + 1}=${f.family}`);
+        const bg = bgAt(grid, p.r, c);
+        const shouldSage = c === 4 || c === 5 || c === totalC;
+        if (shouldSage && bg !== COLOR.sage) badSage.push(`${colLetter(c)}${p.r + 1} bg ${bg}`);
+        if (!shouldSage && bg !== COLOR.white) whiteMissing.push(`${colLetter(c)}${p.r + 1} bg ${bg}`);
       }
     }
-  }
-  check(out, "Team Mix: Days/Hrs/remainder/Total Hrs are formulas", !badF.length, badF.join(", "));
-  check(out, "Team Mix: no negative or non-numeric month", !negative.length, negative.join(", "));
-  check(out, `Team Mix: no month cell above ${SOFT_CEILING} hrs`, !over.length, over.join(", "));
-  if (monthCols.length > 1 && people.length) {
-    const flat = people.filter((p) => p.discipline !== "pm").every((p) => {
-      const vals = monthCols.map((c) => round1(numAt(grid, p.r, c)));
-      return vals.every((v) => Math.abs(v - vals[0]) < 0.05);
-    });
-    check(out, "Team Mix: ramp applied (roles are not all flat)", !flat, "every non-PM role has identical hours each month");
-  }
-  const badFont = [], badSage = [], whiteMissing = [];
-  for (const p of people) {
-    for (let c = 0; c <= totalC; c++) {
-      const f = fontAt(grid, p.r, c);
-      if (f.family && f.family !== "Arial") badFont.push(`${colLetter(c)}${p.r + 1}=${f.family}`);
-      const bg = bgAt(grid, p.r, c);
-      const shouldSage = c === 4 || c === 5 || c === totalC;
-      if (shouldSage && bg !== COLOR.sage) badSage.push(`${colLetter(c)}${p.r + 1} bg ${bg}`);
-      if (!shouldSage && bg !== COLOR.white) whiteMissing.push(`${colLetter(c)}${p.r + 1} bg ${bg}`);
+    check(out, `${label}: body font is Arial (never Calibri)`, !badFont.length, badFont.slice(0, 8).join(", "));
+    check(out, `${label}: sage on exactly Days, Hrs, Total Hrs of role rows`, !badSage.length && !whiteMissing.length, [...badSage, ...whiteMissing].slice(0, 8).join(", "));
+    if (totalR > 0 && totalC > 0) {
+      const bandBad = [];
+      for (const c of [...monthCols, totalC, 0, 1]) if (bgAt(grid, totalR, c) !== COLOR.totalBg) bandBad.push(`${colLetter(c)}${totalR + 1}`);
+      for (const c of [...monthCols, totalC, 7]) if (bgAt(grid, totalR + 1, c) !== COLOR.totalDaysBg) bandBad.push(`${colLetter(c)}${totalR + 2}`);
+      check(out, `${label}: Total (#E5E5E5) and Total Days (#9EC1EF) bands span every month + Total Hrs`, !bandBad.length, bandBad.join(", "));
+      const strayRight = [];
+      for (let r = h - 1; r <= totalR + 1; r++) for (let c = totalC + 1; c < 26; c++) if (bgAt(grid, r, c) !== COLOR.white) strayRight.push(`${colLetter(c)}${r + 1}`);
+      check(out, `${label}: nothing formatted right of the grid`, !strayRight.length, strayRight.slice(0, 8).join(", "));
+      const sumDays = numAt(grid, totalR, 4);
+      const sumCount = numAt(grid, totalR, 1);
+      sumDaysAll += Number.isNaN(sumDays) ? 0 : sumDays;
+      // Mths is written to 2 decimals (the sheet convention), so Σ Days can drift by up to
+      // ΣCount × 20 × 0.005 from the exact figure — the tolerance follows the roster size.
+      const tol = 0.05 + 0.1 * (Number.isNaN(sumCount) ? 1 : sumCount);
+      tolAll += tol;
+      const phase = expectedPhases.find((ph) => title.endsWith(ph));
+      if (expectedPhases.length) {
+        check(out, `${label}: title names a phase with hours`, !!phase, `title '${title}' ends with none of [${expectedPhases.join(", ")}]`);
+        if (phase) check(out, `${label} (${phase}): Σ Days == that phase's T-Shirt days`, Math.abs(sumDays - phaseDays[phase]) < tol, `Team Mix ${sumDays}, T-Shirt ${phaseDays[phase]} (tolerance ${round2(tol)})`);
+      }
+      prevBottom = totalR + 1;
     }
+  });
+  if (prevBottom >= 0) {
+    const strayBelow = [];
+    for (let r = prevBottom + 1; r < Math.min(rowCount(grid), prevBottom + 40); r++) for (let c = 0; c < 26; c++) if (bgAt(grid, r, c) !== COLOR.white) strayBelow.push(`${colLetter(c)}${r + 1}`);
+    check(out, "Team Mix: nothing formatted below the last grid", !strayBelow.length, strayBelow.slice(0, 8).join(", "));
   }
-  check(out, "Team Mix: body font is Arial (never Calibri)", !badFont.length, badFont.slice(0, 8).join(", "));
-  check(out, "Team Mix: sage on exactly Days, Hrs, Total Hrs of role rows", !badSage.length && !whiteMissing.length, [...badSage, ...whiteMissing].slice(0, 8).join(", "));
-  if (totalR > 0 && totalC > 0) {
-    const bandBad = [];
-    for (const c of [...monthCols, totalC, 0, 1]) if (bgAt(grid, totalR, c) !== COLOR.totalBg) bandBad.push(`${colLetter(c)}${totalR + 1}`);
-    for (const c of [...monthCols, totalC, 7]) if (bgAt(grid, totalR + 1, c) !== COLOR.totalDaysBg) bandBad.push(`${colLetter(c)}${totalR + 2}`);
-    check(out, "Team Mix: Total (#E5E5E5) and Total Days (#9EC1EF) bands span every month + Total Hrs", !bandBad.length, bandBad.join(", "));
-    const stray = [];
-    for (let r = totalR + 2; r < Math.min(rowCount(grid), totalR + 40); r++) for (let c = 0; c < 26; c++) if (bgAt(grid, r, c) !== COLOR.white) stray.push(`${colLetter(c)}${r + 1}`);
-    for (let r = 0; r <= totalR + 1; r++) for (let c = totalC + 1; c < 26; c++) if (bgAt(grid, r, c) !== COLOR.white) stray.push(`${colLetter(c)}${r + 1}`);
-    check(out, "Team Mix: nothing formatted outside the data area", !stray.length, stray.slice(0, 8).join(", "));
-    const sumDays = numAt(grid, totalR, 4);
-    if (!Number.isNaN(tshirtTotalDays)) {
-      check(out, "Team Mix: Σ Days == T-Shirt Total Days", Math.abs(sumDays - tshirtTotalDays) < 0.15, `Team Mix ${sumDays}, T-Shirt ${tshirtTotalDays}`);
-    }
+  if (!Number.isNaN(tshirtTotalDays) && headers.length) {
+    check(out, "Team Mix: Σ Days over all grids == T-Shirt Total Days", Math.abs(sumDaysAll - tshirtTotalDays) < Math.max(0.15, tolAll), `Team Mix ${round2(sumDaysAll)}, T-Shirt ${tshirtTotalDays} (tolerance ${round2(Math.max(0.15, tolAll))})`);
   }
-  return { checks: out, people: people.length, months: monthCols.length };
+  return { checks: out, grids: headers.length };
 }
 
 function auditTechStack(grid) {
@@ -1019,7 +1134,7 @@ async function runAudit(api) {
   const checks = [];
   const tshirt = auditTshirt(await api.grid(TAB_TSHIRT));
   checks.push(...tshirt.checks);
-  checks.push(...auditTeamMix(await api.grid(TAB_TEAM), tshirt.layout.mf, tshirt.totalDays).checks);
+  checks.push(...auditTeamMix(await api.grid(TAB_TEAM), tshirt.layout.mf, tshirt.totalDays, tshirt.phaseDays).checks);
   checks.push(...auditTechStack(await api.grid(TAB_TECH)).checks);
   if (tabs.has(TAB_OVERVIEW)) checks.push(...auditOverview(await api.grid(TAB_OVERVIEW)).checks);
   else check(checks, "Overview tab exists (the estimates index imports its cells)", false, "missing");
@@ -1075,21 +1190,25 @@ async function verbRead(api, tab) {
   return out;
 }
 
+function rostersTable(rosters) {
+  return rosters.map((r) => `── ${r.phase}: ${r.totalDays} d ──\n${rosterTable(r.roster)}`).join("\n");
+}
+
 async function verbPlanCheck(api, plan) {
   const layout = locateTshirt(await api.grid(TAB_TSHIRT));
   const totals = tshirtTotals(plan, layout);
-  const roster = buildRoster(plan, totals.totalDays, layout.mf);
-  return { totals, mf: layout.mf, mfTotal: round2(layout.mfTotal), highFactor: layout.highFactor, rate: layout.rate, roster, table: rosterTable(roster) };
+  const rosters = buildRosters(plan, layout);
+  return { totals, mf: layout.mf, mfTotal: round2(layout.mfTotal), highFactor: layout.highFactor, rate: layout.rate, rosters, table: rostersTable(rosters) };
 }
 
 async function verbWrite(api, plan, opts) {
   const ts = await writeTshirt(api, plan, opts);
-  const roster = buildRoster(plan, ts.totals.totalDays, ts.layout.mf);
-  const tm = await writeTeamMix(api, plan, roster);
+  const rosters = buildRosters(plan, ts.layout);
+  const tm = await writeTeamMix(api, plan, rosters);
   const tech = await writeTechStack(api, plan);
   const result = {
     tshirt: { mode: plan.tshirt.mode, itemsWritten: ts.itemsWritten, firstItem1: ts.firstItem1, lastItem1: ts.lastItem1, totalRow1: ts.totalRow1, totals: ts.totals },
-    teamMix: { people: roster.people.length, months: roster.months, columns: roster.n, sumDays: roster.sumDays, table: rosterTable(roster), rowsWritten: tm.rows.length },
+    teamMix: { grids: tm.grids, phases: rosters.map((r) => ({ phase: r.phase, totalDays: r.totalDays, people: r.roster.people.length, months: r.roster.months, columns: r.roster.n, sumDays: r.roster.sumDays })), table: rostersTable(rosters), lastRow: tm.lastRow },
     techStack: tech,
   };
   if (!opts.noAudit) result.audit = await runAudit(api);
@@ -1152,7 +1271,7 @@ async function main(args) {
     if (json) console.log(JSON.stringify({ ok, exitCode: ok ? 0 : 4, ...r }, null, 2));
     else {
       console.log(`T-Shirt (${r.tshirt.mode}): ${r.tshirt.itemsWritten} items, rows ${r.tshirt.firstItem1}–${r.tshirt.lastItem1}, totals row ${r.tshirt.totalRow1}; total ${r.tshirt.totals.totalDays} d, $${r.tshirt.totals.lowDollars} – $${r.tshirt.totals.highDollars}`);
-      console.log(`Team Mix: ${r.teamMix.people} people, ${r.teamMix.months} months, ${r.teamMix.columns} columns, Σ Days ${r.teamMix.sumDays}`);
+      for (const ph of r.teamMix.phases) console.log(`Team Mix — ${ph.phase}: ${ph.people} people, ${ph.months} months, ${ph.columns} columns, Σ Days ${ph.sumDays}`);
       console.log(r.teamMix.table);
       console.log(`Technology Stack: ${r.techStack.rows} rows`);
       if (r.audit) printChecks(r.audit);
@@ -1172,7 +1291,7 @@ function haltAndExit(e, json) {
 
 module.exports = {
   validatePlan, splitRoster, rosterViolations, mfCoverageViolations, monthPlan, resampleWeights, rampHours, buildRoster,
-  tshirtTotals, itemFormulas, rollupFormulas, tshirtRows, teamMixValues, locateTshirt, findPhaseSource,
+  tshirtTotals, phaseTotals, buildRosters, itemFormulas, rollupFormulas, tshirtRows, teamMixValues, teamMixFormatReqs, remainderFormula, locateTshirt, findPhaseSource,
   auditTshirt, auditTeamMix, auditTechStack, auditOverview, colLetter, hexToColor, colorToHex, sheetIdFromArg,
   constants: { SIZE_CODES, PHASES, COLOR, RAMP, ROLE_LABEL, SOFT_CEILING, FOLD_THRESHOLD, TAB_TSHIRT, TAB_TEAM, TAB_TECH, PLAN_SCHEMA },
   Halt, SheetsApi, getToken, runAudit, main,

package/bin/gsd-t.js

@@ -3466,6 +3466,20 @@ async function doUpdateAll() {
   );
 }
 
+// Numeric dotted-version compare: negative when a < b, 0 when equal, positive when a > b.
+// GSD-T versions are plain Major.Minor.Patch integers (patch always ≥ 10), so a
+// segment-wise numeric compare is exact; no prerelease tags exist.
+function versionCmp(a, b) {
+  const pa = String(a).split(".").map((n) => parseInt(n, 10));
+  const pb = String(b).split(".").map((n) => parseInt(n, 10));
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const x = Number.isNaN(pa[i]) ? 0 : pa[i];
+    const y = Number.isNaN(pb[i]) ? 0 : pb[i];
+    if (x !== y) return x - y;
+  }
+  return 0;
+}
+
 // Upgrade the globally-installed @tekyzinc/gsd-t to @latest. Returns
 // { upgraded: bool, reexec: bool, error?: string }.
 // - reexec=true when the on-disk version after `npm install -g` is newer than
@@ -3499,6 +3513,19 @@ async function upgradeGlobalBinary() {
     // Best-effort; fall through.
   }
 
+  if (newVersion && versionCmp(newVersion, PKG_VERSION) < 0) {
+    // v5.20.10 (2026-09-17): right after `npm publish`, npm's cached package
+    // listing still named the PREVIOUS version as @latest, so this step
+    // installed 5.19.11 over a running 5.20.10, reported it as an "upgrade",
+    // handed off to the OLD binary, and that binary overwrote ~/.claude/commands
+    // and every project with the old release. A downgrade is never an upgrade —
+    // HALT and say how to fix it, never continue on a stale listing.
+    error(`HALT: npm installed v${newVersion} over the running v${PKG_VERSION} — @latest resolved to an OLDER release.`);
+    info("npm's cached package listing is stale. Run `npm cache clean --force`, wait until");
+    info(`\`curl -sI https://registry.npmjs.org/@tekyzinc/gsd-t/-/gsd-t-${PKG_VERSION}.tgz\` returns 200, then re-run update-all.`);
+    info(`Restore the current release first: npm install -g @tekyzinc/gsd-t@${PKG_VERSION}`);
+    process.exit(1);
+  }
   if (newVersion && newVersion !== PKG_VERSION) {
     success(`Global binary upgraded: v${PKG_VERSION} → v${newVersion}`);
     info("Handing off to the newly-installed binary for propagation...");

package/commands/cpua.md

@@ -120,6 +120,19 @@ G="$(npm root -g)/@tekyzinc/gsd-t"
 #    the pre-publish package listing cached and `@tekyzinc/gsd-t@{NEW}` returns ETARGET
 #    for minutes while `npm view` already shows the version (v5.17.14, 2026-09-03).
 #    The tarball URL bypasses the cached listing and is deterministic.
+# 1b. WAIT until the registry actually SERVES the tarball, then CLEAR npm's cached listing.
+#    v5.20.10 (2026-09-17): `npm publish` printed "+ @tekyzinc/gsd-t@5.20.10" and `npm view`
+#    showed it, but the tarball URL 404'd for ~4 minutes. Worse, npm's cached package
+#    listing still said latest = the PREVIOUS version, so `gsd-t update-all` (which runs
+#    `npm install -g @tekyzinc/gsd-t@latest`) DOWNGRADED the global, handed off to the old
+#    binary, and that binary rewrote ~/.claude/commands and 34 projects with the old release
+#    — twice. Poll the tarball, then clean the cache, then install. Never skip either.
+for i in $(seq 1 60); do
+  [ "$(curl -s -o /dev/null -w '%{http_code}' "https://registry.npmjs.org/@tekyzinc/gsd-t/-/gsd-t-{NEW_VERSION}.tgz")" = "200" ] && break
+  sleep 10
+done
+[ "$(curl -s -o /dev/null -w '%{http_code}' "https://registry.npmjs.org/@tekyzinc/gsd-t/-/gsd-t-{NEW_VERSION}.tgz")" = "200" ] || { echo "HALT: tarball still 404 after 10 min"; exit 1; }
+npm cache clean --force
 npm install -g "https://registry.npmjs.org/@tekyzinc/gsd-t/-/gsd-t-{NEW_VERSION}.tgz"
 # 2. VERIFY ON DISK — never trust npm's exit code for this step. On v5.17.13 `npm install -g`
 #    reported success and left the OLD version in place; `update-all` then ran from the
@@ -140,7 +153,11 @@ fi
 #    file and the command files; only then does update-all see the new release.
 gsd-t install 2>&1 | tail -5
 [ "$(cat ~/.claude/.gsd-t-version)" = "{NEW_VERSION}" ] || { echo "HALT: ~/.claude/.gsd-t-version did not advance"; exit 1; }
-# 4. Propagate, then prove the global is STILL the new version and a NEW file reached a project.
+# 4. Prove `@latest` now resolves to the NEW version (update-all installs `@latest`; a stale
+#    listing here is the downgrade path — since v5.20.11 update-all HALTS on a downgrade
+#    instead of handing off, but do not rely on the halt: check first).
+[ "$(npm view @tekyzinc/gsd-t dist-tags.latest)" = "{NEW_VERSION}" ] || { echo "HALT: registry latest is not {NEW_VERSION}"; exit 1; }
+# 5. Propagate, then prove the global is STILL the new version and a NEW file reached a project.
 gsd-t update-all 2>&1 | tail -30
 [ "$(node -p "require('$G/package.json').version")" = "{NEW_VERSION}" ] || { echo "HALT: global package reverted during update-all"; exit 1; }
 ```

package/commands/gsd-t-estimate.md

@@ -85,7 +85,7 @@ Reorder items into domains. Insert a **section-heading row** before each group p
 
 ## Step 4: Team Mix — JUDGMENT · PAUSE FOR REVIEW
 
-Your judgment is ONE thing: the FTE per discipline (`teamMix.fte` in the plan — `backend` `frontend` `qa` `pm` `ba`, optionally `techlead` `devops`). Everything else on the tab is computed by the tool per spec §2: the split into people (saturate at 1.00, then spill), months, the column count, the ramp by discipline, the remainder formula.
+Your judgment is ONE thing: the FTE per discipline (`teamMix.fte` in the plan — `backend` `frontend` `qa` `pm` `ba`, optionally `techlead` `devops`; per-phase override via `teamMix.phases.<phase>.fte`). Everything else on the tab is computed by the tool per spec §2: the split into people (saturate at 1.00, then spill), months, the column count, the ramp by discipline, the remainder formula — and **one grid per phase with hours** (MVP, Phase 1, …), stacked on the one tab with 2 blank rows between.
 
 1. **Staff every weighted MF factor** — QA → `qa`, PM → `pm`, Analysis → `ba`. Deployment / standups / buffer are absorbed by the engineers and lead. Typical fractions: PM 0.20–0.25 · BA 0.10 · Tech Lead 0.25 · QA 0.40–0.50. The tool HALTS on a roster that leaves a factor unstaffed — do not argue with it; add the person.
 2. **Run `gsd-t estimate-sheet plan-check --sheet <url> --plan <plan.json>`.** It prints the MF list it read, the T-Shirt total, and the roster table it WOULD write (person · Count · Mths · Days · Hrs · Mon 1..N with the remainder) — or halts with the violation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.20.10",
+  "version": "5.20.12",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 54 slash commands with headless-by-default workflow spawning, unattended supervisor relay with event stream, graph-powered code analysis, real-time agent dashboard, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",

package/templates/estimate-sheet-spec.md

@@ -76,35 +76,36 @@ Column widths: `[150, 120, 300, 430, 122, 90, 90, 61, 53, 76, 81, 81]`.
 | `K` | `=J{r}*8*$H$4` | nf `$#,##0.00` |
 | `L` | `=K{r}*$G$4` | nf `$#,##0.00` |
 
-### 1.3 Totals and summary (BELOW the last item)
+### 1.3 Totals and summary (directly under the last item — NO blank rows)
 
 ```
 <last item row>
-(blank row)
-Total (Days) | … | H =SUM(H14:H<last>) | I =SUM(I…) | J =SUM(J…) | K =SUM(K…) | L =SUM(L…)
-(blank row)
-                                       J: Total Days | K: =J<tot>       | L: =J<tot>*$G$4
-                                       J: Total Hrs  | K: =J<tot>*8     | L: =J<tot>*$G$4*8
-                                       J: Total Cost | K: =K<tot>       | L: =L<tot>
+Total (Days) | … | H =SUM(H14:H<last>) | I =SUM(I…) | J =SUM(J…) | K =SUM(K…) | L =SUM(L…)     ← bg #D8DDE8, bold 10, A:L
+                                       J: Total Days | K: =J<tot>       | L: =J<tot>*$G$4      ← label bold, 0.00
+                                       J: Total Hrs  | K: =J<tot>*8     | L: =J<tot>*$G$4*8    ← label bold, 0.00
+                                       J: Total Cost | K: =K<tot>       | L: =L<tot>           ← label bold, $#,##0.00
 ```
 
-**The summary block sits BELOW the totals row, never inside the summed range** (the template
-ships it at rows 18–20, which becomes circular `#REF!` once items extend past it — move it).
+- The totals row is the template's grey band (`#D8DDE8`, bold, size 10) across `A:L`; its numbers stay in General format (`79.25`, `158.5`, `63400`).
+- No blank row above or below the totals row (David, 2026-09-21).
+- **The summary block never sits inside the summed range** (the template ships it at rows 18–20, which becomes circular `#REF!` once items extend past it).
 
 ---
 
-## 2. Team Mix tab (David's 2026-09-17 layout)
+## 2. Team Mix tab (David's 2026-09-17 layout · one grid per phase, 2026-09-21)
 
-### 2.1 Layout
+### 2.1 Layout of ONE grid
 
 ```
-Row 1   Title  (merged A:<Total Hrs col>)
-Row 2   Header (row 2 and ONLY row 2)
-Row 3.. one row PER PERSON
-Row T   Total        (T = 3 + nroles)
+Row t   Title  "<estimate title> — <phase>"  (merged A:<Total Hrs col>)
+Row t+1 Header (the ONLY header row in the grid)
+Row t+2.. one row PER PERSON
+Row T   Total        (T = t + 2 + nroles)
 Row T+1 Total Days   (right half only, H onward)
 ```
 
+**One grid per phase with hours** (§2.6): the first grid starts at row 1; every further grid starts **exactly 2 blank rows** below the previous grid's Total Days row. All grids live on the one Team Mix tab.
+
 | Col | Header | Content | Style |
 |---|---|---|---|
 | `A` | `Skill set` | person label, e.g. `Backend / API Engineer 1` | left |
@@ -134,6 +135,10 @@ The old `Month / Days / Tot Days / Hrs` layout is retired: `Days` IS the per-per
 - **Recompute `months` and `N` after ANY roster change.** Adding a role raises Σ Count, shortens the duration, and turns the remainder column negative (−12.80 hrs was the symptom).
 - The remainder formula makes each row sum exactly. Never write a fractional last month as a value.
 
+### 2.6 One grid per phase
+
+Every phase (`MVP` / `Phase 1` / `Phase 2` / `Phase 3`) whose T-Shirt items have hours > 0 gets its own Team Mix grid, in phase order, on the same tab, with 2 blank unformatted rows between grids. Each grid's `Σ Days` reconciles to **that phase's** T-Shirt days (the phase rollup `Low Hrs ÷ 8`), and the grids together reconcile to `Total Days`. Months and column count are computed per grid. The team mix is the same for every phase unless the plan gives `teamMix.phases.<phase>.fte`.
+
 ### 2.3 Roster shape — one row per PERSON
 
 1. **No row over Count 1.00.** `Backend Engineer 1.40` is two people → two rows.
@@ -207,10 +212,11 @@ T-SHIRT
   [ ] every item row's H:L are the §1.2 formulas (no values)
   [ ] section heading rows are merged A:L, bg #1C4F8B, and hold no sizes
   [ ] totals row + phase rollups (K4:N7) + summary block reference <last item row>
-  [ ] summary block is BELOW the totals row
+  [ ] totals row directly under the last item, grey band #D8DDE8 bold across A:L; summary block directly under it, labels bold, Total Cost in dollars
   [ ] Σ raw sizes × (1+MF) == Total Days cell (recomputed independently)
-TEAM MIX
-  [ ] header is row 2 only; row 3 is a person
+TEAM MIX (each grid)
+  [ ] one grid per phase with hours; the title ends with the phase name; exactly 2 empty, unformatted rows between grids
+  [ ] the header is the row under the title; the row under the header is a person
   [ ] header months read Mon 1..Mon N with N == month column count; last header is Total Hrs
   [ ] no Count > 1.00; per discipline, all rows but the last are 1.00
   [ ] every non-zero MF factor has a matching person row
@@ -220,7 +226,7 @@ TEAM MIX
   [ ] font Arial 10 everywhere; sage on exactly E, F, Total Hrs of role rows; monthly cells white
   [ ] Total row (#E5E5E5) and Total Days row (#9EC1EF) span every month column + Total Hrs
   [ ] nothing formatted outside the data area
-  [ ] Σ Days == T-Shirt Total Days
+  [ ] each grid's Σ Days == that phase's T-Shirt days; all grids together == Total Days
 TECH STACK
   [ ] at least the categories that apply are filled; none says TBD
 OVERVIEW
@@ -257,5 +263,5 @@ The plan (judgment only):
 ```
 
 - `tshirt.mode` `items` writes whole rows below the header (halts if rows exist unless `--replace`); `sizes` fills `E:L` on rows that already exist (a gap-analysis sheet), matched by the `(id)` suffix in column C — never by position.
-- `teamMix.fte` is per-discipline FTE (`backend` `frontend` `qa` `pm` `ba` `devops` `techlead`). The tool splits it into people (saturate then spill), computes months and the column count, ramps by discipline, writes the remainder formula, and refuses a roster that leaves a weighted MF factor unstaffed.
+- `teamMix.fte` is per-discipline FTE (`backend` `frontend` `qa` `pm` `ba` `devops` `techlead`). The tool splits it into people (saturate then spill), computes months and the column count, ramps by discipline, writes the remainder formula, and refuses a roster that leaves a weighted MF factor unstaffed. It writes **one grid per phase with hours** (§2.6); `teamMix.phases: { "Phase 1": { "fte": {…} } }` overrides the mix for one phase.
 - The MF list, legend, rate and high factor are READ from the sheet; the plan never carries them.