@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.738160b9

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -970,6 +970,93 @@ test("register-hooks agent_end does not re-arm deferred gate after workflow MCP
   });
 });
 
+test("register-hooks message_update uses in-memory write-gate snapshot instead of disk reconcile", async (t) => {
+  const dir = makeTempDir("message-update-memory-snapshot");
+  const originalCwd = process.cwd();
+  const originalEnv = process.env.GSD_PERSIST_WRITE_GATE_STATE;
+  process.chdir(dir);
+  process.env.GSD_PERSIST_WRITE_GATE_STATE = "1";
+  resetWriteGateState(dir);
+  clearPendingAutoStart(dir);
+
+  const gateId = "depth_verification_M012_confirm";
+  const statePath = join(dir, ".gsd", "runtime", "write-gate-state.json");
+
+  t.after(() => {
+    try {
+      resetWriteGateState(dir);
+      clearPendingAutoStart(dir);
+    } finally {
+      if (originalEnv === undefined) {
+        delete process.env.GSD_PERSIST_WRITE_GATE_STATE;
+      } else {
+        process.env.GSD_PERSIST_WRITE_GATE_STATE = originalEnv;
+      }
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  const notices: Array<{ text: string; level: string }> = [];
+  const ctx = {
+    cwd: dir,
+    ui: { notify: (text: string, level: string) => notices.push({ text, level }) },
+  } as any;
+
+  registerHooks(pi, []);
+  setPendingAutoStart(dir, {
+    basePath: dir,
+    milestoneId: "M012",
+    ctx,
+    pi: { sendMessage: () => undefined } as any,
+  });
+
+  mkdirSync(join(dir, ".gsd", "runtime"), { recursive: true });
+  writeFileSync(statePath, JSON.stringify({
+    verifiedDepthMilestones: ["M012"],
+    verifiedApprovalGates: [gateId],
+    activeQueuePhase: false,
+    pendingGateId: null,
+  }, null, 2), "utf-8");
+
+  const approvalMessage = {
+    role: "assistant",
+    content: [
+      { type: "text", text: "Here is the milestone plan.\n\nDid I capture the project correctly?" },
+    ],
+  };
+
+  for (const handler of handlers.get("message_update") ?? []) {
+    await handler({ message: approvalMessage }, ctx);
+  }
+
+  assert.equal(
+    notices.some((n) => /discuss-milestone M012 is waiting for your approval - pausing/.test(n.text)),
+    true,
+    "streaming hook must not suppress the pause from a disk-only verification",
+  );
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M012", null, dir).block,
+    true,
+    "streaming hook must not reconcile disk-only verification into the in-memory snapshot",
+  );
+
+  for (const handler of handlers.get("agent_end") ?? []) {
+    await handler({ messages: [] }, ctx);
+  }
+
+  assert.equal(getPendingGate(dir), null, "agent_end still reconciles disk and suppresses durable re-arm");
+});
+
 // ── External-engine post-hoc gate replay (write-gate two-process sync) ──────
 // On claude-code-cli, pi ingests the SDK turn's tool blocks after the workflow
 // MCP child already executed them. The depth gate can therefore arrive at

package/src/resources/extensions/gsd/tests/register-hooks-loop-guard-auto.test.ts

@@ -0,0 +1,103 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { autoSession } from "../auto-runtime-state.ts";
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { resetToolCallLoopGuard } from "../bootstrap/tool-call-loop-guard.ts";
+
+type Handler = (event: any, ctx?: any) => Promise<any> | any;
+
+function makeHookHarness(): {
+  emitToolCall: (toolName: string, input: Record<string, unknown>) => Promise<any>;
+} {
+  const handlers = new Map<string, Handler[]>();
+  const pi = {
+    on(event: string, handler: Handler) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  };
+  const ctx = {
+    cwd: process.cwd(),
+    ui: { notify: () => undefined },
+  };
+  let callId = 0;
+
+  registerHooks(pi as any, []);
+
+  return {
+    async emitToolCall(toolName: string, input: Record<string, unknown>): Promise<any> {
+      callId += 1;
+      const loopGuardHandler = handlers.get("tool_call")?.[0];
+      assert.ok(loopGuardHandler, "loop-guard tool_call handler should be registered");
+      return loopGuardHandler({ toolCallId: `loop-${callId}`, toolName, input }, ctx);
+    },
+  };
+}
+
+test("register-hooks keeps loop-guard block reason interactive outside auto-mode", async (t) => {
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+  });
+
+  const { emitToolCall } = makeHookHarness();
+
+  for (let i = 0; i < 4; i += 1) {
+    await emitToolCall("web_search", { query: "same query" });
+  }
+  const block = await emitToolCall("web_search", { query: "same query" });
+
+  assert.equal(block?.block, true);
+  assert.match(block.reason, /respond to the user in text/);
+  assert.doesNotMatch(block.reason, /auto-mode recovery\/replan path/);
+});
+
+test("register-hooks rewrites loop-guard block reason for auto-mode identical-args blocks", async (t) => {
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+  });
+
+  const { emitToolCall } = makeHookHarness();
+
+  for (let i = 0; i < 4; i += 1) {
+    await emitToolCall("web_search", { query: "same query" });
+  }
+  const block = await emitToolCall("web_search", { query: "same query" });
+
+  assert.equal(block?.block, true);
+  assert.match(block.reason, /Tool loop detected \(identical args\): web_search/);
+  assert.match(block.reason, /Do not re-issue this blocked tool/);
+  assert.match(block.reason, /auto-mode recovery\/replan path/);
+  assert.doesNotMatch(block.reason, /respond to the user in text/);
+});
+
+test("register-hooks rewrites loop-guard block reason for auto-mode per-tool blocks", async (t) => {
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+  });
+
+  const { emitToolCall } = makeHookHarness();
+
+  for (let i = 0; i < 6; i += 1) {
+    await emitToolCall("gsd_complete_milestone", { milestone: `M${i}` });
+  }
+  const block = await emitToolCall("gsd_complete_milestone", { milestone: "M7" });
+
+  assert.equal(block?.block, true);
+  assert.match(block.reason, /Tool loop detected \(repeated tool\): gsd_complete_milestone/);
+  assert.match(block.reason, /Do not re-issue this blocked tool/);
+  assert.match(block.reason, /auto-mode recovery\/replan path/);
+  assert.doesNotMatch(block.reason, /respond to the user in text/);
+});

package/src/resources/extensions/gsd/tests/root-write-leak-guard.test.ts

@@ -7,7 +7,26 @@ import { closeSync, ftruncateSync, openSync, statSync, writeFileSync } from "nod
 import { join } from "node:path";
 
 import { captureRootDirtySnapshot } from "../root-write-leak-guard.ts";
-import { cleanup, git, makeTempRepo } from "./test-utils.ts";
+import { cleanup, createFile, git, makeTempRepo } from "./test-utils.ts";
+
+test("captureRootDirtySnapshot ignores unignored GSD root runtime directories", () => {
+  const base = makeTempRepo("gsd-root-dirty-runtime-");
+  try {
+    createFile(base, ".gsd/STATE.md", "state\n");
+    createFile(base, ".gsd-backups/snap-001", "backup\n");
+    createFile(base, ".gsd-worktrees/M001/file.txt", "worktree\n");
+    createFile(base, "src/foo.ts", "export {};\n");
+
+    const snapshot = captureRootDirtySnapshot(base);
+
+    assert.equal(snapshot.has(".gsd/STATE.md"), false);
+    assert.equal(snapshot.has(".gsd-backups/snap-001"), false);
+    assert.equal(snapshot.has(".gsd-worktrees/M001/file.txt"), false);
+    assert.equal(snapshot.has("src/foo.ts"), true);
+  } finally {
+    cleanup(base);
+  }
+});
 
 test("captureRootDirtySnapshot does not read dirty files larger than Node's Buffer limit", () => {
   const base = makeTempRepo("gsd-root-dirty-large-");

package/src/resources/extensions/gsd/tests/runtime-invariant-modules.test.ts

@@ -177,10 +177,22 @@ test("auto Unit tool scope allows status/read helpers named by closeout prompts"
   }
 });
 
-test("auto Unit tool scope blocks stale per-task planner in slice planning phases", () => {
-  for (const unitType of ["plan-slice", "refine-slice", "replan-slice"]) {
+test("auto Unit tool scope allows reactive-execute status and diagnostic tools", () => {
+  for (const toolName of ["gsd_milestone_status", "gsd_exec"]) {
+    const result = shouldBlockAutoUnitToolCall("reactive-execute", toolName);
+    assert.equal(result.block, false, `reactive-execute should be able to call ${toolName}`);
+  }
+});
+
+test("auto Unit tool scope allows incremental task planning during plan-slice", () => {
+  const result = shouldBlockAutoUnitToolCall("plan-slice", "gsd_plan_task");
+  assert.equal(result.block, false, "plan-slice should be able to call gsd_plan_task incrementally");
+});
+
+test("auto Unit tool scope still blocks per-task planner outside plan-slice", () => {
+  for (const unitType of ["refine-slice", "replan-slice"]) {
     const result = shouldBlockAutoUnitToolCall(unitType, "gsd_plan_task");
-    assert.equal(result.block, true, `${unitType} should not call stale gsd_plan_task`);
+    assert.equal(result.block, true, `${unitType} should not call gsd_plan_task`);
   }
 });
 

package/src/resources/extensions/gsd/tests/stalled-tool-recovery.test.ts

@@ -48,6 +48,16 @@ function makeRecordingPi() {
   } as any;
 }
 
+function makeRecordingCtx() {
+  const notifications: Array<{ message: string; level: string }> = [];
+  return {
+    notifications,
+    ui: {
+      notify: (message: string, level: string) => { notifications.push({ message, level }); },
+    },
+  } as any;
+}
+
 // ═══ #1855: empty RecoveryContext (basePath undefined) crashes ════════════════
 
 {
@@ -111,6 +121,52 @@ function makeRecordingPi() {
   }
 }
 
+// ═══ plan-slice timeout recovery verifies stale PLAN before advancing ═══════
+
+{
+  console.log("\n=== plan-slice timeout recovery rejects stale placeholder PLAN ===");
+  const base = mkdtempSync(join(tmpdir(), "gsd-timeout-stale-plan-"));
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+    writeFileSync(
+      join(sliceDir, "S01-PLAN.md"),
+      "# S01: Slice\n\n## Tasks\n\nPlanning was interrupted before task rows were persisted.\n",
+      "utf-8",
+    );
+
+    const ctx = makeRecordingCtx();
+    const pi = makeRecordingPi();
+    const result = await recoverTimedOutUnit(ctx, pi, "plan-slice", "M001/S01", "idle", {
+      basePath: base,
+      verbose: false,
+      currentUnitStartedAt: Date.now(),
+      unitRecoveryCount: new Map(),
+    });
+
+    assert.equal(result, "recovered", "invalid existing plan should enter steering recovery");
+    assert.equal(pi.messages.length, 1, "invalid existing plan should trigger steering instead of advancing");
+    assert.ok(
+      ctx.notifications.some((entry: { message: string }) => entry.message.includes("steering plan-slice M001/S01")),
+      "recovery notification should describe steering, not artifact advance",
+    );
+    assert.ok(
+      !ctx.notifications.some((entry: { message: string }) => entry.message.includes("artifact already exists on disk. Advancing.")),
+      "stale placeholder plan should not use the advance-on-existence path",
+    );
+    const runtime = JSON.parse(readFileSync(join(base, ".gsd", "runtime", "units", "plan-slice-M001-S01.json"), "utf-8"));
+    assert.equal(runtime.phase, "recovered", "stale placeholder plan must not be finalized");
+    assert.equal(runtime.recoveryAttempts, 1, "steering recovery attempt should be recorded");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
 // ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
 
 {

package/src/resources/extensions/gsd/tests/state-reconciliation-drift.test.ts

@@ -42,6 +42,8 @@ import {
   type ReconciliationDeps,
 } from "../state-reconciliation.ts";
 import { classifyFailure } from "../recovery-classification.ts";
+import { handlerPhaseIndex, RECONCILIATION_REPAIR_PHASES } from "../state-reconciliation/registry.ts";
+import { staleRenderHandler } from "../state-reconciliation/drift/stale-render.ts";
 import type { GSDState } from "../types.ts";
 
 function makeState(overrides: Partial<GSDState> = {}): GSDState {
@@ -159,6 +161,29 @@ test("ADR-017 (#5700): repair failure throws ReconciliationFailedError with shap
   );
 });
 
+test("ADR-017 (#5700): custom registry handlers outside built-in phases are repaired", async () => {
+  const drift = { kind: "custom-drift", id: "D001" } as unknown as DriftRecord;
+  let repaired = false;
+  const handler = {
+    kind: "custom-drift",
+    detect: () => (repaired ? [] : [drift]),
+    repair: () => {
+      repaired = true;
+    },
+  } as unknown as DriftHandler;
+
+  const result = await reconcileBeforeDispatch("/project", {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+    registry: [handler],
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(repaired, true);
+  assert.equal(result.repaired.length, 1);
+  assert.equal(result.repaired[0]?.kind, "custom-drift");
+});
+
 test("ADR-017 (#5700): a detector failure degrades to a blocker without aborting other handlers", async () => {
   // A single detector throwing (e.g. a transient file read error) must NOT
   // abort the whole cycle and hide every later handler's drift. It is collected
@@ -696,6 +721,126 @@ test("ADR-017 (#5702): stale-render drift detected and repaired end-to-end", asy
   assert.match(repairedContent, /\[x\][^\n]*\*\*T02\*\*/, "T02 checkbox should be checked after repair");
 });
 
+test("#1003: stale-render plan repair reopens DB before rendering", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-stale-render-reopen-"));
+  const sliceDir = join(base, ".gsd", "phases", "01-test");
+  mkdirSync(sliceDir, { recursive: true });
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmTreeQuiet(base);
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  clearRendererCaches();
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "First task", status: "done" });
+
+  const planPath = join(sliceDir, "01-01-PLAN.md");
+  writeFileSync(planPath, makeStalePlanContent("S01", [
+    { id: "T01", title: "First task", done: false },
+  ]));
+  closeDatabase();
+
+  await staleRenderHandler.repair(
+    {
+      kind: "stale-render",
+      renderPath: planPath,
+      reason: "T01 is done in DB but unchecked in plan",
+    },
+    { basePath: base, state: makeState() },
+  );
+
+  const repairedContent = readFileSync(planPath, "utf-8");
+  assert.match(repairedContent, /\[x\][^\n]*\*\*T01\*\*/, "T01 checkbox should be checked after DB reopen repair");
+  assert.equal(getSliceTasks("M001", "S01").length, 1, "DB should be reopened on the original project database");
+});
+
+test("#1003: stale-render plan repair switches back from an open wrong DB", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-stale-render-wrong-db-"));
+  const wrongBase = mkdtempSync(join(tmpdir(), "gsd-stale-render-other-db-"));
+  const sliceDir = join(base, ".gsd", "phases", "01-test");
+  mkdirSync(sliceDir, { recursive: true });
+  mkdirSync(join(wrongBase, ".gsd"), { recursive: true });
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmTreeQuiet(base);
+    rmTreeQuiet(wrongBase);
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  clearRendererCaches();
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "First task", status: "done" });
+
+  const planPath = join(sliceDir, "01-01-PLAN.md");
+  writeFileSync(planPath, makeStalePlanContent("S01", [
+    { id: "T01", title: "First task", done: false },
+  ]));
+  closeDatabase();
+
+  openDatabase(join(wrongBase, ".gsd", "gsd.db"));
+
+  await staleRenderHandler.repair(
+    {
+      kind: "stale-render",
+      renderPath: planPath,
+      reason: "T01 is done in DB but unchecked in plan",
+    },
+    { basePath: base, state: makeState() },
+  );
+
+  const repairedContent = readFileSync(planPath, "utf-8");
+  assert.match(repairedContent, /\[x\][^\n]*\*\*T01\*\*/, "T01 checkbox should be checked after switching back to the project DB");
+  assert.equal(getSliceTasks("M001", "S01").length, 1, "repair should leave the project DB active");
+});
+
+test("#1034: validation-blocked milestone summary drift returns blocker instead of exhausting repair passes", async () => {
+  const drift: Extract<DriftRecord, { kind: "stale-render" }> = {
+    kind: "stale-render",
+    renderPath: "/repo/.gsd/milestones/M001/M001-SUMMARY.md",
+    reason: "M001 is complete with summary in DB but SUMMARY.md missing on disk",
+  };
+  let repairCalled = false;
+  const handler: DriftHandler<Extract<DriftRecord, { kind: "stale-render" }>> = {
+    kind: "stale-render",
+    detect: () => [drift],
+    blocker: staleRenderHandler.blocker!,
+    repair: () => {
+      repairCalled = true;
+    },
+  };
+
+  const validationBlocker = [
+    "Milestone M001 is blocked because milestone validation returned needs-attention.",
+    "Fix options:",
+    "1. Review the validation details: `/gsd status`",
+  ].join("\n");
+
+  const result = await reconcileBeforeDispatch("/repo", {
+    invalidateStateCache: () => {},
+    deriveState: async () =>
+      makeState({
+        phase: "blocked",
+        blockers: [validationBlocker],
+        nextAction: "Resolve M001 validation attention before proceeding.",
+      }),
+    registry: [handler],
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(repairCalled, false, "validation-blocked milestone summary drift should not attempt repair");
+  assert.ok(
+    result.blockers.some((blocker) => blocker.includes("milestone validation returned needs-attention")),
+    "validation blocker should be returned to the caller",
+  );
+  assert.ok(
+    result.blockers.some((blocker) => blocker.includes("Stale milestone summary render")),
+    "stale-render blocker should explain why repair did not run",
+  );
+});
+
 test("ADR-017 (#5702): stale-render detector reason strings match repair contract", (t) => {
   t.skip("TODO(flat-phase): stale-render detection temporarily disabled during layout transition"); return;
   const base = mkdtempSync(join(tmpdir(), "gsd-adr017-render-reasons-"));
@@ -1811,3 +1956,49 @@ test("ADR-017 (#5700): cascading drift triggers second pass within cap", async (
   assert.equal(result.repaired.length, 2, "both passes' repairs collected");
   assert.equal(repaired.length, 2);
 });
+
+test("deriveState is pure: stale sketch healed only via reconcileBeforeDispatch", async (t) => {
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base));
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({
+    id: "S02",
+    milestoneId: "M001",
+    title: "Feature",
+    status: "pending",
+    risk: "medium",
+    depends: [],
+    demo: "S02 demo.",
+    sequence: 1,
+    isSketch: true,
+    sketchScope: "limited",
+  });
+  writeFileSync(
+    join(base, ".gsd", "phases", "01-test", "01-02-PLAN.md"),
+    "# S02 Plan\n",
+  );
+
+  const { deriveState } = await import("../state.ts");
+  invalidateStateCache();
+
+  const beforeReconcile = await deriveState(base);
+  assert.equal(beforeReconcile.phase, "refining", "derive alone must not heal stale sketch flag");
+  assert.equal(getSlice("M001", "S02")?.is_sketch, 1, "DB flag unchanged before reconcile");
+
+  const result = await reconcileBeforeDispatch(base);
+  assert.equal(result.ok, true);
+  assert.equal(getSlice("M001", "S02")?.is_sketch, 0, "reconcile clears sketch flag");
+
+  invalidateStateCache();
+  const afterReconcile = await deriveState(base);
+  assert.notEqual(afterReconcile.phase, "refining", "derive after reconcile advances past sketch gate");
+});
+
+test("reconciliation repair phases: external edits precede re-project handlers", () => {
+  assert.equal(RECONCILIATION_REPAIR_PHASES.length, 3);
+  assert.ok(handlerPhaseIndex("external-markdown-edit") < handlerPhaseIndex("stale-render"));
+  assert.ok(handlerPhaseIndex("external-planning-edit") < handlerPhaseIndex("roadmap-divergence"));
+  assert.ok(handlerPhaseIndex("stale-sketch-flag") < handlerPhaseIndex("stale-render"));
+});