gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0-dev.aeeb2ca00

package/src/resources/extensions/gsd/tests/merge-conflict-stops-loop.test.ts

@@ -2,65 +2,237 @@
  * merge-conflict-stops-loop.test.ts — #2330
  *
  * When a squash merge has real code conflicts (not just .gsd/ files),
- * the merge retries forever because MergeConflictError is caught
- * silently in mergeAndExit. This test verifies that:
- * 1. worktree-resolver re-throws MergeConflictError for code conflicts
- * 2. auto/phases.ts wraps mergeAndExit calls to stop the loop on conflict
+ * the merge used to retry forever because `MergeConflictError` was
+ * caught silently in `mergeAndExit`. The fix:
+ *
+ *   1. `WorktreeResolver.mergeAndExit` **re-throws** `MergeConflictError`
+ *      (and other unexpected errors) so the caller sees the failure.
+ *   2. `auto/phases.ts` catches `MergeConflictError` from `mergeAndExit`
+ *      and returns `{ action: "break", reason: "merge-conflict" }` +
+ *      calls `stopAuto`, instead of looping.
+ *
+ * The previous version of this file was three source-grep assertions
+ * (`src.includes("MergeConflictError")` / `src.includes("throw err")` /
+ * `extractSourceRegion(..., "instanceof MergeConflictError").includes("stopAuto")`).
+ * Those all pass even if the bug reappears verbatim — the catch block
+ * could swallow the error silently as long as the identifier text
+ * remains somewhere in the file. Called out in #4784 / #4824 as the
+ * canonical source-grep false-coverage case.
+ *
+ * This rewrite tests the invariant at the `WorktreeResolver` layer
+ * (where the re-throw happens) with injected deps: we wire
+ * `mergeMilestoneToMain` to throw `MergeConflictError`, call
+ * `mergeAndExit`, and assert the error propagates. That is the ONLY
+ * assertion that fails if someone reverts the re-throw to a silent
+ * catch.
  */
 
-import { readFileSync } from "node:fs";
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertTrue, report } = createTestContext();
-
-const resolverPath = join(import.meta.dirname, "..", "worktree-resolver.ts");
-const resolverSrc = readFileSync(resolverPath, "utf-8");
-
-const phasesPath = join(import.meta.dirname, "..", "auto", "phases.ts");
-const phasesSrc = readFileSync(phasesPath, "utf-8");
-
-console.log("\n=== #2330: Merge conflict stops auto loop ===");
-
-// ── Test 1: worktree-resolver re-throws MergeConflictError ──────────────
-
-const methodStart = resolverSrc.indexOf("Worktree-mode merge:");
-assertTrue(methodStart > 0, "worktree-resolver has _mergeWorktreeMode method");
-
-const methodBody = resolverSrc.slice(methodStart, methodStart + 6000);
-const rethrowsConflict =
-  methodBody.includes("MergeConflictError") &&
-  methodBody.includes("throw err");
-
-assertTrue(
-  rethrowsConflict,
-  "worktree-resolver._mergeWorktreeMode re-throws MergeConflictError (#2330)",
-);
-
-// ── Test 2: auto/phases.ts imports and uses MergeConflictError ──────────
-
-assertTrue(
-  phasesSrc.includes("MergeConflictError") && phasesSrc.includes("mergeAndExit"),
-  "auto/phases.ts handles MergeConflictError from mergeAndExit (#2330)",
-);
-
-// ── Test 3: The handler stops the loop (doesn't just warn) ──────────────
-
-// Find the instanceof MergeConflictError check (not the import line)
-const instanceofIdx = phasesSrc.indexOf("instanceof MergeConflictError");
-assertTrue(instanceofIdx > 0, "auto/phases.ts has instanceof MergeConflictError check");
+import { tmpdir } from "node:os";
+
+import { WorktreeResolver } from "../worktree-resolver.ts";
+import { MergeConflictError } from "../git-service.ts";
+import type { WorktreeResolverDeps } from "../worktree-resolver.ts";
+import type { AutoSession } from "../auto/session.ts";
+
+// ─── Test-only session double ───────────────────────────────────────────
+// `AutoSession` is a large class but `WorktreeResolver` only reads a few
+// fields from it (basePath, originalBasePath, currentMilestoneId).
+function makeSession(basePath: string): AutoSession {
+  return {
+    basePath,
+    originalBasePath: basePath,
+    currentMilestoneId: "M001",
+  } as unknown as AutoSession;
+}
 
-if (instanceofIdx > 0) {
-  const afterHandler = phasesSrc.slice(instanceofIdx, instanceofIdx + 500);
-  const stopsLoop =
-    afterHandler.includes("stopAuto") ||
-    afterHandler.includes('action: "break"') ||
-    afterHandler.includes("reason: \"merge-conflict\"");
+/**
+ * Build a deps object where every method is a no-op or a controlled
+ * value, except the ones the caller explicitly overrides. This is the
+ * boring-tech approach — no mocking library, just plain objects.
+ */
+function makeDeps(
+  overrides: Partial<WorktreeResolverDeps> = {},
+): WorktreeResolverDeps {
+  return {
+    isInAutoWorktree: () => true,
+    shouldUseWorktreeIsolation: () => true,
+    getIsolationMode: () => "worktree",
+    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+    syncWorktreeStateBack: () => ({ synced: [] }),
+    teardownAutoWorktree: () => undefined,
+    createAutoWorktree: () => "",
+    enterAutoWorktree: () => "",
+    enterBranchModeForMilestone: () => undefined,
+    getAutoWorktreePath: () => null,
+    autoCommitCurrentBranch: () => undefined,
+    getCurrentBranch: () => "worktree/M001",
+    autoWorktreeBranch: (mid: string) => `worktree/${mid}`,
+    resolveMilestoneFile: () => null, // no roadmap → early return path
+    readFileSync: () => "",
+    GitServiceImpl: class {
+      constructor(_basePath: string, _config: unknown) {}
+    } as never,
+    loadEffectiveGSDPreferences: () => ({ preferences: {} }),
+    invalidateAllCaches: () => undefined,
+    captureIntegrationBranch: () => undefined,
+    ...overrides,
+  };
+}
 
-  assertTrue(
-    stopsLoop,
-    "auto/phases.ts stops the loop when merge conflict is detected (#2330)",
-  );
+function makeNotifyCtx(): {
+  notify: (msg: string, level?: "info" | "warning" | "error" | "success") => void;
+  calls: Array<{ msg: string; level?: string }>;
+} {
+  const calls: Array<{ msg: string; level?: string }> = [];
+  return {
+    notify: (msg, level) => {
+      calls.push({ msg, level });
+    },
+    calls,
+  };
 }
 
-report();
+describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", () => {
+  let baseDir: string;
+
+  beforeEach(() => {
+    baseDir = mkdtempSync(join(tmpdir(), "merge-conflict-stops-loop-"));
+    // Fake out a milestone directory so mergeAndExit reaches mergeMilestoneToMain.
+    mkdirSync(join(baseDir, ".gsd", "milestones", "M001"), { recursive: true });
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(baseDir, { recursive: true, force: true });
+    } catch {
+      // best-effort
+    }
+  });
+
+  test("propagates MergeConflictError with conflicted file list", () => {
+    const conflicted = ["src/feature.ts", "README.md"];
+    const roadmapPath = join(baseDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    const deps = makeDeps({
+      resolveMilestoneFile: (_base, _mid, type) =>
+        type === "ROADMAP" ? roadmapPath : null,
+      readFileSync: () => "# M001\n",
+      mergeMilestoneToMain: () => {
+        throw new MergeConflictError(conflicted, "squash", "worktree/M001", "main");
+      },
+    });
+
+    const resolver = new WorktreeResolver(makeSession(baseDir), deps);
+    const ctx = makeNotifyCtx();
+
+    assert.throws(
+      () => resolver.mergeAndExit("M001", ctx),
+      (err: unknown) => {
+        assert.ok(
+          err instanceof MergeConflictError,
+          `expected MergeConflictError, got: ${err}`,
+        );
+        assert.deepEqual(err.conflictedFiles, conflicted);
+        assert.equal(err.strategy, "squash");
+        assert.equal(err.branch, "worktree/M001");
+        assert.equal(err.mainBranch, "main");
+        return true;
+      },
+    );
+  });
+
+  test("propagates non-conflict errors too (#4380 — never swallow silently)", () => {
+    const roadmapPath = join(baseDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    class FakePermError extends Error {}
+    const deps = makeDeps({
+      resolveMilestoneFile: (_base, _mid, type) =>
+        type === "ROADMAP" ? roadmapPath : null,
+      readFileSync: () => "# M001\n",
+      mergeMilestoneToMain: () => {
+        throw new FakePermError("EACCES: permission denied");
+      },
+    });
+
+    const resolver = new WorktreeResolver(makeSession(baseDir), deps);
+    const ctx = makeNotifyCtx();
+
+    assert.throws(
+      () => resolver.mergeAndExit("M001", ctx),
+      (err: unknown) => {
+        assert.ok(
+          err instanceof FakePermError,
+          `expected FakePermError, got: ${err}`,
+        );
+        return true;
+      },
+    );
+  });
+
+  test("successful merge does not throw", () => {
+    const roadmapPath = join(baseDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    const deps = makeDeps({
+      resolveMilestoneFile: (_base, _mid, type) =>
+        type === "ROADMAP" ? roadmapPath : null,
+      readFileSync: () => "# M001\n",
+      mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+    });
+
+    const resolver = new WorktreeResolver(makeSession(baseDir), deps);
+    const ctx = makeNotifyCtx();
+
+    // Should not throw — the success path.
+    assert.doesNotThrow(() => resolver.mergeAndExit("M001", ctx));
+  });
+});
+
+// ─── phases.ts handler contract ──────────────────────────────────────────
+//
+// The inline handler at `auto/phases.ts:580-598 / 695-712 / 823-840`:
+//
+//   if (mergeErr instanceof MergeConflictError) {
+//     ctx.ui.notify(`Merge conflict: ${mergeErr.conflictedFiles.join(", ")}. ...`);
+//     await deps.stopAuto(...);
+//     return { action: "break", reason: "merge-conflict" };
+//   }
+//
+// Testing it end-to-end requires constructing a full `IterationContext`
+// + `LoopState` + `deps` surface (hundreds of fields). Extracting the
+// handler into a reusable helper is the right refactor and is tracked
+// alongside this issue. In the meantime, defend the contract between
+// the thrower and the handler: if the fields the handler formats drift,
+// the handler silently regresses.
+
+describe("Merge-conflict handler contract (#2330 — phases.ts inline pattern)", () => {
+  test("MergeConflictError exposes fields the phases.ts handler formats", () => {
+    const err = new MergeConflictError(
+      ["a.ts", "b.ts"],
+      "squash",
+      "worktree/M001",
+      "main",
+    );
+    assert.deepEqual(err.conflictedFiles, ["a.ts", "b.ts"]);
+    assert.equal(err.strategy, "squash");
+    assert.equal(err.branch, "worktree/M001");
+    assert.equal(err.mainBranch, "main");
+    // instanceof is the type-discriminant the handler uses.
+    assert.ok(err instanceof MergeConflictError);
+    // The class extends Error so the non-conflict fallback message path
+    // (`String(mergeErr)` / `mergeErr.message`) still works.
+    assert.ok(err instanceof Error);
+    assert.match(err.message, /worktree\/M001/);
+    assert.match(err.message, /main/);
+  });
+
+  test("MergeConflictError with empty conflicted list still serializes (edge)", () => {
+    // The handler's `conflictedFiles.join(", ")` must not crash on empty
+    // list. Defensive: some producers could legitimately emit a
+    // zero-length array.
+    const err = new MergeConflictError([], "merge", "feature/x", "main");
+    assert.deepEqual(err.conflictedFiles, []);
+    assert.equal(err.conflictedFiles.join(", "), "");
+    assert.ok(err instanceof MergeConflictError);
+  });
+});

package/src/resources/extensions/gsd/tests/milestone-scope-classifier.test.ts

@@ -0,0 +1,187 @@
+// GSD-2 — #4781: classifier behavior matrix. Pure-function tests, no I/O.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  classifyMilestoneScope,
+  type MilestoneScopeInput,
+} from "../milestone-scope-classifier.ts";
+
+// ─── Classification matrix ────────────────────────────────────────────────
+
+test("#4781 classifier: single static HTML to-do app → trivial (b23 forensic case)", () => {
+  const input: MilestoneScopeInput = {
+    title: "To-Do App",
+    vision: "A minimal, clean browser-based to-do app. Pure HTML/CSS/JS, no build step, no backend. Tasks persist in localStorage.",
+    successCriteria: [
+      "Open index.html in any browser without a server",
+      "Add tasks by typing and pressing Enter or clicking Add",
+      "Mark tasks complete (toggleable)",
+      "Delete individual tasks",
+      "Tasks survive a page reload via localStorage",
+    ],
+  };
+  const r = classifyMilestoneScope(input);
+  assert.strictEqual(r.variant, "trivial", `expected trivial, got ${r.variant} — reasons: ${r.reasons.join("; ")}`);
+  assert.ok(r.reasons.some(s => s.includes("trivial keywords")), "should cite trivial keywords");
+});
+
+test("#4781 classifier: readme typo fix → trivial", () => {
+  const r = classifyMilestoneScope({
+    title: "Fix README typo",
+    vision: "Correct spelling error in the installation section.",
+    successCriteria: ["Typo fixed", "README renders correctly"],
+  });
+  assert.strictEqual(r.variant, "trivial");
+});
+
+test("#4781 classifier: auth flow single file → standard (override beats trivial)", () => {
+  const r = classifyMilestoneScope({
+    title: "Add login",
+    vision: "Implement authentication flow in a single file with OAuth credentials.",
+    successCriteria: ["User can log in"],
+  });
+  assert.strictEqual(r.variant, "standard", `override should beat single-file signal. reasons: ${r.reasons.join("; ")}`);
+  assert.ok(r.signals.triggeredOverride, "override signals should be flagged");
+  assert.ok(r.reasons.some(s => s.includes("override keywords")));
+});
+
+test("#4781 classifier: security review scope → standard (even if small)", () => {
+  const r = classifyMilestoneScope({
+    title: "Harden session tokens",
+    vision: "Review and patch security vulnerability in one session token helper.",
+    successCriteria: ["No XSS via token"],
+  });
+  assert.strictEqual(r.variant, "standard");
+  assert.ok(r.signals.triggeredOverride);
+});
+
+test("#4781 classifier: schema migration mentioned → standard (override-level signal)", () => {
+  const r = classifyMilestoneScope({
+    title: "User profile v2",
+    vision: "Perform schema migration to split user.name into first_name and last_name across the users table.",
+    successCriteria: ["Migration lands", "Existing rows backfilled", "Rollback path validated"],
+  });
+  // "migration" / "migrate" / "backfill" are OVERRIDE_KEYWORDS, not
+  // COMPLEX_KEYWORDS — migration is override-level (forces at least
+  // `standard`), not complex-level. Safe behavior: migrations need the
+  // full standard pipeline but not the extra ceremony of complex.
+  assert.strictEqual(r.variant, "standard", `reasons: ${r.reasons.join("; ")}`);
+});
+
+test("#4781 classifier: architecture keyword → complex", () => {
+  const r = classifyMilestoneScope({
+    title: "Redesign plugin registry",
+    vision: "Refactor core architecture of the plugin registry to support versioned contracts.",
+  });
+  assert.strictEqual(r.variant, "complex");
+  assert.ok(r.reasons.some(s => s.includes("complex keywords")));
+});
+
+test("#4781 classifier: >=8 files hint → complex", () => {
+  const r = classifyMilestoneScope({
+    title: "Multi-file refactor",
+    vision: "Touch 12 files to extract shared helpers.",
+  });
+  assert.strictEqual(r.variant, "complex");
+  assert.strictEqual(r.signals.fileCountHint, 12);
+});
+
+test("#4781 classifier: backend API mention → standard (not trivial)", () => {
+  const r = classifyMilestoneScope({
+    title: "Health endpoint",
+    vision: "Add a single-file API endpoint returning status.",
+    successCriteria: ["/health returns 200"],
+  });
+  // Single file + no override + but backend mentioned → not trivial
+  assert.strictEqual(r.variant, "standard");
+});
+
+test("#4781 classifier: tests mentioned → standard (not trivial)", () => {
+  const r = classifyMilestoneScope({
+    title: "Landing page",
+    vision: "Ship a static one-page landing page with unit tests for the form validation.",
+  });
+  assert.strictEqual(r.variant, "standard", `reasons: ${r.reasons.join("; ")}`);
+});
+
+test("#4781 classifier: ambiguous prose → standard (safe default)", () => {
+  const r = classifyMilestoneScope({
+    title: "Generic improvements",
+    vision: "Make the system better.",
+    successCriteria: ["It's better"],
+  });
+  assert.strictEqual(r.variant, "standard");
+  assert.ok(r.reasons.includes("no strong signals — default"));
+});
+
+test("#4781 classifier: empty input → standard (safe default)", () => {
+  const r = classifyMilestoneScope({});
+  assert.strictEqual(r.variant, "standard");
+});
+
+// ─── Override precedence over trivial ──────────────────────────────────────
+
+test("#4781 classifier: override + trivial keyword → standard (override wins)", () => {
+  const r = classifyMilestoneScope({
+    title: "Token rotation",
+    vision: "Single file change to rotate the oauth token expiry schedule.",
+  });
+  // "single file" is trivial signal; "oauth" is override signal. Override wins.
+  assert.strictEqual(r.variant, "standard");
+  assert.ok(r.signals.triggeredOverride);
+});
+
+test("#4781 classifier: complex + override → complex (complex wins, flagged)", () => {
+  const r = classifyMilestoneScope({
+    title: "Auth service refactor",
+    vision: "Refactor core authentication architecture across services.",
+  });
+  // Complex (architecture, refactor core) wins over override (auth).
+  assert.strictEqual(r.variant, "complex");
+  // Override still recorded in signals for telemetry.
+  assert.ok(r.signals.triggeredOverride, "override hits should still be tracked in signals");
+});
+
+// ─── File count hint extraction ───────────────────────────────────────────
+
+test("#4781 classifier: 'a single file' hint parsed as 1", () => {
+  const r = classifyMilestoneScope({
+    title: "Tweak",
+    vision: "Update a single file to flip the copy.",
+  });
+  assert.strictEqual(r.signals.fileCountHint, 1);
+});
+
+test("#4781 classifier: 'two files' hint parsed as 2", () => {
+  const r = classifyMilestoneScope({
+    title: "Minor",
+    vision: "Touch two files.",
+  });
+  assert.strictEqual(r.signals.fileCountHint, 2);
+});
+
+test("#4781 classifier: '12 files' hint parsed as 12", () => {
+  const r = classifyMilestoneScope({
+    title: "Bulk",
+    vision: "Update 12 files.",
+  });
+  assert.strictEqual(r.signals.fileCountHint, 12);
+});
+
+// ─── Reasons surface useful debugging info ─────────────────────────────────
+
+test("#4781 classifier: reasons array populated for every branch", () => {
+  const branches: Array<[string, MilestoneScopeInput]> = [
+    ["trivial", { title: "Readme typo", vision: "Fix a single file typo." }],
+    ["standard (override)", { title: "Auth", vision: "Touch auth helper." }],
+    ["complex (keyword)", { title: "Arch", vision: "Refactor core system design." }],
+    ["complex (file count)", { title: "Bulk", vision: "Update 9 files." }],
+    ["standard (default)", { title: "Generic", vision: "General work." }],
+  ];
+  for (const [label, input] of branches) {
+    const r = classifyMilestoneScope(input);
+    assert.ok(r.reasons.length > 0, `${label}: reasons must not be empty`);
+  }
+});

package/src/resources/extensions/gsd/tests/milestone-summary-classifier.test.ts

@@ -0,0 +1,30 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { classifyMilestoneSummaryContent } from "../milestone-summary-classifier.ts";
+
+test("milestone SUMMARY classifier treats explicit failed status as failure", () => {
+  assert.equal(
+    classifyMilestoneSummaryContent([
+      "---",
+      "status: failed",
+      "---",
+      "",
+      "# M001 Summary",
+      "Recovery stopped.",
+    ].join("\n")),
+    "failure",
+  );
+});
+
+test("milestone SUMMARY classifier does not treat historical not-complete prose as failure", () => {
+  assert.equal(
+    classifyMilestoneSummaryContent([
+      "# M001 Summary",
+      "",
+      "This milestone was previously not complete, now resolved.",
+    ].join("\n")),
+    "unknown",
+  );
+});
+

package/src/resources/extensions/gsd/tests/model-cost-table.test.ts

@@ -74,7 +74,7 @@ test("#2885: cost table includes openai-codex provider models", () => {
   const ids = BUNDLED_COST_TABLE.map(e => e.id);
   const codexModels = [
     "gpt-5.1", "gpt-5.1-codex-max", "gpt-5.1-codex-mini",
-    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini",
+    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini", "gpt-5.5",
   ];
   for (const model of codexModels) {
     assert.ok(ids.includes(model), `cost table should include openai-codex model "${model}"`);
@@ -101,3 +101,11 @@ test("#2885: lookupModelCost returns costs for new models (not 999 fallback)", (
     assert.ok(entry.inputPer1k < 999, `${model} should have a real cost, not the 999 fallback`);
   }
 });
+
+test("gpt-5.5 uses official OpenAI list pricing", () => {
+  const entry = lookupModelCost("gpt-5.5");
+  assert.ok(entry, "lookupModelCost should find gpt-5.5");
+  assert.equal(entry.inputPer1k, 0.005);
+  assert.equal(entry.outputPer1k, 0.03);
+  assert.equal(entry.updatedAt, "2026-04-23");
+});

package/src/resources/extensions/gsd/tests/model-router.test.ts

@@ -382,7 +382,7 @@ test("#2885: openai-codex standard-tier models are recognized", () => {
 
 test("#2885: openai-codex heavy-tier models are recognized", () => {
   const config = { ...defaultRoutingConfig(), enabled: true };
-  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "o4-mini", "o4-mini-deep-research"];
+  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "gpt-5.5", "o4-mini", "o4-mini-deep-research"];
   for (const model of heavyModels) {
     const result = resolveModelForComplexity(
       makeClassification("heavy"),

package/src/resources/extensions/gsd/tests/native-git-bridge-exec-fallback.test.ts

@@ -18,54 +18,12 @@ import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 import { nativeIsRepo, nativeCommit, nativeResetHard } from "../native-git-bridge.js";
 
-// ─── Static analysis ──────────────────────────────────────────────────────
-// Verify the fallback paths of the three affected functions do not call the
-// raw execSync() string-command variant. Replacing all execFileSync( tokens
-// first ensures we match only the bare execSync( form.
-
-const SRC_PATH = join(import.meta.dirname, "..", "native-git-bridge.ts");
-
-function extractFunctionBody(src: string, fnName: string): string {
-  const idx = src.indexOf(`export function ${fnName}`);
-  if (idx === -1) throw new Error(`${fnName} not found in source`);
-  return src.slice(idx, idx + 1500);
-}
-
-function hasRawExecSync(body: string): boolean {
-  const withoutFileSync = body.replace(/execFileSync\(/g, "__FILESYNC__");
-  return withoutFileSync.includes("execSync(");
-}
-
-describe("native-git-bridge #4180: fallback paths use execFileSync not execSync", () => {
-  const src = readFileSync(SRC_PATH, "utf-8");
-
-  test("nativeIsRepo fallback does not use raw execSync", () => {
-    const body = extractFunctionBody(src, "nativeIsRepo");
-    assert.equal(
-      hasRawExecSync(body),
-      false,
-      "nativeIsRepo fallback must use execFileSync to avoid cmd.exe PATH failures on Windows",
-    );
-  });
-
-  test("nativeCommit fallback does not use raw execSync", () => {
-    const body = extractFunctionBody(src, "nativeCommit");
-    assert.equal(
-      hasRawExecSync(body),
-      false,
-      "nativeCommit fallback must use execFileSync to avoid cmd.exe PATH failures on Windows",
-    );
-  });
-
-  test("nativeResetHard fallback does not use raw execSync", () => {
-    const body = extractFunctionBody(src, "nativeResetHard");
-    assert.equal(
-      hasRawExecSync(body),
-      false,
-      "nativeResetHard fallback must use execFileSync to avoid cmd.exe PATH failures on Windows",
-    );
-  });
-});
+// Note: prior static-analysis tests that scanned native-git-bridge.ts for
+// the raw shell-spawn pattern were removed under #4827 — the integration
+// tests below already exercise the fallback path end-to-end with the native
+// module disabled (GSD_ENABLE_NATIVE_GSD_GIT unset). Any cmd.exe PATH
+// regression on Windows surfaces through a real fallback failure, not a
+// grep miss in source text.
 
 // ─── Integration tests ────────────────────────────────────────────────────
 // Verify correct runtime behaviour through the fallback path (native module

package/src/resources/extensions/gsd/tests/notification-widget.test.ts

@@ -16,9 +16,12 @@ test("buildNotificationWidgetLines shows unread count with shortcut pair", () =>
     appendNotification("Need attention", "warning");
 
     const lines = buildNotificationWidgetLines();
-    assert.equal(lines.length, 1);
-    assert.match(lines[0]!, /🔔\s+1 unread/);
-    assert.match(lines[0]!, /\(.+\/.+\)/);
+    // Widget must render at least one line; may add secondary lines later
+    // (e.g., "View with /gsd notif") without breaking this assertion.
+    assert.ok(lines.length >= 1, `expected at least 1 widget line, got ${lines.length}`);
+    const combined = lines.join("\n");
+    assert.match(combined, /🔔\s+1 unread/);
+    assert.match(combined, /\(.+\/.+\)/);
   } finally {
     _resetNotificationStore();
     rmSync(tmp, { recursive: true, force: true });