gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/milestone-merge-stash-restore.test.ts

@@ -0,0 +1,267 @@
+// GSD-2 + src/resources/extensions/gsd/tests/milestone-merge-stash-restore.test.ts
+// Regression: postflight stash pop must run even when mergeAndExit throws.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { _runMilestoneMergeWithStashRestore } from "../auto/phases.js";
+import type { IterationContext } from "../auto/types.js";
+import { MergeConflictError } from "../git-service.js";
+import type {
+  PostflightResult,
+  PreflightResult,
+} from "../clean-root-preflight.js";
+
+interface CallLog {
+  preflightCalls: number;
+  mergeCalls: number;
+  postflightCalls: number;
+  stopAutoCalls: Array<string | undefined>;
+  notifyCalls: Array<{ message: string; level: string }>;
+  milestoneMergedInPhases: boolean;
+}
+
+function buildIc(opts: {
+  preflightResult: PreflightResult;
+  mergeBehavior: "succeed" | (() => never);
+  postflightResult: PostflightResult;
+}): { ic: IterationContext; log: CallLog } {
+  const log: CallLog = {
+    preflightCalls: 0,
+    mergeCalls: 0,
+    postflightCalls: 0,
+    stopAutoCalls: [],
+    notifyCalls: [],
+    milestoneMergedInPhases: false,
+  };
+
+  const session = {
+    basePath: "/tmp/proj",
+    originalBasePath: "/tmp/proj",
+    get milestoneMergedInPhases() {
+      return log.milestoneMergedInPhases;
+    },
+    set milestoneMergedInPhases(v: boolean) {
+      log.milestoneMergedInPhases = v;
+    },
+  };
+
+  const ctx = {
+    ui: {
+      notify: (message: string, level: string) => {
+        log.notifyCalls.push({ message, level });
+      },
+    },
+  };
+
+  const deps = {
+    preflightCleanRoot: () => {
+      log.preflightCalls += 1;
+      return opts.preflightResult;
+    },
+    postflightPopStash: () => {
+      log.postflightCalls += 1;
+      return opts.postflightResult;
+    },
+    resolver: {
+      mergeAndExit: () => {
+        log.mergeCalls += 1;
+        if (opts.mergeBehavior !== "succeed") {
+          opts.mergeBehavior();
+        }
+      },
+    },
+    lifecycle: {
+      exitMilestone: (_mid: string, exitOpts: { merge: boolean }) => {
+        log.mergeCalls += 1;
+        if (opts.mergeBehavior === "succeed") {
+          return { ok: true, merged: exitOpts.merge, codeFilesChanged: false };
+        }
+        try {
+          opts.mergeBehavior();
+          return { ok: true, merged: exitOpts.merge, codeFilesChanged: false };
+        } catch (err) {
+          // Mirror Lifecycle's typed-result wrapping of MergeConflictError
+          // and other thrown values per worktree-lifecycle.exitMilestone.
+          const isMergeConflict =
+            err !== null &&
+            typeof err === "object" &&
+            err !== undefined &&
+            (err as { name?: string }).name === "MergeConflictError";
+          return {
+            ok: false,
+            reason: isMergeConflict ? "merge-conflict" : "teardown-failed",
+            cause: err,
+          } as const;
+        }
+      },
+    },
+    stopAuto: async (_c?: unknown, _p?: unknown, reason?: string) => {
+      log.stopAutoCalls.push(reason);
+    },
+  };
+
+  const ic = {
+    ctx,
+    pi: {},
+    s: session,
+    deps,
+  } as unknown as IterationContext;
+
+  return { ic, log };
+}
+
+const STASH_PUSHED: PreflightResult = {
+  stashPushed: true,
+  stashMarker: "gsd-preflight-stash:M002:42:1700000000000:abc",
+  summary: "Stashed uncommitted changes before merge (milestone M002).",
+};
+
+const STASH_NOT_PUSHED: PreflightResult = {
+  stashPushed: false,
+  summary: "",
+};
+
+const POP_OK: PostflightResult = {
+  restored: true,
+  needsManualRecovery: false,
+  message: "Restored stashed changes after milestone M002 merge.",
+  stashRef: "stash@{0}",
+};
+
+const POP_NEEDS_RECOVERY: PostflightResult = {
+  restored: false,
+  needsManualRecovery: true,
+  message: "git stash pop stash@{0} failed: conflict in lib/models.ts",
+};
+
+test("happy path: merge succeeds and stash is popped", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: STASH_PUSHED,
+    mergeBehavior: "succeed",
+    postflightResult: POP_OK,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.equal(result, null, "happy path returns null (loop continues)");
+  assert.equal(log.preflightCalls, 1);
+  assert.equal(log.mergeCalls, 1);
+  assert.equal(log.postflightCalls, 1, "postflight pop must run on success");
+  assert.equal(log.stopAutoCalls.length, 0, "no stopAuto on happy path");
+  assert.equal(log.milestoneMergedInPhases, true, "merge flag set");
+});
+
+test("regression #5538-followup: postflight pop runs even when mergeAndExit throws non-conflict error", async () => {
+  // The original bug: when mergeAndExit threw, the catch block called
+  // stopAuto + return break BEFORE postflight pop ran. The user's
+  // gsd-preflight-stash:M00x stash was orphaned. This test exercises that
+  // exact scenario and asserts the pop is now invoked.
+  const { ic, log } = buildIc({
+    preflightResult: STASH_PUSHED,
+    mergeBehavior: () => {
+      throw new Error("native git merge failed: index lock present");
+    },
+    postflightResult: POP_OK,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.deepEqual(result, { action: "break", reason: "merge-failed" });
+  assert.equal(log.mergeCalls, 1);
+  assert.equal(
+    log.postflightCalls,
+    1,
+    "postflight pop must run even on merge failure (was the bug)",
+  );
+  assert.equal(log.stopAutoCalls.length, 1);
+  assert.match(log.stopAutoCalls[0] ?? "", /Merge error on milestone M002/);
+  assert.equal(
+    log.milestoneMergedInPhases,
+    false,
+    "merge flag must NOT be set when merge throws",
+  );
+});
+
+test("regression #5538-followup: postflight pop runs even when mergeAndExit throws MergeConflictError", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: STASH_PUSHED,
+    mergeBehavior: () => {
+      throw new MergeConflictError(
+        ["lib/models.ts", "app/page.tsx"],
+        "squash",
+        "milestone/M002",
+        "main",
+      );
+    },
+    postflightResult: POP_OK,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.deepEqual(result, { action: "break", reason: "merge-conflict" });
+  assert.equal(log.mergeCalls, 1);
+  assert.equal(
+    log.postflightCalls,
+    1,
+    "postflight pop must run on merge conflict (was the bug)",
+  );
+  assert.equal(log.stopAutoCalls.length, 1);
+  assert.match(log.stopAutoCalls[0] ?? "", /Merge conflict on milestone M002/);
+});
+
+test("clean tree: no stash to pop, merge succeeds, no pop attempted", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: STASH_NOT_PUSHED,
+    mergeBehavior: "succeed",
+    postflightResult: POP_OK,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.equal(result, null);
+  assert.equal(log.postflightCalls, 0, "no pop when nothing was stashed");
+  assert.equal(log.milestoneMergedInPhases, true);
+});
+
+test("merge succeeds but stash pop needs manual recovery -> postflight-stash-restore-failed break", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: STASH_PUSHED,
+    mergeBehavior: "succeed",
+    postflightResult: POP_NEEDS_RECOVERY,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.deepEqual(result, {
+    action: "break",
+    reason: "postflight-stash-restore-failed",
+  });
+  assert.equal(log.postflightCalls, 1);
+  assert.equal(log.stopAutoCalls.length, 1);
+  assert.match(
+    log.stopAutoCalls[0] ?? "",
+    /Post-merge stash restore failed for milestone M002/,
+  );
+});
+
+test("merge error is reported even when stash pop also failed (merge-error takes priority)", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: STASH_PUSHED,
+    mergeBehavior: () => {
+      throw new Error("network unreachable during push");
+    },
+    postflightResult: POP_NEEDS_RECOVERY,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.deepEqual(result, { action: "break", reason: "merge-failed" });
+  assert.equal(log.postflightCalls, 1, "postflight pop still attempted");
+  assert.equal(log.stopAutoCalls.length, 1, "stopAuto called once, not twice");
+  assert.match(
+    log.stopAutoCalls[0] ?? "",
+    /Merge error/,
+    "stopAuto message reflects merge error, not stash failure",
+  );
+});

package/src/resources/extensions/gsd/tests/milestone-transition-state-rebuild.test.ts

@@ -11,99 +11,15 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync, realpathSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
+import { AutoSession } from "../auto/session.ts";
+import { runPreDispatch } from "../auto/phases.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// ─── Source-level checks ──────────────────────────────────────────────────────
-
-test("auto/phases.ts milestone transition block calls rebuildState", () => {
-  const phasesSrc = readFileSync(
-    join(__dirname, "..", "auto", "phases.ts"),
-    "utf-8",
-  );
-
-  // rebuildState must be called within the milestone transition block
-  assert.ok(
-    phasesSrc.includes("deps.rebuildState(s.basePath)"),
-    "auto/phases.ts should call deps.rebuildState(s.basePath) during milestone transition",
-  );
-
-  // The rebuildState call must appear AFTER the pruneQueueOrder call
-  // (i.e. after all transition cleanup is done)
-  const pruneIdx = phasesSrc.indexOf("deps.pruneQueueOrder(s.basePath, pendingIds)");
-  const rebuildIdx = phasesSrc.indexOf("deps.rebuildState(s.basePath)");
-  assert.ok(pruneIdx > 0, "pruneQueueOrder should exist in phases.ts");
-  assert.ok(rebuildIdx > 0, "rebuildState should exist in phases.ts");
-  assert.ok(
-    rebuildIdx > pruneIdx,
-    "rebuildState should be called after pruneQueueOrder in the milestone transition block",
-  );
-});
-
-test("auto/phases.ts milestone transition block resets completed-units.json", () => {
-  const phasesSrc = readFileSync(
-    join(__dirname, "..", "auto", "phases.ts"),
-    "utf-8",
-  );
-
-  // completed-units.json must be archived and cleared during milestone transition
-  const transitionStart = phasesSrc.indexOf("Milestone transition");
-  assert.ok(transitionStart > 0, "Milestone transition block should exist");
-
-  // The old file is archived before being cleared (#2313)
-  const archiveSection = phasesSrc.indexOf("completed-units-", transitionStart);
-  assert.ok(
-    archiveSection > 0,
-    "auto/phases.ts should archive completed-units.json during milestone transition",
-  );
-
-  // The disk file should be cleared to an empty array
-  assert.ok(
-    phasesSrc.includes('atomicWriteSync(completedKeysPath, JSON.stringify([], null, 2))'),
-    "auto/phases.ts should write empty array to completed-units.json during milestone transition",
-  );
-});
-
-test("auto/loop-deps.ts LoopDeps interface includes rebuildState", () => {
-  const loopDepsSrc = readFileSync(
-    join(__dirname, "..", "auto", "loop-deps.ts"),
-    "utf-8",
-  );
-
-  assert.ok(
-    loopDepsSrc.includes("rebuildState: (basePath: string) => Promise<void>"),
-    "LoopDeps interface should declare rebuildState method",
-  );
-});
-
-test("auto.ts buildLoopDeps wires rebuildState", () => {
-  const autoSrc = readFileSync(
-    join(__dirname, "..", "auto.ts"),
-    "utf-8",
-  );
-
-  // 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);
-  assert.ok(
-    afterBuild.includes("rebuildState,") || afterBuild.includes("rebuildState:"),
-    "buildLoopDeps should include rebuildState in the returned deps object",
-  );
-});
-
-// ─── Functional test: completed-units.json reset ─────────────────────────────
-
-test("completed-units.json is cleared on milestone transition (functional)", () => {
+test("milestone transition archives completed units and rebuilds state", async () => {
   const tempDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-cu-reset-")));
+  const calls: string[] = [];
   try {
-    // Create .gsd directory with a populated completed-units.json
     const gsdDir = join(tempDir, ".gsd");
     mkdirSync(gsdDir, { recursive: true });
 
@@ -116,16 +32,90 @@ test("completed-units.json is cleared on milestone transition (functional)", ()
     ];
     writeFileSync(completedKeysPath, JSON.stringify(staleEntries, null, 2));
 
-    // Verify stale entries exist
-    const before = JSON.parse(readFileSync(completedKeysPath, "utf-8"));
-    assert.equal(before.length, 4, "Should have 4 stale entries before reset");
-
-    // Simulate what phases.ts does: write empty array
-    writeFileSync(completedKeysPath, JSON.stringify([], null, 2));
-
-    // Verify reset
+    const s = new AutoSession();
+    s.basePath = tempDir;
+    s.originalBasePath = tempDir;
+    s.currentMilestoneId = "M001";
+    s.unitDispatchCount.set("old", 1);
+    s.unitRecoveryCount.set("old", 1);
+    s.unitLifetimeDispatches.set("old", 1);
+
+    const state = {
+      phase: "planning",
+      activeMilestone: { id: "M002", title: "Next" },
+      activeSlice: null,
+      activeTask: null,
+      recentDecisions: [],
+      blockers: [],
+      nextAction: "Plan M002",
+      registry: [
+        { id: "M001", title: "Done", status: "complete" },
+        { id: "M002", title: "Next", status: "active" },
+      ],
+    };
+
+    const result = await runPreDispatch({
+      ctx: { ui: { notify() {} } },
+      pi: {},
+      s,
+      prefs: undefined,
+      iteration: 1,
+      flowId: "test-flow",
+      nextSeq: () => 1,
+      deps: {
+        checkResourcesStale: () => null,
+        invalidateAllCaches: () => calls.push("invalidate"),
+        preDispatchHealthGate: async () => ({ proceed: true, fixesApplied: [] }),
+        syncProjectRootToWorktree: () => {},
+        deriveState: async () => state,
+        syncCmuxSidebar: () => {},
+        preflightCleanRoot: () => ({ ok: true, stashPushed: false }),
+        postflightPopStash: () => ({ ok: true, needsManualRecovery: false }),
+        resolver: {
+          mergeAndExit: () => calls.push("merge"),
+        },
+        lifecycle: {
+          enterMilestone: (mid: string) => {
+            calls.push(`enter:${mid}`);
+            return { ok: true, mode: "worktree", path: `/wt/${mid}` };
+          },
+          exitMilestone: (mid: string, opts: { merge: boolean }) => {
+            calls.push(opts.merge ? `merge:${mid}` : `exit:${mid}`);
+            return { ok: true, merged: opts.merge, codeFilesChanged: false };
+          },
+        },
+        sendDesktopNotification: () => {},
+        logCmuxEvent: () => {},
+        getIsolationMode: () => "none",
+        captureIntegrationBranch: () => {},
+        pruneQueueOrder: (_base: string, pending: string[]) => calls.push(`prune:${pending.join(",")}`),
+        rebuildState: async () => calls.push("rebuild"),
+        setActiveMilestoneId: (_base: string, mid: string) => calls.push(`active:${mid}`),
+        reconcileMergeState: () => "clean",
+        emitJournalEvent: () => {},
+        stopAuto: async () => {},
+        pauseAuto: async () => {},
+        closeoutUnit: async () => {},
+        buildSnapshotOpts: () => ({}),
+      },
+    } as any, {
+      recentUnits: [{ key: "stale" }],
+      stuckRecoveryAttempts: 2,
+      consecutiveFinalizeTimeouts: 0,
+    });
+
+    assert.equal(result.action, "next");
+    assert.equal(s.currentMilestoneId, "M002");
+    assert.equal(s.unitDispatchCount.size, 0);
+    assert.equal(s.unitRecoveryCount.size, 0);
+    assert.equal(s.unitLifetimeDispatches.size, 0);
+    assert.ok(existsSync(join(gsdDir, "completed-units-M001.json")));
     const after = JSON.parse(readFileSync(completedKeysPath, "utf-8"));
-    assert.deepEqual(after, [], "completed-units.json should be empty after milestone transition");
+    assert.deepEqual(after, []);
+    assert.ok(
+      calls.indexOf("prune:M002") < calls.indexOf("rebuild"),
+      `expected prune before rebuild, got ${calls.join(" > ")}`,
+    );
   } finally {
     rmSync(tempDir, { recursive: true, force: true });
   }

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Verifies model routing decisions and legacy provider-default telemetry.
 import test, { describe } from "node:test";
 import assert from "node:assert/strict";
 
@@ -14,6 +16,7 @@ import {
 } from "../model-router.js";
 import type { DynamicRoutingConfig, RoutingDecision, ModelCapabilities } from "../model-router.js";
 import type { ClassificationResult } from "../complexity-classifier.js";
+import { getLegacyTelemetry, resetLegacyTelemetry } from "../legacy-telemetry.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -297,16 +300,28 @@ test("cross-provider: configured primary available by bare ID wins over equivale
 // ─── resolveModelForTier (provider-agnostic tier resolution) ────────────────
 
 test("resolveModelForTier: returns canonical Anthropic model when no available models", () => {
-  assert.equal(resolveModelForTier("heavy", []), "claude-opus-4-6");
-  assert.equal(resolveModelForTier("standard", []), "claude-sonnet-4-6");
-  assert.equal(resolveModelForTier("light", []), "claude-haiku-4-5");
+  try {
+    resetLegacyTelemetry();
+    assert.equal(resolveModelForTier("heavy", []), "claude-opus-4-6");
+    assert.equal(resolveModelForTier("standard", []), "claude-sonnet-4-6");
+    assert.equal(resolveModelForTier("light", []), "claude-haiku-4-5");
+    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 3);
+  } finally {
+    resetLegacyTelemetry();
+  }
 });
 
 test("resolveModelForTier: returns canonical model when it is available", () => {
-  assert.equal(
-    resolveModelForTier("heavy", ["claude-opus-4-6", "claude-sonnet-4-6"]),
-    "claude-opus-4-6",
-  );
+  try {
+    resetLegacyTelemetry();
+    assert.equal(
+      resolveModelForTier("heavy", ["claude-opus-4-6", "claude-sonnet-4-6"]),
+      "claude-opus-4-6",
+    );
+    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 0);
+  } finally {
+    resetLegacyTelemetry();
+  }
 });
 
 test("resolveModelForTier: does not prefer canonical over cheaper same-tier model", () => {
@@ -341,11 +356,17 @@ test("resolveModelForTier: picks light-tier cross-provider model", () => {
 });
 
 test("resolveModelForTier: falls back to canonical when no tier match available", () => {
-  // Only unknown models available — getModelTier classifies unknowns as
-  // "standard", so a request for "heavy" finds no match and the canonical
-  // Anthropic ID is returned as a documented fallback.
-  const result = resolveModelForTier("heavy", ["some-custom-model"]);
-  assert.equal(result, "claude-opus-4-6");
+  try {
+    resetLegacyTelemetry();
+    // Only unknown models available — getModelTier classifies unknowns as
+    // "standard", so a request for "heavy" finds no match and the canonical
+    // Anthropic ID is returned as a documented fallback.
+    const result = resolveModelForTier("heavy", ["some-custom-model"]);
+    assert.equal(result, "claude-opus-4-6");
+    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 1);
+  } finally {
+    resetLegacyTelemetry();
+  }
 });
 
 test("resolveModelForTier: handles provider-prefixed available models", () => {