gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.fd2382b9f

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/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/slice-context-injection.test.ts

@@ -31,18 +31,30 @@ describe("slice CONTEXT.md injection into prompt builders (#3452)", () => {
       const fnStart = source.indexOf(`export async function ${builder}`);
       assert.ok(fnStart !== -1, `${builder} should exist in auto-prompts.ts`);
 
-      // Get a reasonable chunk after the function start (enough to cover the inlining section)
+      // Get a reasonable chunk after the function start
       const chunk = source.slice(fnStart, fnStart + 3000);
 
+      // ADR-011: buildPlanSlicePrompt / buildRefineSlicePrompt now delegate to
+      // a shared helper (renderSlicePrompt) that performs the slice CONTEXT
+      // resolve. When a builder delegates, scan the helper's body instead.
+      const delegatesToHelper = chunk.includes("renderSlicePrompt(");
+      const bodyToCheck = delegatesToHelper
+        ? (() => {
+            const helperStart = source.indexOf("async function renderSlicePrompt");
+            assert.ok(helperStart !== -1, "renderSlicePrompt helper must exist");
+            return source.slice(helperStart, helperStart + 3000);
+          })()
+        : chunk;
+
       // Must resolve the slice CONTEXT path
       assert.ok(
-        chunk.includes('resolveSliceFile(base, mid,') && chunk.includes('"CONTEXT"'),
-        `${builder} should call resolveSliceFile with "CONTEXT"`,
+        bodyToCheck.includes('resolveSliceFile(base, mid,') && bodyToCheck.includes('"CONTEXT"'),
+        `${builder} should call resolveSliceFile with "CONTEXT" (directly or via renderSlicePrompt)`,
       );
 
       // Must inline it with inlineFileOptional
       assert.ok(
-        chunk.includes('Slice Context'),
+        bodyToCheck.includes("Slice Context"),
         `${builder} should inline slice CONTEXT with a "Slice Context" label`,
       );
     });

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

@@ -93,6 +93,8 @@ function makeSliceRow(id: string, overrides: Partial<SliceRow> = {}): SliceRow {
     integration_closure: "",
     observability_impact: "",
     replan_triggered_at: null,
+    is_sketch: 0,
+    sketch_scope: "",
     ...overrides,
   };
 }
@@ -295,6 +297,7 @@ describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merg
       loadEffectiveGSDPreferences: () => undefined,
       invalidateAllCaches: () => {},
       captureIntegrationBranch: () => {},
+      enterBranchModeForMilestone: () => {},
     };
 
     // Import and create resolver

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

@@ -79,6 +79,21 @@ test("Rule 2: interrupted sequence does not trigger", () => {
   );
 });
 
+test("Rule 2b: same unit repeated 3 times in the window triggers stuck even with an intervening unit", () => {
+  const result = detectStuck([
+    { key: "execute-task/M002/S03/T01" },
+    { key: "execute-task/M002/S03/T01" },
+    { key: "reassess-roadmap/M002/S02" },
+    { key: "execute-task/M002/S03/T01" },
+  ]);
+  assert.notEqual(result, null);
+  assert.equal(result!.stuck, true);
+  assert.ok(
+    result!.reason.includes("3 times in last 4 attempts"),
+    `reason was: ${result!.reason}`,
+  );
+});
+
 // ─── Rule 3: Oscillation A→B→A→B ─────────────────────────────────────────────
 
 test("Rule 3: A-B-A-B oscillation triggers stuck", () => {

package/src/resources/extensions/gsd/tests/summary-render-parity.test.ts

@@ -50,6 +50,11 @@ const taskRow: TaskRow = {
   observability_impact: "",
   full_plan_md: "",
   sequence: 1,
+  blocker_source: "",
+  escalation_pending: 0,
+  escalation_awaiting_review: 0,
+  escalation_artifact_path: null,
+  escalation_override_applied_at: null,
 };
 
 const verificationEvidence = [

package/src/resources/extensions/gsd/tests/uok-contracts.test.ts

@@ -64,8 +64,9 @@ test("uok contracts include required DAG node kinds", () => {
     "team-worker",
     "verification",
     "reprocess",
+    "refine",
   ];
-  assert.deepEqual(required.length, 6);
+  assert.deepEqual(required.length, 7);
 });
 
 test("uok audit envelope includes trace/turn/causality fields", () => {

package/src/resources/extensions/gsd/tests/uok-flags.test.ts

@@ -7,6 +7,37 @@ test("uok flags default to enabled when preference is unset", () => {
   const flags = resolveUokFlags(undefined);
   assert.equal(flags.enabled, true);
   assert.equal(flags.legacyFallback, false);
+  assert.equal(flags.gates, true);
+  assert.equal(flags.modelPolicy, true);
+  assert.equal(flags.executionGraph, true);
+  assert.equal(flags.gitops, true);
+  assert.equal(flags.auditUnified, true);
+  assert.equal(flags.planV2, true);
+  assert.equal(flags.gitopsTurnAction, "commit");
+  assert.equal(flags.gitopsTurnPush, false);
+});
+
+test("uok nested flags support explicit opt-out", () => {
+  const flags = resolveUokFlags({
+    uok: {
+      enabled: true,
+      gates: { enabled: false },
+      model_policy: { enabled: false },
+      execution_graph: { enabled: false },
+      gitops: { enabled: false, turn_action: "commit", turn_push: true },
+      audit_unified: { enabled: false },
+      plan_v2: { enabled: false },
+    },
+  });
+  assert.equal(flags.enabled, true);
+  assert.equal(flags.gates, false);
+  assert.equal(flags.modelPolicy, false);
+  assert.equal(flags.executionGraph, false);
+  assert.equal(flags.gitops, false);
+  assert.equal(flags.auditUnified, false);
+  assert.equal(flags.planV2, false);
+  assert.equal(flags.gitopsTurnAction, "commit");
+  assert.equal(flags.gitopsTurnPush, true);
 });
 
 test("uok legacy fallback preference forces legacy path", () => {
@@ -36,4 +67,3 @@ test("uok legacy fallback env var forces legacy path", () => {
     else process.env.GSD_UOK_FORCE_LEGACY = previous;
   }
 });
-