gsd-pi 2.80.0-dev.42bd34838 → 2.80.0-dev.488219eb6

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

@@ -2,63 +2,19 @@
  * auto-paused-session-validation.test.ts — Validates milestone existence
  * before restoring from paused-session.json (#1664).
  *
- * Two layers:
- * 1. Source-code regression: ensures auto.ts validates the milestone before
- *    trusting paused-session.json (guards against accidental removal).
- * 2. Filesystem unit: confirms resolveMilestonePath / resolveMilestoneFile
- *    correctly detect missing and completed milestones.
+ * Filesystem unit coverage confirms resolveMilestonePath / resolveMilestoneFile
+ * correctly detect missing and completed milestones.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
-import { fileURLToPath } from "node:url";
-import { dirname } from "node:path";
 
 import { resolveMilestonePath, resolveMilestoneFile } from "../paths.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const AUTO_TS_PATH = join(__dirname, "..", "auto.ts");
-
-// ─── Source-code regression guard ───────────────────────────────────────────
-
-test("auto.ts validates milestone before restoring paused session (#1664)", () => {
-  const source = readFileSync(AUTO_TS_PATH, "utf-8");
-
-  // The resume block must call resolveMilestonePath to verify the milestone dir exists
-  assert.ok(
-    source.includes('resolveMilestonePath(base, meta.milestoneId)'),
-    "auto.ts must call resolveMilestonePath to verify paused milestone exists",
-  );
-
-  // The resume block must check for a SUMMARY file to detect completed milestones
-  assert.ok(
-    source.includes('resolveMilestoneFile(base, meta.milestoneId, "SUMMARY")'),
-    "auto.ts must check for SUMMARY file to detect completed milestones",
-  );
-
-  assert.ok(
-    source.includes("await ensureDbOpen(base)") &&
-      source.indexOf("await ensureDbOpen(base)") < source.indexOf('resolveMilestoneFile(base, meta.milestoneId, "SUMMARY")'),
-    "auto.ts must open the canonical DB before using SUMMARY as a paused-session fallback",
-  );
-
-  // Resume path must sanitize paused session file metadata before unlink/recovery.
-  assert.ok(
-    source.includes("normalizeSessionFilePath(meta.sessionFile ?? null)"),
-    "auto.ts must sanitize paused-session metadata sessionFile before using it",
-  );
-
-  // Pause path must sanitize live session file path before persisting metadata.
-  assert.ok(
-    source.includes("normalizeSessionFilePath(ctx?.sessionManager?.getSessionFile() ?? null)"),
-    "auto.ts must sanitize sessionManager getSessionFile output before persisting",
-  );
-});
-
 // ─── Filesystem validation unit tests ───────────────────────────────────────
 
 function makeTmpBase(): string {

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -1,27 +1,85 @@
+// Project/App: GSD-2
+// File Purpose: Behavior tests for auto-loop cleanup after paused provider exits.
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const autoSource = readFileSync(join(__dirname, "..", "auto.ts"), "utf-8");
+import { cleanupAfterLoopExit, rerootCommandSession } from "../auto.ts";
+import { autoSession } from "../auto-runtime-state.ts";
 
-test("#3370: cleanupAfterLoopExit preserves paused auto badge after provider pause", () => {
-  const cleanupIdx = autoSource.indexOf("function cleanupAfterLoopExit");
-  assert.ok(cleanupIdx > -1, "auto.ts should define cleanupAfterLoopExit");
+test("cleanupAfterLoopExit preserves paused auto badge after provider pause", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-paused-cleanup-"));
+  const previousCwd = process.cwd();
+  const statuses: Array<[string, string | undefined]> = [];
 
-  const dispatchIdx = autoSource.indexOf("export async function dispatchHookUnit", cleanupIdx);
-  assert.ok(dispatchIdx > cleanupIdx, "cleanupAfterLoopExit body should be bounded by the next export");
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = true;
+  autoSession.basePath = join(base, ".gsd", "worktrees", "M001");
+  autoSession.originalBasePath = base;
 
-  const cleanupBody = autoSource.slice(cleanupIdx, dispatchIdx);
-  const pausedGuardIdx = cleanupBody.indexOf("if (!s.paused) {");
-  const clearStatusIdx = cleanupBody.indexOf('ctx.ui.setStatus("gsd-auto", undefined);');
+  try {
+    await cleanupAfterLoopExit({
+      ui: {
+        setStatus: (key: string, value: string | undefined) => {
+          statuses.push([key, value]);
+        },
+        setWidget: () => {},
+        notify: () => {},
+      },
+    } as any);
 
-  assert.ok(pausedGuardIdx > -1, "loop-exit cleanup must guard UI clearing when auto is paused");
-  assert.ok(clearStatusIdx > pausedGuardIdx, "status clearing must live behind the paused guard");
-  assert.ok(
-    autoSource.includes('ctx?.ui.setStatus("gsd-auto", "paused");'),
-    "pauseAuto must still set the paused badge for transient provider pauses",
+    assert.equal(statuses.some(([key]) => key === "gsd-auto"), false);
+    assert.equal(autoSession.active, false);
+    assert.equal(autoSession.paused, true);
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("cleanupAfterLoopExit clears status and widget when auto is not paused", async () => {
+  const statusCalls: unknown[] = [];
+  const widgetCalls: unknown[] = [];
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = false;
+
+  try {
+    await cleanupAfterLoopExit({
+      hasUI: false,
+      ui: {
+        setStatus: (...args: unknown[]) => statusCalls.push(args),
+        setWidget: (...args: unknown[]) => widgetCalls.push(args),
+        notify: () => {},
+      },
+    } as any);
+
+    assert.deepEqual(statusCalls, [["gsd-auto", undefined]]);
+    assert.deepEqual(widgetCalls, [["gsd-progress", undefined]]);
+    assert.equal(autoSession.active, false);
+    assert.equal(autoSession.paused, false);
+  } finally {
+    autoSession.reset();
+  }
+});
+
+test("rerootCommandSession refreshes command workspace to project root", async () => {
+  const calls: string[] = [];
+  const result = await rerootCommandSession(
+    {
+      newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+        calls.push(workspaceRoot);
+        return { cancelled: false };
+      },
+    } as any,
+    "/project/root",
   );
+
+  assert.deepEqual(result, { status: "ok" });
+  assert.deepEqual(calls, ["/project/root"]);
 });

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Auto-loop phase lifecycle regression tests.
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdtempSync, rmSync } from "node:fs";
@@ -60,6 +62,59 @@ async function runSuccessfulFinalize(s: AutoSession) {
   );
 }
 
+async function runFinalizeWithDeps(s: AutoSession, depsOverrides: Record<string, unknown>) {
+  const unit = s.currentUnit;
+  assert.ok(unit, "test setup must provide currentUnit");
+
+  writeUnitRuntimeRecord(s.basePath, unit.type, unit.id, unit.startedAt, {
+    phase: "dispatched",
+  });
+
+  const deps = {
+    clearUnitTimeout() {},
+    buildSnapshotOpts() {
+      return {};
+    },
+    stopAuto: async () => {},
+    pauseAuto: async () => {},
+    updateProgressWidget() {},
+    postUnitPreVerification: async () => "continue",
+    runPostUnitVerification: async () => "continue",
+    postUnitPostVerification: async () => "continue",
+    ...depsOverrides,
+  };
+
+  return runFinalize(
+    {
+      ctx: { ui: { notify() {} } },
+      pi: {},
+      s,
+      deps,
+      prefs: undefined,
+      iteration: 1,
+      flowId: "flow-1",
+      nextSeq: () => 1,
+    } as any,
+    {
+      unitType: unit.type,
+      unitId: unit.id,
+      prompt: "",
+      finalPrompt: "",
+      pauseAfterUatDispatch: false,
+      state: {} as any,
+      mid: "M001",
+      midTitle: "Milestone",
+      isRetry: false,
+      previousTier: undefined,
+    },
+    {
+      recentUnits: [],
+      stuckRecoveryAttempts: 0,
+      consecutiveFinalizeTimeouts: 0,
+    },
+  );
+}
+
 test("runFinalize clears currentUnit after successful finalize", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-finalize-current-unit-"));
   const s = new AutoSession();
@@ -102,3 +157,54 @@ test("runFinalize marks unit runtime finalized after successful finalize", async
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("runFinalize merges a verified complete-milestone immediately and only once", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-finalize-merge-"));
+  t.after(() => {
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const s = new AutoSession();
+  const startedAt = Date.now();
+  let mergeCalls = 0;
+  s.basePath = base;
+  s.originalBasePath = base;
+  s.currentMilestoneId = "M001";
+  s.currentUnit = {
+    type: "complete-milestone",
+    id: "M001",
+    startedAt,
+  };
+
+  const result = await runFinalizeWithDeps(s, {
+    preflightCleanRoot: () => ({ stashPushed: false }),
+    postflightPopStash: () => ({ needsManualRecovery: false }),
+    resolver: {
+      mergeAndExit() {
+        mergeCalls++;
+      },
+    },
+  });
+
+  assert.equal(result.action, "next");
+  assert.equal(mergeCalls, 1);
+  assert.equal(s.milestoneMergedInPhases, true);
+
+  s.currentUnit = {
+    type: "complete-milestone",
+    id: "M001",
+    startedAt: startedAt + 1,
+  };
+  const second = await runFinalizeWithDeps(s, {
+    preflightCleanRoot: () => ({ stashPushed: false }),
+    postflightPopStash: () => ({ needsManualRecovery: false }),
+    resolver: {
+      mergeAndExit() {
+        mergeCalls++;
+      },
+    },
+  });
+
+  assert.equal(second.action, "next");
+  assert.equal(mergeCalls, 1);
+});

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

@@ -1,107 +1,66 @@
 /**
  * auto-pr-bugs.test.ts — Regression tests for #2302.
  *
- * Three interacting bugs prevented auto_pr from ever creating a PR:
- * 1. auto_pr was gated on `pushed` (which requires auto_push)
- * 2. Milestone branch was not pushed to remote before PR creation
- * 3. createDraftPR in git-service.ts lacked --head/--base parameters
+ * Verifies the PR creation command behavior directly instead of asserting on
+ * git-service.ts source text.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-
-// ─── Bug 1: auto_pr should not depend on auto_push / pushed flag ────────────
-
-const autoWorktreeSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-const autoWorktreeSrc = readFileSync(autoWorktreeSrcPath, "utf-8");
-
-test("#2302 bug 1: auto_pr condition should not require pushed flag", () => {
-  // Find the auto_pr block in mergeMilestoneToMain
-  const autoPrIdx = autoWorktreeSrc.indexOf("auto_pr");
-  assert.ok(autoPrIdx !== -1, "auto_pr reference exists in auto-worktree.ts");
-
-  // Get context around the auto_pr check
-  const lineStart = autoWorktreeSrc.lastIndexOf("\n", autoPrIdx) + 1;
-  const lineEnd = autoWorktreeSrc.indexOf("\n", autoPrIdx);
-  const autoPrLine = autoWorktreeSrc.slice(lineStart, lineEnd);
-
-  // The condition should NOT include `&& pushed`
-  assert.ok(
-    !autoPrLine.includes("&& pushed"),
-    "auto_pr condition should not be gated on pushed flag (auto_push dependency)",
-  );
-});
-
-test("auto_pr skips milestone branch push when configured remote is absent", () => {
-  const autoPrIdx = autoWorktreeSrc.indexOf("prefs.auto_pr === true");
-  assert.ok(autoPrIdx !== -1, "auto_pr block exists in auto-worktree.ts");
-
-  const autoPrBlock = autoWorktreeSrc.slice(
-    autoPrIdx,
-    autoWorktreeSrc.indexOf("// 11. Guard removed", autoPrIdx),
+import { tmpdir } from "node:os";
+
+import { createDraftPR } from "../git-service.ts";
+
+function makeTempDir(prefix: string): string {
+  return mkdtempSync(join(tmpdir(), prefix));
+}
+
+test("#2302 createDraftPR passes head and base branch parameters to gh", (t) => {
+  const dir = makeTempDir("gsd-auto-pr-");
+  const bin = join(dir, "bin");
+  const logPath = join(dir, "gh-args.json");
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  mkdirSync(bin, { recursive: true });
+  const ghPath = join(bin, "gh");
+  writeFileSync(
+    ghPath,
+    [
+      "#!/usr/bin/env node",
+      "const fs = require('node:fs');",
+      `fs.writeFileSync(${JSON.stringify(logPath)}, JSON.stringify(process.argv.slice(2)));`,
+      "process.stdout.write('https://example.test/pr/1\\n');",
+    ].join("\n"),
+    "utf-8",
   );
-  const remoteExistsIdx = autoPrBlock.indexOf("gitRemoteExists(originalBasePath_, remote)");
-  const pushIdx = autoPrBlock.indexOf('execFileSync("git", ["push", remote, milestoneBranch]');
-
-  assert.ok(remoteExistsIdx !== -1, "auto_pr must check that the configured remote exists");
-  assert.ok(pushIdx !== -1, "auto_pr still pushes the milestone branch before creating the PR");
-  assert.ok(
-    remoteExistsIdx < pushIdx,
-    "auto_pr must check remote existence before pushing the milestone branch",
+  chmodSync(ghPath, 0o755);
+
+  const prUrl = createDraftPR(
+    dir,
+    "M001",
+    "Draft title",
+    "Draft body",
+    {
+      head: "milestone/M001",
+      base: "main",
+      env: { ...process.env, PATH: `${bin}:${process.env.PATH ?? ""}` },
+    },
   );
-});
-
-// ─── Bug 2: phases.ts should not duplicate PR creation ──────────────────────
-
-const phasesSrcPath = join(import.meta.dirname, "..", "auto", "phases.ts");
-const phasesSrc = readFileSync(phasesSrcPath, "utf-8");
-
-test("#2302 bug 2: phases.ts should not call createDraftPR (handled by mergeMilestoneToMain)", () => {
-  // After fix, phases.ts should not import or call createDraftPR because
-  // PR creation is handled inside mergeMilestoneToMain in auto-worktree.ts
-  const createDraftPRCalls = phasesSrc.match(/createDraftPR\(/g) || [];
 
-  assert.equal(
-    createDraftPRCalls.length,
-    0,
-    "phases.ts should not call createDraftPR — it's handled by mergeMilestoneToMain",
-  );
-});
-
-// ─── Bug 3: createDraftPR should accept head and base branch parameters ─────
-
-const gitServiceSrcPath = join(import.meta.dirname, "..", "git-service.ts");
-const gitServiceSrc = readFileSync(gitServiceSrcPath, "utf-8");
-
-test("#2302 bug 3: createDraftPR should accept head and base branch parameters", () => {
-  // Find the createDraftPR function signature
-  const fnIdx = gitServiceSrc.indexOf("function createDraftPR");
-  assert.ok(fnIdx !== -1, "createDraftPR function exists");
-
-  // Get the function signature (up to the closing paren)
-  const sigEnd = gitServiceSrc.indexOf(")", fnIdx);
-  const signature = gitServiceSrc.slice(fnIdx, sigEnd);
-
-  // Should have head and base parameters
-  assert.ok(
-    signature.includes("head") || signature.includes("branch"),
-    "createDraftPR should accept a head/branch parameter",
-  );
-});
-
-test("#2302 bug 3: createDraftPR should pass --head and --base to gh pr create", () => {
-  const fnIdx = gitServiceSrc.indexOf("function createDraftPR");
-  const fnEnd = gitServiceSrc.indexOf("\n}", fnIdx);
-  const fnBody = gitServiceSrc.slice(fnIdx, fnEnd);
-
-  assert.ok(
-    fnBody.includes("--head"),
-    "createDraftPR should pass --head to gh pr create",
-  );
-  assert.ok(
-    fnBody.includes("--base"),
-    "createDraftPR should pass --base to gh pr create",
-  );
+  assert.equal(prUrl, "https://example.test/pr/1");
+  assert.deepEqual(JSON.parse(readFileSync(logPath, "utf-8")), [
+    "pr",
+    "create",
+    "--draft",
+    "--title",
+    "Draft title",
+    "--body",
+    "Draft body",
+    "--head",
+    "milestone/M001",
+    "--base",
+    "main",
+  ]);
 });

package/src/resources/extensions/gsd/tests/auto-project-root-env.test.ts

@@ -1,33 +1,74 @@
+// Project/App: GSD-2
+// File Purpose: Behavior tests for auto-mode project-root environment cleanup.
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-const sourcePath = join(import.meta.dirname, "..", "auto.ts");
-const source = readFileSync(sourcePath, "utf-8");
-
-test("auto-mode captures GSD_PROJECT_ROOT before entering the dispatch loop", () => {
-  const captureDeclIdx = source.indexOf("function captureProjectRootEnv(projectRoot: string): void {");
-  assert.ok(captureDeclIdx > -1, "auto.ts should define captureProjectRootEnv()");
-
-  const resumeCallIdx = source.indexOf("captureProjectRootEnv(s.originalBasePath || s.basePath);");
-  assert.ok(resumeCallIdx > -1, "auto.ts should capture GSD_PROJECT_ROOT before resume autoLoop");
-
-  const firstLoopIdxCandidates = [
-    source.indexOf("await runAutoLoopWithUok({"),
-    source.indexOf("await autoLoop(ctx, pi, s, buildLoopDeps());"),
-  ].filter((idx) => idx > -1);
-  const firstAutoLoopIdx = firstLoopIdxCandidates.length > 0 ? Math.min(...firstLoopIdxCandidates) : -1;
-  assert.ok(firstAutoLoopIdx > -1, "auto.ts should invoke the auto dispatch loop");
-  assert.ok(
-    resumeCallIdx < firstAutoLoopIdx,
-    "auto.ts must set GSD_PROJECT_ROOT before the first loop call",
-  );
+import {
+  cleanupAfterLoopExit,
+  _captureProjectRootEnvForTest,
+  _restoreProjectRootEnvForTest,
+} from "../auto.ts";
+import { autoSession } from "../auto-runtime-state.ts";
+
+test.afterEach(() => {
+  _restoreProjectRootEnvForTest();
+});
+
+test("auto-mode project-root env capture sets GSD_PROJECT_ROOT and restores an existing value", () => {
+  process.env.GSD_PROJECT_ROOT = "/before";
+
+  _captureProjectRootEnvForTest("/project");
+  assert.equal(process.env.GSD_PROJECT_ROOT, "/project");
+
+  _restoreProjectRootEnvForTest();
+  assert.equal(process.env.GSD_PROJECT_ROOT, "/before");
+  delete process.env.GSD_PROJECT_ROOT;
+});
+
+test("auto-mode project-root env restore deletes GSD_PROJECT_ROOT when it was initially absent", () => {
+  delete process.env.GSD_PROJECT_ROOT;
+
+  _captureProjectRootEnvForTest("/project");
+  assert.equal(process.env.GSD_PROJECT_ROOT, "/project");
+
+  _restoreProjectRootEnvForTest();
+  assert.equal(process.env.GSD_PROJECT_ROOT, undefined);
 });
 
-test("auto-mode restores GSD_PROJECT_ROOT when execution stops or pauses", () => {
-  assert.match(source, /function restoreProjectRootEnv\(\): void \{/);
-  assert.match(source, /cleanupAfterLoopExit\(ctx: ExtensionContext\): void \{[\s\S]*restoreProjectRootEnv\(\);/);
-  assert.match(source, /export async function pauseAuto\([\s\S]*restoreProjectRootEnv\(\);/);
-  assert.match(source, /\} finally \{[\s\S]*restoreProjectRootEnv\(\);[\s\S]*s\.reset\(\);/);
+test("cleanupAfterLoopExit restores captured GSD_PROJECT_ROOT", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-project-root-env-"));
+  const previousCwd = process.cwd();
+  const previousProjectRoot = process.env.GSD_PROJECT_ROOT;
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = join(base, ".gsd", "worktrees", "M001");
+  autoSession.originalBasePath = base;
+  autoSession.projectRootEnvCaptured = true;
+  autoSession.hadProjectRootEnv = true;
+  autoSession.previousProjectRootEnv = "/previous/project";
+  process.env.GSD_PROJECT_ROOT = base;
+
+  try {
+    await cleanupAfterLoopExit({
+      ui: {
+        setStatus: () => {},
+        setWidget: () => {},
+        notify: () => {},
+      },
+    } as any);
+
+    assert.equal(process.env.GSD_PROJECT_ROOT, "/previous/project");
+    assert.equal(autoSession.projectRootEnvCaptured, false);
+    assert.equal(autoSession.previousProjectRootEnv, null);
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    if (previousProjectRoot === undefined) delete process.env.GSD_PROJECT_ROOT;
+    else process.env.GSD_PROJECT_ROOT = previousProjectRoot;
+    rmSync(base, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/auto-remediate-slice-status.test.ts

@@ -4,43 +4,45 @@
  * A SUMMARY.md on disk is a projection/diagnostic. Runtime post-unit checks
  * must not use it to mark the DB slice complete; explicit import/recovery
  * commands own markdown-to-DB behavior.
- *
- * This structural test verifies the complete-slice rogue branch reports the
- * stale projection without calling updateSliceStatus().
  */
 
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import { extractSourceRegion } from "./test-helpers.ts";
+import { afterEach, describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+import { detectRogueFileWrites } from "../auto-post-unit.ts";
+import {
+  closeDatabase,
+  getSlice,
+  insertMilestone,
+  insertSlice,
+  isDbAvailable,
+  openDatabase,
+} from "../gsd-db.ts";
 
-const source = readFileSync(join(__dirname, '..', 'auto-post-unit.ts'), 'utf-8');
+afterEach(() => {
+  if (isDbAvailable()) closeDatabase();
+});
 
-describe('DB-authoritative slice rogue detection', () => {
-  test('updateSliceStatus is not imported for post-unit rogue reconciliation', () => {
-    assert.doesNotMatch(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from\s*["']\.\/gsd-db/,
-      'auto-post-unit must not import updateSliceStatus for disk-to-DB reconciliation');
-  });
+describe("DB-authoritative slice rogue detection", () => {
+  test("complete-slice SUMMARY.md is reported as rogue without marking DB complete", (t) => {
+    const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-rogue-slice-")));
+    t.after(() => rmSync(base, { recursive: true, force: true }));
 
-  test('complete-slice rogue branch does not mark DB complete from disk', () => {
-    assert.doesNotMatch(source, /updateSliceStatus\(mid,\s*sid,\s*["']complete["']/,
-      'SUMMARY.md on disk must not mark slice complete in DB');
-  });
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ milestoneId: "M001", id: "S01", title: "Slice", status: "pending", sequence: 1 });
 
-  test('explicit rogue diagnostic reports stale slice summary projection', () => {
-    const branch = extractSourceRegion(source, 'unitType === "complete-slice"', 'unitType === "plan-milestone"');
-    assert.match(branch, /rogues\.push\(\{\s*path:\s*summaryPath,\s*unitType,\s*unitId\s*\}\)/,
-      'complete-slice branch should report stale SUMMARY.md as rogue');
-  });
+    const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    mkdirSync(dirname(summaryPath), { recursive: true });
+    writeFileSync(summaryPath, "# Summary\n", "utf-8");
+
+    const rogues = detectRogueFileWrites("complete-slice", "M001/S01", base);
 
-  test('post-unit runtime does not call rogue diagnostics automatically', () => {
-    const postUnit = extractSourceRegion(source, 'export async function postUnitPostVerification');
-    assert.doesNotMatch(postUnit, /detectRogueFileWrites\(/,
-      'runtime post-unit path must not scan disk projections for rogue files');
+    assert.deepEqual(rogues, [{ path: summaryPath, unitType: "complete-slice", unitId: "M001/S01" }]);
+    assert.equal(getSlice("M001", "S01")?.status, "pending");
   });
 });