gsd-pi 2.65.0 → 2.66.0

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

@@ -163,16 +163,15 @@ test("deriveState returns completing-milestone when VALIDATION exists with termi
   }
 });
 
-test("deriveState treats needs-remediation as terminal — does not re-enter validating-milestone (#832)", async () => {
+test("deriveState treats needs-remediation as non-terminal — re-enters validating-milestone (#832)", 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 is now terminal — milestone needs a SUMMARY to be fully complete
-    // Without SUMMARY, it enters completing-milestone (not validating-milestone)
-    assert.notEqual(state.phase, "validating-milestone");
+    // needs-remediation routes back to validating-milestone for re-validation
+    assert.equal(state.phase, "validating-milestone");
     assert.equal(state.activeMilestone?.id, "M001");
   } finally {
     cleanup(base);

package/src/resources/extensions/gsd/tests/verification-operational-gate.test.ts

@@ -80,3 +80,18 @@ test("isVerificationNotApplicable: 'Verify API response times under load' requir
 test("isVerificationNotApplicable: 'Monitor error rates for 24h' requires verification", () => {
   assert.equal(isVerificationNotApplicable("Monitor error rates for 24h"), false);
 });
+
+// Regression: #3634 — "Not provided." default from plan-milestone
+test("isVerificationNotApplicable: 'Not provided.' is not applicable (#3634)", () => {
+  assert.equal(isVerificationNotApplicable("Not provided."), true);
+});
+
+test("isVerificationNotApplicable: 'Not provided' (no period) is not applicable (#3634)", () => {
+  assert.equal(isVerificationNotApplicable("Not provided"), true);
+});
+
+test("isVerificationNotApplicable: trailing period does not defeat match (#3634)", () => {
+  assert.equal(isVerificationNotApplicable("None required."), true);
+  assert.equal(isVerificationNotApplicable("N/A."), true);
+  assert.equal(isVerificationNotApplicable("Not applicable."), true);
+});

package/src/resources/extensions/gsd/tests/verify-artifact-tightened.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Regression test for #3607 — tighten verifyExpectedArtifact legacy branch
+ *
+ * The legacy (pre-migration) fallback in verifyExpectedArtifact previously
+ * accepted either a heading match (### T01 --) or a checked checkbox as proof
+ * that gsd_complete_task ran. A heading alone does not prove completion —
+ * it could result from a rogue write.
+ *
+ * The fix removes the hdRe heading regex and requires only a checked checkbox
+ * (cbRe) in the legacy branch, ensuring that only actual tool-completed tasks
+ * are treated as verified.
+ */
+
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+const src = readFileSync(
+  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'auto-recovery.ts'),
+  'utf-8',
+)
+
+describe('verifyExpectedArtifact legacy branch tightened (#3607)', () => {
+  it('legacy branch does NOT define hdRe heading regex', () => {
+    // Find the legacy fallback section
+    const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
+    assert.ok(legacyIdx !== -1, 'LEGACY comment must exist')
+
+    // Check the code within a reasonable window after the LEGACY comment
+    const legacyBlock = src.slice(legacyIdx, legacyIdx + 600)
+
+    assert.ok(
+      !legacyBlock.includes('hdRe'),
+      'hdRe heading regex must NOT exist in legacy branch — heading alone is not proof of completion',
+    )
+  })
+
+  it('legacy branch requires checked checkbox via cbRe', () => {
+    const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
+    assert.ok(legacyIdx !== -1)
+
+    const legacyBlock = src.slice(legacyIdx, legacyIdx + 600)
+
+    assert.ok(
+      legacyBlock.includes('cbRe'),
+      'cbRe checked-checkbox regex must exist in legacy branch',
+    )
+
+    // cbRe must match checked checkboxes [x] or [X]
+    assert.ok(
+      legacyBlock.includes('[xX]'),
+      'cbRe must match both [x] and [X] checkbox variants',
+    )
+  })
+
+  it('legacy branch returns false when no plan file exists', () => {
+    const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
+    assert.ok(legacyIdx !== -1)
+
+    const legacyBlock = src.slice(legacyIdx, legacyIdx + 1000)
+
+    // The else branch: no plan file means cannot verify
+    assert.ok(
+      legacyBlock.includes('no plan file'),
+      'missing plan file must be handled with return false',
+    )
+  })
+
+  it('DB available but task not found returns false', () => {
+    const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
+    assert.ok(legacyIdx !== -1)
+
+    const legacyBlock = src.slice(legacyIdx, legacyIdx + 1000)
+
+    assert.ok(
+      legacyBlock.includes('DB available but task row not found'),
+      'must handle case where DB is available but task row is missing',
+    )
+
+    // The comment should be followed by a return false
+    const commentIdx = legacyBlock.indexOf('DB available but task row not found')
+    const afterComment = legacyBlock.slice(commentIdx, commentIdx + 200)
+    assert.ok(
+      afterComment.includes('return false'),
+      'missing task row when DB available must return false',
+    )
+  })
+})

package/src/resources/extensions/gsd/tests/wave1-critical-regressions.test.ts

@@ -0,0 +1,49 @@
+// GSD State Machine — Wave 1 Critical Regression Tests
+// Validates fixes for event log format mismatch, skipped milestone status,
+// dead code removal, and replan disk-file fallback.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { extractEntityKey } from "../workflow-reconcile.js";
+import { isClosedStatus } from "../status-guards.js";
+import type { WorkflowEvent } from "../workflow-events.js";
+
+// ── Fix 1: Event log cmd format — hyphens and underscores both accepted ──
+
+describe("extractEntityKey normalizes cmd format", () => {
+  const baseEvent = { params: {}, ts: "", hash: "", actor: "agent" as const, session_id: "" };
+
+  test("accepts hyphenated complete-task", () => {
+    const event: WorkflowEvent = { ...baseEvent, cmd: "complete-task", params: { taskId: "T01" } };
+    const key = extractEntityKey(event);
+    assert.deepStrictEqual(key, { type: "task", id: "T01" });
+  });
+
+  test("accepts underscored complete_task (legacy)", () => {
+    const event: WorkflowEvent = { ...baseEvent, cmd: "complete_task", params: { taskId: "T01" } };
+    const key = extractEntityKey(event);
+    assert.deepStrictEqual(key, { type: "task", id: "T01" });
+  });
+
+  test("accepts hyphenated complete-slice", () => {
+    const event: WorkflowEvent = { ...baseEvent, cmd: "complete-slice", params: { sliceId: "S01" } };
+    const key = extractEntityKey(event);
+    assert.deepStrictEqual(key, { type: "slice", id: "S01" });
+  });
+
+  test("accepts hyphenated complete-milestone", () => {
+    const event: WorkflowEvent = { ...baseEvent, cmd: "complete-milestone", params: { milestoneId: "M001" } };
+    const key = extractEntityKey(event);
+    assert.deepStrictEqual(key, { type: "milestone", id: "M001" });
+  });
+});
+
+// ── Fix 3: getActiveMilestoneId must skip "skipped" milestones ──
+
+describe("isClosedStatus includes skipped", () => {
+  test("complete is closed", () => assert.ok(isClosedStatus("complete")));
+  test("done is closed", () => assert.ok(isClosedStatus("done")));
+  test("skipped is closed", () => assert.ok(isClosedStatus("skipped")));
+  test("pending is not closed", () => assert.ok(!isClosedStatus("pending")));
+  test("active is not closed", () => assert.ok(!isClosedStatus("active")));
+});

package/src/resources/extensions/gsd/tests/wave2-events-regressions.test.ts

@@ -0,0 +1,48 @@
+// GSD State Machine — Wave 2 Event Log Regression Tests
+// Validates fixes for appendEvent isolation, entity replay handlers,
+// and post-reconcile cache invalidation.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { extractEntityKey } from "../workflow-reconcile.js";
+import type { WorkflowEvent } from "../workflow-events.js";
+
+const base = { params: {}, ts: "", hash: "", actor: "agent" as const, session_id: "" };
+
+// ── Fix 8: New entity event types handled by extractEntityKey ──
+
+describe("extractEntityKey handles plan events", () => {
+  test("plan-milestone → milestone type", () => {
+    const event: WorkflowEvent = { ...base, cmd: "plan-milestone", params: { milestoneId: "M001" } };
+    const key = extractEntityKey(event);
+    assert.deepStrictEqual(key, { type: "milestone", id: "M001" });
+  });
+
+  test("plan-task → task type", () => {
+    const event: WorkflowEvent = { ...base, cmd: "plan-task", params: { taskId: "T01" } };
+    const key = extractEntityKey(event);
+    assert.deepStrictEqual(key, { type: "task", id: "T01" });
+  });
+
+  test("plan-slice preserves slice_plan type (conflict isolation)", () => {
+    const event: WorkflowEvent = { ...base, cmd: "plan-slice", params: { sliceId: "S01" } };
+    const key = extractEntityKey(event);
+    assert.deepStrictEqual(key, { type: "slice_plan", id: "S01" });
+  });
+
+  test("replan-slice → slice type", () => {
+    const event: WorkflowEvent = { ...base, cmd: "replan-slice", params: { sliceId: "S01" } };
+    const key = extractEntityKey(event);
+    assert.deepStrictEqual(key, { type: "slice", id: "S01" });
+  });
+});
+
+// ── Fix 8b: Unknown commands return null (don't crash) ──
+
+describe("extractEntityKey handles unknown commands gracefully", () => {
+  test("unknown-command returns null", () => {
+    const event: WorkflowEvent = { ...base, cmd: "unknown-future-cmd", params: { foo: "bar" } };
+    const key = extractEntityKey(event);
+    assert.strictEqual(key, null);
+  });
+});

package/src/resources/extensions/gsd/tests/wave3-session-regressions.test.ts

@@ -0,0 +1,47 @@
+// GSD State Machine — Wave 3 Session Regression Tests
+// Validates tri-state hasImplementationArtifacts and AutoSession.consecutiveCompleteBootstraps.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { hasImplementationArtifacts } from "../auto-recovery.js";
+import { AutoSession } from "../auto/session.js";
+
+// ── Fix 9: hasImplementationArtifacts returns tri-state ──
+
+describe("hasImplementationArtifacts tri-state return", () => {
+  test("returns 'unknown' for non-git directory", () => {
+    const result = hasImplementationArtifacts("/tmp/not-a-git-repo-" + Date.now());
+    assert.strictEqual(result, "unknown");
+  });
+
+  test("return type is one of present/absent/unknown", () => {
+    const result = hasImplementationArtifacts(process.cwd());
+    assert.ok(
+      result === "present" || result === "absent" || result === "unknown",
+      `Expected present/absent/unknown, got: ${result}`,
+    );
+  });
+});
+
+// ── Fix 11: consecutiveCompleteBootstraps is per-session ──
+
+describe("AutoSession.consecutiveCompleteBootstraps", () => {
+  test("initial value is 0", () => {
+    const s = new AutoSession();
+    assert.strictEqual(s.consecutiveCompleteBootstraps, 0);
+  });
+
+  test("reset() clears the counter", () => {
+    const s = new AutoSession();
+    s.consecutiveCompleteBootstraps = 5;
+    s.reset();
+    assert.strictEqual(s.consecutiveCompleteBootstraps, 0);
+  });
+
+  test("two sessions have independent counters", () => {
+    const s1 = new AutoSession();
+    const s2 = new AutoSession();
+    s1.consecutiveCompleteBootstraps = 3;
+    assert.strictEqual(s2.consecutiveCompleteBootstraps, 0);
+  });
+});

package/src/resources/extensions/gsd/tests/wave4-write-safety-regressions.test.ts

@@ -0,0 +1,70 @@
+// GSD State Machine — Wave 4 Write Safety Regression Tests
+// Validates randomized tmp suffix in json-persistence and atomic writes.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { saveJsonFile, loadJsonFile } from "../json-persistence.js";
+
+// ── Fix 15: json-persistence uses randomized tmp suffix ──
+
+describe("saveJsonFile atomic write", () => {
+  test("writes JSON file correctly", () => {
+    const tmp = mkdtempSync(join(tmpdir(), "gsd-json-test-"));
+    try {
+      const file = join(tmp, "test.json");
+      saveJsonFile(file, { key: "value" });
+      const content = JSON.parse(readFileSync(file, "utf-8"));
+      assert.deepStrictEqual(content, { key: "value" });
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test("no .tmp file left after successful write", () => {
+    const tmp = mkdtempSync(join(tmpdir(), "gsd-json-test-"));
+    try {
+      const file = join(tmp, "test.json");
+      saveJsonFile(file, { data: 123 });
+      const files = readdirSync(tmp);
+      const tmpFiles = files.filter((f: string) => f.includes(".tmp"));
+      assert.strictEqual(tmpFiles.length, 0, "No .tmp files should remain after write");
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test("concurrent writes don't corrupt data", () => {
+    const tmp = mkdtempSync(join(tmpdir(), "gsd-json-test-"));
+    try {
+      const file = join(tmp, "shared.json");
+      // Write two different values rapidly — both should succeed without corruption
+      saveJsonFile(file, { writer: "first" });
+      saveJsonFile(file, { writer: "second" });
+      const content = JSON.parse(readFileSync(file, "utf-8"));
+      assert.strictEqual(content.writer, "second");
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test("round-trip through loadJsonFile", () => {
+    const tmp = mkdtempSync(join(tmpdir(), "gsd-json-test-"));
+    try {
+      const file = join(tmp, "roundtrip.json");
+      const data = { items: [1, 2, 3], name: "test" };
+      saveJsonFile(file, data);
+      const loaded = loadJsonFile(
+        file,
+        (d): d is typeof data => typeof d === "object" && d !== null && "items" in d,
+        () => ({ items: [], name: "" }),
+      );
+      assert.deepStrictEqual(loaded.items, [1, 2, 3]);
+      assert.strictEqual(loaded.name, "test");
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/wave5-consistency-regressions.test.ts

@@ -0,0 +1,165 @@
+// GSD State Machine — Wave 5 Consistency Regression Tests
+// Validates isClosedStatus usage in projections, upsertDecision seq preservation,
+// event schema versioning, and replay round-trip with mixed cmd formats.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { isClosedStatus } from "../status-guards.js";
+import { openDatabase, closeDatabase, upsertDecision, _getAdapter, insertMilestone, insertSlice, insertTask, getTask } from "../gsd-db.js";
+import { extractEntityKey } from "../workflow-reconcile.js";
+import type { WorkflowEvent } from "../workflow-events.js";
+
+// ── Fix 19: isClosedStatus covers all closed statuses ──
+
+describe("isClosedStatus used by projections", () => {
+  test("skipped is closed (projections now show checked)", () => {
+    assert.ok(isClosedStatus("skipped"));
+  });
+  test("complete is closed", () => {
+    assert.ok(isClosedStatus("complete"));
+  });
+  test("done is closed", () => {
+    assert.ok(isClosedStatus("done"));
+  });
+  test("in-progress is not closed", () => {
+    assert.ok(!isClosedStatus("in-progress"));
+  });
+});
+
+// ── Fix 20: upsertDecision preserves seq on update ──
+
+describe("upsertDecision preserves seq column", () => {
+  test("seq is preserved when decision is re-upserted", () => {
+    const tmp = mkdtempSync(join(tmpdir(), "gsd-upsert-test-"));
+    const dbPath = join(tmp, "gsd.db");
+    try {
+      openDatabase(dbPath);
+      const adapter = _getAdapter();
+      assert.ok(adapter, "adapter must be available");
+
+      // Insert two decisions
+      upsertDecision({
+        id: "D001", when_context: "ctx1", scope: "s1",
+        decision: "d1", choice: "c1", rationale: "r1",
+        revisable: "yes", made_by: "agent", superseded_by: null,
+      });
+      upsertDecision({
+        id: "D002", when_context: "ctx2", scope: "s2",
+        decision: "d2", choice: "c2", rationale: "r2",
+        revisable: "yes", made_by: "agent", superseded_by: null,
+      });
+
+      // Get original seq values
+      const rows1 = adapter.prepare("SELECT id, seq FROM decisions ORDER BY seq").all() as Array<{ id: string; seq: number }>;
+      assert.strictEqual(rows1[0].id, "D001");
+      assert.strictEqual(rows1[1].id, "D002");
+      const d001OriginalSeq = rows1[0].seq;
+
+      // Re-upsert D001 with updated content
+      upsertDecision({
+        id: "D001", when_context: "updated", scope: "s1",
+        decision: "d1-updated", choice: "c1", rationale: "r1",
+        revisable: "yes", made_by: "agent", superseded_by: null,
+      });
+
+      // Verify seq is preserved (not moved to end)
+      const rows2 = adapter.prepare("SELECT id, seq FROM decisions ORDER BY seq").all() as Array<{ id: string; seq: number }>;
+      assert.strictEqual(rows2[0].id, "D001", "D001 should still be first by seq");
+      assert.strictEqual(rows2[0].seq, d001OriginalSeq, "D001 seq should be preserved");
+      assert.strictEqual(rows2[1].id, "D002", "D002 should still be second");
+
+      // Verify content was updated
+      const updated = adapter.prepare("SELECT decision FROM decisions WHERE id = 'D001'").get() as { decision: string };
+      assert.strictEqual(updated.decision, "d1-updated");
+
+      closeDatabase();
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+});
+
+// ── Fix 23: Event schema versioning ──
+
+describe("WorkflowEvent v field", () => {
+  test("appendEvent includes v:2 in output", async () => {
+    const tmp = mkdtempSync(join(tmpdir(), "gsd-event-v-test-"));
+    try {
+      const { appendEvent } = await import("../workflow-events.js");
+      appendEvent(tmp, {
+        cmd: "test-event",
+        params: { foo: "bar" },
+        ts: new Date().toISOString(),
+        actor: "system",
+      });
+
+      const logPath = join(tmp, ".gsd", "event-log.jsonl");
+      const line = readFileSync(logPath, "utf-8").trim();
+      const event = JSON.parse(line);
+      assert.strictEqual(event.v, 2, "New events should have v:2");
+      assert.strictEqual(event.cmd, "test-event");
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+});
+
+// ── Fix 19 (behavior-level): Projection rendering with skipped tasks ──
+
+describe("isClosedStatus drives projection checkbox logic", () => {
+  test("skipped task produces checked checkbox via isClosedStatus", () => {
+    // This tests the behavior contract that projections rely on:
+    // workflow-projections.ts uses isClosedStatus() to determine checkbox state.
+    // "skipped" tasks must render as [x], not [ ].
+    const statuses = ["complete", "done", "skipped"];
+    for (const status of statuses) {
+      assert.ok(
+        isClosedStatus(status),
+        `status "${status}" must be closed so projections render [x]`,
+      );
+    }
+    // Non-closed statuses must render as [ ]
+    for (const status of ["pending", "in-progress", "blocked", "active"]) {
+      assert.ok(
+        !isClosedStatus(status),
+        `status "${status}" must NOT be closed so projections render [ ]`,
+      );
+    }
+  });
+});
+
+// ── extractEntityKey: underscored cmds are recognized (Wave 5 scope) ──
+// Note: hyphenated cmd normalization is in Wave 1. These tests validate
+// the underscored format that Wave 5's extractEntityKey handles directly.
+
+describe("extractEntityKey recognizes underscored cmds", () => {
+  const base: WorkflowEvent = { cmd: "", params: {}, ts: "", hash: "", actor: "agent", session_id: "" };
+
+  test("complete_task → task entity", () => {
+    const key = extractEntityKey({ ...base, cmd: "complete_task", params: { taskId: "T01" } });
+    assert.deepStrictEqual(key, { type: "task", id: "T01" });
+  });
+
+  test("complete_slice → slice entity", () => {
+    const key = extractEntityKey({ ...base, cmd: "complete_slice", params: { sliceId: "S01" } });
+    assert.deepStrictEqual(key, { type: "slice", id: "S01" });
+  });
+
+  test("plan_slice → slice_plan entity (distinct from complete)", () => {
+    const key = extractEntityKey({ ...base, cmd: "plan_slice", params: { sliceId: "S01" } });
+    assert.deepStrictEqual(key, { type: "slice_plan", id: "S01" });
+  });
+
+  test("save_decision → decision entity", () => {
+    const key = extractEntityKey({ ...base, cmd: "save_decision", params: { scope: "s", decision: "d" } });
+    assert.deepStrictEqual(key, { type: "decision", id: "s:d" });
+  });
+
+  test("unknown cmd returns null (not crash)", () => {
+    const key = extractEntityKey({ ...base, cmd: "future_unknown_cmd", params: {} });
+    assert.strictEqual(key, null);
+  });
+});

package/src/resources/extensions/gsd/tests/worker-model-override.test.ts

@@ -0,0 +1,48 @@
+/**
+ * Worker model override — tests for parallel.worker_model preference.
+ *
+ * Verifies validation, resolveParallelConfig pass-through, and type definitions.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const typesSrc = readFileSync(join(__dirname, "..", "types.ts"), "utf-8");
+const validationSrc = readFileSync(join(__dirname, "..", "preferences-validation.ts"), "utf-8");
+const preferencesSrc = readFileSync(join(__dirname, "..", "preferences.ts"), "utf-8");
+
+// ─── Type definition ──────────────────────────────────────────────────────
+
+test("ParallelConfig includes worker_model optional field", () => {
+  assert.ok(
+    typesSrc.includes("worker_model?: string"),
+    "ParallelConfig should have optional worker_model field",
+  );
+});
+
+// ─── Validation ───────────────────────────────────────────────────────────
+
+test("validatePreferences accepts valid worker_model string", () => {
+  assert.ok(
+    validationSrc.includes("p.worker_model"),
+    "validation should check parallel.worker_model",
+  );
+  assert.ok(
+    validationSrc.includes('parallel.worker_model must be a non-empty string'),
+    "validation should reject invalid worker_model",
+  );
+});
+
+// ─── resolveParallelConfig ────────────────────────────────────────────────
+
+test("resolveParallelConfig passes through worker_model", () => {
+  assert.ok(
+    preferencesSrc.includes("worker_model: prefs?.parallel?.worker_model"),
+    "resolveParallelConfig should pass through worker_model",
+  );
+});

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

@@ -90,18 +90,21 @@ describe("workflow-logger audit persistence", () => {
     assert.ok(ctx, "context should exist");
     assert.equal(ctx.fn, "saveDecisionToDb");
     assert.equal(ctx.tool, "gsd_decision_save");
-    assert.equal(ctx.error, undefined, "error key must be stripped from persisted context");
+    assert.equal(ctx.error, "SQLITE_BUSY: database is locked", "error key should be preserved in persisted context");
     assert.equal(ctx.file, undefined, "file key must be stripped from persisted context");
   });
 
-  test("persisted errors omit context when no safe keys present", () => {
+  test("persisted errors preserve error key but strip other unsafe keys", () => {
     logError("bootstrap", "ensureDbOpen failed", {
       error: "ENOENT",
       cwd: "/home/user/project",
     });
     const lines = readAuditLines(tmp);
     assert.equal(lines.length, 1);
-    assert.equal(lines[0].context, undefined, "context should be omitted when no safe keys match");
+    const ctx = lines[0].context as Record<string, string>;
+    assert.ok(ctx, "context should exist when error key is present");
+    assert.equal(ctx.error, "ENOENT", "error key should be preserved");
+    assert.equal(ctx.cwd, undefined, "cwd key must be stripped");
   });
 
   test("mixed warnings and errors only persist errors", () => {

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

@@ -0,0 +1,38 @@
+/**
+ * worktree-expected-warnings.test.ts — #3665
+ *
+ * Verify that auto-worktree.ts and worktree-manager.ts suppress expected
+ * ENOENT and EISDIR conditions instead of logging misleading warnings.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const autoWorktreeFile = join(__dirname, "..", "auto-worktree.ts");
+const worktreeManagerFile = join(__dirname, "..", "worktree-manager.ts");
+
+describe("worktree expected-condition warning suppression (#3665)", () => {
+  const autoSource = readFileSync(autoWorktreeFile, "utf-8");
+
+  test("auto-worktree.ts checks for ENOENT before logging unlink warning", () => {
+    assert.match(autoSource, /code\s*!==\s*["']ENOENT["']/);
+  });
+
+  test("auto-worktree.ts checks for EISDIR before logging unlink warning", () => {
+    assert.match(autoSource, /code\s*!==\s*["']EISDIR["']/);
+  });
+
+  test("auto-worktree.ts references issue #3597", () => {
+    assert.match(autoSource, /#3597/);
+  });
+
+  const managerSource = readFileSync(worktreeManagerFile, "utf-8");
+
+  test("worktree-manager.ts checks isDirectory() before reading .git file", () => {
+    assert.match(managerSource, /lstatSync\(gitPath\)\.isDirectory\(\)/);
+  });
+});

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

@@ -26,9 +26,11 @@ import {
   getSliceBranchName,
   autoCommitCurrentBranch,
   SLICE_BRANCH_RE,
+  _resetServiceCache,
 } from "../worktree.ts";
 
 import { deriveState } from "../state.ts";
+import { _clearGsdRootCache } from "../paths.ts";
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -74,6 +76,14 @@ run("git add .", base);
 run('git commit -m "chore: init"', base);
 
 describe('worktree-integration', async () => {
+  // Isolate from user's global preferences (which may have git.main_branch set).
+  // Reset caches so getService() creates a fresh instance with empty preferences.
+  const originalHome = process.env.HOME;
+  const fakeHome = mkdtempSync(join(tmpdir(), "gsd-fake-home-"));
+  process.env.HOME = fakeHome;
+  _clearGsdRootCache();
+  _resetServiceCache();
+
   // ── Verify main tree baseline ──────────────────────────────────────────────
 
   console.log("\n=== Main tree baseline ===");
@@ -197,4 +207,10 @@ describe('worktree-integration', async () => {
   assert.deepStrictEqual(listWorktrees(base).length, 0, "all worktrees removed");
 
   rmSync(base, { recursive: true, force: true });
+
+  // Restore HOME and reset caches
+  process.env.HOME = originalHome;
+  _clearGsdRootCache();
+  _resetServiceCache();
+  rmSync(fakeHome, { recursive: true, force: true });
 });