gsd-pi 2.66.1-dev.ed243f2 → 2.67.0

package/src/resources/extensions/gsd/tests/detection.test.ts

@@ -17,6 +17,7 @@ import {
   detectProjectState,
   detectV1Planning,
   detectProjectSignals,
+  scanProjectFiles,
 } from "../detection.ts";
 
 function makeTempDir(prefix: string): string {
@@ -1188,3 +1189,39 @@ test("detectProjectSignals: Spring Boot settings-defined catalog accessor emits
     cleanup(dir);
   }
 });
+
+// ─── scanProjectFiles: RECURSIVE_SCAN_IGNORED_DIRS ──────────────────────
+
+test("scanProjectFiles: excludes .claude, .gsd, .planning, .plans, .cursor, .vscode directories", () => {
+  const dir = makeTempDir("scan-ignore-dotdirs");
+  try {
+    // Create project files that should be included
+    mkdirSync(join(dir, "src"), { recursive: true });
+    writeFileSync(join(dir, "src", "main.ts"), "// main\n", "utf-8");
+    writeFileSync(join(dir, "README.md"), "# Project\n", "utf-8");
+
+    // Create tool directories that should be excluded
+    const excludedDirs = [".claude", ".gsd", ".planning", ".plans", ".cursor", ".vscode"];
+    for (const d of excludedDirs) {
+      mkdirSync(join(dir, d), { recursive: true });
+      writeFileSync(join(dir, d, "config.json"), "{}\n", "utf-8");
+    }
+    // Nested .claude directory
+    mkdirSync(join(dir, ".claude", "memory"), { recursive: true });
+    writeFileSync(join(dir, ".claude", "memory", "user.md"), "# Memory\n", "utf-8");
+
+    const files = scanProjectFiles(dir);
+
+    // Should include project files
+    assert.ok(files.includes("src/main.ts"), "should include src/main.ts");
+    assert.ok(files.includes("README.md"), "should include README.md");
+
+    // Should exclude all tool directories
+    for (const d of excludedDirs) {
+      const hasExcluded = files.some((f) => f.startsWith(`${d}/`));
+      assert.ok(!hasExcluded, `should exclude ${d}/ directory but found: ${files.filter((f) => f.startsWith(`${d}/`)).join(", ")}`);
+    }
+  } finally {
+    cleanup(dir);
+  }
+});

package/src/resources/extensions/gsd/tests/file-change-validator.test.ts

@@ -0,0 +1,50 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { validateFileChanges } from "../safety/file-change-validator.ts";
+
+function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+test("validateFileChanges ignores inline descriptions in expected output paths", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-file-change-validator-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  mkdirSync(join(base, "definitions"), { recursive: true });
+  git(base, "init");
+  git(base, "config", "user.email", "test@example.com");
+  git(base, "config", "user.name", "Test User");
+
+  const target = join(base, "definitions", "ac-audit.md");
+  writeFileSync(target, "initial\n");
+  git(base, "add", ".");
+  git(base, "commit", "-m", "initial");
+
+  writeFileSync(target, "updated\n");
+  git(base, "add", ".");
+  git(base, "commit", "-m", "update");
+
+  const audit = validateFileChanges(
+    base,
+    ["definitions/ac-audit.md — current state of AC CRM, tags, pipelines, automations"],
+    [],
+  );
+
+  assert.ok(audit, "audit should be produced when expected output exists");
+  assert.deepEqual(audit.unexpectedFiles, []);
+  assert.deepEqual(audit.missingFiles, []);
+  assert.equal(
+    audit.violations.some((v) => v.severity === "warning"),
+    false,
+    "described expected output should not trigger unexpected-file warnings",
+  );
+});

package/src/resources/extensions/gsd/tests/gsd-tools.test.ts

@@ -245,6 +245,41 @@ describe('gsd-tools', () => {
     }
   });
 
+  test('gsd_summary_save supports CONTEXT-DRAFT persistence', async () => {
+    const tmpDir = makeTmpDir();
+    try {
+      const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+      openDatabase(dbPath);
+
+      await saveArtifactToDb(
+        {
+          path: 'milestones/M001/M001-CONTEXT-DRAFT.md',
+          artifact_type: 'CONTEXT-DRAFT',
+          content: '# M001 Draft Context\n\nDraft notes.',
+          milestone_id: 'M001',
+        },
+        tmpDir,
+      );
+
+      const draftPath = path.join(tmpDir, '.gsd', 'milestones', 'M001', 'M001-CONTEXT-DRAFT.md');
+      assert.ok(fs.existsSync(draftPath), 'Draft context file should be created');
+      const draftContent = fs.readFileSync(draftPath, 'utf-8');
+      assert.ok(draftContent.includes('Draft Context'), 'Draft context file should contain draft content');
+
+      const adapter = _getAdapter();
+      assert.ok(adapter !== null, 'Adapter should be available');
+      const rows = adapter!.prepare(
+        "SELECT * FROM artifacts WHERE path = 'milestones/M001/M001-CONTEXT-DRAFT.md'",
+      ).all();
+      assert.deepStrictEqual(rows.length, 1, 'Should have 1 draft artifact row');
+      assert.deepStrictEqual(rows[0]['artifact_type'] as string, 'CONTEXT-DRAFT', 'Artifact type should be CONTEXT-DRAFT');
+
+      closeDatabase();
+    } finally {
+      cleanupDir(tmpDir);
+    }
+  });
+
   test('DB unavailable error paths', async () => {
     // (d) All tools return isError when DB unavailable
     // Close any open DB and don't open a new one

package/src/resources/extensions/gsd/tests/guided-flow-session-isolation.test.ts

@@ -10,11 +10,15 @@
 
 import { describe, test, beforeEach } 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 {
   getDiscussionMilestoneId,
   setPendingAutoStart,
   clearPendingAutoStart,
+  checkAutoStartAfterDiscuss,
 } from "../guided-flow.ts";
 
 // ─── Tests ─────────────────────────────────────────────────────────────────
@@ -95,3 +99,33 @@ describe("#2985 Bug 4 — getDiscussionMilestoneId must be keyed by basePath", (
     assert.equal(result, "M001", "should return the only active milestone for backward compat");
   });
 });
+
+test("checkAutoStartAfterDiscuss fails closed when a multi-milestone manifest is missing", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-auto-start-manifest-"));
+  try {
+    const gsdDir = join(base, ".gsd");
+    const milestoneDir = join(gsdDir, "milestones", "M001");
+    mkdirSync(milestoneDir, { recursive: true });
+    mkdirSync(join(gsdDir, "milestones", "M002"), { recursive: true });
+    writeFileSync(
+      join(gsdDir, "PROJECT.md"),
+      `# Project\n\n| M001 | First milestone | active |\n| M002 | Second milestone | queued |\n`,
+    );
+    writeFileSync(join(gsdDir, "STATE.md"), "# State\n");
+    writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# M001 Context\n");
+
+    clearPendingAutoStart();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: { ui: { notify: () => undefined } } as any,
+      pi: { setActiveTools: () => undefined, getActiveTools: () => [] } as any,
+    });
+
+    const started = checkAutoStartAfterDiscuss();
+    assert.equal(started, false, "auto-start should fail closed without the manifest");
+  } finally {
+    clearPendingAutoStart();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -9,6 +9,7 @@ import {
   formatRelativeTime,
   type HealthWidgetData,
 } from "../health-widget-core.ts";
+import { registerHooks } from "../bootstrap/register-hooks.ts";
 
 function makeTempDir(prefix: string): string {
   const dir = join(
@@ -177,3 +178,47 @@ test("detectHealthWidgetProjectState: metrics file alone does not imply project"
   );
   assert.equal(detectHealthWidgetProjectState(dir), "initialized");
 });
+
+test("session_start bootstraps the health widget alongside notifications", async (t) => {
+  const dir = makeTempDir("bootstrap");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  t.after(() => {
+    process.chdir(originalCwd);
+    cleanup(dir);
+  });
+
+  const widgets: string[] = [];
+  const handlers = new Map<string, (event: unknown, ctx: any) => Promise<void> | void>();
+  const pi = {
+    on(event: string, handler: (event: unknown, ctx: any) => Promise<void> | void) {
+      handlers.set(event, handler);
+    },
+  } as any;
+
+  registerHooks(pi);
+  const sessionStart = handlers.get("session_start");
+  assert.ok(sessionStart, "session_start handler is registered");
+
+  await sessionStart!({}, {
+    hasUI: true,
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setWorkingMessage: () => {},
+      onTerminalInput: () => () => {},
+      setWidget: (key: string) => {
+        widgets.push(key);
+      },
+    },
+    sessionManager: {
+      getSessionId: () => null,
+    },
+    model: null,
+  } as any);
+
+  assert.ok(widgets.includes("gsd-health"), "health widget is bootstrapped");
+  assert.ok(widgets.includes("gsd-notifications"), "notification widget still boots");
+});

package/src/resources/extensions/gsd/tests/integration/auto-recovery.test.ts

@@ -1,9 +1,10 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, writeFileSync, existsSync, readFileSync, rmSync } from "node:fs";
+import { mkdirSync, writeFileSync, existsSync, readFileSync, rmSync, chmodSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
 
 import {
   resolveExpectedArtifactPath,
@@ -11,6 +12,7 @@ import {
   diagnoseExpectedArtifact,
   buildLoopRemediationSteps,
   hasImplementationArtifacts,
+  reconcileMergeState,
 } from "../../auto-recovery.ts";
 import { parseRoadmap, parsePlan } from "../../parsers-legacy.ts";
 import { parseTaskPlanFile, clearParseCache } from "../../files.ts";
@@ -669,8 +671,6 @@ test("#793: invalidateAllCaches clears all caches so deriveState sees fresh disk
 
 // ─── hasImplementationArtifacts (#1703) ───────────────────────────────────
 
-import { execFileSync } from "node:child_process";
-
 function makeGitBase(): string {
   const base = join(tmpdir(), `gsd-test-git-${randomUUID()}`);
   mkdirSync(base, { recursive: true });
@@ -745,9 +745,6 @@ test("verifyExpectedArtifact complete-milestone fails with only .gsd/ files (#17
 
 // ─── reconcileMergeState: silent nativeCommit failure (#2542) ─────────────
 
-import { reconcileMergeState } from "../../auto-recovery.ts";
-import { chmodSync } from "node:fs";
-
 function makeMockCtx(): { ctx: any; notifications: Array<{ msg: string; level: string }> } {
   const notifications: Array<{ msg: string; level: string }> = [];
   const ctx = {
@@ -760,7 +757,7 @@ function makeMockCtx(): { ctx: any; notifications: Array<{ msg: string; level: s
   return { ctx, notifications };
 }
 
-test("reconcileMergeState returns false and notifies error when nativeCommit fails (#2542)", (t) => {
+test("reconcileMergeState returns blocked and notifies error when nativeCommit fails (#2542)", (t) => {
   const base = makeGitBase();
   t.after(() => cleanup(base));
 
@@ -786,9 +783,7 @@ test("reconcileMergeState returns false and notifies error when nativeCommit fai
   const { ctx, notifications } = makeMockCtx();
   const result = reconcileMergeState(base, ctx);
 
-  // The function should return false to signal reconciliation failure
-  // (Currently it silently swallows the error and returns true — this test should FAIL before the fix)
-  assert.equal(result, false, "reconcileMergeState should return false when nativeCommit fails");
+  assert.equal(result, "blocked", "reconcileMergeState should return blocked when nativeCommit fails");
   const errorNotifications = notifications.filter(n => n.level === "error");
   assert.ok(errorNotifications.length > 0, "should notify an error when nativeCommit fails");
   assert.ok(
@@ -797,18 +792,63 @@ test("reconcileMergeState returns false and notifies error when nativeCommit fai
   );
 });
 
-test("reconcileMergeState returns true when no merge state present", (t) => {
-  // When there's no MERGE_HEAD or SQUASH_MSG, reconcileMergeState returns false (no dirty state)
+test("reconcileMergeState returns clean when no merge state present", (t) => {
   const base = makeGitBase();
   t.after(() => cleanup(base));
 
   const { ctx, notifications } = makeMockCtx();
   const result = reconcileMergeState(base, ctx);
 
-  assert.equal(result, false, "should return false when no merge state exists");
+  assert.equal(result, "clean", "should return clean when no merge state exists");
   assert.equal(notifications.length, 0, "should not notify when no merge state present");
 });
 
+test("reconcileMergeState blocks and preserves unresolved code conflicts", (t) => {
+  const base = makeGitBase();
+  t.after(() => cleanup(base));
+
+  writeFileSync(join(base, "conflict.txt"), "base\n");
+  execFileSync("git", ["add", "conflict.txt"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "add conflict base"], { cwd: base, stdio: "ignore" });
+
+  execFileSync("git", ["checkout", "-b", "feature"], { cwd: base, stdio: "ignore" });
+  writeFileSync(join(base, "conflict.txt"), "feature\n");
+  execFileSync("git", ["add", "conflict.txt"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "feature change"], { cwd: base, stdio: "ignore" });
+
+  execFileSync("git", ["checkout", "main"], { cwd: base, stdio: "ignore" });
+  writeFileSync(join(base, "conflict.txt"), "main\n");
+  execFileSync("git", ["add", "conflict.txt"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "main change"], { cwd: base, stdio: "ignore" });
+
+  let mergeFailed = false;
+  try {
+    execFileSync("git", ["merge", "--no-ff", "feature"], { cwd: base, stdio: "ignore" });
+  } catch {
+    mergeFailed = true;
+  }
+  assert.equal(mergeFailed, true, "merge should produce a conflict");
+  assert.ok(existsSync(join(base, ".git", "MERGE_HEAD")), "MERGE_HEAD should remain present before reconcile");
+
+  const beforeContents = readFileSync(join(base, "conflict.txt"), "utf8");
+  assert.match(beforeContents, /<<<<<<<|=======|>>>>>>>/, "fixture should contain conflict markers");
+
+  const { ctx, notifications } = makeMockCtx();
+  const result = reconcileMergeState(base, ctx);
+
+  assert.equal(result, "blocked", "code conflicts should block reconciliation");
+  assert.ok(existsSync(join(base, ".git", "MERGE_HEAD")), "MERGE_HEAD should be preserved for manual resolution");
+  assert.equal(
+    readFileSync(join(base, "conflict.txt"), "utf8"),
+    beforeContents,
+    "reconcile should preserve the conflicted file contents",
+  );
+  assert.ok(
+    notifications.some((n) => n.level === "error" && n.msg.includes("manual conflict resolution is preserved")),
+    "should notify that auto-mode paused and preserved manual work",
+  );
+});
+
 test("verifyExpectedArtifact complete-milestone passes with impl files (#1703)", (t) => {
   const base = makeGitBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/integration/state-machine-runtime-failures.test.ts

@@ -360,8 +360,8 @@ describe("session management", () => {
     assert.equal(s.unitRecoveryCount.size, 0, "recovery counts cleared");
   });
 
-  test("NEW_SESSION_TIMEOUT_MS is 30 seconds", () => {
-    assert.equal(NEW_SESSION_TIMEOUT_MS, 30_000, "session timeout should be 30s");
+  test("NEW_SESSION_TIMEOUT_MS is 120 seconds", () => {
+    assert.equal(NEW_SESSION_TIMEOUT_MS, 120_000, "session timeout should be 120s");
   });
 
   test("MAX_UNIT_DISPATCHES limits retries for a single unit", () => {

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -72,7 +72,7 @@ function makeMockDeps(
     getCurrentBranch: () => "main",
     autoWorktreeBranch: () => "auto/M001",
     resolveMilestoneFile: () => null,
-    reconcileMergeState: () => false,
+    reconcileMergeState: () => "clean",
     getLedger: () => ({ units: [] }),
     getProjectTotals: () => ({ cost: 0 }),
     formatCost: (c: number) => `$${c.toFixed(2)}`,
@@ -590,9 +590,9 @@ test("unit-end event contains errorContext when unit is cancelled with structure
   resolveAgentEndCancelled({ message: "Hard timeout error: exceeded limit", category: "timeout", isTransient: true });
 
   const result = await unitPromise;
-  // Cancelled units break the loop before emitting unit-end
+  // Transient timeout cancellations pause (recoverable) instead of hard-stopping
   assert.equal(result.action, "break");
-  assert.equal((result as any).reason, "session-failed");
+  assert.equal((result as any).reason, "session-timeout");
 
   // Verify error classification used structured errorContext on the window entry
   const entry = loopState.recentUnits[loopState.recentUnits.length - 1];