gsd-pi 2.45.0-dev.fdcf73c → 2.46.0-dev.cc9d310

package/src/resources/extensions/gsd/tests/projection-regression.test.ts

@@ -0,0 +1,174 @@
+// GSD — projection renderer regression tests
+// Verifies that "done" vs "complete" status mismatch doesn't recur.
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { renderPlanContent, renderRoadmapContent } from '../workflow-projections.ts';
+import type { SliceRow, TaskRow } from '../gsd-db.ts';
+
+// ─── Helpers ─────────────────────────────────────────────────────────────
+
+function makeSliceRow(overrides?: Partial<SliceRow>): SliceRow {
+  return {
+    milestone_id: 'M001',
+    id: 'S01',
+    title: 'Test Slice',
+    status: 'pending',
+    risk: 'medium',
+    depends: [],
+    demo: 'Demo.',
+    created_at: '2026-01-01T00:00:00Z',
+    completed_at: null,
+    full_summary_md: '',
+    full_uat_md: '',
+    goal: 'Test goal',
+    success_criteria: '',
+    proof_level: '',
+    integration_closure: '',
+    observability_impact: '',
+    sequence: 0,
+    replan_triggered_at: null,
+    ...overrides,
+  };
+}
+
+function makeTaskRow(overrides?: Partial<TaskRow>): TaskRow {
+  return {
+    milestone_id: 'M001',
+    slice_id: 'S01',
+    id: 'T01',
+    title: 'Test Task',
+    status: 'pending',
+    one_liner: '',
+    narrative: '',
+    verification_result: '',
+    duration: '',
+    completed_at: null,
+    blocker_discovered: false,
+    deviations: '',
+    known_issues: '',
+    key_files: [],
+    key_decisions: [],
+    full_summary_md: '',
+    full_plan_md: '',
+    description: 'Test description',
+    estimate: '30m',
+    files: ['src/test.ts'],
+    verify: 'npm test',
+    inputs: [],
+    expected_output: [],
+    observability_impact: '',
+    sequence: 0,
+    ...overrides,
+  };
+}
+
+function makeMilestoneRow() {
+  return {
+    id: 'M001',
+    title: 'Test Milestone',
+    status: 'active',
+    depends_on: [],
+    created_at: '2026-01-01T00:00:00Z',
+    completed_at: null,
+    vision: 'Test vision',
+    success_criteria: [],
+    key_risks: [],
+    proof_strategy: [],
+    verification_contract: '',
+    verification_integration: '',
+    verification_operational: '',
+    verification_uat: '',
+    definition_of_done: [],
+    requirement_coverage: '',
+    boundary_map_markdown: '',
+  };
+}
+
+// ─── renderPlanContent: checkbox regression ──────────────────────────────
+
+test('renderPlanContent: task with status "complete" renders [x] checkbox', () => {
+  const slice = makeSliceRow();
+  const tasks = [makeTaskRow({ id: 'T01', status: 'complete', title: 'Completed Task' })];
+
+  const content = renderPlanContent(slice, tasks);
+
+  assert.match(content, /\[x\]\s+\*\*T01:/, 'complete task should have [x] checkbox');
+});
+
+test('renderPlanContent: task with status "done" renders [x] checkbox', () => {
+  const slice = makeSliceRow();
+  const tasks = [makeTaskRow({ id: 'T01', status: 'done', title: 'Done Task' })];
+
+  const content = renderPlanContent(slice, tasks);
+
+  assert.match(content, /\[x\]\s+\*\*T01:/, 'done task should have [x] checkbox');
+});
+
+test('renderPlanContent: task with status "pending" renders [ ] checkbox', () => {
+  const slice = makeSliceRow();
+  const tasks = [makeTaskRow({ id: 'T01', status: 'pending', title: 'Pending Task' })];
+
+  const content = renderPlanContent(slice, tasks);
+
+  assert.match(content, /\[ \]\s+\*\*T01:/, 'pending task should have [ ] checkbox');
+});
+
+test('renderPlanContent: mixed statuses render correct checkboxes', () => {
+  const slice = makeSliceRow();
+  const tasks = [
+    makeTaskRow({ id: 'T01', status: 'complete', title: 'Done One' }),
+    makeTaskRow({ id: 'T02', status: 'pending', title: 'Pending One' }),
+    makeTaskRow({ id: 'T03', status: 'done', title: 'Done Two' }),
+  ];
+
+  const content = renderPlanContent(slice, tasks);
+
+  assert.match(content, /\[x\]\s+\*\*T01:/, 'T01 (complete) should be checked');
+  assert.match(content, /\[ \]\s+\*\*T02:/, 'T02 (pending) should be unchecked');
+  assert.match(content, /\[x\]\s+\*\*T03:/, 'T03 (done) should be checked');
+});
+
+// ─── renderPlanContent: format regression (parsePlan compatibility) ──────
+
+test('renderPlanContent: format matches parsePlan regex **ID: title**', () => {
+  const slice = makeSliceRow();
+  const tasks = [makeTaskRow({ id: 'T01', status: 'pending', title: 'My Task' })];
+
+  const content = renderPlanContent(slice, tasks);
+
+  // parsePlan expects: **T01: My Task** (both ID and title inside bold)
+  // NOT: **T01:** My Task (only ID in bold)
+  assert.match(content, /\*\*T01: My Task\*\*/, 'ID and title should both be inside bold markers');
+});
+
+// ─── renderRoadmapContent: status regression ─────────────────────────────
+
+test('renderRoadmapContent: slice with status "complete" shows ✅', () => {
+  const milestone = makeMilestoneRow();
+  const slices = [makeSliceRow({ id: 'S01', status: 'complete' })];
+
+  const content = renderRoadmapContent(milestone, slices);
+
+  assert.ok(content.includes('✅'), 'complete slice should show ✅');
+});
+
+test('renderRoadmapContent: slice with status "done" shows ✅', () => {
+  const milestone = makeMilestoneRow();
+  const slices = [makeSliceRow({ id: 'S01', status: 'done' })];
+
+  const content = renderRoadmapContent(milestone, slices);
+
+  assert.ok(content.includes('✅'), 'done slice should show ✅');
+});
+
+test('renderRoadmapContent: slice with status "pending" shows ⬜', () => {
+  const milestone = makeMilestoneRow();
+  const slices = [makeSliceRow({ id: 'S01', status: 'pending' })];
+
+  const content = renderRoadmapContent(milestone, slices);
+
+  assert.ok(content.includes('⬜'), 'pending slice should show ⬜');
+});

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -58,17 +58,18 @@ test("guided-resume-task prompt preserves recovery state until work is supersede
   assert.doesNotMatch(prompt, /Delete the continue file after reading it/i);
 });
 
-// ─── Prompt migration: execute-task → gsd_task_complete ───────────────
+// ─── Prompt migration: execute-task → gsd_complete_task ───────────────
 
-test("execute-task prompt references gsd_task_complete tool", () => {
+test("execute-task prompt references gsd_complete_task tool", () => {
   const prompt = readPrompt("execute-task");
-  assert.match(prompt, /gsd_task_complete/);
+  assert.match(prompt, /gsd_complete_task/);
 });
 
-test("execute-task prompt does not instruct LLM to write summary file manually", () => {
+test("execute-task prompt instructs writing task summary before tool call", () => {
   const prompt = readPrompt("execute-task");
-  // Should not contain "Write {{taskSummaryPath}}" as an action instruction
-  assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{taskSummaryPath\}\}`?/m);
+  // The prompt instructs writing the summary file AND calling the tool
+  assert.match(prompt, /\{\{taskSummaryPath\}\}/);
+  assert.match(prompt, /gsd_complete_task/);
 });
 
 test("execute-task prompt does not instruct LLM to toggle checkboxes manually", () => {
@@ -93,12 +94,11 @@ test("guided-execute-task prompt does not instruct manual file write", () => {
   assert.doesNotMatch(prompt, /Write `?\{\{taskId\}\}-SUMMARY\.md`?.*mark it done/i);
 });
 
-// ─── Prompt migration: complete-slice → gsd_slice_complete ────────────
-// These tests are for T02 — expected to fail until that task runs.
+// ─── Prompt migration: complete-slice → gsd_complete_slice ────────────
 
-test("complete-slice prompt references gsd_slice_complete tool", () => {
+test("complete-slice prompt references gsd_complete_slice tool", () => {
   const prompt = readPrompt("complete-slice");
-  assert.match(prompt, /gsd_slice_complete/);
+  assert.match(prompt, /gsd_complete_slice/);
 });
 
 test("complete-slice prompt does not instruct LLM to toggle checkboxes manually", () => {
@@ -111,10 +111,12 @@ test("guided-complete-slice prompt references gsd_slice_complete tool", () => {
   assert.match(prompt, /gsd_slice_complete/);
 });
 
-test("complete-slice prompt does not instruct LLM to write summary/UAT files manually", () => {
+test("complete-slice prompt instructs writing summary and UAT files before tool call", () => {
   const prompt = readPrompt("complete-slice");
-  assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{sliceSummaryPath\}\}/m);
-  assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{sliceUatPath\}\}/m);
+  // The prompt instructs writing the summary AND UAT files, then calling the tool
+  assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
+  assert.match(prompt, /\{\{sliceUatPath\}\}/);
+  assert.match(prompt, /gsd_complete_slice/);
 });
 
 test("complete-slice prompt preserves decisions and knowledge review steps", () => {
@@ -127,7 +129,6 @@ test("complete-slice prompt still contains template variables for context", () =
   const prompt = readPrompt("complete-slice");
   assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
   assert.match(prompt, /\{\{sliceUatPath\}\}/);
-  assert.match(prompt, /\{\{roadmapPath\}\}/);
 });
 
 test("plan-milestone prompt references DB-backed planning tool and explicitly forbids manual roadmap writes", () => {

package/src/resources/extensions/gsd/tests/reopen-slice.test.ts

@@ -0,0 +1,155 @@
+// GSD — reopen-slice handler tests
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getSlice,
+  getSliceTasks,
+} from '../gsd-db.ts';
+import { handleReopenSlice } from '../tools/reopen-slice.ts';
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-reopen-slice-'));
+  mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+function seedCompleteSlice(): void {
+  insertMilestone({ id: 'M001', title: 'Test Milestone', status: 'active' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice', status: 'complete' });
+  insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Task One', status: 'complete' });
+  insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Task Two', status: 'complete' });
+}
+
+// ─── Success path ────────────────────────────────────────────────────────
+
+test('handleReopenSlice: resets a complete slice to in_progress and all tasks to pending', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    seedCompleteSlice();
+
+    const result = await handleReopenSlice({
+      milestoneId: 'M001',
+      sliceId: 'S01',
+      reason: 'need to redo after requirements change',
+    }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.equal(result.sliceId, 'S01');
+    assert.equal(result.tasksReset, 2, 'should report 2 tasks reset');
+
+    const slice = getSlice('M001', 'S01');
+    assert.ok(slice, 'slice should still exist');
+    assert.equal(slice!.status, 'in_progress', 'slice status should be in_progress');
+
+    const tasks = getSliceTasks('M001', 'S01');
+    assert.equal(tasks.length, 2, 'both tasks should still exist');
+    assert.ok(tasks.every(t => t.status === 'pending'), 'all tasks should be pending');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenSlice: works with a single task', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', status: 'complete' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete' });
+
+    const result = await handleReopenSlice({ milestoneId: 'M001', sliceId: 'S01' }, base);
+
+    assert.ok(!('error' in result));
+    assert.equal(result.tasksReset, 1);
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Failure paths ───────────────────────────────────────────────────────
+
+test('handleReopenSlice: rejects empty sliceId', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    const result = await handleReopenSlice({ milestoneId: 'M001', sliceId: '' }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /sliceId/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenSlice: rejects non-existent milestone', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    const result = await handleReopenSlice({ milestoneId: 'M999', sliceId: 'S01' }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /milestone not found/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenSlice: rejects slice in a closed milestone', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Done', status: 'complete' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', status: 'complete' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete' });
+
+    const result = await handleReopenSlice({ milestoneId: 'M001', sliceId: 'S01' }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /closed milestone/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenSlice: rejects reopening a slice that is not complete', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Active', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', status: 'in_progress' });
+
+    const result = await handleReopenSlice({ milestoneId: 'M001', sliceId: 'S01' }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /not complete/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenSlice: rejects non-existent slice', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Active', status: 'active' });
+
+    const result = await handleReopenSlice({ milestoneId: 'M001', sliceId: 'S99' }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /slice not found/);
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/reopen-task.test.ts

@@ -0,0 +1,165 @@
+// GSD — reopen-task handler tests
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getTask,
+} from '../gsd-db.ts';
+import { handleReopenTask } from '../tools/reopen-task.ts';
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-reopen-task-'));
+  mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+function seedCompleteTask(): void {
+  insertMilestone({ id: 'M001', title: 'Test Milestone', status: 'active' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice', status: 'in_progress' });
+  insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Task One', status: 'complete' });
+  insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Task Two', status: 'pending' });
+}
+
+// ─── Success path ────────────────────────────────────────────────────────
+
+test('handleReopenTask: resets a complete task to pending', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    seedCompleteTask();
+
+    const result = await handleReopenTask({
+      milestoneId: 'M001',
+      sliceId: 'S01',
+      taskId: 'T01',
+      reason: 'verification failed after merge',
+    }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.equal(result.taskId, 'T01');
+
+    const task = getTask('M001', 'S01', 'T01');
+    assert.ok(task, 'task should still exist');
+    assert.equal(task!.status, 'pending', 'task status should be reset to pending');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenTask: does not affect other tasks in the slice', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    seedCompleteTask();
+
+    await handleReopenTask({ milestoneId: 'M001', sliceId: 'S01', taskId: 'T01' }, base);
+
+    const t02 = getTask('M001', 'S01', 'T02');
+    assert.ok(t02, 'T02 should still exist');
+    assert.equal(t02!.status, 'pending', 'T02 status should be unchanged');
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Failure paths ───────────────────────────────────────────────────────
+
+test('handleReopenTask: rejects empty taskId', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    const result = await handleReopenTask({ milestoneId: 'M001', sliceId: 'S01', taskId: '' }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /taskId/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenTask: rejects non-existent milestone', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    const result = await handleReopenTask({ milestoneId: 'M999', sliceId: 'S01', taskId: 'T01' }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /milestone not found/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenTask: rejects task in a closed milestone', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Done', status: 'complete' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', status: 'complete' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete' });
+
+    const result = await handleReopenTask({ milestoneId: 'M001', sliceId: 'S01', taskId: 'T01' }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /closed milestone/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenTask: rejects task inside a closed slice', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Active', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', status: 'complete' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete' });
+
+    const result = await handleReopenTask({ milestoneId: 'M001', sliceId: 'S01', taskId: 'T01' }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /closed slice/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenTask: rejects reopening a task that is not complete', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    seedCompleteTask();
+
+    const result = await handleReopenTask({ milestoneId: 'M001', sliceId: 'S01', taskId: 'T02' }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /not complete/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenTask: rejects non-existent task', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Active', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', status: 'in_progress' });
+
+    const result = await handleReopenTask({ milestoneId: 'M001', sliceId: 'S01', taskId: 'T99' }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /task not found/);
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/session-lock-regression.test.ts

@@ -103,7 +103,7 @@ describe('session-lock-regression', async () => {
     try {
       acquireSessionLock(base);
 
-      updateSessionLock(base, 'execute-task', 'M001/S01/T01', 5, '/tmp/session.json');
+      updateSessionLock(base, 'execute-task', 'M001/S01/T01', '/tmp/session.json');
 
       const data = readSessionLockData(base);
       assert.ok(data !== null, 'lock data readable after update');
@@ -111,7 +111,6 @@ describe('session-lock-regression', async () => {
         assert.deepStrictEqual(data.pid, process.pid, 'lock data has correct PID');
         assert.deepStrictEqual(data.unitType, 'execute-task', 'lock data has correct unit type');
         assert.deepStrictEqual(data.unitId, 'M001/S01/T01', 'lock data has correct unit ID');
-        assert.deepStrictEqual(data.completedUnits, 5, 'lock data has correct completed count');
         assert.deepStrictEqual(data.sessionFile, '/tmp/session.json', 'lock data has session file');
       }
 
@@ -136,7 +135,6 @@ describe('session-lock-regression', async () => {
         unitType: 'execute-task',
         unitId: 'M001/S01/T01',
         unitStartedAt: new Date(Date.now() - 3600000).toISOString(),
-        completedUnits: 3,
       };
       writeFileSync(lockFile, JSON.stringify(staleLock, null, 2));
 
@@ -233,7 +231,6 @@ describe('session-lock-regression', async () => {
         unitType: 'execute-task',
         unitId: 'M001/S01/T01',
         unitStartedAt: new Date().toISOString(),
-        completedUnits: 0,
       }, null, 2));
 
       const status = getSessionLockStatus(base);

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

@@ -64,7 +64,7 @@ test("stopAutoRemote cleans up stale lock (dead PID) and returns found:false", (
   const base = makeTmpBase();
   try {
     // Write a lock with a PID that doesn't exist
-    writeLock(base, "execute-task", "M001/S01/T01", 3);
+    writeLock(base, "execute-task", "M001/S01/T01");
     // Overwrite PID to a dead one
     const lock = readCrashLock(base)!;
     const staleData = { ...lock, pid: 999999999 };
@@ -111,7 +111,6 @@ test("stopAutoRemote sends SIGTERM to a live process and returns found:true", {
       unitType: "execute-task",
       unitId: "M001/S01/T01",
       unitStartedAt: new Date().toISOString(),
-      completedUnits: 0,
     };
     writeFileSync(join(base, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2), "utf-8");
 
@@ -143,7 +142,7 @@ test("lock file should be discoverable at project root, not worktree path", () =
 
   try {
     // Simulate: auto-mode writes lock to project root (the fix)
-    writeLock(projectRoot, "execute-task", "M001/S01/T01", 0);
+    writeLock(projectRoot, "execute-task", "M001/S01/T01");
 
     // Second terminal checks project root — should find the lock
     const lock = readCrashLock(projectRoot);