@tekyzinc/gsd-t 5.21.10 → 5.22.10

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.22.10] - 2026-09-27
+
+### Added — AI-assisted T-shirt sizing for `/gsd-t-estimate`
+
+Estimates sized every task as if a person typed the code. Measured against the Hilo Delivery
+Runway build (45 tasks, ~26 solo hours: 13 David + 13 Claude), the old scale priced the same
+work at 1,262–1,577 hours. A size is now the team hours a task takes with AI-assisted
+development: solo AI minutes × project multiplier (greenfield solo ×1, team ×5; yellow-field
+solo ×2, team ×8 isolated / ×12 big blast radius) + task switching added after the multiplier
+(7.5 / 15 / 30 min), mapped to the nearest size on a smaller scale — XS 0.1 · S 0.25 · M 0.5 ·
+L 1 · XL 2 · XXL 4 person-days. The multipliers live in the estimator; the sheet layout is
+unchanged.
+
+- `bin/gsd-t-estimate-sheet.cjs`: new `size` verb (`--solo-min`, `--project`, `--switch-min`);
+  `write` puts the AI scale in the legend (matched by label); sizes mode halts if a sized row
+  outside the plan would be silently re-priced; `plan-check` previews on the new scale
+- `templates/estimate-sheet-spec.md`: §1.4 sizing model; legend + verb list updated
+- `commands/gsd-t-estimate.md`, `templates/playbooks/tekyz-estimation-and-prd-playbook.md`,
+  `templates/estimate-config.json`: size in solo AI minutes; new-team familiarization off by default
+- `test/estimate-sheet-writer.test.js`: +6 tests
+
+Existing estimate sheets keep the old scale until they are re-estimated.
+
+### Fixed — Red Team runs on Opus 5.5 under every profile
+
+The `standard` profile put Red Team on Sonnet, contradicting both profile contracts and the
+READMEs. It now runs on `opus` (Opus 5.5) in standard, pro and premium.
+
+- `bin/gsd-t-model-tier-policy.cjs`, `commands/gsd-t-status.md`,
+  `.gsd-t/contracts/model-profile-config-contract.md`, `test/m86-policy-profiles.test.js`
+
 ## [5.21.10] - 2026-09-22
 
 ### Changed — the top tier now points at Opus 5.5

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v5.21.10** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
+**v5.22.10** - 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.
@@ -184,7 +184,7 @@ This will replace changed command files, back up your CLAUDE.md if customized, a
 | `/gsd-t-scan` | Deep codebase analysis → techdebt.md | Manual |
 | `/gsd-t-gap-analysis` | Requirements gap analysis — spec vs. existing code | Manual |
 | `/gsd-t-promote-debt` | Convert techdebt items to milestones | Manual |
-| `/gsd-t-estimate` | Turn any work doc (scan, gap-analysis sheet, requirements, feature/app spec) into a Tekyz client estimate Google Sheet — T-Shirt Size + Team Mix + Technology Stack, written by the deterministic `gsd-t estimate-sheet` tool from a JSON plan and read-back-audited against `templates/estimate-sheet-spec.md` — supervised, with an operator-arbitrated Estimate Red Team. No PRD (that is `/gsd-t-prd`) | Manual |
+| `/gsd-t-estimate` | Turn any work doc (scan, gap-analysis sheet, requirements, feature/app spec) into a Tekyz client estimate Google Sheet — T-Shirt Size + Team Mix + Technology Stack, written by the deterministic `gsd-t estimate-sheet` tool from a JSON plan and read-back-audited against `templates/estimate-sheet-spec.md`; sizes assume AI-assisted development (solo AI minutes × project multiplier) — supervised, with an operator-arbitrated Estimate Red Team. No PRD (that is `/gsd-t-prd`) | Manual |
 | `/gsd-t-stories` | Generate a dev-team handoff doc in the Tekyz user-stories format (stories + workflows + acceptance criteria + Mermaid flow diagrams + mapped test cases) from any source | Manual |
 | `/gsd-t-demo-videos` | Narrated screen-recording walkthroughs of a running app — coverage plan, UI-driven seeding, batched TTS with a measured one-voice gate, continuous recording, mux, silence trim | Manual |
 | `/gsd-t-populate` | Auto-populate docs from existing codebase | Manual |

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

@@ -47,6 +47,21 @@ const TAB_TECH = "Technology Stack";
 const TAB_OVERVIEW = "Overview";
 
 const SIZE_CODES = ["XS", "S", "M", "L", "XL", "XXL"];
+
+// AI-assisted sizing model (David, 2026-09-27; calibrated on the Hilo Delivery Runway build:
+// 45 tasks, ~26 solo hours). A task is sized in SOLO AI-assisted minutes, multiplied by the
+// project type, plus a per-task switching allowance added AFTER the multiplier (switching is
+// one person's pickup time — it does not grow with team size). The result maps to the nearest
+// size on AI_SIZE_DAYS, which `write` puts in the sheet's legend. The multipliers live here,
+// in the estimator — never on the sheet.
+const AI_SIZE_DAYS = { XS: 0.1, S: 0.25, M: 0.5, L: 1, XL: 2, XXL: 4 };
+const PROJECT_MULTIPLIER = {
+  "greenfield-solo": 1,
+  "greenfield-team": 5,
+  "yellowfield-solo": 2,
+  "yellowfield-team-isolated": 8,
+  "yellowfield-team-wide": 12,
+};
 const PHASES = ["MVP", "Phase 1", "Phase 2", "Phase 3"];
 
 const COLOR = {
@@ -347,10 +362,11 @@ function locateTshirt(grid) {
   cols.sizeLabels = cols.sizes.map((c) => headerText[c]);
   // legend: the XS..XXL rows in column A
   const legend = {};
+  const legendRow1 = {};
   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 (legendFirst < 0) legendFirst = r; legendLast = r; }
+    if (m) { legend[m[1]] = numAt(grid, r, 1); legendRow1[m[1]] = 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}' (looked for 'XS - …' labels in column A above the header row)`);
@@ -391,7 +407,7 @@ function locateTshirt(grid) {
   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 };
+  return { headerRow, firstItemRow: headerRow + 1, legend, legendRow1, legendFirst1: legendFirst + 1, legendLast1: legendLast + 1, mf, mfTotal, mfTotalCell, highFactor, rate, rollupRows, cols };
 }
 
 /** The standard template's column map (what `write` produces). */
@@ -604,6 +620,33 @@ function buildRoster(plan, totalDays, mfList) {
 
 // ───────────────────────── T-Shirt totals (pure) ─────────────────────────
 
+/** Switching allowance (minutes) for a task of `teamMin` minutes: small 7.5, medium 15, large 30. */
+function defaultSwitchMin(teamMin) { return teamMin < 120 ? 7.5 : teamMin < 480 ? 15 : 30; }
+
+/**
+ * The estimator's per-task math: solo AI minutes × project multiplier + switching (after the
+ * multiplier), then the nearest AI_SIZE_DAYS size (geometric midpoints between neighbours).
+ */
+function aiTaskSize({ soloMin, project, switchMin }) {
+  const mult = PROJECT_MULTIPLIER[project];
+  if (mult == null) throw new Halt(`--project must be one of ${Object.keys(PROJECT_MULTIPLIER).join(" | ")}`, 64);
+  if (typeof soloMin !== "number" || !(soloMin > 0)) throw new Halt("--solo-min must be a positive number of minutes", 64);
+  const teamMin = soloMin * mult;
+  const sw = switchMin == null ? defaultSwitchMin(teamMin) : switchMin;
+  if (typeof sw !== "number" || sw < 0) throw new Halt("--switch-min must be a number of minutes ≥ 0", 64);
+  const hours = (teamMin + sw) / 60;
+  const days = hours / 8;
+  let size = SIZE_CODES[SIZE_CODES.length - 1];
+  for (let i = 0; i < SIZE_CODES.length - 1; i++) {
+    const cut = Math.sqrt(AI_SIZE_DAYS[SIZE_CODES[i]] * AI_SIZE_DAYS[SIZE_CODES[i + 1]]);
+    if (days < cut) { size = SIZE_CODES[i]; break; }
+  }
+  return { soloMin, project, multiplier: mult, switchMin: sw, hours: round2(hours), days: round2(days), size, sizeDays: AI_SIZE_DAYS[size] };
+}
+
+/** True when the sheet's legend already carries the AI scale. */
+function legendIsAi(legend) { return SIZE_CODES.every((c) => legend[c] === AI_SIZE_DAYS[c]); }
+
 function sizeDays(code, legend) {
   const v = sizeOf(code);
   if (v === "") return 0;
@@ -721,11 +764,15 @@ async function writeTshirt(api, plan, opts) {
   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`);
+  // New estimates use the AI-assisted scale: the legend is rewritten to AI_SIZE_DAYS (after the
+  // checks below pass, so a halted run changes nothing), and totals are computed on it.
+  const legendChange = !legendIsAi(layout.legend);
+  layout.legend = { ...AI_SIZE_DAYS };
   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`);
 
-  if (plan.tshirt.mode === "sizes") return writeTshirtSizes(api, grid, sheetId, layout, plan, totals, phaseSrc);
+  if (plan.tshirt.mode === "sizes") return writeTshirtSizes(api, grid, sheetId, layout, plan, totals, phaseSrc, legendChange);
 
   const first0 = layout.firstItemRow;
   let occupied = 0;
@@ -735,6 +782,7 @@ async function writeTshirt(api, plan, opts) {
   }
   const built = tshirtRows(plan, first0);
   const lastWritten1 = built.rows[built.rows.length - 1].row1;
+  if (legendChange) await writeAiLegend(api, layout);
 
   // 1. clear values + formats + merges in the item area (clear-then-paint)
   const clearTo = Math.max(lastWritten1 + 5, rowCount(grid) + 1);
@@ -792,7 +840,12 @@ async function writeTshirt(api, plan, opts) {
 }
 
 /** sizes mode — rows exist (gap-analysis sheet); fill E:L on rows matched by "(id)" in column C. */
-async function writeTshirtSizes(api, grid, sheetId, layout, plan, totals, phaseSrc) {
+/** Put AI_SIZE_DAYS into the legend's value column, row by row by label (never by position). */
+async function writeAiLegend(api, layout) {
+  for (const c of SIZE_CODES) await api.putValues(TAB_TSHIRT, `B${layout.legendRow1[c]}`, [[AI_SIZE_DAYS[c]]]);
+}
+
+async function writeTshirtSizes(api, grid, sheetId, layout, plan, totals, phaseSrc, legendChange) {
   const rowsById = new Map();
   for (let r = layout.firstItemRow; r < rowCount(grid); r++) {
     const m = textAt(grid, r, 2).match(/\(([A-Za-z]+-\d+(?:\.\d+)*)\)\s*$/);
@@ -809,6 +862,18 @@ async function writeTshirtSizes(api, grid, sheetId, layout, plan, totals, phaseS
     writes.push({ r0, phase: it.phase, values: [it.phase, sizeOf(it.fe), sizeOf(it.be), f.H, f.I, f.J, f.K, f.L] });
   }
   if (missing.length) throw new Halt(`${TAB_TSHIRT}: no row carries these ids in column C — ${missing.join(", ")}. Rows are matched BY NAME (the "(id)" suffix), never by position.`, 4, missing);
+  if (legendChange) {
+    // Changing the legend re-prices EVERY sized row on the tab. A sized row the plan does not
+    // cover would silently move to the new scale — halt instead, naming the rows.
+    const planned = new Set(writes.map((w) => w.r0));
+    const stray = [];
+    for (const [id, r0] of rowsById) {
+      if (planned.has(r0)) continue;
+      if (layout.cols.sizes.some((c) => textAt(grid, r0, c).trim())) stray.push(id);
+    }
+    if (stray.length) throw new Halt(`${TAB_TSHIRT}: the sheet is on the old day scale and these sized rows are not in the plan — ${stray.join(", ")}. Moving the legend to the AI-assisted scale would re-price them silently. Size every row in the plan, or clear those rows first.`, 4, stray);
+    await writeAiLegend(api, layout);
+  }
   let totalRow0 = -1;
   for (let r = lastItem0 + 1; r < rowCount(grid); r++) if (/^Total \(Days\)/i.test(textAt(grid, r, 0))) { totalRow0 = r; break; }
   if (totalRow0 < 0) throw new Halt(`${TAB_TSHIRT}: no 'Total (Days)' row found below the items — add it (spec §1.3) and re-run`);
@@ -1314,6 +1379,7 @@ function rostersTable(rosters) {
 
 async function verbPlanCheck(api, plan) {
   const layout = locateTshirt(await api.grid(TAB_TSHIRT));
+  layout.legend = { ...AI_SIZE_DAYS }; // preview what `write` produces — it puts the AI scale in the legend
   const totals = tshirtTotals(plan, layout);
   const rosters = buildRosters(plan, layout);
   return { totals, mf: layout.mf, mfTotal: round2(layout.mfTotal), highFactor: layout.highFactor, rate: layout.rate, rosters, table: rostersTable(rosters) };
@@ -1609,7 +1675,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|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]";
+const USAGE = "usage: gsd-t estimate-sheet <read|plan-check|write|teammix|format|phases|titles|audit|plan-schema|size> --sheet <id|url> [--tab <name>] [--plan <plan.json>] [--replace] [--fte '{\"backend\":1.5}'] [--title <t>] [--dry-run] [--no-audit] [--key <path>] [--json]\n       gsd-t estimate-sheet size --solo-min <n> --project <greenfield-solo|greenfield-team|yellowfield-solo|yellowfield-team-isolated|yellowfield-team-wide> [--switch-min <n>] [--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) {
@@ -1617,6 +1683,12 @@ async function main(args) {
   const json = !!args.json;
   if (!verb || verb === "help") { console.log(USAGE); return 0; }
   if (verb === "plan-schema") { console.log(JSON.stringify(PLAN_SCHEMA, null, 2)); return 0; }
+  if (verb === "size") {
+    const r = aiTaskSize({ soloMin: Number(args["solo-min"]), project: args.project, switchMin: args["switch-min"] == null ? undefined : Number(args["switch-min"]) });
+    if (json) console.log(JSON.stringify({ ok: true, exitCode: 0, ...r }, null, 2));
+    else console.log(`${r.soloMin} solo min × ${r.multiplier} (${r.project}) + ${r.switchMin} min switching = ${r.hours} h (${r.days} d) → ${r.size} (${r.sizeDays} d)`);
+    return 0;
+  }
   const sheetId = sheetIdFromArg(args.sheet);
   const api = new SheetsApi(await getToken(args.key), sheetId);
   if (verb === "read") {
@@ -1701,10 +1773,10 @@ function haltAndExit(e, json) {
 }
 
 module.exports = {
-  validatePlan, splitRoster, rosterViolations, mfCoverageViolations, monthPlan, resampleWeights, rampHours, buildRoster,
+  validatePlan, aiTaskSize, legendIsAi, defaultSwitchMin, splitRoster, rosterViolations, mfCoverageViolations, monthPlan, resampleWeights, rampHours, buildRoster,
   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 },
+  constants: { SIZE_CODES, AI_SIZE_DAYS, PROJECT_MULTIPLIER, PHASES, COLOR, RAMP, ROLE_LABEL, SOFT_CEILING, FOLD_THRESHOLD, TAB_TSHIRT, TAB_TEAM, TAB_TECH, PLAN_SCHEMA },
   Halt, SheetsApi, getToken, runAudit, main,
 };
 

package/bin/gsd-t-model-tier-policy.cjs

@@ -113,8 +113,8 @@ function resolve(stageKey) {
  * Frozen profile → stage-key → tier map.
  *
  * Fable removed 2026-07-24 — profiles now dial OPUS-vs-SONNET spend (not Fable):
- *   standard  — cost-leanest: the high-stakes reasoning stages run sonnet,
- *                only the probes stay opus.
+ *   standard  — cost-leanest: probes + red-team run opus; judge,
+ *                pre-mortem and debug-cycle-2 run sonnet.
  *   pro       — mid: red-team + pre-mortem + debug-cycle-2 → opus; the rest sonnet.
  *   premium   — full opus posture: all 6 designated stages → opus (= claude-opus-5-5).
  *
@@ -130,7 +130,7 @@ const PROFILE_STAGE_TIERS = Object.freeze({
     'partition-probe':      'opus',
     'competition-judge':    'sonnet',
     'pre-mortem':           'sonnet',
-    'red-team':             'sonnet',
+    'red-team':             'opus',
     'debug-cycle-2':        'sonnet',
   }),
   pro: Object.freeze({

package/commands/gsd-t-estimate.md

@@ -25,14 +25,15 @@ Read from `$ARGUMENTS` or `.gsd-t/estimate-config.json` if present; otherwise us
 |-------|-----------------|---------|
 | `rate` | `$50/hr` | Blended hourly rate for the LOW figure. |
 | `hoursPerDay` | `8` | Hours per person-day. |
-| `sizeScale` | `XS 0.25 · S 0.5 · M 1 · L 3 · XL 5 · XXL 7` | T-shirt → person-days. |
+| `sizeScale` | `XS 0.1 · S 0.25 · M 0.5 · L 1 · XL 2 · XXL 4` | AI-assisted T-shirt → person-days (spec §1.4). `write` puts it in the sheet legend. |
+| `projectMultiplier` | greenfield solo ×1 · team ×5 · yellow-field solo ×2 · team ×8 isolated / ×12 wide | Solo AI minutes × this. Internal to the estimator — never on the sheet. |
 | `totalMF` | `0.7` | Overhead multiplier. **The sheet's own MF list (`E4:F9`) wins when a sheet exists** — read it, never overwrite it. Hilo sheets run `0.9` (QA .3 · PM .1 · Analysis .1 · Deployment .05 · StdUps/Mtgs .15 · Buffer .2). |
 | `highFactor` | `1.25` | HIGH = LOW × this (the sheet's `G4` wins when a sheet exists). |
 | `sheetTemplateId` | (blank) | Optional template to clone; normally blank — the operator supplies the target sheet. |
 | `gcpProject` | `ai-estimator-415612` | GCP project hosting the permanent Sheets-writer SA. |
 | `serviceAccountEmail` | `gsd-t-sheets-writer@ai-estimator-415612.iam.gserviceaccount.com` | **Permanent** SA — share each sheet with this as Editor. |
 | `serviceAccountKeyPath` | `~/.claude/gsd-t-secrets/gsd-t-sheets-writer-key.json` | SA key (chmod 600, outside any repo). |
-| `newTeamDefault` | `true` | Apply the new-team familiarization adjustment (Step 2.5a) by default. |
+| `newTeamDefault` | `false` | Add a new-team familiarization adjustment (Step 2.5a) only when the operator says the team is new to the code. |
 
 ## Step 0: Inputs + Scope + Sheet
 
@@ -42,7 +43,7 @@ Read from `$ARGUMENTS` or `.gsd-t/estimate-config.json` if present; otherwise us
 4. **Resolve the input document** (`--input`, else `.gsd-t/techdebt.md`). None → "No input document found. Pass `--input <path>` or run `/gsd-t-scan` / `/gsd-t-gap-analysis` first." and stop.
 5. **Classify the input** so the line-item vocabulary matches: scan register → *findings* (`TD-n`) scoped by severity; gap-analysis sheet → *gaps* (`GA-n`, rows already on the T-Shirt tab with columns A–D filled — you fill E–G only); requirements / feature / app spec → *requirements* (`FR-n` or the doc's own numbering).
 6. **Scope**: scan default = all CRITICAL findings; `--severity high|medium|low|all` widens. Requirements default = all. Confirm scope + item count with the user before sizing.
-7. **Confirm the active config values** — rate, MF list (from the sheet), high factor, and whether this is a **new-team project** (Step 2.5a; usually YES for a fresh client).
+7. **Confirm the active config values** — rate, MF list (from the sheet), high factor, and the **project type**: greenfield or yellow-field (an existing app), solo or team (spec §1.4). Nobody hand-writes code — every estimate assumes AI-assisted development by a code-familiar team unless the operator says otherwise.
 
 ## Step 1: Numbering hygiene (MECHANICAL — show result)
 
@@ -57,22 +58,22 @@ Client-facing line-items carry **sequential, rational numbering starting at 1**.
 
 For each in-scope item build a row per spec §1.2 — `A` Module · `B` User Type · `C` Functionality (**with the item id**) · `D` Low-Level Requirement · `E` Phase · `F` Web Portal size · `G` Backend/API size. `H:L` are formulas, never values.
 
-- **Size each column INDEPENDENTLY** (FE and BE each get their own letter; blank = 0). Scale: **XS 0.25 · S 0.5 · M 1 · L 3 · XL 5 · XXL 7** person-days.
-- **Bare codes in `F:G`** — `XS` `S` `M` `L` `XL` `XXL`. Never the legend text (`"XS - Extra Small"`). The lookup happens to compute either way, which is why the long form shipped unnoticed.
-- The sheet computes: `Days = F+G` → `MFactor Days = Days × Total MF` → `Total Days` → `LOW $ = Total × 8 × rate` → `HIGH $ = LOW × high factor`.
+- **Size in solo AI minutes, then let the tool pick the size** (spec §1.4). For each column (FE, BE) estimate the SOLO AI-assisted minutes — one person directing Claude — then run `gsd-t estimate-sheet size --solo-min <n> --project <type>`: it multiplies by the project type (greenfield solo ×1 · team ×5 · yellow-field solo ×2 · team ×8 isolated / ×12 big blast radius), adds task switching after the multiplier, and prints the size. Blast radius is measured with `gsd-t graph blast-radius`, not guessed. Count switching once per item (pass `--switch-min 0` for the smaller column).
+- **Bare codes in `F:G`** — `XS` `S` `M` `L` `XL` `XXL`. Never the legend text (`"XS - Extra Small"`). Scale: **XS 0.1 · S 0.25 · M 0.5 · L 1 · XL 2 · XXL 4** person-days.
+- The sheet computes: `Days = F+G` → `MFactor Days = Days × Total MF` → `Total Days` → `LOW $ = Total × 8 × rate` → `HIGH $ = LOW × high factor`. The overhead factors and high factor are per-project settings the operator adjusts by hand.
 - **Cluster by fix-shape to size fast**: "add existing guard to N routes" (XS–S, repeated) vs "new backend surface" (M, +FE) vs "config / single route" (XS). Size the cluster once, apply to members.
 - **Tune the MF per project** (raise Buffer/QA when confidence is low; raise the high factor above 1.25 for more unknowns) — but change the sheet's MF list only with the operator's say-so.
 - **PAUSE:** present the sized rows (or clusters + representative sizes) and the running total (recomputed from raw sizes: `Σ(FE,BE days) × (1 + MF)`). Wait for `continue` or corrections.
 
 ## Step 2.5: Estimate Adjustments (familiarization + risk/unknowns) — JUDGMENT · PAUSE FOR REVIEW
 
-Base sizes assume *familiar* devs on *well-understood* work. Adjust for the two things that make real work heavier. Document each adjustment per-item so the client sees **why**. **This step is ON by default (`newTeamDefault: true`) — it was skipped on shipped estimates and had to be asked for.**
+Base sizes assume *familiar* devs on *well-understood* work. Adjust for the two things that make real work heavier. Document each adjustment per-item so the client sees **why**. Part (b) always runs; part (a) only for a team new to the code.
 
-**(a) New-team familiarization** — bump each item's SIZE in proportion to its complexity — **NOT the MF** (the Analysis MF is for a Business Analyst, not dev ramp). Trivial config / single route → no bump. Repeated-pattern guards, few routes → +0–1 tier. High-volume sweeps + new-surface builds → +1 tier. Optionally add a one-time **"Codebase Onboarding & Downstream Analysis"** Common line (L–XL), documented as optional.
+**(a) New-team familiarization — OFF by default** (`newTeamDefault: false`; estimates assume a code-familiar team). Only when the operator says the team is new to the code: bump each item's SIZE in proportion to its complexity — **NOT the MF** (the Analysis MF is for a Business Analyst, not dev ramp). Trivial config / single route → no bump. Repeated-pattern guards, few routes → +0–1 tier. High-volume sweeps + new-surface builds → +1 tier. Optionally add a one-time **"Codebase Onboarding & Downstream Analysis"** Common line (L–XL), documented as optional.
 
 **(b) R&D / unknown-approach / spike risk** — an item needing research, an unproven approach, or an unknown integration gets an uplift for the uncertainty: bump its SIZE or raise the high factor if unknowns dominate. Name the unknown explicitly ("requires spike: undocumented 3rd-party API").
 
-**⚠️ The scale is NON-LINEAR. M→L is a 3× cliff (1 day → 3 days).** Never push an item across M→L unless it is genuinely multi-day. Cap routine-work bumps at M. Calibration: HILO 21 criticals = $8,700 familiar → $11,730 new-team (+35%, bumps capped at M).
+**⚠️ The scale doubles at every step (0.1 → 0.25 → 0.5 → 1 → 2 → 4 days).** An uplift is one step at most unless the unknown is genuinely multi-day. Calibration: the Hilo Delivery Runway build — 45 tasks, ~26 solo hours (13 David + 13 Claude) — which the old day scale priced at 1,262–1,577 hours.
 
 - **PAUSE:** present every adjustment (item, reason, before→after size, total delta). Wait for `continue` or corrections.
 

package/commands/gsd-t-help.md

@@ -381,7 +381,7 @@ Use these when user asks for help on a specific command:
 - **Summary**: Turn any structured work document — a scan register, a gap-analysis sheet, a new-feature or new-app requirements doc — into a Tekyz client estimate Google Sheet: **T-Shirt Size + Team Mix + Technology Stack**, written and audited against `~/.claude/templates/estimate-sheet-spec.md`. No PRD (`/gsd-t-prd` owns that)
 - **Auto-invoked**: No
 - **Updates**: the Tekyz estimate Google Sheet (three tabs, written and read-back-audited by `gsd-t estimate-sheet` from `.gsd-t/estimate-plan.json`) + optional `share/<Repo>-estimate-redteam-notes.md` (and, if renumbered, the source doc/docs/scan files)
-- **Use when**: You need a client-facing paid estimate (T-shirt sizing, dollar range, staffed team by month) from a scan, a gap analysis, or a requirements/feature/app spec. **SUPERVISED** — judgment phases (sizing, adjustments, Team Mix, Red Team) pause for your review; **you are the final arbiter** of an Estimate Red Team that challenges the numbers. Accepts `--sheet <url>`. Rate + factors are parameterized (default Tekyz; the sheet's own MF list wins). Playbook: `~/.claude/playbooks/tekyz-estimation-and-prd-playbook.md`
+- **Use when**: You need a client-facing paid estimate (T-shirt sizing, dollar range, staffed team by month) from a scan, a gap analysis, or a requirements/feature/app spec. **SUPERVISED** — judgment phases (sizing, adjustments, Team Mix, Red Team) pause for your review; **you are the final arbiter** of an Estimate Red Team that challenges the numbers. Accepts `--sheet <url>`. Sizes are AI-assisted (solo AI minutes × project multiplier + task switching → `gsd-t estimate-sheet size`; spec §1.4). Rate + factors are parameterized (default Tekyz; the sheet's own MF list wins). Playbook: `~/.claude/playbooks/tekyz-estimation-and-prd-playbook.md`
 
 ### stories
 - **Summary**: Generate a dev-team handoff document in the Tekyz user-stories format — discrete user stories with workflows, grouped acceptance criteria, per-story flow diagrams (Mermaid rendered to embedded images), and mapped test-case tables — from any source (scan register, requirements doc, design contract, or a reverse-engineered codebase)

package/commands/gsd-t-status.md

@@ -89,7 +89,7 @@ The **Model Profile** line MUST always name the active profile — never blank,
 - If the file is present but malformed or contains an unknown profile, display: `Model Profile: premium (default, config-error)` — never silently promote to the most expensive posture.
 
 Profiles control which workflow stages run on Opus vs. Sonnet (Fable removed 2026-07-24 — `opus` = claude-opus-5-5):
-- `standard` — probes opus; high-stakes stages (judge/pre-mortem/red-team/debug-cycle-2) sonnet (cost-leanest)
+- `standard` — probes + red-team opus; judge/pre-mortem/debug-cycle-2 sonnet (cost-leanest)
 - `pro` — probes + pre-mortem + red-team + debug-cycle-2 opus; judge sonnet
 - `premium` — all 6 designated stages opus (full posture, global default)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.21.10",
+  "version": "5.22.10",
   "description": "GSD-T: Contract-Driven Development for Claude Code \u2014 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-config.json

@@ -7,8 +7,11 @@
   "hoursPerDay": 8,
   "_hoursPerDay": "Hours per person-day. Default: 8.",
 
-  "sizeScale": { "XS": 0.25, "S": 0.5, "M": 1, "L": 3, "XL": 5, "XXL": 7 },
-  "_sizeScale": "T-shirt size -> person-days. NON-LINEAR: M->L is a 3x cliff (1 -> 3 days). Do not push routine work across M->L.",
+  "sizeScale": { "XS": 0.1, "S": 0.25, "M": 0.5, "L": 1, "XL": 2, "XXL": 4 },
+  "_sizeScale": "AI-assisted T-shirt scale, person-days (written into the sheet legend by `gsd-t estimate-sheet write`). A size = solo AI minutes x project multiplier + task switching; see estimate-sheet-spec.md section 1.4.",
+
+  "projectMultiplier": { "greenfield-solo": 1, "greenfield-team": 5, "yellowfield-solo": 2, "yellowfield-team-isolated": 8, "yellowfield-team-wide": 12 },
+  "_projectMultiplier": "Solo AI minutes are multiplied by this, by project type (isolated vs wide = code-graph blast radius). Internal to the estimator; never shown on the sheet.",
 
   "totalMF": 0.7,
   "_totalMF": "Overhead multiplier applied to raw Days. Tekyz default 0.7 = QA 0.3 + PM 0.1 + Analysis 0.05 + Deployment 0.05 + Buffer 0.2. Raise Buffer/QA when confidence is low.",
@@ -34,8 +37,8 @@
   "serviceAccountKeyPath": "~/.claude/gsd-t-secrets/gsd-t-sheets-writer-key.json",
   "_serviceAccountKeyPath": "Local path to the SA JSON key (chmod 600, outside any repo — NEVER commit). Step 5 self-provisions the SA+key here if missing.",
 
-  "newTeamDefault": true,
-  "_newTeamDefault": "Whether to assume a new-team familiarization adjustment (Step 2.5a) by default. Usually true for a fresh client.",
+  "newTeamDefault": false,
+  "_newTeamDefault": "Whether to add a new-team familiarization adjustment (Step 2.5a). Default false: estimates assume a code-familiar, AI-assisted team. Turn on only when the operator says the team is new to the code.",
 
   "sheetSpec": "~/.claude/templates/estimate-sheet-spec.md",
   "_sheetSpec": "The layout/formula/styling/roster spec every write is audited against. Bundled at templates/estimate-sheet-spec.md in the GSD-T package."

package/templates/estimate-sheet-spec.md

@@ -42,7 +42,7 @@ Reference implementation (read it, don't guess): "ATP SOW Gap Analysis and Estim
 | `A1` | `Date Submitted` | bg `#D9D9D9`, bold, Calibri |
 | `B1` | date `mm/dd/yyyy` | Calibri 11, left |
 | `A3:B3` | `Legends` / `Person Days` | bg `#3D85C6`, white bold Calibri |
-| `A4:B9` | **Size legend** — `XS - Extra Small` 0.25 · `S - Small` 0.5 · `M - Medium` 1 · `L - Large` 3 · `XL - Extra Large` 5 · `XXL - Extra Extra Large` 7 | Calibri, right |
+| `A4:B9` | **Size legend** — labels `XS - Extra Small` … `XXL - Extra Extra Large`. **Values: the AI-assisted scale** `XS 0.1 · S 0.25 · M 0.5 · L 1 · XL 2 · XXL 4` person-days (§1.4). `write` puts these values in `B4:B9` (matched by label); the labels are never touched. Sheets written before v5.22.10 keep the old `0.25 · 0.5 · 1 · 3 · 5 · 7` scale until they are re-estimated. | Calibri, right |
 | `E3` | `Multiplication Factor` | bg `#3D85C6`, white bold |
 | `E4:F9` | **MF list** — one row per factor (e.g. `QA` 0.3 · `PM` 0.1 · `Analysis` 0.1 · `Deployment` 0.05 · `StdUps/Mtgs` 0.15 · `Buffer` 0.2). **Read the live list — it varies per sheet and is the roster contract for Team Mix (§2.4).** | |
 | `E10:F10` | `Total MF` = `=sum(F4:F9)` | bg `#C9DAF8`, bold |
@@ -78,7 +78,28 @@ Column widths: `[150, 120, 300, 430, 122, 90, 90, 61, 53, 76, 81, 81]`.
 | `K` | `=J{r}*8*$H$4` | nf `$#,##0.00` |
 | `L` | `=K{r}*$G$4` | nf `$#,##0.00` |
 
-### 1.3 Totals and summary (directly under the last item — NO blank rows)
+#### 1.4 How a size is chosen — the AI-assisted model (David, 2026-09-27)
+
+Nobody hand-writes code. A size is the **team hours** a task takes with AI-assisted development, and the multipliers that produce it live in the estimator — never on the sheet. Calibration: the Hilo Delivery Runway build (45 tasks, ~26 solo hours: 13 David + 13 Claude).
+
+1. **Estimate the task in SOLO AI-assisted minutes** — one person directing Claude, greenfield. Runway rate: roughly 5 min for a trivial change, 20 min for a typical screen element or endpoint, 1–2¼ hrs for the heaviest pieces.
+2. **Multiply by the project type:**
+
+| Project | Multiplier |
+|---|---|
+| Greenfield, solo | × 1 |
+| Greenfield, team | × 5 |
+| Yellow-field (existing app), solo | × 2 |
+| Yellow-field, team — isolated change | × 8 |
+| Yellow-field, team — big blast radius | × 12 |
+
+   Blast radius comes from the code graph (`gsd-t graph blast-radius`), not a guess.
+3. **Add task switching AFTER the multiplier** — it is one person's pickup time and does not grow with team size: 5–10 min for small tasks (less when related tasks run back-to-back), ~15 min medium, up to 30 min large.
+4. **Pick the nearest size** on the §1.1 legend. `gsd-t estimate-sheet size --solo-min <n> --project <type> [--switch-min <n>]` does steps 2–4 and prints the size.
+
+The overhead factors (`E4:F9`) and the high factor stay per-project settings the operator adjusts by hand; they are not part of the task math.
+
+## 1.3 Totals and summary (directly under the last item — NO blank rows)
 
 ```
 <last item row>
@@ -252,6 +273,7 @@ Everything in §1–§5 is executed by `bin/gsd-t-estimate-sheet.cjs`, not re-de
 
 ```
 gsd-t estimate-sheet plan-schema                              # the plan shape
+gsd-t estimate-sheet size --solo-min <n> --project <type> [--switch-min <n>]   # §1.4: solo minutes → team hours → size (no sheet needed)
 gsd-t estimate-sheet read       --sheet <id|url> [--tab <name>]   # read-before-write dump
 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
@@ -286,4 +308,4 @@ 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` `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.
+- The MF list, rate and high factor are READ from the sheet; the plan never carries them. The legend VALUES are written by the tool (the AI-assisted scale, §1.4) — in `sizes` mode it HALTS if a sized row on the tab is missing from the plan, because moving the legend would silently re-price that row.

package/templates/playbooks/tekyz-estimation-and-prd-playbook.md

@@ -50,17 +50,21 @@ For each finding, write a row (cols A–G; leave H–L formulas alone):
 `A` Module · `B` User Type · `C` Functionality (include the `(TD-n)`) ·
 `D` Low-Level Requirement · `E` Phase (MVP) · `F` Web Portal size · `G` Backend/API size.
 
-- Size **each column independently** (FE and BE). Sizes: XS .25, S .5, M 1, L 3, XL 5, XXL 7.
+- Size **each column independently** (FE and BE), **AI-assisted** — nobody hand-writes code.
+  Estimate SOLO AI minutes, then `gsd-t estimate-sheet size --solo-min <n> --project <type>`
+  (greenfield solo ×1 · team ×5 · yellow-field solo ×2 · team ×8 isolated / ×12 wide, + task
+  switching after the multiplier) picks the size. Sizes: XS .1, S .25, M .5, L 1, XL 2, XXL 4
+  (estimate-sheet-spec.md §1.4).
 - Sheet computes: `Days = F+G`, `MFactor = Days×MF`, `Total = Days+MFactor`,
   `LOW$ = Total×8×$50`, `HIGH$ = LOW$×1.25`.
 - **Cluster the work** to size fast: "add existing auth guard to routes" (XS–S,
   repeated pattern) vs "new backend surface" (M, +FE) vs "config/1-route" (XS).
 
-### Familiarization bump (new-team projects)
-Base sizes assume *familiar* devs. For a new team, bump SIZE in proportion to
+### Familiarization bump (new-team projects only — off by default)
+Base sizes assume a *code-familiar*, AI-assisted team. Only when the operator says the team is new, bump SIZE in proportion to
 complexity (NOT the MF — Analysis MF is for a Business Analyst):
 - Trivial → no bump. Repeated-pattern guards → +0-1 tier. High-volume sweeps +
-  new-surface → +1 tier. **Never cross the M→L cliff (3×) unless genuinely multi-day.**
+  new-surface → +1 tier (the scale doubles per step — one step at most).
 - Optionally add a one-time "Codebase Onboarding & Downstream Analysis" Common line (L–XL).
 
 ### Tune the MF (per project)