gsd-pi 2.81.0 → 2.82.0-dev.20138ae42

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -2,12 +2,14 @@
 // File Purpose: Behavior tests for auto-loop cleanup after paused provider exits.
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { cleanupAfterLoopExit, rerootCommandSession } from "../auto.ts";
+import { cleanupAfterLoopExit, rerootCommandSession, stopAuto } from "../auto.ts";
 import { autoSession } from "../auto-runtime-state.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
+import { WorktreeLifecycle } from "../worktree-lifecycle.ts";
 
 test("cleanupAfterLoopExit preserves paused auto badge after provider pause", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-paused-cleanup-"));
@@ -41,7 +43,7 @@ test("cleanupAfterLoopExit preserves paused auto badge after provider pause", as
   }
 });
 
-test("cleanupAfterLoopExit clears status and widget when auto is not paused", async () => {
+test("cleanupAfterLoopExit clears status and progress widget without replacing outcome surface", async () => {
   const statusCalls: unknown[] = [];
   const widgetCalls: unknown[] = [];
 
@@ -60,7 +62,16 @@ test("cleanupAfterLoopExit clears status and widget when auto is not paused", as
     } as any);
 
     assert.deepEqual(statusCalls, [["gsd-auto", undefined]]);
-    assert.deepEqual(widgetCalls, [["gsd-progress", undefined]]);
+    assert.equal(
+      widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-progress" && args[1] === undefined),
+      true,
+      "cleanup must clear the stale auto progress widget",
+    );
+    assert.equal(
+      widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-outcome"),
+      false,
+      "cleanup must not replace the auto deck with a generic loop-ended card",
+    );
     assert.equal(autoSession.active, false);
     assert.equal(autoSession.paused, false);
   } finally {
@@ -68,6 +79,123 @@ test("cleanupAfterLoopExit clears status and widget when auto is not paused", as
   }
 });
 
+test("cleanupAfterLoopExit clears progress widget after stopAuto reset", async () => {
+  const statusCalls: unknown[] = [];
+  const widgetCalls: unknown[] = [];
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = false;
+  autoSession.completionStopInProgress = true;
+  autoSession.resetAfterStop({ preserveCompletionSurface: true });
+
+  try {
+    await cleanupAfterLoopExit({
+      hasUI: true,
+      ui: {
+        setStatus: (...args: unknown[]) => statusCalls.push(args),
+        setWidget: (...args: unknown[]) => widgetCalls.push(args),
+        setHeader: () => {},
+        notify: () => {},
+      },
+    } as any);
+
+    assert.deepEqual(statusCalls, [["gsd-auto", undefined]]);
+    assert.equal(
+      widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-progress" && args[1] === undefined),
+      true,
+      "completion cleanup must clear the stale progress widget",
+    );
+    assert.equal(
+      widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-outcome"),
+      false,
+      "completion cleanup must not replace the roll-up with a generic outcome card",
+    );
+    assert.equal(autoSession.completionStopInProgress, false);
+  } finally {
+    autoSession.reset();
+  }
+});
+
+test("cleanupAfterLoopExit restores project root through lifecycle and preserves chdir", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-cleanup-lifecycle-"));
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const previousCwd = process.cwd();
+  let restoreCalls = 0;
+  const originalRestore = WorktreeLifecycle.prototype.restoreToProjectRoot;
+  t.mock.method(WorktreeLifecycle.prototype, "restoreToProjectRoot", function (this: WorktreeLifecycle) {
+    restoreCalls += 1;
+    return originalRestore.call(this);
+  });
+
+  mkdirSync(worktree, { recursive: true });
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = worktree;
+  autoSession.originalBasePath = base;
+
+  try {
+    await cleanupAfterLoopExit({
+      ui: {
+        setStatus: () => {},
+        setWidget: () => {},
+        notify: () => {},
+      },
+    } as any);
+
+    assert.equal(restoreCalls, 1);
+    assert.equal(autoSession.basePath, base);
+    assert.equal(realpathSync(process.cwd()), realpathSync(base));
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("cleanupAfterLoopExit keeps cleanup best-effort when lifecycle restore throws", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-cleanup-restore-throw-"));
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const previousCwd = process.cwd();
+  let restoreCalls = 0;
+  // ADR-016 phase 3 (#5693): the real `restoreToProjectRoot` assigns
+  // `s.basePath = s.originalBasePath` AND chdir's BEFORE any throwable work
+  // (rebuildGitService, cache invalidation). Mirror that ordering in the
+  // mock so the throw scenario reflects production: basePath and cwd are
+  // restored even when the verb throws partway through.
+  t.mock.method(WorktreeLifecycle.prototype, "restoreToProjectRoot", function (this: WorktreeLifecycle) {
+    restoreCalls += 1;
+    const sRef = this as unknown as { s: { basePath: string; originalBasePath: string } };
+    sRef.s.basePath = sRef.s.originalBasePath;
+    try { process.chdir(sRef.s.basePath); } catch { /* mirror real verb's best-effort */ }
+    throw new Error("restore failed");
+  });
+
+  mkdirSync(worktree, { recursive: true });
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = worktree;
+  autoSession.originalBasePath = base;
+
+  try {
+    await cleanupAfterLoopExit({
+      ui: {
+        setStatus: () => {},
+        setWidget: () => {},
+        notify: () => {},
+      },
+    } as any);
+
+    assert.equal(restoreCalls, 1);
+    assert.equal(autoSession.basePath, base);
+    assert.equal(realpathSync(process.cwd()), realpathSync(base));
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("rerootCommandSession refreshes command workspace to project root", async () => {
   const calls: string[] = [];
   const result = await rerootCommandSession(
@@ -83,3 +211,163 @@ test("rerootCommandSession refreshes command workspace to project root", async (
   assert.deepEqual(result, { status: "ok" });
   assert.deepEqual(calls, ["/project/root"]);
 });
+
+test("stopAuto completion closeout reroots session, restores cwd, and preserves final widget", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-completion-stop-"));
+  const previousCwd = process.cwd();
+  const widgetCalls: Array<[string, unknown]> = [];
+  const notifications: string[] = [];
+  const newSessionWorkspaces: string[] = [];
+  let restoreCalls = 0;
+  const originalRestore = WorktreeLifecycle.prototype.restoreToProjectRoot;
+  t.mock.method(WorktreeLifecycle.prototype, "restoreToProjectRoot", function (this: WorktreeLifecycle) {
+    restoreCalls += 1;
+    return originalRestore.call(this);
+  });
+  const milestoneDir = join(base, ".gsd", "milestones", "M003");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(milestoneDir, "M003-SUMMARY.md"), [
+    "---",
+    "id: M003",
+    'title: "Budget tracking"',
+    "status: complete",
+    "key_decisions:",
+    "  - Keep completion closeout in the same TUI surface.",
+    "key_files:",
+    "  - src/resources/extensions/gsd/auto-dashboard.ts",
+    "lessons_learned:",
+    "  - Milestone endings need report output, not auto-loop status.",
+    "---",
+    "",
+    "# M003: Budget tracking",
+    "",
+    "**Added budget warning output and provider roll-up details.**",
+    "",
+    "## Success Criteria Results",
+    "",
+    "Budget warnings appear at milestone completion.",
+    "",
+    "## Definition of Done Results",
+    "",
+    "Completion leaves the report surface visible.",
+    "",
+    "## Requirement Outcomes",
+    "",
+    "Users can see what shipped without opening a fresh session.",
+    "",
+    "## Deviations",
+    "",
+    "None.",
+    "",
+    "## Follow-ups",
+    "",
+    "None.",
+    "",
+  ].join("\n"), "utf-8");
+
+  autoSession.reset();
+  openDatabase(join(base, "gsd-test.db"));
+  insertMilestone({ id: "M003", title: "Budget tracking", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "Complete slice", status: "complete", sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M003", title: "Done slice", status: "done", sequence: 2 });
+  insertSlice({ id: "S03", milestoneId: "M003", title: "Pending slice", status: "active", sequence: 3 });
+
+  autoSession.active = true;
+  autoSession.paused = false;
+  autoSession.basePath = join(base, ".gsd", "worktrees", "M003");
+  autoSession.originalBasePath = base;
+  autoSession.currentMilestoneId = "M003";
+  autoSession.autoStartTime = Date.now() - 60_000;
+  autoSession.cmdCtx = {
+    newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+      newSessionWorkspaces.push(workspaceRoot);
+      widgetCalls.push(["gsd-progress", undefined]);
+      return { cancelled: false };
+    },
+    sessionManager: {
+      getEntries: () => [
+        {
+          type: "message",
+          message: {
+            role: "assistant",
+            usage: { input: 100, cacheRead: 900 },
+          },
+        },
+      ],
+    },
+    getContextUsage: () => ({ percent: 0.9, contextWindow: 1_000_000 }),
+    model: { contextWindow: 1_000_000 },
+  } as any;
+
+  try {
+    await stopAuto(
+      {
+        hasUI: true,
+        ui: {
+          setStatus: () => {},
+          setWidget: (key: string, value: unknown) => {
+            widgetCalls.push([key, value]);
+          },
+          setHeader: () => {},
+          notify: (message: string) => {
+            notifications.push(message);
+          },
+        },
+        modelRegistry: { find: () => null },
+      } as any,
+      { events: { emit: () => {} } } as any,
+      "Milestone M003 complete",
+      {
+        completionWidget: {
+          milestoneId: "M003",
+          milestoneTitle: "Budget tracking",
+        },
+      },
+    );
+
+    assert.deepEqual(newSessionWorkspaces, [base], "completion stop must reroot command session to original project root");
+    assert.equal(restoreCalls, 1, "completion stop must restore project root through lifecycle");
+    assert.equal(realpathSync(process.cwd()), realpathSync(base), "completion stop must chdir back to project root");
+    assert.ok(
+      widgetCalls.some(([key, value]) => key === "gsd-progress" && typeof value === "function"),
+      "completion stop must install a final progress widget",
+    );
+    const lastProgressWidget = widgetCalls.filter(([key]) => key === "gsd-progress").at(-1);
+    assert.equal(typeof lastProgressWidget?.[1], "function", "completion stop must leave the final progress widget installed after reroot");
+    const factory = lastProgressWidget?.[1] as any;
+    const component = factory(
+      { requestRender() {} },
+      { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+    );
+    const output = component.render(140).join("\n");
+    assert.match(output, /Milestone M003 roll-up/);
+    assert.match(output, /Outcome/);
+    assert.match(output, /Added budget warning output/);
+    assert.match(output, /Verification/);
+    assert.match(output, /Files: src\/resources\/extensions\/gsd\/auto-dashboard\.ts/);
+    assert.match(output, /Lessons: Milestone endings need report output/);
+    assert.match(output, /2\/3 slices/);
+    assert.match(output, /Next/);
+    assert.match(output, /Review the roll-up/);
+    assert.match(output, /\/gsd auto for next milestone/);
+    assert.doesNotMatch(output, /COMPLETE-MILESTONE/);
+    assert.doesNotMatch(output, /\/gsd auto to resume/);
+    assert.ok(
+      notifications.some(message => message.includes("Milestone M003 complete. Auto-mode finished this milestone.")),
+      "completion stop notification should describe completion, not an aborted pause",
+    );
+    assert.ok(
+      notifications.every(message => !message.includes("/gsd auto to resume")),
+      "completion stop notification must not tell users to resume a finished auto run",
+    );
+    assert.ok(
+      widgetCalls.every(([key, value]) => key !== "gsd-outcome" || value === undefined),
+      "completion stop should use the roll-up as the single final surface",
+    );
+  } finally {
+    try { closeDatabase(); } catch { /* noop */ }
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/auto-phases-lifecycle.test.ts

@@ -62,7 +62,11 @@ async function runSuccessfulFinalize(s: AutoSession) {
   );
 }
 
-async function runFinalizeWithDeps(s: AutoSession, depsOverrides: Record<string, unknown>) {
+async function runFinalizeWithDeps(
+  s: AutoSession,
+  depsOverrides: Record<string, unknown>,
+  ctxOverride?: Record<string, unknown>,
+) {
   const unit = s.currentUnit;
   assert.ok(unit, "test setup must provide currentUnit");
 
@@ -86,7 +90,7 @@ async function runFinalizeWithDeps(s: AutoSession, depsOverrides: Record<string,
 
   return runFinalize(
     {
-      ctx: { ui: { notify() {} } },
+      ctx: ctxOverride ?? { ui: { notify() {} } },
       pi: {},
       s,
       deps,
@@ -223,3 +227,50 @@ test("runFinalize merges a verified complete-milestone immediately and only once
   assert.equal(lifecycleMergeCalls, 1);
   assert.equal(resolverMergeCalls, 0);
 });
+
+test("runFinalize does not render next-phase handoff for complete-milestone", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-finalize-complete-handoff-"));
+  t.after(() => {
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const s = new AutoSession();
+  const widgetCalls: Array<[string, unknown]> = [];
+  s.basePath = base;
+  s.originalBasePath = base;
+  s.currentMilestoneId = "M001";
+  s.currentUnit = {
+    type: "complete-milestone",
+    id: "M001",
+    startedAt: Date.now(),
+  };
+
+  const result = await runFinalizeWithDeps(
+    s,
+    {
+      preflightCleanRoot: () => ({ stashPushed: false }),
+      postflightPopStash: () => ({ needsManualRecovery: false }),
+      lifecycle: {
+        exitMilestone() {
+          return { ok: true, merged: true, codeFilesChanged: false };
+        },
+      },
+    },
+    {
+      hasUI: true,
+      ui: {
+        notify() {},
+        setWidget(key: string, value: unknown) {
+          widgetCalls.push([key, value]);
+        },
+      },
+    },
+  );
+
+  assert.equal(result.action, "next");
+  assert.equal(
+    widgetCalls.some(([key]) => key === "gsd-outcome"),
+    false,
+    "complete-milestone finalize should leave terminal completion UI to stopAuto",
+  );
+});

package/src/resources/extensions/gsd/tests/auto-post-unit-step-message.test.ts

@@ -3,7 +3,11 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { buildStepCompleteMessage, STEP_COMPLETE_FALLBACK_MESSAGE } from "../auto-post-unit.ts";
+import {
+  buildStepCompleteMessage,
+  shouldReturnStepWizardAfterUnit,
+  STEP_COMPLETE_FALLBACK_MESSAGE,
+} from "../auto-post-unit.ts";
 import type { GSDState } from "../types.ts";
 
 function makeState(overrides: Partial<GSDState>): GSDState {
@@ -51,3 +55,10 @@ test("STEP_COMPLETE_FALLBACK_MESSAGE: used when deriveState throws, still points
   assert.match(STEP_COMPLETE_FALLBACK_MESSAGE, /\/clear/);
   assert.match(STEP_COMPLETE_FALLBACK_MESSAGE, /\/gsd/);
 });
+
+test("shouldReturnStepWizardAfterUnit: terminal milestone completion continues to merge-back path", () => {
+  assert.equal(shouldReturnStepWizardAfterUnit("complete-milestone", "complete"), false);
+  assert.equal(shouldReturnStepWizardAfterUnit("complete-milestone", null), false);
+  assert.equal(shouldReturnStepWizardAfterUnit("execute-task", "complete"), false);
+  assert.equal(shouldReturnStepWizardAfterUnit("execute-task", "executing"), true);
+});

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

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, buildLoopRemediationSteps, writeBlockerPlaceholder, refreshRecoveryDbForArtifact } from "../auto-recovery.ts";
+import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, diagnoseWorktreeIntegrityFailure, buildLoopRemediationSteps, writeBlockerPlaceholder, refreshRecoveryDbForArtifact } from "../auto-recovery.ts";
 import { resolveMilestoneFile } from "../paths.ts";
 import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow, insertTask, getMilestoneCommitAttributionShas } from "../gsd-db.ts";
 import { clearParseCache } from "../files.ts";
@@ -141,6 +141,20 @@ test("resolveExpectedArtifactPath returns null for unknown type", () => {
   }
 });
 
+test("diagnoseWorktreeIntegrityFailure reports missing GSD worktree paths only", () => {
+  const missingWorktreePath = join(tmpdir(), `gsd-test-${randomUUID()}`, ".gsd", "worktrees", "M001-S01");
+  assert.equal(
+    diagnoseWorktreeIntegrityFailure(join(tmpdir(), `gsd-test-${randomUUID()}`)),
+    null,
+    "non-GSD paths should keep falling through to artifact recovery",
+  );
+  assert.equal(
+    diagnoseWorktreeIntegrityFailure(missingWorktreePath),
+    `Worktree integrity failure: ${missingWorktreePath} does not exist. Repair or recreate the worktree before retrying.`,
+    "missing GSD worktree paths should fail terminally before artifact retry",
+  );
+});
+
 test("resolveExpectedArtifactPath returns correct path for all milestone-level types", () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/auto-runtime-state.test.ts

@@ -1,17 +1,21 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { autoSession, getAutoRuntimeSnapshot } from "../auto-runtime-state.ts";
+import {
+  autoSession,
+  clearToolInvocationError,
+  getAutoRuntimeSnapshot,
+} from "../auto-runtime-state.ts";
 
 test("getAutoRuntimeSnapshot includes orchestration phase when available", () => {
   autoSession.reset();
   autoSession.active = true;
   autoSession.basePath = "/tmp/project";
   autoSession.orchestration = {
-    async start() { return { kind: "advanced" as const }; },
-    async advance() { return { kind: "advanced" as const }; },
-    async resume() { return { kind: "advanced" as const }; },
-    async stop() { return { kind: "stopped" as const }; },
+    async start() { return { kind: "stopped" as const, reason: "test" }; },
+    async advance() { return { kind: "stopped" as const, reason: "test" }; },
+    async resume() { return { kind: "stopped" as const, reason: "test" }; },
+    async stop() { return { kind: "stopped" as const, reason: "test" }; },
     getStatus() {
       return { phase: "running" as const, transitionCount: 3, lastTransitionAt: 123 };
     },
@@ -28,6 +32,17 @@ test("getAutoRuntimeSnapshot includes orchestration phase when available", () =>
   autoSession.reset();
 });
 
+test("clearToolInvocationError clears stale tool error state for active auto sessions", () => {
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.lastToolInvocationError = "gsd_task_complete: simulated transient tool error";
+
+  clearToolInvocationError();
+
+  assert.equal(autoSession.lastToolInvocationError, null);
+  autoSession.reset();
+});
+
 test("getAutoRuntimeSnapshot omits orchestration phase when seam not wired", () => {
   autoSession.reset();
 

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

@@ -98,8 +98,17 @@ test("bootstrap aborts before starting next milestone when completed orphan merg
       {
         shouldUseWorktreeIsolation: () => true,
         registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
         lockBase: () => base,
         buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
           exitMilestone: (milestoneId: string) => {
             mergeCalls.push(milestoneId);
             return {
@@ -109,6 +118,16 @@ test("bootstrap aborts before starting next milestone when completed orphan merg
             };
           },
           enterMilestone: () => ({ ok: true, mode: "none", path: base }),
+          // ADR-016 phase 2 / B4 (#5622): the orphan-merge dance now goes
+          // through `adoptOrphanWorktree`. The mock invokes the callback
+          // and returns its result without exercising the swap-revert
+          // protocol — this test only cares about the merge call being
+          // recorded and the bootstrap returning `false` on failure.
+          adoptOrphanWorktree: <T extends { merged: boolean }>(
+            _mid: string,
+            _base: string,
+            run: () => T,
+          ): T => run(),
         }) as any,
       },
       {

package/src/resources/extensions/gsd/tests/auto-unit-closeout.test.ts

@@ -0,0 +1,68 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for auto-unit closeout activity classification.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  isSuspiciousGhostCompletion,
+  snapshotUnitActivity,
+} from "../auto-unit-closeout.ts";
+
+function makeCtx(entries: unknown[]) {
+  return {
+    sessionManager: {
+      getEntries: () => entries,
+    },
+  } as any;
+}
+
+test("isSuspiciousGhostCompletion rejects fast completions with no assistant output or tools", () => {
+  const startedAt = Date.now();
+  const ctx = makeCtx([]);
+
+  assert.equal(isSuspiciousGhostCompletion(ctx, startedAt, 500), true);
+});
+
+test("isSuspiciousGhostCompletion allows fast completions with assistant output", () => {
+  const startedAt = Date.now();
+  const ctx = makeCtx([
+    {
+      type: "message",
+      message: {
+        role: "assistant",
+        content: [{ type: "text", text: "Done." }],
+      },
+    },
+  ]);
+
+  assert.equal(isSuspiciousGhostCompletion(ctx, startedAt, 500), false);
+});
+
+test("snapshotUnitActivity counts assistant messages and tool calls", () => {
+  const ctx = makeCtx([
+    {
+      type: "message",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "text", text: "Working." },
+          { type: "toolCall", name: "read_file" },
+        ],
+      },
+    },
+    {
+      type: "message",
+      message: {
+        role: "user",
+        content: "continue",
+      },
+    },
+  ]);
+
+  assert.deepEqual(snapshotUnitActivity(ctx, 1_000, 1_250), {
+    elapsedMs: 250,
+    toolCalls: 1,
+    assistantMessages: 1,
+  });
+});