@tekyzinc/gsd-t 5.20.13 → 5.20.15

package/CHANGELOG.md

@@ -2,6 +2,57 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.20.15] - 2026-09-21
+
+### Changed — phases must be contiguous; the Team Mix title row is the phase name only
+
+David's review of the 19 Hilo estimates: one had items in MVP and Phase 2 with nothing in
+Phase 1, and every Team Mix title row carried the estimate name.
+
+- Rule (spec §2.6): phases are contiguous — `MVP`, `Phase 1`, `Phase 2`, … with no empty phase
+  between used ones. The audit fails a gap. New `phases` verb renumbers the item Phase cells to
+  close the gap and rebuilds the Team Mix grids.
+- Rule (spec §2.1): each grid's title row is EXACTLY the phase name. The writer, `teammix` and
+  the audit follow it; the plan's `title` is no longer used. New `titles` verb sets existing
+  grids' title rows (the nearest non-empty row above the header — older grids keep a blank row
+  between title and header).
+- Applied: Acron Academy renumbered (Phase 2→1, Phase 3→2, 20 cells) and its grids rebuilt;
+  all 19 estimates' Team Mix titles renamed.
+- Rule (spec §0 / §1.2): Functionality and Low Level Requirements wrap on every item row, and
+  every cell on every tab is top-aligned. Writer, `format` verb (which now top-aligns all tabs)
+  and audit follow it; applied to all 19 estimates.
+- The 14 single-phase estimates' Team Mixes rebuilt on the Low/High midpoint (`teammix`), so all
+  19 now staff the midpoint; the command's Step 4 states the rule.
+
+## [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

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v5.20.13** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
+**v5.20.15** - 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,10 @@
  *   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
+ *   phases     --sheet <id|url> [--dry-run]              close phase gaps (MVP, Phase 2 → MVP, Phase 1) on the T-Shirt tab, then rebuild the Team Mix
+ *   titles     --sheet <id|url> [--dry-run]              set each Team Mix grid's title row to exactly its phase name
  *   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 +78,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 +90,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 +194,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 +202,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) {
@@ -217,7 +234,7 @@ class SheetsApi {
 
   async grid(tab) {
     const rng = encodeURIComponent(`'${tab}'`);
-    const fields = "sheets(merges,properties,data(rowData(values(formattedValue,userEnteredValue,effectiveValue,userEnteredFormat(backgroundColor,textFormat,horizontalAlignment,numberFormat),dataValidation)),columnMetadata(pixelSize)))";
+    const fields = "sheets(merges,properties,data(rowData(values(formattedValue,userEnteredValue,effectiveValue,userEnteredFormat(backgroundColor,textFormat,horizontalAlignment,verticalAlignment,wrapStrategy,numberFormat),dataValidation)),columnMetadata(pixelSize)))";
     const r = await this.call("GET", `${this.base}?ranges=${rng}&includeGridData=true&fields=${fields}`);
     if (!r.sheets || !r.sheets[0]) throw new Halt(`tab '${tab}' not found`, 64);
     return r.sheets[0];
@@ -300,58 +317,104 @@ 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 = {
-  title: "string — Team Mix title, e.g. 'Hilo ATOS — ATP Gap Closure'",
+  title: "optional string — no longer written anywhere (the Team Mix title row is the phase name only)",
   tshirt: {
     mode: "'items' (write whole rows from row 14) | 'sizes' (rows already exist; fill E:L, matched by the id in column C)",
     sections: [{
@@ -376,7 +439,7 @@ function sizeOf(v) { return v == null ? "" : String(v).trim(); }
 function validatePlan(plan) {
   const errors = [];
   if (!plan || typeof plan !== "object") return ["plan is not an object"];
-  if (!plan.title || typeof plan.title !== "string") errors.push("title: required string");
+  if (plan.title != null && typeof plan.title !== "string") errors.push("title: must be a string when given (unused since v5.20.15 — the Team Mix title row is the phase name)");
   const t = plan.tshirt && typeof plan.tshirt === "object" ? plan.tshirt : {};
   if (!["items", "sizes"].includes(t.mode)) errors.push("tshirt.mode: must be 'items' or 'sizes'");
   const sections = Array.isArray(t.sections) ? t.sections : [];
@@ -478,7 +541,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 +621,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) {
@@ -611,6 +692,13 @@ function tshirtRows(plan, firstRow0) {
 function fmtReq(sheetId, r0, r1, c0, c1, format, fields) {
   return { repeatCell: { range: gridRange(sheetId, r0, r1, c0, c1), cell: { userEnteredFormat: format }, fields } };
 }
+/** Rule (spec §0): every cell on a tab the tool writes is TOP-aligned; Functionality + Low Level Requirements wrap. */
+function topAlignReq(sheetId, rows) {
+  return fmtReq(sheetId, 0, rows, 0, 26, { verticalAlignment: "TOP" }, "userEnteredFormat.verticalAlignment");
+}
+function wrapReq(sheetId, r0, r1, c0, c1) {
+  return fmtReq(sheetId, r0, r1, c0, c1, { wrapStrategy: "WRAP" }, "userEnteredFormat.wrapStrategy");
+}
 function widthReqs(sheetId, widths) {
   return widths.map((w, i) => ({ updateDimensionProperties: { range: { sheetId, dimension: "COLUMNS", startIndex: i, endIndex: i + 1 }, properties: { pixelSize: w }, fields: "pixelSize" } }));
 }
@@ -631,6 +719,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`);
@@ -686,6 +776,8 @@ async function writeTshirt(api, plan, opts) {
       reqs.push(copyPhaseReq(sheetId, phaseSrc, r0)); // carries validation + chip format; value re-put below
     }
   }
+  reqs.push(wrapReq(sheetId, first0, lastItem0, 2, 4)); // Functionality + Low Level Requirements wrap
+  reqs.push(topAlignReq(sheetId, lastWritten1 + 5));    // every cell top-aligned
   reqs.push(...widthReqs(sheetId, TSHIRT_WIDTHS));
   await api.batch(reqs);
   // 5. the Phase VALUES again — copyPaste overwrote them with the source cell's value
@@ -728,7 +820,9 @@ async function writeTshirtSizes(api, grid, sheetId, layout, plan, totals, phaseS
     reqs.push(fmtReq(sheetId, w.r0, w.r0 + 1, 4, 7, FMT_ITEM_SIZE, "userEnteredFormat(horizontalAlignment,textFormat)"));
     reqs.push(fmtReq(sheetId, w.r0, w.r0 + 1, 7, 10, FMT_ITEM_NUM, FMT_FIELDS_ALL));
     reqs.push(fmtReq(sheetId, w.r0, w.r0 + 1, 10, 12, FMT_ITEM_CUR, FMT_FIELDS_ALL));
+    reqs.push(wrapReq(sheetId, w.r0, w.r0 + 1, 2, 4));
   }
+  reqs.push(topAlignReq(sheetId, rowCount(grid) + 2));
   await api.batch(reqs);
   for (const w of writes) await api.putValues(TAB_TSHIRT, `E${w.r0 + 1}`, [[w.phase]]);
   const first1 = layout.firstItemRow + 1;
@@ -791,7 +885,7 @@ function teamMixValues(plan, roster, phase, top) {
   for (let m = 1; m <= n; m++) header.push(`Mon ${m}`);
   header.push("Total Hrs");
   const rows = [];
-  rows.push([phase ? `${plan.title} — ${phase}` : plan.title, ...Array(width - 1).fill("")]);
+  rows.push([phase ? phase : "MVP", ...Array(width - 1).fill("")]); // the title row holds ONLY the phase name (David, 2026-09-21)
   rows.push(header);
   const firstP = top + 3; // 1-based row of the first person
   roster.people.forEach((p, i) => {
@@ -848,7 +942,7 @@ async function writeTeamMix(api, plan, rosters) {
   const grids = [];
   let top = 0;
   for (const r of rosters) {
-    const v = teamMixValues(plan, r.roster, rosters.length > 1 || r.phase ? r.phase : "", top);
+    const v = teamMixValues(plan, r.roster, r.phase, top);
     grids.push({ phase: r.phase, v });
     top = v.bottom + GRID_GAP;
   }
@@ -867,6 +961,7 @@ async function writeTeamMix(api, plan, rosters) {
     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]));
+  reqs.push(topAlignReq(sheetId, lastRow + 5));
   await api.batch(reqs);
   return { grids: grids.map((g) => ({ phase: g.phase, titleR: g.v.titleR, bottom: g.v.bottom, rows: g.v.rows.length })), lastRow };
 }
@@ -888,6 +983,7 @@ async function writeTechStack(api, plan) {
     { mergeCells: { range: gridRange(sheetId, 0, 1, 0, 2), mergeType: "MERGE_ALL" } },
     fmtReq(sheetId, 0, 1, 0, 2, { backgroundColor: hexToColor(COLOR.teamHeaderBg), textFormat: { fontSize: 12, bold: true, foregroundColor: hexToColor(COLOR.white) } }, "userEnteredFormat(backgroundColor,textFormat)"),
     fmtReq(sheetId, 1, rows.length, 0, 2, { textFormat: { fontFamily: "Arial", fontSize: 10 }, wrapStrategy: "WRAP" }, "userEnteredFormat(textFormat,wrapStrategy)"),
+    topAlignReq(sheetId, rows.length + 5),
     ...widthReqs(sheetId, TECH_WIDTHS),
   ]);
   return { rows: rows.length - 1 };
@@ -897,74 +993,85 @@ 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 = [];
+  const badSizes = [], noDv = [], badFormula = [], sectionsWithSizes = [], badSectionFmt = [], noWrap = [], notTop = [];
   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}`);
+    for (const c of [2, 3]) { const fm = cellAt(grid, r, c) && cellAt(grid, r, c).userEnteredFormat; if (!fm || fm.wrapStrategy !== "WRAP") noWrap.push(`${colLetter(c)}${r + 1}`); }
+    for (const c of [0, 2, cols.days]) { const fm = cellAt(grid, r, c) && cellAt(grid, r, c).userEnteredFormat; if (!fm || fm.verticalAlignment !== "TOP") notTop.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: Functionality + Low Level Requirements wrap on every item row", !noWrap.length, noWrap.slice(0, 8).join(", "));
+  check(out, "T-Shirt: item cells are top-aligned", !notTop.length, notTop.slice(0, 8).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");
+  const usedPhases = new Set();
+  for (let r = first0; r <= lastItem0; r++) { const v = textAt(grid, r, cols.phase).trim(); if (PHASES.includes(v)) usedPhases.add(v); }
+  const gapMap = phaseGapMap([...usedPhases]);
+  check(out, "T-Shirt: phases are contiguous (no empty phase between used ones)", !Object.keys(gapMap).length, `used [${PHASES.filter((p) => usedPhases.has(p)).join(", ")}] — rename ${Object.entries(gapMap).map(([a, b]) => `${a}→${b}`).join(", ")}`);
   let totalDaysCell = NaN;
-  // Team Mix reconciles to the MIDPOINT of each phase's Low Hrs (L) and High Hrs (N), in days
   const phaseDays = {};
   for (const rr of layout.rollupRows) {
-    const low = numAt(grid, rr, 11), high = numAt(grid, rr, 13);
-    phaseDays[textAt(grid, rr, 9).trim()] = Number.isNaN(low) || Number.isNaN(high) ? NaN : round2((low + high) / 2 / 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}`);
@@ -975,12 +1082,14 @@ function auditTshirt(grid) {
 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 "";
 }
 
@@ -1077,6 +1186,8 @@ function auditTeamMix(grid, mfList, tshirtTotalDays, phaseDays) {
       }
     }
     check(out, `${label}: body font is Arial (never Calibri)`, !badFont.length, badFont.slice(0, 8).join(", "));
+    const notTopTm = people.filter((p) => { const fm = cellAt(grid, p.r, 0) && cellAt(grid, p.r, 0).userEnteredFormat; return !fm || fm.verticalAlignment !== "TOP"; }).map((p) => `A${p.r + 1}`);
+    check(out, `${label}: cells are top-aligned`, !notTopTm.length, notTopTm.slice(0, 6).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 = [];
@@ -1093,9 +1204,9 @@ function auditTeamMix(grid, mfList, tshirtTotalDays, phaseDays) {
       // Σ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));
+      const phase = expectedPhases.find((ph) => title.trim() === ph);
       if (expectedPhases.length) {
-        check(out, `${label}: title names a phase with hours`, !!phase, `title '${title}' ends with none of [${expectedPhases.join(", ")}]`);
+        check(out, `${label}: title row is exactly the phase name`, !!phase, `title '${title}' is not one of [${expectedPhases.join(", ")}]`);
         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;
@@ -1208,6 +1319,264 @@ 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 = "";
+  const plan = { 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)"),
+  ]);
+  // 5. wrap Functionality + Low Level Requirements on item rows; top-align every cell on EVERY tab
+  await api.batch([wrapReq(sheetId, first0, tot0, 2, 4), topAlignReq(sheetId, Math.max(rowCount(grid), t1 + 6))]);
+  const meta = await api.meta();
+  for (const s of meta.sheets) {
+    if (s.properties.title === TAB_TSHIRT) continue;
+    const rows = s.properties.gridProperties && s.properties.gridProperties.rowCount ? Math.min(s.properties.gridProperties.rowCount, 200) : 100;
+    await api.batch([topAlignReq(s.properties.sheetId, rows)]);
+  }
+  const result = { plan, totalRow1: t1 };
+  if (!opts.noAudit) result.audit = await runAudit(api);
+  return result;
+}
+
+/**
+ * Phases must be contiguous: MVP, then Phase 1, Phase 2, … with no empty phase between used
+ * ones (David, 2026-09-21: "MVP then nothing in Phase 1 but items in Phase 2"). Given the set
+ * of phases that carry items, return the rename map that closes the gaps ({} when none).
+ */
+function phaseGapMap(usedPhases) {
+  const numbered = PHASES.filter((p) => p !== "MVP" && usedPhases.includes(p));
+  const map = {};
+  numbered.forEach((p, i) => { const want = `Phase ${i + 1}`; if (p !== want) map[p] = want; });
+  return map;
+}
+
+/** Renumber phases on the T-Shirt tab to close gaps, then rebuild the Team Mix grids to match. */
+async function verbPhases(api, opts) {
+  const grid = await api.grid(TAB_TSHIRT);
+  const layout = locateTshirt(grid);
+  const { cols } = layout;
+  const used = new Set();
+  const cells = [];
+  for (let r = layout.firstItemRow; r < rowCount(grid); r++) {
+    if (/^Total \(Days\)/i.test(textAt(grid, r, 0))) break;
+    const v = textAt(grid, r, cols.phase).trim();
+    if (v === "") continue;
+    if (!PHASES.includes(v)) throw new Halt(`${TAB_TSHIRT}: ${colLetter(cols.phase)}${r + 1} holds '${v}', not one of ${PHASES.join(" | ")}`);
+    used.add(v);
+    cells.push({ r, v });
+  }
+  const map = phaseGapMap([...used]);
+  const plan = { phasesUsed: PHASES.filter((p) => used.has(p)), renames: map, cellsToChange: cells.filter((c) => map[c.v]).length };
+  if (opts.dryRun || !Object.keys(map).length) return { plan, changed: false };
+  for (const c of cells) if (map[c.v]) await api.putValues(TAB_TSHIRT, `${colLetter(cols.phase)}${c.r + 1}`, [[map[c.v]]]);
+  const tm = await verbTeamMix(api, { fte: opts.fte, noAudit: true });
+  const result = { plan, changed: true, teamMix: tm.phases };
+  if (!opts.noAudit) result.audit = await runAudit(api);
+  return result;
+}
+
+/** Set every Team Mix grid's title row to exactly its phase name (rule §2.1). */
+async function verbTitles(api, opts) {
+  const tshirt = await api.grid(TAB_TSHIRT);
+  const layout = locateTshirt(tshirt);
+  const withHours = phaseTotalsFromSheet(tshirt, layout).map((p) => p.phase);
+  const team = await api.grid(TAB_TEAM);
+  const headers = [];
+  for (let r = 0; r < rowCount(team); r++) if (textAt(team, r, 0) === "Skill set") headers.push(r);
+  if (!headers.length) throw new Halt(`${TAB_TEAM}: no grid found`);
+  if (headers.length !== withHours.length) throw new Halt(`${TAB_TEAM}: ${headers.length} grid(s) but ${withHours.length} phase(s) with hours [${withHours.join(", ")}] — run 'teammix' first`);
+  const changes = [];
+  headers.forEach((h, i) => {
+    if (h < 1) throw new Halt(`${TAB_TEAM}: header at row 1 has no title row above it`);
+    // the title is the nearest non-empty row above the header (older grids keep a blank row 2
+    // between title and header — writing into the blank row left the old title in place)
+    const titleR = textAt(team, h - 1, 0).trim() === "" && h >= 2 && textAt(team, h - 2, 0).trim() !== "" ? h - 2 : h - 1;
+    const cur = textAt(team, titleR, 0).trim();
+    const fromTitle = PHASES.find((p) => cur === p || cur.endsWith(` — ${p}`));
+    const want = fromTitle ? fromTitle : withHours[i];
+    if (fromTitle && fromTitle !== withHours[i]) throw new Halt(`${TAB_TEAM}: grid ${i + 1} is titled for ${fromTitle} but the ${i + 1}${["st", "nd", "rd"][i] || "th"} phase with hours is ${withHours[i]} — run 'teammix' first`);
+    if (cur !== want) changes.push({ row1: titleR + 1, from: cur, to: want });
+  });
+  if (opts.dryRun) return { changes, changed: false };
+  for (const c of changes) await api.putValues(TAB_TEAM, `A${c.row1}`, [[c.to]]);
+  return { changes, changed: changes.length > 0 };
+}
+
 async function verbWrite(api, plan, opts) {
   const ts = await writeTshirt(api, plan, opts);
   const rosters = buildRosters(plan, ts.layout);
@@ -1228,7 +1597,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);
   }
@@ -1240,7 +1609,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|phases|titles|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) {
@@ -1256,6 +1625,41 @@ 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 === "phases") {
+    let fte;
+    if (args.fte) { try { fte = JSON.parse(args.fte); } catch (e) { throw new Halt(`--fte must be JSON: ${e.message}`, 64); } }
+    const r = await verbPhases(api, { dryRun: !!args["dry-run"], noAudit: !!args["no-audit"], fte });
+    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)); console.log(r.changed ? "phases renumbered + Team Mix rebuilt" : (Object.keys(r.plan.renames).length ? "(dry run — nothing written)" : "no gap — nothing to do")); if (r.audit) printChecks(r.audit); }
+    return ok ? 0 : 4;
+  }
+  if (verb === "titles") {
+    const r = await verbTitles(api, { dryRun: !!args["dry-run"] });
+    if (json) console.log(JSON.stringify({ ok: true, exitCode: 0, ...r }, null, 2));
+    else { console.log(r.changes.length ? r.changes.map((c) => `A${c.row1}: '${c.from}' → '${c.to}'`).join("\n") : "titles already correct"); if (args["dry-run"] && r.changes.length) console.log("(dry run — nothing written)"); }
+    return 0;
+  }
+  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);
@@ -1298,7 +1702,7 @@ function haltAndExit(e, json) {
 
 module.exports = {
   validatePlan, splitRoster, rosterViolations, mfCoverageViolations, monthPlan, resampleWeights, rampHours, buildRoster,
-  tshirtTotals, phaseTotals, buildRosters, midDays, itemFormulas, rollupFormulas, tshirtRows, teamMixValues, teamMixFormatReqs, remainderFormula, locateTshirt, findPhaseSource,
+  tshirtTotals, phaseTotals, buildRosters, midDays, deriveFteFromTeamMix, phaseTotalsFromSheet, verbTeamMix, phaseGapMap, verbPhases, verbTitles, 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/commands/gsd-t-estimate.md

@@ -87,6 +87,7 @@ Reorder items into domains. Insert a **section-heading row** before each group p
 
 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.
 
+0. **The Team Mix staffs the MIDPOINT of the Low and High estimates** — per phase, `(Low Hrs + High Hrs) ÷ 2 ÷ 8` days from that phase's rollups — never the Low figure. The tool computes it; you do not choose it.
 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.
 3. **PAUSE:** present that table verbatim. Wait for `continue` or corrections (a resize or a different FTE → edit the plan, re-run plan-check, present again).

package/package.json

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

@@ -27,6 +27,8 @@ Reference implementation (read it, don't guess): "ATP SOW Gap Analysis and Estim
 | **Map sheet rows to items BY NAME, not by counting.** | Section header rows shift positional alignment and put a whole column on the wrong tasks. |
 | **Recompute the total from raw sizes independently** (`Σ(FE,BE days) × (1 + MF)`) before reporting a number. | A total was reported from a cell just repaired; the true figure differed by 13 days. |
 | **`IMPORTRANGE` `#REF!` on the index sheet needs a human "Allow access" click.** Report it; do not "fix" it. | The service account cannot grant it. |
+| **Every cell on every tab the tool writes is TOP-aligned.** | David, 2026-09-21. |
+| **Functionality and Low Level Requirements wrap** (T-Shirt columns C and D, every item row); Technology Stack descriptions wrap. | Long requirement text was running off the cell. |
 | Access token expires in 1 h — mint fresh per run; regenerate on a sudden 401. | |
 
 ---
@@ -65,8 +67,8 @@ Column widths: `[150, 120, 300, 430, 122, 90, 90, 61, 53, 76, 81, 81]`.
 |---|---|---|
 | `A` | Module | |
 | `B` | User type | |
-| `C` | Functionality — **include the item id** `(GA-n)` / `(TD-n)` / `(FR-n)` | |
-| `D` | Low-level requirement (one or two sentences) | |
+| `C` | Functionality — **include the item id** `(GA-n)` / `(TD-n)` / `(FR-n)` | **wrap** |
+| `D` | Low-level requirement (one or two sentences) | **wrap** |
 | `E` | Phase — `MVP` / `Phase 1` / `Phase 2` / `Phase 3` | **Carries a `ONE_OF_LIST` validation + chip format. Populate by `copyPaste` (`PASTE_NORMAL`) from an existing MVP cell — a values-write drops the dropdown.** |
 | `F` | Web Portal (frontend) size | **Bare code only: `XS` `S` `M` `L` `XL` `XXL`. Never the legend text `"XS - Extra Small"`.** Blank = 0. |
 | `G` | Backend/API size | same |
@@ -97,7 +99,7 @@ Total (Days) | … | H =SUM(H14:H<last>) | I =SUM(I…) | J =SUM(J…) | K =SUM(
 ### 2.1 Layout of ONE grid
 
 ```
-Row t   Title  "<estimate title> — <phase>"  (merged A:<Total Hrs col>)
+Row t   Title  — EXACTLY the phase name: "MVP" / "Phase 1" / …  (merged A:<Total Hrs col>; nothing else in it)
 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)
@@ -132,12 +134,16 @@ The old `Month / Days / Tot Days / Hrs` layout is retired: `Days` IS the per-per
 
 - **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: fold it into the last full month (soft ceiling ~172 hrs) instead of opening a near-empty column.
+- 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
 
+**Phases are contiguous.** Items use `MVP`, then `Phase 1`, `Phase 2`, `Phase 3` with no empty phase between used ones — `MVP` + `Phase 2` with nothing in `Phase 1` is a defect; renumber (`Phase 2` → `Phase 1`, `Phase 3` → `Phase 2`) so the numbering has no gap (`gsd-t estimate-sheet phases` does this and rebuilds the grids). The audit fails a gap.
+
+**The title row of each grid is the phase name and nothing else** — `MVP`, `Phase 1`, … Never the estimate title, never "<title> — Phase 1" (David, 2026-09-21).
+
 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
@@ -172,6 +178,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.
@@ -210,13 +218,15 @@ Every item is a read-back check against the live sheet. Any ✗ blocks delivery.
 T-SHIRT
   [ ] every size cell in F:G is one of XS S M L XL XXL or blank (no legend text)
   [ ] every item row's E cell has ONE_OF_LIST validation
+  [ ] C and D wrap on every item row; every cell top-aligned
   [ ] 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>
   [ ] 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)
+  [ ] phases are contiguous — no empty phase between used ones
 TEAM MIX (each grid)
-  [ ] one grid per phase with hours; the title ends with the phase name; exactly 2 empty, unformatted rows between grids
+  [ ] one grid per phase with hours; the title row is EXACTLY 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
@@ -246,8 +256,19 @@ 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 phases     --sheet <id|url> [--dry-run]      # close phase gaps on the T-Shirt tab (Phase 2→1, 3→2 …), then rebuild the Team Mix grids
+gsd-t estimate-sheet titles     --sheet <id|url> [--dry-run]      # set each Team Mix grid's title row to exactly its phase name
+gsd-t estimate-sheet teammix    --sheet <id|url> [--fte '{"backend":1.5,…}'] [--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
@@ -264,5 +285,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.