gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.eaa4973bc

package/src/resources/extensions/gsd/tests/queue-auto-guard.test.ts

@@ -0,0 +1,181 @@
+/**
+ * Tests that /gsd queue is blocked when auto-mode is active.
+ *
+ * Relates to #4704: /gsd queue writes .gsd/PROJECT.md + QUEUE-ORDER.json
+ * directly into the project-root worktree, racing with auto-mode's
+ * pre-merge dirty-tree check and causing __dirty_working_tree__ failures.
+ *
+ * The fix adds an isAutoActive() guard in handleWorkflowCommand before
+ * delegating to showQueue, mirroring the existing /gsd quick guard (#2417).
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Structural test: verify the guard exists in source ──────────────────────
+
+describe("/gsd queue auto-mode guard (#4704)", () => {
+  it("handleWorkflowCommand checks isAutoActive() before calling showQueue", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    // Find the queue command block
+    const queueBlockMatch = src.match(
+      /if\s*\(\s*trimmed\s*===\s*"queue"\s*\)\s*\{([\s\S]*?)\n  \}/,
+    );
+    assert.ok(queueBlockMatch, "queue command block exists in handleWorkflowCommand");
+
+    const queueBlock = queueBlockMatch[1];
+
+    // Verify auto-mode guard comes BEFORE showQueue call. Accepts either the
+    // inline isAutoActive() check (Tier 1) or the shared requireNotAutoActive()
+    // helper (Tier 2 / #4712).
+    const guardIndex = Math.max(
+      queueBlock.indexOf("isAutoActive()"),
+      queueBlock.indexOf("requireNotAutoActive("),
+    );
+    const showQueueIndex = queueBlock.indexOf("showQueue(");
+
+    assert.ok(guardIndex !== -1, "auto-mode guard exists in queue command block");
+    assert.ok(showQueueIndex !== -1, "showQueue() call exists in queue command block");
+    assert.ok(
+      guardIndex < showQueueIndex,
+      "auto-mode guard appears before showQueue() call",
+    );
+  });
+
+  it("guard shows error message mentioning /gsd stop", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    assert.ok(
+      src.includes("cannot run while auto-mode is active"),
+      "error message explains that the command cannot run during auto-mode",
+    );
+    assert.ok(
+      src.includes("/gsd stop"),
+      "error message mentions /gsd stop as the resolution",
+    );
+  });
+
+  it("guard returns true (handled) to prevent falling through", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    const queueBlockMatch = src.match(
+      /if\s*\(\s*trimmed\s*===\s*"queue"\s*\)\s*\{([\s\S]*?)\n  \}/,
+    );
+    assert.ok(queueBlockMatch);
+    const queueBlock = queueBlockMatch[1];
+
+    // The guard block should have its own return true before showQueue
+    const guardBlock = queueBlock.slice(0, queueBlock.indexOf("showQueue("));
+    assert.ok(
+      guardBlock.includes("return true"),
+      "guard block returns true before showQueue is reached",
+    );
+  });
+});
+
+// ─── .gsd/audit/ runtime classification regression ──────────────────────────
+
+describe(".gsd/audit/ runtime classification (#4704)", () => {
+  it("GSD_RUNTIME_PATTERNS in gitignore.ts includes .gsd/audit/", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "gitignore.ts"),
+      "utf-8",
+    );
+    assert.ok(
+      src.includes('".gsd/audit/"'),
+      ".gsd/audit/ listed in GSD_RUNTIME_PATTERNS",
+    );
+  });
+
+  it("RUNTIME_EXCLUSION_PATHS in git-service.ts includes .gsd/audit/", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "git-service.ts"),
+      "utf-8",
+    );
+    assert.ok(
+      src.includes('".gsd/audit/"'),
+      ".gsd/audit/ listed in RUNTIME_EXCLUSION_PATHS",
+    );
+  });
+
+  it("SKIP_PATHS in worktree-manager.ts includes .gsd/audit/", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "worktree-manager.ts"),
+      "utf-8",
+    );
+    assert.ok(
+      src.includes('".gsd/audit/"'),
+      ".gsd/audit/ listed in SKIP_PATHS",
+    );
+  });
+});
+
+// ─── Windows gsd.db close+reopen around pre-merge stash ─────────────────────
+
+describe("Windows pre-merge DB release (#4704)", () => {
+  it("mergeMilestoneToMain closes gsd.db on win32 before git stash", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "auto-worktree.ts"),
+      "utf-8",
+    );
+
+    // Locate the stash push line and ensure a win32-gated closeDatabase()
+    // call precedes it in the same function scope.
+    const stashIndex = src.indexOf('"stash", "push", "--include-untracked"');
+    assert.ok(stashIndex !== -1, "pre-merge stash push exists");
+
+    const beforeStash = src.slice(0, stashIndex);
+    const win32Index = beforeStash.lastIndexOf('process.platform === "win32"');
+    const closeIndex = beforeStash.lastIndexOf("closeDatabase()");
+
+    assert.ok(win32Index !== -1, "win32 platform guard appears before stash");
+    assert.ok(closeIndex !== -1, "closeDatabase() invoked before stash");
+    assert.ok(
+      win32Index < closeIndex && closeIndex < stashIndex,
+      "platform guard wraps the closeDatabase() call before the stash",
+    );
+  });
+
+  it("openDatabase is called after the stash to reopen the connection", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "auto-worktree.ts"),
+      "utf-8",
+    );
+    const stashIndex = src.indexOf('"stash", "push", "--include-untracked"');
+    const afterStash = src.slice(stashIndex);
+    assert.ok(
+      afterStash.includes("openDatabase("),
+      "openDatabase() called after the pre-merge stash",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/quick-auto-guard.test.ts

@@ -35,15 +35,20 @@ describe("/gsd quick auto-mode guard (#2417)", () => {
 
     const quickBlock = quickBlockMatch[1];
 
-    // Verify isAutoActive guard comes BEFORE handleQuick call
-    const guardIndex = quickBlock.indexOf("isAutoActive()");
+    // Verify the shared auto-mode guard comes BEFORE handleQuick call.
+    // Accepts either the inline isAutoActive() check (legacy) or the shared
+    // requireNotAutoActive() helper (#4712).
+    const guardIndex = Math.max(
+      quickBlock.indexOf("isAutoActive()"),
+      quickBlock.indexOf("requireNotAutoActive("),
+    );
     const handleQuickIndex = quickBlock.indexOf("handleQuick(");
 
-    assert.ok(guardIndex !== -1, "isAutoActive() guard exists in quick command block");
+    assert.ok(guardIndex !== -1, "auto-mode guard exists in quick command block");
     assert.ok(handleQuickIndex !== -1, "handleQuick() call exists in quick command block");
     assert.ok(
       guardIndex < handleQuickIndex,
-      "isAutoActive() guard appears before handleQuick() call",
+      "auto-mode guard appears before handleQuick() call",
     );
   });
 
@@ -59,10 +64,11 @@ describe("/gsd quick auto-mode guard (#2417)", () => {
       "utf-8",
     );
 
-    // The error message should tell the user to stop auto-mode first
+    // The shared helper assembles the message dynamically from the command name,
+    // so assert on the message fragment and the /gsd stop instruction.
     assert.ok(
-      src.includes("/gsd quick cannot run while auto-mode is active"),
-      "error message explains that quick cannot run during auto-mode",
+      src.includes("cannot run while auto-mode is active"),
+      "error message explains that the command cannot run during auto-mode",
     );
     assert.ok(
       src.includes("/gsd stop"),

package/src/resources/extensions/gsd/tests/require-slice-discussion-dispatch.test.ts

@@ -0,0 +1,170 @@
+/**
+ * Regression tests for #3454: auto-dispatch must honour
+ * require_slice_discussion and pause before plan-slice when:
+ *   1. state.phase === "planning"
+ *   2. require_slice_discussion is enabled in preferences
+ *   3. state.activeSlice is non-null
+ *   4. the slice has no CONTEXT file on disk
+ *
+ * Exercises the dispatch rule from DISPATCH_RULES directly with a
+ * DispatchContext built against a real temp directory — no source-string
+ * matching, no brittle rename dependencies.
+ */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+import type { GSDPreferences } from "../preferences.ts";
+
+// Use a stable token (the preference name) for rule lookup instead of the
+// full human-readable title — copy edits to the rule name will not break
+// these tests as long as the rule still references the preference it gates.
+const RULE_NAME_TOKEN = "require_slice_discussion";
+
+function findRule() {
+  const matches = DISPATCH_RULES.filter(r => r.name.includes(RULE_NAME_TOKEN));
+  if (matches.length !== 1) {
+    throw new Error(`expected exactly one dispatch rule containing "${RULE_NAME_TOKEN}", found ${matches.length}`);
+  }
+  return matches[0];
+}
+
+function buildState(overrides: Partial<GSDState> = {}): GSDState {
+  return {
+    activeMilestone: { id: "M001", title: "Test milestone" },
+    activeSlice: { id: "S01", title: "Test slice" },
+    activeTask: null,
+    phase: "planning",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+    ...overrides,
+  };
+}
+
+function makeBasePath(prefix: string): string {
+  const dir = mkdtempSync(join(tmpdir(), `gsd-req-slice-${prefix}-`));
+  mkdirSync(join(dir, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  return dir;
+}
+
+function buildCtx(
+  basePath: string,
+  prefs: GSDPreferences | undefined,
+  state: GSDState = buildState(),
+): DispatchContext {
+  return {
+    basePath,
+    mid: "M001",
+    midTitle: "Test milestone",
+    state,
+    prefs,
+  };
+}
+
+describe("require_slice_discussion dispatch rule (#3454)", () => {
+  // ─── Positive case: rule fires ────────────────────────────────────────
+
+  test("returns stop action when preference enabled and CONTEXT missing", async () => {
+    const basePath = makeBasePath("fire");
+    try {
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const action = await findRule().match(buildCtx(basePath, prefs));
+      assert.ok(action, "rule must return a non-null action when pausing is required");
+      assert.strictEqual(action!.action, "stop");
+      if (action!.action === "stop") {
+        assert.match(action!.reason, /S01/);
+        assert.match(action!.reason, /require_slice_discussion/);
+        assert.match(action!.reason, /\/gsd discuss/);
+        assert.strictEqual(action!.level, "info");
+      }
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  // ─── Negative cases: rule falls through ───────────────────────────────
+
+  test("falls through (null) when preference is disabled", async () => {
+    const basePath = makeBasePath("pref-disabled");
+    try {
+      const prefs = { phases: { require_slice_discussion: false } } as unknown as GSDPreferences;
+      const action = await findRule().match(buildCtx(basePath, prefs));
+      assert.strictEqual(action, null);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("falls through (null) when preference is absent / undefined", async () => {
+    const basePath = makeBasePath("pref-absent");
+    try {
+      const action = await findRule().match(buildCtx(basePath, undefined));
+      assert.strictEqual(action, null);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("falls through (null) when phase is not 'planning'", async () => {
+    const basePath = makeBasePath("wrong-phase");
+    try {
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const state = buildState({ phase: "executing" });
+      const action = await findRule().match(buildCtx(basePath, prefs, state));
+      assert.strictEqual(action, null);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("falls through (null) when no active slice", async () => {
+    const basePath = makeBasePath("no-slice");
+    try {
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const state = buildState({ activeSlice: null });
+      const action = await findRule().match(buildCtx(basePath, prefs, state));
+      assert.strictEqual(action, null);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  // ─── Context-file present: should not pause ───────────────────────────
+
+  test("falls through (null) when CONTEXT file already exists on disk", async () => {
+    const basePath = makeBasePath("ctx-present");
+    try {
+      // Seed the CONTEXT file that /gsd discuss would have written.
+      const sliceDir = join(basePath, ".gsd", "milestones", "M001", "slices", "S01");
+      writeFileSync(join(sliceDir, "S01-CONTEXT.md"), "# Discussion notes\n", "utf-8");
+
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const action = await findRule().match(buildCtx(basePath, prefs));
+      assert.strictEqual(
+        action,
+        null,
+        "once the slice has a CONTEXT file, the rule must fall through so planning proceeds",
+      );
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  // ─── Rule ordering: must run before the plan-slice rule ──────────────
+
+  test("rule is ordered before the 'planning → plan-slice' rule", () => {
+    const discussIdx = DISPATCH_RULES.findIndex(r => r.name.includes(RULE_NAME_TOKEN));
+    const planIdx = DISPATCH_RULES.findIndex(r => r.name.startsWith("planning → plan-slice"));
+    assert.ok(discussIdx >= 0, "require_slice_discussion rule must be registered");
+    assert.ok(planIdx >= 0, "plan-slice rule must be registered");
+    assert.ok(
+      discussIdx < planIdx,
+      "require_slice_discussion rule must be ordered before plan-slice so it preempts dispatch",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/rewrite-docs-abandon-detect.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Regression tests for #3490: post-unit handler for rewrite-docs must
+ * detect abandon/descope overrides that target the current milestone and
+ * park it — without false-positive parking on unrelated scope-change
+ * overrides that merely contain an abandon-family verb.
+ *
+ * Exercises detectAbandonMilestone() directly — a pure function over
+ * Override objects, no I/O and no production-code import chain.
+ * parkMilestone() end-to-end behavior is covered by the existing
+ * park-milestone.test.ts / park-edge-cases.test.ts / park-db-sync.test.ts
+ * suites; here we only validate the decision layer that feeds it.
+ */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { detectAbandonMilestone } from "../abandon-detect.ts";
+import type { Override } from "../files.ts";
+
+function mkOverride(change: string): Override {
+  return {
+    timestamp: "2026-04-21T00:00:00.000Z",
+    change,
+    scope: "active",
+    appliedAt: "M001/S01/T01",
+  };
+}
+
+describe("detectAbandonMilestone (#3490)", () => {
+  test("parks on explicit abandon-milestone phrasing", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("abandon this milestone, it's no longer relevant")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+    assert.strictEqual(d.matched.length, 1);
+    assert.match(d.reason, /abandon this milestone/);
+  });
+
+  test("parks on descope-milestone phrasing", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("descope the entire milestone")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks when override references milestone by ID instead of the word", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("shelve M003 for now, coming back next quarter")],
+      "M003",
+    );
+    assert.strictEqual(d.shouldPark, true);
+    assert.strictEqual(d.matched[0], "shelve M003 for now, coming back next quarter");
+  });
+
+  test("parks on past-tense / gerund verb forms (UK spelling)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("this milestone was cancelled by product")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks on US spelling 'canceled' (single-l)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("the milestone was canceled by the PM")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks on hyphenated 'de-scope' variant", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("de-scope this milestone — moved to v2")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks on space-separated 'de scope' variant", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("de scope the milestone entirely")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks on 'de-scoped' past-tense hyphen variant", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("M003 was de-scoped last week")],
+      "M003",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  // ─── False-positive guards ────────────────────────────────────────────
+
+  test("does NOT park on 'cancel the standup reminder' (no milestone ref)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("cancel the daily standup reminder")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+    assert.deepStrictEqual(d.matched, []);
+  });
+
+  test("does NOT park on 'drop the dependency on X' (no milestone ref)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("drop the dependency on X and use Y instead")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+  });
+
+  test("does NOT park on 'scrap the v1 design' (no milestone ref)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("scrap the v1 design for the landing page")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+  });
+
+  test("does NOT park on override with milestone word but no abandon verb", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("change the milestone title to something clearer")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+  });
+
+  test("does NOT park when a different milestone ID is referenced", () => {
+    // The abandon verb is present and an MID is present, but the MID is
+    // not the current milestone. We require either the literal word
+    // "milestone" OR the current MID — a reference to a different MID
+    // (M007) with neither the word "milestone" nor the current ID (M001)
+    // should not trigger.
+    const d = detectAbandonMilestone(
+      [mkOverride("drop M007")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+  });
+
+  // ─── Edge cases ───────────────────────────────────────────────────────
+
+  test("empty overrides list returns no-park", () => {
+    const d = detectAbandonMilestone([], "M001");
+    assert.strictEqual(d.shouldPark, false);
+    assert.deepStrictEqual(d.matched, []);
+  });
+
+  test("null/undefined currentMilestoneId returns no-park even with matching text", () => {
+    const d1 = detectAbandonMilestone(
+      [mkOverride("abandon this milestone")],
+      null,
+    );
+    assert.strictEqual(d1.shouldPark, false);
+
+    const d2 = detectAbandonMilestone(
+      [mkOverride("abandon this milestone")],
+      undefined,
+    );
+    assert.strictEqual(d2.shouldPark, false);
+  });
+
+  test("multiple abandon overrides are concatenated in reason", () => {
+    const d = detectAbandonMilestone(
+      [
+        mkOverride("abandon this milestone"),
+        mkOverride("cancel the standup"),           // filtered out (no ref)
+        mkOverride("descope the milestone entirely"),
+      ],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+    assert.strictEqual(d.matched.length, 2, "only the two milestone-scoped overrides match");
+    assert.match(d.reason, /abandon this milestone/);
+    assert.match(d.reason, /descope the milestone entirely/);
+    assert.doesNotMatch(d.reason, /cancel the standup/);
+  });
+
+  // ─── Regex-injection guard on milestone ID ────────────────────────────
+
+  test("milestone ID with regex metacharacters is escaped, not interpreted", () => {
+    // A pathological MID should not break the matcher — the function
+    // escapes regex metacharacters before building the pattern.
+    const d = detectAbandonMilestone(
+      [mkOverride("abandon M.01 the milestone")],
+      "M.01",
+    );
+    // 'milestone' is present, so this parks regardless of escaping,
+    // but the test confirms the RegExp construction does not throw.
+    assert.strictEqual(d.shouldPark, true);
+  });
+});
+

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

@@ -142,9 +142,9 @@ test("Rule 3: A-A-A-A triggers Rule 2 not Rule 3", () => {
 
 test("Rule 4: same ENOENT path in two entries triggers stuck", () => {
   const result = detectStuck([
-    { key: "A", error: "ENOENT: no such file or directory, access '/home/user/.gsd/agent/skills/debug-like-expert/SKILL.md'" },
+    { key: "A", error: "ENOENT: no such file or directory, access '/home/user/.agents/skills/debug-like-expert/SKILL.md'" },
     { key: "B" },
-    { key: "A", error: "ENOENT: no such file or directory, access '/home/user/.gsd/agent/skills/debug-like-expert/SKILL.md'" },
+    { key: "A", error: "ENOENT: no such file or directory, access '/home/user/.agents/skills/debug-like-expert/SKILL.md'" },
   ]);
   assert.notEqual(result, null);
   assert.equal(result!.stuck, true);

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

@@ -258,6 +258,55 @@ test("resolution: markCaptureExecuted is idempotent", () => {
   }
 });
 
+// ─── executeTriageResolutions + note execution (#3578) ──────────────────────
+
+test("resolution: executeTriageResolutions stamps note captures as executed", () => {
+  const tmp = makeTempDir("res-exec-note");
+  try {
+    const id = appendCapture(tmp, "FYI the API changed");
+    markCaptureResolved(tmp, id, "note", "acknowledged", "informational");
+
+    const result = executeTriageResolutions(tmp, "M001", "S01");
+
+    // The note should now be marked as executed
+    const all = loadAllCaptures(tmp);
+    assert.strictEqual(all.length, 1);
+    assert.strictEqual(all[0].executed, true, "note capture should be marked as executed");
+
+    // It should appear in the actions log
+    assert.ok(
+      result.actions.some(a => a.includes(id) && a.includes("Note acknowledged")),
+      "actions should include a note-acknowledged entry",
+    );
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("resolution: executeTriageResolutions does not double-stamp already-executed notes", () => {
+  const tmp = makeTempDir("res-exec-note-idem");
+  try {
+    const id = appendCapture(tmp, "informational note");
+    markCaptureResolved(tmp, id, "note", "acknowledged", "info");
+
+    // First execution — stamps the note
+    executeTriageResolutions(tmp, "M001", "S01");
+
+    // Second execution — should be a no-op for the note
+    const result2 = executeTriageResolutions(tmp, "M001", "S01");
+
+    assert.strictEqual(result2.actions.length, 0, "second call should produce no actions");
+
+    // Verify the Executed field was not duplicated in the file
+    const filePath = join(tmp, ".gsd", "CAPTURES.md");
+    const content = readFileSync(filePath, "utf-8");
+    const executedMatches = content.match(/\*\*Executed:\*\*/g);
+    assert.strictEqual(executedMatches?.length, 1, "should have exactly one Executed field");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
 // ─── loadActionableCaptures ──────────────────────────────────────────────────
 
 test("resolution: loadActionableCaptures returns only unexecuted actionable captures", () => {
@@ -387,8 +436,7 @@ 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");
-    // 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)");
+    assert.strictEqual(result.actions.length, 3, "should have 3 action entries (inject + quick-task + note acknowledged; defer excluded)");
   } finally {
     rmSync(tmp, { recursive: true, force: true });
   }