gsd-pi 2.76.0 → 2.77.0-dev.538325aea

package/src/resources/extensions/gsd/tests/token-counter.test.ts

@@ -102,7 +102,8 @@ describe("token-counter: estimateTokensForProvider", () => {
 
 describe("token-counter: backward compatibility", () => {
   it("countTokensSync returns heuristic estimate when tiktoken is not loaded", () => {
-    // Without tiktoken loaded, countTokensSync falls back to ceil(len/4)
+    // Without tiktoken loaded, countTokensSync falls back to estimateTokensForProvider.
+    // With no provider (defaults to "unknown", ratio 4.0): ceil(100/4) = 25.
     const text = "A".repeat(100);
     const result = countTokensSync(text);
     // Either tiktoken is loaded (exact count) or heuristic (ceil(100/4) = 25)
@@ -127,3 +128,106 @@ describe("token-counter: backward compatibility", () => {
     assert.equal(result, 0);
   });
 });
+
+// ─── provider-aware fallback (issue #4529) ───────────────────────────────────
+// Regression tests: countTokens/countTokensSync must use provider-specific
+// ratios for their heuristic fallback, not a hardcoded GPT-4o / 4 divisor.
+
+describe("token-counter: provider-aware heuristic fallback", () => {
+  // These tests exercise the heuristic path (no tiktoken or before init).
+  // We call estimateTokensForProvider directly to validate expected values,
+  // then verify countTokens/countTokensSync return the same values when
+  // tiktoken is unavailable.
+
+  it("countTokensSync uses anthropic ratio (3.5) when provider is 'anthropic'", () => {
+    const text = "A".repeat(350);
+    // anthropic: ceil(350 / 3.5) = 100
+    // openai/unknown: ceil(350 / 4.0) = 88
+    // These are different — the provider must matter.
+    const anthropicEstimate = estimateTokensForProvider(text, "anthropic");
+    const unknownEstimate = estimateTokensForProvider(text, "unknown");
+    assert.equal(anthropicEstimate, 100, "anthropic ratio should give 100 tokens for 350 chars");
+    assert.equal(unknownEstimate, 88, "unknown ratio should give 88 tokens for 350 chars");
+    assert.notEqual(
+      anthropicEstimate,
+      unknownEstimate,
+      "anthropic and unknown estimates must differ — if they are equal the provider is being ignored",
+    );
+
+    // Actually call countTokensSync with the anthropic provider.
+    // When tiktoken is not loaded, this must return the provider-aware estimate (100).
+    // When tiktoken is loaded, it returns the tiktoken count (which is also > 0 and
+    // will be in the range [88, 120] for 350 "A" characters with cl100k_base).
+    const syncResult = countTokensSync(text, "anthropic");
+    assert.ok(typeof syncResult === "number", "countTokensSync must return a number");
+    assert.ok(syncResult > 0, "countTokensSync must return a positive count");
+    // If tiktoken is unavailable the result must exactly match the anthropic heuristic.
+    // If tiktoken is available we cannot assert the exact value, but we know it will
+    // not equal the unknown-provider heuristic (88) for 350 identical characters.
+    const tiktokenAvailable = syncResult !== anthropicEstimate;
+    if (!tiktokenAvailable) {
+      assert.equal(
+        syncResult,
+        anthropicEstimate,
+        `countTokensSync with 'anthropic' provider must return ${anthropicEstimate} (not the unknown-provider value ${unknownEstimate}) when tiktoken is unavailable`,
+      );
+    }
+  });
+
+  it("countTokens uses anthropic ratio when provider='anthropic' and tiktoken unavailable", async () => {
+    const text = "A".repeat(350);
+    // anthropic heuristic: ceil(350 / 3.5) = 100
+    // unknown/hardcoded-4 heuristic: ceil(350 / 4.0) = 88
+    const anthropicEstimate = estimateTokensForProvider(text, "anthropic"); // 100
+    const unknownEstimate = estimateTokensForProvider(text, "unknown");     // 88
+    const hardcodedFallback = Math.ceil(text.length / 4);                   // 88
+
+    // The anthropic heuristic must produce more tokens than the old /4 fallback.
+    assert.equal(anthropicEstimate, 100, "anthropic heuristic should give 100 tokens for 350 chars");
+    assert.ok(
+      anthropicEstimate > hardcodedFallback,
+      `anthropic estimate (${anthropicEstimate}) must exceed the hardcoded /4 fallback (${hardcodedFallback})`,
+    );
+    assert.notEqual(
+      anthropicEstimate,
+      unknownEstimate,
+      "anthropic and unknown estimates must differ — provider is being ignored if equal",
+    );
+
+    // Call countTokens with the anthropic provider and verify the result.
+    const result = await countTokens(text, "anthropic");
+    assert.ok(typeof result === "number", "should return a number");
+    assert.ok(result > 0, "should return a positive token count");
+
+    // When tiktoken is unavailable: result must equal the anthropic heuristic (100),
+    // NOT the unknown-provider heuristic (88). This is the core regression guard for #4529.
+    // When tiktoken IS available: result is the tiktoken count, which will differ from
+    // the heuristic — but it must never equal the wrong (unknown) heuristic for this text.
+    if (result === anthropicEstimate || result === unknownEstimate) {
+      // We are on the heuristic path — assert the correct provider ratio was used.
+      assert.equal(
+        result,
+        anthropicEstimate,
+        `countTokens with 'anthropic' provider returned ${result} but expected ${anthropicEstimate} (anthropic heuristic) not ${unknownEstimate} (unknown/hardcoded heuristic)`,
+      );
+    } else {
+      // tiktoken is active — result is an exact BPE count.
+      // For 350 identical "A" characters cl100k_base produces a count in [80, 130].
+      assert.ok(
+        result >= 80 && result <= 130,
+        `tiktoken count ${result} for 350 "A" chars is outside expected range [80, 130]`,
+      );
+    }
+  });
+
+  it("countTokens with provider='anthropic' yields more tokens than provider='openai' (heuristic)", () => {
+    const text = "A".repeat(400);
+    // anthropic: ceil(400/3.5) = 115, openai: ceil(400/4.0) = 100
+    const anthropic = estimateTokensForProvider(text, "anthropic");
+    const openai = estimateTokensForProvider(text, "openai");
+    assert.ok(
+      anthropic > openai,
+      `anthropic estimate (${anthropic}) must exceed openai estimate (${openai}) for same text`,
+    );
+  });
+});

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

@@ -14,6 +14,7 @@ import {
   isToolCompatibleWithProvider,
   filterToolsForProvider,
   adjustToolSet,
+  GROQ_MAX_TOOLS,
 } from "../model-router.js";
 
 import {
@@ -197,3 +198,109 @@ describe("adjustToolSet", () => {
     assert.deepEqual(removedTools, ["mcp_complex"]);
   });
 });
+
+// ─── GROQ_MAX_TOOLS constant ─────────────────────────────────────────────────
+
+describe("GROQ_MAX_TOOLS", () => {
+  test("equals 128", () => {
+    assert.equal(GROQ_MAX_TOOLS, 128);
+  });
+});
+
+// ─── Groq tool-count cap (#4376) ────────────────────────────────────────────
+
+describe("filterToolsForProvider — Groq 128-tool cap", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("does not cap when provider is not groq", () => {
+    const toolNames = Array.from({ length: 200 }, (_, i) => `tool_${i}`);
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "openai-completions");
+    assert.equal(compatible.length, 200);
+    assert.equal(filtered.length, 0);
+  });
+
+  test("does not cap when <= 128 tools with groq provider", () => {
+    const toolNames = Array.from({ length: 128 }, (_, i) => `tool_${i}`);
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "openai-completions", "groq");
+    assert.equal(compatible.length, 128);
+    assert.equal(filtered.length, 0);
+  });
+
+  test("caps to 128 when >128 tools with groq provider", () => {
+    const toolNames = Array.from({ length: 200 }, (_, i) => `tool_${i}`);
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "openai-completions", "groq");
+    assert.equal(compatible.length, 128);
+    assert.equal(filtered.length, 72);
+  });
+
+  test("keeps the first 128 tools when capping", () => {
+    const toolNames = Array.from({ length: 200 }, (_, i) => `tool_${i}`);
+    const { compatible } = filterToolsForProvider(toolNames, "openai-completions", "groq");
+    assert.equal(compatible[0], "tool_0");
+    assert.equal(compatible[127], "tool_127");
+  });
+
+  test("trimmed tools appear in filtered list", () => {
+    const toolNames = Array.from({ length: 130 }, (_, i) => `tool_${i}`);
+    const { filtered } = filterToolsForProvider(toolNames, "openai-completions", "groq");
+    assert.equal(filtered.length, 2);
+    assert.equal(filtered[0], "tool_128");
+    assert.equal(filtered[1], "tool_129");
+  });
+
+  test("emits a warning when tools are trimmed", () => {
+    const warnings: string[] = [];
+    const original = console.warn;
+    console.warn = (...args: unknown[]) => { warnings.push(String(args[0])); };
+    try {
+      const toolNames = Array.from({ length: 129 }, (_, i) => `tool_${i}`);
+      filterToolsForProvider(toolNames, "openai-completions", "groq");
+      assert.equal(warnings.length, 1);
+      assert.ok(warnings[0].includes("128"), "warning mentions Groq limit");
+    } finally {
+      console.warn = original;
+    }
+  });
+
+  test("does not warn when tools are at the limit", () => {
+    const warnings: string[] = [];
+    const original = console.warn;
+    console.warn = (...args: unknown[]) => { warnings.push(String(args[0])); };
+    try {
+      const toolNames = Array.from({ length: 128 }, (_, i) => `tool_${i}`);
+      filterToolsForProvider(toolNames, "openai-completions", "groq");
+      assert.equal(warnings.length, 0);
+    } finally {
+      console.warn = original;
+    }
+  });
+});
+
+describe("adjustToolSet — Groq 128-tool cap", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("caps to 128 tools when provider is groq and >128 tools active", () => {
+    const toolNames = Array.from({ length: 150 }, (_, i) => `tool_${i}`);
+    const { toolNames: result, removedTools } = adjustToolSet(toolNames, "openai-completions", "groq");
+    assert.equal(result.length, 128);
+    assert.equal(removedTools.length, 22);
+  });
+
+  test("does not cap for non-groq providers even with >128 tools", () => {
+    const toolNames = Array.from({ length: 150 }, (_, i) => `tool_${i}`);
+    const { toolNames: result, removedTools } = adjustToolSet(toolNames, "openai-completions", "openai");
+    assert.equal(result.length, 150);
+    assert.equal(removedTools.length, 0);
+  });
+
+  test("does not cap when provider is omitted", () => {
+    const toolNames = Array.from({ length: 150 }, (_, i) => `tool_${i}`);
+    const { toolNames: result, removedTools } = adjustToolSet(toolNames, "openai-completions");
+    assert.equal(result.length, 150);
+    assert.equal(removedTools.length, 0);
+  });
+});

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

@@ -109,6 +109,29 @@ test("plan-v2 gate fails closed for execution phase when finalized context is mi
   assert.match(compiled.reason ?? "", /CONTEXT\.md/i);
 });
 
+test("plan-v2 gate accepts finalized context from project-root fallback", () => {
+  const projectRoot = createBasePath();
+  const worktreeBase = createBasePath();
+  seedGraphRows();
+
+  writeMilestoneFile(projectRoot, "CONTEXT", "Finalized context in project root.");
+  writeMilestoneFile(worktreeBase, "CONTEXT-DRAFT", "Draft context in worktree.");
+
+  const prevProjectRoot = process.env.GSD_PROJECT_ROOT;
+  process.env.GSD_PROJECT_ROOT = projectRoot;
+  try {
+    const compiled = ensurePlanV2Graph(worktreeBase, buildState("executing"));
+    assert.equal(compiled.ok, true);
+    assert.equal(compiled.finalizedContextIncluded, true);
+  } finally {
+    if (prevProjectRoot === undefined) {
+      delete process.env.GSD_PROJECT_ROOT;
+    } else {
+      process.env.GSD_PROJECT_ROOT = prevProjectRoot;
+    }
+  }
+});
+
 test("plan-v2 compiler writes pipeline metadata for clarify/research/draft stages", () => {
   const basePath = createBasePath();
   seedGraphRows();

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

@@ -13,7 +13,7 @@ import { buildCompleteMilestonePrompt, buildValidateMilestonePrompt } from "../a
 import type { GSDState } from "../types.ts";
 import { clearPathCache } from "../paths.ts";
 import { clearParseCache } from "../files.ts";
-import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase, getMilestone } from "../gsd-db.ts";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────
 
@@ -177,16 +177,22 @@ test("deriveState returns completing-milestone when VALIDATION exists with termi
   }
 });
 
-test("deriveState treats needs-remediation as non-terminal — re-enters validating-milestone (#832)", async () => {
+test("deriveState returns blocked when needs-remediation has no incomplete slices (#4506)", async () => {
   const base = makeTmpBase();
   try {
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
     writeValidation(base, "M001", "---\nverdict: needs-remediation\nremediation_round: 0\n---\n\n# Validation\nNeeds fixes.");
 
     const state = await deriveState(base);
-    // needs-remediation routes back to validating-milestone for re-validation
-    assert.equal(state.phase, "validating-milestone");
+    // All slices done + needs-remediation → blocked (prevents infinite
+    // validate-milestone dispatch loop). Previously returned
+    // validating-milestone, which caused #4506.
+    assert.equal(state.phase, "blocked");
     assert.equal(state.activeMilestone?.id, "M001");
+    assert.ok(
+      state.blockers.some(b => b.includes("needs-remediation") && b.includes("M001")),
+      "blocker message should mention milestone and verdict",
+    );
   } finally {
     cleanup(base);
   }
@@ -251,8 +257,8 @@ Test
 `);
     openTestDb(base);
     insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
-    insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "complete", depends: [], sequence: 1 });
-    insertSlice({ id: "S02", milestoneId: "M001", title: "Skipped slice", status: "skipped", depends: [], sequence: 2 });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "complete", depends: [] });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Skipped slice", status: "skipped", depends: [] });
     writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDelivered.");
 
     const prompt = await buildCompleteMilestonePrompt("M001", "Test Milestone", base);
@@ -290,8 +296,8 @@ Test
 `);
     openTestDb(base);
     insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
-    insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "complete", depends: [], sequence: 1 });
-    insertSlice({ id: "S02", milestoneId: "M001", title: "Skipped slice", status: "skipped", depends: [], sequence: 2 });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "complete", depends: [] });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Skipped slice", status: "skipped", depends: [] });
     writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDelivered.");
     writeSliceAssessment(base, "M001", "S01", "---\nverdict: PASS\n---\n# Assessment\nEvidence captured.");
 
@@ -379,6 +385,128 @@ test("dispatch rule skips when skip_milestone_validation preference is set", asy
   }
 });
 
+test("dispatch rule fails closed for failure-path SUMMARY when DB milestone is not complete (#4658)", async () => {
+  const state: GSDState = {
+    activeMilestone: { id: "M001", title: "Test" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "completing-milestone",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "Complete milestone M001.",
+    registry: [{ id: "M001", title: "Test", status: "active" }],
+    progress: { milestones: { done: 0, total: 1 } },
+  };
+
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeMilestoneSummary(base, "M001", "# Milestone Summary\nverification FAILED — not complete.");
+
+    const ctx: DispatchContext = {
+      basePath: base,
+      mid: "M001",
+      midTitle: "Test",
+      state,
+      prefs: undefined,
+    };
+    const result = await resolveDispatch(ctx);
+    assert.equal(result.action, "stop");
+    if (result.action === "stop") {
+      assert.equal(result.level, "warning");
+      assert.match(result.reason, /failure-path SUMMARY/i);
+    }
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("dispatch rule reconciles DB for successful stale SUMMARY (#4658)", async () => {
+  const state: GSDState = {
+    activeMilestone: { id: "M001", title: "Test" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "completing-milestone",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "Complete milestone M001.",
+    registry: [{ id: "M001", title: "Test", status: "active" }],
+    progress: { milestones: { done: 0, total: 1 } },
+  };
+
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeMilestoneSummary(
+      base,
+      "M001",
+      [
+        "---",
+        "id: M001",
+        "status: complete",
+        "---",
+        "",
+        "# M001: Test",
+        "",
+        "**Complete.**",
+      ].join("\n"),
+    );
+
+    const ctx: DispatchContext = {
+      basePath: base,
+      mid: "M001",
+      midTitle: "Test",
+      state,
+      prefs: undefined,
+    };
+    const result = await resolveDispatch(ctx);
+    assert.equal(result.action, "skip");
+    const milestone = getMilestone("M001");
+    assert.equal(milestone?.status, "complete");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("dispatch rule fails closed for ambiguous stale SUMMARY (#4658)", async () => {
+  const state: GSDState = {
+    activeMilestone: { id: "M001", title: "Test" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "completing-milestone",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "Complete milestone M001.",
+    registry: [{ id: "M001", title: "Test", status: "active" }],
+    progress: { milestones: { done: 0, total: 1 } },
+  };
+
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeMilestoneSummary(base, "M001", "# M001 Summary\nSome notes without completion metadata.");
+
+    const ctx: DispatchContext = {
+      basePath: base,
+      mid: "M001",
+      midTitle: "Test",
+      state,
+      prefs: undefined,
+    };
+    const result = await resolveDispatch(ctx);
+    assert.equal(result.action, "stop");
+    if (result.action === "stop") {
+      assert.equal(result.level, "warning");
+      assert.match(result.reason, /ambiguous SUMMARY/i);
+    }
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── Artifact resolution & verification ───────────────────────────────────
 
 test("resolveExpectedArtifactPath returns VALIDATION path for validate-milestone", () => {

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync, readFileSync, existsSync, writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, readFileSync, existsSync, writeFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -11,7 +11,7 @@ import {
   _getAdapter,
   insertGateRow,
 } from "../gsd-db.ts";
-import { markDepthVerified, clearDiscussionFlowState } from "../bootstrap/write-gate.ts";
+import { markDepthVerified, clearDiscussionFlowState, loadWriteGateSnapshot } from "../bootstrap/write-gate.ts";
 import {
   executeCompleteMilestone,
   executePlanMilestone,
@@ -742,3 +742,66 @@ test("executeSummarySave leaves sibling CONTEXT-DRAFT intact for non-CONTEXT art
     cleanup(base);
   }
 });
+
+test("executeSummarySave CONTEXT HARD BLOCK clears after write-gate state file is deleted (#4343)", async () => {
+  const base = makeTmpBase();
+  const originalEnv = process.env.GSD_PERSIST_WRITE_GATE_STATE;
+  process.env.GSD_PERSIST_WRITE_GATE_STATE = "1";
+  try {
+    openTestDb(base);
+    clearDiscussionFlowState();
+
+    // First call: CONTEXT artifact without depth verification → HARD BLOCK
+    const blocked = await inProjectDir(base, () => executeSummarySave({
+      milestone_id: "M001",
+      artifact_type: "CONTEXT",
+      content: "# Context\n\ncontent",
+    }, base));
+    assert.equal(blocked.isError, true, "should be blocked without depth verification");
+    assert.match(
+      blocked.content[0].text,
+      /HARD BLOCK/,
+      "blocked result should mention HARD BLOCK",
+    );
+
+    // Verify the state file was written (persist mode is active)
+    const stateFilePath = join(base, ".gsd", "runtime", "write-gate-state.json");
+    // The state file may or may not exist at this point (block doesn't write state).
+    // Write a fake state file simulating stale persisted block state.
+    mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+    writeFileSync(stateFilePath, JSON.stringify({
+      verifiedDepthMilestones: [],
+      activeQueuePhase: false,
+      pendingGateId: "depth_verification_M001",
+    }));
+
+    // User deletes the state file to reset the block
+    unlinkSync(stateFilePath);
+    assert.ok(!existsSync(stateFilePath), "state file deleted");
+
+    // The snapshot loaded after deletion should be clean (no pending gate, no block)
+    const snapshot = loadWriteGateSnapshot(base);
+    assert.equal(snapshot.pendingGateId, null, "pendingGateId should be null after file deletion");
+    assert.deepEqual(snapshot.verifiedDepthMilestones, [], "verifiedDepthMilestones should be empty after file deletion");
+
+    // Depth-verify and re-attempt: should succeed after deletion clears stale state
+    markDepthVerified("M001", base);
+
+    const unblocked = await inProjectDir(base, () => executeSummarySave({
+      milestone_id: "M001",
+      artifact_type: "CONTEXT",
+      content: "# Context\n\nfinal content",
+    }, base));
+    assert.equal(unblocked.isError, undefined, "should not be blocked after depth verification");
+    assert.equal(unblocked.details.operation, "save_summary");
+  } finally {
+    if (originalEnv === undefined) {
+      delete process.env.GSD_PERSIST_WRITE_GATE_STATE;
+    } else {
+      process.env.GSD_PERSIST_WRITE_GATE_STATE = originalEnv;
+    }
+    clearDiscussionFlowState();
+    closeDatabase();
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/worktree-db.test.ts

@@ -10,6 +10,8 @@ import {
   insertDecision,
   insertRequirement,
   insertArtifact,
+  insertMilestone,
+  getMilestone,
   getDecisionById,
   getRequirementById,
   _getAdapter,
@@ -442,4 +444,37 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
   cleanup(mainDir, wtDir);
 }
 
+// Test: reconcileWorktreeDb must NOT downgrade milestone status complete→active (#4372)
+{
+  const mainDir = tempDir();
+  const wtDir = tempDir();
+  const mainDb = path.join(mainDir, 'gsd.db');
+  const wtDb = path.join(wtDir, 'gsd.db');
+
+  // Seed main with a milestone already marked complete
+  seedMainDb(mainDb);
+  const mainAdapter = _getAdapter()!;
+  insertMilestone({ id: 'M-COMP', title: 'Completed Milestone', status: 'complete' });
+  // Manually mark completed_at so it's a realistic complete record
+  mainAdapter.prepare(`UPDATE milestones SET completed_at = '2025-06-01T00:00:00.000Z' WHERE id = 'M-COMP'`).run();
+  closeDatabase();
+
+  // Copy to worktree — the worktree has the milestone as 'active' (stale / older snapshot)
+  copyWorktreeDb(mainDb, wtDb);
+  openDatabase(wtDb);
+  const wtAdapter = _getAdapter()!;
+  wtAdapter.prepare(`UPDATE milestones SET status = 'active', completed_at = NULL WHERE id = 'M-COMP'`).run();
+  closeDatabase();
+
+  // Reconcile: main should win and keep 'complete'
+  openDatabase(mainDb);
+  reconcileWorktreeDb(mainDb, wtDb);
+
+  const m = getMilestone('M-COMP');
+  assert.ok(m !== null, 'milestone M-COMP still exists after reconcile');
+  assert.strictEqual(m!.status, 'complete', 'complete milestone must not be downgraded to active by stale worktree');
+
+  cleanup(mainDir, wtDir);
+}
+
 // ─── Final Report ──────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/worktree-journal-events.test.ts

@@ -190,7 +190,12 @@ describe("worktree journal events", () => {
     });
     const resolver = new WorktreeResolver(s, deps);
 
-    resolver.mergeAndExit("M001", makeNotifyCtx());
+    // Since #4380, mergeAndExit re-throws all errors after emitting the journal
+    // event and restoring state — callers must handle the throw.
+    assert.throws(
+      () => resolver.mergeAndExit("M001", makeNotifyCtx()),
+      /conflict in main/,
+    );
 
     const entries = readJournalEntries(tmp);
     const failed = entries.find(e => e.eventType === "worktree-merge-failed");