@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.553dc518

package/src/resources/extensions/gsd/tests/repository-registry.test.ts

@@ -83,7 +83,7 @@ test("defaultRepositoryTargets returns [project] for a single-repo project regis
   assert.deepEqual(defaultRepositoryTargets(registry), ["project"]);
 });
 
-test("defaultRepositoryTargets returns [project] for a parent-mode registry", (t) => {
+test("defaultRepositoryTargets returns declared child repos for a parent-mode registry", (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-repo-registry-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));
   mkdirSync(join(base, ".gsd"), { recursive: true });
@@ -98,7 +98,46 @@ test("defaultRepositoryTargets returns [project] for a parent-mode registry", (t
     },
   });
 
-  assert.deepEqual(defaultRepositoryTargets(registry), ["project"]);
+  assert.deepEqual(defaultRepositoryTargets(registry), ["frontend"]);
+});
+
+test("defaultRepositoryTargets returns all child repos (declaration order) in parent mode", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-repo-registry-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  mkdirSync(join(base, "frontend"), { recursive: true });
+  mkdirSync(join(base, "backend"), { recursive: true });
+
+  const registry = createRepositoryRegistryFromPreferences(base, {
+    workspace: {
+      mode: "parent",
+      repositories: {
+        frontend: { path: "frontend" },
+        backend: { path: "backend" },
+      },
+    },
+  });
+
+  assert.deepEqual(defaultRepositoryTargets(registry), ["frontend", "backend"]);
+});
+
+test("defaultRepositoryTargets excludes the implicit project repo in parent mode", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-repo-registry-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  mkdirSync(join(base, "frontend"), { recursive: true });
+
+  const registry = createRepositoryRegistryFromPreferences(base, {
+    workspace: {
+      mode: "parent",
+      repositories: {
+        frontend: { path: "frontend" },
+      },
+    },
+  });
+
+  const targets = defaultRepositoryTargets(registry);
+  assert.ok(!targets.includes("project"), "implicit project repo must not be a default target in parent mode");
 });
 
 test("repository registry keeps project root anchored to .gsd project in monorepo subdirectory", (t) => {

package/src/resources/extensions/gsd/tests/require-slice-discussion-dispatch.test.ts

@@ -16,6 +16,13 @@ import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import {
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.ts";
 import type { GSDState } from "../types.ts";
 import type { GSDPreferences } from "../preferences.ts";
 
@@ -87,6 +94,54 @@ describe("require_slice_discussion dispatch rule (#3454)", () => {
     }
   });
 
+  test("includes prior non-PASS UAT warning when the just-closed slice failed", async () => {
+    const basePath = makeBasePath("prior-fail");
+    const dbDir = mkdtempSync(join(tmpdir(), "gsd-req-slice-db-"));
+    const dbPath = join(dbDir, "test.db");
+    try {
+      openDatabase(dbPath);
+      mkdirSync(join(basePath, ".gsd", "milestones", "M001", "slices", "S02"), { recursive: true });
+
+      insertMilestone({ id: "M001", title: "Test milestone" });
+      insertSlice({ id: "S01", milestoneId: "M001", title: "Completed slice", status: "complete", sequence: 1 });
+      insertSlice({ id: "S02", milestoneId: "M001", title: "Next slice", status: "pending", sequence: 2 });
+
+      const assessmentPath = ".gsd/milestones/M001/slices/S01/S01-ASSESSMENT.md";
+      const assessmentBody = [
+        "---",
+        "verdict: fail",
+        "---",
+        "",
+        "# S01 UAT Assessment",
+      ].join("\n");
+      writeFileSync(join(basePath, assessmentPath), assessmentBody, "utf-8");
+      insertAssessment({
+        path: assessmentPath,
+        milestoneId: "M001",
+        sliceId: "S01",
+        status: "fail",
+        scope: "run-uat",
+        fullContent: assessmentBody,
+      });
+
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const state = buildState({ activeSlice: { id: "S02", title: "Next slice" } });
+      const action = await findRule().match(buildCtx(basePath, prefs, state));
+
+      assert.ok(action, "rule must still pause for discussion");
+      assert.strictEqual(action!.action, "stop");
+      if (action!.action === "stop") {
+        assert.match(action!.reason, /S02 requires discussion/);
+        assert.match(action!.reason, /slice just closed \(S01\)/);
+        assert.match(action!.reason, /non-PASS UAT verdict \(FAIL\)/);
+      }
+    } finally {
+      closeDatabase();
+      rmSync(basePath, { recursive: true, force: true });
+      rmSync(dbDir, { recursive: true, force: true });
+    }
+  });
+
   // ─── Negative cases: rule falls through ───────────────────────────────
 
   test("falls through (null) when preference is disabled", async () => {

package/src/resources/extensions/gsd/tests/root-write-leak-guard.test.ts

@@ -3,11 +3,11 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { closeSync, ftruncateSync, openSync, statSync, writeFileSync } from "node:fs";
+import { closeSync, ftruncateSync, openSync, statSync } from "node:fs";
 import { join } from "node:path";
 
-import { captureRootDirtySnapshot } from "../root-write-leak-guard.ts";
-import { cleanup, createFile, git, makeTempRepo } from "./test-utils.ts";
+import { captureRootDirtySnapshot, detectRootWriteLeak } from "../root-write-leak-guard.ts";
+import { cleanup, createFile, makeTempRepo } from "./test-utils.ts";
 
 test("captureRootDirtySnapshot ignores unignored GSD root runtime directories", () => {
   const base = makeTempRepo("gsd-root-dirty-runtime-");
@@ -34,11 +34,7 @@ test("captureRootDirtySnapshot does not read dirty files larger than Node's Buff
     const relPath = "large.bin";
     const absPath = join(base, relPath);
 
-    writeFileSync(absPath, "tracked\n", "utf-8");
-    git(base, "add", relPath);
-    git(base, "commit", "-m", "track large fixture");
-
-    const fd = openSync(absPath, "r+");
+    const fd = openSync(absPath, "w");
     try {
       ftruncateSync(fd, 2_200 * 1024 * 1024);
     } finally {
@@ -51,9 +47,35 @@ test("captureRootDirtySnapshot does not read dirty files larger than Node's Buff
     const snapshot = captureRootDirtySnapshot(base);
     const entry = snapshot.get(relPath);
 
-    assert.equal(entry?.status, "M");
+    assert.equal(entry?.status, "??");
     assert.match(entry?.fingerprint ?? "", /^large:\d+:/);
   } finally {
     cleanup(base);
   }
 });
+
+test("detectRootWriteLeak reports changed baseline untracked root files", () => {
+  const base = makeTempRepo("gsd-root-dirty-baseline-");
+  try {
+    const relPath = "notes/todo.md";
+    createFile(base, relPath, "before\n");
+    const before = captureRootDirtySnapshot(base);
+
+    createFile(base, relPath, "after\n");
+    const leak = detectRootWriteLeak({
+      rootPath: base,
+      worktreePath: join(base, ".gsd", "worktrees", "M001"),
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      before,
+    });
+
+    assert.ok(leak, "changed baseline untracked file should be reported as a leak");
+    assert.deepEqual(
+      leak.files.map((file) => file.path),
+      [relPath],
+    );
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/runtime-invariant-modules.test.ts

@@ -10,6 +10,7 @@ import {
   compileUnitContextContract,
   compileUnitToolContract,
   getUnitWorkflowDispatchReadinessError,
+  getUnitWorkflowDispatchReadinessErrorForModel,
 } from "../tool-contract.js";
 import { shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
 import type { GSDState } from "../types.js";
@@ -111,6 +112,25 @@ test("Tool Contract derives dispatch readiness from Unit workflow tools", () =>
   assert.equal(error, null);
 });
 
+test("Tool Contract derives dispatch readiness from selected model context", () => {
+  const authLookups: string[] = [];
+  const error = getUnitWorkflowDispatchReadinessErrorForModel({
+    model: { provider: "claude-code" },
+    fallbackModel: { provider: "openai-codex", baseUrl: "local://claude-code" },
+    getProviderAuthMode(provider) {
+      authLookups.push(provider);
+      return provider === "claude-code" ? "externalCli" : "oauth";
+    },
+    unitType: "plan-slice",
+    projectRoot: "/tmp/project",
+    env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+    surface: "auto-mode",
+  });
+
+  assert.equal(error, null);
+  assert.deepEqual(authLookups, ["claude-code"]);
+});
+
 test("Unit Context Contract exposes prompt context without workflow tool surface", () => {
   const result = compileUnitContextContract("execute-task");
 

package/src/resources/extensions/gsd/tests/schedule-wakeup-tool.test.ts

@@ -0,0 +1,167 @@
+// Project/App: gsd-pi
+// File Purpose: Regression tests for ScheduleWakeup tool behavior.
+
+import test, { mock } from "node:test";
+import assert from "node:assert/strict";
+
+import { autoSession } from "../auto-runtime-state.ts";
+import {
+  registerScheduleWakeupTool,
+  _resetInteractiveWakeupsForTest,
+} from "../bootstrap/schedule-wakeup-tool.ts";
+
+test("ScheduleWakeup arms an interactive wakeup when auto-mode is inactive", async () => {
+  autoSession.reset();
+  _resetInteractiveWakeupsForTest();
+  mock.timers.enable({ apis: ["setTimeout"] });
+
+  const sent: Array<{ message: unknown; options: unknown }> = [];
+  let tool: any;
+  const pi = {
+    registerTool(registered: any) {
+      tool = registered;
+    },
+    sendMessage(message: unknown, options: unknown) {
+      sent.push({ message, options });
+    },
+  };
+
+  try {
+    registerScheduleWakeupTool(pi as any);
+    assert.ok(tool, "ScheduleWakeup tool should be registered");
+
+    const result = await tool.execute(
+      "call-1",
+      {
+        delaySeconds: 1,
+        prompt: "Check the external job and report back.",
+        reason: "poll external job",
+      },
+      undefined,
+      undefined,
+      { cwd: process.cwd() },
+    );
+
+    assert.equal(result.isError, undefined);
+    assert.match(result.content[0].text, /Wakeup scheduled for 1s/);
+    assert.equal(sent.length, 0, "wakeup should not dispatch synchronously");
+
+    mock.timers.tick(999);
+    assert.equal(sent.length, 0, "wakeup should wait for the configured delay");
+
+    mock.timers.tick(1);
+    assert.equal(sent.length, 1);
+    assert.deepEqual(sent[0].options, { triggerTurn: true });
+    assert.deepEqual(sent[0].message, {
+      customType: "gsd-schedule-wakeup",
+      content: "Check the external job and report back.",
+      display: true,
+      details: {
+        delaySeconds: 1,
+        reason: "poll external job",
+      },
+    });
+  } finally {
+    mock.timers.reset();
+    _resetInteractiveWakeupsForTest();
+    autoSession.reset();
+  }
+});
+
+test("ScheduleWakeup re-arm cancels the prior interactive timer instead of stacking", async () => {
+  autoSession.reset();
+  _resetInteractiveWakeupsForTest();
+  mock.timers.enable({ apis: ["setTimeout"] });
+
+  const sent: Array<{ message: any; options: unknown }> = [];
+  let tool: any;
+  const pi = {
+    registerTool(registered: any) {
+      tool = registered;
+    },
+    sendMessage(message: unknown, options: unknown) {
+      sent.push({ message, options } as { message: any; options: unknown });
+    },
+  };
+
+  try {
+    registerScheduleWakeupTool(pi as any);
+    assert.ok(tool, "ScheduleWakeup tool should be registered");
+
+    const ctx = { cwd: process.cwd() };
+    await tool.execute(
+      "call-1",
+      { delaySeconds: 5, prompt: "stale prompt", reason: "first arm" },
+      undefined,
+      undefined,
+      ctx,
+    );
+    await tool.execute(
+      "call-2",
+      { delaySeconds: 5, prompt: "fresh prompt", reason: "re-arm" },
+      undefined,
+      undefined,
+      ctx,
+    );
+
+    mock.timers.tick(5000);
+
+    assert.equal(sent.length, 1, "re-arming must not stack overlapping wakeups");
+    assert.equal(sent[0].message.content, "fresh prompt");
+  } finally {
+    mock.timers.reset();
+    _resetInteractiveWakeupsForTest();
+    autoSession.reset();
+  }
+});
+
+test("ScheduleWakeup keeps interactive wakeups isolated per session base path", async () => {
+  autoSession.reset();
+  _resetInteractiveWakeupsForTest();
+  mock.timers.enable({ apis: ["setTimeout"] });
+
+  const sent: Array<{ message: any; options: unknown }> = [];
+  let tool: any;
+  const pi = {
+    registerTool(registered: any) {
+      tool = registered;
+    },
+    sendMessage(message: unknown, options: unknown) {
+      sent.push({ message, options } as { message: any; options: unknown });
+    },
+  };
+
+  try {
+    registerScheduleWakeupTool(pi as any);
+    assert.ok(tool, "ScheduleWakeup tool should be registered");
+
+    // Two concurrent interactive sessions (different cwds) arm wakeups. One
+    // session re-arming must not cancel the other session's pending wakeup.
+    await tool.execute(
+      "call-a",
+      { delaySeconds: 5, prompt: "session A", reason: "poll A" },
+      undefined,
+      undefined,
+      { cwd: "/tmp" },
+    );
+    await tool.execute(
+      "call-b",
+      { delaySeconds: 5, prompt: "session B", reason: "poll B" },
+      undefined,
+      undefined,
+      { cwd: process.cwd() },
+    );
+
+    mock.timers.tick(5000);
+
+    assert.equal(sent.length, 2, "distinct sessions must each keep their wakeup");
+    assert.deepEqual(
+      sent.map((s) => s.message.content).sort(),
+      ["session A", "session B"],
+    );
+  } finally {
+    mock.timers.reset();
+    _resetInteractiveWakeupsForTest();
+    autoSession.reset();
+  }
+});

package/src/resources/extensions/gsd/tests/stale-worktree-cwd.test.ts

@@ -12,11 +12,9 @@ import { join, sep } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import {
-  createAutoWorktree,
-  teardownAutoWorktree,
-  mergeMilestoneToMain,
-} from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 import { _resetServiceCache } from "../worktree.ts";
 import { _clearGsdRootCache } from "../paths.ts";
 

package/src/resources/extensions/gsd/tests/stalled-tool-recovery.test.ts

@@ -18,6 +18,7 @@
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { verifyExpectedArtifact } from "../auto-recovery.ts";
 import { recoverTimedOutUnit, type RecoveryContext } from "../auto-timeout-recovery.ts";
 import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.ts";
 import { test } from 'node:test';
@@ -167,6 +168,54 @@ function makeRecordingCtx() {
   }
 }
 
+// ═══ plan-slice verification accepts completed task summaries ═══════════════
+
+{
+  console.log("\n=== plan-slice verification accepts completed task summaries ===");
+  const base = mkdtempSync(join(tmpdir(), "gsd-plan-slice-complete-summary-"));
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S05");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S05", milestoneId: "M001", title: "Slice", status: "in_progress" });
+    insertTask({ id: "T01", milestoneId: "M001", sliceId: "S05", title: "Done 1", status: "complete" });
+    insertTask({ id: "T02", milestoneId: "M001", sliceId: "S05", title: "Done 2", status: "complete" });
+    insertTask({ id: "T03", milestoneId: "M001", sliceId: "S05", title: "Pending 1", status: "pending" });
+    insertTask({ id: "T04", milestoneId: "M001", sliceId: "S05", title: "Pending 2", status: "pending" });
+    writeFileSync(
+      join(sliceDir, "S05-PLAN.md"),
+      [
+        "# S05: Slice",
+        "",
+        "## Tasks",
+        "",
+        "- [x] **T01: Done 1** `est:10m`",
+        "- [x] **T02: Done 2** `est:10m`",
+        "- [ ] **T03: Pending 1** `est:10m`",
+        "- [ ] **T04: Pending 2** `est:10m`",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+    writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n", "utf-8");
+    writeFileSync(join(tasksDir, "T02-SUMMARY.md"), "# T02 Summary\n", "utf-8");
+    writeFileSync(join(tasksDir, "T03-PLAN.md"), "# T03 Plan\n", "utf-8");
+    writeFileSync(join(tasksDir, "T04-PLAN.md"), "# T04 Plan\n", "utf-8");
+
+    assert.equal(
+      verifyExpectedArtifact("plan-slice", "M001/S05", base),
+      true,
+      "completed DB tasks should be accounted for by SUMMARY files",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
 // ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
 
 {

package/src/resources/extensions/gsd/tests/stash-pop-gsd-conflict.test.ts

@@ -14,7 +14,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { createAutoWorktree, mergeMilestoneToMain } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
 import { _resetServiceCache } from "../worktree.ts";
 import { _clearGsdRootCache } from "../paths.ts";
 

package/src/resources/extensions/gsd/tests/stash-queued-context-files.test.ts

@@ -28,7 +28,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { createAutoWorktree, mergeMilestoneToMain } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
 import { _resetServiceCache } from "../worktree.ts";
 import { _clearGsdRootCache } from "../paths.ts";
 

package/src/resources/extensions/gsd/tests/state-corruption-2945.test.ts

@@ -312,7 +312,7 @@ describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merg
       } as unknown as AutoSession;
 
       const deps = {
-        mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+        mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
         worktreeProjection: new WorktreeStateProjection(),
         gitServiceFactory: () => ({}) as unknown as ReturnType<
           import("../worktree-lifecycle.js").WorktreeLifecycleDeps["gitServiceFactory"]

package/src/resources/extensions/gsd/tests/status-per-repo.test.ts

@@ -0,0 +1,94 @@
+/**
+ * status-per-repo.test.ts — `/gsd status` per-repository git-health block (#818).
+ *
+ * Covers the parent-workspace addition to formatTextStatus:
+ *   - parent mode with child repos → "Repositories:" section listing each
+ *   - dirty vs clean markers
+ *   - single-repo (project-mode) project → no Repositories section
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { formatTextStatus } from "../commands/handlers/core.ts";
+import type { GSDState } from "../types.ts";
+
+function gitInit(cwd: string): void {
+  execFileSync("git", ["init"], { cwd, stdio: "ignore" });
+}
+
+function makeBaseState(): GSDState {
+  return {
+    activeMilestone: null,
+    activeSlice: null,
+    activeTask: null,
+    phase: "planning",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "None",
+    registry: [],
+  };
+}
+
+function writeParentPrefs(base: string, repos: Record<string, { path: string; role?: string }>): void {
+  const repoLines = Object.entries(repos)
+    .map(([id, cfg]) => `    ${id}:\n      path: ${cfg.path}${cfg.role ? `\n      role: ${cfg.role}` : ""}`)
+    .join("\n");
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    `---\nversion: 1\nworkspace:\n  mode: parent\n  repositories:\n${repoLines}\n---\n`,
+    "utf-8",
+  );
+}
+
+test("formatTextStatus shows a Repositories section for a clean parent workspace", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-status-repo-clean-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    mkdirSync(join(base, "frontend"), { recursive: true });
+    gitInit(join(base, "frontend"));
+    writeParentPrefs(base, { frontend: { path: "frontend", role: "web UI" } });
+
+    const out = formatTextStatus(makeBaseState(), base);
+    assert.match(out, /Repositories:/);
+    assert.match(out, /✓ frontend — web UI \(clean\)/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("formatTextStatus marks a dirty child repo with ✗", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-status-repo-dirty-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    mkdirSync(join(base, "backend"), { recursive: true });
+    gitInit(join(base, "backend"));
+    writeParentPrefs(base, { backend: { path: "backend" } });
+    // Make the backend repo dirty.
+    writeFileSync(join(base, "backend", "README.md"), "# dirty\n", "utf-8");
+
+    const out = formatTextStatus(makeBaseState(), base);
+    assert.match(out, /✗ backend \(uncommitted changes\)/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("formatTextStatus omits the Repositories section for single-repo projects", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-status-repo-single-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    // No workspace config → project mode (default).
+    const out = formatTextStatus(makeBaseState(), base);
+    assert.doesNotMatch(out, /Repositories:/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/steer-worktree-path.test.ts

@@ -8,7 +8,7 @@ import { mkdtempSync, mkdirSync, existsSync, readFileSync, rmSync, writeFileSync
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { appendOverride, loadActiveOverrides } from "../files.ts";
-import { getAutoWorktreePath } from "../auto-worktree.ts";
+import { getAutoWorktreePath } from "../auto-worktree-path-resolution.ts";
 
 describe("steer worktree path resolution (#3476)", () => {
   let projectRoot: string;

package/src/resources/extensions/gsd/tests/sync-worktree-skip-current.test.ts

@@ -8,7 +8,7 @@ import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { syncWorktreeStateBack } from "../auto-worktree.ts";
+import { syncWorktreeStateBack } from "../auto-worktree-sync.ts";
 
 describe("syncWorktreeStateBack does not copy worktree milestone projections", () => {
   it("copies root diagnostics but leaves milestone markdown directories behind", () => {

package/src/resources/extensions/gsd/tests/system-flat-phase-layout.test.ts

@@ -0,0 +1,33 @@
+// gsd-pi — Regression tests: system.md documents the flat-phase layout, not legacy milestone/slice/task paths
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const promptsDir = join(process.cwd(), "src/resources/extensions/gsd/prompts");
+
+function readPrompt(name: string): string {
+  return readFileSync(join(promptsDir, `${name}.md`), "utf-8");
+}
+
+test("system.md does not advertise legacy milestone/slice/task artifact paths", () => {
+  const prompt = readPrompt("system");
+  for (const legacy of [".gsd/milestones", "milestones/M001", "slices/S01", "tasks/T01-PLAN.md"]) {
+    assert.ok(
+      !prompt.includes(legacy),
+      `system.md must not reference the legacy path fragment "${legacy}" after flat-phase migration`,
+    );
+  }
+});
+
+test("system.md documents the flat-phase directory structure", () => {
+  const prompt = readPrompt("system");
+  assert.match(prompt, /phases\/\{MM\}-\{slug\}/, "system.md must document phases/{MM}-{slug}/ directories");
+  assert.match(prompt, /\{MM\}-\{SS\}-PLAN\.md/, "system.md must document {MM}-{SS}-PLAN.md slice plans");
+  assert.match(
+    prompt,
+    /do not expect `tasks\/T##-PLAN\.md`/,
+    "system.md must state task plan content lives inside the slice plan, not tasks/T##-PLAN.md",
+  );
+});

package/src/resources/extensions/gsd/tests/teardown-chdir-failure-clears-registry.test.ts

@@ -36,13 +36,13 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
 import {
-  createAutoWorktree,
-  teardownAutoWorktree,
-  getAutoWorktreeOriginalBase,
   getActiveAutoWorktreeContext,
+  getAutoWorktreeOriginalBase,
   _resetAutoWorktreeOriginalBaseForTests,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────