gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0

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

@@ -0,0 +1,353 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createAutoOrchestrator } from "../auto/orchestrator.js";
+import type { AutoOrchestratorDeps } from "../auto/contracts.js";
+
+function makeDeps(overrides: Partial<AutoOrchestratorDeps> = {}): { deps: AutoOrchestratorDeps; calls: string[] } {
+  const calls: string[] = [];
+
+  const deps: AutoOrchestratorDeps = {
+    dispatch: {
+      async decideNextUnit() {
+        calls.push("dispatch.decide");
+        return { unitType: "execute-task", unitId: "T01", reason: "ready", preconditions: [] };
+      },
+    },
+    recovery: {
+      async classifyAndRecover() {
+        calls.push("recovery.classify");
+        return { action: "stop", reason: "fatal" };
+      },
+    },
+    worktree: {
+      async prepareForUnit() { calls.push("worktree.prepare"); },
+      async syncAfterUnit() { calls.push("worktree.sync"); },
+      async cleanupOnStop() { calls.push("worktree.cleanup"); },
+    },
+    health: {
+      async preAdvanceGate() {
+        calls.push("health.pre");
+        return { allow: true };
+      },
+      async postAdvanceRecord() { calls.push("health.post"); },
+    },
+    runtime: {
+      async ensureLockOwnership() { calls.push("runtime.lock"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    notifications: {
+      async notifyLifecycle(event) { calls.push(`notify:${event.name}`); },
+    },
+  };
+
+  return { deps: { ...deps, ...overrides }, calls };
+}
+
+test("start() advances and records active unit", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+
+  assert.equal(result.kind, "advanced");
+  const status = orchestrator.getStatus();
+  assert.equal(status.phase, "running");
+  assert.deepEqual(status.activeUnit, { unitType: "execute-task", unitId: "T01" });
+  assert.ok(calls.includes("journal:start"));
+  assert.ok(calls.includes("journal:advance"));
+});
+
+test("advance() returns blocked when health gate denies", async () => {
+  const { deps } = makeDeps({
+    health: {
+      async preAdvanceGate() { return { allow: false, reason: "doctor-block" }; },
+      async postAdvanceRecord() {},
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "blocked");
+  assert.equal(result.reason, "doctor-block");
+});
+
+test("advance() stops when dispatch has no next unit", async () => {
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() { return null; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "stopped");
+  assert.equal(orchestrator.getStatus().phase, "stopped");
+});
+
+test("advance() uses recovery on error", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("lock lost"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "escalate", reason: "needs manual" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "error");
+  assert.equal(result.reason, "needs manual");
+  assert.equal(orchestrator.getStatus().phase, "error");
+  assert.ok(calls.includes("journal:advance-error"));
+});
+
+test("advance() is idempotent for the same active unit", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const second = await orchestrator.advance();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(second.kind, "blocked");
+  assert.equal(second.reason, "idempotent advance: unit already active");
+
+  const prepareCalls = calls.filter((c) => c === "worktree.prepare").length;
+  assert.equal(prepareCalls, 1);
+});
+
+test("resume() re-enters running flow via advance", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.resume();
+
+  assert.equal(result.kind, "advanced");
+  assert.equal(orchestrator.getStatus().phase, "running");
+});
+
+test("resume() clears idempotent lock and allows re-advance", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const blocked = await orchestrator.advance();
+  const resumed = await orchestrator.resume();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(blocked.kind, "blocked");
+  assert.equal(resumed.kind, "advanced");
+});
+
+test("transitionCount increases across lifecycle transitions", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const before = orchestrator.getStatus().transitionCount;
+  await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+  const afterStart = orchestrator.getStatus().transitionCount;
+  await orchestrator.stop("done");
+  const afterStop = orchestrator.getStatus().transitionCount;
+
+  assert.ok(afterStart > before);
+  assert.ok(afterStop > afterStart);
+});
+
+test("stop() clears idempotent unit lock so advance can run again", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const blocked = await orchestrator.advance();
+  const stopped = await orchestrator.stop("reset");
+  const second = await orchestrator.advance();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(blocked.kind, "blocked");
+  assert.equal(stopped.kind, "stopped");
+  assert.equal(second.kind, "advanced");
+});
+
+test("advance() stopped clears previous activeUnit", async () => {
+  let first = true;
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() {
+        if (first) {
+          first = false;
+          return { unitType: "execute-task", unitId: "T01", reason: "ready", preconditions: [] };
+        }
+        return null;
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  const stopped = await orchestrator.advance();
+
+  assert.equal(stopped.kind, "stopped");
+  assert.equal(orchestrator.getStatus().activeUnit, undefined);
+});
+
+test("recovery stop clears activeUnit", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("boom"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "stop", reason: "fatal" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "stopped");
+  assert.equal(orchestrator.getStatus().activeUnit, undefined);
+  assert.ok(calls.includes("journal:advance-stopped"));
+  assert.ok(calls.includes("notify:stopped"));
+  assert.ok(!calls.includes("notify:error"));
+});
+
+test("recovery retry maps to paused result", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("boom"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "retry", reason: "transient" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "paused");
+  assert.equal(result.reason, "transient");
+  assert.equal(orchestrator.getStatus().phase, "paused");
+  assert.ok(calls.includes("journal:advance-paused"));
+  assert.ok(calls.includes("notify:pause"));
+});
+
+test("getStatus() returns defensive copy of activeUnit", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  const snap1 = orchestrator.getStatus();
+  if (snap1.activeUnit) snap1.activeUnit.unitId = "MUTATED";
+  const snap2 = orchestrator.getStatus();
+
+  assert.equal(snap2.activeUnit?.unitId, "T01");
+});
+
+test("start() clears prior idempotent lock", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  const blocked = await orchestrator.advance();
+  const restarted = await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+
+  assert.equal(blocked.kind, "blocked");
+  assert.equal(restarted.kind, "advanced");
+});
+
+test("error path emits error notification", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("boom"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "escalate", reason: "needs manual" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+
+  assert.ok(calls.includes("notify:error"));
+});
+
+test("blocked path journals advance-blocked", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  await orchestrator.advance();
+
+  assert.ok(calls.includes("journal:advance-blocked"));
+});
+
+test("health post hook runs on blocked result", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  await orchestrator.advance();
+
+  assert.ok(calls.includes("health.post"));
+});
+
+test("start() emits start notification", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+
+  assert.ok(calls.includes("notify:start"));
+});
+
+test("resume() emits resume notification", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.resume();
+
+  assert.ok(calls.includes("notify:resume"));
+});
+
+test("stopped with no remaining units clears idempotent lock for next advance", async () => {
+  let callCount = 0;
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() {
+        callCount += 1;
+        if (callCount === 2) return null;
+        return { unitType: "execute-task", unitId: "T01", reason: "ready", preconditions: [] };
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const stopped = await orchestrator.advance();
+  const after = await orchestrator.advance();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(stopped.kind, "stopped");
+  assert.equal(after.kind, "advanced");
+});
+
+test("stop() cleans up worktree and transitions to stopped", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.stop("user-request");
+
+  assert.equal(result.kind, "stopped");
+  assert.equal(orchestrator.getStatus().phase, "stopped");
+  assert.ok(calls.includes("worktree.cleanup"));
+  assert.ok(calls.includes("journal:stop"));
+  assert.ok(calls.includes("notify:stop"));
+});

package/src/resources/extensions/gsd/tests/auto-runtime-state.test.ts

@@ -0,0 +1,39 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { autoSession, getAutoRuntimeSnapshot } from "../auto-runtime-state.ts";
+
+test("getAutoRuntimeSnapshot includes orchestration phase when available", () => {
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = "/tmp/project";
+  autoSession.orchestration = {
+    async start() { return { kind: "advanced" as const }; },
+    async advance() { return { kind: "advanced" as const }; },
+    async resume() { return { kind: "advanced" as const }; },
+    async stop() { return { kind: "stopped" as const }; },
+    getStatus() {
+      return { phase: "running" as const, transitionCount: 3, lastTransitionAt: 123 };
+    },
+  };
+
+  const snap = getAutoRuntimeSnapshot();
+
+  assert.equal(snap.active, true);
+  assert.equal(snap.basePath, "/tmp/project");
+  assert.equal(snap.orchestrationPhase, "running");
+  assert.equal(snap.orchestrationTransitionCount, 3);
+  assert.equal(snap.orchestrationLastTransitionAt, 123);
+
+  autoSession.reset();
+});
+
+test("getAutoRuntimeSnapshot omits orchestration phase when seam not wired", () => {
+  autoSession.reset();
+
+  const snap = getAutoRuntimeSnapshot();
+
+  assert.equal(snap.orchestrationPhase, undefined);
+  assert.equal(snap.orchestrationTransitionCount, undefined);
+  assert.equal(snap.orchestrationLastTransitionAt, undefined);
+});

package/src/resources/extensions/gsd/tests/auto-session-encapsulation.test.ts

@@ -201,6 +201,9 @@ test("AutoSession.toJSON() includes key diagnostic properties", () => {
     "basePath",
     "currentMilestoneId",
     "currentUnit",
+    "orchestrationPhase",
+    "orchestrationTransitionCount",
+    "orchestrationLastTransitionAt",
   ];
 
   const missing = requiredDiagnostics.filter(prop => !toJSONBody.includes(prop));

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

@@ -1,3 +1,5 @@
+// GSD Extension - Database regression tests.
+
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 import * as fs from 'node:fs';
@@ -29,7 +31,10 @@ import {
   getTask,
   getSliceTasks,
   checkpointDatabase,
+  refreshOpenDatabaseFromDisk,
+  tryCreateMemoriesFts,
 } from '../gsd-db.ts';
+import { _resetLogs, peekLogs, setStderrLoggingEnabled } from '../workflow-logger.ts';
 
 const _require = createRequire(import.meta.url);
 
@@ -910,6 +915,31 @@ describe('gsd-db', () => {
     closeDatabase();
   });
 
+  test('gsd-db: FTS5 unavailable warning normalizes provider typo', () => {
+    const previousStderr = setStderrLoggingEnabled(false);
+    _resetLogs();
+    try {
+      const ok = tryCreateMemoriesFts({
+        exec(): void {
+          throw new Error('no such moduel : fts5');
+        },
+        prepare(): never {
+          throw new Error('prepare should not be called');
+        },
+        close(): void {},
+      });
+
+      assert.equal(ok, false, 'FTS5 creation should report fallback');
+      const warning = peekLogs().find((entry) => entry.component === 'db' && entry.message.includes('FTS5 unavailable'));
+      assert.ok(warning, 'FTS5 fallback warning should be logged');
+      assert.match(warning!.message, /no such module: fts5/);
+      assert.doesNotMatch(warning!.message, /moduel/);
+    } finally {
+      _resetLogs();
+      setStderrLoggingEnabled(previousStderr);
+    }
+  });
+
   // ─── checkpointDatabase ────────────────────────────────────────────────────
 
   describe('checkpointDatabase', () => {
@@ -952,6 +982,71 @@ describe('gsd-db', () => {
     });
   });
 
+  // ─── refreshOpenDatabaseFromDisk ───────────────────────────────────────────
+
+  describe('refreshOpenDatabaseFromDisk', () => {
+    test('refreshOpenDatabaseFromDisk: reopens the active file-backed database and sees external writes', (t) => {
+      const dbPath = tempDbPath();
+      t.after(() => cleanup(dbPath));
+
+      openDatabase(dbPath);
+      insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+      insertSlice({
+        id: 'S01',
+        milestoneId: 'M001',
+        title: 'Slice 1',
+        status: 'pending',
+        sequence: 1,
+      });
+      insertTask({
+        id: 'T01',
+        milestoneId: 'M001',
+        sliceId: 'S01',
+        title: 'Task 1',
+        status: 'pending',
+        sequence: 1,
+      });
+
+      const adapterBefore = _getAdapter()!;
+
+      const externalDb = openRawSqliteForTest(dbPath);
+      try {
+        externalDb.exec(`
+          INSERT INTO tasks (milestone_id, slice_id, id, title, status, sequence)
+          VALUES ('M001', 'S01', 'T02', 'Task 2', 'pending', 2)
+        `);
+      } finally {
+        externalDb.close();
+      }
+
+      const visibleBeforeRefresh = getSliceTasks('M001', 'S01').map(task => task.id);
+      assert.ok(visibleBeforeRefresh.includes('T01'));
+
+      assert.equal(refreshOpenDatabaseFromDisk(), true);
+      assert.notEqual(_getAdapter(), adapterBefore, 'refresh must replace the active adapter rather than becoming a no-op');
+      const sliceTaskIds = getSliceTasks('M001', 'S01').map(task => task.id);
+      assert.deepEqual(sliceTaskIds, ['T01', 'T02']);
+      assert.equal(isDbAvailable(), true);
+    });
+
+    test('refreshOpenDatabaseFromDisk: refuses in-memory databases without closing them', () => {
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+
+      assert.equal(refreshOpenDatabaseFromDisk(), false);
+      assert.equal(isDbAvailable(), true);
+      assert.ok(_getAdapter()!.prepare("SELECT 1 FROM milestones WHERE id = 'M001'").get());
+
+      closeDatabase();
+    });
+
+    test('refreshOpenDatabaseFromDisk: is a no-op when no database is open', () => {
+      closeDatabase();
+      assert.equal(refreshOpenDatabaseFromDisk(), false);
+      assert.equal(isDbAvailable(), false);
+    });
+  });
+
   // ─── getDbStatus ───────────────────────────────────────────────────────────
 
   describe('getDbStatus', () => {

package/src/resources/extensions/gsd/tests/integration/auto-recovery.test.ts

@@ -1,3 +1,5 @@
+// GSD Extension — Auto recovery integration tests.
+
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, existsSync, readFileSync, rmSync, chmodSync } from "node:fs";
@@ -401,6 +403,57 @@ test("verifyExpectedArtifact plan-slice fails for plan with no tasks (#699)", (t
   assert.equal(result, false, "should fail when plan has no task entries (empty scaffold, #699)");
 });
 
+test("verifyExpectedArtifact plan-slice trusts DB tasks over legacy plan syntax", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    closeDatabase();
+    cleanup(base);
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  insertTask({ id: "T02", milestoneId: "M001", sliceId: "S01", title: "Second task", status: "pending" });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    "# S01: Slice\n\n## Tasks\n\nTask rows live in the DB; this projection intentionally has no legacy task syntax.\n",
+  );
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+  writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan\n");
+
+  const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+  assert.equal(result, true, "DB task rows plus task plan files should verify plan-slice");
+});
+
+test("verifyExpectedArtifact plan-slice still fails when a DB-backed task plan file is missing", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    closeDatabase();
+    cleanup(base);
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  insertTask({ id: "T02", milestoneId: "M001", sliceId: "S01", title: "Second task", status: "pending" });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    "# S01: Slice\n\n## Tasks\n\nTask rows live in the DB; this projection intentionally has no legacy task syntax.\n",
+  );
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+
+  const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+  assert.equal(result, false, "DB task rows must still require matching task plan files");
+});
+
 // ─── verifyExpectedArtifact: heading-style plan tasks (#1691) ─────────────
 
 test("verifyExpectedArtifact accepts plan-slice with heading-style tasks (### T01 --)", (t) => {
@@ -456,6 +509,32 @@ test("verifyExpectedArtifact accepts plan-slice with colon-style heading tasks (
   );
 });
 
+test("verifyExpectedArtifact accepts indented legacy plan-slice task markers", (t) => {
+  const base = makeTmpBase();
+  t.after(() => cleanup(base));
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+    "# S01: Test Slice",
+    "",
+    "## Tasks",
+    "",
+    "  - [ ] **T01: Implement feature** `est:1h`",
+    "",
+    "  ### T02 -- Write tests",
+  ].join("\n"));
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+  writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan");
+
+  assert.strictEqual(
+    verifyExpectedArtifact("plan-slice", "M001/S01", base),
+    true,
+    "Indented legacy task markers should be treated as completed plan-slice artifacts",
+  );
+});
+
 test("verifyExpectedArtifact execute-task rejects heading-style plan without checked checkbox (#3607)", (t) => {
   const base = makeTmpBase();
   t.after(() => cleanup(base));