@opengsd/gsd-pi 1.6.0 → 1.7.0

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

@@ -0,0 +1,117 @@
+// GSD — reopen-reason injection tests (#1272)
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from '../gsd-db.ts';
+import { handleReopenTask } from '../tools/reopen-task.ts';
+import {
+  reopenReasonArtifactPath,
+  writeReopenReason,
+  claimReopenReasonForInjection,
+} from '../reopen-reason.ts';
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-reopen-reason-'));
+  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' });
+}
+
+test('writeReopenReason then claim: injects the reason, then is one-shot', () => {
+  const base = makeTmpBase();
+  try {
+    const reason = 'T01 shifted the descendants count to 12. Fix: update the assertion to 12.';
+    writeReopenReason(base, 'M001', 'S01', 'T01', reason);
+
+    const path = reopenReasonArtifactPath(base, 'M001', 'S01', 'T01')!;
+    assert.ok(existsSync(path), 'artifact should be written');
+
+    const claimed = claimReopenReasonForInjection(base, 'M001', 'S01', 'T01');
+    assert.ok(claimed, 'first claim should return an injection block');
+    assert.match(claimed!.injectionBlock, /Reopened — Reason/);
+    assert.match(claimed!.injectionBlock, /descendants count to 12/);
+    assert.ok(!existsSync(path), 'artifact should be deleted after claim (one-shot)');
+
+    const second = claimReopenReasonForInjection(base, 'M001', 'S01', 'T01');
+    assert.equal(second, null, 'second claim should return null');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('claimReopenReasonForInjection: returns null when nothing pending', () => {
+  const base = makeTmpBase();
+  try {
+    assert.equal(claimReopenReasonForInjection(base, 'M001', 'S01', 'T01'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('writeReopenReason: empty/whitespace reason is a no-op', () => {
+  const base = makeTmpBase();
+  try {
+    writeReopenReason(base, 'M001', 'S01', 'T01', '   ');
+    const path = reopenReasonArtifactPath(base, 'M001', 'S01', 'T01')!;
+    assert.ok(!existsSync(path), 'no artifact should be written for an empty reason');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenTask: persists a claimable reopen reason when reason is provided', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    seedCompleteTask();
+
+    const result = await handleReopenTask({
+      milestoneId: 'M001',
+      sliceId: 'S01',
+      taskId: 'T01',
+      reason: 'Full suite caught NavNodeTest regression — update count assertion to 12.',
+    }, base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const claimed = claimReopenReasonForInjection(base, 'M001', 'S01', 'T01');
+    assert.ok(claimed, 'reopen reason should be claimable after handleReopenTask');
+    assert.match(claimed!.injectionBlock, /NavNodeTest regression/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenTask: no reason provided leaves nothing to claim', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    seedCompleteTask();
+
+    await handleReopenTask({ milestoneId: 'M001', sliceId: 'S01', taskId: 'T01' }, base);
+
+    assert.equal(claimReopenReasonForInjection(base, 'M001', 'S01', 'T01'), null);
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/worker-resume-wait.test.ts

@@ -0,0 +1,73 @@
+/**
+ * Tests: awaitWorkerResume — headless worker pause survives without a resumer.
+ *
+ * Regression for #1273: a worker `pause` used to call a terminal pauseAuto()
+ * that exited the process with BLOCKED (10). On the headless path there is no
+ * resumer to send the matching `resume`, so the worker was stranded after its
+ * first unit. awaitWorkerResume lets the worker wait for the coordinator to lift
+ * the pause and, when no resumer responds, report "timeout" so the caller can
+ * degrade to in-process serialization instead of halting forever.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { awaitWorkerResume, sendSignal } from "../session-status-io.ts";
+
+function makeBase(): { base: string; cleanup: () => void } {
+  const base = mkdtempSync(join(tmpdir(), "gsd-worker-resume-"));
+  mkdirSync(join(base, ".gsd", "parallel"), { recursive: true });
+  return { base, cleanup: () => rmSync(base, { recursive: true, force: true }) };
+}
+
+describe("awaitWorkerResume", () => {
+  it("returns 'resume' when the coordinator sends resume", async () => {
+    const { base, cleanup } = makeBase();
+    try {
+      sendSignal(base, "M001", "resume");
+      const outcome = await awaitWorkerResume(base, "M001", { timeoutMs: 500, pollMs: 20 });
+      assert.equal(outcome, "resume");
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("returns 'stop' when the coordinator sends stop", async () => {
+    const { base, cleanup } = makeBase();
+    try {
+      sendSignal(base, "M001", "stop");
+      const outcome = await awaitWorkerResume(base, "M001", { timeoutMs: 500, pollMs: 20 });
+      assert.equal(outcome, "stop");
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("returns 'timeout' when no resumer lifts the pause (headless, #1273)", async () => {
+    const { base, cleanup } = makeBase();
+    try {
+      const outcome = await awaitWorkerResume(base, "M001", { timeoutMs: 100, pollMs: 20 });
+      assert.equal(outcome, "timeout");
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("ignores a repeated pause and still resumes when resume arrives", async () => {
+    const { base, cleanup } = makeBase();
+    try {
+      // A duplicate pause must not be treated as a resume, nor reset the wait.
+      sendSignal(base, "M001", "pause");
+      const waiting = awaitWorkerResume(base, "M001", { timeoutMs: 1000, pollMs: 20 });
+      // Deliver the resume shortly after the pause is consumed and ignored.
+      setTimeout(() => sendSignal(base, "M001", "resume"), 60);
+      const outcome = await waiting;
+      assert.equal(outcome, "resume");
+    } finally {
+      cleanup();
+    }
+  });
+});

package/src/resources/extensions/gsd/tools/reopen-task.ts

@@ -23,6 +23,7 @@ import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { writeReopenReason } from "../reopen-reason.js";
 import { existsSync, unlinkSync } from "node:fs";
 import { join, basename, dirname } from "node:path";
 import { resolveTasksDir, resolveSlicePath, clearPathCache } from "../paths.js";
@@ -125,6 +126,20 @@ export async function handleReopenTask(
   }
   clearPathCache();
 
+  // ── Persist the reopen reason for the next execute-task dispatch (#1272) ──
+  // Without this, the re-dispatched executor receives the original task plan
+  // and verify command with zero signal that it was reopened — it re-runs the
+  // (still-green) scoped verify and re-completes the task, never touching the
+  // regression the gate actually caught. buildExecuteTaskPrompt claims this
+  // artifact and prepends the diagnosis to the next dispatch.
+  if (params.reason && params.reason.trim() !== "") {
+    try {
+      writeReopenReason(basePath, params.milestoneId, params.sliceId, params.taskId, params.reason);
+    } catch (reasonErr) {
+      logWarning("tool", `reopen-task reason persistence warning: ${(reasonErr as Error).message}`);
+    }
+  }
+
   // ── Post-mutation hook ───────────────────────────────────────────────────
   try {
     await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });

package/src/resources/extensions/shared/gsd-browser-cli.ts

@@ -355,14 +355,16 @@ export function resolveGsdBrowserMcpLaunchConfig(
 }
 
 /**
- * CLI invocation that starts the gsd-browser session daemon with the same
- * session and identity flags as {@link resolveGsdBrowserMcpLaunchConfig}, so
- * browser UAT can warm Chrome/CDP before the first MCP navigation.
+ * CLI invocation that runs a `daemon <action>` command against the gsd-browser
+ * session daemon with the same session and identity flags as
+ * {@link resolveGsdBrowserMcpLaunchConfig}, so start (warm-up) and stop
+ * (teardown) address the exact same managed daemon.
  */
-export function resolveGsdBrowserDaemonStartInvocation(
+function resolveGsdBrowserDaemonInvocation(
+  action: "start" | "stop",
   projectRoot: string,
-  env: NodeJS.ProcessEnv = process.env,
-  options: GsdBrowserMcpLaunchOptions = {},
+  env: NodeJS.ProcessEnv,
+  options: GsdBrowserMcpLaunchOptions,
 ): Pick<GsdBrowserMcpLaunchConfig, "command" | "args" | "cwd" | "env"> {
   const launch = resolveGsdBrowserMcpLaunchConfig(projectRoot, env, options);
   const mcpIndex = launch.args.indexOf("mcp");
@@ -374,8 +376,34 @@ export function resolveGsdBrowserDaemonStartInvocation(
   const sessionFlags = launch.args.slice(mcpIndex + 1);
   return {
     command: launch.command,
-    args: [...prefix, "daemon", "start", ...sessionFlags],
+    args: [...prefix, "daemon", action, ...sessionFlags],
     cwd: launch.cwd,
     ...(launch.env ? { env: launch.env } : {}),
   };
 }
+
+/**
+ * CLI invocation that starts the gsd-browser session daemon with the same
+ * session and identity flags as {@link resolveGsdBrowserMcpLaunchConfig}, so
+ * browser UAT can warm Chrome/CDP before the first MCP navigation.
+ */
+export function resolveGsdBrowserDaemonStartInvocation(
+  projectRoot: string,
+  env: NodeJS.ProcessEnv = process.env,
+  options: GsdBrowserMcpLaunchOptions = {},
+): Pick<GsdBrowserMcpLaunchConfig, "command" | "args" | "cwd" | "env"> {
+  return resolveGsdBrowserDaemonInvocation("start", projectRoot, env, options);
+}
+
+/**
+ * CLI invocation that stops the gsd-browser session daemon warmed for browser
+ * UAT, so the Chrome process is torn down instead of lingering after the
+ * triggering task/session ends.
+ */
+export function resolveGsdBrowserDaemonStopInvocation(
+  projectRoot: string,
+  env: NodeJS.ProcessEnv = process.env,
+  options: GsdBrowserMcpLaunchOptions = {},
+): Pick<GsdBrowserMcpLaunchConfig, "command" | "args" | "cwd" | "env"> {
+  return resolveGsdBrowserDaemonInvocation("stop", projectRoot, env, options);
+}