gsd-pi 2.44.0 → 2.45.0-dev.1afbdaa

package/src/resources/extensions/gsd/tests/overrides.test.ts

@@ -1,15 +1,14 @@
 // GSD Extension - Override Tests
 // Tests for parseOverrides, appendOverride, loadActiveOverrides, formatOverridesSection, resolveAllOverrides
 
+import { describe, test, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { createTestContext } from './test-helpers.ts';
 import { parseOverrides, appendOverride, loadActiveOverrides, formatOverridesSection, resolveAllOverrides } from '../files.ts';
 import type { Override } from '../files.ts';
 
-const { assertEq, assertTrue, assertMatch, assertNoMatch, report } = createTestContext();
-
 const tempDirs: string[] = [];
 
 function makeTempDir(prefix: string): string {
@@ -26,106 +25,100 @@ function cleanup(): void {
   tempDirs.length = 0;
 }
 
-console.log('\n=== parseOverrides: empty content ===');
-{ const result = parseOverrides(""); assertEq(result.length, 0, "empty content returns no overrides"); }
-
-console.log('\n=== parseOverrides: single active override ===');
-{
-  const content = `# GSD Overrides\n\nUser-issued overrides that supersede plan document content.\n\n---\n\n## Override: 2026-03-14T10:00:00.000Z\n\n**Change:** Use Postgres instead of SQLite\n**Scope:** active\n**Applied-at:** M001/S02/T03\n\n---\n`;
-  const result = parseOverrides(content);
-  assertEq(result.length, 1, "parses one override");
-  assertEq(result[0].timestamp, "2026-03-14T10:00:00.000Z", "correct timestamp");
-  assertEq(result[0].change, "Use Postgres instead of SQLite", "correct change");
-  assertEq(result[0].scope, "active", "correct scope");
-  assertEq(result[0].appliedAt, "M001/S02/T03", "correct appliedAt");
-}
-
-console.log('\n=== parseOverrides: multiple overrides, mixed scopes ===');
-{
-  const content = `# GSD Overrides\n\n---\n\n## Override: 2026-03-14T10:00:00.000Z\n\n**Change:** Use Postgres instead of SQLite\n**Scope:** resolved\n**Applied-at:** M001/S02/T03\n\n---\n\n## Override: 2026-03-14T11:00:00.000Z\n\n**Change:** Use JWT instead of session cookies\n**Scope:** active\n**Applied-at:** M001/S03/T01\n\n---\n`;
-  const result = parseOverrides(content);
-  assertEq(result.length, 2, "parses two overrides");
-  assertEq(result[0].scope, "resolved", "first is resolved");
-  assertEq(result[1].scope, "active", "second is active");
-  assertEq(result[1].change, "Use JWT instead of session cookies", "second change text");
-}
-
-console.log('\n=== appendOverride: creates new file ===');
-{
-  const tmp = makeTempDir("append-new");
-  await appendOverride(tmp, "Use Postgres", "M001/S01/T01");
-  const content = readFileSync(join(tmp, ".gsd", "OVERRIDES.md"), "utf-8");
-  assertTrue(content.includes("# GSD Overrides"), "has header");
-  assertTrue(content.includes("**Change:** Use Postgres"), "has change");
-  assertTrue(content.includes("**Scope:** active"), "has active scope");
-  assertTrue(content.includes("**Applied-at:** M001/S01/T01"), "has appliedAt");
-}
-
-console.log('\n=== appendOverride: appends to existing file ===');
-{
-  const tmp = makeTempDir("append-existing");
-  await appendOverride(tmp, "First override", "M001/S01/T01");
-  await appendOverride(tmp, "Second override", "M001/S02/T02");
-  const content = readFileSync(join(tmp, ".gsd", "OVERRIDES.md"), "utf-8");
-  assertTrue(content.includes("**Change:** First override"), "has first override");
-  assertTrue(content.includes("**Change:** Second override"), "has second override");
-  const parsed = parseOverrides(content);
-  assertEq(parsed.length, 2, "two overrides in file");
-}
-
-console.log('\n=== loadActiveOverrides: no file ===');
-{
-  const tmp = makeTempDir("load-no-file");
-  const result = await loadActiveOverrides(tmp);
-  assertEq(result.length, 0, "returns empty when no file");
-}
-
-console.log('\n=== loadActiveOverrides: filters to active only ===');
-{
-  const tmp = makeTempDir("load-filter");
-  const content = `# GSD Overrides\n\n---\n\n## Override: 2026-03-14T10:00:00.000Z\n\n**Change:** Resolved change\n**Scope:** resolved\n**Applied-at:** M001/S01/T01\n\n---\n\n## Override: 2026-03-14T11:00:00.000Z\n\n**Change:** Active change\n**Scope:** active\n**Applied-at:** M001/S02/T01\n\n---\n`;
-  writeFileSync(join(tmp, ".gsd", "OVERRIDES.md"), content, "utf-8");
-  const result = await loadActiveOverrides(tmp);
-  assertEq(result.length, 1, "only one active override");
-  assertEq(result[0].change, "Active change", "correct active change");
-}
-
-console.log('\n=== formatOverridesSection: empty array ===');
-{ const result = formatOverridesSection([]); assertEq(result, "", "empty overrides returns empty string"); }
-
-console.log('\n=== formatOverridesSection: formats section ===');
-{
-  const overrides: Override[] = [
-    { timestamp: "2026-03-14T10:00:00.000Z", change: "Use Postgres", scope: "active", appliedAt: "M001/S01/T01" },
-  ];
-  const result = formatOverridesSection(overrides);
-  assertTrue(result.includes("## Active Overrides (supersede plan content)"), "has header");
-  assertTrue(result.includes("**Use Postgres**"), "has change text");
-  assertTrue(result.includes("supersede any conflicting content"), "has instruction");
-}
-
-console.log('\n=== resolveAllOverrides: marks all as resolved ===');
-{
-  const tmp = makeTempDir("resolve-all");
-  await appendOverride(tmp, "First", "M001/S01/T01");
-  await appendOverride(tmp, "Second", "M001/S02/T01");
-  let active = await loadActiveOverrides(tmp);
-  assertEq(active.length, 2, "two active before resolve");
-  await resolveAllOverrides(tmp);
-  active = await loadActiveOverrides(tmp);
-  assertEq(active.length, 0, "no active after resolve");
-  const content = readFileSync(join(tmp, ".gsd", "OVERRIDES.md"), "utf-8");
-  const allOverrides = parseOverrides(content);
-  assertEq(allOverrides.length, 2, "still two overrides total");
-  assertTrue(allOverrides.every(o => o.scope === "resolved"), "all resolved");
-}
-
-console.log('\n=== resolveAllOverrides: no file — no error ===');
-{
-  const tmp = makeTempDir("resolve-no-file");
-  await resolveAllOverrides(tmp);
-  assertTrue(true, "resolveAllOverrides with no file does not throw");
-}
-
-cleanup();
-report();
+describe('overrides', () => {
+  afterEach(() => cleanup());
+
+  test('parseOverrides: empty content', () => {
+    const result = parseOverrides(""); assert.deepStrictEqual(result.length, 0, "empty content returns no overrides");
+  });
+
+  test('parseOverrides: single active override', () => {
+    const content = `# GSD Overrides\n\nUser-issued overrides that supersede plan document content.\n\n---\n\n## Override: 2026-03-14T10:00:00.000Z\n\n**Change:** Use Postgres instead of SQLite\n**Scope:** active\n**Applied-at:** M001/S02/T03\n\n---\n`;
+    const result = parseOverrides(content);
+    assert.deepStrictEqual(result.length, 1, "parses one override");
+    assert.deepStrictEqual(result[0].timestamp, "2026-03-14T10:00:00.000Z", "correct timestamp");
+    assert.deepStrictEqual(result[0].change, "Use Postgres instead of SQLite", "correct change");
+    assert.deepStrictEqual(result[0].scope, "active", "correct scope");
+    assert.deepStrictEqual(result[0].appliedAt, "M001/S02/T03", "correct appliedAt");
+  });
+
+  test('parseOverrides: multiple overrides, mixed scopes', () => {
+    const content = `# GSD Overrides\n\n---\n\n## Override: 2026-03-14T10:00:00.000Z\n\n**Change:** Use Postgres instead of SQLite\n**Scope:** resolved\n**Applied-at:** M001/S02/T03\n\n---\n\n## Override: 2026-03-14T11:00:00.000Z\n\n**Change:** Use JWT instead of session cookies\n**Scope:** active\n**Applied-at:** M001/S03/T01\n\n---\n`;
+    const result = parseOverrides(content);
+    assert.deepStrictEqual(result.length, 2, "parses two overrides");
+    assert.deepStrictEqual(result[0].scope, "resolved", "first is resolved");
+    assert.deepStrictEqual(result[1].scope, "active", "second is active");
+    assert.deepStrictEqual(result[1].change, "Use JWT instead of session cookies", "second change text");
+  });
+
+  test('appendOverride: creates new file', async () => {
+    const tmp = makeTempDir("append-new");
+    await appendOverride(tmp, "Use Postgres", "M001/S01/T01");
+    const content = readFileSync(join(tmp, ".gsd", "OVERRIDES.md"), "utf-8");
+    assert.ok(content.includes("# GSD Overrides"), "has header");
+    assert.ok(content.includes("**Change:** Use Postgres"), "has change");
+    assert.ok(content.includes("**Scope:** active"), "has active scope");
+    assert.ok(content.includes("**Applied-at:** M001/S01/T01"), "has appliedAt");
+  });
+
+  test('appendOverride: appends to existing file', async () => {
+    const tmp = makeTempDir("append-existing");
+    await appendOverride(tmp, "First override", "M001/S01/T01");
+    await appendOverride(tmp, "Second override", "M001/S02/T02");
+    const content = readFileSync(join(tmp, ".gsd", "OVERRIDES.md"), "utf-8");
+    assert.ok(content.includes("**Change:** First override"), "has first override");
+    assert.ok(content.includes("**Change:** Second override"), "has second override");
+    const parsed = parseOverrides(content);
+    assert.deepStrictEqual(parsed.length, 2, "two overrides in file");
+  });
+
+  test('loadActiveOverrides: no file', async () => {
+    const tmp = makeTempDir("load-no-file");
+    const result = await loadActiveOverrides(tmp);
+    assert.deepStrictEqual(result.length, 0, "returns empty when no file");
+  });
+
+  test('loadActiveOverrides: filters to active only', async () => {
+    const tmp = makeTempDir("load-filter");
+    const content = `# GSD Overrides\n\n---\n\n## Override: 2026-03-14T10:00:00.000Z\n\n**Change:** Resolved change\n**Scope:** resolved\n**Applied-at:** M001/S01/T01\n\n---\n\n## Override: 2026-03-14T11:00:00.000Z\n\n**Change:** Active change\n**Scope:** active\n**Applied-at:** M001/S02/T01\n\n---\n`;
+    writeFileSync(join(tmp, ".gsd", "OVERRIDES.md"), content, "utf-8");
+    const result = await loadActiveOverrides(tmp);
+    assert.deepStrictEqual(result.length, 1, "only one active override");
+    assert.deepStrictEqual(result[0].change, "Active change", "correct active change");
+  });
+
+  test('formatOverridesSection: empty array', () => {
+    const result = formatOverridesSection([]); assert.deepStrictEqual(result, "", "empty overrides returns empty string");
+  });
+
+  test('formatOverridesSection: formats section', () => {
+    const overrides: Override[] = [
+      { timestamp: "2026-03-14T10:00:00.000Z", change: "Use Postgres", scope: "active", appliedAt: "M001/S01/T01" },
+    ];
+    const result = formatOverridesSection(overrides);
+    assert.ok(result.includes("## Active Overrides (supersede plan content)"), "has header");
+    assert.ok(result.includes("**Use Postgres**"), "has change text");
+    assert.ok(result.includes("supersede any conflicting content"), "has instruction");
+  });
+
+  test('resolveAllOverrides: marks all as resolved', async () => {
+    const tmp = makeTempDir("resolve-all");
+    await appendOverride(tmp, "First", "M001/S01/T01");
+    await appendOverride(tmp, "Second", "M001/S02/T01");
+    let active = await loadActiveOverrides(tmp);
+    assert.deepStrictEqual(active.length, 2, "two active before resolve");
+    await resolveAllOverrides(tmp);
+    active = await loadActiveOverrides(tmp);
+    assert.deepStrictEqual(active.length, 0, "no active after resolve");
+    const content = readFileSync(join(tmp, ".gsd", "OVERRIDES.md"), "utf-8");
+    const allOverrides = parseOverrides(content);
+    assert.deepStrictEqual(allOverrides.length, 2, "still two overrides total");
+    assert.ok(allOverrides.every(o => o.scope === "resolved"), "all resolved");
+  });
+
+  test('resolveAllOverrides: no file — no error', async () => {
+    const tmp = makeTempDir("resolve-no-file");
+    await resolveAllOverrides(tmp);
+    assert.ok(true, "resolveAllOverrides with no file does not throw");
+  });
+});

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

@@ -322,7 +322,6 @@ test("budget — refreshWorkerStatuses updates worker state from disk", async ()
     const workers = getWorkerStatuses();
     assert.equal(workers.length, 1);
     assert.equal(workers[0]!.state, "paused", "worker state should be updated from disk");
-    assert.equal(workers[0]!.completedUnits, 5, "completedUnits should be updated from disk");
     assert.equal(workers[0]!.cost, 2.5, "cost should be updated from disk");
   } finally {
     resetOrchestrator();

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

@@ -5,6 +5,8 @@
  * restored after a coordinator crash, with PID liveness filtering.
  */
 
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import {
   mkdtempSync,
   mkdirSync,
@@ -24,10 +26,6 @@ import {
   type PersistedState,
 } from "../parallel-orchestrator.ts";
 import { writeSessionStatus, readAllSessionStatuses, removeSessionStatus } from "../session-status-io.ts";
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
-
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
 function makeTempDir(): string {
@@ -57,8 +55,9 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
 
 // ─── Tests ────────────────────────────────────────────────────────────────────
 
-// Test 1: persistState writes valid JSON
-{
+
+describe('parallel-crash-recovery', () => {
+test('Test 1: persistState writes valid JSON', () => {
   const basePath = makeTempDir();
   try {
     // We can't call persistState directly without internal state set up,
@@ -72,7 +71,6 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
           worktreePath: "/tmp/wt-M001",
           startedAt: Date.now(),
           state: "running",
-          completedUnits: 3,
           cost: 0.15,
         },
       ],
@@ -82,29 +80,27 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
 
     const raw = readFileSync(stateFilePath(basePath), "utf-8");
     const parsed = JSON.parse(raw) as PersistedState;
-    assertEq(parsed.active, true, "persistState: active field preserved");
-    assertEq(parsed.workers.length, 1, "persistState: worker count preserved");
-    assertEq(parsed.workers[0].milestoneId, "M001", "persistState: milestoneId preserved");
-    assertEq(parsed.workers[0].cost, 0.15, "persistState: cost preserved");
-    assertEq(parsed.totalCost, 0.15, "persistState: totalCost preserved");
+    assert.deepStrictEqual(parsed.active, true, "persistState: active field preserved");
+    assert.deepStrictEqual(parsed.workers.length, 1, "persistState: worker count preserved");
+    assert.deepStrictEqual(parsed.workers[0].milestoneId, "M001", "persistState: milestoneId preserved");
+    assert.deepStrictEqual(parsed.workers[0].cost, 0.15, "persistState: cost preserved");
+    assert.deepStrictEqual(parsed.totalCost, 0.15, "persistState: totalCost preserved");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-}
+});
 
-// Test 2: restoreState returns null for missing file
-{
+test('Test 2: restoreState returns null for missing file', () => {
   const basePath = makeTempDir();
   try {
     const result = restoreState(basePath);
-    assertEq(result, null, "restoreState: returns null when no state file");
+    assert.deepStrictEqual(result, null, "restoreState: returns null when no state file");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-}
+});
 
-// Test 3: restoreState filters dead PIDs
-{
+test('Test 3: restoreState filters dead PIDs', () => {
   const basePath = makeTempDir();
   try {
     // PID 99999999 is almost certainly not alive
@@ -117,7 +113,6 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
           worktreePath: "/tmp/wt-M001",
           startedAt: Date.now(),
           state: "running",
-          completedUnits: 0,
           cost: 0,
         },
         {
@@ -127,7 +122,6 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
           worktreePath: "/tmp/wt-M002",
           startedAt: Date.now(),
           state: "running",
-          completedUnits: 0,
           cost: 0,
         },
       ],
@@ -136,15 +130,14 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
 
     const result = restoreState(basePath);
     // Both PIDs are dead, so result should be null and file should be cleaned up
-    assertEq(result, null, "restoreState: returns null when all PIDs dead");
-    assertTrue(!existsSync(stateFilePath(basePath)), "restoreState: cleans up state file when all dead");
+    assert.deepStrictEqual(result, null, "restoreState: returns null when all PIDs dead");
+    assert.ok(!existsSync(stateFilePath(basePath)), "restoreState: cleans up state file when all dead");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-}
+});
 
-// Test 4: restoreState keeps alive PIDs
-{
+test('Test 4: restoreState keeps alive PIDs', () => {
   const basePath = makeTempDir();
   try {
     // Use current process PID (definitely alive)
@@ -157,7 +150,6 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
           worktreePath: "/tmp/wt-M001",
           startedAt: Date.now(),
           state: "running",
-          completedUnits: 5,
           cost: 0.25,
         },
         {
@@ -167,7 +159,6 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
           worktreePath: "/tmp/wt-M002",
           startedAt: Date.now(),
           state: "running",
-          completedUnits: 0,
           cost: 0,
         },
       ],
@@ -176,18 +167,16 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
     writeStateFile(basePath, state);
 
     const result = restoreState(basePath);
-    assertTrue(result !== null, "restoreState: returns state when alive PID exists");
-    assertEq(result!.workers.length, 1, "restoreState: filters out dead PID");
-    assertEq(result!.workers[0].milestoneId, "M001", "restoreState: keeps alive worker");
-    assertEq(result!.workers[0].pid, process.pid, "restoreState: preserves PID");
-    assertEq(result!.workers[0].completedUnits, 5, "restoreState: preserves progress");
+    assert.ok(result !== null, "restoreState: returns state when alive PID exists");
+    assert.deepStrictEqual(result!.workers.length, 1, "restoreState: filters out dead PID");
+    assert.deepStrictEqual(result!.workers[0].milestoneId, "M001", "restoreState: keeps alive worker");
+    assert.deepStrictEqual(result!.workers[0].pid, process.pid, "restoreState: preserves PID");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-}
+});
 
-// Test 5: restoreState skips stopped/error workers even with alive PIDs
-{
+test('Test 5: restoreState skips stopped/error workers even with alive PIDs', () => {
   const basePath = makeTempDir();
   try {
     const state = makePersistedState({
@@ -199,7 +188,6 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
           worktreePath: "/tmp/wt-M001",
           startedAt: Date.now(),
           state: "stopped",
-          completedUnits: 10,
           cost: 0.50,
         },
       ],
@@ -207,14 +195,13 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
     writeStateFile(basePath, state);
 
     const result = restoreState(basePath);
-    assertEq(result, null, "restoreState: skips stopped workers");
+    assert.deepStrictEqual(result, null, "restoreState: skips stopped workers");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-}
+});
 
-// Test 6: orphan detection finds stale sessions
-{
+test('Test 6: orphan detection finds stale sessions', () => {
   const basePath = makeTempDir();
   try {
     // Write a session status with a dead PID
@@ -246,7 +233,7 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
 
     // Read all sessions — both should exist initially
     const before = readAllSessionStatuses(basePath);
-    assertEq(before.length, 2, "orphan: both sessions exist before detection");
+    assert.deepStrictEqual(before.length, 2, "orphan: both sessions exist before detection");
 
     // Now simulate orphan detection logic (same as prepareParallelStart)
     const sessions = readAllSessionStatuses(basePath);
@@ -265,34 +252,33 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
       }
     }
 
-    assertTrue(orphans.length === 2, "orphan: detected both sessions");
+    assert.ok(orphans.length === 2, "orphan: detected both sessions");
     const deadOrphan = orphans.find(o => o.milestoneId === "M001");
-    assertTrue(deadOrphan !== undefined && !deadOrphan.alive, "orphan: M001 detected as dead");
+    assert.ok(deadOrphan !== undefined && !deadOrphan.alive, "orphan: M001 detected as dead");
     const aliveOrphan = orphans.find(o => o.milestoneId === "M002");
-    assertTrue(aliveOrphan !== undefined && aliveOrphan.alive, "orphan: M002 detected as alive");
+    assert.ok(aliveOrphan !== undefined && aliveOrphan.alive, "orphan: M002 detected as alive");
 
     // Dead session should be cleaned up
     const after = readAllSessionStatuses(basePath);
-    assertEq(after.length, 1, "orphan: dead session cleaned up");
-    assertEq(after[0].milestoneId, "M002", "orphan: alive session remains");
+    assert.deepStrictEqual(after.length, 1, "orphan: dead session cleaned up");
+    assert.deepStrictEqual(after[0].milestoneId, "M002", "orphan: alive session remains");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-}
+});
 
-// Test 7: restoreState handles corrupt JSON gracefully
-{
+test('Test 7: restoreState handles corrupt JSON gracefully', () => {
   const basePath = makeTempDir();
   try {
     writeFileSync(stateFilePath(basePath), "{ not valid json !!!", "utf-8");
     const result = restoreState(basePath);
-    assertEq(result, null, "restoreState: returns null for corrupt JSON");
+    assert.deepStrictEqual(result, null, "restoreState: returns null for corrupt JSON");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-}
+});
 
 // Clean up module state
 resetOrchestrator();
 
-report();
+});

package/src/resources/extensions/gsd/tests/parallel-merge.test.ts

@@ -70,7 +70,6 @@ function makeWorker(overrides: Partial<WorkerInfo> = {}): WorkerInfo {
     worktreePath: "/tmp/test",
     startedAt: Date.now(),
     state: "stopped",
-    completedUnits: 3,
     cost: 1.5,
     ...overrides,
   };
@@ -132,16 +131,16 @@ test("determineMergeOrder — by-completion sorts by startedAt (earliest first)"
   assert.deepEqual(order, ["M003", "M002", "M001"]);
 });
 
-test("determineMergeOrder — only includes stopped workers with completedUnits > 0", () => {
+test("determineMergeOrder — only includes stopped workers", () => {
   const workers = [
-    makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 3 }),
-    makeWorker({ milestoneId: "M002", state: "running", completedUnits: 2 }),
-    makeWorker({ milestoneId: "M003", state: "stopped", completedUnits: 0 }),
-    makeWorker({ milestoneId: "M004", state: "error", completedUnits: 5 }),
-    makeWorker({ milestoneId: "M005", state: "paused", completedUnits: 1 }),
+    makeWorker({ milestoneId: "M001", state: "stopped" }),
+    makeWorker({ milestoneId: "M002", state: "running" }),
+    makeWorker({ milestoneId: "M003", state: "stopped" }),
+    makeWorker({ milestoneId: "M004", state: "error" }),
+    makeWorker({ milestoneId: "M005", state: "paused" }),
   ];
   const order = determineMergeOrder(workers, "sequential");
-  assert.deepEqual(order, ["M001"]);
+  assert.deepEqual(order, ["M001", "M003"]);
 });
 
 test("determineMergeOrder — empty workers returns empty array", () => {

package/src/resources/extensions/gsd/tests/parallel-orchestration.test.ts

@@ -297,7 +297,6 @@ describe("parallel-orchestrator: lifecycle", () => {
             worktreePath: "/tmp/wt-M001",
             startedAt: Date.now(),
             state: "running",
-            completedUnits: 2,
             cost: 0.25,
           },
         ],
@@ -309,7 +308,6 @@ describe("parallel-orchestrator: lifecycle", () => {
       const workers = getWorkerStatuses(base);
       assert.equal(workers.length, 1);
       assert.equal(workers[0].milestoneId, "M001");
-      assert.equal(workers[0].completedUnits, 2);
       assert.equal(isParallelActive(), true);
     } finally {
       resetOrchestrator();
@@ -416,7 +414,6 @@ describe("parallel-orchestrator: lifecycle", () => {
       const workers = getWorkerStatuses();
       assert.equal(workers.length, 1);
       assert.equal(workers[0].state, "running");
-      assert.equal(workers[0].completedUnits, 4);
     } finally {
       resetOrchestrator();
       rmSync(base, { recursive: true, force: true });
@@ -552,7 +549,6 @@ function makeWorker(overrides: Partial<WorkerInfo> = {}): WorkerInfo {
     worktreePath: "/tmp/test-worktree",
     startedAt: Date.now() - 60_000,
     state: "stopped",
-    completedUnits: 5,
     cost: 2.50,
     ...overrides,
   };
@@ -563,9 +559,9 @@ function makeWorker(overrides: Partial<WorkerInfo> = {}): WorkerInfo {
 describe("parallel-merge: determineMergeOrder sequential", () => {
   it("returns milestone IDs sorted alphabetically by default", () => {
     const workers = [
-      makeWorker({ milestoneId: "M003", state: "stopped", completedUnits: 1 }),
-      makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 2 }),
-      makeWorker({ milestoneId: "M002", state: "stopped", completedUnits: 3 }),
+      makeWorker({ milestoneId: "M003", state: "stopped" }),
+      makeWorker({ milestoneId: "M001", state: "stopped" }),
+      makeWorker({ milestoneId: "M002", state: "stopped" }),
     ];
     const order = determineMergeOrder(workers, "sequential");
     assert.deepEqual(order, ["M001", "M002", "M003"]);
@@ -573,27 +569,27 @@ describe("parallel-merge: determineMergeOrder sequential", () => {
 
   it("excludes workers that are still running", () => {
     const workers = [
-      makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 5 }),
-      makeWorker({ milestoneId: "M002", state: "running", completedUnits: 0 }),
-      makeWorker({ milestoneId: "M003", state: "stopped", completedUnits: 2 }),
+      makeWorker({ milestoneId: "M001", state: "stopped" }),
+      makeWorker({ milestoneId: "M002", state: "running" }),
+      makeWorker({ milestoneId: "M003", state: "stopped" }),
     ];
     const order = determineMergeOrder(workers, "sequential");
     assert.deepEqual(order, ["M001", "M003"]);
   });
 
-  it("excludes workers with zero completedUnits even if stopped", () => {
+  it("includes all stopped workers", () => {
     const workers = [
-      makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 0 }),
-      makeWorker({ milestoneId: "M002", state: "stopped", completedUnits: 3 }),
+      makeWorker({ milestoneId: "M001", state: "stopped" }),
+      makeWorker({ milestoneId: "M002", state: "stopped" }),
     ];
     const order = determineMergeOrder(workers, "sequential");
-    assert.deepEqual(order, ["M002"]);
+    assert.deepEqual(order, ["M001", "M002"]);
   });
 
   it("returns empty array when no workers are completed", () => {
     const workers = [
-      makeWorker({ milestoneId: "M001", state: "running", completedUnits: 0 }),
-      makeWorker({ milestoneId: "M002", state: "paused", completedUnits: 0 }),
+      makeWorker({ milestoneId: "M001", state: "running" }),
+      makeWorker({ milestoneId: "M002", state: "paused" }),
     ];
     const order = determineMergeOrder(workers);
     assert.deepEqual(order, []);
@@ -601,8 +597,8 @@ describe("parallel-merge: determineMergeOrder sequential", () => {
 
   it("uses sequential order as the default when no order arg provided", () => {
     const workers = [
-      makeWorker({ milestoneId: "M002", state: "stopped", completedUnits: 1 }),
-      makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 1 }),
+      makeWorker({ milestoneId: "M002", state: "stopped" }),
+      makeWorker({ milestoneId: "M001", state: "stopped" }),
     ];
     // Call with no second argument — should default to "sequential"
     const order = determineMergeOrder(workers);
@@ -614,9 +610,9 @@ describe("parallel-merge: determineMergeOrder by-completion", () => {
   it("returns milestones sorted by startedAt (earliest first)", () => {
     const now = Date.now();
     const workers = [
-      makeWorker({ milestoneId: "M003", state: "stopped", completedUnits: 1, startedAt: now - 30_000 }),
-      makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 1, startedAt: now - 90_000 }),
-      makeWorker({ milestoneId: "M002", state: "stopped", completedUnits: 1, startedAt: now - 60_000 }),
+      makeWorker({ milestoneId: "M003", state: "stopped", startedAt: now - 30_000 }),
+      makeWorker({ milestoneId: "M001", state: "stopped", startedAt: now - 90_000 }),
+      makeWorker({ milestoneId: "M002", state: "stopped", startedAt: now - 60_000 }),
     ];
     const order = determineMergeOrder(workers, "by-completion");
     assert.deepEqual(order, ["M001", "M002", "M003"]);
@@ -625,9 +621,9 @@ describe("parallel-merge: determineMergeOrder by-completion", () => {
   it("excludes paused workers from by-completion order", () => {
     const now = Date.now();
     const workers = [
-      makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 2, startedAt: now - 90_000 }),
-      makeWorker({ milestoneId: "M002", state: "paused",  completedUnits: 1, startedAt: now - 60_000 }),
-      makeWorker({ milestoneId: "M003", state: "stopped", completedUnits: 3, startedAt: now - 30_000 }),
+      makeWorker({ milestoneId: "M001", state: "stopped", startedAt: now - 90_000 }),
+      makeWorker({ milestoneId: "M002", state: "paused",  startedAt: now - 60_000 }),
+      makeWorker({ milestoneId: "M003", state: "stopped", startedAt: now - 30_000 }),
     ];
     const order = determineMergeOrder(workers, "by-completion");
     assert.deepEqual(order, ["M001", "M003"]);