gsd-pi 2.34.0-dev.7d38042 → 2.34.0-dev.e6d9bed

package/src/resources/extensions/gsd/guided-flow.ts

@@ -788,9 +788,11 @@ export async function showSmartEntry(
   // ── Self-heal stale runtime records from crashed auto-mode sessions ──
   selfHealRuntimeRecords(basePath, ctx);
 
-  // Check for crash from previous auto-mode session
+  // Check for crash from previous auto-mode session.
+  // Skip if the lock was written by the current process — acquireSessionLock()
+  // writes to the same file, so we'd always false-positive (#1398).
   const crashLock = readCrashLock(basePath);
-  if (crashLock) {
+  if (crashLock && crashLock.pid !== process.pid) {
     clearLock(basePath);
 
     // Bootstrap crash with zero completed units = no work was lost.

package/src/resources/extensions/gsd/preferences-validation.ts

@@ -586,5 +586,43 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── Auto Visualize ─────────────────────────────────────────────────
+  if (preferences.auto_visualize !== undefined) {
+    if (typeof preferences.auto_visualize === "boolean") {
+      validated.auto_visualize = preferences.auto_visualize;
+    } else {
+      errors.push("auto_visualize must be a boolean");
+    }
+  }
+
+  // ─── Auto Report ────────────────────────────────────────────────────
+  if (preferences.auto_report !== undefined) {
+    if (typeof preferences.auto_report === "boolean") {
+      validated.auto_report = preferences.auto_report;
+    } else {
+      errors.push("auto_report must be a boolean");
+    }
+  }
+
+  // ─── Compression Strategy ───────────────────────────────────────────
+  if (preferences.compression_strategy !== undefined) {
+    const validStrategies = new Set(["truncate", "compress"]);
+    if (typeof preferences.compression_strategy === "string" && validStrategies.has(preferences.compression_strategy)) {
+      validated.compression_strategy = preferences.compression_strategy as GSDPreferences["compression_strategy"];
+    } else {
+      errors.push(`compression_strategy must be one of: truncate, compress`);
+    }
+  }
+
+  // ─── Context Selection ──────────────────────────────────────────────
+  if (preferences.context_selection !== undefined) {
+    const validModes = new Set(["full", "smart"]);
+    if (typeof preferences.context_selection === "string" && validModes.has(preferences.context_selection)) {
+      validated.context_selection = preferences.context_selection as GSDPreferences["context_selection"];
+    } else {
+      errors.push(`context_selection must be one of: full, smart`);
+    }
+  }
+
   return { preferences: validated, errors, warnings };
 }

package/src/resources/extensions/gsd/preferences.ts

@@ -252,6 +252,8 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
     search_provider: override.search_provider ?? base.search_provider,
     compression_strategy: override.compression_strategy ?? base.compression_strategy,
     context_selection: override.context_selection ?? base.context_selection,
+    auto_visualize: override.auto_visualize ?? base.auto_visualize,
+    auto_report: override.auto_report ?? base.auto_report,
   };
 }
 

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

@@ -2,9 +2,10 @@
  * doctor-git.test.ts — Integration tests for doctor git health checks.
  *
  * Creates real temp git repos with deliberate broken state, runs runGSDDoctor,
- * and asserts correct detection and fixing of all 4 git issue codes:
+ * and asserts correct detection and fixing of git issue codes:
  *   orphaned_auto_worktree, stale_milestone_branch,
- *   corrupt_merge_state, tracked_runtime_files
+ *   corrupt_merge_state, tracked_runtime_files,
+ *   integration_branch_missing, worktree_directory_orphaned
  */
 
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
@@ -299,6 +300,101 @@ async function main(): Promise<void> {
       console.log("\n=== none-mode skips stale branch (skipped on Windows) ===");
     }
 
+    // ─── Test: Integration branch missing ──────────────────────────────
+    if (process.platform !== "win32") {
+    console.log("\n=== integration_branch_missing ===");
+    {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Write integration branch metadata for M001 pointing to a non-existent branch
+      const metaPath = join(dir, ".gsd", "milestones", "M001", "M001-META.json");
+      writeFileSync(metaPath, JSON.stringify({ integrationBranch: "feat/does-not-exist" }, null, 2));
+
+      const detect = await runGSDDoctor(dir);
+      const missingBranchIssues = detect.issues.filter(i => i.code === "integration_branch_missing");
+      assertTrue(missingBranchIssues.length > 0, "detects missing integration branch");
+      assertTrue(
+        missingBranchIssues[0]?.message.includes("feat/does-not-exist"),
+        "message includes the missing branch name",
+      );
+      assertEq(missingBranchIssues[0]?.fixable, false, "integration_branch_missing is not auto-fixable");
+      assertEq(missingBranchIssues[0]?.severity, "error", "severity is error");
+    }
+    } else {
+      console.log("\n=== integration_branch_missing (skipped on Windows) ===");
+    }
+
+    // ─── Test: Integration branch present — no false positive ──────────
+    if (process.platform !== "win32") {
+    console.log("\n=== integration_branch_missing (no false positive) ===");
+    {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Write integration branch metadata for M001 pointing to "main" (which exists)
+      const metaPath = join(dir, ".gsd", "milestones", "M001", "M001-META.json");
+      writeFileSync(metaPath, JSON.stringify({ integrationBranch: "main" }, null, 2));
+
+      const detect = await runGSDDoctor(dir);
+      const missingBranchIssues = detect.issues.filter(i => i.code === "integration_branch_missing");
+      assertEq(missingBranchIssues.length, 0, "existing integration branch NOT flagged");
+    }
+    } else {
+      console.log("\n=== integration_branch_missing (no false positive — skipped on Windows) ===");
+    }
+
+    // ─── Test: Orphaned worktree directory ─────────────────────────────
+    if (process.platform !== "win32") {
+    console.log("\n=== worktree_directory_orphaned ===");
+    {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Create a worktrees/ dir with an entry that is NOT in git worktree list
+      const orphanDir = join(dir, ".gsd", "worktrees", "orphan-feature");
+      mkdirSync(orphanDir, { recursive: true });
+      writeFileSync(join(orphanDir, "some-file.txt"), "leftover content\n");
+
+      const detect = await runGSDDoctor(dir);
+      const orphanDirIssues = detect.issues.filter(i => i.code === "worktree_directory_orphaned");
+      assertTrue(orphanDirIssues.length > 0, "detects orphaned worktree directory");
+      assertTrue(
+        orphanDirIssues[0]?.message.includes("orphan-feature"),
+        "message includes the orphaned directory name",
+      );
+      assertTrue(orphanDirIssues[0]?.fixable === true, "worktree_directory_orphaned is fixable");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assertTrue(
+        fixed.fixesApplied.some(f => f.includes("removed orphaned worktree directory")),
+        "fix removes orphaned worktree directory",
+      );
+      assertTrue(!existsSync(orphanDir), "orphaned directory removed after fix");
+    }
+    } else {
+      console.log("\n=== worktree_directory_orphaned (skipped on Windows) ===");
+    }
+
+    // ─── Test: Registered worktree NOT flagged as orphaned ─────────────
+    if (process.platform !== "win32") {
+    console.log("\n=== worktree_directory_orphaned (registered worktree not flagged) ===");
+    {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Create a real registered worktree under .gsd/worktrees/
+      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b worktree/feature-1 .gsd/worktrees/feature-1", dir);
+
+      const detect = await runGSDDoctor(dir);
+      const orphanDirIssues = detect.issues.filter(i => i.code === "worktree_directory_orphaned");
+      assertEq(orphanDirIssues.length, 0, "registered worktree NOT flagged as orphaned");
+    }
+    } else {
+      console.log("\n=== worktree_directory_orphaned (registered worktree not flagged — skipped on Windows) ===");
+    }
+
     // ─── Test 9: none-mode still detects corrupt merge state ───────────
     console.log("\n=== none-mode keeps corrupt merge state ===");
     {

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

@@ -2,9 +2,9 @@
  * doctor-runtime.test.ts — Tests for doctor runtime health checks.
  *
  * Tests detection and auto-fix of:
- *   stale_crash_lock, orphaned_completed_units, stale_hook_state,
- *   activity_log_bloat, state_file_missing, state_file_stale,
- *   gitignore_missing_patterns
+ *   stale_crash_lock, stranded_lock_directory, orphaned_completed_units,
+ *   stale_hook_state, activity_log_bloat, state_file_missing,
+ *   state_file_stale, gitignore_missing_patterns
  */
 
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, realpathSync } from "node:fs";
@@ -290,6 +290,62 @@ node_modules/
       assertEq(content.length, 0, "all orphaned keys removed");
     }
 
+    // ─── Test: Stranded lock directory detection & fix ────────────────
+    // Skip on Windows: proper-lockfile uses advisory file locking on Windows,
+    // not the directory-based mechanism. The .gsd.lock/ directory pattern is
+    // a POSIX-specific lockfile implementation detail.
+    if (process.platform !== "win32") {
+    console.log("\n=== stranded_lock_directory ===");
+    {
+      const dir = createMinimalProject();
+      cleanups.push(dir);
+
+      // Create the proper-lockfile lock directory without a live lock holder.
+      // The lock dir sits at <parent of .gsd>/.gsd.lock (i.e., <basePath>/.gsd.lock).
+      const lockDir = join(dir, ".gsd.lock");
+      mkdirSync(lockDir, { recursive: true });
+
+      const detect = await runGSDDoctor(dir);
+      const strandedIssues = detect.issues.filter(i => i.code === "stranded_lock_directory");
+      assertTrue(strandedIssues.length > 0, "detects stranded lock directory");
+      assertTrue(strandedIssues[0]?.message.includes("lock directory"), "message describes stranded lock directory");
+      assertTrue(strandedIssues[0]?.fixable === true, "stranded lock dir is fixable");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assertTrue(
+        fixed.fixesApplied.some(f => f.includes("removed stranded lock directory")),
+        "fix removes stranded lock directory",
+      );
+      assertTrue(!existsSync(lockDir), "lock directory removed after fix");
+    }
+
+    // ─── Test: Stranded lock dir with live lock holder — NOT flagged ───
+    console.log("\n=== stranded_lock_directory (live holder not flagged) ===");
+    {
+      const dir = createMinimalProject();
+      cleanups.push(dir);
+
+      // Create lock dir + auto.lock with PID 1 (init/launchd — always alive, never our own PID)
+      const lockDir = join(dir, ".gsd.lock");
+      mkdirSync(lockDir, { recursive: true });
+      const liveLockData = {
+        pid: 1,
+        startedAt: new Date().toISOString(),
+        unitType: "execute-task",
+        unitId: "M001/S01/T01",
+        unitStartedAt: new Date().toISOString(),
+        completedUnits: 1,
+      };
+      writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(liveLockData, null, 2));
+
+      const detect = await runGSDDoctor(dir);
+      const strandedIssues = detect.issues.filter(i => i.code === "stranded_lock_directory");
+      assertEq(strandedIssues.length, 0, "live lock holder: stranded_lock_directory NOT detected");
+    }
+    } else {
+      console.log("\n=== stranded_lock_directory (skipped on Windows) ===");
+    }
+
   } finally {
     for (const dir of cleanups) {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }

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

@@ -175,6 +175,34 @@ test("git fields comprehensive validation", () => {
   assert.equal(preferences.git?.isolation, "branch");
 });
 
+test("auto_visualize, auto_report, compression_strategy, context_selection validate correctly", () => {
+  const { preferences, errors } = validatePreferences({
+    auto_visualize: true,
+    auto_report: false,
+    compression_strategy: "compress",
+    context_selection: "smart",
+  });
+  assert.equal(errors.length, 0);
+  assert.equal(preferences.auto_visualize, true);
+  assert.equal(preferences.auto_report, false);
+  assert.equal(preferences.compression_strategy, "compress");
+  assert.equal(preferences.context_selection, "smart");
+});
+
+test("auto_visualize, auto_report, compression_strategy, context_selection reject invalid values", () => {
+  const { errors: e1 } = validatePreferences({ auto_visualize: "yes" as never });
+  assert.ok(e1.some(e => e.includes("auto_visualize")));
+
+  const { errors: e2 } = validatePreferences({ auto_report: 1 as never });
+  assert.ok(e2.some(e => e.includes("auto_report")));
+
+  const { errors: e3 } = validatePreferences({ compression_strategy: "shrink" as never });
+  assert.ok(e3.some(e => e.includes("compression_strategy")));
+
+  const { errors: e4 } = validatePreferences({ context_selection: "partial" as never });
+  assert.ok(e4.some(e => e.includes("context_selection")));
+});
+
 test("all wizard fields together produce no errors", () => {
   const { errors, warnings } = validatePreferences({
     version: 1,

package/src/resources/skills/create-gsd-extension/references/events-reference.md

@@ -61,10 +61,10 @@ pi.on("tool_call", async (event, ctx) => {
 
 **tool_result** — Fired after tool executes. Can modify result. Handlers chain like middleware.
 ```typescript
-import { isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { isToolResultEventType } from "@mariozechner/pi-coding-agent";
 
 pi.on("tool_result", async (event, ctx) => {
-  if (isBashToolResult(event)) {
+  if (isToolResultEventType("bash", event)) {
     // event.details is typed as BashToolDetails
   }
   // Return partial patch: { content, details, isError }
@@ -105,7 +105,7 @@ pi.on("model_select", async (event, ctx) => {
 Built-in type guards for tool events:
 
 ```typescript
-import { isToolCallEventType, isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { isToolCallEventType, isToolResultEventType } from "@mariozechner/pi-coding-agent";
 
 // Tool calls — narrows event.input type
 if (isToolCallEventType("bash", event)) { /* event.input: { command, timeout? } */ }
@@ -114,7 +114,7 @@ if (isToolCallEventType("write", event)) { /* event.input: { path, content } */
 if (isToolCallEventType("edit", event)) { /* event.input: { path, oldText, newText } */ }
 
 // Tool results — narrows event.details type
-if (isBashToolResult(event)) { /* event.details: BashToolDetails */ }
+if (isToolResultEventType("bash", event)) { /* event.details: BashToolDetails */ }
 ```
 
 For custom tools, export your input type and use explicit type params: