gsd-pi 2.80.0-dev.cf9433f56 → 2.80.0-dev.d4fc28e6b

package/src/resources/extensions/gsd/tests/session-switch-abort-misclassification.test.ts

@@ -0,0 +1,166 @@
+// GSD-2 + src/resources/extensions/gsd/tests/session-switch-abort-misclassification.test.ts
+// Regression: session-transition aborts must not be classified as user cancellations.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  _handleSessionSwitchAgentEnd,
+  isClaudeCodeSessionSwitchAbortMessage,
+} from "../bootstrap/agent-end-recovery.js";
+import type { ErrorContext } from "../auto/types.js";
+
+test("user-abort message during session-switch is dropped (not propagated as cancellation)", () => {
+  // The Anthropic SDK emits this exact string when newSession() aborts an
+  // in-flight stream during a unit-to-unit session transition. Before the fix
+  // this was misclassified as a user cancellation and killed auto-mode with
+  // "Auto-mode stopped — Unit aborted: Claude Code process aborted by user".
+  let cancelledWith: ErrorContext | null = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    { stopReason: "error", errorMessage: "Claude Code process aborted by user" },
+    resolveCancelled,
+  );
+  assert.equal(cancelledWith, null, "SDK user-abort during session-switch must not propagate cancellation");
+
+  _handleSessionSwitchAgentEnd(
+    { stopReason: "error", errorMessage: "Request aborted by user" },
+    resolveCancelled,
+  );
+  assert.equal(cancelledWith, null, "proxy user-abort during session-switch must not propagate cancellation");
+});
+
+test("genuine stopReason='aborted' with errorMessage during session-switch still propagates", () => {
+  // Regression guard for prior behavior: genuine aborts with diagnostic content
+  // continue to surface as cancellations so transient-pause recovery can run.
+  let cancelledWith: { message: string; category: string; isTransient?: boolean } | null = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    {
+      stopReason: "aborted",
+      errorMessage: "stream torn down mid-flight",
+      content: [{ type: "text", text: "partial output" }],
+    },
+    resolveCancelled,
+  );
+
+  assert.deepEqual(cancelledWith, {
+    message: "stream torn down mid-flight",
+    category: "aborted",
+    isTransient: true,
+  });
+});
+
+test("Claude Code stream-aborted placeholder during session-switch is dropped", () => {
+  let cancelledWith: unknown = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    {
+      stopReason: "aborted",
+      content: [{ type: "text", text: "Claude Code stream aborted by caller" }],
+    },
+    resolveCancelled,
+  );
+
+  assert.equal(cancelledWith, null);
+});
+
+test("Claude Code session-switch abort detection is narrow", () => {
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "error",
+      content: [{ type: "text", text: "Claude Code error: Claude Code process aborted by user" }],
+    }),
+    false,
+  );
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "aborted",
+      content: [{ type: "text", text: "Claude Code stream aborted by caller" }],
+    }),
+    true,
+  );
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "aborted",
+      content: [{ type: "text", text: "partial output before network failure" }],
+    }),
+    false,
+  );
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "aborted",
+      content: [{ type: "text", text: "Request aborted by user\nAPI Error: 529 overloaded" }],
+    }),
+    false,
+  );
+  assert.equal(
+    isClaudeCodeSessionSwitchAbortMessage({
+      stopReason: "error",
+      errorMessage: "Request aborted by user",
+      content: [{ type: "text", text: "Claude Code process aborted by user" }],
+    }),
+    true,
+  );
+});
+
+test("empty-content aborted during session-switch is silently ignored", () => {
+  // Empty-content aborted is a non-fatal LLM stop; we must not pause/cancel.
+  let cancelledWith: unknown = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    { stopReason: "aborted", content: [] },
+    resolveCancelled,
+  );
+
+  assert.equal(cancelledWith, null);
+});
+
+test("non-abort errors during session-switch are not propagated through this helper", () => {
+  // Real provider errors (rate-limit, network, unsupported-model) are handled
+  // by the post-switch retry pipeline — not by the in-flight switch handler.
+  let cancelledWith: unknown = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    { stopReason: "error", errorMessage: "rate limit exceeded" },
+    resolveCancelled,
+  );
+
+  assert.equal(cancelledWith, null);
+});
+
+test("malformed lastMsg is rejected gracefully", () => {
+  let calls = 0;
+  const resolveCancelled = (_ctx: unknown) => {
+    calls += 1;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(undefined, resolveCancelled as never);
+  _handleSessionSwitchAgentEnd(null, resolveCancelled as never);
+  _handleSessionSwitchAgentEnd("not an object", resolveCancelled as never);
+  _handleSessionSwitchAgentEnd({}, resolveCancelled as never);
+  _handleSessionSwitchAgentEnd({ stopReason: "completed" }, resolveCancelled as never);
+
+  assert.equal(calls, 0, "malformed or non-abort lastMsg must not invoke cancellation");
+});

package/src/resources/extensions/gsd/tests/state-corruption-2945.test.ts

@@ -291,6 +291,7 @@ describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merg
       getAutoWorktreePath: () => null,
       autoCommitCurrentBranch: () => {},
       getCurrentBranch: () => "main",
+      checkoutBranch: () => {},
       autoWorktreeBranch: () => "gsd/M001",
       resolveMilestoneFile: () => "/mock/roadmap.md",
       readFileSync: () => "# Roadmap content",

package/src/resources/extensions/gsd/tests/system-context-memory.test.ts

@@ -0,0 +1,112 @@
+// Project/App: GSD-2
+// File Purpose: System context memory gating regression tests.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildContextMessage, isLowEntropyResumePrompt, loadMemoryBlock } from "../bootstrap/system-context.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
+import { createMemory } from "../memory-store.ts";
+
+test("buildContextMessage marks hidden guided context when memory is supplied", () => {
+  const message = buildContextMessage({
+    memoryBlock: "\n\n[MEMORY]\n\n- keep this",
+    injection: "[GSD Guided Execute Context]\nUse the task plan.",
+    forensicsInjection: null,
+  });
+
+  assert.ok(message, "expected hidden context message");
+  assert.equal(message.customType, "gsd-guided-context");
+  assert.equal(message.display, false);
+  assert.match(message.content, /\[GSD Context Metadata\]\n- Memory supplied: yes/);
+  assert.ok(
+    message.content.indexOf("Memory supplied: yes") < message.content.indexOf("[GSD Guided Execute Context]"),
+    "memory marker should appear before guided context",
+  );
+});
+
+test("buildContextMessage caps hidden context by default", () => {
+  const original = process.env.PI_GSD_CONTEXT_MAX_CHARS;
+  delete process.env.PI_GSD_CONTEXT_MAX_CHARS;
+  try {
+    const message = buildContextMessage({
+      memoryBlock: "",
+      injection: `[GSD Guided Execute Context]\n${"large context\n".repeat(500)}`,
+      forensicsInjection: null,
+    });
+
+    assert.ok(message, "expected hidden context message");
+    assert.equal(message.customType, "gsd-guided-context");
+    assert.ok(message.content.length <= 4000);
+    assert.match(message.content, /\[GSD Context Truncated\]/);
+  } finally {
+    if (original === undefined) delete process.env.PI_GSD_CONTEXT_MAX_CHARS;
+    else process.env.PI_GSD_CONTEXT_MAX_CHARS = original;
+  }
+});
+
+test("buildContextMessage supports explicit context cap override", () => {
+  const original = process.env.PI_GSD_CONTEXT_MAX_CHARS;
+  process.env.PI_GSD_CONTEXT_MAX_CHARS = "1200";
+  try {
+    const message = buildContextMessage({
+      memoryBlock: "",
+      injection: `[GSD Guided Execute Context]\n${"large context\n".repeat(200)}`,
+      forensicsInjection: null,
+    });
+
+    assert.ok(message, "expected hidden context message");
+    assert.equal(message.customType, "gsd-guided-context");
+    assert.ok(message.content.length <= 1200);
+    assert.match(message.content, /\[GSD Context Truncated\]/);
+  } finally {
+    if (original === undefined) delete process.env.PI_GSD_CONTEXT_MAX_CHARS;
+    else process.env.PI_GSD_CONTEXT_MAX_CHARS = original;
+  }
+});
+
+test("buildContextMessage does not add memory marker when only guided context is supplied", () => {
+  const message = buildContextMessage({
+    memoryBlock: "",
+    injection: "[GSD Guided Execute Context]\nUse the task plan.",
+    forensicsInjection: null,
+  });
+
+  assert.ok(message, "expected guided context message");
+  assert.equal(message.customType, "gsd-guided-context");
+  assert.doesNotMatch(message.content, /Memory supplied: yes/);
+});
+
+test("loadMemoryBlock keeps critical memories while gating prompt-relevant query hits", async () => {
+  closeDatabase();
+  assert.equal(openDatabase(":memory:"), true);
+  try {
+    createMemory({
+      category: "gotcha",
+      content: "Always preserve critical resume safety context.",
+      confidence: 0.95,
+    });
+    createMemory({
+      category: "preference",
+      content: "React dashboard preference should only appear for a React prompt query.",
+      confidence: 0.95,
+    });
+
+    const withPromptRelevant = await loadMemoryBlock("React dashboard", { includePromptRelevant: true });
+    assert.match(withPromptRelevant, /critical resume safety context/);
+    assert.match(withPromptRelevant, /React dashboard preference/);
+
+    const withoutPromptRelevant = await loadMemoryBlock("React dashboard", { includePromptRelevant: false });
+    assert.match(withoutPromptRelevant, /critical resume safety context/);
+    assert.doesNotMatch(withoutPromptRelevant, /React dashboard preference/);
+  } finally {
+    closeDatabase();
+  }
+});
+
+test("isLowEntropyResumePrompt identifies bare resume prompts only", () => {
+  assert.equal(isLowEntropyResumePrompt("continue"), true);
+  assert.equal(isLowEntropyResumePrompt("Go ahead."), true);
+  assert.equal(isLowEntropyResumePrompt("run the tests"), false);
+  assert.equal(isLowEntropyResumePrompt("/gsd auto"), false);
+});

package/src/resources/extensions/gsd/tests/system-context-message-routing.test.ts

@@ -1,9 +1,5 @@
-// GSD bootstrap + system-context-message-routing.test — regression coverage
-// for #5019. `memoryBlock` is FTS-queried against the user prompt and changes
-// per call; embedding it in the cached system prefix invalidates Anthropic
-// prompt-cache hits on every request. The fix routes memory through the
-// existing context-message channel (volatile user-message suffix) and combines
-// it with any active guided-execute or forensics injection.
+// Project/App: GSD-2
+// File Purpose: Regression coverage for volatile system-context message routing.
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
@@ -11,6 +7,8 @@ import assert from "node:assert/strict";
 import { buildContextMessage } from "../bootstrap/system-context.ts";
 
 describe("buildContextMessage (#5019 — memory routing)", () => {
+  const markedMemory = "[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]\nrule one";
+
   test("returns null when nothing to inject", () => {
     const result = buildContextMessage({
       memoryBlock: "",
@@ -37,7 +35,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result, "expected a context message");
     assert.equal(result.customType, "gsd-memory");
-    assert.equal(result.content, "[MEMORY]\nrule one\nrule two");
+    assert.equal(result.content, "[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]\nrule one\nrule two");
     assert.equal(result.display, false);
   });
 
@@ -71,7 +69,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-guided-context");
-    assert.equal(result.content, "[MEMORY]\nrule one\n\n[GUIDED]\nexecute T01");
+    assert.equal(result.content, `${markedMemory}\n\n[GUIDED]\nexecute T01`);
   });
 
   test("memory + forensics: memory prepended, customType is gsd-forensics", () => {
@@ -82,7 +80,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-forensics");
-    assert.equal(result.content, "[MEMORY]\nrule one\n\n[FORENSICS]\ninvestigation context");
+    assert.equal(result.content, `${markedMemory}\n\n[FORENSICS]\ninvestigation context`);
   });
 
   test("guided takes precedence over forensics when both are somehow present", () => {

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

@@ -0,0 +1,291 @@
+// Project/App: GSD-2
+// File Purpose: Tests for opt-in GSD tool surface reduction.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { buildMinimalAutoGsdToolSet, buildMinimalGsdToolSet, buildMinimalGsdWorkflowToolSet, buildRequestScopedGsdToolSet, MINIMAL_AUTO_BASE_TOOL_NAMES, MINIMAL_GSD_TOOL_NAMES, restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch } from "../bootstrap/register-hooks.ts";
+
+test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surface", () => {
+  const result = buildMinimalGsdToolSet([
+    "bash",
+    "read",
+    "browser_open",
+    "gsd_plan_milestone",
+    "gsd_task_complete",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "memory_query",
+    "capture_thought",
+    "gsd_graph",
+  ]);
+
+  assert.ok(result.includes("bash"));
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("browser_open"));
+  for (const toolName of MINIMAL_GSD_TOOL_NAMES) {
+    assert.ok(result.includes(toolName), `expected ${toolName}`);
+  }
+  assert.ok(!result.includes("gsd_plan_milestone"));
+  assert.ok(!result.includes("gsd_task_complete"));
+  assert.ok(!result.includes("gsd_graph"));
+});
+
+test("buildMinimalGsdToolSet deduplicates preserved and minimal tools", () => {
+  const result = buildMinimalGsdToolSet(["bash", "bash", "memory_query"]);
+
+  assert.deepEqual(result.filter((toolName) => toolName === "bash"), ["bash"]);
+  assert.deepEqual(result.filter((toolName) => toolName === "memory_query"), ["memory_query"]);
+});
+
+test("buildMinimalGsdToolSet does not reintroduce provider-filtered GSD tools", () => {
+  const result = buildMinimalGsdToolSet(["bash", "read", "memory_query"]);
+
+  assert.deepEqual(result, ["bash", "read", "memory_query"]);
+  assert.ok(!result.includes("gsd_exec"));
+});
+
+test("buildMinimalAutoGsdToolSet keeps unit-specific completion tools without aliases", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "ask_user_questions",
+    "bash",
+    "read",
+    "lsp",
+    "browser_click",
+    "gsd_task_complete",
+    "gsd_complete_task",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "gsd_slice_complete",
+    "gsd_complete_slice",
+    "memory_query",
+    "capture_thought",
+  ], "execute-task");
+
+  assert.ok(result.includes("ask_user_questions"));
+  assert.ok(result.includes("bash"));
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("gsd_task_complete"));
+  assert.ok(result.includes("memory_query"));
+  assert.ok(!result.includes("lsp"));
+  assert.ok(!result.includes("browser_click"));
+  assert.ok(!result.includes("gsd_complete_task"));
+  assert.ok(!result.includes("gsd_slice_complete"));
+  assert.ok(!result.includes("gsd_complete_slice"));
+});
+
+test("buildMinimalAutoGsdToolSet keeps only the auto base non-GSD tools", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "ask_user_questions",
+    "bash",
+    "bg_shell",
+    "browser_wait_for",
+    "edit",
+    "glob",
+    "grep",
+    "lsp",
+    "ls",
+    "mac_find",
+    "read",
+    "subagent",
+    "write",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "memory_query",
+    "capture_thought",
+  ], "execute-task");
+
+  for (const toolName of MINIMAL_AUTO_BASE_TOOL_NAMES) {
+    assert.ok(result.includes(toolName), `expected ${toolName}`);
+  }
+  assert.ok(!result.includes("browser_wait_for"));
+  assert.ok(!result.includes("lsp"));
+  assert.ok(!result.includes("mac_find"));
+  assert.ok(!result.includes("subagent"));
+});
+
+test("buildMinimalAutoGsdToolSet includes closeout tool for complete-slice", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "subagent",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "gsd_task_complete",
+    "gsd_slice_complete",
+    "gsd_complete_slice",
+    "memory_query",
+    "capture_thought",
+  ], "complete-slice");
+
+  assert.ok(result.includes("gsd_slice_complete"));
+  assert.ok(result.includes("subagent"));
+  assert.ok(result.includes("capture_thought"));
+  assert.ok(!result.includes("gsd_task_complete"));
+  assert.ok(!result.includes("gsd_complete_slice"));
+});
+
+test("buildMinimalAutoGsdToolSet covers execute-task-simple", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "gsd_task_complete",
+    "gsd_decision_save",
+    "gsd_plan_task",
+    "memory_query",
+    "capture_thought",
+  ], "execute-task-simple");
+
+  assert.ok(result.includes("gsd_task_complete"));
+  assert.ok(result.includes("gsd_decision_save"));
+  assert.ok(!result.includes("gsd_plan_task"));
+});
+
+test("buildMinimalGsdWorkflowToolSet keeps workflow GSD tools but drops broad non-GSD tools", () => {
+  const result = buildMinimalGsdWorkflowToolSet([
+    "ask_user_questions",
+    "bash",
+    "bg_shell",
+    "browser_wait_for",
+    "edit",
+    "lsp",
+    "mac_find",
+    "read",
+    "subagent",
+    "write",
+    "gsd_plan_milestone",
+    "gsd_complete_milestone",
+    "gsd_task_complete",
+    "gsd_summary_save",
+    "memory_query",
+    "capture_thought",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "gsd_graph",
+  ]);
+
+  assert.ok(result.includes("ask_user_questions"));
+  assert.ok(result.includes("bash"));
+  assert.ok(result.includes("bg_shell"));
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("write"));
+  assert.ok(result.includes("gsd_plan_milestone"));
+  assert.ok(result.includes("gsd_complete_milestone"));
+  assert.ok(result.includes("gsd_task_complete"));
+  assert.ok(result.includes("gsd_summary_save"));
+  assert.ok(!result.includes("browser_wait_for"));
+  assert.ok(!result.includes("lsp"));
+  assert.ok(!result.includes("mac_find"));
+  assert.ok(!result.includes("subagent"));
+  assert.ok(!result.includes("gsd_graph"));
+});
+
+test("buildRequestScopedGsdToolSet scopes queued workflow custom-message requests", () => {
+  const result = buildRequestScopedGsdToolSet([
+    "ask_user_questions",
+    "bash",
+    "browser_wait_for",
+    "lsp",
+    "read",
+    "write",
+    "gsd_plan_milestone",
+    "gsd_complete_milestone",
+    "gsd_task_complete",
+    "gsd_graph",
+    "memory_query",
+    "capture_thought",
+  ], [{ customType: "gsd-run" }, { customType: "gsd-memory" }]);
+
+  assert.ok(result);
+  assert.ok(result.includes("ask_user_questions"));
+  assert.ok(result.includes("bash"));
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("write"));
+  assert.ok(result.includes("gsd_plan_milestone"));
+  assert.ok(result.includes("gsd_complete_milestone"));
+  assert.ok(!result.includes("browser_wait_for"));
+  assert.ok(!result.includes("lsp"));
+  assert.ok(!result.includes("gsd_graph"));
+});
+
+test("buildRequestScopedGsdToolSet ignores stale workflow messages outside the current request tail", () => {
+  assert.equal(buildRequestScopedGsdToolSet(["bash", "gsd_plan_milestone"], []), undefined);
+});
+
+test("scopeGsdWorkflowToolsForDispatch applies and restores per-unit skill visibility", () => {
+  const calls: Array<{ kind: "tools" | "skills"; value: string[] | undefined }> = [];
+  let activeTools = [
+    "bash",
+    "read",
+    "lsp",
+    "gsd_plan_milestone",
+    "gsd_decision_save",
+    "memory_query",
+    "capture_thought",
+  ];
+  let visibleSkills: string[] | undefined = ["previous-skill"];
+
+  const state = scopeGsdWorkflowToolsForDispatch({
+    getActiveTools: () => activeTools,
+    setActiveTools: (names) => {
+      activeTools = names;
+      calls.push({ kind: "tools", value: names });
+    },
+    getVisibleSkills: () => visibleSkills,
+    setVisibleSkills: (names) => {
+      visibleSkills = names;
+      calls.push({ kind: "skills", value: names });
+    },
+  }, "plan-milestone");
+
+  assert.ok(state);
+  assert.deepEqual(visibleSkills, [
+    "write-milestone-brief",
+    "decompose-into-slices",
+    "design-an-interface",
+    "grill-me",
+    "write-docs",
+    "api-design",
+    "tdd",
+    "verify-before-complete",
+  ]);
+  assert.ok(!activeTools.includes("lsp"));
+
+  restoreGsdWorkflowTools({
+    setActiveTools: (names) => {
+      activeTools = names;
+      calls.push({ kind: "tools", value: names });
+    },
+    setVisibleSkills: (names) => {
+      visibleSkills = names;
+      calls.push({ kind: "skills", value: names });
+    },
+  }, state);
+
+  assert.deepEqual(activeTools, [
+    "bash",
+    "read",
+    "lsp",
+    "gsd_plan_milestone",
+    "gsd_decision_save",
+    "memory_query",
+    "capture_thought",
+  ]);
+  assert.deepEqual(visibleSkills, ["previous-skill"]);
+  assert.equal(calls.filter((call) => call.kind === "skills").length, 2);
+});

package/src/resources/extensions/gsd/tests/unit-dispatches.test.ts

@@ -13,7 +13,7 @@ import {
   insertSlice,
 } from "../gsd-db.ts";
 import { registerAutoWorker } from "../db/auto-workers.ts";
-import { claimMilestoneLease } from "../db/milestone-leases.ts";
+import { claimMilestoneLease, releaseMilestoneLease } from "../db/milestone-leases.ts";
 import {
   recordDispatchClaim,
   markRunning,
@@ -105,6 +105,55 @@ test("partial unique index rejects double-claim of the same active unit", (t) =>
   }
 });
 
+test("recordDispatchClaim cancels stale active dispatch after lease takeover", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  const { workerId: firstWorkerId, leaseToken: firstLeaseToken } = setup(base);
+
+  const first = recordDispatchClaim({
+    traceId: "t-first",
+    workerId: firstWorkerId,
+    milestoneLeaseToken: firstLeaseToken,
+    milestoneId: "M001",
+    sliceId: "S01",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+  });
+  assert.equal(first.ok, true);
+  if (!first.ok) return;
+  markRunning(first.dispatchId);
+
+  assert.equal(releaseMilestoneLease(firstWorkerId, "M001", firstLeaseToken), true);
+  const takeoverWorkerId = registerAutoWorker({ projectRootRealpath: base });
+  const takeoverLease = claimMilestoneLease(takeoverWorkerId, "M001");
+  assert.equal(takeoverLease.ok, true);
+  if (!takeoverLease.ok) return;
+
+  const second = recordDispatchClaim({
+    traceId: "t-takeover",
+    workerId: takeoverWorkerId,
+    milestoneLeaseToken: takeoverLease.token,
+    milestoneId: "M001",
+    sliceId: "S01",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+    attemptN: 2,
+  });
+
+  assert.equal(second.ok, true);
+  if (!second.ok) return;
+
+  const recent = getRecentForUnit("M001/S01", 5);
+  assert.equal(recent.length, 2);
+  assert.equal(recent[0].id, second.dispatchId);
+  assert.equal(recent[0].status, "claimed");
+  assert.equal(recent[0].worker_id, takeoverWorkerId);
+  assert.equal(recent[0].attempt_n, 2);
+  assert.equal(recent[1].id, first.dispatchId);
+  assert.equal(recent[1].status, "canceled");
+  assert.equal(recent[1].exit_reason, "stale-dispatch-lease-takeover");
+});
+
 test("after markCompleted, a fresh claim for the same unit succeeds", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));