@tekyzinc/gsd-t 5.11.26 → 5.11.28

package/CHANGELOG.md

@@ -2,6 +2,75 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.11.28] - 2026-08-11
+
+### Fixed — the graph stored the alias edges, then could not find them (two bugs)
+
+`who-imports src/lib/db.ts` returned 5 importers on hilo-figma-atos.
+`grep -rl '@/lib/db' src` returned 793. Found by David, who halted the scan
+rather than running it on a graph that was answering wrongly.
+
+v5.11.26 taught the INDEXER to expand `@/lib/db` into `src/lib/db`, and it does
+— the edges are in the database, correctly. It never met the QUERY side, which
+is what turns `src/lib/db` into the real file id `src/lib/db.ts`. Two
+independent bugs there, and fixing either alone still returns nothing:
+
+1. The resolver opened with `if (!dst.startsWith(".")) return dst` — an expanded
+   alias has no leading dot, so it was classed as an external package like
+   "react" and returned untouched. The extension was never appended.
+2. The set of known files was built from FUNCTION nodes, so a module exporting
+   only constants, types, or re-exports was not in it. Atos's `src/lib/db.ts`
+   exports a constant. The indexer already records every file it walked in the
+   `files` table — the authoritative list was stored all along.
+
+- `bin/gsd-t-graph-query-cli.cjs`: resolve non-relative targets against the file
+  set (packages still pass through untouched, and an expanded alias is NOT
+  re-joined to the importer's directory); read the file set from the `files`
+  table, announcing the degradation on an older graph that lacks it.
+- `test/m112-alias-query-resolution.test.js`: 7 regressions, all going through
+  the QUERY rather than the stored edge.
+
+Every v5.11.26 test asserted the edge was STORED correctly. Not one asked
+whether it could then be FOUND — the feature was tested at the write and called
+done. These tests close that gap.
+
+Requires `gsd-t graph index` only if the graph predates the `files` table;
+otherwise the fix applies to existing indexes immediately.
+
+## [5.11.27] - 2026-08-11
+
+### Fixed — the scan's volume probe returned a stand-in, and the whole run was built on it
+
+HiloAviation, this morning. The probe answered `totals: {"trackedFiles": 5036}`
+and `slices: [{"key": "test", "paths": ["src/"]}]` — one slice for a 4,900-file
+application, keyed "test", and none of the six measurements the prompt asked for.
+The schema accepted it (one slice is legal, `totals` takes any object), so the
+scan read that single slice, produced 3 findings, and headed the register
+"Coverage: FULL".
+
+The probe had no retry. Every finder gets re-run when it answers `{"findings":[]}`;
+the probe — which decides what every finder will ever look at — got one call, and
+whatever came back became the plan.
+
+The tell is not the slice count; a small repo really is one slice. It is that the
+fields explicitly requested are absent: the shape of an answer with none of the
+work behind it. So the result is now inspected before it is trusted, retried on
+opus with the fault named, and a second stand-in HALTS the scan rather than
+scanning it — a register that under-counts while claiming full coverage is worse
+than no register.
+
+- `templates/workflows/gsd-t-scan.workflow.js`: `probePlaceholderFaults()` +
+  retry-on-opus + halt; the prompt is now a reusable constant so the retry sends
+  the same task; the slice count and totals are logged at probe time, so a thin
+  plan is visible before the run rather than inferred afterwards from a thin
+  register.
+- `test/m112-probe-placeholder.test.js`: 11 regressions, including the verbatim
+  payload that produced the 3-finding scan.
+
+The whole-tree tell only fires when the measurements are missing too. A small
+project genuinely is one slice covering `src/`, and halting that scan would be a
+false alarm on every small repo — worse than the bug being fixed.
+
 ## [5.11.26] - 2026-08-11
 
 ### Fixed — a quarter of every import edge pointed at a string no file matched

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v5.11.26** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
+**v5.11.28** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
 
 **Eliminates context rot** — task-level fresh dispatch (one subagent per task, ~10-20% context each) means compaction never triggers.
 **Compaction-proof debug loops** — `gsd-t headless --debug-loop` runs test-fix-retest cycles as separate `claude -p` sessions. A JSONL debug ledger persists all hypothesis/fix/learning history across fresh sessions. Anti-repetition preamble injection prevents retrying failed hypotheses. Escalation tiers (sonnet → opus → human) and a hard iteration ceiling enforced externally.

package/bin/gsd-t-graph-query-cli.cjs

@@ -437,10 +437,68 @@ function loadSqliteStore(dbPath) {
     // TS/JS routinely omit the extension; the graph keys on real file ids.
     // Every indexed file appears as the `file` of its nodes (the indexer does not
     // emit dedicated FILE nodes), so collect the distinct file set from there.
-    const fileIds = new Set(nodes.map((n) => norm(n.file)).filter(Boolean));
+    // [RULE] query-file-set-comes-from-files-table-not-inferred-from-functions
+    //
+    // hilo-figma-atos, 2026-08-11, the second half of the same miss. This set
+    // decides whether an extensionless import target can be matched to a real
+    // file. Built from node rows, it contains only files that declare a
+    // FUNCTION — so `src/lib/db.ts`, which exports a constant, was not in it,
+    // and no query could ever resolve an import of it. A file of constants,
+    // types, or re-exports is exactly the kind of shared module a whole codebase
+    // imports, and it was invisible.
+    //
+    // The indexer records every file it walked in the `files` table. That is the
+    // authoritative list; inferring one from functions was always an
+    // approximation of a fact already stored.
+    let fileIds;
+    const hasFilesTable = db
+      .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='files'")
+      .get();
+    if (hasFilesTable) {
+      fileIds = new Set(
+        db.prepare("SELECT file FROM files").all().map((r) => norm(r.file)).filter(Boolean)
+      );
+    } else {
+      // A graph built before the files table existed. Node-derived is what this
+      // has always done — announced, because it under-reports imports of any
+      // file that declares no function.
+      fileIds = new Set(nodes.map((n) => norm(n.file)).filter(Boolean));
+      process.stderr.write(
+        "[graph] this index predates the files table — imports of constant-only/type-only files may be missed; re-run `gsd-t graph index`\n"
+      );
+    }
     const EXTS = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", "/index.ts", "/index.tsx", "/index.js"];
+    // [RULE] query-resolves-expanded-alias-not-only-relative
+    //
+    // hilo-figma-atos, 2026-08-11: `who-imports src/lib/db.ts` returned 5 of 793
+    // real importers. The 788 missing ones all wrote `@/lib/db`.
+    //
+    // The two halves of the alias fix did not meet. The indexer (v5.11.26)
+    // expands `@/lib/db` to `src/lib/db` — correct, and stored. But this
+    // resolver, which is what appends the file extension, skipped it: the gate
+    // below returned early for anything not starting with ".", treating an
+    // expanded project path exactly like the package import `react`. So the edge
+    // sat in the database as `src/lib/db` while the query asked for
+    // `src/lib/db.ts`, and the two never met.
+    //
+    // A relative specifier is resolved against its source file's directory; an
+    // expanded alias is ALREADY project-relative and must not be — joining it to
+    // the importer's directory would produce `src/app/src/lib/db`. So the two
+    // take different routes to the same place: add the extension either way.
     const resolveDst = (srcFile, dst) => {
-      if (typeof dst !== "string" || !dst.startsWith(".")) return dst; // package/external
+      if (typeof dst !== "string" || !dst) return dst;
+
+      if (!dst.startsWith(".")) {
+        // Not relative. Either a package ("react", "next/navigation") or an
+        // alias the indexer already expanded to a project path. The file set is
+        // what tells them apart — a package matches nothing in it.
+        const base = norm(dst);
+        for (const ext of EXTS) {
+          if (fileIds.has(base + ext)) return base + ext;
+        }
+        return dst; // genuinely external — keep it exactly as written
+      }
+
       const base = path.posix.normalize(path.posix.join(path.posix.dirname(norm(srcFile)), norm(dst)));
       // Prefer an actual indexed file id (try the bare path, then common extensions).
       for (const ext of EXTS) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.11.26",
+  "version": "5.11.28",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 54 slash commands with headless-by-default workflow spawning, unattended supervisor relay with event stream, graph-powered code analysis, real-time agent dashboard, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",

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

@@ -399,7 +399,7 @@ log(`preflight ok — branch=${pre.branch}, repo=${repoName}, priorRegister=${pr
 
 // Volume probe — an agent measures the codebase (its own Bash) and carves slices.
 phase("Probe");
-const probe = await agent(
+const PROBE_PROMPT =
   [
     `⛔ TARGET DIRECTORY IS FIXED: you MUST scan ONLY the project at the absolute path \`${projectDir}\`. Before any measurement, \`cd ${projectDir}\` (or pass that exact path to every Read/Grep/Bash). Do NOT scan your current working directory, the GSD-T package, or any other tree — every file you measure and every slice path you emit MUST be under \`${projectDir}\`. If \`${projectDir}\` does not exist or is empty, return a single slice noting that.`,
     ``,
@@ -437,14 +437,116 @@ const probe = await agent(
     ``,
     `Measure with real tooling and report in \`totals\`: files, loc, routes, tables, components, featureDomains (distinct business/feature areas). Read \`${projectDir}/package.json\` for the stack. Return JSON per the schema: totals + slices.`,
     SHAPE_RULE,
-  ].join("\n"),
-  { label: "volume-probe", phase: "Probe", schema: PROBE_SCHEMA, model: "sonnet" }
-);
+  ].join("\n");
+
+// Did the probe MEASURE the codebase, or return something shaped like an answer?
+//
+// [RULE] probe-placeholder-is-rejected-not-scanned
+//
+// HiloAviation, 2026-08-11. The probe returned:
+//
+//     totals : {"trackedFiles": 5036}
+//     slices : [{"key": "test", "paths": ["src/"]}]
+//
+// One slice for a 4,900-file application, keyed "test", and a totals object
+// carrying none of the six numbers the prompt asked for. The schema accepted it
+// — one slice is legal, and totals takes any object — so the scan ran that one
+// slice, found 3 findings, and the register's header read "Coverage: FULL".
+//
+// The tell is not the slice count. It is that the fields explicitly named in the
+// prompt are simply absent: the agent produced the SHAPE of an answer without
+// doing the work, the same instinct that sends `{"findings":[]}` through a
+// finder. So the probe result is inspected before it is trusted, and a probe
+// that did not measure is retried on a stronger model rather than scanned.
+function probePlaceholderFaults(result) {
+  const faults = [];
+  const totals = (result && result.totals) || {};
+  const slices = (result && Array.isArray(result.slices) && result.slices) || [];
+
+  // Every number the prompt asks for by name. None present means the agent
+  // reported whatever it had to hand instead of measuring.
+  const asked = ["files", "loc", "routes", "tables", "components", "featureDomains"];
+  const present = asked.filter((k) => totals[k] !== undefined && totals[k] !== null);
+  if (present.length === 0) {
+    faults.push(
+      `totals contains none of the six requested measurements (${asked.join(", ")}) — it holds ` +
+      `${JSON.stringify(totals).slice(0, 160)}`
+    );
+  }
+
+  // A single slice whose path is the whole source tree has decomposed nothing —
+  // but ONLY when the totals are missing too. A small repo genuinely is one
+  // slice covering src/, and halting that scan would be a false alarm on every
+  // small project. What separates the two is whether the agent measured: a real
+  // probe reports the numbers AND explains the single slice. Both tells together
+  // are one judgment, not two independent ones.
+  const WHOLE_TREE = new Set([".", "./", "*", "src", "src/", "./src", "./src/", projectDir]);
+  if (slices.length === 1 && present.length === 0) {
+    const paths = Array.isArray(slices[0].paths) ? slices[0].paths : [];
+    if (paths.length && paths.every((p) => WHOLE_TREE.has(String(p).trim().replace(/\/+$/, "/")) || WHOLE_TREE.has(String(p).trim()))) {
+      faults.push(
+        `the one slice "${slices[0].key}" owns the entire source tree (${JSON.stringify(paths)}) — ` +
+        `that is not a decomposition`
+      );
+    }
+  }
+
+  return faults;
+}
+
+let probe = await agent(PROBE_PROMPT, {
+  label: "volume-probe", phase: "Probe", schema: PROBE_SCHEMA, model: "sonnet",
+});
+
+let probeFaults = probePlaceholderFaults(probe);
+if (probeFaults.length) {
+  log(`⚠ PROBE DID NOT MEASURE — the answer has the right shape but not the work behind it:`);
+  for (const f of probeFaults) log(`   · ${f}`);
+  log(`   retrying on opus with the fault named.`);
+
+  const retry = await agent(
+    [
+      PROBE_PROMPT,
+      ``,
+      `!! A PREVIOUS ATTEMPT AT THIS EXACT TASK WAS REJECTED. What was wrong with it:`,
+      ...probeFaults.map((f) => `   · ${f}`),
+      ``,
+      `RUN THE MEASUREMENTS. Do not answer from a guess, and do not return a minimal stand-in to see whether it is accepted — it will not be.`,
+      `Count the files. Count the lines. Find the routes, the database tables, the components, and the distinct business areas. Those NUMBERS go in \`totals\`.`,
+      `Then carve the codebase into slices by business capability, one slice per real area of the product. A single slice owning the whole tree is not an answer.`,
+    ].join("\n"),
+    { label: "volume-probe (retry on opus)", phase: "Probe", schema: PROBE_SCHEMA, model: "opus" }
+  );
+
+  const retryFaults = probePlaceholderFaults(retry);
+  if (retry && Array.isArray(retry.slices) && retry.slices.length && retryFaults.length === 0) {
+    log(`✓ probe recovered on opus — ${retry.slices.length} slice(s), totals=${JSON.stringify(retry.totals)}`);
+    probe = retry;
+  } else {
+    // Both attempts produced a stand-in. Scanning it would read a fraction of the
+    // codebase and print "Coverage: FULL" over the result — a register that lies
+    // is worse than no register.
+    log(`✗ PROBE FAILED — two attempts, neither measured the codebase.`);
+    for (const f of (retryFaults.length ? retryFaults : probeFaults)) log(`   · ${f}`);
+    return {
+      status: "failed",
+      reason: "probe-placeholder",
+      message:
+        "The probe never measured the codebase, on either attempt. Nothing was scanned: a run on this " +
+        "answer would have covered a fraction of the project while reporting full coverage.",
+      probe: retry || probe,
+    };
+  }
+}
+
 const rawSlices = (probe && Array.isArray(probe.slices) && probe.slices) || [];
 if (!rawSlices.length) {
   log("probe returned no slices — halting");
   return { status: "failed", reason: "no-slices", probe };
 }
+// What the plan actually is, before anything runs on it. A thin plan was only
+// ever visible afterwards, in a thin register.
+log(`probe: ${rawSlices.length} slice(s) — totals=${JSON.stringify(probe.totals || {})}`);
 // Did the probe slice the way it was told? A layer prefix is the tell.
 //
 // The instruction alone is not enough — a prompt is advice, and this axis flipped