@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.4fb2d460

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/skill-discovery.test.ts

@@ -109,3 +109,49 @@ test("appendDiscoveredSkillsFallback does not duplicate skills already in the pr
     location: "/tmp/already-loaded/SKILL.md",
   }]), prompt);
 });
+
+test("snapshotSkills({cwd}) detects skills added to the project .agents/skills/ mid-session", async () => {
+  await withTempSkillHome(async (home) => {
+    // Use a project dir under the temp home so cwd is isolated.
+    const projectDir = join(home, "myproject");
+    const projectSkills = join(projectDir, ".agents", "skills");
+    snapshotSkills({ cwd: projectDir });
+
+    // Add a skill to the project skills dir after the snapshot.
+    writeDiskSkill(projectSkills, "project-disk-skill", "Project skill added mid-session.");
+    const detected = detectNewSkills();
+
+    assert.deepEqual(detected.map(skill => skill.name), ["project-disk-skill"]);
+    assert.equal(detected[0].location, join(projectSkills, "project-disk-skill", "SKILL.md"));
+  });
+});
+
+test("snapshotSkills({cwd}) detects skills added to the project .claude/skills/ mid-session", async () => {
+  await withTempSkillHome(async (home) => {
+    const projectDir = join(home, "claude-project");
+    const claudeSkills = join(projectDir, ".claude", "skills");
+    snapshotSkills({ cwd: projectDir });
+
+    writeDiskSkill(claudeSkills, "claude-project-skill", "Claude-format skill added mid-session.");
+    const detected = detectNewSkills();
+
+    assert.deepEqual(detected.map(skill => skill.name), ["claude-project-skill"]);
+  });
+});
+
+test("snapshotSkills({cwd}) treats skills already in the project dir as baseline, not newly discovered", async () => {
+  await withTempSkillHome(async (home) => {
+    // projectDir is intentionally NOT process.cwd(): mirrors auto-mode passing a
+    // base path that differs from cwd (e.g. after chdir into a worktree). The
+    // baseline must scan the passed cwd's dirs, so a skill present *before* the
+    // snapshot is part of the baseline and is never reported as newly discovered.
+    // Regresses the fix where snapshotCurrentSkillNames fell back to process.cwd().
+    const projectDir = join(home, "preexisting-project");
+    const projectSkills = join(projectDir, ".agents", "skills");
+    writeDiskSkill(projectSkills, "preexisting-project-skill");
+
+    snapshotSkills({ cwd: projectDir });
+
+    assert.deepEqual(detectNewSkills(), []);
+  });
+});

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 ─────────────────────────────────────────────────────────────────
 

package/src/resources/extensions/gsd/tests/teardown-cleanup-parity.test.ts

@@ -22,7 +22,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { teardownAutoWorktree, _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree.ts";
+import { _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 
 function git(args: string[], cwd: string): void {
   execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });

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

@@ -38,13 +38,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 ─────────────────────────────────────────────────────────────────
 

package/src/resources/extensions/gsd/tests/token-tool-gating.test.ts

@@ -552,6 +552,41 @@ test("discuss-milestone dispatch keeps required headless milestone tools after t
   assert.ok(!activeTools.includes("gsd_complete_milestone"));
 });
 
+test("#1157: validate-milestone dispatch surface removes generic write and bash tools", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "ask_user_questions",
+    "bash",
+    "bg_shell",
+    "edit",
+    "find",
+    "glob",
+    "grep",
+    "ls",
+    "read",
+    "subagent",
+    "write",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_validate_milestone",
+    "gsd_reassess_roadmap",
+  ], "validate-milestone");
+
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("find"));
+  assert.ok(result.includes("subagent"));
+  assert.ok(result.includes("gsd_validate_milestone"));
+  assert.ok(result.includes("gsd_milestone_status"));
+  assert.ok(result.includes("gsd_exec"));
+  assert.ok(result.includes("gsd_reassess_roadmap"));
+  assert.ok(!result.includes("bash"));
+  assert.ok(!result.includes("bg_shell"));
+  assert.ok(!result.includes("write"));
+  assert.ok(!result.includes("edit"));
+  assert.ok(!result.includes("ask_user_questions"));
+});
+
 test("scopeGsdWorkflowToolsForDispatch applies and restores per-unit skill visibility", () => {
   const calls: Array<{ kind: "tools" | "skills"; value: string[] | undefined }> = [];
   let activeTools = [