@tekyzinc/gsd-t 4.9.13 → 4.10.10

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

@@ -0,0 +1,167 @@
+/**
+ * gsd-t-scip-reader.cjs
+ *
+ * M95 — Read a SCIP index (`index.scip`, a protobuf emitted by scip-typescript /
+ * scip-python) and turn it into the data the graph needs to RESOLVE call edges:
+ *
+ *   1. symbolToDef : Map<scipSymbol, funcId>      — where each symbol is DEFINED
+ *   2. fileRefs    : Map<relPath, Array<{symbol, funcId, line}>>  — every
+ *      reference occurrence in that file, already resolved to the def funcId
+ *
+ * A funcId is the graph's canonical `relPath#funcName` (line-suffix dropped here;
+ * the indexer keys call edges on `relPath#name`-style ids — see resolveCallEdges).
+ *
+ * Why this exists: before M95 the SCIP "upgrade" only RAN scip-typescript and
+ * relabelled the tree-sitter edges 'compiler-accurate' without reading the output.
+ * This module reads the output so call targets actually resolve across files.
+ *
+ * The SCIP protobuf decoder is the one bundled inside scip-typescript
+ * (`dist/src/scip.js`). scip-typescript is a GSD-T install requirement (M95), so
+ * depending on its bundled decoder is legitimate. We locate it across install
+ * layouts and FAIL LOUD if absent (never silently degrade).
+ *
+ * [RULE] scip-resolution-reads-real-output  — edges are derived from the .scip
+ *        protobuf, never relabelled-in-place.
+ * [RULE] scip-symbol-to-funcid-deterministic — same .scip → same funcId map.
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execSync } = require('node:child_process');
+
+// ── Locate scip-typescript's bundled SCIP protobuf decoder ───────────────────
+let _scipProto = null;
+
+/**
+ * Load the bundled `scip.js` protobuf namespace from scip-typescript.
+ * Searches: local node_modules → global npm root → NODE_PATH.
+ * @returns {object|null} the `scip` namespace (Index, Document, …) or null.
+ */
+function loadScipProto() {
+  if (_scipProto) return _scipProto;
+
+  const candidates = [];
+  // 1. local node_modules (if scip-typescript is a project dep)
+  try {
+    candidates.push(require.resolve('@sourcegraph/scip-typescript/dist/src/scip.js'));
+  } catch { /* not local */ }
+  // 2. global npm root
+  try {
+    const groot = execSync('npm root -g', { encoding: 'utf8' }).trim();
+    candidates.push(path.join(groot, '@sourcegraph/scip-typescript/dist/src/scip.js'));
+  } catch { /* npm not reachable */ }
+
+  for (const c of candidates) {
+    try {
+      if (fs.existsSync(c)) {
+        const mod = require(c);
+        _scipProto = mod.scip || mod;
+        if (_scipProto && _scipProto.Index) return _scipProto;
+      }
+    } catch { /* try next */ }
+  }
+  return null;
+}
+
+// ── SCIP symbol → function name ──────────────────────────────────────────────
+// A SCIP symbol looks like:
+//   "scip-typescript npm <pkg> <ver> src/`calc.ts`/computeTotal()."
+// The trailing descriptor after the last '/' identifies the entity:
+//   "computeTotal()."  → a method/function descriptor (ends with "().")
+//   "computeTotal()(x)" → a parameter (we ignore params for call resolution)
+// We extract the bare name from a function/method descriptor.
+
+/**
+ * Extract the function name from a SCIP symbol, or null if the symbol is not a
+ * callable (parameter, type, module, etc.).
+ * @param {string} symbol
+ * @returns {string|null}
+ */
+function funcNameFromSymbol(symbol) {
+  if (!symbol || typeof symbol !== 'string') return null;
+  // Parameters look like "name().(param)" — skip (they contain "(...)" after "().")
+  // Methods/functions end with "()." possibly preceded by the name.
+  // Take the final descriptor (after the last unescaped '/').
+  const lastSlash = symbol.lastIndexOf('/');
+  const descriptor = lastSlash === -1 ? symbol : symbol.slice(lastSlash + 1);
+  // Method/function descriptor: "<name>()." — capture <name>
+  const m = descriptor.match(/^([A-Za-z_$][\w$]*)\(\)\.$/);
+  return m ? m[1] : null;
+}
+
+// ── Read a SCIP index into resolution maps ───────────────────────────────────
+
+const SYMBOL_ROLE_DEFINITION = 0x1; // SymbolRole.Definition bit
+
+/**
+ * Decode a `.scip` file and build resolution maps.
+ *
+ * @param {string} scipPath  absolute path to an index.scip
+ * @returns {{ ok: true, symbolToDef: Map<string,string>,
+ *             fileRefs: Map<string, Array<{symbol:string, funcId:string, line:number}>> }
+ *         | { ok: false, reason: string }}
+ */
+function readScipIndex(scipPath) {
+  const proto = loadScipProto();
+  if (!proto) {
+    return { ok: false, reason: 'scip-decoder-unavailable' };
+  }
+  if (!fs.existsSync(scipPath)) {
+    return { ok: false, reason: 'scip-file-missing' };
+  }
+
+  let obj;
+  try {
+    const buf = fs.readFileSync(scipPath);
+    obj = proto.Index.deserialize(buf).toObject();
+  } catch (e) {
+    return { ok: false, reason: `scip-decode-failed: ${e.message}` };
+  }
+
+  const symbolToDef = new Map();          // scipSymbol → funcId (relPath#name)
+  const fileRefs = new Map();             // relPath → [{symbol, line}]
+
+  const docs = obj.documents || [];
+
+  // First pass: collect every DEFINITION occurrence → symbol → funcId.
+  for (const doc of docs) {
+    const relPath = doc.relative_path;
+    if (!relPath) continue;
+    for (const occ of doc.occurrences || []) {
+      const isDef = (occ.symbol_roles & SYMBOL_ROLE_DEFINITION) !== 0;
+      if (!isDef) continue;
+      const name = funcNameFromSymbol(occ.symbol);
+      if (!name) continue;
+      // funcId = the graph's file#name key
+      symbolToDef.set(occ.symbol, `${relPath}#${name}`);
+    }
+  }
+
+  // Second pass: collect every REFERENCE occurrence per file, resolved to the def.
+  for (const doc of docs) {
+    const relPath = doc.relative_path;
+    if (!relPath) continue;
+    const refs = [];
+    for (const occ of doc.occurrences || []) {
+      const isDef = (occ.symbol_roles & SYMBOL_ROLE_DEFINITION) !== 0;
+      if (isDef) continue;                       // refs only
+      const name = funcNameFromSymbol(occ.symbol);
+      if (!name) continue;                        // only callable references
+      const funcId = symbolToDef.get(occ.symbol); // resolve to the def
+      if (!funcId) continue;                      // external/unresolvable → skip (stays floor)
+      const line = Array.isArray(occ.range) ? occ.range[0] : null;
+      refs.push({ symbol: occ.symbol, funcId, line });
+    }
+    if (refs.length) fileRefs.set(relPath, refs);
+  }
+
+  return { ok: true, symbolToDef, fileRefs };
+}
+
+module.exports = {
+  loadScipProto,
+  funcNameFromSymbol,
+  readScipIndex,
+};

package/bin/gsd-t.js

@@ -1501,6 +1501,41 @@ function installCgc() {
   }
 }
 
+// M95: install the SCIP indexers that give the code graph compiler-accurate
+// call-edge resolution. These are a GSD-T requirement (not "optional only to get
+// better") — the precise call graph (who-calls / test-impl / blast-radius across
+// imports) depends on them. Node-only npm packages (Apache-2.0 / MIT). Fail-loud
+// but non-blocking: if the global install needs sudo, warn with the manual
+// command rather than aborting the whole GSD-T install.
+function installScipIndexers() {
+  const indexers = [
+    { bin: "scip-typescript", pkg: "@sourcegraph/scip-typescript", langs: "TS/JS" },
+    { bin: "scip-python", pkg: "@sourcegraph/scip-python", langs: "Python" },
+  ];
+  for (const { bin, pkg, langs } of indexers) {
+    let present = false;
+    try {
+      execFileSync("which", [bin], { encoding: "utf8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"] });
+      present = true;
+    } catch { /* not present */ }
+
+    if (present) {
+      info(`${bin} present (${langs} compiler-accurate edges)`);
+      continue;
+    }
+    info(`Installing ${bin} (${langs} compiler-accurate code graph)...`);
+    try {
+      execFileSync("npm", ["install", "-g", pkg], {
+        encoding: "utf8", timeout: 180000, stdio: ["pipe", "pipe", "pipe"],
+      });
+      success(`${bin} installed`);
+    } catch (e) {
+      warn(`${bin} install failed — code graph will use tree-sitter floor (approximate) for ${langs}`);
+      info(`To enable compiler-accurate ${langs} edges: npm install -g ${pkg}`);
+    }
+  }
+}
+
 // ─── Commands ────────────────────────────────────────────────────────────────
 
 // Shared templates that slash-command prompts reference by predictable path.
@@ -1689,6 +1724,9 @@ async function doInstall(opts = {}) {
   heading("Graph Engine (CGC)");
   installCgc();
 
+  heading("SCIP Indexers (Compiler-Accurate Code Graph — M95)");
+  installScipIndexers();
+
   saveInstalledVersion();
 
   showInstallSummary(gsdtCommands.length, utilityCommands.length);
@@ -2636,6 +2674,14 @@ const PROJECT_BIN_TOOLS = [
   // M93 — jargon-gloss lint for written docs (the file surface the brevity-guard
   // Stop hook can't reach). Propagated so a project's doc checks can invoke it.
   "gsd-t-jargon-lint.cjs",
+  // M94/M95 — code-graph runtime. The wired consumers (execute/wave disjointness,
+  // debug, quick, impact, plan, scan) look for `bin/gsd-t-graph-query-cli.cjs` IN
+  // THE PROJECT and fall back to grep when it is absent. Propagating the query CLI
+  // plus its require-chain (indexer, freshness, edge-extract, SCIP upgrade + reader)
+  // is what actually makes a project graph-aware instead of grep-dependent.
+  // [[project_code_graph_universal_consumer]] [[feedback_graph_is_architectural_anchor]]
+  "gsd-t-graph-query-cli.cjs", "gsd-t-graph-index.cjs", "gsd-t-graph-freshness.cjs",
+  "gsd-t-graph-edge-extract.cjs", "gsd-t-graph-scip-upgrade.cjs", "gsd-t-scip-reader.cjs",
 ];
 
 // Files that older versions of this installer copied into project bin/ but
@@ -3114,6 +3160,31 @@ function checkDoctorCgc() {
   return issues;
 }
 
+// M95: report SCIP indexer presence. SCIP gives the code graph compiler-accurate
+// call-edge resolution (who-calls / test-impl / blast-radius across imports).
+// Absence is a WARN (graph still works at tree-sitter floor), not a hard error.
+function checkDoctorScip() {
+  let issues = 0;
+  heading("SCIP Indexers (Compiler-Accurate Code Graph)");
+  const indexers = [
+    { bin: "scip-typescript", langs: "TS/JS", pkg: "@sourcegraph/scip-typescript" },
+    { bin: "scip-python", langs: "Python", pkg: "@sourcegraph/scip-python" },
+  ];
+  for (const { bin, langs, pkg } of indexers) {
+    try {
+      const ver = execFileSync(bin, ["--version"], {
+        encoding: "utf8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+      success(`${bin} ${ver} (${langs} compiler-accurate)`);
+    } catch {
+      warn(`${bin} not installed — ${langs} edges fall back to tree-sitter floor (approximate)`);
+      info(`Run: npm install -g ${pkg}  (or reinstall GSD-T)`);
+      issues++;
+    }
+  }
+  return issues;
+}
+
 // Verify context meter wiring: hook registration, hook script presence,
 // config validity, and a local estimation dry-run.
 // Returns number of issues (RED results). Mirrors checkDoctorCgc shape.
@@ -3355,6 +3426,7 @@ async function doDoctor(opts) {
   issues += checkDoctorInstallation();
   issues += await checkDoctorProject(opts);
   issues += checkDoctorCgc();
+  issues += checkDoctorScip();
   // M61 D1: Context Meter retired (token-budget.cjs + context-meter hook deleted).
   // checkDoctorContextMeter would emit phantom errors for the deleted subsystem
   // and tell the user to reinstall it. Native /context replaces the meter.
@@ -3506,68 +3578,111 @@ function doChangelog() {
 }
 
 // ─── Graph ──────────────────────────────────────────────────────────────────
+// M94 Fix-1: the M20–M21 dead engine (graph-indexer / graph-store / graph-query)
+// is REMOVED. All entity-graph verbs (status / who-imports / who-calls / blast-radius
+// / index / query) now delegate to the M94 D5 query CLI
+// (bin/gsd-t-graph-query-cli.cjs). [RULE] graph-status-live
+// [RULE] graph-rewire-no-dangling-export
+//
+// Preserved intact: `gsd-t graph --output json|table` and `gsd-t graph tasks`
+// which print the M44 task-DAG (bin/gsd-t-task-graph.cjs) — a SEPARATE working
+// feature unrelated to the codebase entity graph. (Destructive Action Guard.)
+
+/**
+ * Delegate a verb to the D5 graph query CLI.
+ * Returns the JSON envelope (already parsed) or { ok: false, reason: '...' }.
+ * Prints human-readable output when interactive=true (the default).
+ *
+ * [RULE] graph-status-live — NEVER hits the dead M20–M21 "No graph index found" path.
+ */
+function _graphQueryCli(verbAndArgs) {
+  const { spawnSync } = require("child_process");
+  const cliPath = require("path").join(__dirname, "gsd-t-graph-query-cli.cjs");
+  const result = spawnSync(process.execPath, [cliPath].concat(verbAndArgs), {
+    encoding: "utf8",
+    cwd: process.cwd(),
+    timeout: 30000,
+  });
+  if (result.error) {
+    return { ok: false, reason: "graph-unavailable", detail: result.error.message };
+  }
+  const stdout = (result.stdout || "").trim();
+  if (!stdout) {
+    return { ok: false, reason: "graph-unavailable", detail: result.stderr || "no output" };
+  }
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    return { ok: false, reason: "graph-unavailable", detail: stdout };
+  }
+}
 
+/**
+ * gsd-t graph index
+ * Builds the codebase entity graph via D3 (bin/gsd-t-graph-index.cjs).
+ * [RULE] graph-rewire-no-dangling-export
+ */
 function doGraphIndex() {
   heading("GSD-T Graph — Index");
-  const root = process.cwd();
-  const gq = require("./graph-indexer");
-  const result = gq.indexProject(root, { force: true });
-  if (result.success) {
-    success(`Indexed ${result.entityCount} entities, ${result.relationshipCount} relationships`);
-    info(`Files processed: ${result.filesProcessed}, skipped: ${result.filesSkipped}`);
-    info(`Duration: ${result.duration}ms`);
-    if (result.errors.length > 0) {
-      warn(`Parse errors: ${result.errors.length}`);
-      result.errors.forEach(e => log(`  ${DIM}${e}${RESET}`));
-    }
-  } else {
-    error("Indexing failed");
+  const { spawnSync } = require("child_process");
+  const idxPath = require("path").join(__dirname, "gsd-t-graph-index.cjs");
+  const result = spawnSync(process.execPath, [idxPath, "build", "--repo", process.cwd()], {
+    encoding: "utf8",
+    cwd: process.cwd(),
+    stdio: ["ignore", "inherit", "inherit"],
+    timeout: 300000,
+  });
+  if (result.status !== 0 && result.status !== null) {
+    error("Graph index build failed — see output above");
   }
 }
 
+/**
+ * gsd-t graph status
+ * Queries live index state via D5 CLI.
+ * [RULE] graph-status-live — NEVER returns "No graph index found" from the dead path.
+ * [RULE] graph-rewire-no-dangling-export
+ */
 function doGraphStatus() {
   heading("GSD-T Graph — Status");
-  const root = process.cwd();
-  const store = require("./graph-store");
-  const meta = store.readMeta(root);
-  if (!meta) {
-    warn("No graph index found. Run: gsd-t graph index");
+  const envelope = _graphQueryCli(["status"]);
+  if (!envelope.ok) {
+    warn(`Graph index unavailable: ${envelope.reason || "graph-unavailable"}`);
+    info("Run: gsd-t graph index");
+    return;
+  }
+  // envelope from D5 CLI: { ok, verb:"status", indexed, storeSize, fileCount, tier, ... }
+  if (envelope.indexed === false) {
+    warn("No graph index found.");
+    info("Run: gsd-t graph index");
     return;
   }
-  success(`Provider: ${meta.provider}`);
-  info(`Entities: ${meta.entityCount}`);
-  info(`Relationships: ${meta.relationshipCount}`);
-  info(`Last indexed: ${meta.lastIndexed}`);
-  info(`Duration: ${meta.duration}ms`);
-  const fileCount = Object.keys(meta.fileHashes || {}).length;
-  info(`Files tracked: ${fileCount}`);
+  success(`Graph index: ${envelope.fileCount || 0} files`);
+  if (envelope.tier) info(`Tier: ${envelope.tier}`);
+  if (envelope.storeSize !== undefined) info(`Store size: ${envelope.storeSize} bytes`);
+  if (envelope.detail) log(JSON.stringify(envelope, null, 2));
 }
 
+/**
+ * gsd-t graph query <verb> [args...]
+ * Delegates the verb directly to the D5 CLI.
+ * [RULE] graph-rewire-no-dangling-export
+ */
 function doGraphQuery(args) {
-  const root = process.cwd();
-  const gq = require("./graph-query");
-  const type = args[0];
-  if (!type) {
-    error("Usage: gsd-t graph query <type> [params...]");
-    info("Types: getEntity, getEntities, getCallers, getCallees,");
-    info("       findDeadCode, findDuplicates, findCircularDeps,");
-    info("       getDomainBoundaryViolations, getIndexStatus");
+  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");
     return;
   }
-  const params = {};
-  for (let i = 1; i < args.length; i++) {
-    const [k, v] = args[i].split("=");
-    if (k && v) params[k] = v;
-  }
-  const result = gq.query(type, params, root);
-  log(JSON.stringify(result, null, 2));
+  const envelope = _graphQueryCli([verb].concat(args.slice(1)));
+  log(JSON.stringify(envelope, null, 2));
 }
 
 function doGraph(args) {
   // M44 D1-T4: `gsd-t graph --output json|table` prints the task-graph DAG
-  // (parsed from .gsd-t/domains/*/tasks.md) for debugging. The pre-existing
-  // `index|status|query` subcommands are the codebase entity graph (graph-
-  // indexer) and remain unchanged.
+  // (parsed from .gsd-t/domains/*/tasks.md). This is a SEPARATE working feature
+  // (Destructive Action Guard — preserved intact). [RULE] graph-rewire-no-dangling-export
   const outIdx = args.indexOf("--output");
   if (outIdx !== -1) {
     const fmt = args[outIdx + 1] || "json";
@@ -3575,13 +3690,16 @@ function doGraph(args) {
   }
   const sub = args[0] || "status";
   switch (sub) {
-    case "index":  doGraphIndex(); break;
-    case "status": doGraphStatus(); break;
-    case "query":  doGraphQuery(args.slice(1)); break;
-    case "tasks":  doGraphTaskOutput(args[1] || "table"); break;
+    case "index":         doGraphIndex(); break;
+    case "status":        doGraphStatus(); break;
+    case "query":         doGraphQuery(args.slice(1)); break;
+    case "who-imports":   { const e = _graphQueryCli(["who-imports", args[1] || ""]); log(JSON.stringify(e, null, 2)); break; }
+    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 "tasks":         doGraphTaskOutput(args[1] || "table"); break;
     default:
       error(`Unknown graph subcommand: ${sub}`);
-      info("Usage: gsd-t graph [index|status|query|tasks]");
+      info("Usage: gsd-t graph [index|status|query|who-imports|who-calls|blast-radius|tasks]");
       info("       gsd-t graph --output json|table   (task DAG)");
   }
 }

package/commands/gsd-t-debug.md

@@ -90,6 +90,16 @@ The Workflow runs up to 2 cycles. Cycle 2 receives Cycle 1's failed hypothesis t
 - `complete` → re-run verify (`/gsd-t-verify`); auto-advance.
 - `needs-human` → present root-cause hypothesis + nextStepsIfNotResolved to the user. Do NOT spawn a third cycle; that's the Prime Rule.
 
+## Graph-Enhanced Debugging — READER + WRITER Pattern (M94-D11)
+
+Debug applies the **WRITER pattern** from `graph-consumer-wiring-contract.md`:
+
+**READER half (localization):** Before the fix agent reasons over code, the debug workflow queries `blast-radius` and `who-calls` to localize the bug's call chain — which callers reach the failing function, what is downstream of the changed symbol. This replaces grep-reconstructed call-chain discovery. The structural slice is injected into the debug agent's context.
+
+**WRITER half (re-index after fix):** After the fix lands, the workflow triggers a re-index of the edited files so downstream graph queries see fresh edges (`graph-freshness-contract.md` D4 surface — `freshness_check_on_query` over the touched set). `[RULE] debug-reader-and-writer-both`.
+
+**FAIL-LOUD on graph-unavailable:** On `{ok:false, reason:"graph-unavailable"}`, the debug workflow surfaces `"graph unavailable — fix it (gsd-t graph status)"` and halts the graph-query step. It does NOT fall back to grep for the structural question. The existing debug-loop logic (2-cycle cap, loop-ledger halt) is NOT disrupted — the graph query is additive, injected before the fix agent receives context.
+
 ## Contract-Boundary Debugging
 
 If the bug is at a domain contract boundary (one domain calls another via API/schema/component contract), the debug cycle agent is instructed to:

package/commands/gsd-t-design-build.md

@@ -2,6 +2,16 @@
 
 This command delegates to the **JavaScript orchestrator** for ironclad flow control. Do NOT attempt to run the build pipeline inline — the orchestrator handles Claude spawning, measurement, review gates, and feedback processing deterministically.
 
+## Graph-Enhanced Design Build — WRITER Pattern (M94-D11)
+
+Design-build applies the **WRITER pattern** from `graph-consumer-wiring-contract.md`:
+
+**READER half (who-imports / cluster):** Before generating code, the build pipeline queries `gsd-t graph who-imports` on the target design-contract files to discover which existing components import the target (impact of the generated code on existing consumers), and `gsd-t graph cluster` to surface tightly-coupled file groups relevant to the component's context. This replaces grep/raw-read for the dependency structure question. The structural slice is injected into the code-generation agent's context. `[RULE] design-build-writer-pattern`.
+
+**WRITER half:** After each tier (elements → widgets → pages) generates files, the pipeline triggers a re-index of the generated files (`freshness_check_on_query` from `graph-freshness-contract.md` D4 surface) so the next tier's `who-imports` / `cluster` query sees the new edges from the generated components. `[RULE] design-build-writer-pattern`.
+
+**FAIL-LOUD on graph-unavailable:** On `{ok:false, reason:"graph-unavailable"}`, the structural query surfaces `"graph unavailable — fix it (gsd-t graph status)"` — the pipeline does NOT fall back to grep for the structural question. `[RULE] consumer-structural-grep-removed`.
+
 ## Step 1: Launch the Orchestrator
 
 ```bash

package/commands/gsd-t-execute.md

@@ -57,6 +57,21 @@ The Workflow returns:
 - `status === "verify-failed"`: domains completed but verify-gate found regressions. Invoke `gsd-t-debug` (or its Workflow) before retry.
 - `status === "failed"`: a domain reported `failed`, integrate failed, or preflight blocked. Read `domainResults` for the blocking entry.
 
+## Graph-Aware Disjointness (SAFETY-CRITICAL — M94-D11)
+
+The file-disjointness check (`bin/gsd-t-file-disjointness.cjs`) is **graph-aware** as of M94. It uses `gsd-t graph blast-radius` and `gsd-t graph who-imports` to detect **transitive dependency overlap** — two domains whose touched files share a transitive dependency (one's files import a module that the other's files also import) are NOT disjoint even if their declared `Touches` lists have no literal overlap.
+
+**FAIL-LOUD halt on graph-unavailable:**
+On `graph-unavailable`, the disjointness check **FAILS LOUD and HALTS** — it does NOT fan out on a grep-reconstructed disjointness guess. A grep-reconstructed disjointness guess risks a concurrent-edit conflict (two agents editing overlapping code). This is the safety-critical invariant: `[RULE] execute-disjointness-fail-loud-halts-never-grep-guess`.
+
+**Bootstrap escape hatch (fresh repo or parser regression):**
+`graph-unavailable` in a fresh repo (no index yet built) or after a parser regression must not permanently brick parallel execution. When the graph is genuinely unavailable:
+- The HALT message clearly states `graph-unavailable` (not `graph-says-non-disjoint`) and surfaces the remediation: `gsd-t graph status` and `gsd-t graph build`.
+- The operator may pass `--disjointness-fallback=touches-only` to fall back to the literal-Touches-overlap check with a **loud announced WARNING** (never silent). This escape is NOT applicable to `graph-says-non-disjoint` verdicts — a real non-disjoint block stays absolute.
+- `[RULE] disjointness-bootstrap-escape-not-a-no-recourse-brick`
+
+**WRITER half:** After each domain's edits land, the workflow triggers a freshness pass over the touched set so downstream graph queries see fresh edges (`graph-freshness-contract.md` D4 surface). `[RULE] execute-disjointness-graph-aware-dependency-overlap`.
+
 ## Document Ripple
 
 After execute completes, ensure these are updated in the same commit chain:

package/commands/gsd-t-feature.md

@@ -52,18 +52,26 @@ Build a mental model of: "How does this codebase work today?"
 
 Note what you find — this informs Step 3's Multi-Consumer Check and Step 4's milestone ordering.
 
-## Step 1.5: Graph-Enhanced Blast Radius Analysis
+## Step 1.5: Graph Structural Slice — blast-radius + who-imports (M94-D10)
 
 ```bash
-node scripts/gsd-t-watch-state.js advance --agent-id "$GSD_T_AGENT_ID" --parent-id "${GSD_T_PARENT_AGENT_ID:-null}" --command gsd-t-feature --step 1 --step-label ".5: Graph-Enhanced Blast Radius Analysis" 2>/dev/null || true
+node scripts/gsd-t-watch-state.js advance --agent-id "$GSD_T_AGENT_ID" --parent-id "${GSD_T_PARENT_AGENT_ID:-null}" --command gsd-t-feature --step 1 --step-label ".5: Graph Structural Slice" 2>/dev/null || true
 ```
 
-If `.gsd-t/graph/meta.json` exists (graph index is available):
-1. Query `getSurfaceConsumers` and `getCallers` on functions likely affected by the feature to calculate blast radius across all consumer surfaces
-2. Query `getTransitiveCallers` for deep impact chains that may not be obvious from architecture docs alone
-3. Feed these findings into the Impact Analysis in Step 3
+**[RULE] plan-feature-gapanalysis-use-graph-not-grep** — the feature agent MUST use the graph
+CLI for blast-radius and who-imports questions (new-feature impact on existing code), NOT
+grep/raw-read to reconstruct dependents.
 
-If graph is not available, skip this step.
+The phase Workflow (`gsd-t-phase.workflow.js`) automatically queries `gsd-t graph blast-radius`
+for the feature phase and injects the pre-computed blast-radius slice into the agent context.
+Use this slice to identify which existing code is in the blast radius of the new feature's
+touch points — catching impact via call edges that a grep over import patterns would MISS.
+
+**On `graph-unavailable`:** the phase Workflow surfaces a LOUD message and the feature agent
+FAILS LOUD — it does NOT silently skip this step or fall back to grep for the structural
+blast-radius / who-imports question. Run `gsd-t graph status` to diagnose.
+
+Graph consumer manifest row: `commands/gsd-t-feature.md | templates/workflows/gsd-t-phase.workflow.js | reader | blast-radius,who-imports | grep-reconstructed blast-radius/dependent discovery`
 
 ## Step 2: Understand the Feature
 

package/commands/gsd-t-gap-analysis.md

@@ -32,18 +32,28 @@ Read (if they exist):
 3. `docs/requirements.md` — existing requirements
 4. `docs/architecture.md` — system structure
 
-## Step 1.5: Graph-Enhanced Code Mapping
+## Step 1.5: Graph Structural Slice — who-imports + dead-code (M94-D10)
 
 ```bash
-node scripts/gsd-t-watch-state.js advance --agent-id "$GSD_T_AGENT_ID" --parent-id "${GSD_T_PARENT_AGENT_ID:-null}" --command gsd-t-gap-analysis --step 1 --step-label ".5: Graph-Enhanced Code Mapping" 2>/dev/null || true
+node scripts/gsd-t-watch-state.js advance --agent-id "$GSD_T_AGENT_ID" --parent-id "${GSD_T_PARENT_AGENT_ID:-null}" --command gsd-t-gap-analysis --step 1 --step-label ".5: Graph Structural Slice" 2>/dev/null || true
 ```
 
-If `.gsd-t/graph/meta.json` exists (graph index is available):
-1. Query `getRequirementFor` to pre-map requirements to code entities — provides evidence for classification in Step 4
-2. Query `findDeadCode` to identify unreachable code that may indicate implemented-but-disconnected features (potential gap indicators)
-3. Feed these findings into the classification step to improve evidence quality
+**[RULE] plan-feature-gapanalysis-use-graph-not-grep** — the gap-analysis agent MUST use the
+graph CLI for dead-code and who-imports questions (requirements-vs-code coverage gaps), NOT
+grep/raw-read to reconstruct the dependency or dead-code picture.
 
-If graph is not available, skip this step.
+The phase Workflow (`gsd-t-phase.workflow.js`) automatically queries `gsd-t graph dead-code`
+for the gap-analysis phase and injects the pre-computed dead-code slice into the agent context.
+Use this slice to:
+1. Identify implemented-but-disconnected code (dead-code entries that may indicate a gap — a
+   feature was implemented but never wired into a consumer).
+2. Identify which requirements map to code entities via real import/call edges (`who-imports`).
+
+**On `graph-unavailable`:** the phase Workflow surfaces a LOUD message and the gap-analysis
+agent FAILS LOUD — it does NOT silently skip this step or fall back to grep for the structural
+dead-code / who-imports question. Run `gsd-t graph status` to diagnose.
+
+Graph consumer manifest row: `commands/gsd-t-gap-analysis.md | templates/workflows/gsd-t-phase.workflow.js | reader | who-imports,dead-code | grep-reconstructed dead-code/dependency discovery`
 
 ## Step 2: Parse Requirements
 

package/commands/gsd-t-impact.md

@@ -14,6 +14,31 @@ The agent analyzes the downstream effects of proposed changes: what might break,
 
 Read `.gsd-t/progress.md`, the relevant domain `tasks.md`, and `docs/architecture.md`/`.gsd-t/contracts/` for the surfaces in scope.
 
+## Step 1.5: Graph Structural Slice — blast-radius (M94-D10)
+
+**[RULE] impact-uses-blast-radius-not-grep** — the impact agent MUST use the graph CLI
+to answer the downstream-effect (blast-radius) question, NOT grep/raw-read to reconstruct
+dependents.
+
+The phase Workflow (`gsd-t-phase.workflow.js`) automatically queries `gsd-t graph blast-radius`
+for the impact phase and injects the pre-computed blast-radius slice into the agent context
+before reasoning begins. The agent receives the structural answer and MUST use it — no grep
+reconstruction of import/call dependents is permitted.
+
+**On `graph-unavailable`:** the phase Workflow surfaces a LOUD message:
+```
+⚠ graph unavailable — structural blast-radius slice NOT injected (fix it: gsd-t graph status).
+  NO grep fallback — structural question unanswered.
+```
+The impact agent FAILS LOUD on graph-unavailable — it does NOT silently fall back to grep for
+the structural blast-radius question. Run `gsd-t graph status` to diagnose.
+
+The `blast-radius` verb returns the downstream impact set as the UNION of the import-graph
+and call-graph reverse-reachable sets from the target (transitive). This catches dependents
+reachable only via call edges that a grep over import patterns would MISS.
+
+Graph consumer manifest row: `commands/gsd-t-impact.md | templates/workflows/gsd-t-phase.workflow.js | reader | blast-radius | grep-reconstructed dependent set`
+
 ## Step 2: Resolve the active model profile (M86 — invoke-time injection)
 
 Before calling the Workflow, resolve the active model profile to build the `overrides` map:

package/commands/gsd-t-integrate.md

@@ -25,6 +25,31 @@ It does NOT re-do work that domain workers already did, and does NOT run the ful
 
 Read `.gsd-t/progress.md` and verify all required domain workers have completed (status `complete` in their tasks.md). Read `.gsd-t/contracts/m{NN}-integration-points.md` for the shared-file matrix.
 
+## Step 1.5: Graph Structural Slice — who-imports + blast-radius (M94-D10, ADDITIVE)
+
+**[RULE] integrate-uses-graph-for-wiring-verification** — the integrate Workflow MUST use
+the graph CLI `who-imports` and `blast-radius` verbs to verify cross-domain wiring (real
+import/call edges across the seam), NOT LLM-reconstructed wiring by reading files.
+
+**[RULE] verify-integrate-graph-additive-announced-not-hard-fail** — integrate's graph query
+degrades ANNOUNCED on graph-unavailable, NOT as a hard-fail of the entire integrate run.
+
+The integrate Workflow (`gsd-t-integrate.workflow.js`) queries `gsd-t graph who-imports` and
+`gsd-t graph blast-radius` to verify that domains are actually wired (real edges exist across
+the cross-domain seam). The integrate agent receives this slice and uses it to confirm
+wiring — rather than reading files and inferring the connection.
+
+**On `graph-unavailable`:** the integrate Workflow records a WARNING and CONTINUES its
+cross-domain wire-up work:
+```
+⚠ graph unavailable — structural wiring-check skipped, fix it (gsd-t graph status)
+```
+It does NOT hard-fail integrate solely due to graph unavailability — integrate must always be
+able to run. This is the bootstrap carve-out (PRE-MORTEM Finding 3). Integrate does NOT
+silently grep for the structural wiring question.
+
+Graph consumer manifest row (lint-exempt per verify+integrate carve-out): `commands/gsd-t-integrate.md | templates/workflows/gsd-t-integrate.workflow.js | reader | who-imports,blast-radius | LLM-read-reconstructed cross-domain wiring verification`
+
 ## Step 2: Invoke the integrate Workflow
 
 Call the `Workflow` tool with: