gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/complete-task-normalize-lists.test.ts

@@ -9,46 +9,42 @@
 
 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 completeTaskSrc = readFileSync(
-  join(__dirname, '..', 'tools', 'complete-task.ts'),
-  'utf-8',
-);
-const roadmapSlicesSrc = readFileSync(
-  join(__dirname, '..', 'roadmap-slices.ts'),
-  'utf-8',
-);
+import { normalizeListParam } from "../tools/complete-task.ts";
+import { parseRoadmapSlices } from "../roadmap-slices.ts";
 
 describe('complete-task normalizeListParam (#3692)', () => {
-  test('normalizeListParam function is defined', () => {
-    assert.match(completeTaskSrc, /function normalizeListParam\(/,
-      'normalizeListParam function should be defined in complete-task.ts');
+  test('normalizes newline-delimited key file strings', () => {
+    assert.deepEqual(
+      normalizeListParam("- src/app.ts\n* tests/app.test.ts\n  docs/notes.md"),
+      ["src/app.ts", "tests/app.test.ts", "docs/notes.md"],
+    );
   });
 
-  test('normalizeListParam is applied to keyFiles', () => {
-    assert.match(completeTaskSrc, /normalizeListParam\(params\.keyFiles\)/,
-      'normalizeListParam should be applied to keyFiles');
-  });
-
-  test('normalizeListParam is applied to keyDecisions', () => {
-    assert.match(completeTaskSrc, /normalizeListParam\(params\.keyDecisions\)/,
-      'normalizeListParam should be applied to keyDecisions');
+  test('normalizes arrays and empty values', () => {
+    assert.deepEqual(normalizeListParam(["api", 42]), ["api", "42"]);
+    assert.deepEqual(normalizeListParam("   "), []);
+    assert.deepEqual(normalizeListParam(undefined), []);
   });
 });
 
 describe('roadmap-slices depColumnIndex detection (#3692)', () => {
-  test('depColumnIndex is detected from header row', () => {
-    assert.match(roadmapSlicesSrc, /depColumnIndex/,
-      'depColumnIndex variable should exist in roadmap-slices.ts');
-    assert.match(roadmapSlicesSrc, /headerCells/,
-      'headerCells should be parsed from the header row');
-    assert.match(roadmapSlicesSrc, /depends|deps|depend/i,
-      'header detection should match depends/deps/depend');
+  test('parses dependencies from the dependency table column only', () => {
+    const slices = parseRoadmapSlices([
+      "## Slices",
+      "| ID | Title | Risk | Depends | Status |",
+      "| -- | ----- | ---- | ------- | ------ |",
+      "| S01 | Foundation | low | none | Done |",
+      "| S02 | Title mentions S01 but no dependency | medium | none | Pending |",
+      "| S03 | Integration | high | S01, S02 | Pending |",
+    ].join("\n"));
+
+    assert.deepEqual(
+      slices.map((slice) => ({ id: slice.id, depends: slice.depends })),
+      [
+        { id: "S01", depends: [] },
+        { id: "S02", depends: [] },
+        { id: "S03", depends: ["S01", "S02"] },
+      ],
+    );
   });
 });

package/src/resources/extensions/gsd/tests/completed-units-metrics-sync.test.ts

@@ -1,124 +1,61 @@
 /**
  * completed-units-metrics-sync.test.ts — Regression tests for #2313.
- *
- * 1. completed-units.json should be archived (not wiped) on milestone transition
- * 2. metrics.json should be in the worktree → project root sync file list
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, cpSync } from "node:fs";
+import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, cpSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-
-// ─── Bug 1: completed-units.json should be archived, not wiped ─────────────
-
-const phasesSrcPath = join(import.meta.dirname, "..", "auto", "phases.ts");
-const phasesSrc = readFileSync(phasesSrcPath, "utf-8");
-
-test("#2313: completed-units.json should not be blindly wiped to [] on milestone transition", () => {
-  // The milestone transition block should NOT write an empty array to completed-units.json
-  // without first archiving the existing data. Look for the archive/rename pattern.
-  const transitionIdx = phasesSrc.indexOf("Milestone transition");
-  assert.ok(transitionIdx !== -1, "Milestone transition section exists");
-
-  // Find the completed-units handling block
-  const completedUnitsIdx = phasesSrc.indexOf("completed-units", transitionIdx);
-  assert.ok(completedUnitsIdx !== -1, "completed-units handling exists in transition");
-
-  // Get a window around the completed-units handling (1200 chars to
-  // accommodate CRLF line endings on Windows which inflate byte offsets).
-  const windowStart = Math.max(0, completedUnitsIdx - 300);
-  const windowEnd = Math.min(phasesSrc.length, completedUnitsIdx + 900);
-  const window = phasesSrc.slice(windowStart, windowEnd).toLowerCase();
-
-  // Should archive/rename the old file before resetting
-  const hasArchive = window.includes("archive") ||
-    window.includes("rename") ||
-    window.includes("cpsync") ||
-    window.includes("safecopy") ||
-    window.includes("completed-units-");
-
-  assert.ok(
-    hasArchive,
-    "completed-units.json should be archived before reset during milestone transition",
-  );
-});
-
-// ─── Bug 2: metrics.json should be in the sync file lists ──────────────────
-
-test("#2313: syncStateToProjectRoot should sync metrics.json", () => {
-  const syncSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const syncSrc = readFileSync(syncSrcPath, "utf-8");
-
-  // syncStateToProjectRoot should copy metrics.json from worktree to project root
-  assert.ok(
-    syncSrc.includes("metrics.json"),
-    "auto-worktree.ts should reference metrics.json for sync",
-  );
-});
-
-test("syncStateToProjectRoot should back-sync completed-units.json", () => {
-  const syncSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const syncSrc = readFileSync(syncSrcPath, "utf-8");
-  const fnIdx = syncSrc.indexOf("export function syncStateToProjectRoot(");
-  assert.ok(fnIdx !== -1, "syncStateToProjectRoot exists");
-  const fnBlock = syncSrc.slice(fnIdx, syncSrc.indexOf("// ─── Resource Staleness", fnIdx));
-
-  assert.ok(
-    fnBlock.includes('"completed-units.json"'),
-    "syncStateToProjectRoot should copy completed-units.json back to the project root",
-  );
-});
-
-test("#2313: syncWorktreeStateBack should include metrics.json in ROOT_DIAGNOSTIC_FILES", () => {
-  const autoWorktreeSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const autoWorktreeSrc = readFileSync(autoWorktreeSrcPath, "utf-8");
-
-  // Find the ROOT_DIAGNOSTIC_FILES constant used for worktree copy-back.
-  const constIdx = autoWorktreeSrc.indexOf("ROOT_DIAGNOSTIC_FILES");
-  assert.ok(constIdx !== -1, "ROOT_DIAGNOSTIC_FILES constant exists");
-
-  // Get the array content
-  const arrayStart = autoWorktreeSrc.indexOf("[", constIdx);
-  const arrayEnd = autoWorktreeSrc.indexOf("]", arrayStart);
-  const rootFilesBlock = autoWorktreeSrc.slice(arrayStart, arrayEnd);
-
-  assert.ok(
-    rootFilesBlock.includes("metrics.json"),
-    "metrics.json should be in ROOT_DIAGNOSTIC_FILES list",
-  );
+import { syncStateToProjectRoot } from "../auto-worktree.ts";
+
+test("#2313: syncStateToProjectRoot copies metrics and completed-units to the project root", () => {
+  const root = mkdtempSync(join(tmpdir(), "gsd-sync-metrics-"));
+  const projectRoot = join(root, "project");
+  const worktree = join(root, "worktree");
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+  mkdirSync(join(worktree, ".gsd"), { recursive: true });
+  writeFileSync(join(worktree, ".gsd", "metrics.json"), JSON.stringify({ tokens: 42 }));
+  writeFileSync(join(worktree, ".gsd", "completed-units.json"), JSON.stringify([{ id: "T01" }]));
+
+  try {
+    syncStateToProjectRoot(worktree, projectRoot, "M001");
+
+    assert.deepEqual(
+      JSON.parse(readFileSync(join(projectRoot, ".gsd", "metrics.json"), "utf-8")),
+      { tokens: 42 },
+    );
+    assert.deepEqual(
+      JSON.parse(readFileSync(join(projectRoot, ".gsd", "completed-units.json"), "utf-8")),
+      [{ id: "T01" }],
+    );
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
 });
 
-// ─── Functional test: completed-units archive ────────────────────────────────
-
 test("#2313: functional — completed-units archive creates milestone-specific file", () => {
   const tmpBase = mkdtempSync(join(tmpdir(), "gsd-completed-units-"));
   const gsdDir = join(tmpBase, ".gsd");
   mkdirSync(gsdDir, { recursive: true });
 
-  // Simulate existing completed-units.json with data
-  const existing = [
-    { type: "task", id: "T01" },
-    { type: "slice", id: "S01" },
-  ];
-  const completedKeysPath = join(gsdDir, "completed-units.json");
-  writeFileSync(completedKeysPath, JSON.stringify(existing, null, 2));
-
-  // Simulate the archive behavior: copy to milestone-specific file
-  const milestoneId = "M001";
-  const archivePath = join(gsdDir, `completed-units-${milestoneId}.json`);
-  cpSync(completedKeysPath, archivePath);
-
-  // Reset the main file
-  writeFileSync(completedKeysPath, JSON.stringify([], null, 2));
-
-  // Verify archive exists with original data
-  assert.ok(existsSync(archivePath), "archive file should exist");
-  const archived = JSON.parse(readFileSync(archivePath, "utf-8"));
-  assert.deepEqual(archived, existing, "archived data should match original");
-
-  // Verify main file is reset
-  const current = JSON.parse(readFileSync(completedKeysPath, "utf-8"));
-  assert.deepEqual(current, [], "current completed-units should be empty after transition");
+  try {
+    const existing = [
+      { type: "task", id: "T01" },
+      { type: "slice", id: "S01" },
+    ];
+    const completedKeysPath = join(gsdDir, "completed-units.json");
+    writeFileSync(completedKeysPath, JSON.stringify(existing, null, 2));
+
+    const milestoneId = "M001";
+    const archivePath = join(gsdDir, `completed-units-${milestoneId}.json`);
+    cpSync(completedKeysPath, archivePath);
+    writeFileSync(completedKeysPath, JSON.stringify([], null, 2));
+
+    assert.ok(existsSync(archivePath), "archive file should exist");
+    assert.deepEqual(JSON.parse(readFileSync(archivePath, "utf-8")), existing);
+    assert.deepEqual(JSON.parse(readFileSync(completedKeysPath, "utf-8")), []);
+  } finally {
+    rmSync(tmpBase, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/context-budget.test.ts

@@ -4,7 +4,7 @@
  * No I/O, no extension context, no global state.
  */
 
-import { describe, it } from "node:test";
+import { describe, it, beforeEach } from "node:test";
 import assert from "node:assert/strict";
 
 import {
@@ -16,8 +16,17 @@ import {
   computeBudgets,
   truncateAtSectionBoundary,
   resolveExecutorContextWindow,
+  _resetEmpiricalCacheForTest,
 } from "../context-budget.js";
 
+// Reset the per-provider empirical chars-per-token cache before each test.
+// The hardcoded char-ratio assertions below assume the static fallback path
+// (3.5 / 4.0 chars/token) is used. Without this guard, a prior test that
+// warms tiktoken would populate the cache and silently break these tests.
+beforeEach(() => {
+  _resetEmpiricalCacheForTest();
+});
+
 import type { TokenProvider } from "../token-counter.js";
 
 // ─── Test helpers ─────────────────────────────────────────────────────────────

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

@@ -1,3 +1,5 @@
+// GSD-2 + context-store.test.ts — Regression coverage for DB-backed context query helpers.
+
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import {
@@ -362,7 +364,11 @@ describe("context-store: sub-5ms query timing", () => {
 
     assert.strictEqual(decisions.length, 50, `got ${decisions.length} decisions (expected 50)`);
     assert.strictEqual(requirements.length, 50, `got ${requirements.length} requirements (expected 50)`);
-    assert.ok(elapsed < 5, `query latency ${elapsed.toFixed(2)}ms should be < 5ms`);
+    const maxLatencyMs = process.env.NODE_V8_COVERAGE ? 15 : 5;
+    assert.ok(
+      elapsed < maxLatencyMs,
+      `query latency ${elapsed.toFixed(2)}ms should be < ${maxLatencyMs}ms`,
+    );
   });
 });
 

package/src/resources/extensions/gsd/tests/crash-handler-secondary.test.ts

@@ -13,11 +13,8 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from 'node:f
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { randomUUID } from 'node:crypto';
-import { fileURLToPath } from 'node:url';
-import { dirname } from 'node:path';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+import { installEpipeGuard } from "../bootstrap/register-extension.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
@@ -25,13 +22,6 @@ function makeTmpBase(): string {
   return base;
 }
 
-// ─── register-extension source assertions ────────────────────────────────────
-
-const registerExtSrc = readFileSync(
-  join(__dirname, '..', 'bootstrap', 'register-extension.ts'),
-  'utf-8',
-);
-
 describe('register-extension crash handler secondary fixes (#3348)', () => {
   test('writeCrashLog is exported and writes a file to the crash directory', async () => {
     // Dynamic import so GSD_HOME can be pointed at a temp dir without polluting ~/.gsd
@@ -60,30 +50,44 @@ describe('register-extension crash handler secondary fixes (#3348)', () => {
   });
 
   test('_gsdRejectionGuard is registered for unhandledRejection', () => {
-    assert.match(
-      registerExtSrc,
-      /_gsdRejectionGuard/,
-      '_gsdRejectionGuard handler should be defined',
-    );
-    assert.match(
-      registerExtSrc,
-      /unhandledRejection/,
-      'installEpipeGuard should register an unhandledRejection handler',
+    installEpipeGuard();
+    const listener = process.listeners("unhandledRejection").find((candidate) =>
+      candidate.name === "_gsdRejectionGuard"
     );
+    assert.ok(listener, 'installEpipeGuard should register an unhandledRejection handler');
   });
 
-  test('_gsdEpipeGuard calls process.exit(1) for unrecoverable errors, not log-and-continue', () => {
-    // The original #3696 fix replaced "throw err" with a log-and-continue.
-    // The secondary fix replaces that with writeCrashLog + process.exit(1).
-    assert.ok(
-      !registerExtSrc.includes('process.stderr.write(`[gsd] uncaught extension error (non-fatal)'),
-      '_gsdEpipeGuard should NOT log errors as non-fatal and continue',
-    );
-    assert.match(
-      registerExtSrc,
-      /process\.exit\(1\)/,
-      '_gsdEpipeGuard should call process.exit(1) for unrecoverable errors',
+  test('_gsdEpipeGuard writes a crash log and exits for unrecoverable errors', () => {
+    installEpipeGuard();
+    const listener = process.listeners("uncaughtException").find((candidate) =>
+      candidate.name === "_gsdEpipeGuard"
     );
+    assert.ok(listener, '_gsdEpipeGuard should be registered');
+
+    const tmpHome = join(tmpdir(), `gsd-crash-exit-test-${randomUUID()}`);
+    const origHome = process.env.GSD_HOME;
+    const originalExit = process.exit;
+    let exitCode: number | string | null | undefined;
+    (process as any).exit = (code?: number | string | null | undefined): never => {
+      exitCode = code;
+      throw new Error("process.exit intercepted");
+    };
+    process.env.GSD_HOME = tmpHome;
+    try {
+      assert.throws(
+        () => listener(new Error("unrecoverable crash guard test"), "uncaughtException"),
+        /process\.exit intercepted/,
+      );
+      assert.equal(exitCode, 1);
+      const crashDir = join(tmpHome, "crash");
+      const logs = readdirSync(crashDir).filter((f) => f.endsWith(".log"));
+      assert.equal(logs.length, 1);
+      assert.match(readFileSync(join(crashDir, logs[0]), "utf-8"), /unrecoverable crash guard test/);
+    } finally {
+      (process as any).exit = originalExit;
+      process.env.GSD_HOME = origHome;
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
   });
 
   test('writeCrashLog never throws even when directory is unwritable', async () => {
@@ -232,4 +236,59 @@ describe('emitCrashRecoveredUnitEnd (#3348)', () => {
       rmSync(base, { recursive: true, force: true });
     }
   });
+
+  test('emitOpenUnitEndForUnit closes the latest open start with error context', async () => {
+    const base = makeTmpBase();
+    try {
+      const { emitJournalEvent, queryJournal } = await import('../journal.ts');
+      const { emitOpenUnitEndForUnit } = await import('../crash-recovery.ts');
+
+      const firstFlowId = randomUUID();
+      const secondFlowId = randomUUID();
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: firstFlowId,
+        seq: 1,
+        eventType: 'unit-start',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02' },
+      });
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: firstFlowId,
+        seq: 2,
+        eventType: 'unit-end',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02', status: 'completed' },
+        causedBy: { flowId: firstFlowId, seq: 1 },
+      });
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: secondFlowId,
+        seq: 3,
+        eventType: 'unit-start',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02' },
+      });
+
+      const emitted = emitOpenUnitEndForUnit(
+        base,
+        'execute-task',
+        'M008/S04/T02',
+        'cancelled',
+        { message: 'runUnitPhase exploded', category: 'unit-exception', isTransient: false },
+      );
+
+      assert.equal(emitted, true, 'open unit should be closed');
+      const ends = queryJournal(base).filter((e) => e.eventType === 'unit-end');
+      assert.equal(ends.length, 2, 'should preserve existing end and add one new end');
+      const newEnd = ends.find((e) => e.causedBy?.flowId === secondFlowId);
+      assert.ok(newEnd, 'new end should close the latest open start');
+      assert.equal(newEnd!.data?.status, 'cancelled');
+      assert.deepEqual(newEnd!.data?.errorContext, {
+        message: 'runUnitPhase exploded',
+        category: 'unit-exception',
+        isTransient: false,
+      });
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/crash-recovery-via-db.test.ts

@@ -30,6 +30,7 @@ import {
   isLockProcessAlive,
 } from "../crash-recovery.ts";
 import { normalizeRealPath } from "../paths.ts";
+import { writeUnitRuntimeRecord } from "../unit-runtime.ts";
 
 function makeBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-crash-recovery-"));
@@ -102,6 +103,27 @@ test("readCrashLock synthesizes LockData from a stale dead worker (no dispatches
   assert.ok(lock!.startedAt, "startedAt populated from workers.started_at");
 });
 
+test("readCrashLock falls back to latest in-flight runtime record when dispatch claim is missing", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  writeUnitRuntimeRecord(base, "execute-task", "M008/S04/T02", 1778069087937, {
+    phase: "dispatched",
+    lastProgressAt: 1778069087937,
+    lastProgressKind: "dispatch",
+  });
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+
+  const lock = readCrashLock(base);
+  assert.ok(lock, "stale worker surfaced as a crash lock");
+  assert.equal(lock!.unitType, "execute-task");
+  assert.equal(lock!.unitId, "M008/S04/T02");
+  assert.equal(lock!.unitStartedAt, new Date(1778069087937).toISOString());
+});
+
 test("readCrashLock includes the most recent dispatch as unitType/unitId", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -15,6 +15,7 @@ import { tmpdir } from "node:os";
 import { autoLoop } from "../auto/loop.js";
 import { resolveAgentEnd, _hasPendingResolveForTest, _resetPendingResolve } from "../auto/resolve.js";
 import type { LoopDeps } from "../auto/loop-deps.js";
+import { WorktreeStateProjection } from "../worktree-state-projection.js";
 import type { SessionLockStatus } from "../session-lock.js";
 import { writeGraph, readGraph, type WorkflowGraph, type GraphStep } from "../graph.ts";
 import { writeFileSync } from "node:fs";
@@ -172,7 +173,6 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     rebuildState: async () => {},
     loadEffectiveGSDPreferences: () => undefined,
     preDispatchHealthGate: async () => ({ proceed: true, fixesApplied: [] }),
-    syncProjectRootToWorktree: () => {},
     checkResourcesStale: () => null,
     validateSessionLock: () => ({ valid: true } as SessionLockStatus),
     updateSessionLock: () => {},
@@ -182,7 +182,6 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     pruneQueueOrder: () => {},
     isInAutoWorktree: () => false,
     shouldUseWorktreeIsolation: () => false,
-    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: false }),
     teardownAutoWorktree: () => {},
     createAutoWorktree: () => "/tmp/wt",
     captureIntegrationBranch: () => {},
@@ -192,7 +191,11 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     resolveMilestoneFile: () => null,
     reconcileMergeState: () => "clean",
     preflightCleanRoot: () => ({ stashPushed: false, summary: "" }),
-    postflightPopStash: () => {},
+    postflightPopStash: () => ({
+      restored: true,
+      needsManualRecovery: false,
+      message: "restored",
+    }),
     getLedger: () => null,
     getProjectTotals: () => ({ cost: 0 }),
     formatCost: (c: number) => `$${c.toFixed(2)}`,
@@ -224,15 +227,19 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     readFileSync: () => "",
     atomicWriteSync: () => {},
     GitServiceImpl: class {} as any,
-    resolver: {
-      get workPath() { return "/tmp/project"; },
-      get projectRoot() { return "/tmp/project"; },
-      get lockPath() { return "/tmp/project"; },
-      enterMilestone: () => {},
-      exitMilestone: () => {},
-      mergeAndExit: () => {},
-      mergeAndEnterNext: () => {},
+    lifecycle: {
+      enterMilestone: () => ({ ok: true, mode: "none", path: "/tmp/project" }),
+      exitMilestone: (_mid: string, opts: { merge: boolean }) => ({
+        ok: true,
+        merged: opts.merge,
+        codeFilesChanged: false,
+      }),
+      degradeToBranchMode: () => {},
+      restoreToProjectRoot: () => {},
+      isInMilestone: () => true,
+      getCurrentMilestoneIfAny: () => "M001",
     } as any,
+    worktreeProjection: new WorktreeStateProjection(),
     postUnitPreVerification: async () => "continue" as const,
     runPostUnitVerification: async () => "continue" as const,
     postUnitPostVerification: async () => "continue" as const,
@@ -412,6 +419,10 @@ describe("Custom engine loop integration", () => {
     await autoLoop(ctx, pi, s, deps);
 
     assert.deepEqual(turnResults, [{ status: "completed", failureClass: "none", error: undefined }]);
+    assert.ok(
+      deps.callLog.includes("journal:iteration-end"),
+      `complete workflow should emit iteration-end; log=${deps.callLog.join(",")}`,
+    );
     assert.ok(
       deps.callLog.indexOf("turnResult:completed") < deps.callLog.indexOf("stopAuto:Workflow complete"),
       `turn should finalize before stopAuto; log=${deps.callLog.join(",")}`,
@@ -464,6 +475,10 @@ describe("Custom engine loop integration", () => {
     assert.equal(turnResults[0].status, "stopped");
     assert.equal(turnResults[0].failureClass, "manual-attention");
     assert.match(turnResults[0].error ?? "", /custom-engine-dispatch-stop/);
+    assert.ok(
+      deps.callLog.includes("journal:iteration-end"),
+      `blocked workflow should emit iteration-end; log=${deps.callLog.join(",")}`,
+    );
     assert.equal(s.currentTraceId, null);
     assert.equal(s.currentTurnId, null);
     assert.equal(pi.calls.length, 0, "blocked workflow should not dispatch a custom step");
@@ -656,11 +671,16 @@ describe("Custom engine loop integration", () => {
       activeRunDir: runDir,
       basePath: runDir,
     });
+    const journalEvents: Array<{ eventType: string; data?: any }> = [];
     const deps = makeMockDeps({
       stopAuto: async (_ctx, _pi, reason) => {
         deps.callLog.push(`stopAuto:${reason ?? "no-reason"}`);
         s.active = false;
       },
+      emitJournalEvent: (entry: any) => {
+        journalEvents.push(entry);
+        deps.callLog.push(`journal:${entry.eventType}`);
+      },
     });
 
     const resolver = setInterval(() => {
@@ -692,6 +712,21 @@ describe("Custom engine loop integration", () => {
     assert.match(stopEntry ?? "", /requested retry 4 times without passing/);
     const finalGraph = readGraph(runDir);
     assert.equal(finalGraph.steps[0]?.status, "active", "failed verification must not reconcile the step complete");
+
+    const unitEndIndexes = journalEvents
+      .map((entry, index) => entry.eventType === "unit-end" ? index : -1)
+      .filter((index) => index >= 0);
+    const iterationEndIndexes = journalEvents
+      .map((entry, index) => entry.eventType === "iteration-end" ? index : -1)
+      .filter((index) => index >= 0);
+    assert.equal(unitEndIndexes.length, 4, "each custom verification retry/stop attempt must emit unit-end");
+    assert.equal(iterationEndIndexes.length, 4, "each custom verification retry/stop iteration must close after unit-end");
+    for (const [i, unitEndIndex] of unitEndIndexes.entries()) {
+      assert.ok(
+        iterationEndIndexes[i]! > unitEndIndex,
+        `custom verification attempt ${i + 1} should emit iteration-end after unit-end`,
+      );
+    }
   });
 
   it("persists custom verification retry budget across a session restart", async () => {