gsd-pi 2.64.0-dev.6fe1e44 → 2.64.0-dev.b3ee078

package/src/resources/extensions/bg-shell/bg-shell-lifecycle.ts

@@ -16,6 +16,7 @@ import {
 import {
 	processes,
 	pendingAlerts,
+	pushAlert,
 	cleanupAll,
 	cleanupSessionProcesses,
 	persistManifest,
@@ -37,19 +38,30 @@ export function registerBgShellLifecycle(pi: ExtensionAPI, state: BgShellSharedS
 		}
 	}
 
-	// Clean up on session shutdown
-	pi.on("session_shutdown", async () => {
-		cleanupAll();
-	});
-
 	// Register signal handlers to clean up bg processes on unexpected exit (fixes #428)
 	const signalCleanup = () => {
 		cleanupAll();
+		// Also kill bash-tool spawned children that bg-shell doesn't track
+		try {
+			const { listDescendants } = require("@gsd/native") as typeof import("@gsd/native");
+			const descendants = listDescendants(process.pid);
+			for (const childPid of descendants) {
+				try { process.kill(childPid, "SIGKILL"); } catch {}
+			}
+		} catch {}
 	};
 	process.on("SIGTERM", signalCleanup);
 	process.on("SIGINT", signalCleanup);
 	process.on("beforeExit", signalCleanup);
 
+	// Clean up on session shutdown — remove signal handlers to prevent accumulation
+	pi.on("session_shutdown", async () => {
+		process.off("SIGTERM", signalCleanup);
+		process.off("SIGINT", signalCleanup);
+		process.off("beforeExit", signalCleanup);
+		cleanupAll();
+	});
+
 	// ── Compaction Awareness: Survive Context Resets ───────────────
 
 	/** Build a compact state summary of all alive processes for context re-injection */
@@ -65,7 +77,7 @@ export function registerBgShellLifecycle(pi: ExtensionAPI, state: BgShellSharedS
 			return `  - id:${p.id} "${p.label}" [${p.processType}] status:${p.status} uptime:${formatUptime(Date.now() - p.startedAt)}${portInfo}${urlInfo}${errInfo}${groupInfo}`;
 		}).join("\n");
 
-		pendingAlerts.push(
+		pushAlert(null,
 			`${reason} ${alive.length} background process(es) are still running:\n${processSummaries}\nUse bg_shell digest/output/kill with these IDs.`
 		);
 	}
@@ -150,7 +162,7 @@ export function registerBgShellLifecycle(pi: ExtensionAPI, state: BgShellSharedS
 					`  - ${s.id}: ${s.label} (pid ${s.pid}, type: ${s.processType}${s.group ? `, group: ${s.group}` : ""})`
 				).join("\n");
 
-				pendingAlerts.push(
+				pushAlert(null,
 					`${surviving.length} background process(es) from previous session still running:\n${summary}\n  Note: These processes are outside bg_shell's control. Kill them manually if needed.`
 				);
 			}

package/src/resources/extensions/bg-shell/process-manager.ts

@@ -33,6 +33,8 @@ export const processes = new Map<string, BgProcess>();
 /** Pending alerts to inject into the next agent context */
 export let pendingAlerts: string[] = [];
 
+const MAX_PENDING_ALERTS = 50;
+
 /** Replace the pendingAlerts array (used by the extension entry point) */
 export function setPendingAlerts(alerts: string[]): void {
 	pendingAlerts = alerts;
@@ -58,8 +60,12 @@ export function addEvent(bg: BgProcess, event: Omit<ProcessEvent, "timestamp">):
 	}
 }
 
-export function pushAlert(bg: BgProcess, message: string): void {
-	pendingAlerts.push(`[bg:${bg.id} ${bg.label}] ${message}`);
+export function pushAlert(bg: BgProcess | null, message: string): void {
+	const prefix = bg ? `[bg:${bg.id} ${bg.label}] ` : "";
+	pendingAlerts.push(`${prefix}${message}`);
+	if (pendingAlerts.length > MAX_PENDING_ALERTS) {
+		pendingAlerts.splice(0, pendingAlerts.length - MAX_PENDING_ALERTS);
+	}
 }
 
 export function getInfo(p: BgProcess): BgProcessInfo {

package/src/resources/extensions/gsd/bootstrap/db-tools.ts

@@ -804,27 +804,39 @@ export function registerDbTools(pi: ExtensionAPI): void {
         return m ? [m[1].trim(), m[2].trim()] : [s.trim(), ""];
       };
       const coerced = { ...params };
-      coerced.filesModified = (params.filesModified ?? []).map((f: any) => {
+      // Coerce simple string-array fields: LLMs sometimes pass a plain string
+      // instead of a single-element array (#3585).
+      const wrapArray = (v: any): any[] =>
+        v == null ? [] : Array.isArray(v) ? v : [v];
+      coerced.provides = wrapArray(params.provides);
+      coerced.keyFiles = wrapArray(params.keyFiles);
+      coerced.keyDecisions = wrapArray(params.keyDecisions);
+      coerced.patternsEstablished = wrapArray(params.patternsEstablished);
+      coerced.observabilitySurfaces = wrapArray(params.observabilitySurfaces);
+      coerced.requirementsSurfaced = wrapArray(params.requirementsSurfaced);
+      coerced.drillDownPaths = wrapArray(params.drillDownPaths);
+      coerced.affects = wrapArray(params.affects);
+      coerced.filesModified = wrapArray(params.filesModified).map((f: any) => {
         if (typeof f !== "string") return f;
         const [path, description] = splitPair(f);
         return { path, description };
       });
-      coerced.requires = (params.requires ?? []).map((r: any) => {
+      coerced.requires = wrapArray(params.requires).map((r: any) => {
         if (typeof r !== "string") return r;
         const [slice, provides] = splitPair(r);
         return { slice, provides };
       });
-      coerced.requirementsAdvanced = (params.requirementsAdvanced ?? []).map((r: any) => {
+      coerced.requirementsAdvanced = wrapArray(params.requirementsAdvanced).map((r: any) => {
         if (typeof r !== "string") return r;
         const [id, how] = splitPair(r);
         return { id, how };
       });
-      coerced.requirementsValidated = (params.requirementsValidated ?? []).map((r: any) => {
+      coerced.requirementsValidated = wrapArray(params.requirementsValidated).map((r: any) => {
         if (typeof r !== "string") return r;
         const [id, proof] = splitPair(r);
         return { id, proof };
       });
-      coerced.requirementsInvalidated = (params.requirementsInvalidated ?? []).map((r: any) => {
+      coerced.requirementsInvalidated = wrapArray(params.requirementsInvalidated).map((r: any) => {
         if (typeof r !== "string") return r;
         const [id, what] = splitPair(r);
         return { id, what };
@@ -884,14 +896,14 @@ export function registerDbTools(pi: ExtensionAPI): void {
       deviations: Type.Optional(Type.String({ description: "Deviations from the slice plan, or 'None.'" })),
       knownLimitations: Type.Optional(Type.String({ description: "Known limitations or gaps, or 'None.'" })),
       followUps: Type.Optional(Type.String({ description: "Follow-up work discovered during execution, or 'None.'" })),
-      keyFiles: Type.Optional(Type.Array(Type.String(), { description: "Key files created or modified" })),
-      keyDecisions: Type.Optional(Type.Array(Type.String(), { description: "Key decisions made during this slice" })),
-      patternsEstablished: Type.Optional(Type.Array(Type.String(), { description: "Patterns established by this slice" })),
-      observabilitySurfaces: Type.Optional(Type.Array(Type.String(), { description: "Observability surfaces added" })),
-      provides: Type.Optional(Type.Array(Type.String(), { description: "What this slice provides to downstream slices" })),
-      requirementsSurfaced: Type.Optional(Type.Array(Type.String(), { description: "New requirements surfaced" })),
-      drillDownPaths: Type.Optional(Type.Array(Type.String(), { description: "Paths to task summaries for drill-down" })),
-      affects: Type.Optional(Type.Array(Type.String(), { description: "Downstream slices affected" })),
+      keyFiles: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Key files created or modified" })),
+      keyDecisions: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Key decisions made during this slice" })),
+      patternsEstablished: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Patterns established by this slice" })),
+      observabilitySurfaces: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Observability surfaces added" })),
+      provides: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "What this slice provides to downstream slices" })),
+      requirementsSurfaced: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "New requirements surfaced" })),
+      drillDownPaths: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Paths to task summaries for drill-down" })),
+      affects: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Downstream slices affected" })),
       requirementsAdvanced: Type.Optional(Type.Array(
         Type.Union([
           Type.Object({

package/src/resources/extensions/gsd/bootstrap/register-shortcuts.ts

@@ -44,6 +44,7 @@ export function registerShortcuts(pi: ExtensionAPI): void {
             minWidth: 60,
             maxHeight: "88%",
             anchor: "center",
+            backdrop: true,
           },
         },
       );

package/src/resources/extensions/gsd/bootstrap/system-context.ts

@@ -264,6 +264,13 @@ function buildWorktreeContextBlock(): string {
   return "";
 }
 
+/**
+ * Low-entropy resume intent patterns — short phrases a user types to
+ * continue work after a pause, rate limit, or context reset (#3615).
+ * Tested against the trimmed, lowercased prompt with trailing punctuation stripped.
+ */
+const RESUME_INTENT_PATTERNS = /^(continue|resume|ok|go|go ahead|proceed|keep going|carry on|next|yes|yeah|yep|sure|do it|let's go|pick up where you left off)$/;
+
 async function buildGuidedExecuteContextInjection(prompt: string, basePath: string): Promise<string | null> {
   const executeMatch = prompt.match(/Execute the next task:\s+(T\d+)\s+\("([^"]+)"\)\s+in slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i);
   if (executeMatch) {
@@ -280,6 +287,27 @@ async function buildGuidedExecuteContextInjection(prompt: string, basePath: stri
     }
   }
 
+  // Fallback: low-entropy resume prompt (e.g., "continue", "ok", "go ahead")
+  // during an active executing task — inject task context so the agent
+  // doesn't rebuild from scratch (#3615).
+  // Intent-gated: only fire for short, resume-like prompts to avoid hijacking
+  // control/help/diagnostic prompts with unrelated execution context.
+  // Phase-gated: only fire during "executing" to avoid misrouting during
+  // replanning, gate evaluation, or other non-execution phases.
+  const trimmed = prompt.trim().toLowerCase().replace(/[.!?,]+$/g, "");
+  if (RESUME_INTENT_PATTERNS.test(trimmed)) {
+    const state = await deriveState(basePath);
+    if (state.phase === "executing" && state.activeTask && state.activeMilestone && state.activeSlice) {
+      return buildTaskExecutionContextInjection(
+        basePath,
+        state.activeMilestone.id,
+        state.activeSlice.id,
+        state.activeTask.id,
+        state.activeTask.title,
+      );
+    }
+  }
+
   return null;
 }
 

package/src/resources/extensions/gsd/commands/handlers/notifications-handler.ts

@@ -105,6 +105,7 @@ export async function handleNotificationsCommand(
               minWidth: 60,
               maxHeight: "88%",
               anchor: "center",
+              backdrop: true,
             },
           },
         );

package/src/resources/extensions/gsd/notification-overlay.ts

@@ -157,9 +157,8 @@ export class GSDNotificationOverlay {
     }
 
     const content = this.buildContentLines(width);
-    const viewportHeight = Math.max(5, process.stdout.rows ? process.stdout.rows - 8 : 24);
-    const chromeHeight = 2; // top + bottom border
-    const visibleContentRows = Math.max(1, viewportHeight - chromeHeight);
+    const maxVisibleRows = Math.max(5, process.stdout.rows ? process.stdout.rows - 8 : 24) - 2;
+    const visibleContentRows = Math.min(content.length, maxVisibleRows);
     const maxScroll = Math.max(0, content.length - visibleContentRows);
     this.scrollOffset = Math.min(this.scrollOffset, maxScroll);
     const visibleContent = content.slice(this.scrollOffset, this.scrollOffset + visibleContentRows);

package/src/resources/extensions/gsd/notification-store.ts

@@ -275,14 +275,19 @@ function _withLock<T>(basePath: string, fn: () => T): T {
     }
   }
 
+  // Only run the mutation if we actually own the lock
+  const ownsLock = fd !== null;
   try {
-    // Write our PID timestamp into the lock for stale detection
-    if (fd !== null) {
+    if (ownsLock && fd !== null) {
+      // Write our PID timestamp into the lock for stale detection
       writeFileSync(lockPath, String(Date.now()), "utf-8");
       closeSync(fd);
     }
     return fn();
   } finally {
-    try { unlinkSync(lockPath); } catch { /* best-effort cleanup */ }
+    // Only delete the lock if we created it — never remove another process's lock
+    if (ownsLock) {
+      try { unlinkSync(lockPath); } catch { /* best-effort cleanup */ }
+    }
   }
 }

package/src/resources/extensions/gsd/tests/complete-slice-string-coercion.test.ts

@@ -124,6 +124,42 @@ describe("verificationEvidence sentinel coercion (#3565)", () => {
   });
 });
 
+// ─── wrapArray coercion unit tests (#3585) ──────────────────────────────
+
+describe("wrapArray coercion for simple string-array fields (#3585)", () => {
+  /**
+   * The wrapArray coercion logic extracted from db-tools.ts sliceCompleteExecute.
+   * Duplicated here so we can unit-test it directly.
+   */
+  function wrapArray(v: any): any[] {
+    return v == null ? [] : Array.isArray(v) ? v : [v];
+  }
+
+  test("null returns empty array", () => {
+    assert.deepEqual(wrapArray(null), []);
+  });
+
+  test("undefined returns empty array", () => {
+    assert.deepEqual(wrapArray(undefined), []);
+  });
+
+  test("plain string wraps into single-element array", () => {
+    assert.deepEqual(
+      wrapArray("Validated Tech UI flows and Portal self-service flows"),
+      ["Validated Tech UI flows and Portal self-service flows"],
+    );
+  });
+
+  test("array passes through unchanged", () => {
+    const arr = ["item1", "item2"];
+    assert.deepEqual(wrapArray(arr), arr);
+  });
+
+  test("empty array passes through unchanged", () => {
+    assert.deepEqual(wrapArray([]), []);
+  });
+});
+
 // ─── Handler integration with coerced params ─────────────────────────────
 
 describe("handleCompleteSlice with coerced string arrays (#3565)", () => {

package/src/resources/extensions/gsd/tests/notification-store.test.ts

@@ -2,7 +2,7 @@
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -246,4 +246,37 @@ describe("notification-store", () => {
     assert.equal(getUnreadCount(), 0);
     assert.equal(getLineCount(), 0);
   });
+
+  test("markAllRead does not delete a foreign lock file", () => {
+    initNotificationStore(tmp);
+    appendNotification("msg1", "info");
+
+    // Simulate another process holding the lock
+    const lockPath = join(tmp, ".gsd", "notifications.lock");
+    writeFileSync(lockPath, String(Date.now()), "utf-8");
+
+    // markAllRead should still work (best-effort) but not delete the foreign lock
+    markAllRead();
+
+    assert.ok(existsSync(lockPath), "foreign lock file should not be deleted");
+
+    // Clean up the lock so afterEach doesn't leave artifacts
+    rmSync(lockPath, { force: true });
+  });
+
+  test("clearNotifications does not delete a foreign lock file", () => {
+    initNotificationStore(tmp);
+    appendNotification("msg1", "info");
+
+    // Simulate another process holding the lock
+    const lockPath = join(tmp, ".gsd", "notifications.lock");
+    writeFileSync(lockPath, String(Date.now()), "utf-8");
+
+    // clearNotifications should still work but not delete the foreign lock
+    clearNotifications();
+
+    assert.ok(existsSync(lockPath), "foreign lock file should not be deleted");
+
+    rmSync(lockPath, { force: true });
+  });
 });

package/src/resources/extensions/gsd/tests/unstructured-continue-context-injection.test.ts

@@ -0,0 +1,163 @@
+// GSD-2 — Regression test for #3615: unstructured "continue" must inject task context
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+/**
+ * Bug #3615: When a user types "continue" (or any bare text) to resume
+ * an in-progress session, buildGuidedExecuteContextInjection() only
+ * matched two hardcoded regex patterns (auto-dispatch and guided-resume).
+ * The function returned null for any other input, so no task context was
+ * injected — causing the agent to rebuild everything from scratch and
+ * burn ~86k tokens.
+ *
+ * This test verifies:
+ *   1. Structural: the fallback exists with phase + intent guards
+ *   2. Behavioral: RESUME_INTENT_PATTERNS matches expected prompts and
+ *      rejects non-resume prompts (control, help, diagnostic, etc.)
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const systemContextSource = readFileSync(
+  join(__dirname, "..", "bootstrap", "system-context.ts"),
+  "utf-8",
+);
+
+// ── Structural tests ────────────────────────────────────────────────
+
+describe("#3615 — structural: fallback exists with correct guards", () => {
+  const fnStart = systemContextSource.indexOf("async function buildGuidedExecuteContextInjection(");
+  assert.ok(fnStart >= 0, "should find buildGuidedExecuteContextInjection");
+  const fnEnd = systemContextSource.indexOf("\nasync function ", fnStart + 1);
+  const fnBody = fnEnd >= 0
+    ? systemContextSource.slice(fnStart, fnEnd)
+    : systemContextSource.slice(fnStart);
+
+  test("has a deriveState fallback after the two regex branches", () => {
+    const deriveStateCalls = fnBody.match(/deriveState\(basePath\)/g);
+    assert.ok(
+      deriveStateCalls && deriveStateCalls.length >= 2,
+      `expected >=2 deriveState(basePath) calls, got ${deriveStateCalls?.length ?? 0}`,
+    );
+  });
+
+  test("fallback is phase-gated to executing only", () => {
+    const afterFallback = fnBody.indexOf("// Fallback:");
+    assert.ok(afterFallback >= 0, "should have a fallback comment");
+    const fallbackSection = fnBody.slice(afterFallback);
+    assert.ok(
+      fallbackSection.includes('state.phase === "executing"'),
+      'fallback must be gated on state.phase === "executing"',
+    );
+  });
+
+  test("fallback is intent-gated via RESUME_INTENT_PATTERNS", () => {
+    const afterFallback = fnBody.indexOf("// Fallback:");
+    const fallbackSection = fnBody.slice(afterFallback);
+    assert.ok(
+      fallbackSection.includes("RESUME_INTENT_PATTERNS"),
+      "fallback must check RESUME_INTENT_PATTERNS before deriveState",
+    );
+  });
+
+  test("fallback calls buildTaskExecutionContextInjection with derived state", () => {
+    const afterFallback = fnBody.indexOf("// Fallback:");
+    const fallbackSection = fnBody.slice(afterFallback);
+    assert.ok(
+      fallbackSection.includes("buildTaskExecutionContextInjection") &&
+      fallbackSection.includes("state.activeMilestone.id") &&
+      fallbackSection.includes("state.activeSlice.id") &&
+      fallbackSection.includes("state.activeTask.id"),
+      "fallback must call buildTaskExecutionContextInjection with state-derived IDs",
+    );
+  });
+
+  test("only one return null at the end", () => {
+    const returnNulls = fnBody.match(/return null;/g);
+    assert.ok(
+      returnNulls && returnNulls.length === 1,
+      `expected exactly 1 'return null' (at end after fallback), got ${returnNulls?.length ?? 0}`,
+    );
+  });
+});
+
+// ── Behavioral tests: RESUME_INTENT_PATTERNS ────────────────────────
+
+describe("#3615 — behavioral: RESUME_INTENT_PATTERNS matches resume prompts", () => {
+  // Extract the regex from source so the test stays in sync
+  const patternMatch = systemContextSource.match(/const RESUME_INTENT_PATTERNS\s*=\s*\/(.+)\/;/);
+  assert.ok(patternMatch, "should find RESUME_INTENT_PATTERNS definition");
+  const pattern = new RegExp(patternMatch[1]);
+
+  // Helper: normalize prompt the same way the production code does
+  const normalize = (s: string) => s.trim().toLowerCase().replace(/[.!?,]+$/g, "");
+
+  const shouldMatch = [
+    "continue",
+    "Continue",
+    "CONTINUE",
+    "continue.",
+    "continue!",
+    "resume",
+    "ok",
+    "OK",
+    "Ok!",
+    "go",
+    "go ahead",
+    "Go ahead.",
+    "proceed",
+    "keep going",
+    "carry on",
+    "next",
+    "yes",
+    "yeah",
+    "yep",
+    "sure",
+    "do it",
+    "let's go",
+    "pick up where you left off",
+    "  continue  ",  // whitespace padded
+  ];
+
+  const shouldNotMatch = [
+    "help",
+    "status",
+    "/gsd auto",
+    "/gsd stats",
+    "what's the plan?",
+    "show me the logs",
+    "abort",
+    "stop",
+    "cancel",
+    "replan this slice",
+    "I think we should change the approach",
+    "can you explain what you just did?",
+    "run the tests",
+    "check the build",
+    "Execute the next task: T01",
+    "what files were changed",
+    "",
+  ];
+
+  for (const prompt of shouldMatch) {
+    test(`matches resume prompt: "${prompt}"`, () => {
+      assert.ok(
+        pattern.test(normalize(prompt)),
+        `expected RESUME_INTENT_PATTERNS to match "${prompt}" (normalized: "${normalize(prompt)}")`,
+      );
+    });
+  }
+
+  for (const prompt of shouldNotMatch) {
+    test(`rejects non-resume prompt: "${prompt}"`, () => {
+      assert.ok(
+        !pattern.test(normalize(prompt)),
+        `expected RESUME_INTENT_PATTERNS to NOT match "${prompt}" (normalized: "${normalize(prompt)}")`,
+      );
+    });
+  }
+});