gsd-pi 2.65.0 → 2.66.0-dev.6c91c1f

package/src/resources/extensions/gsd/tests/stale-lockfile-recovery.test.ts

@@ -0,0 +1,36 @@
+/**
+ * stale-lockfile-recovery.test.ts — #3668
+ *
+ * Verify that session-lock.ts contains pre-flight stale lock cleanup logic
+ * that removes orphaned lock directories when the owning PID is dead,
+ * preventing the 30-min stale window from blocking /gsd after crashes.
+ */
+
+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 sourceFile = join(__dirname, "..", "session-lock.ts");
+
+describe("stale lockfile auto-recovery (#3668)", () => {
+  const source = readFileSync(sourceFile, "utf-8");
+
+  test("checks for orphan lock with isPidAlive", () => {
+    assert.match(source, /isPidAlive\(existingData\.pid\)/);
+  });
+
+  test("removes stale lock directory with rmSync", () => {
+    assert.match(source, /rmSync\(lockDir,\s*\{\s*recursive:\s*true/);
+  });
+
+  test("references issue #3218 in pre-flight cleanup comment", () => {
+    assert.match(source, /#3218.*Pre-flight stale lock cleanup/);
+  });
+
+  test("provides actionable rm -rf workaround in error message", () => {
+    assert.match(source, /rm\s+-rf/);
+  });
+});

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

@@ -0,0 +1,147 @@
+/**
+ * Regression test for #3470: DB-backed active milestone selection must not
+ * prefer a stale queued shell over the real active milestone.
+ *
+ * Scenario: M068 is a queued placeholder (DB row, no files, no slices).
+ * M070 is the real active milestone (context, roadmap, slices, tasks).
+ * deriveStateFromDb() must select M070 as active, not M068.
+ */
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { deriveStateFromDb, invalidateStateCache } from "../state.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from "../gsd-db.ts";
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-stale-milestone-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function writeFile(base: string, relativePath: string, content: string): void {
+  const full = join(base, ".gsd", relativePath);
+  mkdirSync(join(full, ".."), { recursive: true });
+  writeFileSync(full, content);
+}
+
+describe("stale queued milestone selection (#3470)", () => {
+  let base: string;
+
+  afterEach(() => {
+    closeDatabase();
+    if (base) rmSync(base, { recursive: true, force: true });
+  });
+
+  test("queued shell with no content does not block real active milestone", async () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+
+    // M068: queued shell — DB row exists, no files, no slices
+    insertMilestone({ id: "M068", title: "Queued Shell", status: "queued" });
+
+    // M070: real active milestone — context, roadmap, slices, tasks
+    insertMilestone({ id: "M070", title: "Real Active", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M070", title: "Slice One", status: "active", risk: "low", depends: [] });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M070", title: "Task One", status: "pending" });
+
+    writeFile(base, "milestones/M070/M070-CONTEXT.md", "# M070: Real Active\n\nThis is the real milestone.");
+    writeFile(base, "milestones/M070/M070-ROADMAP.md", "# M070: Real Active\n\n## Slices\n\n- [ ] **S01: Slice One**");
+    writeFile(base, "milestones/M070/slices/S01/S01-PLAN.md", "# S01: Slice One\n\n## Tasks\n\n- [ ] **T01: Task One**");
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    assert.equal(state.activeMilestone?.id, "M070", "Active milestone must be M070, not queued shell M068");
+
+    // M068 should appear as pending in registry, not active
+    const m068Entry = state.registry.find((e: any) => e.id === "M068");
+    assert.ok(m068Entry, "M068 should still appear in registry");
+    assert.equal(m068Entry!.status, "pending", "M068 should be pending, not active");
+
+    // M070 should be active in registry
+    const m070Entry = state.registry.find((e: any) => e.id === "M070");
+    assert.ok(m070Entry, "M070 should appear in registry");
+    assert.equal(m070Entry!.status, "active", "M070 should be active in registry");
+  });
+
+  test("queued milestone WITH context file can still be selected as active", async () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+
+    // M068: queued but has context (discussion started) — should be activatable
+    insertMilestone({ id: "M068", title: "Queued With Context", status: "queued" });
+    writeFile(base, "milestones/M068/M068-CONTEXT.md", "# M068: Queued With Context\n\nDiscussion started.");
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    assert.equal(state.activeMilestone?.id, "M068", "Queued milestone with context should become active");
+  });
+
+  test("queued milestone WITH context-draft can still be selected as active", async () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+
+    // M068: queued but has draft (discussion in progress)
+    insertMilestone({ id: "M068", title: "Queued With Draft", status: "queued" });
+    writeFile(base, "milestones/M068/M068-CONTEXT-DRAFT.md", "# M068: Queued With Draft\n\nDraft in progress.");
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    assert.equal(state.activeMilestone?.id, "M068", "Queued milestone with draft should become active");
+  });
+
+  test("queued milestone WITH slices can still be selected as active", async () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+
+    // M068: queued but has slices (planning started)
+    insertMilestone({ id: "M068", title: "Queued With Slices", status: "queued" });
+    insertSlice({ id: "S01", milestoneId: "M068", title: "Slice One", status: "pending", risk: "low", depends: [] });
+    writeFile(base, "milestones/M068/M068-ROADMAP.md", "# M068\n\n## Slices\n\n- [ ] **S01: Slice One**");
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    assert.equal(state.activeMilestone?.id, "M068", "Queued milestone with slices should become active");
+  });
+
+  test("multiple queued shells all skipped in favor of real active", async () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+
+    // Three queued shells before the real milestone
+    insertMilestone({ id: "M065", title: "Shell 1", status: "queued" });
+    insertMilestone({ id: "M066", title: "Shell 2", status: "queued" });
+    insertMilestone({ id: "M068", title: "Shell 3", status: "queued" });
+
+    // M070: real active
+    insertMilestone({ id: "M070", title: "Real Active", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M070", title: "Slice One", status: "active", risk: "low", depends: [] });
+    writeFile(base, "milestones/M070/M070-CONTEXT.md", "# M070: Real Active");
+    writeFile(base, "milestones/M070/M070-ROADMAP.md", "# M070\n\n## Slices\n\n- [ ] **S01: Slice One**");
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    assert.equal(state.activeMilestone?.id, "M070", "Must skip all queued shells to reach M070");
+
+    // All shells should be pending
+    for (const id of ["M065", "M066", "M068"]) {
+      const entry = state.registry.find((e: any) => e.id === id);
+      assert.ok(entry, `${id} should be in registry`);
+      assert.equal(entry!.status, "pending", `${id} should be pending, not active`);
+    }
+  });
+});

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

@@ -17,6 +17,8 @@ import {
   teardownAutoWorktree,
   mergeMilestoneToMain,
 } from "../auto-worktree.ts";
+import { _resetServiceCache } from "../worktree.ts";
+import { _clearGsdRootCache } from "../paths.ts";
 
 function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
@@ -62,6 +64,13 @@ test("mergeMilestoneToMain restores cwd to project root", () => {
   const savedCwd = process.cwd();
   let tempDir = "";
 
+  // Isolate from user's global preferences (which may have git.main_branch set)
+  const originalHome = process.env.HOME;
+  const fakeHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-fake-home-")));
+  process.env.HOME = fakeHome;
+  _clearGsdRootCache();
+  _resetServiceCache();
+
   try {
     tempDir = createTempRepo();
 
@@ -97,9 +106,13 @@ test("mergeMilestoneToMain restores cwd to project root", () => {
     assert.ok(!existsSync(wtPath), "worktree directory removed after merge");
   } finally {
     process.chdir(savedCwd);
+    process.env.HOME = originalHome;
+    _clearGsdRootCache();
+    _resetServiceCache();
     if (tempDir && existsSync(tempDir)) {
       rmSync(tempDir, { recursive: true, force: true });
     }
+    rmSync(fakeHome, { recursive: true, force: true });
   }
 });
 

package/src/resources/extensions/gsd/tests/stash-pop-gsd-conflict.test.ts

@@ -15,6 +15,27 @@ import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
 import { createAutoWorktree, mergeMilestoneToMain } from "../auto-worktree.ts";
+import { _resetServiceCache } from "../worktree.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+
+// Isolate from user's global preferences (which may have git.main_branch set)
+let originalHome: string | undefined;
+let fakeHome: string;
+
+test.before(() => {
+  originalHome = process.env.HOME;
+  fakeHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-fake-home-")));
+  process.env.HOME = fakeHome;
+  _clearGsdRootCache();
+  _resetServiceCache();
+});
+
+test.after(() => {
+  process.env.HOME = originalHome;
+  _clearGsdRootCache();
+  _resetServiceCache();
+  rmSync(fakeHome, { recursive: true, force: true });
+});
 
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();

package/src/resources/extensions/gsd/tests/stash-queued-context-files.test.ts

@@ -27,6 +27,27 @@ import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
 import { createAutoWorktree, mergeMilestoneToMain } from "../auto-worktree.ts";
+import { _resetServiceCache } from "../worktree.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+
+// Isolate from user's global preferences (which may have git.main_branch set)
+let originalHome: string | undefined;
+let fakeHome: string;
+
+test.before(() => {
+  originalHome = process.env.HOME;
+  fakeHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-fake-home-")));
+  process.env.HOME = fakeHome;
+  _clearGsdRootCache();
+  _resetServiceCache();
+});
+
+test.after(() => {
+  process.env.HOME = originalHome;
+  _clearGsdRootCache();
+  _resetServiceCache();
+  rmSync(fakeHome, { recursive: true, force: true });
+});
 
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, {

package/src/resources/extensions/gsd/tests/state-machine-full-walkthrough.test.ts

@@ -1040,8 +1040,8 @@ describe("state-machine-full-walkthrough", () => {
   // FAILURE MODES: What happens when things go wrong
   // ═══════════════════════════════════════════════════════════════════════════
 
-  describe("Failure: DB has slice but no task rows (partial migration)", () => {
-    test("DB tasks empty but PLAN on disk has tasks → wrong phase (planning)", async () => {
+  describe("Recovery: DB has slice but no task rows (partial migration)", () => {
+    test("DB tasks empty but PLAN on disk has tasks → reconciles to executing", async () => {
       const base = createFixtureBase();
       const dbPath = join(base, ".gsd", "gsd.db");
       openDatabase(dbPath);
@@ -1056,11 +1056,10 @@ describe("state-machine-full-walkthrough", () => {
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // BUG: Returns "planning" because getSliceTasks() returns []
-      // and line 703 treats empty tasks as "no tasks defined".
-      // PLAN file on disk has T01/T02 but DB doesn't know about them.
-      assert.equal(state.phase, "planning",
-        "KNOWN ISSUE: DB empty tasks → planning even though PLAN has tasks on disk");
+      // FIX (#3600): plan-file tasks are now reconciled into the DB,
+      // so the phase correctly advances to executing instead of planning.
+      assert.equal(state.phase, "executing",
+        "reconciled plan-file tasks → executing (not stuck in planning)");
     });
   });
 

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

@@ -0,0 +1,47 @@
+/**
+ * Regression test for #3691 — /gsd status opens DB before deriveState
+ *
+ * In cold sessions the DB was not opened before deriveState, causing
+ * status to fall back to filesystem-only state.  The fix adds an
+ * ensureDbOpen() call before deriveState in handleStatus.
+ *
+ * Also verifies that quick.ts checks getIsolationMode before branching.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const coreSrc = readFileSync(
+  join(__dirname, '..', 'commands', 'handlers', 'core.ts'),
+  'utf-8',
+);
+const quickSrc = readFileSync(
+  join(__dirname, '..', 'quick.ts'),
+  'utf-8',
+);
+
+describe('status opens DB before deriveState (#3691)', () => {
+  test('handleStatus calls ensureDbOpen before deriveState', () => {
+    const ensureIdx = coreSrc.indexOf('ensureDbOpen');
+    const deriveIdx = coreSrc.indexOf('deriveState(basePath)');
+    assert.ok(ensureIdx > -1, 'ensureDbOpen call should exist in core.ts');
+    assert.ok(deriveIdx > -1, 'deriveState(basePath) call should exist in core.ts');
+    assert.ok(
+      ensureIdx < deriveIdx,
+      'ensureDbOpen must appear before deriveState so DB is ready',
+    );
+  });
+
+  test('quick.ts checks getIsolationMode before branching', () => {
+    assert.match(quickSrc, /getIsolationMode\(\)/,
+      'quick.ts should call getIsolationMode()');
+    assert.match(quickSrc, /getIsolationMode\(\)\s*!==\s*"none"/,
+      'quick.ts should compare isolation mode against "none"');
+  });
+});

package/src/resources/extensions/gsd/tests/stuck-detection-coverage.test.ts

@@ -165,6 +165,7 @@ test("Rule 4: ENOENT paths non-consecutive still triggers", () => {
   assert.ok(result!.reason.includes("/missing/skill"), `reason was: ${result!.reason}`);
 });
 
+
 // ─── Gap documentation: 3-unit cycle evades detection ────────────────────────
 
 test("Three-unit cycle A-B-C-A-B-C does NOT trigger stuck (documents gap L13)", () => {

package/src/resources/extensions/gsd/tests/subagent-agent-discovery.test.ts

@@ -42,3 +42,50 @@ test("discoverAgents falls back to legacy .pi/agents when needed", (t) => {
 	assert.equal(discovery.projectAgentsDir, agentsDir);
 	assert.deepEqual(discovery.agents.map((agent) => agent.name), ["ping"]);
 });
+
+test("discoverAgents accepts tools frontmatter as a YAML list", (t) => {
+	const root = makeProjectRoot(t);
+	const agentsDir = join(root, ".gsd", "agents");
+	mkdirSync(agentsDir, { recursive: true });
+	writeFileSync(
+		join(agentsDir, "reviewer.md"),
+		[
+			"---",
+			"name: reviewer",
+			"description: review agent",
+			"tools:",
+			"  - bash",
+			"  - read",
+			"---",
+			"Review code",
+			"",
+		].join("\n"),
+	);
+
+	const discovery = discoverAgents(root, "project");
+
+	assert.deepEqual(discovery.agents.map((agent) => agent.name), ["reviewer"]);
+	assert.deepEqual(discovery.agents[0]?.tools, ["bash", "read"]);
+});
+
+test("discoverAgents still accepts comma-separated tools frontmatter", (t) => {
+	const root = makeProjectRoot(t);
+	const agentsDir = join(root, ".gsd", "agents");
+	mkdirSync(agentsDir, { recursive: true });
+	writeFileSync(
+		join(agentsDir, "reviewer.md"),
+		[
+			"---",
+			"name: reviewer",
+			"description: review agent",
+			"tools: bash, read",
+			"---",
+			"Review code",
+			"",
+		].join("\n"),
+	);
+
+	const discovery = discoverAgents(root, "project");
+
+	assert.deepEqual(discovery.agents[0]?.tools, ["bash", "read"]);
+});

package/src/resources/extensions/gsd/tests/symlink-extension-discovery.test.ts

@@ -0,0 +1,125 @@
+// Regression test for: discoverManifests() skips symlinked extension directories
+//
+// The bug: Dirent.isDirectory() returns false for symlinks, so extensions installed
+// as directory symlinks under ~/.gsd/agent/extensions/ were invisible to all
+// management commands (list, enable, disable, info).
+//
+// The fix: check `entry.isDirectory() || entry.isSymbolicLink()`, matching the
+// pattern already used in loader.ts discoverExtensionsInDir().
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  symlinkSync,
+  readdirSync,
+  existsSync,
+  rmSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+// Inline the discovery logic so the test is self-contained and can verify both
+// the buggy and fixed behaviour without importing the private function.
+function discoverManifestsBuggy(extDir: string): string[] {
+  const found: string[] = [];
+  if (!existsSync(extDir)) return found;
+  for (const entry of readdirSync(extDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue; // BUG: skips symlinks
+    const mPath = join(extDir, entry.name, "extension-manifest.json");
+    if (existsSync(mPath)) found.push(entry.name);
+  }
+  return found;
+}
+
+function discoverManifestsFixed(extDir: string): string[] {
+  const found: string[] = [];
+  if (!existsSync(extDir)) return found;
+  for (const entry of readdirSync(extDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue; // FIX
+    const mPath = join(extDir, entry.name, "extension-manifest.json");
+    if (existsSync(mPath)) found.push(entry.name);
+  }
+  return found;
+}
+
+const MANIFEST = JSON.stringify({
+  id: "test-ext",
+  name: "Test Extension",
+  version: "1.0.0",
+  description: "A test extension",
+  tier: "community",
+  requires: { platform: "linux" },
+});
+
+describe("symlink extension discovery", () => {
+  let tmp: string;
+  let extDir: string;
+  let realExtDir: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "gsd-ext-test-"));
+    extDir = join(tmp, "agent", "extensions");
+    realExtDir = join(tmp, "my-ext-source");
+
+    // Create the real extension directory outside extDir (simulates a dev checkout)
+    mkdirSync(realExtDir, { recursive: true });
+    writeFileSync(join(realExtDir, "extension-manifest.json"), MANIFEST, "utf-8");
+
+    // Create the extensions scan directory
+    mkdirSync(extDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test("real directory is discovered by both implementations", () => {
+    // Install extension as a real directory copy
+    const realCopy = join(extDir, "my-ext");
+    mkdirSync(realCopy);
+    writeFileSync(join(realCopy, "extension-manifest.json"), MANIFEST, "utf-8");
+
+    assert.deepEqual(discoverManifestsBuggy(extDir), ["my-ext"]);
+    assert.deepEqual(discoverManifestsFixed(extDir), ["my-ext"]);
+  });
+
+  test("symlinked directory is missed by buggy implementation", () => {
+    // Install extension as a directory symlink — the common dev workflow
+    symlinkSync(realExtDir, join(extDir, "my-ext"));
+
+    // Buggy: symlink is invisible
+    assert.deepEqual(discoverManifestsBuggy(extDir), []);
+  });
+
+  test("symlinked directory is discovered by fixed implementation", () => {
+    symlinkSync(realExtDir, join(extDir, "my-ext"));
+
+    // Fixed: symlink is visible
+    assert.deepEqual(discoverManifestsFixed(extDir), ["my-ext"]);
+  });
+
+  test("non-manifest symlinks are ignored", () => {
+    // Symlink to a dir that has no manifest — should not appear
+    const noManifestDir = join(tmp, "no-manifest");
+    mkdirSync(noManifestDir);
+    symlinkSync(noManifestDir, join(extDir, "no-manifest"));
+
+    assert.deepEqual(discoverManifestsFixed(extDir), []);
+  });
+
+  test("mix of real dirs and symlinks are all discovered", () => {
+    // Real dir
+    const realCopy = join(extDir, "ext-real");
+    mkdirSync(realCopy);
+    writeFileSync(join(realCopy, "extension-manifest.json"), MANIFEST, "utf-8");
+
+    // Symlink dir
+    symlinkSync(realExtDir, join(extDir, "ext-symlink"));
+
+    const found = discoverManifestsFixed(extDir).sort();
+    assert.deepEqual(found, ["ext-real", "ext-symlink"]);
+  });
+});

package/src/resources/extensions/gsd/tests/sync-worktree-skip-current.test.ts

@@ -0,0 +1,65 @@
+/**
+ * Regression test for #3641 — syncWorktreeStateBack skips current milestone
+ *
+ * When syncing worktree state back to main, the current milestone being
+ * merged should be skipped. Its files are already in the milestone branch
+ * and copying them back would conflict with the squash merge.
+ *
+ * The fix adds a `mid === milestoneId` skip guard inside the milestone
+ * iteration loop in syncWorktreeStateBack.
+ */
+
+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-worktree.ts'),
+  'utf-8',
+)
+
+describe('syncWorktreeStateBack skips current milestone (#3641)', () => {
+  it('syncWorktreeStateBack function exists', () => {
+    assert.ok(
+      src.includes('function syncWorktreeStateBack('),
+      'syncWorktreeStateBack function must be defined',
+    )
+  })
+
+  it('mid === milestoneId skip guard exists in the milestone loop', () => {
+    // Find syncWorktreeStateBack
+    const fnStart = src.indexOf('function syncWorktreeStateBack(')
+    assert.ok(fnStart !== -1)
+
+    // Get a reasonable portion of the function
+    const fnBlock = src.slice(fnStart, fnStart + 3000)
+
+    // Find the for loop iterating milestones
+    const loopIdx = fnBlock.indexOf('for (const mid of wtMilestones)')
+    assert.ok(loopIdx !== -1, 'milestone iteration loop must exist')
+
+    // After the loop, there should be the skip guard
+    const loopBody = fnBlock.slice(loopIdx, loopIdx + 300)
+    assert.ok(
+      loopBody.includes('mid === milestoneId'),
+      'mid === milestoneId skip guard must exist inside the milestone loop',
+    )
+    assert.ok(
+      loopBody.includes('continue'),
+      'skip guard must use continue to skip the current milestone',
+    )
+  })
+
+  it('syncMilestoneDir is still called for non-current milestones', () => {
+    const fnStart = src.indexOf('function syncWorktreeStateBack(')
+    assert.ok(fnStart !== -1)
+
+    const fnBlock = src.slice(fnStart, fnStart + 3000)
+
+    assert.ok(
+      fnBlock.includes('syncMilestoneDir('),
+      'syncMilestoneDir must still be called for other milestones',
+    )
+  })
+})

package/src/resources/extensions/gsd/tests/tool-invocation-error-loop-break.test.ts

@@ -44,7 +44,7 @@ describe("#2883: tool invocation error tracking on AutoSession", () => {
 
 // ─── isToolInvocationError classifier ────────────────────────────────────
 
-import { isToolInvocationError } from "../auto-tool-tracking.ts";
+import { isToolInvocationError, isQueuedUserMessageSkip } from "../auto-tool-tracking.ts";
 
 describe("#2883: isToolInvocationError classification", () => {
   test("detects JSON validation failure pattern", () => {
@@ -101,3 +101,31 @@ describe("#2883: isToolInvocationError classification", () => {
     assert.equal(isToolInvocationError("ECONNRESET"), false);
   });
 });
+
+// ─── isQueuedUserMessageSkip classifier (#3595) ─────────────────────────
+
+describe("#3595: isQueuedUserMessageSkip classification", () => {
+  test("detects exact skip message with period", () => {
+    assert.equal(isQueuedUserMessageSkip("Skipped due to queued user message."), true);
+  });
+
+  test("detects skip message without period", () => {
+    assert.equal(isQueuedUserMessageSkip("Skipped due to queued user message"), true);
+  });
+
+  test("detects skip message with surrounding whitespace", () => {
+    assert.equal(isQueuedUserMessageSkip("  Skipped due to queued user message.  "), true);
+  });
+
+  test("returns false for normal tool errors", () => {
+    assert.equal(isQueuedUserMessageSkip("Slice S01 is already complete"), false);
+  });
+
+  test("returns false for empty string", () => {
+    assert.equal(isQueuedUserMessageSkip(""), false);
+  });
+
+  test("returns false for partial match (substring)", () => {
+    assert.equal(isQueuedUserMessageSkip("Error: Skipped due to queued user message. Retry later."), false);
+  });
+});

package/src/resources/extensions/gsd/tests/triage-resolution.test.ts

@@ -387,7 +387,8 @@ test("resolution: executeTriageResolutions handles mixed classifications", () =>
     assert.strictEqual(result.injected, 1, "should inject 1 task");
     assert.strictEqual(result.replanned, 0);
     assert.strictEqual(result.quickTasks.length, 1, "should queue 1 quick-task");
-    assert.strictEqual(result.actions.length, 2, "should have 2 action entries (note/defer excluded)");
+    // inject + quick-task + note acknowledged = 3 actions (defer still excluded)
+    assert.strictEqual(result.actions.length, 3, "should have 3 action entries (defer excluded, note now included)");
   } finally {
     rmSync(tmp, { recursive: true, force: true });
   }