@opengsd/gsd-pi 1.0.2-dev.e9a1b49 → 1.0.2-dev.fb7ddf1

package/src/resources/extensions/gsd/tests/commands-usage.test.ts

@@ -8,6 +8,7 @@ import {
   scanSessionTokenTotals,
   handleUsage,
 } from "../commands-usage.ts";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 
 const TS = 1;
 
@@ -108,3 +109,99 @@ test("handleUsage emits JSON when --json is passed", async () => {
   assert.equal(parsed.contextUsage.tokens, 10_000);
   assert.equal(parsed.sessionTotals.input, 0);
 });
+
+test("handleUsage renders interactive usage output inside a full border", async () => {
+  let renderFn: ((width: number) => string[]) | undefined;
+  const messages: string[] = [];
+  const ctx = {
+    hasUI: true,
+    model: { provider: "claude-code", id: "claude-sonnet-4-6", contextWindow: 200_000 },
+    getContextUsage: () => ({ tokens: 10_000, contextWindow: 200_000, percent: 5 }),
+    sessionManager: { getEntries: () => [] },
+    ui: {
+      custom: async (factory: any) => {
+        const theme = {
+          fg: (_color: string, text: string) => text,
+          bold: (text: string) => text,
+        };
+        const component = factory({ requestRender: () => {} }, theme, {}, () => {});
+        renderFn = component.render;
+        return true;
+      },
+      notify(message: string) {
+        messages.push(message);
+      },
+    },
+  };
+
+  await handleUsage("", ctx as any);
+
+  assert.equal(messages.length, 0, "interactive usage should use the dialog instead of notify");
+  assert.ok(renderFn, "render function should have been captured");
+  const lines = renderFn!(80);
+  assertFullOuterBorder(lines, 80);
+  assert.match(lines.join("\n"), /claude-code\/claude-sonnet-4-6/);
+});
+
+test("handleUsage keeps short-terminal usage dialog scrollable", async () => {
+  const originalRowsDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "rows");
+  Object.defineProperty(process.stdout, "rows", { value: 10, configurable: true });
+
+  try {
+    let component: { render(width: number): string[]; handleInput(data: string): void } | undefined;
+    let closed = false;
+    const ctx = {
+      hasUI: true,
+      model: { provider: "claude-code", id: "claude-sonnet-4-6", contextWindow: 200_000 },
+      getContextUsage: () => ({ tokens: 10_000, contextWindow: 200_000, percent: 5 }),
+      sessionManager: {
+        getEntries: () => sessionEntries({
+          role: "assistant",
+          usage: {
+            input: 1000,
+            output: 200,
+            cacheRead: 500,
+            cacheWrite: 100,
+            totalTokens: 1800,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0.05 },
+          },
+          content: [{ type: "toolCall", id: "tc-1", name: "read", arguments: {} }],
+          timestamp: TS,
+        }),
+      },
+      ui: {
+        custom: async (factory: any) => {
+          const theme = {
+            fg: (_color: string, text: string) => text,
+            bold: (text: string) => text,
+          };
+          component = factory({ requestRender: () => {} }, theme, {}, () => {
+            closed = true;
+          });
+          return true;
+        },
+        notify() {},
+      },
+    };
+
+    await handleUsage("", ctx as any);
+
+    assert.ok(component, "usage dialog should render via custom UI");
+    const initialLines = component.render(80);
+    assert.ok(initialLines.length <= 8, `usage dialog should fit 80% terminal height, got ${initialLines.length}`);
+
+    for (let i = 0; i < 10; i++) component.handleInput("\u001b[B");
+
+    assert.equal(closed, false, "scroll keys should not close a scrollable usage dialog");
+    assert.match(component.render(80).join("\n"), /Tool calls: 1/);
+
+    component.handleInput("x");
+    assert.equal(closed, true, "non-scroll keys should close the usage dialog");
+  } finally {
+    if (originalRowsDescriptor) {
+      Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);
+    } else {
+      delete (process.stdout as { rows?: number }).rows;
+    }
+  }
+});

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

@@ -2,7 +2,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync } from "node:fs";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { postUnitPreVerification } from "../auto-post-unit.ts";
@@ -70,7 +70,9 @@ test("complete-slice with gsd_task_reopen handoff continues instead of artifact-
 test("complete-slice with gsd_replan_slice tool result continues instead of artifact-retrying", async () => {
   const base = makeTempRepo("gsd-complete-slice-replan-");
   try {
-    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-REPLAN.md"), "# Replan\n");
 
     const s = new AutoSession();
     s.active = true;
@@ -101,10 +103,45 @@ test("complete-slice with gsd_replan_slice tool result continues instead of arti
     assert.equal(s.pendingVerificationRetry, null);
     assert.equal(s.verificationRetryCount.has(retryKey), false);
     assert.ok(
-      notifications.some((message) => message.includes("handed off via reopen/replan")),
+      notifications.some((message) => message.includes("valid replan outcome")),
       `expected handoff notification, got: ${notifications.join("\n")}`,
     );
   } finally {
     cleanup(base);
   }
 });
+
+test("complete-slice with gsd_replan_slice but no REPLAN artifact retries", async () => {
+  const base = makeTempRepo("gsd-complete-slice-replan-missing-artifact-");
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+
+    const s = new AutoSession();
+    s.active = true;
+    s.basePath = base;
+    s.currentUnit = { type: "complete-slice", id: "M001/S01", startedAt: Date.now() };
+
+    const notifications: string[] = [];
+    const result = await postUnitPreVerification(
+      makePostUnitContext(base, s, notifications),
+      {
+        skipSettleDelay: true,
+        skipWorktreeSync: true,
+        agentEndMessages: [
+          {
+            role: "toolResult",
+            toolName: "gsd_replan_slice",
+            isError: false,
+            content: "Slice replanned with reopened task T02.",
+          },
+        ],
+      },
+    );
+
+    assert.equal(result, "retry");
+    assert.ok(s.pendingVerificationRetry);
+    assert.equal(s.pendingVerificationRetry?.unitId, "M001/S01");
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/context-chart.test.ts

@@ -10,6 +10,7 @@ import type { ContextBreakdownReport } from "../commands-context.ts";
 import { buildContextChartHtml, writeContextChartHtml } from "../context-chart-html.ts";
 import { formatContextChartText, getContextChartTotals } from "../context-overlay.ts";
 import { buildContextBreakdown } from "../commands-context.ts";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 
 const TS = 1;
 
@@ -103,3 +104,11 @@ test("formatContextChartText includes chart sections", () => {
   assert.match(text, /Conversation/);
   assert.match(text, /█/);
 });
+
+test("formatContextChartText renders the context dialog inside a full border", () => {
+  const lines = formatContextChartText(SAMPLE_REPORT, 80).split("\n");
+  assertFullOuterBorder(lines, 80);
+  assert.match(lines[0] ?? "", /^╭─ Context Breakdown /);
+  assert.ok(lines.some((line) => line.startsWith("│")), "body rows should have side borders");
+  assert.match(lines.at(-1) ?? "", /^╰─+╯$/);
+});

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -344,6 +344,70 @@ describe("Custom engine loop integration", () => {
     );
   });
 
+  it("step mode stops after one custom workflow step", async () => {
+    _resetPendingResolve();
+
+    const runDir = makeTmpDir();
+    const graph = makeGraph([
+      makeStep({ id: "step-a" }),
+      makeStep({ id: "step-b", dependsOn: ["step-a"] }),
+      makeStep({ id: "step-c", dependsOn: ["step-b"] }),
+    ], "step-mode-custom");
+    writeGraph(runDir, graph);
+    writeDefinition(runDir, graph.steps, "step-mode-custom");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const s = makeLoopSession({
+      activeEngineId: "custom",
+      activeRunDir: runDir,
+      basePath: runDir,
+      stepMode: true,
+    });
+
+    const deps = makeMockDeps({
+      stopAuto: async (_ctx, _pi, reason) => {
+        deps.callLog.push(`stopAuto:${reason ?? "no-reason"}`);
+        s.active = false;
+      },
+    });
+
+    const loopPromise = autoLoop(ctx, pi, s, deps);
+    await resolveNextAgentEnd();
+
+    let timeout: NodeJS.Timeout | undefined;
+    try {
+      await Promise.race([
+        loopPromise,
+        new Promise((_, reject) =>
+          timeout = setTimeout(() => {
+            s.active = false;
+            if (_hasPendingResolveForTest()) {
+              resolveAgentEnd({ messages: [{ role: "assistant" }] });
+            }
+            reject(new Error(
+              `step mode did not stop after one custom workflow step; calls=${pi.calls.length}; log=${deps.callLog.join(",")}`,
+            ));
+          }, 1_000),
+        ),
+      ]);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+
+    const finalGraph = readGraph(runDir);
+    assert.equal(pi.calls.length, 1, "step mode should dispatch exactly one custom step");
+    assert.equal(finalGraph.steps[0]?.status, "complete", "first step should complete");
+    assert.equal(finalGraph.steps[1]?.status, "pending", "second step should wait for the next /gsd next");
+    assert.equal(finalGraph.steps[2]?.status, "pending", "third step should wait for a later step");
+    assert.equal(
+      deps.callLog.some((e: string) => e.startsWith("stopAuto:")),
+      false,
+      "step-mode pause should not complete or stop the whole workflow",
+    );
+    assert.equal(s.preserveStepSurfaceAfterLoopExit, true);
+  });
+
   it("stops when engine reports isComplete on first derive", async () => {
     _resetPendingResolve();
 

package/src/resources/extensions/gsd/tests/dashboard-overlay.test.ts

@@ -0,0 +1,25 @@
+/**
+ * GSD dashboard overlay dialog chrome tests.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { GSDDashboardOverlay } from "../dashboard-overlay.ts";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
+
+const fakeTheme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+test("GSDDashboardOverlay renders inside the shared full border", (t) => {
+  const overlay = new GSDDashboardOverlay({ requestRender() {} }, fakeTheme as any, () => {});
+  t.after(() => overlay.dispose());
+
+  const lines = overlay.render(100);
+  assertFullOuterBorder(lines, 100);
+  assert.match(lines[0] ?? "", /^╭─ GSD Dashboard /);
+  assert.ok(lines.some((line) => line.startsWith("│")), "body rows should have side borders");
+  assert.match(lines.at(-1) ?? "", /^╰─+╯$/);
+});

package/src/resources/extensions/gsd/tests/discord-invite-links.test.ts

@@ -19,6 +19,7 @@ const VALID_INVITE = "https://discord.gg/8NnkKuepmQ";
 const FILES_WITH_INVITE_LINKS: string[] = [
   "README.md",
   "docs/dev/what-is-pi/15-pi-packages-the-ecosystem.md",
+  "packages/pi-coding-agent/README.md",
 ];
 
 describe("Discord invite links (#2699)", () => {

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

@@ -9,7 +9,9 @@ const discussPrompt = readFileSync(promptPath, "utf-8");
 test("discuss prompt: resilient vision framing", () => {
   const hardenedPattern = /Say exactly:\s*"What's the vision\?"/;
   assert.ok(!hardenedPattern.test(discussPrompt), "prompt no longer uses exact-verbosity lock");
-  assert.ok(discussPrompt.includes('Ask: "What\'s the vision?" once'), "prompt asks for vision exactly once");
+  assert.ok(discussPrompt.includes('Ask exactly this once: "{{visionAsk}}"'), "prompt asks the injected vision opener exactly once");
+  assert.ok(discussPrompt.includes("The opener is intentionally variable"), "prompt documents variable opener voice");
   assert.ok(discussPrompt.includes("Special handling"), "prompt documents special handling");
-  assert.ok(discussPrompt.includes('instead of repeating "What\'s the vision?"'), "prompt forbids repeating");
+  assert.ok(discussPrompt.includes("instead of repeating the opener"), "prompt forbids repeating the opener");
+  assert.ok(!discussPrompt.includes('"What\'s the vision?"'), "prompt no longer freezes the old opener");
 });

package/src/resources/extensions/gsd/tests/discuss-tool-scoping.test.ts

@@ -111,7 +111,7 @@ describe("discuss tool scoping (#2949)", () => {
             setCalls.push([...tools]);
             activeTools = [...tools];
           },
-          sendMessage: (message: unknown) => {
+          sendMessage: async (message: unknown) => {
             sent.push(message);
             sentTools = [...activeTools];
           },

package/src/resources/extensions/gsd/tests/doctor-empty-worktree.test.ts

@@ -4,7 +4,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -30,6 +30,17 @@ function makeRepo(): string {
   return base;
 }
 
+function makeRepoWithOnlyGitignoreCommitted(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-empty-worktree-"));
+  runGit(["init", "-b", "main"], base);
+  runGit(["config", "user.name", "Test User"], base);
+  runGit(["config", "user.email", "test@example.com"], base);
+  writeFileSync(join(base, ".gitignore"), "node_modules\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "chore: init gitignore"], base);
+  return base;
+}
+
 test("doctor fix recreates an empty registered milestone worktree", async (t) => {
   const base = makeRepo();
   t.after(() => rmSync(base, { recursive: true, force: true }));
@@ -63,3 +74,62 @@ test("doctor fix recreates an empty registered milestone worktree", async (t) =>
   assert.ok(existsSync(join(wtPath, "package.json")), "worktree content is restored");
   assert.ok(existsSync(join(wtPath, "milestone-note.txt")), "branch content is restored");
 });
+
+test("doctor fix recreates an empty worktree when cwd is inside that worktree", async (t) => {
+  const base = makeRepo();
+  const originalCwd = process.cwd();
+  t.after(() => {
+    try {
+      process.chdir(originalCwd);
+    } catch { /* ignore deleted cwd during cleanup */ }
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  createWorktree(base, "M001", { branch: "milestone/M001" });
+  const wtPath = worktreePath(base, "M001");
+  for (const entry of readdirSync(wtPath)) {
+    if (entry === ".git") continue;
+    rmSync(join(wtPath, entry), { recursive: true, force: true });
+  }
+  process.chdir(wtPath);
+
+  const report = await runGSDDoctor(base, {
+    fix: true,
+    fixLevel: "all",
+    isolationMode: "worktree",
+  });
+
+  assert.ok(
+    report.fixesApplied.some((fix) => fix.includes("recreated empty worktree")),
+    "doctor applies the repair while cwd is in the worktree",
+  );
+  assert.ok(existsSync(join(wtPath, "package.json")), "worktree content is restored");
+});
+
+test("doctor fix imports untracked project-root content when the worktree only has git metadata", async (t) => {
+  const base = makeRepoWithOnlyGitignoreCommitted();
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "---\ngit:\n  isolation: worktree\n---\n", "utf-8");
+  writeFileSync(join(base, "package.json"), "{\"scripts\":{}}\n", "utf-8");
+  createWorktree(base, "M001", { branch: "milestone/M001" });
+  const wtPath = worktreePath(base, "M001");
+  assert.ok(existsSync(join(wtPath, ".gitignore")), "test setup keeps committed non-content metadata");
+  assert.equal(existsSync(join(wtPath, "package.json")), false, "test setup leaves project content only at the root");
+
+  const report = await runGSDDoctor(base, {
+    fix: true,
+    fixLevel: "all",
+  });
+
+  assert.ok(
+    report.issues.some((issue) => issue.code === "worktree_empty_with_project_content"),
+    "doctor reports the empty worktree even when .gitignore exists",
+  );
+  assert.ok(
+    report.fixesApplied.some((fix) => fix.includes("copied") && fix.includes("project file")),
+    "doctor copies the root project content into the recreated worktree",
+  );
+  assert.ok(existsSync(join(wtPath, "package.json")), "untracked project content is restored into the worktree");
+});

package/src/resources/extensions/gsd/tests/doctor-providers.test.ts

@@ -702,6 +702,48 @@ test("runProviderChecks reports ok for claude-code without any API key", () => {
   rmSync(tmpHome, { recursive: true, force: true });
 });
 
+test("runProviderChecks reports errors for required Google CLI providers missing from PATH", () => {
+  const scenarios = [
+    { provider: "google-gemini-cli", label: "Google Gemini CLI", model: "gemini-2.5-pro" },
+    { provider: "google-antigravity", label: "Antigravity", model: "default" },
+  ];
+
+  for (const { provider, label, model } of scenarios) {
+    const repo = realpathSync(mkdtempSync(join(tmpdir(), `gsd-providers-${provider}-repo-`)));
+    mkdirSync(join(repo, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(repo, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "models:",
+        "  execution:",
+        `    model: ${model}`,
+        `    provider: ${provider}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+
+    const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), `gsd-providers-${provider}-home-`)));
+
+    withEnv({
+      HOME: tmpHome,
+      PATH: tmpHome,
+    }, () => {
+      withCwd(repo, () => {
+        const results = runProviderChecks();
+        const cli = results.find(r => r.name === provider);
+        assert.ok(cli, `${provider} result should exist`);
+        assert.equal(cli!.status, "error", `${provider} should error when the CLI binary is missing`);
+        assert.ok(cli!.detail?.includes(label), "should explain which CLI must be installed");
+      });
+    });
+
+    rmSync(repo, { recursive: true, force: true });
+    rmSync(tmpHome, { recursive: true, force: true });
+  }
+});
+
 test("runProviderChecks reports ok for Anthropic via claude-code binary in PATH", () => {
   // Simulate a user who has no Anthropic API key but has the claude CLI installed.
   // Their PREFERENCES use a claude model without an explicit provider, so the doctor
@@ -736,6 +778,69 @@ test("runProviderChecks reports ok for Anthropic via claude-code binary in PATH"
   });
 });
 
+test("runProviderChecks ignores external CLI auth sentinels when the CLI is missing", () => {
+  const scenarios = [
+    {
+      requiredProvider: "anthropic",
+      routeProvider: "claude-code",
+      model: "claude-sonnet-4-6",
+      env: {
+        ANTHROPIC_API_KEY: undefined,
+        ANTHROPIC_OAUTH_TOKEN: undefined,
+        COPILOT_GITHUB_TOKEN: undefined,
+        GH_TOKEN: undefined,
+        GITHUB_TOKEN: undefined,
+      },
+    },
+    {
+      requiredProvider: "google",
+      routeProvider: "google-gemini-cli",
+      model: "gemini-2.5-pro",
+      env: {
+        GEMINI_API_KEY: undefined,
+        GOOGLE_API_KEY: undefined,
+      },
+    },
+  ];
+
+  for (const { requiredProvider, routeProvider, model, env } of scenarios) {
+    const repo = realpathSync(mkdtempSync(join(tmpdir(), `gsd-providers-${routeProvider}-sentinel-repo-`)));
+    const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), `gsd-providers-${routeProvider}-sentinel-home-`)));
+    const agentDir = join(tmpHome, ".gsd", "agent");
+    mkdirSync(join(repo, ".gsd"), { recursive: true });
+    mkdirSync(agentDir, { recursive: true });
+    writeFileSync(
+      join(repo, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "models:",
+        `  execution: ${model}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    writeFileSync(join(agentDir, "auth.json"), JSON.stringify({
+      [routeProvider]: { type: "api_key", key: "cli" },
+    }));
+
+    withEnv({
+      ...env,
+      HOME: tmpHome,
+      PATH: tmpHome,
+    }, () => {
+      withCwd(repo, () => {
+        const results = runProviderChecks();
+        const provider = results.find(r => r.name === requiredProvider);
+        assert.ok(provider, `${requiredProvider} result should exist`);
+        assert.equal(provider!.status, "error", `${routeProvider} sentinel should not satisfy ${requiredProvider}`);
+      });
+    });
+
+    rmSync(repo, { recursive: true, force: true });
+    rmSync(tmpHome, { recursive: true, force: true });
+  }
+});
+
 test("runProviderChecks detects claude.cmd in PATH on Windows (#4503)", { skip: process.platform !== "win32" }, () => {
   const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cc-win-route-home-")));
   const binDir = join(tmpHome, "bin");

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

@@ -1,11 +1,12 @@
 import { afterEach, test } from "node:test";
 import assert from "node:assert/strict";
-import { closeDatabase } from "../gsd-db.ts";
+import { _getAdapter, closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { filterDoctorIssues } from "../doctor-format.ts";
 import { checkEngineHealth } from "../doctor-engine-checks.ts";
+import { appendEvent } from "../workflow-events.ts";
 
 afterEach(() => {
   closeDatabase();
@@ -41,3 +42,102 @@ test("checkEngineHealth reports db_unavailable when gsd.db exists but the DB is
   assert.equal(dbIssue.unitId, "project");
   assert.equal(dbIssue.file, ".gsd/gsd.db");
 });
+
+test("checkEngineHealth reads canonical reopen events from worktree bases", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-reopen-worktree-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  const worktree = join(gsdDir, "worktrees", "M001");
+  mkdirSync(join(worktree, ".gsd"), { recursive: true });
+  writeFileSync(join(worktree, ".git"), "gitdir: ../../../../.git/worktrees/M001\n", "utf-8");
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertMilestone({ id: "M001", title: "Reopened", status: "active" });
+  const db = _getAdapter()!;
+  db.prepare(
+    `INSERT INTO workers (
+      worker_id, host, pid, started_at, version, last_heartbeat_at, status, project_root_realpath
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run("worker-1", "localhost", 1, "2026-01-01T00:00:00.000Z", "test", "2026-01-01T00:00:00.000Z", "stopped", base);
+  db.prepare(
+    `INSERT INTO unit_dispatches (
+      trace_id, worker_id, milestone_lease_token, milestone_id,
+      unit_type, unit_id, status, attempt_n, started_at, ended_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    "trace-1",
+    "worker-1",
+    1,
+    "M001",
+    "complete-milestone",
+    "M001",
+    "completed",
+    1,
+    "2026-01-01T00:00:00.000Z",
+    "2026-01-01T00:00:01.000Z",
+  );
+  appendEvent(base, {
+    cmd: "reopen-milestone",
+    params: { milestoneId: "M001" },
+    ts: "2026-01-01T00:00:02.000Z",
+    actor: "agent",
+  });
+
+  const issues: any[] = [];
+  await checkEngineHealth(worktree, issues, []);
+
+  assert.equal(
+    issues.some((issue) => issue.code === "completed_milestone_reopened"),
+    false,
+    "canonical reopen event should exempt the reopened milestone from doctor drift errors",
+  );
+});
+
+test("checkEngineHealth treats explicit reopen as authoritative when dispatch timestamps are missing", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-reopen-no-dispatch-time-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertMilestone({ id: "M001", title: "Reopened", status: "active" });
+  const db = _getAdapter()!;
+  db.prepare(
+    `INSERT INTO workers (
+      worker_id, host, pid, started_at, version, last_heartbeat_at, status, project_root_realpath
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run("worker-1", "localhost", 1, "2026-01-01T00:00:00.000Z", "test", "2026-01-01T00:00:00.000Z", "stopped", base);
+  db.exec("PRAGMA writable_schema = ON");
+  db.prepare(
+    `UPDATE sqlite_schema
+     SET sql = replace(sql, 'started_at TEXT NOT NULL', 'started_at TEXT')
+     WHERE type = 'table' AND name = 'unit_dispatches'`,
+  ).run();
+  db.exec("PRAGMA writable_schema = OFF");
+  closeDatabase();
+  openDatabase(join(gsdDir, "gsd.db"));
+  const reopenedDb = _getAdapter()!;
+  reopenedDb.prepare(
+    `INSERT INTO unit_dispatches (
+      trace_id, worker_id, milestone_lease_token, milestone_id,
+      unit_type, unit_id, status, attempt_n, started_at, ended_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run("trace-1", "worker-1", 1, "M001", "complete-milestone", "M001", "completed", 1, null, null);
+  appendEvent(base, {
+    cmd: "reopen-milestone",
+    params: { milestoneId: "M001" },
+    ts: "2026-01-01T00:00:02.000Z",
+    actor: "agent",
+  });
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  assert.equal(
+    issues.some((issue) => issue.code === "completed_milestone_reopened"),
+    false,
+    "explicit reopen should exempt reopened milestone even when completion dispatch timestamps are absent",
+  );
+});