gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

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

@@ -1,4 +1,4 @@
-import { parseMemoryResponse, _resetExtractionState, buildMemoryLLMCall } from '../memory-extractor.ts';
+import { parseMemoryResponse, buildMemoryLLMCall } from '../memory-extractor.ts';
 import {
   openDatabase,
   closeDatabase,
@@ -159,16 +159,6 @@ test('integration: mixed action lifecycle', () => {
   closeDatabase();
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-extractor: _resetExtractionState
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('memory-extractor: reset extraction state', () => {
-  // Just verify it doesn't throw
-  _resetExtractionState();
-  assert.ok(true, '_resetExtractionState should not throw');
-});
-
 // ═══════════════════════════════════════════════════════════════════════════
 // memory-extractor: buildMemoryLLMCall resolves OAuth API key via modelRegistry
 // Regression test for #2959 — OAuth users had broken memory extraction
@@ -200,8 +190,8 @@ test('memory-extractor: buildMemoryLLMCall resolves API key from modelRegistry f
   assert.ok(llmCallFn !== null, 'buildMemoryLLMCall should return a function when models are available');
 
   // The function should have resolved the API key eagerly via modelRegistry.getApiKey.
-  // Give the async getApiKey a tick to resolve.
-  await new Promise(resolve => setTimeout(resolve, 50));
+  // Await the exposed promise deterministically instead of polling via setTimeout.
+  await llmCallFn!.apiKeyReady;
   assert.ok(getApiKeyCalled, 'buildMemoryLLMCall must call modelRegistry.getApiKey() to resolve OAuth tokens');
 });
 
@@ -246,8 +236,8 @@ test('memory-extractor: buildMemoryLLMCall prefers haiku model', async () => {
   const llmCallFn = buildMemoryLLMCall(ctx);
   assert.ok(llmCallFn !== null, 'should return a function');
 
-  // Wait for the async getApiKey to resolve
-  await new Promise(resolve => setTimeout(resolve, 50));
+  // Await the exposed API-key-ready promise deterministically.
+  await llmCallFn!.apiKeyReady;
   assert.strictEqual(resolvedModelId, 'claude-3-5-haiku-20241022',
     'should resolve API key for haiku model, not sonnet');
 });

package/src/resources/extensions/gsd/tests/memory-pressure-stuck-state.test.ts

@@ -51,4 +51,16 @@ describe("stuck detection persistence (#3704)", () => {
   test("stuck state file path uses runtime directory", () => {
     assert.match(loopSource, /stuck-state\.json/);
   });
+
+  test("saveStuckState called in standard dev path as well as custom engine path (#4382)", () => {
+    // Count all call-sites of saveStuckState (excluding the function definition itself).
+    // After the fix, both the custom-engine path and the standard dev path must each
+    // call saveStuckState so stuckRecoveryAttempts survives session restarts.
+    const callMatches = loopSource.match(/saveStuckState\(s\.basePath,\s*loopState\)/g) ?? [];
+    assert.ok(
+      callMatches.length >= 2,
+      `saveStuckState must be called in both the custom-engine path and the standard dev path ` +
+      `(found ${callMatches.length} call(s) — standard path is missing its call, #4382)`,
+    );
+  });
 });

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

@@ -323,9 +323,9 @@ test('memory-store: schema includes memories table', () => {
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assert.deepStrictEqual(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 20 (memory Phase 4 relations included)
+  // Verify schema version is 22 (v22 quality_gates DDL fix included)
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.['v'], 20, 'schema version should be 20');
+  assert.deepStrictEqual(version?.["v"], 22, 'schema version should be 22');
 
   closeDatabase();
 });

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-status-authoritative.test.ts

@@ -75,7 +75,7 @@ test("getMilestoneStatus returns 'pending' for authoritative 'pending' even when
   assert.equal(getMilestoneStatus(milestone, {}), "pending");
 });
 
-test("getMilestoneStatus maps 'parked' to 'pending' item status", () => {
+test("getMilestoneStatus preserves authoritative 'parked' item status", () => {
   const milestone = makeMilestone({
     id: "M004",
     status: "parked",
@@ -83,8 +83,8 @@ test("getMilestoneStatus maps 'parked' to 'pending' item status", () => {
       { id: "S01", title: "Slice 1", done: true, tasks: [] },
     ],
   });
-  // Parked milestones should render as pending in the UI
-  assert.equal(getMilestoneStatus(milestone, {}), "pending");
+  // Parked milestones should retain a distinct parked status in the UI
+  assert.equal(getMilestoneStatus(milestone, {}), "parked");
 });
 
 test("getMilestoneStatus falls back to heuristic when no authoritative status", () => {

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/milestone-transition-state-rebuild.test.ts

@@ -85,8 +85,10 @@ test("auto.ts buildLoopDeps wires rebuildState", () => {
     "utf-8",
   );
 
-  // rebuildState should be in the LoopDeps object literal
-  const buildLoopDepsIdx = autoSrc.indexOf("function buildLoopDeps()");
+  // rebuildState should be in the LoopDeps object literal.
+  // Match the signature prefix so the test survives future param changes
+  // (e.g. the DECOUPLE-02 change from `()` to `(pi: ExtensionAPI)`).
+  const buildLoopDepsIdx = autoSrc.indexOf("function buildLoopDeps(");
   assert.ok(buildLoopDepsIdx > 0, "buildLoopDeps function should exist");
 
   const afterBuild = autoSrc.slice(buildLoopDepsIdx);

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"),