gsd-pi 2.45.0 → 2.46.0-dev.cc9d310

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);

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

@@ -0,0 +1,122 @@
+// GSD Extension — sync-lock unit tests
+// Tests acquireSyncLock() and releaseSyncLock().
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { acquireSyncLock, releaseSyncLock } from '../sync-lock.ts';
+
+function tempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-sync-lock-'));
+}
+
+function cleanupDir(dirPath: string): void {
+  try { fs.rmSync(dirPath, { recursive: true, force: true }); } catch { /* best effort */ }
+}
+
+// ─── acquireSyncLock ─────────────────────────────────────────────────────
+
+test('sync-lock: acquireSyncLock returns { acquired: true } when no lock exists', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  try {
+    const result = acquireSyncLock(base);
+    assert.strictEqual(result.acquired, true);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('sync-lock: acquireSyncLock creates lock file at .gsd/sync.lock', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  try {
+    acquireSyncLock(base);
+    const lockPath = path.join(base, '.gsd', 'sync.lock');
+    assert.ok(fs.existsSync(lockPath), 'sync.lock should exist after acquire');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('sync-lock: lock file contains pid and acquired_at fields', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  try {
+    acquireSyncLock(base);
+    const lockPath = path.join(base, '.gsd', 'sync.lock');
+    const content = JSON.parse(fs.readFileSync(lockPath, 'utf-8'));
+    assert.strictEqual(typeof content.pid, 'number');
+    assert.strictEqual(typeof content.acquired_at, 'string');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── releaseSyncLock ─────────────────────────────────────────────────────
+
+test('sync-lock: releaseSyncLock removes lock file', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  try {
+    acquireSyncLock(base);
+    const lockPath = path.join(base, '.gsd', 'sync.lock');
+    assert.ok(fs.existsSync(lockPath), 'lock file should exist before release');
+    releaseSyncLock(base);
+    assert.ok(!fs.existsSync(lockPath), 'lock file should not exist after release');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('sync-lock: releaseSyncLock is a no-op when no lock file exists', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  try {
+    // Should not throw
+    releaseSyncLock(base);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── acquire → release → re-acquire round-trip ───────────────────────────
+
+test('sync-lock: can re-acquire after release', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  try {
+    const r1 = acquireSyncLock(base);
+    assert.strictEqual(r1.acquired, true, 'first acquire should succeed');
+    releaseSyncLock(base);
+    const r2 = acquireSyncLock(base);
+    assert.strictEqual(r2.acquired, true, 're-acquire after release should succeed');
+    releaseSyncLock(base);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── stale lock override ─────────────────────────────────────────────────
+
+test('sync-lock: overrides stale lock file (mtime backdated)', (t) => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  const lockPath = path.join(base, '.gsd', 'sync.lock');
+  try {
+    // Write a lock file with a very old mtime (simulating staleness)
+    fs.writeFileSync(lockPath, JSON.stringify({ pid: 99999, acquired_at: new Date(0).toISOString() }));
+    // Backdate mtime by 2 minutes
+    const staleTime = new Date(Date.now() - 120_000);
+    fs.utimesSync(lockPath, staleTime, staleTime);
+
+    // Should override stale lock and acquire
+    const result = acquireSyncLock(base, 500);
+    assert.strictEqual(result.acquired, true, 'should acquire over stale lock');
+    releaseSyncLock(base);
+  } finally {
+    cleanupDir(base);
+  }
+});

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

@@ -0,0 +1,175 @@
+// GSD — unit-ownership tests
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  claimUnit,
+  releaseUnit,
+  getOwner,
+  checkOwnership,
+  taskUnitKey,
+  sliceUnitKey,
+} from '../unit-ownership.ts';
+
+function makeTmpBase(): string {
+  return mkdtempSync(join(tmpdir(), 'gsd-ownership-'));
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+// ─── Key builders ────────────────────────────────────────────────────────
+
+test('taskUnitKey: builds correct key', () => {
+  assert.equal(taskUnitKey('M001', 'S01', 'T01'), 'M001/S01/T01');
+});
+
+test('sliceUnitKey: builds correct key', () => {
+  assert.equal(sliceUnitKey('M001', 'S01'), 'M001/S01');
+});
+
+// ─── Claim / get / release ───────────────────────────────────────────────
+
+test('claimUnit: creates claim file and records agent', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'executor-01');
+
+    assert.ok(existsSync(join(base, '.gsd', 'unit-claims.json')), 'claim file should exist');
+    assert.equal(getOwner(base, 'M001/S01/T01'), 'executor-01');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('claimUnit: overwrites existing claim (last writer wins)', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'executor-01');
+    claimUnit(base, 'M001/S01/T01', 'executor-02');
+
+    assert.equal(getOwner(base, 'M001/S01/T01'), 'executor-02');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('claimUnit: multiple units can be claimed independently', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+    claimUnit(base, 'M001/S01/T02', 'agent-b');
+
+    assert.equal(getOwner(base, 'M001/S01/T01'), 'agent-a');
+    assert.equal(getOwner(base, 'M001/S01/T02'), 'agent-b');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('getOwner: returns null when no claim file exists', () => {
+  const base = makeTmpBase();
+  try {
+    assert.equal(getOwner(base, 'M001/S01/T01'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('getOwner: returns null for unclaimed unit', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+    assert.equal(getOwner(base, 'M001/S01/T99'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('releaseUnit: removes claim', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+    releaseUnit(base, 'M001/S01/T01');
+
+    assert.equal(getOwner(base, 'M001/S01/T01'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('releaseUnit: no-op for non-existent claim', () => {
+  const base = makeTmpBase();
+  try {
+    // Should not throw
+    releaseUnit(base, 'M001/S01/T01');
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── checkOwnership ──────────────────────────────────────────────────────
+
+test('checkOwnership: returns null when no actorName provided (opt-in)', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+
+    // No actorName → ownership not enforced
+    assert.equal(checkOwnership(base, 'M001/S01/T01', undefined), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('checkOwnership: returns null when no claim file exists', () => {
+  const base = makeTmpBase();
+  try {
+    assert.equal(checkOwnership(base, 'M001/S01/T01', 'agent-a'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('checkOwnership: returns null when unit is unclaimed', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+
+    // Different unit, unclaimed
+    assert.equal(checkOwnership(base, 'M001/S01/T99', 'agent-b'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('checkOwnership: returns null when actor matches owner', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+
+    assert.equal(checkOwnership(base, 'M001/S01/T01', 'agent-a'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('checkOwnership: returns error string when actor does not match owner', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+
+    const err = checkOwnership(base, 'M001/S01/T01', 'agent-b');
+    assert.ok(err !== null, 'should return error');
+    assert.match(err!, /owned by agent-a/);
+    assert.match(err!, /not agent-b/);
+  } finally {
+    cleanup(base);
+  }
+});