@tekyzinc/gsd-t 5.20.12 → 5.20.14

package/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.20.14] - 2026-09-21
+
+### Added — `gsd-t estimate-sheet teammix` rebuilds any estimate's Team Mix; the reader handles both template layouts
+
+Reviewing the 19 estimates linked from the Hilo index found ten on an older T-Shirt layout
+(Project/Client rows on top, legend from row 8, up to four size columns, header row 17) and an
+older Team Mix model (Count = peak-month hours ÷ 160). Five estimates have more than one phase
+and needed the per-phase Team Mix.
+
+- `bin/gsd-t-estimate-sheet.cjs`: `locateTshirt` finds every header cell BY LABEL and returns a
+  column map; item/rollup formulas and the audit are generated from the map. New `teammix` verb:
+  derives the roster from the sheet's existing grid (entered Counts summed per discipline; a
+  peak-utilisation roster splits the sheet's total FTE by each role's hours), reads phase
+  Low/High hours from the rollups, and rewrites one grid per phase; `--fte` overrides, `--dry-run`
+  previews, unmappable roles halt. Disciplines `design` and `mobile` added. `write` refuses the
+  older layout by name. Fold rule now checks a full-timer still fits under 172 hrs. 429 rate
+  limits back off and retry the identical request (3×), then halt.
+- Applied to the five multi-phase Hilo estimates (Acron, Role-Based Permissions, Part 141 & 61,
+  Part 121, Aeroplanned); all Team Mix checks pass on each. Aeroplanned had no PM/BA row — added
+  at 0.20 / 0.10.
+- `test/estimate-sheet-writer.test.js`: older-layout reader, roster derivation (both models),
+  fold-vs-ceiling.
+- `format` verb: normalises a T-Shirt tab's formatting only — section rows to the spec blue
+  (unmerging each sheet's own merge range first), blank rows before the totals row deleted, the
+  grey bold totals band, and the standard summary block (bold labels, Total Cost in dollars)
+  rewritten directly under it; recognises the four old summary variants and inserts rows when
+  another table sits close below. Applied to all 19 Hilo estimates; every totals/summary check
+  now passes on all 19.
+
+## [5.20.13] - 2026-09-21
+
+### Fixed — Team Mix staffs the midpoint of Low and High, not Low
+
+David's correction on the first live sheet. The Team Mix was sized to the Low figure;
+Tekyz staffs the midpoint of the Low and High estimates.
+
+- `bin/gsd-t-estimate-sheet.cjs`: `midDays = low × (1 + high factor) / 2`; each phase grid is
+  built and audited against `(Low Hrs + High Hrs) ÷ 2 ÷ 8` from that phase's rollups; the
+  grids together against the midpoint of `Total Days` and `Total Days × high factor`.
+- `templates/estimate-sheet-spec.md` §2.2 / §2.6 / §5; tests updated; live write on the E2E
+  copy: 3 phase grids, all audit checks pass.
+
 ## [5.20.12] - 2026-09-21
 
 ### Fixed — estimate writer proven end-to-end; two-month remainder formula

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v5.20.12** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
+**v5.20.14** - 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

@@ -23,6 +23,8 @@
  *   read       --sheet <id|url> [--tab <name>]          dump layout (read-before-write)
  *   plan-check --sheet <id|url> --plan <plan.json>      validate plan, print the roster it WOULD write
  *   write      --sheet <id|url> --plan <plan.json> [--replace]   write T-Shirt + Team Mix + Tech Stack, then audit
+ *   teammix    --sheet <id|url> [--fte <json>] [--dry-run] rebuild the Team Mix (one grid per phase) from the sheet's own roster + rollups
+ *   format     --sheet <id|url> [--dry-run]              normalise T-Shirt formatting only (section rows, totals band, summary block); values untouched
  *   audit      --sheet <id|url>                          the spec §5 checklist, by read-back
  *   plan-schema                                          print the plan shape
  * Flags: --json (envelope only)  --key <path>  --no-audit (write only; for debugging)
@@ -74,6 +76,8 @@ const RAMP = {
   devops: [0.45, 0.85, 1.7],
   pm: [1, 1, 1],
   techlead: [1.3, 0.8, 0.9],
+  design: [1.6, 0.9, 0.5],   // Design / UX: heaviest at the start, a tail for revisions
+  mobile: [1.35, 1.05, 0.6], // same shape as frontend
 };
 
 const ROLE_LABEL = {
@@ -84,6 +88,8 @@ const ROLE_LABEL = {
   ba: "Business Analyst",
   devops: "DevOps Engineer",
   techlead: "Tech Lead / Architect",
+  design: "Design / UX",
+  mobile: "Mobile Engineer",
 };
 
 // MF factor label → the discipline that must staff it (spec §2.4). Factors with
@@ -186,7 +192,7 @@ class SheetsApi {
     this.base = `https://sheets.googleapis.com/v4/spreadsheets/${sheetId}`;
   }
 
-  async call(method, url, body) {
+  async call(method, url, body, attempt = 1) {
     // Spec §0: NEVER send X-Goog-User-Project — on these sheets it CAUSES a 403.
     const res = await fetch(url, {
       method,
@@ -194,6 +200,15 @@ class SheetsApi {
       body: body == null ? undefined : JSON.stringify(body),
     });
     const text = await res.text();
+    if (res.status === 429 && attempt <= 3) {
+      // Rate limit (60 reads/min/user — hit 2026-09-21 auditing 19 sheets in a row). This is
+      // flow control, not a masked failure: the same request is re-sent unchanged after the
+      // documented wait, and the 4th 429 halts.
+      const wait = 20000 * attempt;
+      console.error(`  … Sheets API 429 (rate limit) — waiting ${wait / 1000}s, retry ${attempt}/3`);
+      await new Promise((r) => setTimeout(r, wait));
+      return this.call(method, url, body, attempt + 1);
+    }
     if (!res.ok) {
       const short = text.slice(0, 400);
       if (res.status === 403) {
@@ -300,54 +315,100 @@ function rowIsEmpty(grid, r, cols = 12) {
   return true;
 }
 
-/** Locate the T-Shirt tab's fixed header block (spec §1.1). HALTS if it is not the template. */
-function locateTshirt(grid) {
-  let headerRow = -1;
-  for (let r = 0; r < Math.min(rowCount(grid), 40); r++) {
-    if (/^Module\/Functionality$/i.test(textAt(grid, r, 0).trim())) { headerRow = r; break; }
+/** Find the first cell whose text equals `label` (case-insensitive, trimmed) in the top `maxRows` rows. */
+function findCell(grid, label, maxRows = 25, maxCols = 20) {
+  const want = label.toLowerCase();
+  for (let r = 0; r < Math.min(rowCount(grid), maxRows); r++) {
+    for (let c = 0; c < maxCols; c++) if (textAt(grid, r, c).trim().toLowerCase() === want) return { r, c };
   }
-  if (headerRow < 0) throw new Halt(`${TAB_TSHIRT}: column header row ('Module/Functionality' in A) not found — is this the Tekyz template?`);
+  return null;
+}
+
+/**
+ * Locate the T-Shirt tab's header block BY LABEL, not by fixed row (spec §1.1). Two layouts
+ * are in the wild: the current template (Date row 1, legend A4:B9, header row 13, two size
+ * columns) and an older one (Project/Client/Date rows 3–5, legend A8:B13, header row 17, up
+ * to four size columns). Everything the writer and audit need is returned as a column map.
+ * HALTS on anything it cannot find — never guesses a coordinate.
+ */
+function locateTshirt(grid) {
+  const hdr = findCell(grid, "Module/Functionality", 40, 3);
+  if (!hdr || hdr.c !== 0) throw new Halt(`${TAB_TSHIRT}: column header row ('Module/Functionality' in A) not found — is this the Tekyz template?`);
+  const headerRow = hdr.r;
+  const headerText = [];
+  for (let c = 0; c < 20; c++) headerText.push(textAt(grid, headerRow, c).trim());
+  const colOf = (label) => { const c = headerText.findIndex((x) => x.toLowerCase() === label.toLowerCase()); if (c < 0) throw new Halt(`${TAB_TSHIRT}: header row ${headerRow + 1} has no '${label}' column`); return c; };
+  const cols = { phase: colOf("Phase"), days: colOf("Days"), mfactor: colOf("MFactor Days"), total: colOf("Total Days"), low: colOf("LOW $"), high: colOf("HIGH $") };
+  cols.sizes = [];
+  for (let c = cols.phase + 1; c < cols.days; c++) cols.sizes.push(c);
+  if (!cols.sizes.length) throw new Halt(`${TAB_TSHIRT}: no size columns between 'Phase' and 'Days'`);
+  cols.sizeLabels = cols.sizes.map((c) => headerText[c]);
+  // legend: the XS..XXL rows in column A
   const legend = {};
-  for (let r = 0; r < 20; r++) {
+  let legendFirst = -1, legendLast = -1;
+  for (let r = 0; r < headerRow; r++) {
     const m = textAt(grid, r, 0).trim().match(/^(XS|S|M|L|XL|XXL)\s*-/);
-    if (m) legend[m[1]] = numAt(grid, r, 1);
+    if (m) { legend[m[1]] = numAt(grid, r, 1); if (legendFirst < 0) legendFirst = r; legendLast = r; }
   }
   for (const code of SIZE_CODES) {
-    if (!(code in legend) || Number.isNaN(legend[code])) throw new Halt(`${TAB_TSHIRT}: size legend missing '${code}' in A4:B9`);
+    if (!(code in legend) || Number.isNaN(legend[code])) throw new Halt(`${TAB_TSHIRT}: size legend missing '${code}' (looked for 'XS - …' labels in column A above the header row)`);
   }
+  // MF list: under 'Multiplication Factor' down to 'Total MF'
+  const mfHdr = findCell(grid, "Multiplication Factor", headerRow, 12);
+  if (!mfHdr) throw new Halt(`${TAB_TSHIRT}: 'Multiplication Factor' header not found`);
   const mf = [];
   let mfTotalCell = null;
-  for (let r = 0; r < 20; r++) {
-    const label = textAt(grid, r, 4).trim();
+  for (let r = mfHdr.r + 1; r < headerRow; r++) {
+    const label = textAt(grid, r, mfHdr.c).trim();
     if (!label) continue;
-    if (/^Total MF$/i.test(label)) { mfTotalCell = { r, c: 5, value: numAt(grid, r, 5) }; continue; }
-    if (/^Multiplication Factor$/i.test(label)) continue;
-    const v = numAt(grid, r, 5);
+    if (/^Total MF$/i.test(label)) { mfTotalCell = { r, c: mfHdr.c + 1, value: numAt(grid, r, mfHdr.c + 1) }; break; }
+    const v = numAt(grid, r, mfHdr.c + 1);
     if (!Number.isNaN(v)) mf.push({ label, value: v, row: r + 1 });
   }
-  if (!mf.length) throw new Halt(`${TAB_TSHIRT}: multiplication-factor list (E4:F9) not found`);
-  if (!mfTotalCell) throw new Halt(`${TAB_TSHIRT}: 'Total MF' cell not found`);
+  if (!mf.length) throw new Halt(`${TAB_TSHIRT}: multiplication-factor list under '${colLetter(mfHdr.c)}${mfHdr.r + 1}' is empty`);
+  if (!mfTotalCell) throw new Halt(`${TAB_TSHIRT}: 'Total MF' cell not found under the MF list`);
   const mfTotal = mf.reduce((s, f) => s + f.value, 0);
-  const highFactor = numAt(grid, 3, 6);
-  const rate = numAt(grid, 3, 7);
-  if (Number.isNaN(highFactor)) throw new Halt(`${TAB_TSHIRT}: High $ Factor (G4) is not a number`);
-  if (Number.isNaN(rate)) throw new Halt(`${TAB_TSHIRT}: Avg. Hrly Rate (H4) is not a number`);
+  const hfHdr = findCell(grid, "High $ Factor", headerRow, 14);
+  if (!hfHdr) throw new Halt(`${TAB_TSHIRT}: 'High $ Factor' header not found`);
+  const highFactor = numAt(grid, hfHdr.r + 1, hfHdr.c);
+  if (Number.isNaN(highFactor)) throw new Halt(`${TAB_TSHIRT}: High $ Factor (${colLetter(hfHdr.c)}${hfHdr.r + 2}) is not a number`);
+  const rateHdr = findCell(grid, "Avg. Hrly Rate", headerRow, 14);
+  if (!rateHdr) throw new Halt(`${TAB_TSHIRT}: 'Avg. Hrly Rate' header not found`);
+  const rate = numAt(grid, rateHdr.r + 1, rateHdr.c);
+  if (Number.isNaN(rate)) throw new Halt(`${TAB_TSHIRT}: Avg. Hrly Rate (${colLetter(rateHdr.c)}${rateHdr.r + 2}) is not a number`);
+  cols.highFactor = { r: hfHdr.r + 1, c: hfHdr.c };
+  cols.rate = { r: rateHdr.r + 1, c: rateHdr.c };
+  cols.mfTotal = { r: mfTotalCell.r, c: mfTotalCell.c };
+  // phase rollups: the column holding 'MVP' above the header; Low/High Hrs columns from their headers
+  const mvp = findCell(grid, "MVP", headerRow, 16);
+  if (!mvp) throw new Halt(`${TAB_TSHIRT}: phase rollup block ('MVP' label above the header row) not found`);
   const rollupRows = [];
-  for (let r = 0; r < 12; r++) if (PHASES.includes(textAt(grid, r, 9).trim())) rollupRows.push(r);
-  if (rollupRows.length !== 4) throw new Halt(`${TAB_TSHIRT}: expected 4 phase rollup rows in column J (MVP, Phase 1–3), found ${rollupRows.length}`);
-  return { headerRow, firstItemRow: headerRow + 1, legend, mf, mfTotal, mfTotalCell, highFactor, rate, rollupRows };
+  for (let r = 0; r < headerRow; r++) if (PHASES.includes(textAt(grid, r, mvp.c).trim())) rollupRows.push(r);
+  if (rollupRows.length !== 4) throw new Halt(`${TAB_TSHIRT}: expected 4 phase rollup rows in column ${colLetter(mvp.c)} (MVP, Phase 1–3), found ${rollupRows.length}`);
+  const lowHrs = findCell(grid, "Low Hrs", headerRow, 20), highHrs = findCell(grid, "High Hrs", headerRow, 20);
+  const lowDol = findCell(grid, "Low ($)", headerRow, 20), highDol = findCell(grid, "High ($)", headerRow, 20);
+  if (!lowHrs || !highHrs || !lowDol || !highDol) throw new Halt(`${TAB_TSHIRT}: rollup headers 'Low ($)' / 'Low Hrs' / 'High ($)' / 'High Hrs' not all found`);
+  cols.rollupPhase = mvp.c; cols.lowHrs = lowHrs.c; cols.highHrs = highHrs.c; cols.lowDol = lowDol.c; cols.highDol = highDol.c;
+  return { headerRow, firstItemRow: headerRow + 1, legend, legendFirst1: legendFirst + 1, legendLast1: legendLast + 1, mf, mfTotal, mfTotalCell, highFactor, rate, rollupRows, cols };
 }
 
-/** Row index of a cell in column E with a ONE_OF_LIST validation — the Phase dropdown source; -1 if none. */
-function findPhaseSource(grid, fromRow) {
+/** The standard template's column map (what `write` produces). */
+const STANDARD_COLS = { phase: 4, sizes: [5, 6], days: 7, mfactor: 8, total: 9, low: 10, high: 11, rollupPhase: 9, lowHrs: 11, highHrs: 13, lowDol: 10, highDol: 12, highFactor: { r: 3, c: 6 }, rate: { r: 3, c: 7 }, mfTotal: { r: 9, c: 5 } };
+const STANDARD_LEGEND = { first1: 4, last1: 9 };
+
+/** Row index of a cell in the Phase column with a ONE_OF_LIST validation — the Phase dropdown source; -1 if none. */
+function findPhaseSourceIn(grid, fromRow, phaseCol) {
   for (let r = fromRow; r < rowCount(grid); r++) {
-    const cell = cellAt(grid, r, 4);
+    const cell = cellAt(grid, r, phaseCol);
     const dv = cell && cell.dataValidation;
     if (dv && dv.condition && dv.condition.type === "ONE_OF_LIST") return r;
   }
   return -1;
 }
 
+/** Row index of a cell in column E with a ONE_OF_LIST validation — the Phase dropdown source; -1 if none. */
+function findPhaseSource(grid, fromRow) { return findPhaseSourceIn(grid, fromRow, 4); }
+
 // ───────────────────────── plan validation (pure) ─────────────────────────
 
 const PLAN_SCHEMA = {
@@ -478,7 +539,11 @@ function monthPlan(totalDays, people) {
   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);
+  // Fold a small tail into the last full month ONLY if a full-time person still fits under the
+  // soft ceiling: months × 160 ≤ whole × 172. (Acron, 2026-09-21: 1.098 months folded to one
+  // column put Backend 1 at 175.7 hrs — over the ceiling — so the fold must check the hours.)
+  const fits = months * 160 <= whole * SOFT_CEILING + 1e-9;
+  const n = whole >= 1 && frac < FOLD_THRESHOLD && fits ? whole : Math.ceil(months);
   return { months, sumCount, n: Math.max(1, n) };
 }
 
@@ -554,25 +619,39 @@ function tshirtTotals(plan, layout) {
 
 // ───────────────────────── T-Shirt formulas (pure, spec §1.2–1.3) ─────────────────────────
 
-function itemFormulas(r) {
-  return {
-    H: `=(IF(F${r}="",0,SUMIF($A$4:$A$9,LEFT(F${r},2)&"*",$B$4:$B$9))+IF(G${r}="",0,SUMIF($A$4:$A$9,LEFT(G${r},2)&"*",$B$4:$B$9)))`,
-    I: `=H${r}*$F$10`,
-    J: `=H${r}+I${r}`,
-    K: `=J${r}*8*$H$4`,
-    L: `=K${r}*$G$4`,
+/** Item-row formulas for any column map (spec §1.2). Keys are the STANDARD letters H..L; `cells` carries the real columns. */
+function itemFormulasFor(r, cols, legend) {
+  const L = colLetter;
+  const lg = `$A$${legend.first1}:$A$${legend.last1}`, lv = `$B$${legend.first1}:$B$${legend.last1}`;
+  const days = "=(" + cols.sizes.map((c) => `IF(${L(c)}${r}="",0,SUMIF(${lg},LEFT(${L(c)}${r},2)&"*",${lv}))`).join("+") + ")";
+  const abs = (cell) => `$${L(cell.c)}$${cell.r + 1}`;
+  const f = {
+    H: days,
+    I: `=${L(cols.days)}${r}*${abs(cols.mfTotal)}`,
+    J: `=${L(cols.days)}${r}+${L(cols.mfactor)}${r}`,
+    K: `=${L(cols.total)}${r}*8*${abs(cols.rate)}`,
+    L: `=${L(cols.low)}${r}*${abs(cols.highFactor)}`,
   };
+  f.cells = [[cols.days, f.H], [cols.mfactor, f.I], [cols.total, f.J], [cols.low, f.K], [cols.high, f.L]];
+  return f;
 }
 
-function rollupFormulas(rollupRow1, firstRow1, lastRow1) {
-  const e = `$E$${firstRow1}:$E$${lastRow1}`;
+/** The standard template's item formulas (what `write` produces). */
+function itemFormulas(r) { return itemFormulasFor(r, STANDARD_COLS, STANDARD_LEGEND); }
+
+function rollupFormulasFor(rollupRow1, firstRow1, lastRow1, cols) {
+  const L = colLetter;
+  const e = `$${L(cols.phase)}$${firstRow1}:$${L(cols.phase)}$${lastRow1}`;
+  const ph = `$${L(cols.rollupPhase)}${rollupRow1}`;
+  const rate = `$${L(cols.rate.c)}$${cols.rate.r + 1}`;
   return [
-    `=SUMIF(${e},$J${rollupRow1},$K$${firstRow1}:$K$${lastRow1})`,
-    `=SUMIF(${e},$J${rollupRow1},$J$${firstRow1}:$J$${lastRow1})*8`,
-    `=SUMIF(${e},$J${rollupRow1},$L$${firstRow1}:$L$${lastRow1})`,
-    `=IF($H$4=0,0,M${rollupRow1}/$H$4)`,
+    `=SUMIF(${e},${ph},$${L(cols.low)}$${firstRow1}:$${L(cols.low)}$${lastRow1})`,
+    `=SUMIF(${e},${ph},$${L(cols.total)}$${firstRow1}:$${L(cols.total)}$${lastRow1})*8`,
+    `=SUMIF(${e},${ph},$${L(cols.high)}$${firstRow1}:$${L(cols.high)}$${lastRow1})`,
+    `=IF(${rate}=0,0,${L(cols.highDol)}${rollupRow1}/${rate})`,
   ];
 }
+function rollupFormulas(rollupRow1, firstRow1, lastRow1) { return rollupFormulasFor(rollupRow1, firstRow1, lastRow1, STANDARD_COLS); }
 
 /** Rows for items mode, starting at firstRow0 (0-based). */
 function tshirtRows(plan, firstRow0) {
@@ -631,6 +710,8 @@ async function writeTshirt(api, plan, opts) {
   const grid = await api.grid(TAB_TSHIRT);
   const sheetId = grid.properties.sheetId;
   const layout = locateTshirt(grid);
+  const std = ["phase", "days", "mfactor", "total", "low", "high"].every((k) => layout.cols[k] === STANDARD_COLS[k]) && layout.cols.sizes.length === 2 && layout.legendFirst1 === 4 && layout.headerRow === 12;
+  if (!std) throw new Halt(`${TAB_TSHIRT}: this sheet is not the current template layout (header row ${layout.headerRow + 1}, size columns ${layout.cols.sizeLabels.join("/")}) — 'write' supports the current template only; 'teammix' and 'audit' work on both`);
   const totals = tshirtTotals(plan, layout);
   const phaseSrc = findPhaseSource(grid, 0);
   if (phaseSrc < 0) throw new Halt(`${TAB_TSHIRT}: no Phase dropdown source cell found in column E — add a ONE_OF_LIST validation (MVP / Phase 1 / Phase 2 / Phase 3) to E${layout.firstItemRow + 1} and re-run`);
@@ -740,13 +821,19 @@ async function writeTshirtSizes(api, grid, sheetId, layout, plan, totals, phaseS
 
 // ───────────────────────── write: Team Mix (spec §2) ─────────────────────────
 
-/** Per-phase T-Shirt totals in PHASES order — only phases with hours > 0 (spec §2.6). */
+/** Team Mix staffs the MIDPOINT of the Low and High figures (David, 2026-09-21): mid = low × (1 + highFactor) / 2. */
+function midDays(lowDays, highFactor) { return round2(lowDays * (1 + highFactor) / 2); }
+
+/** Per-phase T-Shirt totals in PHASES order — only phases with hours > 0 (spec §2.6). `totalDays` is the Low figure; `staffDays` the midpoint the Team Mix staffs. */
 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)) }));
+  return PHASES.filter((ph) => raw[ph] > 0).map((ph) => {
+    const low = round2(raw[ph] * (1 + layout.mfTotal));
+    return { phase: ph, rawDays: round2(raw[ph]), totalDays: low, highDays: round2(low * layout.highFactor), staffDays: midDays(low, layout.highFactor) };
+  });
 }
 
 /** One roster per phase with hours. FTE comes from teamMix.phases[<phase>].fte when given, else teamMix.fte. */
@@ -756,7 +843,7 @@ function buildRosters(plan, layout) {
   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) };
+    return { ...ph, roster: buildRoster(sub, ph.staffDays, layout.mf) };
   });
 }
 
@@ -891,89 +978,95 @@ async function writeTechStack(api, plan) {
 
 function check(list, name, ok, detail) { list.push({ check: name, ok: !!ok, detail: ok ? "" : String(detail == null ? "" : detail) }); }
 
-/** T-Shirt audit. The template header block is REQUIRED — locateTshirt halts if it is missing. */
+/** T-Shirt audit — layout-aware via locateTshirt's column map. HALTS if the header block is missing. */
 function auditTshirt(grid) {
   const out = [];
   const layout = locateTshirt(grid);
+  const { cols } = layout;
+  const legendRows = { first1: layout.legendFirst1, last1: layout.legendLast1 };
   const first0 = layout.firstItemRow;
   const badSizes = [], noDv = [], badFormula = [], sectionsWithSizes = [], badSectionFmt = [];
   let lastItem0 = -1, totalRow0 = -1;
   for (let r = first0; r < rowCount(grid); r++) {
     const a = textAt(grid, r, 0);
     if (/^Total \(Days\)/i.test(a)) { totalRow0 = r; break; }
-    if (rowIsEmpty(grid, r)) continue;
-    const isSection = a !== "" && textAt(grid, r, 2) === "" && textAt(grid, r, 7) === "";
+    if (rowIsEmpty(grid, r, cols.high + 1)) continue;
+    const isSection = a !== "" && textAt(grid, r, 2) === "" && textAt(grid, r, cols.days) === "";
     if (isSection) {
-      const feTxt = textAt(grid, r, 5);
-      const beTxt = textAt(grid, r, 6);
-      if (feTxt !== "" || beTxt !== "") sectionsWithSizes.push(r + 1);
+      if (cols.sizes.some((c) => textAt(grid, r, c) !== "")) sectionsWithSizes.push(r + 1);
       if (bgAt(grid, r, 0) !== COLOR.sectionBg) badSectionFmt.push(`row ${r + 1} bg ${bgAt(grid, r, 0)}`);
       continue;
     }
     lastItem0 = r;
-    for (const c of [5, 6]) {
+    for (const c of cols.sizes) {
       const v = textAt(grid, r, c).trim();
       if (v && !SIZE_CODES.includes(v)) badSizes.push(`${colLetter(c)}${r + 1}='${v}'`);
     }
-    const cell = cellAt(grid, r, 4);
-    if (!(cell && cell.dataValidation && cell.dataValidation.condition && cell.dataValidation.condition.type === "ONE_OF_LIST")) noDv.push(`E${r + 1}`);
-    const f = itemFormulas(r + 1);
-    [["H", 7], ["I", 8], ["J", 9], ["K", 10], ["L", 11]].forEach(([k, c]) => { if (formulaAt(grid, r, c) !== f[k]) badFormula.push(`${k}${r + 1}`); });
+    const cell = cellAt(grid, r, cols.phase);
+    if (!(cell && cell.dataValidation && cell.dataValidation.condition && cell.dataValidation.condition.type === "ONE_OF_LIST")) noDv.push(`${colLetter(cols.phase)}${r + 1}`);
+    const f = itemFormulasFor(r + 1, cols, legendRows);
+    for (const [c, want] of f.cells) if (formulaAt(grid, r, c) !== want) badFormula.push(`${colLetter(c)}${r + 1}`);
   }
   check(out, "T-Shirt: at least one item row", lastItem0 >= 0, "no item rows below the header");
-  check(out, "T-Shirt: size cells are bare codes (no legend text)", !badSizes.length, badSizes.join(", "));
-  check(out, "T-Shirt: every item row has the Phase dropdown", !noDv.length, noDv.join(", "));
-  check(out, "T-Shirt: H:L are the spec formulas on every item row", !badFormula.length, badFormula.slice(0, 12).join(", "));
+  check(out, "T-Shirt: size cells are bare codes (no legend text, no '-')", !badSizes.length, badSizes.slice(0, 10).join(", "));
+  check(out, "T-Shirt: every item row has the Phase dropdown", !noDv.length, noDv.slice(0, 10).join(", "));
+  check(out, "T-Shirt: Days..HIGH $ are the spec formulas on every item row", !badFormula.length, badFormula.slice(0, 12).join(", "));
   check(out, "T-Shirt: section rows carry no sizes", !sectionsWithSizes.length, `rows ${sectionsWithSizes.join(", ")}`);
-  check(out, "T-Shirt: section rows are styled (bg #1C4F8B)", !badSectionFmt.length, badSectionFmt.join(", "));
+  check(out, "T-Shirt: section rows are styled (bg #1C4F8B)", !badSectionFmt.length, badSectionFmt.slice(0, 6).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);
+    const low = numAt(grid, rr, cols.lowHrs), high = numAt(grid, rr, cols.highHrs);
+    phaseDays[textAt(grid, rr, cols.rollupPhase).trim()] = Number.isNaN(low) || Number.isNaN(high) ? NaN : round2((low + high) / 2 / 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}`);
+    check(out, "T-Shirt: totals row is the template band (bg #D8DDE8, bold) across the table", [0, cols.phase, cols.total, cols.high].every((c) => bgAt(grid, totalRow0, c) === COLOR.tshirtTotalBg) && totFont.bold, `A bg ${bgAt(grid, totalRow0, 0)}, ${colLetter(cols.high)} bg ${bgAt(grid, totalRow0, cols.high)}, bold ${totFont.bold}`);
+    const want = `=SUM(${colLetter(cols.total)}${first0 + 1}:${colLetter(cols.total)}${lastItem0 + 1})`;
+    check(out, "T-Shirt: totals row sums the full item range", formulaAt(grid, totalRow0, cols.total) === want, `${colLetter(cols.total)}${totalRow0 + 1} is '${formulaAt(grid, totalRow0, cols.total)}', want '${want}'`);
+    totalDaysCell = numAt(grid, totalRow0, cols.total);
+    // summary block: the three labels directly under the totals row, anywhere in the row
+    const findLabel = (r) => { for (let c = 0; c < cols.high + 1; c++) { const v = textAt(grid, r, c).trim(); if (/^Total (Days|Hrs|Cost)$/i.test(v)) return { c, v }; } return null; };
     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);
+    const labels = sumRows.map(findLabel);
+    check(out, "T-Shirt: summary block (Total Days / Total Hrs / Total Cost) sits directly under the totals row", labels[0] && labels[0].v === "Total Days" && labels[1] && labels[1].v === "Total Hrs" && labels[2] && labels[2].v === "Total Cost", `rows ${sumRows[0] + 1}–${sumRows[2] + 1} = [${labels.map((l) => (l ? l.v : "")).join(", ")}]`);
+    check(out, "T-Shirt: summary labels are bold", labels.every((l) => l && fontAt(grid, sumRows[labels.indexOf(l)], l.c).bold), "");
+    if (labels[2]) {
+      const costCell = cellAt(grid, sumRows[2], labels[2].c + 1);
+      const costFmt = costCell && costCell.userEnteredFormat && costCell.userEnteredFormat.numberFormat;
+      check(out, "T-Shirt: Total Cost is formatted as dollars", !!costFmt && costFmt.type === "CURRENCY", `${colLetter(labels[2].c + 1)}${sumRows[2] + 1} numberFormat ${JSON.stringify(costFmt)}`);
+    } else check(out, "T-Shirt: Total Cost is formatted as dollars", false, "no Total Cost row");
     const badRoll = [];
     for (const rr of layout.rollupRows) {
-      if (formulaAt(grid, rr, 10) !== rollupFormulas(rr + 1, first0 + 1, lastItem0 + 1)[0]) badRoll.push(`K${rr + 1}`);
+      if (formulaAt(grid, rr, cols.lowDol) !== rollupFormulasFor(rr + 1, first0 + 1, lastItem0 + 1, cols)[0]) badRoll.push(`${colLetter(cols.lowDol)}${rr + 1}`);
     }
-    check(out, "T-Shirt: phase rollups (K4:N7) reference the full item range", !badRoll.length, badRoll.join(", "));
+    check(out, "T-Shirt: phase rollups 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;
+    for (let r = first0; r < totalRow0; r++) if (findLabel(r)) summaryAbove = true;
     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]; }
+      for (const c of cols.sizes) { const v = textAt(grid, r, c).trim(); if (v && layout.legend[v] != null) raw += layout.legend[v]; }
     }
     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, phaseDays };
+  return { checks: out, layout, totalDays: totalDaysCell, staffDays: Number.isNaN(totalDaysCell) ? NaN : midDays(totalDaysCell, layout.highFactor), lastItem1: lastItem0 + 1, phaseDays };
 }
 
 function disciplineOfLabel(label) {
   const l = label.toLowerCase();
   if (/qa|test/.test(l)) return "qa";
-  if (/project manager|\bpm\b/.test(l)) return "pm";
-  if (/analyst/.test(l)) return "ba";
+  if (/project m|\bpm\b/.test(l)) return "pm";
+  if (/analys/.test(l)) return "ba";
   if (/devops/.test(l)) return "devops";
   if (/lead|architect/.test(l)) return "techlead";
+  if (/design|\bux\b/.test(l)) return "design";
+  if (/mobile|ios|android/.test(l)) return "mobile";
   if (/front/.test(l)) return "frontend";
-  if (/back|api/.test(l)) return "backend";
+  if (/back|api|platform/.test(l)) return "backend";
   return "";
 }
 
@@ -1089,7 +1182,7 @@ function auditTeamMix(grid, mfList, tshirtTotalDays, phaseDays) {
       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)})`);
+        if (phase) check(out, `${label} (${phase}): Σ Days == midpoint of that phase's Low/High days`, Math.abs(sumDays - phaseDays[phase]) < tol, `Team Mix ${sumDays}, T-Shirt ${phaseDays[phase]} (tolerance ${round2(tol)})`);
       }
       prevBottom = totalR + 1;
     }
@@ -1100,7 +1193,7 @@ function auditTeamMix(grid, mfList, tshirtTotalDays, phaseDays) {
     check(out, "Team Mix: nothing formatted below the last grid", !strayBelow.length, strayBelow.slice(0, 8).join(", "));
   }
   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))})`);
+    check(out, "Team Mix: Σ Days over all grids == midpoint of T-Shirt Low/High days", Math.abs(sumDaysAll - tshirtTotalDays) < Math.max(0.15, tolAll), `Team Mix ${round2(sumDaysAll)}, T-Shirt midpoint ${tshirtTotalDays} (tolerance ${round2(Math.max(0.15, tolAll))})`);
   }
   return { checks: out, grids: headers.length };
 }
@@ -1134,7 +1227,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, tshirt.phaseDays).checks);
+  checks.push(...auditTeamMix(await api.grid(TAB_TEAM), tshirt.layout.mf, tshirt.staffDays, 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");
@@ -1191,7 +1284,7 @@ async function verbRead(api, tab) {
 }
 
 function rostersTable(rosters) {
-  return rosters.map((r) => `── ${r.phase}: ${r.totalDays} d ──\n${rosterTable(r.roster)}`).join("\n");
+  return rosters.map((r) => `── ${r.phase}: low ${r.totalDays} d · high ${r.highDays} d → staffing the midpoint ${r.staffDays} d ──\n${rosterTable(r.roster)}`).join("\n");
 }
 
 async function verbPlanCheck(api, plan) {
@@ -1201,6 +1294,193 @@ async function verbPlanCheck(api, plan) {
   return { totals, mf: layout.mf, mfTotal: round2(layout.mfTotal), highFactor: layout.highFactor, rate: layout.rate, rosters, table: rostersTable(rosters) };
 }
 
+/**
+ * Derive the per-discipline FTE from a sheet's EXISTING Team Mix (first grid): each person
+ * row's label → discipline, Count summed per discipline. HALTS on a label it cannot classify
+ * or a grid it cannot find — a rebuild must never guess a roster.
+ */
+function deriveFteFromTeamMix(grid) {
+  let header = -1;
+  for (let r = 0; r < rowCount(grid); r++) if (textAt(grid, r, 0) === "Skill set") { header = r; break; }
+  if (header < 0) throw new Halt(`${TAB_TEAM}: no 'Skill set' header row — cannot derive the roster`);
+  // Two roster models exist. Current: Count is an ENTERED FTE → sum per discipline. Older:
+  // Count is a FORMULA `=ROUND(MAX(months)/160,2)` (peak-month utilisation), so summing it
+  // overstates the team; there, keep the sheet's total FTE and split it by each role's share
+  // of Total Hrs. The model is read from the first Count cell, never assumed.
+  const firstCount = formulaAt(grid, header + 1, 1);
+  const peakModel = /MAX\(/i.test(firstCount);
+  let totalHrsCol = -1;
+  for (let c = 0; c < 30; c++) if (textAt(grid, header, c).trim() === "Total Hrs") totalHrsCol = c;
+  if (peakModel && totalHrsCol < 0) throw new Halt(`${TAB_TEAM}: peak-utilisation roster but no 'Total Hrs' column to split by`);
+  const people = [];
+  const unknown = [];
+  let totalFte = NaN;
+  for (let r = header + 1; r < rowCount(grid); r++) {
+    const a = textAt(grid, r, 0);
+    if (a === "" || /^Total/i.test(a)) break;
+    if (/^Tot\b/i.test(a)) { totalFte = numAt(grid, r, 1); continue; } // 'Tot FTE' / 'Tot Dys/Hrs' summary line inside the roster
+    const d = disciplineOfLabel(a);
+    if (!d) { unknown.push(a); continue; }
+    const count = numAt(grid, r, 1);
+    const hours = peakModel ? numAt(grid, r, totalHrsCol) : NaN;
+    if (Number.isNaN(count)) throw new Halt(`${TAB_TEAM}: '${a}' has no numeric Count in column B`);
+    if (peakModel && Number.isNaN(hours)) throw new Halt(`${TAB_TEAM}: '${a}' has no numeric Total Hrs`);
+    people.push({ d, count, hours });
+  }
+  if (unknown.length) throw new Halt(`${TAB_TEAM}: cannot map these roles to a discipline — ${unknown.join(", ")}. Known: ${Object.keys(ROLE_LABEL).join(", ")}`);
+  if (!people.length) throw new Halt(`${TAB_TEAM}: no person rows under the header`);
+  const fte = {};
+  if (peakModel) {
+    const sumFte = Number.isNaN(totalFte) ? people.reduce((s, p) => s + p.count, 0) : totalFte;
+    const sumHrs = people.reduce((s, p) => s + p.hours, 0);
+    if (!(sumHrs > 0)) throw new Halt(`${TAB_TEAM}: Total Hrs sum to 0 — cannot split the roster`);
+    for (const p of people) fte[p.d] = round2((fte[p.d] ? fte[p.d] : 0) + sumFte * p.hours / sumHrs);
+  } else {
+    for (const p of people) fte[p.d] = round2((fte[p.d] ? fte[p.d] : 0) + p.count);
+  }
+  for (const d of Object.keys(fte)) if (!(fte[d] > 0)) delete fte[d];
+  return fte;
+}
+
+/** Per-phase Low/High days read from the T-Shirt rollups (phases with hours > 0), in PHASES order. */
+function phaseTotalsFromSheet(grid, layout) {
+  const out = [];
+  for (const rr of layout.rollupRows) {
+    const ph = textAt(grid, rr, layout.cols.rollupPhase).trim();
+    const low = numAt(grid, rr, layout.cols.lowHrs), high = numAt(grid, rr, layout.cols.highHrs);
+    if (Number.isNaN(low) || Number.isNaN(high)) throw new Halt(`${TAB_TSHIRT}: rollup row ${rr + 1} (${ph}) has no Low Hrs / High Hrs values`);
+    if (low > 0) out.push({ phase: ph, totalDays: round2(low / 8), highDays: round2(high / 8), staffDays: round2((low + high) / 2 / 8) });
+  }
+  if (!out.length) throw new Halt(`${TAB_TSHIRT}: no phase has hours — nothing to staff`);
+  return PHASES.filter((p) => out.some((o) => o.phase === p)).map((p) => out.find((o) => o.phase === p));
+}
+
+/** Rebuild the Team Mix tab (one grid per phase) from the sheet's own roster + rollups. No plan needed. */
+async function verbTeamMix(api, opts) {
+  const tshirt = await api.grid(TAB_TSHIRT);
+  const layout = locateTshirt(tshirt);
+  const team = await api.grid(TAB_TEAM);
+  const fte = opts.fte ? opts.fte : deriveFteFromTeamMix(team);
+  const title = opts.title ? opts.title : textAt(team, 0, 0).replace(/\s+—\s+(MVP|Phase \d)$/, "");
+  if (!title) throw new Halt(`${TAB_TEAM}: A1 has no title to carry over — pass --title`);
+  const plan = { title, teamMix: { fte } };
+  const rosters = phaseTotalsFromSheet(tshirt, layout).map((ph) => ({ ...ph, roster: buildRoster(plan, ph.staffDays, layout.mf) }));
+  if (opts.dryRun) return { title, fte, rosters, table: rostersTable(rosters) };
+  const tm = await writeTeamMix(api, plan, rosters);
+  const result = { title, fte, phases: rosters.map((r) => ({ phase: r.phase, lowDays: r.totalDays, highDays: r.highDays, staffDays: r.staffDays, people: r.roster.people.length, months: r.roster.months, columns: r.roster.n, sumDays: r.roster.sumDays })), table: rostersTable(rosters), grids: tm.grids };
+  if (!opts.noAudit) result.audit = await runAudit(api);
+  return result;
+}
+
+/**
+ * Normalise a T-Shirt tab's FORMATTING to the spec without touching any size, phase, item text
+ * or formula (spec §1.2 section rows, §1.3 totals row + summary block). Layout-aware via the
+ * column map, so it works on both template generations. What it does, in order:
+ *   1. section heading rows → merged A:<HIGH $>, bg #1C4F8B, white bold Arial 10
+ *   2. blank rows between the last item and the totals row → deleted
+ *   3. totals row → bg #D8DDE8, bold 10, across the table
+ *   4. summary block (Total Days / Total Hrs / Total Cost) → rewritten directly under the totals
+ *      row in the standard shape; blank rows in between deleted; labels bold; Cost in dollars
+ * HALTS when the rows under the totals row hold anything other than the old summary block or
+ * blanks — it never overwrites content it did not expect.
+ */
+async function verbFormat(api, opts) {
+  const grid = await api.grid(TAB_TSHIRT);
+  const sheetId = grid.properties.sheetId;
+  const layout = locateTshirt(grid);
+  const { cols } = layout;
+  const width = cols.high + 1;
+  const L = colLetter;
+  const first0 = layout.firstItemRow;
+  const sections = [];
+  let lastItem0 = -1, totalRow0 = -1;
+  for (let r = first0; r < rowCount(grid); r++) {
+    const a = textAt(grid, r, 0);
+    if (/^Total \(Days\)/i.test(a)) { totalRow0 = r; break; }
+    if (rowIsEmpty(grid, r, width)) continue;
+    if (a !== "" && textAt(grid, r, 2) === "" && textAt(grid, r, cols.days) === "") sections.push(r);
+    else lastItem0 = r;
+  }
+  if (lastItem0 < 0) throw new Halt(`${TAB_TSHIRT}: no item rows`);
+  if (totalRow0 < 0) throw new Halt(`${TAB_TSHIRT}: no 'Total (Days)' row below the items — add it first`);
+  // the rows under the totals row must be the old summary block or blank
+  // Old summary variants seen across the 19 Hilo sheets (2026-09-21): the standard 3 rows;
+  // a 'Low | High' header row above them; 'Total Cost (Low)' / '(High)' split rows; nothing at
+  // all. Anything else under the totals row (a second table, notes) ends the block and is
+  // NEVER touched — the new block goes in the free rows above it, inserting rows if needed.
+  const summaryRe = /^(Total (Days|Hrs|Cost)( \((Low|High)\))?|Low|High)$/i;
+  const totRef = new RegExp(`\\b[A-Z]{1,2}\\$?${totalRow0 + 1}\\b`);
+  let summaryEnd0 = totalRow0; // last row of the old summary block (or the totals row if none)
+  let nextContent0 = -1;       // first row of foreign content below the block, if any
+  for (let r = totalRow0 + 1; r < Math.min(rowCount(grid), totalRow0 + 10); r++) {
+    let rowHas = false, foreign = false;
+    for (let c = 0; c < width; c++) {
+      const v = textAt(grid, r, c).trim();
+      if (v === "") continue;
+      rowHas = true;
+      const ok = summaryRe.test(v) || (v.startsWith("=") && (totRef.test(v) || new RegExp(`\\b[A-Z]{1,2}(${totalRow0 + 2}|${totalRow0 + 3}|${totalRow0 + 4})\\b`).test(v)));
+      if (!ok) foreign = true;
+    }
+    if (foreign) { nextContent0 = r; break; }
+    if (rowHas) summaryEnd0 = r;
+  }
+  const blankBefore = totalRow0 - lastItem0 - 1;
+  const freeAfter = (nextContent0 < 0 ? Infinity : nextContent0 - 1) - totalRow0; // rows available under the totals row
+  const plan = { sections: sections.map((r) => r + 1), lastItem1: lastItem0 + 1, totalRow1: totalRow0 + 1, blankRowsBeforeTotals: blankBefore, oldSummaryRows: summaryEnd0 > totalRow0 ? `${totalRow0 + 2}–${summaryEnd0 + 1}` : "none", foreignContentAtRow: nextContent0 < 0 ? null : nextContent0 + 1, rowsToInsertForSummary: Math.max(0, 3 - Math.min(freeAfter, 3)) };
+  if (opts.dryRun) return { layout: { headerRow1: layout.headerRow + 1, sizeColumns: cols.sizeLabels, totalCol: L(cols.total) }, plan };
+
+  // 1. section rows (before any row deletion — indices are current)
+  const reqs = [];
+  const merges = Array.isArray(grid.merges) ? grid.merges : [];
+  for (const r0 of sections) {
+    // Google only unmerges an EXACT existing range — use the sheet's own merge list (two Hilo
+    // sheets had section rows merged wider than the table, and A:<HIGH $> 400'd).
+    for (const m of merges) if (m.startRowIndex <= r0 && m.endRowIndex > r0) reqs.push({ unmergeCells: { range: { sheetId, startRowIndex: m.startRowIndex, endRowIndex: m.endRowIndex, startColumnIndex: m.startColumnIndex, endColumnIndex: m.endColumnIndex } } });
+    reqs.push({ mergeCells: { range: gridRange(sheetId, r0, r0 + 1, 0, width), mergeType: "MERGE_ALL" } });
+    reqs.push(fmtReq(sheetId, r0, r0 + 1, 0, width,
+      { backgroundColor: hexToColor(COLOR.sectionBg), textFormat: { fontFamily: "Arial", fontSize: 10, bold: true, foregroundColor: hexToColor(COLOR.white) }, horizontalAlignment: "LEFT" },
+      "userEnteredFormat(backgroundColor,textFormat,horizontalAlignment)"));
+  }
+  if (reqs.length) await api.batch(reqs);
+  // 2. clear the old summary block (values + formats), then delete the blank rows before the totals row
+  if (summaryEnd0 > totalRow0) {
+    await api.clearValues(TAB_TSHIRT, `A${totalRow0 + 2}:${L(width - 1)}${summaryEnd0 + 1}`);
+    await api.batch([fmtReq(sheetId, totalRow0 + 1, summaryEnd0 + 1, 0, width, {}, "userEnteredFormat")]);
+  }
+  let tot0 = totalRow0;
+  if (blankBefore > 0) {
+    await api.batch([{ deleteDimension: { range: { sheetId, dimension: "ROWS", startIndex: lastItem0 + 1, endIndex: totalRow0 } } }]);
+    tot0 = lastItem0 + 1;
+  }
+  // make room for the 3 summary rows when other content sits close under the totals row
+  if (plan.rowsToInsertForSummary > 0) {
+    const at = tot0 + 1 + (freeAfter === Infinity ? 3 : Math.max(0, freeAfter)); // insert right before the foreign content
+    await api.batch([{ insertDimension: { range: { sheetId, dimension: "ROWS", startIndex: at, endIndex: at + plan.rowsToInsertForSummary }, inheritFromBefore: false } }]);
+  }
+  // 3. totals row band
+  await api.batch([
+    fmtReq(sheetId, tot0, tot0 + 1, 0, width, { backgroundColor: hexToColor(COLOR.tshirtTotalBg), textFormat: { fontSize: 10, bold: true }, horizontalAlignment: "LEFT" }, "userEnteredFormat(backgroundColor,textFormat,horizontalAlignment)"),
+    fmtReq(sheetId, tot0, tot0 + 1, cols.days, width, { horizontalAlignment: "RIGHT" }, "userEnteredFormat.horizontalAlignment"),
+  ]);
+  // 4. summary block directly under the totals row
+  const t1 = tot0 + 1;
+  const hf = `$${L(cols.highFactor.c)}$${cols.highFactor.r + 1}`;
+  const rows = [
+    ["Total Days", `=${L(cols.total)}${t1}`, `=${L(cols.total)}${t1}*${hf}`],
+    ["Total Hrs", `=${L(cols.total)}${t1}*8`, `=${L(cols.total)}${t1}*${hf}*8`],
+    ["Total Cost", `=${L(cols.low)}${t1}`, `=${L(cols.high)}${t1}`],
+  ];
+  await api.putValues(TAB_TSHIRT, `${L(cols.total)}${t1 + 1}:${L(cols.total + 2)}${t1 + 3}`, rows);
+  await api.batch([
+    fmtReq(sheetId, t1, t1 + 3, cols.total, cols.total + 3, { textFormat: { fontSize: 10, bold: true } }, "userEnteredFormat.textFormat"),
+    fmtReq(sheetId, t1, t1 + 2, cols.total + 1, cols.total + 3, { horizontalAlignment: "RIGHT", numberFormat: { type: "NUMBER", pattern: "0.00" } }, "userEnteredFormat(horizontalAlignment,numberFormat)"),
+    fmtReq(sheetId, t1 + 2, t1 + 3, cols.total + 1, cols.total + 3, { horizontalAlignment: "RIGHT", numberFormat: { type: "CURRENCY", pattern: "$#,##0.00" } }, "userEnteredFormat(horizontalAlignment,numberFormat)"),
+  ]);
+  const result = { plan, totalRow1: t1 };
+  if (!opts.noAudit) result.audit = await runAudit(api);
+  return result;
+}
+
 async function verbWrite(api, plan, opts) {
   const ts = await writeTshirt(api, plan, opts);
   const rosters = buildRosters(plan, ts.layout);
@@ -1208,7 +1488,7 @@ async function verbWrite(api, plan, opts) {
   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: { 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 },
+    teamMix: { grids: tm.grids, phases: rosters.map((r) => ({ phase: r.phase, lowDays: r.totalDays, highDays: r.highDays, staffDays: r.staffDays, 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);
@@ -1221,7 +1501,7 @@ function parseArgs(argv) {
   const out = { _: [] };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
-    if (a === "--json" || a === "--replace" || a === "--no-audit") out[a.slice(2)] = true;
+    if (a === "--json" || a === "--replace" || a === "--no-audit" || a === "--dry-run") out[a.slice(2)] = true;
     else if (a.startsWith("--")) { out[a.slice(2)] = argv[i + 1]; i++; }
     else out._.push(a);
   }
@@ -1233,7 +1513,7 @@ function printChecks(audit) {
   console.log(`${audit.ok ? "AUDIT PASS" : `AUDIT FAIL (${audit.failed})`} — ${audit.title}`);
 }
 
-const USAGE = "usage: gsd-t estimate-sheet <read|plan-check|write|audit|plan-schema> --sheet <id|url> [--tab <name>] [--plan <plan.json>] [--replace] [--no-audit] [--key <path>] [--json]";
+const USAGE = "usage: gsd-t estimate-sheet <read|plan-check|write|teammix|format|audit|plan-schema> --sheet <id|url> [--tab <name>] [--plan <plan.json>] [--replace] [--fte '{\"backend\":1.5}'] [--title <t>] [--dry-run] [--no-audit] [--key <path>] [--json]";
 
 /** Runs a verb; returns the exit code. Throws Halt (or any error) — the runner below turns that into exit 4/64. */
 async function main(args) {
@@ -1249,6 +1529,26 @@ async function main(args) {
     else { console.log(r.title); r.tabs.forEach((t) => console.log(`  tab ${JSON.stringify(t.title)} id=${t.sheetId}`)); (r.rows ? r.rows : []).forEach((l) => console.log(l)); }
     return 0;
   }
+  if (verb === "teammix") {
+    // rebuild the Team Mix from the sheet's own roster + phase rollups (no plan file)
+    let fte;
+    if (args.fte) { try { fte = JSON.parse(args.fte); } catch (e) { throw new Halt(`--fte must be JSON like {"backend":1.5,"qa":0.4}: ${e.message}`, 64); } }
+    const r = await verbTeamMix(api, { fte, title: args.title, dryRun: !!args["dry-run"], noAudit: !!args["no-audit"] });
+    const ok = !r.audit || r.audit.ok;
+    if (json) console.log(JSON.stringify({ ok, exitCode: ok ? 0 : 4, ...r }, null, 2));
+    else {
+      console.log(`title: ${r.title}`); console.log(`fte: ${JSON.stringify(r.fte)}`); console.log(r.table);
+      if (r.audit) printChecks(r.audit); else if (args["dry-run"]) console.log("(dry run — nothing written)");
+    }
+    return ok ? 0 : 4;
+  }
+  if (verb === "format") {
+    const r = await verbFormat(api, { dryRun: !!args["dry-run"], noAudit: !!args["no-audit"] });
+    const ok = !r.audit || r.audit.ok;
+    if (json) console.log(JSON.stringify({ ok, exitCode: ok ? 0 : 4, ...r }, null, 2));
+    else { console.log(JSON.stringify(r.plan)); if (r.audit) printChecks(r.audit); else if (args["dry-run"]) console.log("(dry run — nothing written)"); }
+    return ok ? 0 : 4;
+  }
   if (verb === "audit") {
     const a = await runAudit(api);
     if (json) console.log(JSON.stringify({ ok: a.ok, exitCode: a.ok ? 0 : 4, ...a }, null, 2)); else printChecks(a);
@@ -1271,7 +1571,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}`);
-      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}`);
+      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} (midpoint of ${ph.lowDays}–${ph.highDays})`);
       console.log(r.teamMix.table);
       console.log(`Technology Stack: ${r.techStack.rows} rows`);
       if (r.audit) printChecks(r.audit);
@@ -1291,7 +1591,7 @@ function haltAndExit(e, json) {
 
 module.exports = {
   validatePlan, splitRoster, rosterViolations, mfCoverageViolations, monthPlan, resampleWeights, rampHours, buildRoster,
-  tshirtTotals, phaseTotals, buildRosters, itemFormulas, rollupFormulas, tshirtRows, teamMixValues, teamMixFormatReqs, remainderFormula, locateTshirt, findPhaseSource,
+  tshirtTotals, phaseTotals, buildRosters, midDays, deriveFteFromTeamMix, phaseTotalsFromSheet, verbTeamMix, itemFormulasFor, rollupFormulasFor, findCell, 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.20.12",
+  "version": "5.20.14",
   "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

@@ -130,14 +130,15 @@ The old `Month / Days / Tot Days / Hrs` layout is retired: `Days` IS the per-per
 
 ### 2.2 The math
 
-- `months = totalDays / (Σ Count × 20)` — solve so `Σ Days` equals the T-Shirt `Total Days`.
-- Month columns `N = ceil(months)`, EXCEPT when the fractional tail is under ~0.1 month: fold it into the last full month (soft ceiling ~172 hrs) instead of opening a near-empty column.
+- **The Team Mix staffs the MIDPOINT of the Low and High figures** (David, 2026-09-21): `staffDays = Low Total Days × (1 + high factor) / 2` — per phase, from that phase's `Low Hrs` and `High Hrs` rollups. Never the Low figure alone.
+- `months = staffDays / (Σ Count × 20)` — solve so `Σ Days` equals that midpoint.
+- Month columns `N = ceil(months)`, EXCEPT when the fractional tail is under ~0.1 month AND a full-time person still fits under the soft ceiling (`months × 160 ≤ N × 172`): then fold it into the last full month instead of opening a near-empty column.
 - **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`.
+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 **the midpoint of that phase's Low and High days** (`(Low Hrs + High Hrs) ÷ 2 ÷ 8` from the phase rollups), and the grids together reconcile to the midpoint of `Total Days` and `Total Days × high factor`. 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
 
@@ -171,6 +172,8 @@ Monthly hours follow when the work happens. Normalise the weights, multiply by t
 | DevOps | 0.45 / 0.85 / 1.70 | back-loaded — mirror of BA |
 | Project Manager | 1.00 / 1.00 / 1.00 | flat |
 | Tech Lead / Architect | 1.30 / 0.80 / 0.90 | design-heavy, uptick at integration |
+| Design / UX | 1.60 / 0.90 / 0.50 | heaviest at the start, a tail for revisions |
+| Mobile | 1.35 / 1.05 / 0.60 | same shape as frontend |
 
 - A flat `160 / 160 / 147` for every role is the tell that no ramping was applied.
 - **The only ceiling is 160 hrs per person per month, soft to ~172.** There is NO `Count × 160` per-row ceiling — a 0.40 QA can work 106 hrs in their heavy month; that is what ramping means.
@@ -226,7 +229,7 @@ TEAM MIX (each grid)
   [ ] 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
-  [ ] each grid's Σ Days == that phase's T-Shirt days; all grids together == Total Days
+  [ ] each grid's Σ Days == midpoint of that phase's Low/High days; all grids together == midpoint of Total Days and Total Days × high factor
 TECH STACK
   [ ] at least the categories that apply are filled; none says TBD
 OVERVIEW
@@ -245,8 +248,17 @@ gsd-t estimate-sheet read       --sheet <id|url> [--tab <name>]   # read-before-
 gsd-t estimate-sheet plan-check --sheet <id|url> --plan plan.json # validate + the roster it WOULD write (the Step 4 pause)
 gsd-t estimate-sheet write      --sheet <id|url> --plan plan.json [--replace]   # T-Shirt + Team Mix + Tech Stack, then audit
 gsd-t estimate-sheet audit      --sheet <id|url>                  # §5 checklist by read-back
+gsd-t estimate-sheet format     --sheet <id|url> [--dry-run]      # normalise T-Shirt FORMATTING only: section rows (§1.2), grey totals band directly under
+                                # the last item, standard summary block directly under it (§1.3); no size, phase, text or item formula is touched;
+                                # rows under the totals row that are not the old summary block are never overwritten (rows are inserted above them)
+gsd-t estimate-sheet teammix    --sheet <id|url> [--fte '{"backend":1.5,…}'] [--title <t>] [--dry-run]
+                                # rebuild the Team Mix (one grid per phase) from the sheet's OWN roster and phase rollups — no plan needed;
+                                # the roster is derived from the existing grid (entered Counts summed per discipline; older peak-utilisation
+                                # rosters split the sheet's total FTE by each role's hours); --fte overrides it; halts on a role it cannot map
 ```
 
+Both the current template and the older layout (Project/Client rows on top, legend from row 8, up to four size columns, header row 17) are READ by `audit` and `teammix` — every coordinate comes from the labels, never a fixed row. `write` produces the current template only.
+
 The plan (judgment only):
 
 ```json
@@ -263,5 +275,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. It writes **one grid per phase with hours** (§2.6); `teamMix.phases: { "Phase 1": { "fte": {…} } }` overrides the mix for one phase.
+- `teamMix.fte` is per-discipline FTE (`backend` `frontend` `qa` `pm` `ba` `devops` `techlead` `design` `mobile`). 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.