gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.96d4bb599

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -32,6 +32,19 @@ test("classifyError detects rate limit from message", () => {
   assert.equal(result.kind, "rate-limit");
 });
 
+test("classifyError treats Anthropic quota-window phrasing as transient rate-limit (#4373)", () => {
+  const result = classifyError("You've hit your limit · resets soon");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 60_000);
+});
+
+test("classifyError treats usage-limit phrasing as transient rate-limit (#4373)", () => {
+  const result = classifyError("usage limit reached for this workspace");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+});
+
 test("classifyError treats OpenRouter affordability errors as transient rate-limit class", () => {
   const result = classifyError(
     "402 This request requires more credits, or fewer max_tokens. You requested up to 32000 tokens, but can only afford 329.",
@@ -202,6 +215,10 @@ test("isTransientNetworkError detects DNS errors", () => {
   assert.ok(isTransientNetworkError("dns resolution failed"));
 });
 
+test("isTransientNetworkError detects unexpected EOF", () => {
+  assert.ok(isTransientNetworkError("unexpected EOF"));
+});
+
 test("isTransientNetworkError rejects auth errors", () => {
   assert.ok(!isTransientNetworkError("unauthorized: invalid API key"));
 });
@@ -455,6 +472,22 @@ test("agent-end-recovery.ts resumes transient provider pauses through startAuto
   );
 });
 
+test("agent-end-recovery.ts does not defer rate-limit errors to core retry handler before fallback (#4373)", () => {
+  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
+  assert.ok(
+    src.includes('if (isTransient(cls) && cls.kind !== "rate-limit")'),
+    "rate-limit errors must bypass transient core-retry deferral so fallback can execute (#4373)",
+  );
+});
+
+test("agent-end-recovery.ts updates dashboard dispatched model after fallback switch", () => {
+  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
+  assert.ok(
+    src.includes("setCurrentDispatchedModelId"),
+    "agent-end-recovery.ts should update currentDispatchedModelId when recovery switches model",
+  );
+});
+
 // ── Codex error extraction (#1166) ──────────────────────────────────────────
 
 test("openai-codex-responses.ts extracts nested error fields", () => {

package/src/resources/extensions/gsd/tests/python-resolver.test.ts

@@ -0,0 +1,131 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+// Regression tests for #4416: python invocation normalization for Windows.
+// These tests import from python-resolver.ts which is created as part of the fix.
+import { normalizePythonCommand, detectPythonExecutable } from "../python-resolver.ts";
+
+describe("normalizePythonCommand", () => {
+  test("passes through command that does not start with python", () => {
+    assert.equal(normalizePythonCommand("npm run test"), "npm run test");
+  });
+
+  test("passes through empty string", () => {
+    assert.equal(normalizePythonCommand(""), "");
+  });
+
+  test("passes through non-python shell commands unchanged", () => {
+    assert.equal(normalizePythonCommand("node index.js"), "node index.js");
+    assert.equal(normalizePythonCommand("npx tsc --noEmit"), "npx tsc --noEmit");
+  });
+
+  test("passes through command unchanged when no python is detected", () => {
+    // We cannot fully mock detectPythonExecutable here without a mock framework,
+    // but we can verify that a command without python tokens is always preserved.
+    const cmd = "cargo test";
+    assert.equal(normalizePythonCommand(cmd), cmd);
+  });
+
+  test("rewrites leading python3 token when interpreter is detected", () => {
+    const input = "python3 -m pytest";
+    const result = normalizePythonCommand(input);
+    const detected = detectPythonExecutable();
+    if (detected === null) {
+      assert.equal(result, input, "expected passthrough when no interpreter is detected");
+      return;
+    }
+    assert.ok(
+      result.startsWith(`${detected} `),
+      `Expected rewritten prefix '${detected} ' in: ${result}`,
+    );
+    assert.ok(result.includes("-m pytest"), `Expected arguments preserved in: ${result}`);
+  });
+
+  test("rewrites leading python token when interpreter is detected", () => {
+    const input = "python manage.py migrate";
+    const result = normalizePythonCommand(input);
+    const detected = detectPythonExecutable();
+    if (detected === null) {
+      assert.equal(result, input, "expected passthrough when no interpreter is detected");
+      return;
+    }
+    assert.ok(
+      result.startsWith(`${detected} `),
+      `Expected rewritten prefix '${detected} ' in: ${result}`,
+    );
+    assert.ok(result.includes("manage.py migrate"), `Expected arguments preserved in: ${result}`);
+  });
+
+  test("rewrites python token after && compound separator", () => {
+    const input = "echo ok && python3 -m pytest --tb=short";
+    const result = normalizePythonCommand(input);
+    const detected = detectPythonExecutable();
+    if (detected === null) {
+      assert.equal(result, input, "expected passthrough when no interpreter is detected");
+      return;
+    }
+    assert.ok(
+      result.includes(`&& ${detected} `),
+      `Expected '&& ${detected} ' segment in: ${result}`,
+    );
+    assert.ok(
+      result.includes("-m pytest --tb=short"),
+      `Expected arguments preserved in: ${result}`,
+    );
+  });
+
+  test("rewrites leading python token when command has leading whitespace", () => {
+    const input = "  python3 -m pytest";
+    const result = normalizePythonCommand(input);
+    const detected = detectPythonExecutable();
+    if (detected === null) {
+      assert.equal(result, input, "expected passthrough when no interpreter is detected");
+      return;
+    }
+    assert.equal(
+      result,
+      `  ${detected} -m pytest`,
+      `Expected leading whitespace preserved and python3 rewritten in: ${result}`,
+    );
+  });
+
+  test("does not duplicate '-3' when rewriting existing 'py -3' token", () => {
+    const input = "py -3 -m pytest";
+    const result = normalizePythonCommand(input);
+    const detected = detectPythonExecutable();
+    if (detected === null) {
+      assert.equal(result, input, "expected passthrough when no interpreter is detected");
+      return;
+    }
+    assert.equal(
+      result,
+      `${detected} -m pytest`,
+      `Expected clean rewrite without duplicated '-3' in: ${result}`,
+    );
+  });
+});
+
+describe("detectPythonExecutable", () => {
+  test("returns a string or null — never throws", () => {
+    let result: string | null | undefined;
+    assert.doesNotThrow(() => {
+      result = detectPythonExecutable();
+    });
+    assert.ok(result === null || typeof result === "string");
+  });
+
+  test("return value is a known python invocation form or null", () => {
+    const result = detectPythonExecutable();
+    const valid = [null, "python3", "python", "py -3"];
+    assert.ok(
+      valid.includes(result as string | null),
+      `Expected one of ${valid.join(", ")}, got: ${String(result)}`,
+    );
+  });
+
+  test("returns the same value on repeated calls (cached)", () => {
+    const first = detectPythonExecutable();
+    const second = detectPythonExecutable();
+    assert.equal(first, second, "detectPythonExecutable must return consistent cached result");
+  });
+});

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -10,6 +10,7 @@ import {
   resetWriteGateState,
   shouldBlockContextArtifactSave,
 } from "../bootstrap/write-gate.ts";
+import { toRoundResultResponse } from "../../remote-questions/manager.ts";
 
 function makeTempDir(prefix: string): string {
   const dir = join(
@@ -95,3 +96,69 @@ test("register-hooks unlocks milestone depth verification from question id witho
     "question-id milestone inference should unlock the matching milestone context write",
   );
 });
+
+test("register-hooks clears depth gate when remote (Telegram/Slack/Discord) answer is normalized (#4406)", async (t) => {
+  const dir = makeTempDir("remote");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState();
+
+  t.after(() => {
+    resetWriteGateState();
+    process.chdir(originalCwd);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<void> | void) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const questionId = "depth_verification_M002_confirm";
+  const questions = [
+    {
+      id: questionId,
+      question: "Do you agree?",
+      options: [
+        { label: "Yes, you got it (Recommended)" },
+        { label: "Needs adjustment" },
+      ],
+    },
+  ];
+
+  for (const handler of handlers.get("tool_call") ?? []) {
+    await handler({ toolName: "ask_user_questions", input: { questions } });
+  }
+  assert.equal(getPendingGate(), questionId);
+
+  // Simulate the normalized response the remote manager now emits:
+  // a Telegram button press returns a RemoteAnswer that is fed through
+  // toRoundResultResponse before reaching details.response.
+  const remoteAnswer = {
+    answers: {
+      [questionId]: { answers: ["Yes, you got it (Recommended)"] },
+    },
+  };
+  const normalized = toRoundResultResponse(remoteAnswer);
+
+  for (const handler of handlers.get("tool_result") ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: { response: normalized },
+    });
+  }
+
+  assert.equal(getPendingGate(), null, "normalized remote answer must clear the gate");
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M002").block,
+    false,
+    "remote confirmation must unlock the matching milestone context write",
+  );
+});

package/src/resources/extensions/gsd/tests/remote-notification-from-desktop.test.ts

@@ -0,0 +1,107 @@
+/**
+ * remote-notification-from-desktop.test.ts
+ *
+ * Regression guard: sendDesktopNotification must fire sendRemoteNotification
+ * as a fire-and-forget side-effect so that Telegram/Slack/Discord channels
+ * receive the same events as native desktop notifications.
+ *
+ * Testing strategy (structural analysis):
+ *   node:test does not support mock.module without --experimental-test-module-mocks,
+ *   so we use the same source-code structural approach established in this codebase
+ *   (see session-start-footer.test.ts). We read notifications.ts and assert that:
+ *     1. It imports sendRemoteNotification from the remote-questions/notify module.
+ *     2. The sendDesktopNotification function body calls sendRemoteNotification
+ *        with title and message as arguments.
+ *     3. The call uses the void fire-and-forget pattern with a .catch(() => {})
+ *        suppressor so that async failures never break the synchronous caller.
+ *
+ * Relates to #4341.
+ */
+
+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 SOURCE = readFileSync(join(__dirname, "..", "notifications.ts"), "utf-8");
+
+test("notifications.ts imports sendRemoteNotification from remote-questions/notify", () => {
+  const hasImport =
+    SOURCE.includes('from "../remote-questions/notify.js"') ||
+    SOURCE.includes("from '../remote-questions/notify.js'");
+  assert.ok(
+    hasImport,
+    "notifications.ts must import from '../remote-questions/notify.js'",
+  );
+
+  const importLine = SOURCE.split("\n").find(
+    (line) =>
+      line.includes("sendRemoteNotification") &&
+      (line.includes("remote-questions/notify") || line.includes("remote-questions/notify.js")),
+  );
+  assert.ok(
+    importLine,
+    "The import statement must include sendRemoteNotification from the remote-questions/notify module",
+  );
+});
+
+test("sendDesktopNotification calls sendRemoteNotification(title, message)", () => {
+  // Extract the body of sendDesktopNotification — from its opening brace to the
+  // closing brace at the same indentation level.
+  const fnStart = SOURCE.indexOf("export function sendDesktopNotification(");
+  assert.ok(fnStart > -1, "sendDesktopNotification must be present in notifications.ts");
+
+  // Find the next exported function/const after sendDesktopNotification to bound the search.
+  const nextExportIdx = SOURCE.indexOf("\nexport ", fnStart + 1);
+  const fnBody = nextExportIdx > -1 ? SOURCE.slice(fnStart, nextExportIdx) : SOURCE.slice(fnStart);
+
+  assert.ok(
+    fnBody.includes("sendRemoteNotification"),
+    "sendDesktopNotification must call sendRemoteNotification",
+  );
+
+  assert.ok(
+    fnBody.includes("sendRemoteNotification(title") || fnBody.includes("sendRemoteNotification(title,"),
+    "sendRemoteNotification must be called with title as first argument",
+  );
+});
+
+test("sendRemoteNotification is invoked as void fire-and-forget with .catch(() => {})", () => {
+  const fnStart = SOURCE.indexOf("export function sendDesktopNotification(");
+  const nextExportIdx = SOURCE.indexOf("\nexport ", fnStart + 1);
+  const fnBody = nextExportIdx > -1 ? SOURCE.slice(fnStart, nextExportIdx) : SOURCE.slice(fnStart);
+
+  assert.ok(
+    fnBody.includes("void sendRemoteNotification("),
+    "sendRemoteNotification must be called with void (fire-and-forget)",
+  );
+
+  assert.ok(
+    fnBody.includes(".catch("),
+    "sendRemoteNotification call must be followed by .catch() to suppress unhandled-rejection warnings",
+  );
+});
+
+test("sendRemoteNotification call appears before shouldSendDesktopNotification guard", () => {
+  // Regression guard for the HIGH-severity bug where remote notifications were
+  // gated behind the desktop-notification preference check. Users who disable
+  // desktop notifications must still receive Telegram/Slack/Discord messages.
+  const fnStart = SOURCE.indexOf("export function sendDesktopNotification(");
+  assert.ok(fnStart > -1, "sendDesktopNotification must be present in notifications.ts");
+
+  const nextExportIdx = SOURCE.indexOf("\nexport ", fnStart + 1);
+  const fnBody = nextExportIdx > -1 ? SOURCE.slice(fnStart, nextExportIdx) : SOURCE.slice(fnStart);
+
+  const remoteCallIdx = fnBody.indexOf("sendRemoteNotification(");
+  const guardIdx = fnBody.indexOf("shouldSendDesktopNotification(");
+
+  assert.ok(remoteCallIdx > -1, "sendRemoteNotification must be called inside sendDesktopNotification");
+  assert.ok(guardIdx > -1, "shouldSendDesktopNotification guard must be present inside sendDesktopNotification");
+
+  assert.ok(
+    remoteCallIdx < guardIdx,
+    `sendRemoteNotification (pos ${remoteCallIdx}) must appear BEFORE the shouldSendDesktopNotification guard (pos ${guardIdx}) so that remote channels fire even when desktop notifications are disabled`,
+  );
+});

package/src/resources/extensions/gsd/tests/requirements.test.ts

@@ -95,6 +95,15 @@ describe('requirements', () => {
     assert.ok(report.issues.some(issue => issue.code === "active_requirement_missing_owner"), "doctor flags missing owner");
   });
 
+  // #4414: active_requirement_missing_owner is a planning-hygiene signal,
+  // not a correctness blocker — severity must be warning, not error.
+  test('#4414: active_requirement_missing_owner is a warning, not an error', async () => {
+    const report = await runGSDDoctor(base);
+    const issue = report.issues.find(i => i.code === "active_requirement_missing_owner");
+    assert.ok(issue, "issue is present");
+    assert.equal(issue!.severity, "warning", "severity downgraded so doctor report.ok is not flipped to false");
+  });
+
   after(() => {
     rmSync(base, { recursive: true, force: true });
   });

package/src/resources/extensions/gsd/tests/session-start-footer.test.ts

@@ -0,0 +1,153 @@
+/**
+ * session-start-footer.test.ts
+ *
+ * Verifies that register-hooks.ts suppresses the built-in footer by calling
+ * ctx.ui.setFooter(hideFooter) in both session_start and session_switch when
+ * isAutoActive() is true.
+ *
+ * Testing strategy:
+ *   Two layers:
+ *   1. Source-code regression guard: ensures the guard and setFooter call are
+ *      structurally present in register-hooks.ts for both event handlers.
+ *      (node:test does not support mock.module without --experimental-test-module-mocks,
+ *       so structural analysis is the correct approach here.)
+ *   2. Behavioral integration test: fires the live session_start handler with a
+ *      fake ctx when isAutoActive() is false (its default at test time) and
+ *      confirms setFooter is NOT called — verifying the guard is conditional.
+ *
+ * Relates to #4314.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, readFileSync, rmSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const HOOKS_SOURCE = readFileSync(
+  join(__dirname, "..", "bootstrap", "register-hooks.ts"),
+  "utf-8",
+);
+
+// ─── Source-code regression guards ──────────────────────────────────────────
+
+test("register-hooks.ts imports hideFooter from auto-dashboard", () => {
+  assert.ok(
+    HOOKS_SOURCE.includes('import { hideFooter } from "../auto-dashboard.js"') ||
+    HOOKS_SOURCE.includes("import { hideFooter } from '../auto-dashboard.js'"),
+    "register-hooks.ts must import hideFooter from auto-dashboard.js",
+  );
+});
+
+test("session_start handler calls ctx.ui.setFooter(hideFooter) when isAutoActive()", () => {
+  // Locate the session_start handler body (up to the next pi.on call)
+  const sessionStartIdx = HOOKS_SOURCE.indexOf('"session_start"');
+  assert.ok(sessionStartIdx > -1, "session_start handler must exist");
+
+  const sessionSwitchIdx = HOOKS_SOURCE.indexOf('"session_switch"');
+  assert.ok(sessionSwitchIdx > sessionStartIdx, "session_switch handler must follow session_start");
+
+  const sessionStartBody = HOOKS_SOURCE.slice(sessionStartIdx, sessionSwitchIdx);
+
+  assert.ok(
+    sessionStartBody.includes("isAutoActive()"),
+    "session_start handler must call isAutoActive()",
+  );
+  assert.ok(
+    sessionStartBody.includes("ctx.ui.setFooter(hideFooter)"),
+    "session_start handler must call ctx.ui.setFooter(hideFooter)",
+  );
+
+  // Guard must wrap the setFooter call
+  const guardIdx = sessionStartBody.indexOf("isAutoActive()");
+  const setFooterIdx = sessionStartBody.indexOf("ctx.ui.setFooter(hideFooter)");
+  assert.ok(
+    guardIdx < setFooterIdx,
+    "isAutoActive() guard must appear before ctx.ui.setFooter(hideFooter) in session_start",
+  );
+});
+
+test("session_switch handler calls ctx.ui.setFooter(hideFooter) when isAutoActive()", () => {
+  const sessionSwitchIdx = HOOKS_SOURCE.indexOf('"session_switch"');
+  assert.ok(sessionSwitchIdx > -1, "session_switch handler must exist");
+
+  const beforeAgentStartIdx = HOOKS_SOURCE.indexOf('"before_agent_start"');
+  assert.ok(beforeAgentStartIdx > sessionSwitchIdx, "before_agent_start handler must follow session_switch");
+
+  const sessionSwitchBody = HOOKS_SOURCE.slice(sessionSwitchIdx, beforeAgentStartIdx);
+
+  assert.ok(
+    sessionSwitchBody.includes("isAutoActive()"),
+    "session_switch handler must call isAutoActive()",
+  );
+  assert.ok(
+    sessionSwitchBody.includes("ctx.ui.setFooter(hideFooter)"),
+    "session_switch handler must call ctx.ui.setFooter(hideFooter)",
+  );
+
+  const guardIdx = sessionSwitchBody.indexOf("isAutoActive()");
+  const setFooterIdx = sessionSwitchBody.indexOf("ctx.ui.setFooter(hideFooter)");
+  assert.ok(
+    guardIdx < setFooterIdx,
+    "isAutoActive() guard must appear before ctx.ui.setFooter(hideFooter) in session_switch",
+  );
+});
+
+// ─── Behavioral test: setFooter NOT called when auto-mode is inactive ────────
+
+test("session_start does NOT call setFooter when isAutoActive() is false (default)", async (t) => {
+  const dir = join(
+    tmpdir(),
+    `gsd-footer-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  t.after(() => {
+    process.chdir(originalCwd);
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  });
+
+  let setFooterCallCount = 0;
+
+  const handlers = new Map<string, (event: unknown, ctx: any) => Promise<void> | void>();
+  const pi = {
+    on(event: string, handler: (event: unknown, ctx: any) => Promise<void> | void) {
+      handlers.set(event, handler);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const sessionStart = handlers.get("session_start");
+  assert.ok(sessionStart, "session_start handler must be registered");
+
+  await sessionStart!({}, {
+    hasUI: true,
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setFooter: (_footer: unknown) => {
+        setFooterCallCount++;
+      },
+      setWorkingMessage: () => {},
+      onTerminalInput: () => () => {},
+      setWidget: () => {},
+    },
+    sessionManager: { getSessionId: () => null },
+    model: null,
+  } as any);
+
+  // isAutoActive() is false at test time (no auto session started),
+  // so setFooter must not be called.
+  assert.equal(
+    setFooterCallCount,
+    0,
+    "setFooter must NOT be called when isAutoActive() returns false",
+  );
+});

package/src/resources/extensions/gsd/tests/skip-slice-cascades-tasks.test.ts

@@ -0,0 +1,125 @@
+/**
+ * Regression test for #4375: gsd_skip_slice must cascade "skipped" status to
+ * all non-closed tasks in the slice.
+ *
+ * Without the cascade, executeCompleteMilestone's deep-task check finds
+ * pending tasks inside a skipped slice and refuses to complete the milestone,
+ * causing auto-mode to loop on complete-milestone until stuck-recovery aborts.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getSlice,
+  getSliceTasks,
+  updateSliceStatus,
+  updateTaskStatus,
+} from "../gsd-db.ts";
+import { handleSkipSlice } from "../tools/skip-slice.ts";
+
+describe("handleSkipSlice cascades skip to tasks (#4375)", () => {
+  let dir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "gsd-skip-cascade-"));
+    dbPath = join(dir, "test.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    insertSlice({ milestoneId: "M001", id: "S03", title: "Deferred", status: "pending", sequence: 3 });
+    insertTask({ milestoneId: "M001", sliceId: "S03", id: "T01", title: "task 1", status: "pending", sequence: 1 });
+    insertTask({ milestoneId: "M001", sliceId: "S03", id: "T02", title: "task 2", status: "active", sequence: 2 });
+    insertTask({ milestoneId: "M001", sliceId: "S03", id: "T03", title: "task 3", status: "pending", sequence: 3 });
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("sets slice to skipped and cascades pending/active tasks to skipped", () => {
+    const result = handleSkipSlice({ milestoneId: "M001", sliceId: "S03", reason: "deferred" });
+
+    assert.equal(result.error, undefined, `expected success, got error: ${result.error ?? ""}`);
+    assert.equal(result.sliceId, "S03");
+    assert.equal(result.milestoneId, "M001");
+    assert.equal(result.tasksSkipped, 3, "all three non-closed tasks should be cascaded");
+
+    const slice = getSlice("M001", "S03");
+    assert.equal(slice?.status, "skipped", "slice status must be skipped");
+
+    const tasks = getSliceTasks("M001", "S03");
+    for (const t of tasks) {
+      assert.equal(t.status, "skipped", `task ${t.id} must be skipped after cascade`);
+    }
+  });
+
+  test("does not downgrade already-closed tasks", () => {
+    updateTaskStatus("M001", "S03", "T01", "complete", new Date().toISOString());
+
+    const result = handleSkipSlice({ milestoneId: "M001", sliceId: "S03" });
+
+    assert.equal(result.error, undefined);
+    assert.equal(result.tasksSkipped, 2, "only the two non-closed tasks should be cascaded");
+
+    const tasks = getSliceTasks("M001", "S03");
+    const byId = new Map(tasks.map((t) => [t.id, t.status]));
+    assert.equal(byId.get("T01"), "complete", "completed task must not be downgraded");
+    assert.equal(byId.get("T02"), "skipped");
+    assert.equal(byId.get("T03"), "skipped");
+  });
+
+  test("re-running skip on an already-skipped slice heals leftover pending tasks (#4375 recovery)", () => {
+    const first = handleSkipSlice({ milestoneId: "M001", sliceId: "S03" });
+    assert.equal(first.error, undefined);
+    assert.equal(first.tasksSkipped, 3);
+
+    // Simulate historical inconsistent state: slice skipped but a task was
+    // later recreated or reset to pending by some migration/bug path.
+    updateTaskStatus("M001", "S03", "T01", "pending");
+
+    const second = handleSkipSlice({ milestoneId: "M001", sliceId: "S03" });
+    assert.equal(second.error, undefined, "re-running must succeed (no 'already skipped' hard error)");
+    assert.equal(second.tasksSkipped, 1, "only the leftover pending task should be cascaded");
+    assert.equal(second.wasAlreadySkipped, true);
+
+    const tasks = getSliceTasks("M001", "S03");
+    for (const t of tasks) {
+      assert.equal(t.status, "skipped", `task ${t.id} must be skipped after recovery`);
+    }
+  });
+
+  test("refuses to skip an already-complete slice", () => {
+    updateSliceStatus("M001", "S03", "complete");
+
+    const result = handleSkipSlice({ milestoneId: "M001", sliceId: "S03" });
+    assert.ok(result.error, "expected error when slice is already complete");
+    assert.match(result.error!, /already complete/i);
+    assert.equal(result.errorCode, "already_complete");
+  });
+
+  test("refuses to skip a slice in the legacy 'done' status", () => {
+    updateSliceStatus("M001", "S03", "done");
+
+    const result = handleSkipSlice({ milestoneId: "M001", sliceId: "S03" });
+    assert.ok(result.error, "expected error when slice is already done");
+    assert.match(result.error!, /already complete/i);
+    assert.equal(result.errorCode, "already_complete");
+  });
+
+  test("returns error for unknown slice", () => {
+    const result = handleSkipSlice({ milestoneId: "M001", sliceId: "S99" });
+    assert.ok(result.error);
+    assert.match(result.error!, /not found/i);
+    assert.equal(result.errorCode, "slice_not_found");
+  });
+});