@tekyzinc/gsd-t 5.22.10 → 5.24.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;
   }
 }
 
@@ -4756,7 +4766,31 @@ function doGraphStatus() {
     return;
   }
   success(`Graph index: ${envelope.fileCount || 0} files`);
-  if (envelope.tier) info(`Tier: ${envelope.tier}`);
+  // Per-tier file counts (what the build reported), then the worst tier present.
+  const tiers = envelope.tiers ? Object.entries(envelope.tiers).sort((a, b) => b[1] - a[1]) : [];
+  if (tiers.length) info(`Tiers: ${tiers.map(([t, n]) => `${t} ${n}`).join(" · ")}`);
+  if (envelope.tier) info(`Lowest tier present: ${envelope.tier}`);
+  if (envelope.tableCount || envelope.enumCount) info(`Database tables: ${envelope.tableCount}, enums: ${envelope.enumCount} (gsd-t graph table <name> · who-uses <name>)`);
+  // [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 (ex && ex.defaults && ex.defaults.length) info(`Excluded by default: ${ex.defaults.join(", ")}`);
+  // Suggestions only — a folder is never dropped from the graph without the user listing it.
+  const sug = envelope.excludeSuggestions;
+  if (sug && sug.length) {
+    info(`Folders that may not be the app (${sug[0].reason}) — add to .gsd-t/graph-exclude.json if so:`);
+    for (const x of sug.slice(0, 15)) log(`      ${x.folder}  (${x.files} files)`);
+  }
   if (envelope.storeSize !== undefined) info(`Store size: ${envelope.storeSize} bytes`);
   if (envelope.detail) log(JSON.stringify(envelope, null, 2));
 }
@@ -4770,7 +4804,7 @@ function doGraphQuery(args) {
   const verb = args[0];
   if (!verb) {
     error("Usage: gsd-t graph query <verb> [target]");
-    info("Verbs: status, who-imports, who-calls, blast-radius, cluster, dead-code, orphan, dangling, test-impl");
+    info("Verbs: status, who-imports, who-calls, body, blast-radius, who-uses [--writes|--reads], table, cluster, dead-code, orphan, dangling, test-impl");
     return;
   }
   const envelope = _graphQueryCli([verb].concat(args.slice(1)));
@@ -4795,6 +4829,9 @@ function doGraph(args) {
     case "who-calls":     { const e = _graphQueryCli(["who-calls",   args[1] || ""]); log(JSON.stringify(e, null, 2)); break; }
     case "blast-radius":  { const e = _graphQueryCli(["blast-radius", args[1] || ""]); log(JSON.stringify(e, null, 2)); break; }
     case "body":          { const e = _graphQueryCli(["body",         args[1] || ""]); log(JSON.stringify(e, null, 2)); break; }
+    // Database tables (Drizzle pgTable/mysqlTable/sqliteTable + pgEnum).
+    case "who-uses":      { const e = _graphQueryCli(["who-uses"].concat(args.slice(1))); log(JSON.stringify(e, null, 2)); break; }
+    case "table":         { const e = _graphQueryCli(["table",        args[1] || ""]); log(JSON.stringify(e, null, 2)); break; }
     case "tasks":         doGraphTaskOutput(args[1] || "table"); break;
     case "metrics":       { // M99 D3-T2: append-only arm — rollup the telemetry ledger
       const _metricsRollup = require("./gsd-t-graph-metrics-rollup.cjs");
@@ -4843,7 +4880,7 @@ function doGraph(args) {
     }
     default:
       error(`Unknown graph subcommand: ${sub}`);
-      info("Usage: gsd-t graph [index|status|query|who-imports|who-calls|blast-radius|body|tasks|metrics|wiring-log]");
+      info("Usage: gsd-t graph [index|status|query|who-imports|who-calls|blast-radius|body|who-uses|table|tasks|metrics|wiring-log]");
       info("       gsd-t graph --output json|table   (task DAG)");
   }
 }

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.24.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

@@ -281,8 +281,47 @@ function buildNoGraphReason(found, cls) {
   ].join("\n");
 }
 
+// --- Database-table questions ---------------------------------------------
+//
+// `grep -rn "insert(scheduleEvents"` or `grep pgTable` asks about a database
+// table. The graph indexes Drizzle tables (who-uses / table / blast-radius), so
+// the block names those verbs and the table instead of sending the caller to
+// who-calls, which has no answer for a table. [RULE] search-guard-routes-table-questions
+
+const TABLE_BUILDER_SHAPE = /\b(pgTable|mysqlTable|sqliteTable|pgEnum)\b/;
+const TABLE_OP_SHAPE = /\.?\b(from|innerJoin|leftJoin|rightJoin|fullJoin|insert|update|delete|references)\s*\\?\(\s*(?:\\?\(\s*\\?\)\s*=>\s*)?([A-Za-z_$][\w$]*)/;
+const QUERY_API_SHAPE = /\bquery\\?\.([A-Za-z_$][\w$]*)/;
+
+/** → { table: name|null, why } when the pattern reads as a table question; else null. */
+function tableQuestion(pattern) {
+  const p = String(pattern);
+  const op = TABLE_OP_SHAPE.exec(p);
+  if (op) return { table: op[2], why: "a Drizzle table operation (" + op[1] + ")" };
+  const q = QUERY_API_SHAPE.exec(p);
+  if (q && /\bdb\b|\btx\b/.test(p)) return { table: q[1], why: "a Drizzle relational query (db.query.<table>)" };
+  if (TABLE_BUILDER_SHAPE.test(p)) return { table: null, why: "a Drizzle table declaration" };
+  return null;
+}
+
+function tableRouting(tq) {
+  const t = tq.table === null ? "<table>" : tq.table;
+  return [
+    "This reads as a database-table question (" + tq.why + "). The graph indexes tables:",
+    "",
+    "  gsd-t graph who-uses " + t + "            - every function / route / method that uses it",
+    "  gsd-t graph who-uses " + t + " --writes   - only inserts / updates / deletes (--reads for reads)",
+    "  gsd-t graph table " + t + "               - its columns and foreign keys, both directions",
+    "  gsd-t graph blast-radius " + t + "        - tables that reference it + the code that uses it",
+    "",
+    "A table is found by its code name (scheduleEvents) or its SQL name (schedule_events).",
+    "",
+  ];
+}
+
 function buildStructuralReason(found, cls) {
   const lines = [];
+  const tq = tableQuestion(found.pattern);
+  if (tq !== null) lines.push(...tableRouting(tq));
 
   const symbol = cls.symbol === null ? found.pattern : cls.symbol;
   const verb = cls.verb === null ? "who-calls" : cls.verb;
@@ -298,6 +337,7 @@ function buildStructuralReason(found, cls) {
     "  gsd-t graph " + verb + " " + symbol,
     "",
     "Other verbs: who-imports, who-calls, defines, blast-radius, body.",
+    "A database table (Drizzle)? gsd-t graph who-uses " + symbol + "  /  gsd-t graph table " + symbol,
     "",
     "If this really is a text search - a phrase in prose, a key in config, a string in a",
     "document - scope it to the files the graph does not index, and it will run:",
@@ -308,7 +348,8 @@ function buildStructuralReason(found, cls) {
 }
 
 function buildUnclearReason(found, cls) {
-  return [
+  const tq = tableQuestion(found.pattern);
+  return (tq === null ? [] : tableRouting(tq)).concat([
     "This search could be asking about code structure, and that has to be settled before",
     "it runs - a guess in either direction is how the graph rule stopped having teeth.",
     "",
@@ -320,12 +361,65 @@ function buildUnclearReason(found, cls) {
     "  Structure (who calls, who imports, where defined):",
     "    gsd-t graph who-calls <symbol>",
     "",
+    "  A database table (who reads or writes it, its columns and foreign keys):",
+    "    gsd-t graph who-uses <table>   /   gsd-t graph table <table>",
+    "",
     "  Text in files the graph does not index (.md, .json, .sql, config, prose):",
     "    add --include='*.md' (or the right extensions) and run it again",
-  ].join("\n");
+  ]).join("\n");
 }
 
 
+// --- 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 +567,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;
     }
   }