gsd-pi 2.73.1 → 2.74.0-dev.0306a2e

package/src/resources/extensions/gsd/tests/uok-plan-v2-wiring.test.ts

@@ -0,0 +1,167 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+import {
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
+import type { GSDState, Phase } from "../types.ts";
+import { ensurePlanV2Graph } from "../uok/plan-v2.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const gsdDir = join(__dirname, "..");
+const MILESTONE_ID = "M001";
+const SLICE_ID = "S01";
+const TASK_ID = "T01";
+const tempDirs = new Set<string>();
+
+function createBasePath(): string {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-uok-planv2-"));
+  mkdirSync(join(basePath, ".gsd", "milestones", MILESTONE_ID), { recursive: true });
+  tempDirs.add(basePath);
+  return basePath;
+}
+
+function writeMilestoneFile(basePath: string, suffix: string, content: string): void {
+  const milestoneDir = join(basePath, ".gsd", "milestones", MILESTONE_ID);
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(milestoneDir, `${MILESTONE_ID}-${suffix}.md`), `${content}\n`, "utf-8");
+}
+
+function writeSliceFile(basePath: string, suffix: string, content: string): void {
+  const sliceDir = join(basePath, ".gsd", "milestones", MILESTONE_ID, "slices", SLICE_ID);
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(join(sliceDir, `${SLICE_ID}-${suffix}.md`), `${content}\n`, "utf-8");
+}
+
+function seedGraphRows(): void {
+  insertMilestone({ id: MILESTONE_ID, title: "Milestone", status: "active" });
+  insertSlice({
+    id: SLICE_ID,
+    milestoneId: MILESTONE_ID,
+    title: "Slice",
+    status: "in_progress",
+    sequence: 1,
+  });
+  insertTask({
+    id: TASK_ID,
+    milestoneId: MILESTONE_ID,
+    sliceId: SLICE_ID,
+    title: "Task",
+    status: "pending",
+    keyFiles: ["src/task.ts"],
+    sequence: 1,
+  });
+}
+
+function buildState(phase: Phase): GSDState {
+  return {
+    phase,
+    activeMilestone: { id: MILESTONE_ID, title: "Milestone" },
+    activeSlice: null,
+    activeTask: null,
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "dispatch",
+    registry: [],
+  };
+}
+
+test.beforeEach(() => {
+  closeDatabase();
+  const opened = openDatabase(":memory:");
+  assert.equal(opened, true);
+});
+
+test.afterEach(() => {
+  closeDatabase();
+  for (const path of tempDirs) {
+    rmSync(path, { recursive: true, force: true });
+  }
+  tempDirs.clear();
+});
+
+test("guided flow enforces plan-v2 gate before execution-oriented dispatch", () => {
+  const source = readFileSync(join(gsdDir, "guided-flow.ts"), "utf-8");
+  assert.ok(
+    source.includes("needsPlanV2Gate") &&
+    source.includes("ensurePlanV2Graph") &&
+    source.includes("Plan gate failed-closed"),
+    "guided flow should fail-closed when plan-v2 graph compilation fails",
+  );
+});
+
+test("plan-v2 gate fails closed for execution phase when finalized context is missing", () => {
+  const basePath = createBasePath();
+  seedGraphRows();
+
+  writeMilestoneFile(basePath, "CONTEXT-DRAFT", "Draft context only.");
+
+  const compiled = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(compiled.ok, false);
+  assert.match(compiled.reason ?? "", /CONTEXT\.md/i);
+});
+
+test("plan-v2 compiler writes pipeline metadata for clarify/research/draft stages", () => {
+  const basePath = createBasePath();
+  seedGraphRows();
+
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+  writeMilestoneFile(basePath, "CONTEXT-DRAFT", "Draft context retained.");
+  writeMilestoneFile(basePath, "RESEARCH", "Milestone research synthesis.");
+  writeSliceFile(basePath, "RESEARCH", "Slice research detail.");
+
+  const compiled = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(compiled.ok, true);
+  assert.equal(compiled.clarifyRoundLimit, 3);
+  assert.equal(compiled.researchSynthesized, true);
+  assert.equal(compiled.draftContextIncluded, true);
+  assert.equal(compiled.finalizedContextIncluded, true);
+
+  const graphPath = compiled.graphPath ?? "";
+  const graphRaw = readFileSync(graphPath, "utf-8");
+  const graph = JSON.parse(graphRaw) as {
+    pipeline?: Record<string, unknown>;
+    nodes?: unknown[];
+  };
+
+  assert.equal(graph.pipeline?.["clarifyRoundLimit"], 3);
+  assert.equal(graph.pipeline?.["researchSynthesized"], true);
+  assert.equal(graph.pipeline?.["draftContextIncluded"], true);
+  assert.equal(graph.pipeline?.["finalizedContextIncluded"], true);
+  assert.equal(Array.isArray(graph.nodes), true);
+});
+
+test("plan-v2 graph may compile during planning even without finalized context", () => {
+  const basePath = createBasePath();
+  seedGraphRows();
+
+  writeMilestoneFile(basePath, "CONTEXT-DRAFT", "Planning draft context.");
+  const compiled = ensurePlanV2Graph(basePath, buildState("planning"));
+  assert.equal(compiled.ok, true);
+});
+
+test("plan-v2 ensure rejects empty executable graph", () => {
+  const basePath = createBasePath();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  insertMilestone({ id: MILESTONE_ID, title: "Milestone", status: "active" });
+  insertSlice({
+    id: SLICE_ID,
+    milestoneId: MILESTONE_ID,
+    title: "Slice",
+    status: "pending",
+    sequence: 1,
+  });
+
+  const compiled = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(compiled.ok, false);
+  assert.match(compiled.reason ?? "", /compiled graph is empty/i);
+});

package/src/resources/extensions/gsd/tests/uok-preferences.test.ts

@@ -0,0 +1,42 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { validatePreferences } from "../preferences-validation.ts";
+
+test("uok preferences validate nested flags and turn_action", () => {
+  const input = {
+    uok: {
+      enabled: true,
+      legacy_fallback: { enabled: false },
+      gates: { enabled: true },
+      model_policy: { enabled: true },
+      execution_graph: { enabled: false },
+      gitops: {
+        enabled: true,
+        turn_action: "status-only",
+        turn_push: false,
+      },
+      audit_unified: { enabled: true },
+      plan_v2: { enabled: true },
+    },
+  };
+
+  const result = validatePreferences(input as never);
+  assert.equal(result.errors.length, 0);
+  assert.equal(result.preferences.uok?.enabled, true);
+  assert.equal(result.preferences.uok?.legacy_fallback?.enabled, false);
+  assert.equal(result.preferences.uok?.gitops?.turn_action, "status-only");
+  assert.equal(result.preferences.uok?.plan_v2?.enabled, true);
+});
+
+test("uok preferences reject invalid turn_action", () => {
+  const result = validatePreferences({
+    uok: {
+      gitops: {
+        turn_action: "push-everything",
+      },
+    },
+  } as never);
+
+  assert.ok(result.errors.some((e) => e.includes("uok.gitops.turn_action")));
+});

package/src/resources/extensions/gsd/tests/validate-milestone-stuck-guard.test.ts

@@ -0,0 +1,179 @@
+// gsd-pi — Regression tests for the validate-milestone stuck-loop guard (#4094)
+
+import { describe, test, mock, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { tmpdir } from "node:os";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+import { runPostUnitVerification, type VerificationContext } from "../auto-verification.ts";
+import { AutoSession } from "../auto/session.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+
+let tempDir: string;
+let dbPath: string;
+let originalCwd: string;
+
+function makeMockCtx() {
+  return {
+    ui: {
+      notify: mock.fn(),
+      setStatus: () => {},
+      setWidget: () => {},
+      setFooter: () => {},
+    },
+    model: { id: "test-model" },
+  } as any;
+}
+
+function makeMockPi() {
+  return {
+    sendMessage: mock.fn(),
+    setModel: mock.fn(async () => true),
+  } as any;
+}
+
+function makeMockSession(basePath: string, unitType: string, unitId: string): AutoSession {
+  const s = new AutoSession();
+  s.basePath = basePath;
+  s.active = true;
+  s.pendingVerificationRetry = null;
+  s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
+  return s;
+}
+
+function setupTestEnvironment(): void {
+  originalCwd = process.cwd();
+  tempDir = join(tmpdir(), `validate-milestone-guard-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(tempDir, { recursive: true });
+
+  const milestoneDir = join(tempDir, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+
+  process.chdir(tempDir);
+  _clearGsdRootCache();
+
+  dbPath = join(tempDir, ".gsd", "gsd.db");
+  openDatabase(dbPath);
+  invalidateAllCaches();
+}
+
+function cleanupTestEnvironment(): void {
+  try { process.chdir(originalCwd); } catch { /* ignore */ }
+  try { closeDatabase(); } catch { /* ignore */ }
+  try { rmSync(tempDir, { recursive: true, force: true }); } catch { /* ignore */ }
+}
+
+function writeValidationFile(verdict: string): void {
+  const path = join(tempDir, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+  const content = `---
+verdict: ${verdict}
+remediation_round: 1
+---
+
+# Milestone Validation: M001
+
+## Verdict Rationale
+Test fixture
+`;
+  writeFileSync(path, content, "utf-8");
+  invalidateAllCaches();
+}
+
+describe("validate-milestone stuck-loop guard (#4094)", () => {
+  beforeEach(() => setupTestEnvironment());
+  afterEach(() => cleanupTestEnvironment());
+
+  test("pauses when verdict=needs-remediation and all slices are closed", async () => {
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Slice 2", status: "done" });
+    writeValidationFile("needs-remediation");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, "validate-milestone", "M001");
+
+    const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
+
+    assert.equal(result, "pause");
+    assert.equal(pauseAutoMock.mock.callCount(), 1);
+    assert.equal(ctx.ui.notify.mock.callCount(), 1);
+    const notifyArgs = ctx.ui.notify.mock.calls[0].arguments;
+    assert.match(notifyArgs[0], /needs-remediation/);
+    assert.equal(notifyArgs[1], "error");
+  });
+
+  test("treats skipped slices as closed", async () => {
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Slice 2", status: "skipped" });
+    writeValidationFile("needs-remediation");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, "validate-milestone", "M001");
+
+    const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
+
+    assert.equal(result, "pause");
+    assert.equal(pauseAutoMock.mock.callCount(), 1);
+  });
+
+  test("continues when verdict=needs-remediation but a queued remediation slice exists", async () => {
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Remediation", status: "queued" });
+    writeValidationFile("needs-remediation");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, "validate-milestone", "M001");
+
+    const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
+
+    assert.equal(result, "continue");
+    assert.equal(pauseAutoMock.mock.callCount(), 0);
+  });
+
+  test("continues when verdict is pass", async () => {
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
+    writeValidationFile("pass");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, "validate-milestone", "M001");
+
+    const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
+
+    assert.equal(result, "continue");
+    assert.equal(pauseAutoMock.mock.callCount(), 0);
+  });
+
+  test("continues when no VALIDATION file exists yet", async () => {
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, "validate-milestone", "M001");
+
+    const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
+
+    assert.equal(result, "continue");
+    assert.equal(pauseAutoMock.mock.callCount(), 0);
+  });
+});

package/src/resources/extensions/gsd/tests/validate-milestone-write-order.test.ts

@@ -112,4 +112,43 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
     ).get();
     assert.equal(row, undefined, "assessment row should be deleted after disk-write rollback");
   });
+
+  it("persists milestone validation gate_runs rows when UOK gates are enabled", async () => {
+    base = makeTmpBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001" });
+
+    const result = await handleValidateMilestone(VALID_PARAMS, base, {
+      uokGatesEnabled: true,
+      traceId: "trace-val-1",
+      turnId: "turn-val-1",
+    });
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      `SELECT gate_id, outcome, failure_class, trace_id, turn_id
+       FROM gate_runs
+       WHERE gate_id = 'milestone-validation-gates'
+       ORDER BY id DESC
+       LIMIT 1`,
+    ).get() as
+      | {
+          gate_id: string;
+          outcome: string;
+          failure_class: string;
+          trace_id: string;
+          turn_id: string;
+        }
+      | undefined;
+
+    assert.ok(row, "milestone validation gate row should be persisted");
+    assert.equal(row?.gate_id, "milestone-validation-gates");
+    assert.equal(row?.outcome, "pass");
+    assert.equal(row?.failure_class, "none");
+    assert.equal(row?.trace_id, "trace-val-1");
+    assert.equal(row?.turn_id, "turn-val-1");
+  });
 });

package/src/resources/extensions/gsd/tests/workflow-logger-wiring.test.ts

@@ -0,0 +1,223 @@
+// GSD Extension — workflow-logger wiring regression tests
+//
+// Verifies the plumbing between workflow-logger and the rest of the state
+// system (auto-loop phases, detect-stuck, notification store). Without this
+// wiring, warnings/errors logged during a unit leak across units, never
+// reach the user as a consolidated post-unit alert, and don't enrich
+// stuck-detection reasons.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  logWarning,
+  logError,
+  peekLogs,
+  _resetLogs,
+  setStderrLoggingEnabled,
+} from "../workflow-logger.ts";
+import { detectStuck } from "../auto/detect-stuck.ts";
+
+const phasesSrc = readFileSync(
+  join(import.meta.dirname, "..", "auto", "phases.ts"),
+  "utf-8",
+);
+const autoSrc = readFileSync(
+  join(import.meta.dirname, "..", "auto.ts"),
+  "utf-8",
+);
+
+// ─── Source-scan: phases.ts calls the logger lifecycle API ─────────────────
+
+test("auto/phases.ts imports _resetLogs, drainAndSummarize, formatForNotification, hasAnyIssues", () => {
+  assert.match(
+    phasesSrc,
+    /from\s+"\.\.\/workflow-logger\.js"/,
+    "phases.ts imports from workflow-logger",
+  );
+  for (const name of [
+    "_resetLogs",
+    "drainLogs",
+    "drainAndSummarize",
+    "formatForNotification",
+    "hasAnyIssues",
+  ]) {
+    assert.ok(
+      phasesSrc.includes(name),
+      `phases.ts should reference ${name}`,
+    );
+  }
+});
+
+test("runUnitPhase calls _resetLogs() before assigning s.currentUnit", () => {
+  // Find the "s.currentUnit = { type: unitType" assignment line and check
+  // the preceding ~500 chars contain a _resetLogs() call.
+  const idx = phasesSrc.indexOf("s.currentUnit = { type: unitType");
+  assert.ok(idx > 0, "runUnitPhase should assign s.currentUnit");
+  const before = phasesSrc.slice(Math.max(0, idx - 500), idx);
+  assert.match(
+    before,
+    /_resetLogs\(\)/,
+    "_resetLogs() must be called immediately before s.currentUnit assignment",
+  );
+});
+
+test("runFinalize drains and surfaces logger buffer via ctx.ui.notify", () => {
+  // Locate the runFinalize success path and verify it calls drainAndSummarize
+  // and routes the result through ctx.ui.notify.
+  const runFinalizeIdx = phasesSrc.indexOf("export async function runFinalize");
+  assert.ok(runFinalizeIdx > 0, "runFinalize export should exist");
+  const finalizeBody = phasesSrc.slice(runFinalizeIdx);
+  assert.match(
+    finalizeBody,
+    /hasAnyIssues\(\)/,
+    "runFinalize should gate drain on hasAnyIssues",
+  );
+  assert.match(
+    finalizeBody,
+    /drainAndSummarize\(\)/,
+    "runFinalize should call drainAndSummarize on success",
+  );
+  assert.match(
+    finalizeBody,
+    /formatForNotification\(logs\)/,
+    "runFinalize should format drained logs for the notification",
+  );
+});
+
+test("runFinalize timeout branches drain the buffer to prevent bleed", () => {
+  // Both timeout branches null out s.currentUnit — they should also drain
+  // so accumulated logs for the timed-out unit don't leak into the next.
+  const runFinalizeIdx = phasesSrc.indexOf("export async function runFinalize");
+  const finalizeBody = phasesSrc.slice(runFinalizeIdx);
+  const drainCallCount =
+    (finalizeBody.match(/drainLogs\(\)/g) ?? []).length;
+  assert.ok(
+    drainCallCount >= 2,
+    `runFinalize timeout branches should each call drainLogs() (found ${drainCallCount}, expected >= 2)`,
+  );
+});
+
+// ─── Source-scan: auto.ts calls setLogBasePath in startAuto ────────────────
+
+test("startAuto calls setLogBasePath(base) so audit log is pinned on resume", () => {
+  const startAutoIdx = autoSrc.indexOf("export async function startAuto");
+  assert.ok(startAutoIdx > 0, "startAuto export should exist");
+  const body = autoSrc.slice(startAutoIdx);
+  assert.match(
+    body,
+    /setLogBasePath\(base\)/,
+    "startAuto must call setLogBasePath(base) to pin the audit log",
+  );
+});
+
+// ─── Runtime: detect-stuck enriches reason with summarizeLogs() ────────────
+
+test("detectStuck reason includes workflow-logger summary when logs present", () => {
+  setStderrLoggingEnabled(false);
+  try {
+    _resetLogs();
+    logWarning("projection", "STATE.md render failed");
+    logError("db", "WAL checkpoint failed");
+
+    const result = detectStuck([
+      { key: "execute-task/slice-A/task-1", error: "ENOENT: no such file" },
+      { key: "execute-task/slice-A/task-1", error: "ENOENT: no such file" },
+    ]);
+
+    assert.notEqual(result, null);
+    assert.equal(result!.stuck, true);
+    assert.match(
+      result!.reason,
+      /Same error repeated:/,
+      "reason should still start with the rule string",
+    );
+    assert.match(
+      result!.reason,
+      /STATE\.md render failed/,
+      "reason should include the accumulated logger warning",
+    );
+    assert.match(
+      result!.reason,
+      /WAL checkpoint failed/,
+      "reason should include the accumulated logger error",
+    );
+
+    // Critical: summarizeLogs must not drain — the auto-loop's finalize
+    // step owns the buffer lifecycle, detect-stuck is read-only.
+    assert.equal(
+      peekLogs().length,
+      2,
+      "detect-stuck must not drain the buffer",
+    );
+  } finally {
+    _resetLogs();
+    setStderrLoggingEnabled(true);
+  }
+});
+
+test("detectStuck reason unchanged when logger buffer is empty", () => {
+  setStderrLoggingEnabled(false);
+  try {
+    _resetLogs();
+    const result = detectStuck([
+      { key: "A", error: "boom" },
+      { key: "A", error: "boom" },
+    ]);
+    assert.notEqual(result, null);
+    // No trailing " — " suffix when there are no logs to summarize.
+    assert.doesNotMatch(
+      result!.reason,
+      / — \d+ (error|warning)/,
+      "reason should have no logger suffix when buffer is empty",
+    );
+  } finally {
+    setStderrLoggingEnabled(true);
+  }
+});
+
+// ─── Runtime: readTransaction rollback failure surfaces via logError ────────
+//
+// snapshotState now delegates its transaction to readTransaction() in
+// gsd-db.ts (single-writer refactor in #4198), so the split-brain
+// ROLLBACK-failure log lives there, not in workflow-manifest.ts.
+
+test("readTransaction logs ROLLBACK failures as split-brain signal", () => {
+  const dbSrc = readFileSync(
+    join(import.meta.dirname, "..", "gsd-db.ts"),
+    "utf-8",
+  );
+  assert.match(
+    dbSrc,
+    /logError\("db",\s*"snapshotState ROLLBACK failed"/,
+    "readTransaction ROLLBACK catch should call logError",
+  );
+});
+
+// ─── Runtime: state.ts and workflow-projections.ts log silent bailouts ─────
+
+test("state.ts logs roadmap read failures instead of silently continuing", () => {
+  const stateSrc = readFileSync(
+    join(import.meta.dirname, "..", "state.ts"),
+    "utf-8",
+  );
+  assert.match(
+    stateSrc,
+    /logWarning\("state",\s*"reconcileDiskToDb: roadmap read failed/,
+    "state.ts reconcileDiskToDb should log roadmap read failures",
+  );
+});
+
+test("workflow-projections.ts logs DB probe failures instead of silent return", () => {
+  const projectionsSrc = readFileSync(
+    join(import.meta.dirname, "..", "workflow-projections.ts"),
+    "utf-8",
+  );
+  assert.match(
+    projectionsSrc,
+    /logWarning\("projection",\s*"renderStateProjection: DB handle probe failed/,
+    "renderStateProjection DB probe should log on failure",
+  );
+});

package/src/resources/extensions/gsd/tools/complete-slice.ts

@@ -424,6 +424,32 @@ export async function handleCompleteSlice(
     logError("tool", `complete-slice event log FAILED — completion invisible to reconciliation`, { error: (eventErr as Error).message });
   }
 
+  // Fire-and-forget graph rebuild — must NOT await, must NOT crash slice completion.
+  // Dynamic import of the package name (not a relative path) so it resolves
+  // correctly via package.json#exports in both development and production.
+  // eslint-disable-next-line @typescript-eslint/no-floating-promises
+  (async () => {
+    try {
+      const graphMod = await import("@gsd-build/mcp-server") as unknown as Partial<{
+        buildGraph: (dir: string) => Promise<{ nodes: unknown[]; edges: unknown[]; builtAt: string }>;
+        writeGraph: (gsdRoot: string, graph: unknown) => Promise<void>;
+        resolveGsdRoot: (basePath: string) => string;
+      }>;
+      if (
+        typeof graphMod.buildGraph !== "function"
+        || typeof graphMod.writeGraph !== "function"
+        || typeof graphMod.resolveGsdRoot !== "function"
+      ) {
+        throw new Error("graph helpers unavailable from @gsd-build/mcp-server");
+      }
+      const g = await graphMod.buildGraph(basePath);
+      await graphMod.writeGraph(graphMod.resolveGsdRoot(basePath), g);
+    } catch (graphErr) {
+      // Graph rebuild is best-effort — log at warning level but never propagate
+      logWarning("tool", `complete-slice graph rebuild failed (non-fatal): ${(graphErr as Error).message ?? String(graphErr)}`);
+    }
+  })();
+
   return {
     sliceId: params.sliceId,
     milestoneId: params.milestoneId,