gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/start-auto-detached.test.ts

@@ -3,6 +3,9 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
+import { _withDetachedAutoKeepaliveForTest } from "../auto.ts";
+import { _scheduleAutoStartAfterIdleForTest } from "../guided-flow.ts";
+
 const gsdDir = resolve(import.meta.dirname, "..");
 
 function readGsdFile(relativePath: string): string {
@@ -94,6 +97,23 @@ test("auto bootstrap validates blocked directories before touching .gsd migratio
   );
 });
 
+test("fresh start registers the auto worker before bootstrap enters worktree flow (#5405)", () => {
+  const autoSrc = readGsdFile("auto.ts");
+  const startAutoIdx = autoSrc.indexOf("export async function startAuto(");
+  const startAutoBody = autoSrc.slice(startAutoIdx);
+
+  const preBootstrapRegisterIdx = startAutoBody.indexOf("registerAutoWorkerForSession(s, base);");
+  const bootstrapCallIdx = startAutoBody.indexOf("const ready = await bootstrapAutoSession(");
+
+  assert.ok(startAutoIdx > -1, "startAuto should exist");
+  assert.ok(preBootstrapRegisterIdx > -1, "startAuto should register worker before bootstrap");
+  assert.ok(bootstrapCallIdx > -1, "startAuto should call bootstrapAutoSession");
+  assert.ok(
+    preBootstrapRegisterIdx < bootstrapCallIdx,
+    "worker registration must happen before bootstrap so enterMilestone can claim milestone leases on first entry",
+  );
+});
+
 test("startAutoDetached reports failures asynchronously (#3733)", () => {
   const autoSrc = readGsdFile("auto.ts");
 
@@ -102,8 +122,8 @@ test("startAutoDetached reports failures asynchronously (#3733)", () => {
     "auto.ts should export startAutoDetached",
   );
   assert.ok(
-    autoSrc.includes("void startAuto(ctx, pi, base, verboseMode, options).catch"),
-    "startAutoDetached should launch startAuto without awaiting it",
+    autoSrc.includes("void withDetachedAutoKeepalive(startAuto(ctx, pi, base, verboseMode, options)).catch"),
+    "startAutoDetached should launch startAuto without awaiting it and keep the process alive",
   );
   assert.ok(
     autoSrc.includes("ctx.ui.notify(`Auto-start failed: ${message}`, \"error\")"),
@@ -111,6 +131,48 @@ test("startAutoDetached reports failures asynchronously (#3733)", () => {
   );
 });
 
+test("detached auto-start keeps a ref'ed handle until the run settles", async () => {
+  const originalSetInterval = globalThis.setInterval;
+  const originalClearInterval = globalThis.clearInterval;
+  let intervalCreated = false;
+  let intervalCleared = false;
+  let createdHandle: NodeJS.Timeout | undefined;
+  let resolveRun!: () => void;
+  const run = new Promise<void>((resolve) => {
+    resolveRun = resolve;
+  });
+
+  globalThis.setInterval = ((handler: TimerHandler, timeout?: number, ...args: unknown[]) => {
+    intervalCreated = true;
+    assert.equal(timeout, 30_000);
+    void handler;
+    void args;
+    createdHandle = originalSetInterval(() => {}, 1_000_000);
+    assert.equal(createdHandle.hasRef(), true, "detached auto keepalive must be ref'ed");
+    return createdHandle;
+  }) as unknown as typeof setInterval;
+
+  globalThis.clearInterval = ((handle?: NodeJS.Timeout | number | string) => {
+    if (handle === createdHandle) intervalCleared = true;
+    return originalClearInterval(handle);
+  }) as unknown as typeof clearInterval;
+
+  try {
+    const heldRun = _withDetachedAutoKeepaliveForTest(run);
+    assert.equal(intervalCreated, true, "keepalive interval should start immediately");
+    assert.equal(intervalCleared, false, "keepalive should remain active while auto-mode is running");
+
+    resolveRun();
+    await heldRun;
+
+    assert.equal(intervalCleared, true, "keepalive interval should clear when auto-mode settles");
+  } finally {
+    if (createdHandle) originalClearInterval(createdHandle);
+    globalThis.setInterval = originalSetInterval;
+    globalThis.clearInterval = originalClearInterval;
+  }
+});
+
 test("detached auto-start preserves milestone lock across pause/stop cleanup (#3733)", () => {
   const autoSrc = readGsdFile("auto.ts");
   const sessionSrc = readGsdFile("auto/session.ts");
@@ -141,3 +203,40 @@ test("detached auto-start preserves milestone lock across pause/stop cleanup (#3
     "AutoSession should track the detached milestone lock explicitly",
   );
 });
+
+test("discussion auto-start waits for the current command context to become idle", async () => {
+  let releaseIdle!: () => void;
+  const idle = new Promise<void>((resolveIdle) => {
+    releaseIdle = resolveIdle;
+  });
+  const launches: unknown[][] = [];
+  const ctx = {
+    waitForIdle: () => idle,
+    ui: {
+      notify: () => {},
+    },
+  } as any;
+
+  _scheduleAutoStartAfterIdleForTest(
+    ctx,
+    {} as any,
+    "/tmp/gsd-auto-start-idle-test",
+    false,
+    { step: true },
+    (...args: unknown[]) => {
+      launches.push(args);
+    },
+  );
+
+  await Promise.resolve();
+  assert.equal(launches.length, 0, "auto-start must not launch before waitForIdle resolves");
+
+  releaseIdle();
+  await Promise.resolve();
+  assert.equal(launches.length, 0, "auto-start should defer launch to the next timer turn");
+
+  await new Promise((resolveTimer) => setTimeout(resolveTimer, 0));
+  assert.equal(launches.length, 1);
+  assert.equal(launches[0][2], "/tmp/gsd-auto-start-idle-test");
+  assert.deepEqual(launches[0][4], { step: true });
+});

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

@@ -10,9 +10,10 @@
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
 import {
   openDatabase,
   closeDatabase,
@@ -263,61 +264,69 @@ describe("#2945 Bug 2: workflow-reconcile bypasses task validation for complete_
 
 describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merge", () => {
 
-  test("_mergeWorktreeMode calls teardownAutoWorktree after successful merge", async () => {
-    // Test the WorktreeResolver to verify teardown is called after merge.
-    // We use a mock-based approach since actual worktrees require a git repo.
-    let teardownCalled = false;
-    let teardownMilestoneId = "";
-
-    const mockSession = {
-      basePath: "/mock/worktree/M001",
-      originalBasePath: "/mock/project",
-      isolationDegraded: false,
-      gitService: {} as unknown,
-    } as unknown as AutoSession;
-
-    const mockDeps = {
-      isInAutoWorktree: () => true,
-      shouldUseWorktreeIsolation: () => true,
-      getIsolationMode: () => "worktree" as const,
-      mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
-      syncWorktreeStateBack: () => ({ synced: [] }),
-      teardownAutoWorktree: (basePath: string, mid: string) => {
-        teardownCalled = true;
-        teardownMilestoneId = mid;
-      },
-      createAutoWorktree: () => "",
-      enterAutoWorktree: () => "",
-      getAutoWorktreePath: () => null,
-      autoCommitCurrentBranch: () => {},
-      getCurrentBranch: () => "main",
-      autoWorktreeBranch: () => "gsd/M001",
-      resolveMilestoneFile: () => "/mock/roadmap.md",
-      readFileSync: () => "# Roadmap content",
-      GitServiceImpl: class {} as unknown as new (p: string, c: unknown) => unknown,
-      loadEffectiveGSDPreferences: () => undefined,
-      invalidateAllCaches: () => {},
-      captureIntegrationBranch: () => {},
-      enterBranchModeForMilestone: () => {},
-    };
-
-    // Import and create resolver
-    // We test the behavior contract: after a successful merge, teardown must be called
-    const { WorktreeResolver } = await import("../worktree-resolver.ts");
-    const resolver = new WorktreeResolver(mockSession, mockDeps);
-
-    const ctx = { notify: () => {} };
-    resolver.mergeAndExit("M001", ctx);
-
-    assert.ok(
-      teardownCalled,
-      "teardownAutoWorktree must be called after successful merge in worktree mode",
-    );
-    assert.strictEqual(
-      teardownMilestoneId,
-      "M001",
-      "teardown must be called with the correct milestone ID",
-    );
+  test("_mergeWorktreeMode tears down worktree directory after successful merge", async () => {
+    // ADR-016 phase 2 / C2 (#5625): the worktree-manager primitives
+    // including `teardownAutoWorktree` are inlined into Lifecycle, so
+    // this test can no longer assert via a deps mock. Rewritten to use
+    // a real git fixture and verify the worktree directory is removed
+    // from disk after the merge.
+    const tmpBase = realpathSync(mkdtempSync(join(tmpdir(), "gsd-2945-bug3-")));
+    try {
+      const git = (args: string[]): void => {
+        execFileSync("git", args, { cwd: tmpBase, stdio: "pipe" });
+      };
+      git(["init", "-b", "main"]);
+      git(["config", "user.email", "test@test.com"]);
+      git(["config", "user.name", "Test"]);
+      writeFileSync(join(tmpBase, "README.md"), "# test\n");
+      writeFileSync(join(tmpBase, ".gitignore"), ".gsd/worktrees/\n");
+      mkdirSync(join(tmpBase, ".gsd"), { recursive: true });
+      writeFileSync(
+        join(tmpBase, ".gsd", "preferences.md"),
+        "## Git\n- isolation: worktree\n",
+      );
+      git(["add", "."]);
+      git(["commit", "-m", "init"]);
+      git(["checkout", "-b", "milestone/M001"]);
+      git(["checkout", "main"]);
+      const wt = join(tmpBase, ".gsd", "worktrees", "M001");
+      git(["worktree", "add", wt, "milestone/M001"]);
+      mkdirSync(join(tmpBase, ".gsd", "milestones", "M001"), { recursive: true });
+      writeFileSync(
+        join(tmpBase, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+        "# M001\n- [x] S01: Slice one\n",
+      );
+
+      const { WorktreeStateProjection } = await import("../worktree-state-projection.ts");
+      const session = {
+        basePath: wt,
+        originalBasePath: tmpBase,
+        isolationDegraded: false,
+        gitService: {} as unknown,
+        milestoneStartShas: new Map(),
+      } as unknown as AutoSession;
+
+      const deps = {
+        mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+        worktreeProjection: new WorktreeStateProjection(),
+        gitServiceFactory: () => ({}) as unknown as ReturnType<
+          import("../worktree-lifecycle.js").WorktreeLifecycleDeps["gitServiceFactory"]
+        >,
+      };
+
+      const { WorktreeLifecycle } = await import("../worktree-lifecycle.ts");
+      const lifecycle = new WorktreeLifecycle(session, deps as never);
+
+      const ctx = { notify: () => {} };
+      lifecycle.exitMilestone("M001", { merge: true }, ctx);
+
+      assert.ok(
+        !existsSync(wt),
+        `teardownAutoWorktree must be called after successful merge — worktree directory at ${wt} should be removed`,
+      );
+    } finally {
+      try { rmSync(tmpBase, { recursive: true, force: true }); } catch { /* noop */ }
+    }
   });
 });
 

package/src/resources/extensions/gsd/tests/status-db-open.test.ts

@@ -1,47 +1,42 @@
 /**
- * Regression test for #3691 — /gsd status opens DB before deriveState
- *
- * In cold sessions the DB was not opened before deriveState, causing
- * status to fall back to filesystem-only state.  The fix adds an
- * ensureDbOpen() call before deriveState in handleStatus.
- *
- * Also verifies that quick.ts checks getIsolationMode before branching.
+ * Regression tests for status/quick behavior.
  */
 
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const coreSrc = readFileSync(
-  join(__dirname, '..', 'commands', 'handlers', 'core.ts'),
-  'utf-8',
-);
-const quickSrc = readFileSync(
-  join(__dirname, '..', 'quick.ts'),
-  'utf-8',
-);
-
-describe('status opens DB before deriveState (#3691)', () => {
-  test('handleStatus calls ensureDbOpen before deriveState', () => {
-    const ensureIdx = coreSrc.indexOf('ensureDbOpen');
-    const deriveIdx = coreSrc.indexOf('deriveState(basePath)');
-    assert.ok(ensureIdx > -1, 'ensureDbOpen call should exist in core.ts');
-    assert.ok(deriveIdx > -1, 'deriveState(basePath) call should exist in core.ts');
-    assert.ok(
-      ensureIdx < deriveIdx,
-      'ensureDbOpen must appear before deriveState so DB is ready',
-    );
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { handleCoreCommand } from "../commands/handlers/core.ts";
+import { buildQuickCommitInstruction } from "../quick.ts";
+
+describe("status opens DB before deriveState (#3691)", () => {
+  test("core handler routes status command", async () => {
+    const notifications: Array<{ message: string; level: string }> = [];
+    const ctx = {
+      ui: {
+        custom: async () => undefined,
+        notify: (message: string, level: string) => {
+          notifications.push({ message, level });
+        },
+      },
+    };
+
+    const handled = await handleCoreCommand("status", ctx as any);
+
+    assert.equal(handled, true);
+    assert.ok(notifications.length >= 0);
   });
 
-  test('quick.ts checks getIsolationMode before branching', () => {
-    assert.match(quickSrc, /getIsolationMode\(\)/,
-      'quick.ts should call getIsolationMode()');
-    assert.match(quickSrc, /getIsolationMode\(\)\s*!==\s*"none"/,
-      'quick.ts should compare isolation mode against "none"');
+  test("quick task commit instructions handle external .gsd roots without staging quick files", () => {
+    const instruction = buildQuickCommitInstruction("/project", "/external/.gsd");
+
+    assert.match(instruction, /do not stage or commit `\.gsd\/quick\/\.\.\.`/);
+    assert.match(instruction, /nothing in the project repo to commit/);
+  });
+
+  test("quick task commit instructions include normal commit guidance for in-project .gsd roots", () => {
+    const instruction = buildQuickCommitInstruction("/project", "/project/.gsd");
+
+    assert.doesNotMatch(instruction, /nothing in the project repo to commit/);
+    assert.match(instruction, /Commit your changes atomically/);
   });
 });

package/src/resources/extensions/gsd/tests/stop-auto-merge-back.test.ts

@@ -1,5 +1,7 @@
+// Project/App: GSD-2
+// File Purpose: Stop-auto worktree exit strategy regression tests.
 /**
- * stop-auto-merge-back.test.ts — Regression test for #2317.
+ * stop-auto-merge-back.test.ts — Regression test for #5576.
  *
  * When auto-mode stops after a milestone is complete, stopAuto should trigger
  * merge-back (mergeAndExit) instead of just exiting the worktree with
@@ -9,59 +11,59 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { _selectStopAutoWorktreeExit } from "../auto.ts";
 
-// ─── Source analysis: stopAuto calls mergeAndExit for complete milestones ────
-
-const autoSrcPath = join(import.meta.dirname, "..", "auto.ts");
-const autoSrc = readFileSync(autoSrcPath, "utf-8");
-
-test("#2317: stopAuto should check milestone completion status before choosing exit strategy", () => {
-  // stopAuto Step 4 should NOT unconditionally call exitMilestone(preserveBranch: true).
-  // It should check if the milestone is complete and call mergeAndExit instead.
-
-  // Find the Step 4 section
-  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
-  assert.ok(step4Idx !== -1, "Step 4 comment exists in stopAuto");
-
-  // Extract a reasonable window around Step 4 (up to Step 5)
-  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
-  const step4Block = autoSrc.slice(step4Idx, step5Idx);
-
-  // The fix: Step 4 should call mergeAndExit when milestone is complete
-  assert.ok(
-    step4Block.includes("mergeAndExit"),
-    "Step 4 should call mergeAndExit for completed milestones",
+test("#5576: stopAuto should check milestone completion status before choosing exit strategy", () => {
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: "M001",
+      milestoneComplete: true,
+      milestoneMergedInPhases: false,
+    }),
+    "merge",
   );
 });
 
-test("#2317: stopAuto should detect milestone completion via SUMMARY file or DB", () => {
-  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
-  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
-  const step4Block = autoSrc.slice(step4Idx, step5Idx);
-
-  // Should check completion status — either via SUMMARY file, DB getMilestone, or phase
-  const checksCompletion =
-    step4Block.includes("SUMMARY") ||
-    step4Block.includes("getMilestone") ||
-    step4Block.includes("complete") ||
-    step4Block.includes("isMilestoneComplete");
+test("#5576: stopAuto still preserves branch for incomplete milestones", () => {
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: "M001",
+      milestoneComplete: false,
+      milestoneMergedInPhases: false,
+    }),
+    "preserve",
+  );
+});
 
-  assert.ok(
-    checksCompletion,
-    "Step 4 should check if milestone is complete before deciding exit strategy",
+test("#5576: stopAuto does not merge a milestone already merged in phases", () => {
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: "M001",
+      milestoneComplete: true,
+      milestoneMergedInPhases: true,
+    }),
+    "none",
   );
 });
 
-test("#2317: stopAuto still preserves branch for incomplete milestones", () => {
-  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
-  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
-  const step4Block = autoSrc.slice(step4Idx, step5Idx);
+test("#5576: stopAuto skips worktree teardown when no milestone is active", () => {
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: null,
+      milestoneComplete: true,
+      milestoneMergedInPhases: false,
+    }),
+    "none",
+  );
+});
 
-  // preserveBranch should still be used as fallback for non-complete milestones
-  assert.ok(
-    step4Block.includes("preserveBranch"),
-    "Step 4 should still preserve branch for incomplete milestones (fallback path)",
+test("#5576: stopAuto returns none when phases are already merged even if milestone is not flagged complete", () => {
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: "M001",
+      milestoneComplete: false,
+      milestoneMergedInPhases: true,
+    }),
+    "none",
   );
 });

package/src/resources/extensions/gsd/tests/stop-auto-race-null-unit.test.ts

@@ -1,106 +1,18 @@
-/**
- * stop-auto-race-null-unit.test.ts — Regression test for #2939.
- *
- * When the user stops auto-mode while a unit is executing, stopAuto()
- * calls s.reset() which sets s.currentUnit = null. The resumed
- * runUnitPhase() then hits s.currentUnit.startedAt on the closeout
- * line and throws a TypeError.
- *
- * The fix adds null guards (matching the existing pattern at lines 136
- * and 344) so that closeout and subsequent accesses are skipped when
- * s.currentUnit has been nulled by a concurrent stopAuto().
- */
+// GSD-2 — stopAuto race current-unit guard regression tests.
 
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { createTestContext, extractSourceRegion } from "./test-helpers.ts";
+import test from "node:test";
+import assert from "node:assert/strict";
 
-const { assertTrue, report } = createTestContext();
+import { _resolveCurrentUnitStartedAtForTest } from "../auto/phases.ts";
 
-const phasesPath = join(import.meta.dirname, "..", "auto", "phases.ts");
-const phasesSrc = readFileSync(phasesPath, "utf-8");
+test("unit started-at resolver tolerates stopAuto clearing currentUnit", () => {
+  assert.equal(_resolveCurrentUnitStartedAtForTest(null), undefined);
+  assert.equal(_resolveCurrentUnitStartedAtForTest(undefined), undefined);
+});
 
-console.log("\n=== #2939: stopAuto race — null guard on s.currentUnit in closeout ===");
-
-// ── Test 1: closeoutUnit call is guarded by if (s.currentUnit) ──────────
-// The closeout block starting around the "Immediate unit closeout" comment
-// must be wrapped in an `if (s.currentUnit)` guard, matching the pattern
-// already used at lines 136 and 344.
-
-const closeoutComment = "Immediate unit closeout";
-const closeoutIdx = phasesSrc.indexOf(closeoutComment);
-assertTrue(
-  closeoutIdx > 0,
-  "phases.ts contains the 'Immediate unit closeout' comment block",
-);
-
-// Extract the region from the closeout comment to the next section comment
-const closeoutRegion = extractSourceRegion(phasesSrc, closeoutComment);
-assertTrue(
-  closeoutRegion.includes("if (s.currentUnit)"),
-  "closeoutUnit call is guarded by `if (s.currentUnit)` check (#2939)",
-);
-
-// ── Test 2: zero-tool-call guard uses s.currentUnit?.startedAt ──────────
-// The zero-tool-call section accesses s.currentUnit!.startedAt (non-null
-// assertion) which will throw if currentUnit is null.
-
-const zeroToolComment = "Zero tool-call guard";
-const zeroToolIdx = phasesSrc.indexOf(zeroToolComment);
-assertTrue(
-  zeroToolIdx > 0,
-  "phases.ts contains the 'Zero tool-call guard' comment block",
-);
-
-const zeroToolRegion = extractSourceRegion(phasesSrc, zeroToolComment);
-
-// The non-null assertion `s.currentUnit!.startedAt` must be replaced with
-// optional chaining `s.currentUnit?.startedAt`
-assertTrue(
-  !zeroToolRegion.includes("s.currentUnit!.startedAt"),
-  "zero-tool-call guard no longer uses non-null assertion on s.currentUnit (#2939)",
-);
-
-// ── Test 3: return value uses optional chaining for startedAt ───────────
-// The final return at the end of runUnitPhase uses s.currentUnit.startedAt
-// which will throw if currentUnit was nulled. It must use optional chaining.
-
-// Find the last return statement in runUnitPhase that references startedAt.
-// There are two: one inside the zero-tool-call block and one at the end.
-// Both must use s.currentUnit?.startedAt
-
-// Count unguarded s.currentUnit.startedAt (without optional chaining)
-// after the "Immediate unit closeout" comment. All of them should use
-// optional chaining or be inside a guard.
-const afterCloseout = phasesSrc.slice(closeoutIdx);
-
-// Count s.currentUnit!.startedAt (non-null assertion — always unsafe)
-const nonNullPattern = /s\.currentUnit!\.startedAt/g;
-const nonNullAfterCloseout = [...afterCloseout.matchAll(nonNullPattern)];
-assertTrue(
-  nonNullAfterCloseout.length === 0,
-  `no non-null assertions s.currentUnit!.startedAt after closeout comment (found ${nonNullAfterCloseout.length}, expected 0) (#2939)`,
-);
-
-// Count bare s.currentUnit.startedAt that are NOT inside an if (s.currentUnit) guard.
-// The closeout block itself uses s.currentUnit.startedAt inside a guard — that's fine.
-// But any usage outside a guard block (e.g. in a return statement) must use optional chaining.
-// We check that all return statements use optional chaining.
-const returnWithBareAccess = /return\s*\{[^}]*s\.currentUnit\.startedAt/g;
-const bareReturnCount = [...afterCloseout.matchAll(returnWithBareAccess)].length;
-assertTrue(
-  bareReturnCount === 0,
-  `no return statements use bare s.currentUnit.startedAt (found ${bareReturnCount}, expected 0) (#2939)`,
-);
-
-// ── Test 4: the return at end of runUnitPhase uses optional chaining ────
-// The final `return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } }`
-// must use optional chaining.
-
-const finalReturnPattern = /unitStartedAt:\s*s\.currentUnit\?\.startedAt/;
-assertTrue(
-  finalReturnPattern.test(afterCloseout),
-  "final return uses s.currentUnit?.startedAt with optional chaining (#2939)",
-);
-
-report();
+test("unit started-at resolver preserves the active unit timestamp", () => {
+  assert.equal(
+    _resolveCurrentUnitStartedAtForTest({ startedAt: 12345 }),
+    12345,
+  );
+});