gsd-pi 2.45.0-dev.fdcf73c → 2.46.0-dev.5c2b8ed

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

package/src/resources/extensions/gsd/tests/workflow-events.test.ts

@@ -0,0 +1,205 @@
+// GSD Extension — workflow-events unit tests
+// Tests appendEvent, readEvents, findForkPoint, compactMilestoneEvents.
+
+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 {
+  appendEvent,
+  readEvents,
+  findForkPoint,
+  compactMilestoneEvents,
+  type WorkflowEvent,
+} from '../workflow-events.ts';
+
+function tempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-events-'));
+}
+
+function cleanupDir(dirPath: string): void {
+  try { fs.rmSync(dirPath, { recursive: true, force: true }); } catch { /* best effort */ }
+}
+
+function makeEvent(cmd: string, params: Record<string, unknown> = {}): Omit<WorkflowEvent, 'hash' | 'session_id'> {
+  return { cmd, params, ts: new Date().toISOString(), actor: 'agent' };
+}
+
+// ─── appendEvent ─────────────────────────────────────────────────────────
+
+test('workflow-events: appendEvent creates .gsd dir and event-log.jsonl', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+    assert.ok(fs.existsSync(path.join(base, '.gsd', 'event-log.jsonl')));
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: appendEvent writes valid JSON line', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+    const content = fs.readFileSync(path.join(base, '.gsd', 'event-log.jsonl'), 'utf-8');
+    const lines = content.trim().split('\n');
+    assert.strictEqual(lines.length, 1);
+    const parsed = JSON.parse(lines[0]!) as WorkflowEvent;
+    assert.strictEqual(parsed.cmd, 'complete-task');
+    assert.strictEqual(parsed.actor, 'agent');
+    assert.strictEqual(typeof parsed.hash, 'string');
+    assert.strictEqual(parsed.hash.length, 16);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: appendEvent appends multiple events', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { taskId: 'T01' }));
+    appendEvent(base, makeEvent('complete-slice', { sliceId: 'S01' }));
+    const events = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.strictEqual(events.length, 2);
+    assert.strictEqual(events[0]!.cmd, 'complete-task');
+    assert.strictEqual(events[1]!.cmd, 'complete-slice');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: same cmd+params → same hash (deterministic)', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('plan-task', { milestoneId: 'M001', sliceId: 'S01' }));
+    appendEvent(base, makeEvent('plan-task', { milestoneId: 'M001', sliceId: 'S01' }));
+    const events = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.strictEqual(events[0]!.hash, events[1]!.hash, 'identical cmd+params produce identical hash');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: different params → different hash', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { taskId: 'T01' }));
+    appendEvent(base, makeEvent('complete-task', { taskId: 'T02' }));
+    const events = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.notStrictEqual(events[0]!.hash, events[1]!.hash, 'different params produce different hash');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── readEvents ──────────────────────────────────────────────────────────
+
+test('workflow-events: readEvents returns [] for non-existent file', () => {
+  const result = readEvents('/nonexistent/path/event-log.jsonl');
+  assert.deepStrictEqual(result, []);
+});
+
+test('workflow-events: readEvents skips corrupted lines', () => {
+  const base = tempDir();
+  try {
+    fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+    const logPath = path.join(base, '.gsd', 'event-log.jsonl');
+    // Write a valid line, a corrupted line, and another valid line
+    fs.writeFileSync(logPath,
+      '{"cmd":"complete-task","params":{},"ts":"2026-01-01T00:00:00Z","hash":"abcd1234abcd1234","actor":"agent"}\n' +
+      'NOT VALID JSON {{{{\n' +
+      '{"cmd":"plan-task","params":{},"ts":"2026-01-01T00:00:01Z","hash":"1234abcd1234abcd","actor":"system"}\n',
+    );
+    const events = readEvents(logPath);
+    assert.strictEqual(events.length, 2, 'should return 2 valid events, skipping the corrupted line');
+    assert.strictEqual(events[0]!.cmd, 'complete-task');
+    assert.strictEqual(events[1]!.cmd, 'plan-task');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── findForkPoint ───────────────────────────────────────────────────────
+
+test('workflow-events: findForkPoint returns -1 for two empty logs', () => {
+  assert.strictEqual(findForkPoint([], []), -1);
+});
+
+test('workflow-events: findForkPoint returns -1 when first events differ', () => {
+  const e1 = { cmd: 'a', params: {}, ts: '', hash: 'hash1', actor: 'agent' } as WorkflowEvent;
+  const e2 = { cmd: 'b', params: {}, ts: '', hash: 'hash2', actor: 'agent' } as WorkflowEvent;
+  assert.strictEqual(findForkPoint([e1], [e2]), -1);
+});
+
+test('workflow-events: findForkPoint returns 0 when only first event is common', () => {
+  const common = { cmd: 'a', params: {}, ts: '', hash: 'hash1', actor: 'agent' } as WorkflowEvent;
+  const eA = { cmd: 'b', params: {}, ts: '', hash: 'hash2', actor: 'agent' } as WorkflowEvent;
+  const eB = { cmd: 'c', params: {}, ts: '', hash: 'hash3', actor: 'agent' } as WorkflowEvent;
+  // logA: [common, eA], logB: [common, eB]
+  assert.strictEqual(findForkPoint([common, eA], [common, eB]), 0);
+});
+
+test('workflow-events: findForkPoint returns last common index for prefix relationship', () => {
+  const e1 = { cmd: 'a', params: {}, ts: '', hash: 'h1', actor: 'agent' } as WorkflowEvent;
+  const e2 = { cmd: 'b', params: {}, ts: '', hash: 'h2', actor: 'agent' } as WorkflowEvent;
+  const e3 = { cmd: 'c', params: {}, ts: '', hash: 'h3', actor: 'agent' } as WorkflowEvent;
+  // logA is a prefix of logB → fork point is last index of logA
+  assert.strictEqual(findForkPoint([e1, e2], [e1, e2, e3]), 1);
+});
+
+test('workflow-events: findForkPoint handles equal logs', () => {
+  const e1 = { cmd: 'a', params: {}, ts: '', hash: 'h1', actor: 'agent' } as WorkflowEvent;
+  const e2 = { cmd: 'b', params: {}, ts: '', hash: 'h2', actor: 'agent' } as WorkflowEvent;
+  assert.strictEqual(findForkPoint([e1, e2], [e1, e2]), 1);
+});
+
+// ─── compactMilestoneEvents ──────────────────────────────────────────────
+
+test('workflow-events: compactMilestoneEvents returns { archived: 0 } when no matching events', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M002', taskId: 'T01' }));
+    const result = compactMilestoneEvents(base, 'M001');
+    assert.strictEqual(result.archived, 0);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: compactMilestoneEvents archives milestone events', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T02' }));
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M002', taskId: 'T03' }));
+
+    const result = compactMilestoneEvents(base, 'M001');
+    assert.strictEqual(result.archived, 2, 'should archive 2 M001 events');
+
+    // Archive file should exist
+    const archivePath = path.join(base, '.gsd', 'event-log-M001.jsonl.archived');
+    assert.ok(fs.existsSync(archivePath), 'archive file should exist');
+    const archived = readEvents(archivePath);
+    assert.strictEqual(archived.length, 2, 'archive file should have 2 events');
+
+    // Active log should retain only M002 event
+    const active = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.strictEqual(active.length, 1, 'active log should have 1 remaining event');
+    assert.strictEqual((active[0]!.params as { milestoneId?: string }).milestoneId, 'M002');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: compactMilestoneEvents empties active log when all events are from milestone', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+    compactMilestoneEvents(base, 'M001');
+    const active = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.strictEqual(active.length, 0, 'active log should be empty after full compact');
+  } finally {
+    cleanupDir(base);
+  }
+});