@tekyzinc/gsd-t 5.22.10 → 5.23.10

package/bin/gsd-t-graph-scip-upgrade.cjs

@@ -134,6 +134,14 @@ function _resetScipCache(override) {
  * is confirmed present and invocable. Phase-2 will replace the edges with
  * SCIP-derived ones. This is the documented UPGRADE FLOOR behavior.
  */
+const SCIP_MAX_FILE_BYTES = '64mb';
+const SCIP_HEAP_MB = 8192;
+const SCIP_MISSING_TIER = 'tree-sitter-floor-SCIP-MISSING';
+// A file SCIP indexed but where fewer than this share of its repo-resolvable calls
+// resolved. [RULE] scip-tier-proportional
+const COMPILER_PARTIAL_TIER = 'compiler-partial';
+const COMPILER_ACCURATE_MIN_FRACTION = 0.9;
+
 function runScipTypescript(projectRoot, outPath) {
   // M95: emit to a REAL file (outPath) so the index can be READ and call edges
   // resolved — not /dev/null. The old /dev/null path only proved invocability.
@@ -145,10 +153,22 @@ function runScipTypescript(projectRoot, outPath) {
   // --infer-tsconfig: resolve a tsconfig even when one isn't at the repo root
   // (monorepos / nested layouts — e.g. web/tsconfig.json). Without it, projects
   // whose tsconfig lives in a subdir got 0 resolved call edges. [RULE] scip-infer-nested-tsconfig
-  const scip = spawnSync('scip-typescript', ['index', '--infer-tsconfig', '--output', out, '.'], {
+  // --max-file-byte-size: scip-typescript SKIPS every file over 1mb by default,
+  // silently — no warning, no document in the index. A 50k-line route file
+  // (hilo-figma-atos routes-locations.ts, 1.9MB) was never resolved, so every
+  // call in it stayed unresolved and who-calls answered []. Raise the cap well
+  // past any hand-written source file. [RULE] scip-no-silent-large-file-skip
+  // A larger heap keeps a big project from dying mid-run once those files are in.
+  const nodeOpts = process.env.NODE_OPTIONS || '';
+  const env = /max-old-space-size/.test(nodeOpts)
+    ? process.env
+    : { ...process.env, NODE_OPTIONS: `${nodeOpts} --max-old-space-size=${SCIP_HEAP_MB}`.trim() };
+  const scip = spawnSync('scip-typescript',
+    ['index', '--infer-tsconfig', '--max-file-byte-size', SCIP_MAX_FILE_BYTES, '--output', out, '.'], {
     cwd: projectRoot,
     encoding: 'utf8',
     timeout: 180_000,
+    env,
   });
   if (scip.status === 0) return { ok: true, scipPath: out };
   return { ok: false, error: scip.stderr || `exit code ${scip.status}` };
@@ -314,7 +334,7 @@ function findTsProjectDirs(repoRoot) {
  *             resolveFileEdges: (relPath, edges) => { edges, resolved: number } }}
  */
 function buildScipResolver(repoRoot, opts = {}) {
-  const { readScipIndex } = require('./gsd-t-scip-reader.cjs');
+  const { readScipIndex, scipPositionKey } = require('./gsd-t-scip-reader.cjs');
   const avail = detectScip();
 
   // Detect which languages have source present (so we only run the relevant
@@ -325,10 +345,21 @@ function buildScipResolver(repoRoot, opts = {}) {
   // is language-agnostic (Python symbols use the same `name().` descriptor form),
   // so TS and Python refs merge into one fileRefs map keyed by repo-relative path.
   const fileRefs = new Map(); // relPath → [{symbol, funcId, line}]
+  const scipDocs = new Set(); // every file any indexer produced a document for
+  const defNames = new Set(); // every name SCIP saw DEFINED in the repo — what a call could resolve to
+  const occurrencePositions = new Map(); // relPath → Set<positionKey> of every SCIP occurrence
   const ranIndexers = [];
 
   function mergeRead(read) {
     if (!read || !read.ok) return;
+    if (read.docPaths) for (const d of read.docPaths) scipDocs.add(d);
+    if (read.symbolToDef) for (const fid of read.symbolToDef.values()) defNames.add(fid.split('#').pop());
+    if (read.occurrencePositions) {
+      for (const [f, pos] of read.occurrencePositions) {
+        if (occurrencePositions.has(f)) for (const k of pos) occurrencePositions.get(f).add(k);
+        else occurrencePositions.set(f, pos);
+      }
+    }
     for (const [file, refs] of read.fileRefs) {
       if (fileRefs.has(file)) fileRefs.get(file).push(...refs);
       else fileRefs.set(file, refs.slice());
@@ -383,8 +414,7 @@ function buildScipResolver(repoRoot, opts = {}) {
    * resolves to a real funcId, rewrite dst to that funcId.
    */
   function resolveFileEdges(relPath, edges) {
-    const refs = fileRefs.get(relPath);
-    if (!refs || !refs.length) return { edges, resolved: 0 };
+    const refs = fileRefs.get(relPath) || [];
 
     // name → resolved funcId (last writer wins; SCIP refs in this file)
     const nameToFuncId = new Map();
@@ -394,6 +424,12 @@ function buildScipResolver(repoRoot, opts = {}) {
     }
 
     let resolved = 0;
+    // missed = a call to a name the repo defines, at a position where SCIP put NO
+    // symbol — the compiler never looked at it. A call SCIP resolved to a library
+    // (drizzle's `text()`) or a local (`const [x, setX] = useState()`) is not a
+    // miss: SCIP answered, the answer just is not a repo function.
+    const positions = occurrencePositions.get(relPath);
+    let missed = 0;
     const out = edges.map((edge) => {
       const dst = edge.target || edge.dst || '';
       const kind = edge.kind;
@@ -401,12 +437,18 @@ function buildScipResolver(repoRoot, opts = {}) {
       if (!isCall || !dst.startsWith('UNRESOLVED#')) return edge;
       const calleeName = dst.slice('UNRESOLVED#'.length);
       const funcId = nameToFuncId.get(calleeName);
-      if (!funcId) return edge; // still unresolved → stays floor
+      if (!funcId) { // still unresolved → stays floor
+        const seen = positions && Number.isInteger(edge.col) && positions.has(scipPositionKey(edge.line - 1, edge.col));
+        if (defNames.has(calleeName) && !seen) missed++;
+        return edge;
+      }
       resolved++;
       // rewrite dst to the resolved funcId, mark scip-derived
       return { ...edge, target: funcId, dst: funcId, scipResolved: true };
     });
-    return { edges: out, resolved };
+    // resolvable = resolved + missed. A call to a library (`c.json`) or a local
+    // never counts against the file. [RULE] scip-tier-proportional
+    return { edges: out, resolved, resolvable: resolved + missed };
   }
 
   // tsProjects reports which tsconfig projects actually contributed refs. A
@@ -419,6 +461,10 @@ function buildScipResolver(repoRoot, opts = {}) {
     indexedFiles: fileRefs.size,
     scipPath: resolveScipPath('index.scip', repoRoot),
     resolveFileEdges,
+    // [RULE] scip-missing-file-detected-never-silent — lets the upgrader tell a
+    // file the indexer never produced a document for from one it indexed.
+    coversLanguage: (lang) => ranIndexers.includes(lang),
+    hasScipDoc: (relPath) => scipDocs.has(relPath),
   };
 }
 
@@ -492,8 +538,17 @@ function tryScipUpgrade(absPath, relPath, entities, edges, options) {
     return { upgraded: false, tier, entities, edges };
   }
 
+  // The indexer ran for this language but produced no document for this file
+  // (skipped for size, outside every tsconfig, or dropped mid-run). Its call
+  // targets are unknown — say so in the tier, never label it plain floor or,
+  // worse, compiler-accurate. [RULE] scip-missing-file-detected-never-silent
+  if (typeof resolver.hasScipDoc === 'function' && typeof resolver.coversLanguage === 'function' &&
+      resolver.coversLanguage(lang) && !resolver.hasScipDoc(relPath)) {
+    return { upgraded: false, tier: SCIP_MISSING_TIER, entities, edges };
+  }
+
   // Resolve this file's UNRESOLVED# call edges against the SCIP index.
-  const { edges: resolvedEdges, resolved } = resolver.resolveFileEdges(relPath, edges);
+  const { edges: resolvedEdges, resolved, resolvable = 0 } = resolver.resolveFileEdges(relPath, edges);
 
   // Rust cross-crate edges stay flagged partial.
   // [RULE] rust-cross-crate-flagged-partial
@@ -505,15 +560,36 @@ function tryScipUpgrade(absPath, relPath, entities, edges, options) {
   });
 
   // [RULE] scip-tier-honest: label compiler-accurate ONLY when SCIP actually
-  // resolved ≥1 edge in this file OR the file has no call edges to resolve (a
-  // pure-definition file SCIP indexed cleanly). A file whose calls all stayed
+  // resolved enough edges (proportionally). A file whose calls all stayed
   // UNRESOLVED is NOT compiler-accurate — it's floor.
+  // [RULE] scip-tier-proportional: the fraction of resolvable calls that actually
+  // resolved determines the tier. If ≥COMPILER_ACCURATE_MIN_FRACTION resolved,
+  // it's accurate; otherwise partial (still better than floor). A file with no
+  // resolvable edges (only locals/library calls) that SCIP indexed cleanly
+  // is compiler-accurate. [ISSUE] user reported: routes-locations.ts 80% UNRESOLVED
+  // yet labeled compiler-accurate because ONE edge resolved.
   const hadCallEdges = edges.some(e => (e.kind === 'call-site' || e.kind === 'CALL'));
-  const isAccurate = !hadCallEdges || resolved > 0;
-  const tier = isAccurate ? 'compiler-accurate' : 'tree-sitter-floor';
+  let tier = 'tree-sitter-floor';
+  if (!hadCallEdges) {
+    // Pure-definition file SCIP indexed cleanly → compiler-accurate
+    tier = 'compiler-accurate';
+  } else if (resolvable > 0) {
+    // File has resolvable calls — judge by proportion resolved
+    if (resolved / resolvable >= COMPILER_ACCURATE_MIN_FRACTION) {
+      // Enough resolvable calls resolved → accurate
+      tier = 'compiler-accurate';
+    } else if (resolved > 0) {
+      // Some but not enough resolvable calls resolved → partial
+      tier = COMPILER_PARTIAL_TIER;
+    }
+    // else: no edges resolved (0/resolvable) → tree-sitter-floor (default)
+  }
+  // else: no resolvable calls (all external/local) — stay tree-sitter-floor (default)
+
+  const upgraded = tier === 'compiler-accurate';
 
   return {
-    upgraded: isAccurate,
+    upgraded,
     tier,
     entities,
     edges: finalEdges,
@@ -584,4 +660,8 @@ module.exports = {
   _resetScipCache,
   isRustCrossCrateEdge,
   EXT_TO_LANG,
+  SCIP_MISSING_TIER,
+  SCIP_MAX_FILE_BYTES,
+  COMPILER_PARTIAL_TIER,
+  COMPILER_ACCURATE_MIN_FRACTION,
 };

package/bin/gsd-t-scip-reader.cjs

@@ -151,7 +151,8 @@ function isBuildOutputPath(relPath) {
  * @param {string} [pathPrefix]  repo-relative dir the index was produced from
  *                               (e.g. "server"); "" or "." for the repo root
  * @returns {{ ok: true, symbolToDef: Map<string,string>,
- *             fileRefs: Map<string, Array<{symbol:string, funcId:string, line:number}>> }
+ *             fileRefs: Map<string, Array<{symbol:string, funcId:string, line:number}>>,
+ *             docPaths: Set<string> }
  *         | { ok: false, reason: string }}
  */
 function readScipIndex(scipPath, pathPrefix) {
@@ -177,6 +178,18 @@ function readScipIndex(scipPath, pathPrefix) {
 
   const symbolToDef = new Map();          // scipSymbol → funcId (relPath#name)
   const fileRefs = new Map();             // relPath → [{symbol, line}]
+  // Every file the indexer produced a document for — including files with no
+  // resolvable reference, which never appear in fileRefs. Without this set a
+  // file the indexer SKIPPED (scip-typescript drops files over its byte-size cap)
+  // is indistinguishable from one it indexed and found nothing in.
+  // [RULE] scip-missing-file-detected-never-silent
+  const docPaths = new Set();
+  // Every position (line, column) SCIP put ANY symbol at, per file — external,
+  // local, or repo. A call site whose callee sits at one of these was SEEN by the
+  // compiler (resolved to something, even if not a repo function); one that
+  // does not was never looked at. Numbers, not strings: a large repo has
+  // millions of occurrences. [RULE] scip-tier-proportional
+  const occurrencePositions = new Map();
 
   const docs = obj.documents || [];
 
@@ -185,6 +198,7 @@ function readScipIndex(scipPath, pathPrefix) {
     const rawPath = doc.relative_path;
     if (!rawPath || isBuildOutputPath(rawPath)) continue;
     const relPath = reroot(rawPath);
+    docPaths.add(relPath);
     for (const occ of doc.occurrences || []) {
       const isDef = (occ.symbol_roles & SYMBOL_ROLE_DEFINITION) !== 0;
       if (!isDef) continue;
@@ -196,12 +210,19 @@ function readScipIndex(scipPath, pathPrefix) {
   }
 
   // Second pass: collect every REFERENCE occurrence per file, resolved to the def.
+  // A reference is kept whatever scope encloses it — named function, anonymous
+  // route handler, or top-level callback. The CALLER identity comes from the
+  // tree-sitter floor (which synthesizes one for anonymous scopes); SCIP only
+  // resolves the TARGET. [RULE] anonymous-caller-synthesized-never-dropped
   for (const doc of docs) {
     const rawPath = doc.relative_path;
     if (!rawPath || isBuildOutputPath(rawPath)) continue;
     const relPath = reroot(rawPath);
     const refs = [];
+    const positions = new Set();
+    occurrencePositions.set(relPath, positions);
     for (const occ of doc.occurrences || []) {
+      if (Array.isArray(occ.range) && occ.range.length >= 2) positions.add(scipPositionKey(occ.range[0], occ.range[1]));
       const isDef = (occ.symbol_roles & SYMBOL_ROLE_DEFINITION) !== 0;
       if (isDef) continue;                       // refs only
       const name = funcNameFromSymbol(occ.symbol);
@@ -214,11 +235,17 @@ function readScipIndex(scipPath, pathPrefix) {
     if (refs.length) fileRefs.set(relPath, refs);
   }
 
-  return { ok: true, symbolToDef, fileRefs };
+  return { ok: true, symbolToDef, fileRefs, docPaths, occurrencePositions };
+}
+
+/** 0-based line + column → one number (columns never reach 1e6). */
+function scipPositionKey(line0, col) {
+  return line0 * 1e6 + col;
 }
 
 module.exports = {
   loadScipProto,
   funcNameFromSymbol,
   readScipIndex,
+  scipPositionKey,
 };

package/bin/gsd-t.js

@@ -3708,6 +3708,8 @@ const PROJECT_BIN_TOOLS = [
   // graph dead → grep fallback (found by the Binvoice architect run 2026-07-12).
   // Same class as [[project_global_bin_propagation_gap]] / [[project_m96_graph_runs_in_projects]].
   "gsd-t-graph-store-resolver.cjs",
+  // Required by the indexer + freshness walker (project graph exclude list).
+  "gsd-t-graph-exclude.cjs",
   // M96 — multi-location resolver for the store engine (better-sqlite3), so a
   // copied tool finds the engine from the GSD-T global package, not the project's
   // own (usually absent) node_modules. Fail-loud with remediation if all miss.
@@ -4724,14 +4726,22 @@ function doGraphIndex() {
   heading("GSD-T Graph — Index");
   const { spawnSync } = require("child_process");
   const idxPath = require("path").join(__dirname, "gsd-t-graph-index.cjs");
+  // A large repo's SCIP run legitimately takes many minutes (hilo-figma-atos: >5).
+  // The old 5-minute cap killed the indexer mid-build and — because a killed child
+  // has status null — reported nothing and exited 0, leaving a half-built graph
+  // that looked complete. A kill or spawn error is a failure, said out loud.
   const result = spawnSync(process.execPath, [idxPath, "build", "--repo", process.cwd()], {
     encoding: "utf8",
     cwd: process.cwd(),
     stdio: ["ignore", "inherit", "inherit"],
-    timeout: 300000,
+    timeout: 30 * 60 * 1000,
   });
-  if (result.status !== 0 && result.status !== null) {
-    error("Graph index build failed — see output above");
+  if (result.error || result.signal || result.status !== 0) {
+    const why = result.error ? result.error.message
+      : result.signal ? `killed by ${result.signal} (timeout 30 min?) — the graph is INCOMPLETE`
+      : `exit ${result.status}`;
+    error(`Graph index build failed: ${why}`);
+    process.exitCode = 1;
   }
 }
 
@@ -4757,6 +4767,19 @@ function doGraphStatus() {
   }
   success(`Graph index: ${envelope.fileCount || 0} files`);
   if (envelope.tier) info(`Tier: ${envelope.tier}`);
+  // [RULE] scip-missing-file-detected-never-silent — files the SCIP indexer never
+  // produced a document for: their call edges stay unresolved, so who-calls is blind there.
+  const miss = envelope.scipMissing;
+  if (miss && miss.count > 0) {
+    warn(`${miss.count} file(s) not in SCIP (call edges unresolved): ${miss.files.join(", ")}${miss.count > miss.files.length ? ", …" : ""}`);
+    info("Re-run: gsd-t graph index  (then check again)");
+  }
+  const ex = envelope.excludes;
+  if (ex && ex.patterns && ex.patterns.length) {
+    info(`Excluded by ${ex.source}: ${ex.patterns.join(", ")}`);
+  } else {
+    info("Excludes: none (add folders to .gsd-t/graph-exclude.json — { \"exclude\": [\"design/\"] })");
+  }
   if (envelope.storeSize !== undefined) info(`Store size: ${envelope.storeSize} bytes`);
   if (envelope.detail) log(JSON.stringify(envelope, null, 2));
 }

package/commands/gsd-t-estimate-rescale.md

@@ -0,0 +1,64 @@
+# GSD-T: Estimate Rescale — Re-price an Existing Estimate on the AI-Assisted Scale
+
+You are re-estimating an **existing** Tekyz estimate sheet with the AI-assisted sizing model, **without touching the original**. The tool copies the sheet's `T-Shirt Size Estimate` and `Team Mix` tabs into two new tabs — **`T-Shirt Size Estimate (Rescale)`** and **`Team Mix (Rescale)`** — and re-sizes the copies. The original tabs, the Overview tab and the Hilo Estimates Summaries index (which reads the Overview) are never written. `$ARGUMENTS` carries `--sheet <url>` and optionally the project type (`--project <type>`).
+
+**THE SHEET IS WRITTEN BY A TOOL, NOT BY HAND.** `gsd-t estimate-sheet rescale` (`bin/gsd-t-estimate-sheet.cjs`, project-local `bin/` first, else the global `gsd-t`) lists the rows, validates your plan, makes the copies, writes the sizes, rebuilds the Team Mix and audits the copies by reading back — halting on any violation. **You never PUT a cell yourself.** Your output is judgment only: a size per row. Spec: `~/.claude/templates/estimate-sheet-spec.md` §1.4 (the sizing model) and §7 (rescale).
+
+> **Client-billed work.** Dollar figures here are client deliverables, not GSD-T build cost.
+
+## Human-in-the-Loop (SUPERVISED)
+
+**Step 2 (sizing) PAUSES for review** before anything is written. Steps 1, 3 and 4 flow but show their result.
+
+## Step 1: Inputs + the rows to re-size (MECHANICAL · show result)
+
+1. Resolve the sheet from `--sheet <url>`; otherwise ask for the URL. A `403` means the sheet is not shared with the service account (`gsd-t-sheets-writer@ai-estimator-415612.iam.gserviceaccount.com`) — ask the operator to share it as Editor, then re-run.
+2. **Confirm the project type** (spec §1.4) — it sets every row's multiplier:
+
+   | Project | `--project` | Multiplier |
+   |---|---|---|
+   | Greenfield, solo | `greenfield-solo` | × 1 |
+   | Greenfield, team | `greenfield-team` | × 3 |
+   | Yellow-field (existing app), solo | `yellowfield-solo` | × 2 |
+   | Yellow-field, team — isolated change | `yellowfield-team-isolated` | × 5 |
+   | Yellow-field, team — big blast radius | `yellowfield-team-wide` | × 7 |
+
+   A yellow-field team estimate chooses isolated vs wide **per row**, from the code graph of the app being changed (`gsd-t graph blast-radius <file-or-symbol>` in that repo) — not a guess. No graph for the app → say so and ask the operator which rows are wide.
+3. List the rows: `gsd-t estimate-sheet rescale --sheet <url> --list`. It prints every sized item row (row number, module, functionality, requirement, phase, current sizes), the size-column labels, the current legend and the sheet's overhead factor. Show the operator the count and the current Low hours.
+
+## Step 2: Re-size every row — JUDGMENT · PAUSE FOR REVIEW
+
+Nobody hand-writes code. For each row and each size column:
+
+1. Estimate the **solo AI-assisted minutes** — one person directing Claude, greenfield, counting the person's time AND Claude's time. Runway rate (26 h = 13 human + 13 Claude): ~10 min for a trivial change, ~40 min for a typical screen element or endpoint, 2–4½ hrs for the heaviest pieces. Read the Functionality and Low Level Requirements; do not scale the old size mechanically — the old sizes assumed hand-coding.
+2. Run `gsd-t estimate-sheet size --solo-min <n> --project <type> --xxs` — it multiplies, adds task switching after the multiplier, and prints the size. `--xxs` is always on here: the (Rescale) tab carries **XXS (0.5 hr)** so sub-hour work does not round up to XS. Count switching once per row: pass `--switch-min 0` for the row's smaller column.
+3. Build the plan — one entry per listed row, `functionality` copied **exactly** from the list (the tool matches row AND text, and halts on a row that moved):
+
+   ```json
+   { "items": [ { "row": 15, "functionality": "Route the existing permission resolver into every unguarded surface", "sizes": ["S", "M"] } ] }
+   ```
+
+   `sizes` follows the size-column order the list printed; `""` for a column with no work. Every sized row must be in the plan — a missing row halts, because its copy would silently re-price on the new scale.
+4. Write it to `.gsd-t/estimate-rescale-plan.json` and preview: `gsd-t estimate-sheet rescale --sheet <url> --plan .gsd-t/estimate-rescale-plan.json --dry-run` (old Low hours → new Low hours; nothing written).
+5. **PAUSE:** show the operator the per-row table (row · functionality · solo min · multiplier · size) and the before → after Low hours. Wait for `continue` or corrections.
+
+## Step 3: Write the (Rescale) tabs (MECHANICAL · show result)
+
+```bash
+gsd-t estimate-sheet rescale --sheet <url> --plan .gsd-t/estimate-rescale-plan.json   # add --replace to rebuild existing (Rescale) tabs
+```
+
+It copies the two tabs next to their originals, puts the AI-assisted scale in the copy's legend (XXS 0.0625 · XS 0.1 · S 0.25 · M 0.5 · L 1 · XL 2 · XXL 4 days; XXS in the row under XXL), switches the copy's Days formulas to an exact size lookup (the template's two-letter prefix would read `XX*` as XXS + XXL), writes the sizes, rebuilds `Team Mix (Rescale)` with the original tab's roster staffed from the copy's phase rollups, and audits the copies. `--suffix "<name>"` writes a separately named pair (`… (<name>)`) instead of `(Rescale)`. Existing (Rescale) tabs halt the run unless `--replace` — and `--replace` deletes only the two (Rescale) tabs. **Exit 4 = a ✗ — fix and re-run. Exit 64 = auth/API/input halt.** Show the tool's output verbatim.
+
+## Step 4: Report
+
+Sheet URL · project type · rows re-sized · Low hours before → after · the Team Mix (Rescale) roster and months · the audit result. State plainly that the original tabs and the Summary index still show the old figures.
+
+## Document Ripple
+
+- The Google Sheet (external) — only the two `(Rescale)` tabs are created or rebuilt.
+- `.gsd-t/estimate-rescale-plan.json` — the sizing judgment, kept so the re-estimate is reproducible.
+
+## ▶ Next Up
+
+Standalone command — no auto-successor.

package/commands/gsd-t-estimate.md

@@ -26,7 +26,7 @@ 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.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. |
+| `projectMultiplier` | greenfield solo ×1 · team ×3 · yellow-field solo ×2 · team ×5 isolated / ×7 wide | Solo AI minutes × this. Includes team overhead. 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. |
@@ -58,7 +58,7 @@ 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 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).
+- **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, counting the person's time AND Claude's time (Runway: ~10 min trivial · ~40 min typical · 2–4½ hr heaviest) — then run `gsd-t estimate-sheet size --solo-min <n> --project <type>`: it multiplies by the project type (greenfield solo ×1 · team ×3 · yellow-field solo ×2 · team ×5 isolated / ×7 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.

package/commands/gsd-t-help.md

@@ -383,6 +383,12 @@ Use these when user asks for help on a specific command:
 - **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>`. 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`
 
+### estimate-rescale
+- **Summary**: Re-price an EXISTING Tekyz estimate sheet on the AI-assisted scale without touching it — copies the T-Shirt and Team Mix tabs into `T-Shirt Size Estimate (Rescale)` / `Team Mix (Rescale)`, re-sizes every row (solo AI minutes × project multiplier + task switching, with an XXS 0.5 hr size), rebuilds the Team Mix and audits the copies
+- **Auto-invoked**: No
+- **Updates**: the two `(Rescale)` tabs on the sheet (original tabs, Overview and the estimates index are never written) + `.gsd-t/estimate-rescale-plan.json`
+- **Use when**: An estimate was sized on the old hand-coding day scale and you want the AI-assisted figure beside it. **SUPERVISED** — the per-row sizing pauses for your review. Accepts `--sheet <url>` and `--project <greenfield-solo|greenfield-team|yellowfield-solo|yellowfield-team-isolated|yellowfield-team-wide>`. Spec: `~/.claude/templates/estimate-sheet-spec.md` §1.4 and §7
+
 ### 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)
 - **Auto-invoked**: No

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.22.10",
+  "version": "5.23.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/scripts/gsd-t-graph-search-guard.js

@@ -326,6 +326,56 @@ function buildUnclearReason(found, cls) {
 }
 
 
+// --- A path forward after an incomplete, empty graph answer ----------------
+//
+// When the graph just answered [] and said its answer was incomplete, blocking
+// the grep with "ask the graph" sends the caller back to the answer that failed
+// them - a dead end. The query CLI records that answer; this names what IS
+// allowed next: open the files holding the unresolved call sites (Read is not
+// blocked), and re-index so SCIP can resolve them. This is a message, not a
+// bypass - the search itself stays blocked.
+// [RULE] incomplete-empty-answer-names-a-path-forward
+
+const INCOMPLETE_MARKER_MAX_AGE_MS = 30 * 60 * 1000;
+
+/** Throws when the marker exists but cannot be read - the caller denies with that. */
+function incompleteAnswerNote(projectDir) {
+  const file = path.join(projectDir, ".gsd-t", "graphDB", "last-incomplete-answer.json");
+  if (!fs.existsSync(file)) return "";
+  const m = JSON.parse(fs.readFileSync(file, "utf8"));
+  if (!m || Date.now() - Date.parse(m.ts) > INCOMPLETE_MARKER_MAX_AGE_MS) return "";
+  const lines = [
+    "",
+    "",
+    "The graph's last answer (" + m.verb + " " + m.target + ") was EMPTY and marked incomplete:",
+    "  " + (m.note || "some call edges are unresolved"),
+    "",
+    "Allowed path forward:",
+  ];
+  const sites = m.unresolvedCallSites;
+  if (sites && Array.isArray(sites.files) && sites.files.length) {
+    lines.push("  1. Open these files with the Read tool - they hold " + sites.count +
+      " unresolved call site(s) naming the target:");
+    for (const f of sites.files.slice(0, 10)) lines.push("       " + f);
+    if (sites.files.length > 10) lines.push("       ... (" + sites.files.length + " files; full list in the query's coverage.unresolvedCallSites)");
+  } else {
+    lines.push("  1. gsd-t graph body <symbol>  - read the definition, then Read the files that import its module");
+    lines.push("     (gsd-t graph who-imports <file>)");
+  }
+  lines.push("  2. gsd-t graph status  - lists files missing from SCIP; gsd-t graph index re-resolves them");
+  return lines.join("\n");
+}
+
+/** The note, or a deny naming why the marker could not be read. */
+function pathForwardOrDeny(projectDir) {
+  try {
+    return incompleteAnswerNote(projectDir);
+  } catch (e) {
+    deny("The graph's last incomplete-answer record (.gsd-t/graphDB/last-incomplete-answer.json) " +
+      "could not be read: " + e.message + "\n\nDelete it and re-run the graph query.");
+  }
+}
+
 // --- Recording the decision ------------------------------------------------
 //
 // One line per block, into the same ledger the graph's own tooling writes. The
@@ -473,13 +523,13 @@ function decide(raw) {
 
     if (cls.verdict === "structural") {
       recordBlock(projectDir, f.program, f.pattern, "structural");
-      if (hasGraph) deny(buildStructuralReason(f, cls));
+      if (hasGraph) deny(buildStructuralReason(f, cls) + pathForwardOrDeny(projectDir));
       else deny(buildNoGraphReason(f, cls));
       return;
     }
     if (cls.verdict === "unclear") {
       recordBlock(projectDir, f.program, f.pattern, "unclear");
-      deny(buildUnclearReason(f, cls));
+      deny(buildUnclearReason(f, cls) + (hasGraph ? pathForwardOrDeny(projectDir) : ""));
       return;
     }
   }

package/scripts/statusline-command.sh

@@ -66,11 +66,20 @@ model=$(printf '%s' "$input" | jq -r '.model.id // ""')
 #       Computed as input_tokens + cache_creation_input_tokens +
 #       cache_read_input_tokens to capture the full window pressure. ---
 ctx_left=""
-if [ -n "$cwd" ]; then
+# Claude Code passes this session's transcript path directly. Prefer it: the
+# cwd-derived slug below misses whenever the session's working folder is a
+# subfolder (or contains spaces), which silently dropped the ctx field.
+transcript=$(printf '%s' "$input" | jq -r '.transcript_path // ""')
+if [ -n "$transcript" ] && [ -f "$transcript" ]; then
+  sess_dir=$(dirname "$transcript")
+elif [ -n "$cwd" ]; then
   proj_slug=$(printf '%s' "$cwd" | sed 's:/:-:g')
   sess_dir="$HOME/.claude/projects/$proj_slug"
+fi
+if [ -n "$sess_dir" ]; then
   if [ -d "$sess_dir" ]; then
-    latest_jsonl=$(ls -t "$sess_dir"/*.jsonl 2>/dev/null | head -1)
+    latest_jsonl=$transcript
+    [ -f "$latest_jsonl" ] || latest_jsonl=$(ls -t "$sess_dir"/*.jsonl 2>/dev/null | head -1)
     if [ -n "$latest_jsonl" ]; then
       # Window size by model family. Haiku = 200k; everything else = 1M.
       case "$model" in

package/templates/CLAUDE-global.md

@@ -625,7 +625,7 @@ Add `**Also available:**` with `- /gsd-t-{alt} — {desc}` lines if alternatives
 | `setup` | `status` | |
 | `design-decompose` | `design-build` | `partition` (if domains needed first) |
 
-Commands with no successor (standalone): `quick`, `debug`, `brainstorm`, `status`, `help`, `resume`, `prompt`, `log`, `health`, `pause`, `estimate`, `stories`, backlog commands.
+Commands with no successor (standalone): `quick`, `debug`, `brainstorm`, `status`, `help`, `resume`, `prompt`, `log`, `health`, `pause`, `estimate`, `estimate-rescale`, `stories`, backlog commands.
 
 Skip the hint if auto-advancing (Level 3 mid-wave) — only show when the user needs to manually invoke the next step.
 

package/templates/estimate-config.json

@@ -10,8 +10,8 @@
   "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.",
+  "projectMultiplier": { "greenfield-solo": 1, "greenfield-team": 3, "yellowfield-solo": 2, "yellowfield-team-isolated": 5, "yellowfield-team-wide": 7 },
+  "_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. Includes team overhead — set the sheet overhead factor accordingly (David, 2026-09-28).",
 
   "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.",

package/templates/estimate-sheet-spec.md

@@ -80,20 +80,20 @@ Column widths: `[150, 120, 300, 430, 122, 90, 90, 61, 53, 76, 81, 81]`.
 
 #### 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).
+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 — solo minutes count both).
 
-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.
+1. **Estimate the task in SOLO AI-assisted minutes** — one person directing Claude, greenfield, counting **the person's time AND Claude's time** (David, 2026-09-29). Runway rate: roughly 10 min for a trivial change, 40 min for a typical screen element or endpoint, 2–4½ hrs for the heaviest pieces.
 2. **Multiply by the project type:**
 
 | Project | Multiplier |
 |---|---|
 | Greenfield, solo | × 1 |
-| Greenfield, team | × 5 |
+| Greenfield, team | × 3 |
 | Yellow-field (existing app), solo | × 2 |
-| Yellow-field, team — isolated change | × 8 |
-| Yellow-field, team — big blast radius | × 12 |
+| Yellow-field, team — isolated change | × 5 |
+| Yellow-field, team — big blast radius | × 7 |
 
-   Blast radius comes from the code graph (`gsd-t graph blast-radius`), not a guess.
+   The multipliers include team overhead (reviews, QA, coordination) — do not also charge it through the overhead factors (David, 2026-09-28). 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.
 
@@ -273,7 +273,8 @@ 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 size --solo-min <n> --project <type> [--switch-min <n>] [--xxs]   # §1.4: solo minutes → team hours → size (no sheet needed); --xxs for (Rescale) tabs
+gsd-t estimate-sheet rescale --sheet <id|url> (--list | --plan <p.json> [--dry-run] [--replace] [--suffix <name>])  # §7: re-price into (Rescale) copies; originals untouched
 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
@@ -309,3 +310,22 @@ 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, 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.
+
+---
+
+## 7. Rescale — re-price an existing estimate into copied tabs (`/gsd-t-estimate-rescale`)
+
+An estimate written on the old day scale is re-priced **without touching it**. `gsd-t estimate-sheet rescale` copies `T-Shirt Size Estimate` → **`T-Shirt Size Estimate (Rescale)`** and `Team Mix` → **`Team Mix (Rescale)`** (each placed next to its original) and re-sizes the copies only. The original tabs, the Overview tab and the estimates index are never written.
+
+| Step | Rule |
+|---|---|
+| List | `rescale --list` prints every sized item row (row, text, phase, sizes), the size-column labels, legend and MF. |
+| Plan | `{ "items": [ { "row", "functionality", "sizes": [...] } ] }` — every sized row exactly once, matched by row AND exact Functionality text (a moved row HALTS); sizes in size-column order. A missing row HALTS — its copy would silently re-price. |
+| Legend | The copy gets the AI scale plus **XXS 0.0625 d (0.5 hr)** in the row directly under XXL (HALTS if that row is not empty). XXS exists on (Rescale) tabs only. |
+| Formulas | With XXS present the copy's Days column uses an **exact** lookup — `SUMIF(legend, F{r}&" -*", values)` — because the template's `LEFT(F{r},2)&"*"` reads `XX*` as XXS + XXL. The audit expects the exact form whenever the legend carries XXS. |
+| Team Mix | `Team Mix (Rescale)` keeps the original tab's roster (derived as `teammix` does) and staffs the copy's phase rollups (midpoint of Low/High, §2.2). |
+| Formatting | The copy is re-wrapped (C/D) and top-aligned so it passes §5 on its own. |
+| Overhead | The COPY's overhead factors are zeroed by default (the multipliers already include team overhead); `"noOverhead": false` in the plan keeps them. The original tab's factors are never written. |
+| Re-run | Existing (Rescale) tabs HALT the run; `--replace` rebuilds them **in place** — the T-Shirt copy is cleared and re-copied from the original (values, formulas, formats, validation, widths) and the Team Mix copy is cleared and rewritten, so both tabs keep their identity. They are never deleted and re-created: other sheets import them by name (IMPORTRANGE), and a view that refreshes while a tab is missing caches `#REF!`. `--dry-run` prints old → new Low hours and writes nothing. |
+| Audit | §5 T-Shirt + Team Mix checks run on the (Rescale) tabs by read-back; exit 4 on any ✗. |
+| Second copy | `--suffix "AI v2"` writes `T-Shirt Size Estimate (AI v2)` + `Team Mix (AI v2)` instead, so a second re-estimate never overwrites the `(Rescale)` tabs other sheets import by name. Plain text only (no parentheses, quotes or `!`). |

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

@@ -51,8 +51,8 @@ For each finding, write a row (cols A–G; leave H–L formulas alone):
 `D` Low-Level Requirement · `E` Phase (MVP) · `F` Web Portal size · `G` Backend/API size.
 
 - 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
+  Estimate SOLO AI minutes (human + Claude time; ~10 / 40 min / 2–4½ hr), then `gsd-t estimate-sheet size --solo-min <n> --project <type>`
+  (greenfield solo ×1 · team ×3 · yellow-field solo ×2 · team ×5 isolated / ×7 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`,