@tekyzinc/gsd-t 4.9.13 → 4.10.10

package/templates/workflows/gsd-t-phase.workflow.js

@@ -102,7 +102,21 @@ async function runCli(projectDir, subcmd, argv, localBin, label, parseJson = tru
   ].join("\n");
   const opts = { label, schema: _CLI_ENVELOPE_SCHEMA, model: "haiku" };
   if (phaseNameOpt) opts.phase = phaseNameOpt;
-  const r = await agent(prompt, opts).catch((e) => ({ ok: false, exitCode: -1, envelope: null, stderr: String(e && e.message), via: "error" }));
+  // The CLI is run by a haiku helper agent, not a subprocess, so a return can transiently
+  // come back missing its parsed result. Retry ONCE on a missing/unparsed result before
+  // giving up — a genuine CLI failure fails both attempts (real error survives the retry),
+  // while a transient helper miss is recovered. Only retry when JSON was expected (parseJson)
+  // and the parsed result is absent; never retry on a clean exit that simply returned no JSON.
+  const runOnce = () => agent(prompt, opts).catch((e) => ({ ok: false, exitCode: -1, envelope: null, stderr: String(e && e.message), via: "error" }));
+  let r = await runOnce();
+  // Retry once when JSON was expected but no parsed result came back — covers both the
+  // throw path (via="error") and a malformed return the loose schema let through (ok=false
+  // with the result absent). A real CLI failure that returned valid JSON (envelope present,
+  // ok=false) is NOT retried — that is a true result, not a transient miss.
+  const missingResult = (x) => !x || (parseJson && (x.envelope === undefined || x.envelope === null) && x.ok !== true);
+  if (missingResult(r)) {
+    r = await runOnce();
+  }
   return r || { ok: false, exitCode: -1, envelope: null, via: "error" };
 }
 async function runPreflight(projectDir, label = "preflight", phaseNameOpt) { return runCli(projectDir, "preflight", ["--json"], "cli-preflight.cjs", label, true, phaseNameOpt); }
@@ -122,6 +136,76 @@ async function generateBrief(projectDir, { kind = "execute", milestone, domain,
   return { ok: r.ok, briefPath: `${projectDir}/.gsd-t/briefs/${id}.json`, via: r.via };
 }
 
+// M94-D10-T0: Structural-slice injection seam.
+// Queries the graph CLI for the structural question appropriate to this phase and
+// returns the slice as a JSON-stringified string to inject into worker agent context.
+// On graph-unavailable returns a LOUD surfaced message (no silent grep).
+// Invariant: [RULE] phase-workflow-injects-structural-slice
+// Invariant: [RULE] phase-workflow-fail-loud-no-grep
+//
+// verb-map per phase (based on the d8 consumer manifest):
+//   impact   → blast-radius   (downstream impact set from target)
+//   plan     → who-imports    (touched-file dependents for sequencing)
+//   partition→ cluster        (tightly-coupled file groups for domain-cut)
+//   feature  → blast-radius   (new-feature impact on existing code)
+//   gap-analysis → dead-code  (requirements-vs-code coverage gaps)
+//   project  → cluster        (structure-aligned milestone decomposition)
+//   populate → who-imports    (derive doc structure from real edges)
+//   promote-debt → blast-radius (scope a debt item's reach)
+//   prd      → cluster        (structure-aware decomposition)
+//   milestone/discuss/design-decompose/doc-ripple → no structural verb (no-op)
+const PHASE_GRAPH_VERB_MAP = {
+  impact:         "blast-radius",
+  plan:           "who-imports",
+  partition:      "cluster",
+  feature:        "blast-radius",
+  "gap-analysis": "dead-code",
+  project:        "cluster",
+  populate:       "who-imports",
+  "promote-debt": "blast-radius",
+  prd:            "cluster",
+};
+
+/**
+ * queryStructuralSlice — calls `gsd-t graph <verb>` for the phase's structural question.
+ * Returns { ok, verb, slice, graphUnavailable, loudMessage } where:
+ *   ok=true  → slice is a JSON-ready object (the graph result)
+ *   ok=false, graphUnavailable=true → LOUD message (no grep fallback)
+ *   ok=false, graphUnavailable=false → graph returned an error / unexpected envelope
+ *
+ * [RULE] phase-workflow-fail-loud-no-grep — on graph-unavailable, surface the loud
+ * message and NEVER fall back to grep for the structural question.
+ */
+async function queryStructuralSlice(projectDir, phaseName, phaseNameOpt) {
+  const verb = PHASE_GRAPH_VERB_MAP[phaseName];
+  if (!verb) {
+    // Phase has no mapped structural verb (milestone/discuss/design-decompose/doc-ripple) — no-op.
+    return { ok: true, verb: null, slice: null, graphUnavailable: false, loudMessage: null };
+  }
+  // The graph query uses gsd-t-graph-query-cli.cjs (local) or `gsd-t graph <verb>` (global).
+  // argv: only the verb (no target) for phase-level queries that return a global set
+  // (cluster/dead-code/who-imports/blast-radius without a target returns the full graph slice).
+  const r = await runCli(
+    projectDir, `graph ${verb}`, [], "gsd-t-graph-query-cli.cjs",
+    `graph:${verb}`, true, phaseNameOpt
+  );
+  const env = r.envelope || {};
+  if (env.ok === false && env.reason === "graph-unavailable") {
+    // [RULE] phase-workflow-fail-loud-no-grep: surface LOUD, no grep fallback.
+    const loudMessage = `⚠ graph unavailable — structural ${verb} slice NOT injected (fix it: gsd-t graph status). NO grep fallback — structural question unanswered.`;
+    log(`M94 graph-slice: ${loudMessage}`);
+    return { ok: false, verb, slice: null, graphUnavailable: true, loudMessage };
+  }
+  if (env.ok === true) {
+    log(`M94 graph-slice: ${phaseName} → ${verb} → ${(env.results || []).length} result(s) (tier: ${env.tier || "?"})`);
+    return { ok: true, verb, slice: env, graphUnavailable: false, loudMessage: null };
+  }
+  // Unexpected envelope (graph returned ok:false for a non-unavailable reason).
+  const loudMessage = `⚠ graph ${verb} query returned unexpected envelope (ok=${env.ok}, reason=${env.reason || "?"}). Structural slice NOT injected.`;
+  log(`M94 graph-slice: ${loudMessage}`);
+  return { ok: false, verb, slice: null, graphUnavailable: false, loudMessage };
+}
+
 // M82: run the deterministic selection oracle over a candidate-set spec. The spec
 // is written to a file via the agent's Bash (no fs in this sandbox), then judged by
 // `gsd-t competition-judge --in <file>`. The agent MUST copy the judge's rich output
@@ -749,6 +833,17 @@ ${STATED_CLAIMS_INSTRUCTION}`,
 const baseObjective = promptByPhase[phaseName];
 const briefLine = `**Brief (REQUIRED):** ${brief.briefPath || "(no brief — re-walk repo)"}`;
 
+// M94-D10-T0: Query the structural graph slice for this phase.
+// The result is threaded into every worker-agent prompt so the agent receives
+// the pre-computed structural answer and has no reason to grep for structure.
+// [RULE] phase-workflow-injects-structural-slice
+const _graphSliceResult = await queryStructuralSlice(projectDir, phaseName, "Phase");
+const _graphSliceLine = _graphSliceResult.ok && _graphSliceResult.slice
+  ? `\n**Structural Graph Slice (${_graphSliceResult.verb}):** ${JSON.stringify(_graphSliceResult.slice)}\nUse this pre-computed graph slice to answer structural questions — do NOT grep for ${_graphSliceResult.verb} answers.`
+  : _graphSliceResult.loudMessage
+    ? `\n**Structural Graph:** ${_graphSliceResult.loudMessage}`
+    : "";
+
 let result;
 // M90 §2 D4-T4: holds the divergence-path result from the competition arm (R-ARCH-1).
 // Set inside the competition arm (before Finalize), attached to result after.
@@ -761,6 +856,7 @@ if (!competitionOn) {
       `You are the ${phaseName} phase agent.`,
       milestone ? `Milestone: ${milestone}` : "",
       briefLine,
+      _graphSliceLine,
       userInput ? `\nUser input:\n${userInput}` : "",
       ``,
       `Objective: ${baseObjective}`,
@@ -849,6 +945,7 @@ if (!competitionOn) {
           `You are candidate ${ids[i]} — one of ${competitionN} INDEPENDENT ${phaseName} proposals competing on quality.`,
           milestone ? `Milestone: ${milestone}` : "",
           briefLine,
+          _graphSliceLine,
           userInput ? `\nUser input:\n${userInput}` : "",
           ``,
           `Objective: ${baseObjective}`,
@@ -1030,6 +1127,7 @@ if (!competitionOn) {
       `You are the ${phaseName} finalizer. A competition selected a WINNING proposal; implement it for real.`,
       milestone ? `Milestone: ${milestone}` : "",
       briefLine,
+      _graphSliceLine,
       ``,
       `Objective: ${baseObjective}`,
       ``,

package/templates/workflows/gsd-t-quick.workflow.js

@@ -166,6 +166,59 @@ const RESEARCH_RESULT_SCHEMA = {
   properties: { ok: { type: "boolean" }, gapKey: { type: "string" }, citedBlock: { type: "string" }, sourceUrls: { type: "array", items: { type: "string" } }, fetchDates: { type: "array", items: { type: "string" } }, reason: { type: "string" } },
 };
 
+// M94-D11 §READER: Query blast-radius / who-imports for structural impact before editing.
+// Returns a short text snippet injected into the Execute phase agent prompt.
+// On graph-unavailable: logs the fail-loud message and returns null (no grep fallback).
+// [RULE] quick-writer-pattern
+async function queryGraphForQuick(projectDir, task, phaseName) {
+  // Extract a plausible target hint from the task description (first word-token that
+  // looks like a file or function name). Heuristic — the agent uses the full slice.
+  const words = (task || "").split(/\s+/).filter(Boolean);
+  const targetHint = words.find((w) => w.includes("/") || w.includes(".") || w.includes("#")) || words[0] || "";
+  if (!targetHint || targetHint.length < 2) return null;
+
+  const r = await runCli(
+    projectDir,
+    "graph",
+    ["blast-radius", targetHint],
+    "gsd-t-graph-query-cli.cjs",
+    "graph-blast-radius",
+    true,
+    phaseName
+  ).catch(() => ({ ok: false, exitCode: -1, envelope: null }));
+
+  const env = r && r.envelope;
+  if (!env) return null;
+  if (!env.ok && env.reason === "graph-unavailable") {
+    log(`M94-D11 READER: graph unavailable — fix it (gsd-t graph status). Quick proceeds without structural slice.`);
+    return null; // Fail-loud logged; no grep fallback [RULE consumer-structural-grep-removed]
+  }
+  if (env.ok && Array.isArray(env.results)) {
+    return `## Graph structural slice (blast-radius for "${targetHint}"):\n${JSON.stringify(env.results.slice(0, 20), null, 2)}`;
+  }
+  return null;
+}
+
+// M94-D11 §WRITER: Trigger a freshness pass over the touched set after edits.
+// who-imports triggers freshness_check_on_query inline (D4 surface) — re-indexes any
+// content-hash-dirty file before answering. Best-effort (non-blocking).
+// [RULE] quick-writer-pattern
+async function reindexTouchedFilesQuick(projectDir, filesEdited, phaseName) {
+  if (!Array.isArray(filesEdited) || filesEdited.length === 0) return;
+  for (const f of filesEdited.slice(0, 10)) {
+    await runCli(
+      projectDir,
+      "graph",
+      ["who-imports", f],
+      "gsd-t-graph-query-cli.cjs",
+      `graph-reindex-touched:${f.slice(-30)}`,
+      true,
+      phaseName
+    ).catch(() => {});
+  }
+  log(`M94-D11 WRITER: re-indexed ${Math.min(filesEdited.length, 10)} touched file(s) after quick task`);
+}
+
 if (!task) {
   log("quick: args.task required");
   return { status: "failed", reason: "no-task" };
@@ -176,11 +229,16 @@ const pre = await runPreflight(projectDir);
 if (!pre.ok) return { status: "failed", reason: "preflight-failed", preflight: pre.envelope };
 const brief = await generateBrief(projectDir, { kind: "execute", id: "quick-brief" });
 
+// M94-D11 §READER: query graph for structural impact before the Execute agent reasons
+// [RULE] quick-writer-pattern
+const _graphSliceLine = await queryGraphForQuick(projectDir, task, "Preflight") || "";
+
 phase("Execute");
 const result = await agent(
   [
     `Quick task: ${task}`,
     `**Brief:** ${brief.briefPath || "(no brief)"}`,
+    _graphSliceLine ? `\n**Graph structural slice (M94-D11 READER — blast-radius impact):**\n${_graphSliceLine}\nUse this slice for structural impact assessment — do NOT grep for import/dependency relationships.` : "",
     ``,
     `**CRUX-FIRST — START HERE (smallest change is the default, ceremony is opt-in):**`,
     `1. CRUX: state the crux of this ask in ONE line — the single thing that must become true.`,
@@ -213,6 +271,12 @@ if (result.status === "failed" || result.status === "blocked") {
   return { status: result.status, result };
 }
 
+// M94-D11 §WRITER: re-index touched files after edits land (freshness trigger).
+// [RULE] quick-writer-pattern
+if (Array.isArray(result.filesEdited) && result.filesEdited.length > 0) {
+  await reindexTouchedFilesQuick(projectDir, result.filesEdited, "Execute");
+}
+
 // ── M89 Research Phase — Stated-Claims→classify→cite (§6.5/§1/§2/§3/§4/§7) ──
 phase("Research");
 const guessedClaims = [];

package/templates/workflows/gsd-t-scan.workflow.js

@@ -19,7 +19,10 @@
 //   agents: living docs + 5 dimension files + plain-english) → render(agent: HTML).
 //
 // args shape:
-//   { projectDir: ".", scanNumber?: 13, verify?: "single"|"none" }
+//   { projectDir: ".", scanNumber?: 13, verify?: "single"|"none", graphMode?: "wired"|"disabled" }
+//   graphMode:
+//     "wired"    (default) — build index if absent, query structural slice, inject into scanSlice agents
+//     "disabled" — skip all graph calls (the no-graph baseline for AC-4 INSIGHT-delta comparison)
 //   (no slice cap — the probe's cohesive-sub-domain decomposition is the slice set.)
 
 export const meta = {
@@ -27,10 +30,11 @@ export const meta = {
   description:
     "GSD-T scan (runtime-native): preflight → volume-probe → pipeline(deep-finder per slice → single verify) → synthesis(archive+register) → document(living docs + 5 dimension files + plain-english) → render. Orchestrator does NO fs/require; all I/O is inside subagents. Fans out by codebase volume.",
   phases: [
-    { title: "Preflight",  detail: "branch + prior-register check (agent via Bash)" },
-    { title: "Probe",      detail: "volume probe → per-area slice list", model: "sonnet" },
-    { title: "Deep Scan",  detail: "pipeline: per-slice deep finder → single verify" },
-    { title: "Synthesis",  detail: "archive prior + write fresh register + git", model: "opus" },
+    { title: "Preflight",     detail: "branch + prior-register check (agent via Bash)" },
+    { title: "Probe",         detail: "volume probe → per-area slice list", model: "sonnet" },
+    { title: "Graph-Wiring",  detail: "M94-D6: build index if absent + query structural slice (dead-code/dangling/cluster) → inject into finders ADDITIVELY; fallback announced on graph-unavailable", model: "haiku" },
+    { title: "Deep Scan",     detail: "pipeline: per-slice deep finder (graph-augmented when wired) → single verify" },
+    { title: "Synthesis",     detail: "archive prior + write fresh register + git", model: "opus" },
     { title: "Document",      detail: "living docs + 5 dimension files (per-doc fan-out)" },
     { title: "Plain-English", detail: "non-technical companion: batched gen + severity-grouped chunked write" },
   ],
@@ -48,6 +52,9 @@ const projectDir    = _args.projectDir || ".";
 const scanNumber    = _args.scanNumber || null;
 const verifyMode    = _args.verify || "single"; // "single" | "none"
 const maxSlicesOverride = _args.maxSlicesHint || null; // optional power-user ceiling override
+// M94-D6: graph wiring — "wired" (default) or "disabled" (no-graph baseline for AC-4).
+// [RULE] scan-injects-structural-slice / [RULE] no-graph-baseline-proven-graph-free
+const graphMode     = (_args.graphMode === "disabled") ? "disabled" : "wired";
 
 // VOLUME-DERIVED CAP — a RUNAWAY BACKSTOP, not the target count. The probe decides
 // the actual slice count by cohesive sub-domain WITHIN this cap; the cap only fires
@@ -181,8 +188,81 @@ const RENDER_SCHEMA = {
   },
 };
 
+// M94-D6: Graph-wiring schemas (additive — consumed only when graphMode === "wired").
+// The structural slice the D5 CLI returns; injected into scanSlice finder agents.
+// [RULE] scan-injects-structural-slice / [RULE] scan-slice-consumed
+const GRAPH_STATUS_SCHEMA = {
+  type: "object",
+  required: ["ok"],
+  additionalProperties: true,
+  properties: {
+    ok:     { type: "boolean" },
+    reason: { type: "string" },
+    // ok=true fields (from graph-query-cli-contract §status verb):
+    storeExists: { type: "boolean" },
+    notes:       { type: "string" },
+  },
+};
+
+const GRAPH_BUILD_SCHEMA = {
+  type: "object",
+  required: ["ok"],
+  additionalProperties: true,
+  properties: {
+    ok:    { type: "boolean" },
+    notes: { type: "string" },
+  },
+};
+
+const GRAPH_SLICE_SCHEMA = {
+  type: "object",
+  required: ["ok"],
+  additionalProperties: true,
+  properties: {
+    ok:       { type: "boolean" },
+    reason:   { type: "string" },
+    deadCode: { type: "array", items: { type: "object" }, description: "dead-code verb results" },
+    dangling: { type: "array", items: { type: "object" }, description: "dangling verb results" },
+    clusters: { type: "array", items: { type: "object" }, description: "cluster verb results" },
+    coverage: { type: "object", description: "coverage envelope from the query" },
+    notes:    { type: "string" },
+  },
+};
+
 // ───── Script body — orchestration only, ZERO file I/O here ─────────────────
 
+// M94-D6: structuralSlice — the pre-computed structural findings from the D5 CLI.
+// Populated by the Graph-Wiring phase (after Probe, before Deep Scan) when graphMode==="wired".
+// Null when graphMode==="disabled" (no-graph baseline) or graph-unavailable (fallback).
+// [RULE] scan-injects-structural-slice / [RULE] no-graph-baseline-proven-graph-free
+let structuralSlice = null;   // { deadCode, dangling, clusters, coverage, tier } | null
+let graphWiringMode = "pending"; // "wired" | "fallback-announced" | "disabled"
+
+// M94-D6: runCli — inline async helper that delegates CLI calls to an agent() Bash.
+// M81 invariant: NO require/fs/child_process in the orchestrator body.
+// This is the ONLY way to invoke the D5 query CLI from the sandbox.
+// [RULE] no-graph-baseline-proven-graph-free — this helper is called ONLY when graphMode==="wired".
+async function runCli(verb, target, label) {
+  const targetArg = target ? ` ${JSON.stringify(target)}` : "";
+  const cmd = `node bin/gsd-t-graph-query-cli.cjs ${verb}${targetArg} 2>/dev/null || echo '{"ok":false,"reason":"graph-unavailable"}'`;
+  const result = await agent(
+    [
+      `Run the following command in \`${projectDir}\` via Bash and return ONLY the raw JSON line it prints (no commentary):`,
+      `\`\`\`bash`,
+      `cd ${JSON.stringify(projectDir)} && ${cmd}`,
+      `\`\`\``,
+      `If the command fails or prints no JSON, return: {"ok":false,"reason":"graph-unavailable"}`,
+      `Return ONLY the JSON, nothing else.`,
+    ].join("\n"),
+    { label: `graph:${label || verb}`, phase: "Graph-Wiring", model: "haiku" }
+  ).catch(() => null);
+  try {
+    return (typeof result === "string") ? JSON.parse(result.trim()) : (result || { ok: false, reason: "graph-unavailable" });
+  } catch (_) {
+    return { ok: false, reason: "graph-unavailable" };
+  }
+}
+
 // Preflight: an agent checks branch + whether a prior register exists, via Bash.
 // (No fs in the body — that was the bug.)
 phase("Preflight");
@@ -242,6 +322,62 @@ if (rawSlices.length > sliceCap) {
 }
 log(`probe derived ${rawSlices.length} slice(s); backstop cap=${computedCap}; running ${slices.length} deep-finder(s); totals=${JSON.stringify(probe.totals)}`);
 
+// M94-D6: Graph-Wiring phase — ADDITIVE injection of the pre-computed structural slice.
+// Current scan architecture is KEPT FULLY INTACT (Destructive Action Guard).
+// [RULE] scan-injects-structural-slice / [RULE] no-graph-baseline-proven-graph-free
+phase("Graph-Wiring");
+if (graphMode === "disabled") {
+  // No-graph baseline mode (AC-4 INSIGHT-delta measurement).
+  // ZERO graph calls in this path — [RULE] no-graph-baseline-proven-graph-free.
+  graphWiringMode = "disabled";
+  log("graph-wiring: DISABLED (no-graph baseline mode — graph-query call-count == 0; AC-4 baseline)");
+} else {
+  // graphMode === "wired": build index if absent, then query structural slice.
+  // Step 1: check if index exists and is queryable.
+  const statusResult = await runCli("status", null, "status");
+  if (!statusResult || !statusResult.ok) {
+    // Graph unavailable — announce fallback, continue with intact grep-mode scan.
+    // [RULE] parser-fail-disables-loud-never-silent (from graph-query-cli-contract)
+    graphWiringMode = "fallback-announced";
+    log(`⚠ GRAPH-FALLBACK (ANNOUNCED): graph index not available (${(statusResult && statusResult.reason) || "graph-unavailable"}) — scan continues in full grep-mode (today's architecture, intact). Structural findings from LLM reconstruction only. Build the index (gsd-t graph build) to enable graph-wired accuracy.`);
+  } else {
+    // Step 2: query the structural slice (dead-code + dangling + clusters).
+    // These are the findings the deep-finders currently reconstruct by reading files (error-prone);
+    // the graph hands them over pre-computed and ACCURATE.
+    const [deadCodeResult, danglingResult, clusterResult] = await parallel([
+      () => runCli("dead-code", null, "dead-code"),
+      () => runCli("dangling",  null, "dangling"),
+      () => runCli("cluster",   null, "cluster"),
+    ]);
+
+    const allOk = (deadCodeResult && deadCodeResult.ok) ||
+                  (danglingResult && danglingResult.ok) ||
+                  (clusterResult  && clusterResult.ok);
+
+    if (!allOk) {
+      // All three verbs returned graph-unavailable — announce fallback.
+      graphWiringMode = "fallback-announced";
+      log(`⚠ GRAPH-FALLBACK (ANNOUNCED): all structural-slice queries returned graph-unavailable — scan continues in full grep-mode. Dead-code / dangling / cluster findings from LLM reconstruction only.`);
+    } else {
+      // Structural slice assembled — will be injected into scanSlice finder agents.
+      structuralSlice = {
+        deadCode: (deadCodeResult && deadCodeResult.ok && deadCodeResult.results) || [],
+        dangling: (danglingResult && danglingResult.ok && danglingResult.results) || [],
+        clusters: (clusterResult  && clusterResult.ok  && clusterResult.results)  || [],
+        // Coverage envelopes: any incomplete coverage is surfaced to finders.
+        coverage: {
+          deadCode: (deadCodeResult && deadCodeResult.coverage) || null,
+          dangling: (danglingResult && danglingResult.coverage) || null,
+          cluster:  (clusterResult  && clusterResult.coverage)  || null,
+        },
+        tier: (deadCodeResult && deadCodeResult.tier) || (danglingResult && danglingResult.tier) || "unknown",
+      };
+      graphWiringMode = "wired";
+      log(`graph-wiring: WIRED — structural slice ready (dead-code: ${structuralSlice.deadCode.length} candidates, dangling: ${structuralSlice.dangling.length} edges, clusters: ${structuralSlice.clusters.length} groups, tier: ${structuralSlice.tier}). Slice will be INJECTED ADDITIVELY into scanSlice deep-finders. [RULE] scan-injects-structural-slice`);
+    }
+  }
+}
+
 const deep = budget && budget.total && budget.total > 300000 ? "MAXIMUM" : "thorough";
 
 // Deep scan — pipeline: per-slice deep finder → single verify (no barrier).
@@ -252,13 +388,54 @@ phase("Deep Scan");
 // coverage as complete (7/19 slices dropped this way on the Hilo run). So: (1) the
 // finder call is RETRIED once on a null/invalid result; (2) a slice that still fails
 // is flagged `failed:true` and tracked — never conflated with a genuinely-empty slice.
-function finderPrompt(slice) {
+//
+// M94-D6: finderPrompt accepts an optional graphSliceContext string — the pre-computed
+// structural slice from the D5 CLI, INJECTED ADDITIVELY so the finder reasons over
+// accurate, deterministic structure rather than LLM-reconstructing relationships by reading.
+// [RULE] scan-injects-structural-slice / [RULE] scan-slice-consumed
+function finderPrompt(slice, graphSliceContext) {
   return [
     `⛔ Scan ONLY files under the absolute project path \`${projectDir}\`. \`cd ${projectDir}\` first; never read outside this tree.`,
     `You are a DEEP tech-debt finder for ONE slice of a scan of \`${projectDir}\`: \`${slice.key}\` (dimension: ${slice.dimension}).`,
     `Owned paths (relative to \`${projectDir}\`): ${JSON.stringify(slice.paths)}.`,
     slice.why ? `Why this slice matters: ${slice.why}` : ``,
     ``,
+    // M94-D6: graph structural slice — ADDITIVE injection block.
+    // Present only when graphMode==="wired" AND the slice was fetched.
+    // The finder MUST use this data to answer structural questions — do NOT re-read
+    // the graph from files (that is error-prone reconstruction; this is accurate).
+    // [RULE] scan-injects-structural-slice / [RULE] scan-slice-consumed
+    graphSliceContext ? [
+      `## Pre-computed Structural Slice (GRAPH-WIRED — use this for structural findings)`,
+      ``,
+      `The following structural data has been PRE-COMPUTED from the deterministic dependency graph`,
+      `(D5 query CLI — ${graphSliceContext.tier || "unknown"} tier). Use this data DIRECTLY for dead-code,`,
+      `cycle, dangling-reference, and coupling findings — do NOT reconstruct these from file reads`,
+      `(the graph is more accurate). This is ADDITIVE: you still read files for in-file logic defects.`,
+      ``,
+      `**Dead-code candidates** (functions/files with no inbound edges from the graph):`,
+      graphSliceContext.deadCode && graphSliceContext.deadCode.length > 0
+        ? "```json\n" + JSON.stringify(graphSliceContext.deadCode.slice(0, 50), null, 1) + "\n```"
+        : "(none — all indexed symbols have inbound edges, OR the index has incomplete coverage)",
+      graphSliceContext.coverage && graphSliceContext.coverage.deadCode && graphSliceContext.coverage.deadCode.complete === false
+        ? `⚠ Dead-code coverage incomplete (${graphSliceContext.coverage.deadCode.unparsedContributors || "?"} file(s) unparsed — result may be partial).`
+        : "",
+      ``,
+      `**Dangling references** (call/import edges to missing nodes — delete/rename residue):`,
+      graphSliceContext.dangling && graphSliceContext.dangling.length > 0
+        ? "```json\n" + JSON.stringify(graphSliceContext.dangling.slice(0, 30), null, 1) + "\n```"
+        : "(none found)",
+      ``,
+      `**Tightly-coupled file clusters** (may indicate coupling/cycle debt):`,
+      graphSliceContext.clusters && graphSliceContext.clusters.length > 0
+        ? "```json\n" + JSON.stringify(graphSliceContext.clusters.slice(0, 20), null, 1) + "\n```"
+        : "(none found — no file groups above the coupling threshold)",
+      ``,
+      `When you report a dead-code / dangling / coupling finding, CITE the graph data above`,
+      `(e.g. "funcId: X has no inbound call edges per the graph") so the finding is traceable`,
+      `to the pre-computed query result. [RULE] scan-insight-delta-graph-attributed`,
+    ].filter(Boolean).join("\n") : "",
+    ``,
     `MANDATE: ENUMERATE, do NOT sample. Read EVERY file under your owned paths (use Read/Grep). You own only this slice, so go to the bottom of it.`,
     `Depth = ${deep}. "thorough" = every file, every non-trivial real defect (high+medium confidence). "MAXIMUM" = also lower-confidence/speculative items worth review.`,
     `Surface: bugs, security holes, missing validation, broken invariants, race conditions, dead/duplicated code, N+1s, untested critical paths, contract drift, domain-specific correctness (money math, state-machine gaps, timezone bugs, idempotency holes).`,
@@ -351,11 +528,12 @@ async function gatedAgent(prompt, opts) {
 // but setTimeout is not). Used only for rate-limit backoff between retries.
 function sleep(ms) { return new Promise((res) => setTimeout(res, ms)); }
 
-async function runFinder(slice) {
+async function runFinder(slice, graphSliceContext) {
   // up to 2 attempts; a null/invalid (non-array findings) result counts as a drop.
+  // M94-D6: graphSliceContext passed through to finderPrompt for ADDITIVE injection.
   for (let attempt = 1; attempt <= 2; attempt++) {
     try {
-      const r = await gatedAgent(finderPrompt(slice), {
+      const r = await gatedAgent(finderPrompt(slice, graphSliceContext), {
         label: attempt === 1 ? `find:${slice.key}` : `find:${slice.key} (retry)`,
         phase: "Deep Scan", schema: FINDER_SCHEMA, model: "sonnet",
       });
@@ -370,7 +548,11 @@ async function runFinder(slice) {
 
 async function scanSlice(slice) {
   const sliceKey = slice.key || "unknown-slice";
-  const finderResult = await runFinder(slice);
+  // M94-D6: inject the structural slice context ADDITIVELY — only when graph is wired.
+  // When graphMode==="disabled" OR graph-unavailable, graphSliceContext is null (no injection).
+  // [RULE] scan-injects-structural-slice / [RULE] no-graph-baseline-proven-graph-free
+  const graphSliceContext = (graphWiringMode === "wired" && structuralSlice) ? structuralSlice : null;
+  const finderResult = await runFinder(slice, graphSliceContext);
   // M72: distinguish a FAILED finder (null after retries) from a genuinely-clean slice.
   if (!finderResult || !Array.isArray(finderResult.findings)) {
     return { slice: sliceKey, findings: [], failed: true };
@@ -824,4 +1006,13 @@ return {
   plainEnglishComplete: peComplete,
   htmlReport: null, // render stage removed (M71)
   probeTotals: probe.totals,
+  // M94-D6: graph wiring status (surfaced for AC-4 INSIGHT-delta comparison).
+  // [RULE] scan-injects-structural-slice / [RULE] no-graph-baseline-proven-graph-free
+  graphWiring: {
+    mode: graphWiringMode,  // "wired" | "fallback-announced" | "disabled"
+    structuralSlicePresent: structuralSlice !== null,
+    deadCodeCount: (structuralSlice && structuralSlice.deadCode) ? structuralSlice.deadCode.length : 0,
+    danglingCount: (structuralSlice && structuralSlice.dangling) ? structuralSlice.dangling.length : 0,
+    clusterCount:  (structuralSlice && structuralSlice.clusters) ? structuralSlice.clusters.length : 0,
+  },
 };

package/templates/workflows/gsd-t-verify.workflow.js

@@ -257,6 +257,49 @@ if (!vg.ok) {
 }
 log(`verify-gate green`);
 
+// ─── M94-D10-T5: Graph Structural Slice — dead-code + dangling (ADDITIVE, announced-degradation) ──
+// [RULE] qa-verify-use-orphan-dangling-verbs — query dead-code + dangling structurally.
+// [RULE] verify-integrate-graph-additive-announced-not-hard-fail — PRE-MORTEM Finding 3
+//   bootstrap carve-out: verify degrades ANNOUNCED on graph-unavailable, does NOT hard-fail.
+//   The graph query ENRICHES the triad; it must not brick verify itself.
+// Runtime-native (M81): delegate to an agent's Bash via runCli helper.
+let _graphDeadCodeSlice = null;
+let _graphDanglingSlice = null;
+let _graphVerifyWarning = null;
+
+{
+  const dcResult = await runCli(
+    projectDir, "graph dead-code", [], "gsd-t-graph-query-cli.cjs",
+    "graph:dead-code", true, "Verify-Gate"
+  );
+  const dcEnv = dcResult.envelope || {};
+  if (dcEnv.ok === true) {
+    _graphDeadCodeSlice = dcEnv;
+    log(`M94 graph dead-code: ${(dcEnv.results || []).length} dead-code result(s) (tier: ${dcEnv.tier || "?"})`);
+  } else if (dcEnv.reason === "graph-unavailable") {
+    _graphVerifyWarning = "⚠ graph unavailable — structural gate skipped, fix it (gsd-t graph status)";
+    log(`M94 graph dead-code: ${_graphVerifyWarning}`);
+  } else {
+    _graphVerifyWarning = `⚠ graph dead-code query unexpected envelope (reason: ${dcEnv.reason || "?"}); structural gate skipped`;
+    log(`M94 graph dead-code: ${_graphVerifyWarning}`);
+  }
+
+  if (!_graphVerifyWarning) {
+    // Only query dangling if dead-code succeeded (same graph availability)
+    const dangResult = await runCli(
+      projectDir, "graph dangling", [], "gsd-t-graph-query-cli.cjs",
+      "graph:dangling", true, "Verify-Gate"
+    );
+    const dangEnv = dangResult.envelope || {};
+    if (dangEnv.ok === true) {
+      _graphDanglingSlice = dangEnv;
+      log(`M94 graph dangling: ${(dangEnv.results || []).length} dangling result(s)`);
+    } else {
+      log(`M94 graph dangling: query failed (reason: ${dangEnv.reason || "?"}) — no dangling slice`);
+    }
+  }
+}
+
 // ─── M89 §7 ENFORCE Gate (FAIL-blocking — A4 no-silent-guess) ─────────────
 // Scans all milestone artifacts for STRUCTURAL auto-research-claim markers and FAILs if:
 //   (a) ANY marker is status=uncited (an external guessed claim was never cited), OR
@@ -698,6 +741,12 @@ const stages = [
       `You are the QA validator for milestone \`${milestone}\`.`,
       ``,
       `**Brief (REQUIRED):** ${briefRef}`,
+      // M94-D10-T5: inject dead-code/dangling graph slice (ADDITIVE — enriches QA, announced-degradation on unavailable)
+      _graphVerifyWarning
+        ? `\n**Graph Structural Gate:** ${_graphVerifyWarning} (WARNING only — QA continues other checks)`
+        : (_graphDeadCodeSlice
+          ? `\n**Graph Structural Slice (dead-code):** ${JSON.stringify(_graphDeadCodeSlice)}\n**Graph Structural Slice (dangling):** ${_graphDanglingSlice ? JSON.stringify(_graphDanglingSlice) : "N/A"}\nInclude these structural findings in your QA analysis — dead-code and dangling-ref entries are structural quality signals. Do NOT grep for dead-code; the pre-computed slice above is authoritative.`
+          : ""),
       ``,
       `Per .gsd-t/contracts/orthogonal-validation-contract.md, your scope is`,
       `**test mechanics + contract compliance**. Run the test suite. Report pass/fail/skip`,
@@ -707,7 +756,7 @@ const stages = [
       `Run the QA protocol. ${qaProtocolInstruction}`,
       ``,
       `Return JSON per the schema.`,
-    ].join("\n"),
+    ].filter(Boolean).join("\n"),
     { label: "qa", phase: "Orthogonal Triad", schema: QA_SCHEMA, model: "sonnet" }
   ),
 ].filter(Boolean);