gsd-pi 2.76.0-dev.4100bd590 → 2.76.0-dev.479ad0e78

package/dist/resources/extensions/gsd/model-router.js

@@ -440,6 +440,20 @@ function getModelCost(modelId) {
 function bareModelId(modelId) {
     return modelId.includes("/") ? modelId.split("/").pop() : modelId;
 }
+// ─── Provider-specific Tool Limits ─────────────────────────────────────────
+/**
+ * Groq enforces a hard limit of 128 tools per request.
+ * Requests exceeding this limit receive a 400 error:
+ * "maximum number of items is 128"
+ * @see https://console.groq.com/docs/tool-use
+ */
+export const GROQ_MAX_TOOLS = 128;
+/**
+ * Provider IDs that map to the Groq API backend.
+ * Used to detect Groq at the GSD routing layer where only the provider string
+ * is available (the pi-ai openai-completions adapter is shared across providers).
+ */
+const GROQ_PROVIDER_IDS = new Set(["groq"]);
 // ─── Tool Compatibility Filter (ADR-005 Phase 3) ───────────────────────────
 /**
  * Check if a tool is compatible with a provider's capabilities.
@@ -461,8 +475,14 @@ export function isToolCompatibleWithProvider(toolName, providerCaps) {
 /**
  * Filter a list of tool names to only those compatible with a provider.
  * Used by the routing pipeline to adjust tool sets when switching providers.
+ *
+ * @param toolNames - The full list of active tool names to filter.
+ * @param providerApi - The pi-ai API string (e.g. "openai-completions").
+ * @param provider - Optional provider ID (e.g. "groq"). Used to apply
+ *   provider-specific limits that can't be expressed as API-level capabilities
+ *   (e.g. Groq's 128-tool hard limit on the shared openai-completions adapter).
  */
-export function filterToolsForProvider(toolNames, providerApi) {
+export function filterToolsForProvider(toolNames, providerApi, provider) {
     const providerCaps = getProviderCapabilities(providerApi);
     // Provider doesn't support tool calling at all
     if (!providerCaps.toolCalling) {
@@ -478,6 +498,14 @@ export function filterToolsForProvider(toolNames, providerApi) {
             filtered.push(name);
         }
     }
+    // Groq enforces a hard limit of 128 tools per request (#4376).
+    // Trim the compatible list to GROQ_MAX_TOOLS and move the excess to filtered.
+    if (provider && GROQ_PROVIDER_IDS.has(provider) && compatible.length > GROQ_MAX_TOOLS) {
+        const trimmed = compatible.splice(GROQ_MAX_TOOLS);
+        filtered.push(...trimmed);
+        console.warn(`[gsd] Groq tool limit: ${compatible.length + trimmed.length} tools active but Groq allows at most ${GROQ_MAX_TOOLS}. ` +
+            `Trimming to the first ${GROQ_MAX_TOOLS} tools. Removed: ${trimmed.join(", ")}`);
+    }
     return { compatible, filtered };
 }
 /**
@@ -486,8 +514,13 @@ export function filterToolsForProvider(toolNames, providerApi) {
  *
  * This is a hard filter only — it removes tools that would fail at the
  * provider level. It does NOT remove tools based on soft heuristics.
+ *
+ * @param activeToolNames - The full list of currently active tool names.
+ * @param selectedModelApi - The pi-ai API string for the selected model.
+ * @param provider - Optional provider ID (e.g. "groq") for provider-specific
+ *   limits beyond what the API-level capability profile expresses.
  */
-export function adjustToolSet(activeToolNames, selectedModelApi) {
-    const { compatible, filtered } = filterToolsForProvider(activeToolNames, selectedModelApi);
+export function adjustToolSet(activeToolNames, selectedModelApi, provider) {
+    const { compatible, filtered } = filterToolsForProvider(activeToolNames, selectedModelApi, provider);
     return { toolNames: compatible, removedTools: filtered };
 }

package/dist/resources/extensions/gsd/pre-execution-checks.js

@@ -68,8 +68,13 @@ export function extractPackageReferences(description) {
             }
         }
     }
-    // require('pkg') or import from 'pkg' in code blocks
-    const importPattern = /(?:require\s*\(\s*['"]|from\s+['"])([a-zA-Z0-9@/_-]+)['"\)]/g;
+    // require('pkg') or `import ... from 'pkg'` in code blocks.
+    // The `from\s+['"]` branch MUST be preceded by an `import` keyword so that
+    // natural-language prose like `from "What's Next"` or `from 'master'` does
+    // not produce false package-existence failures.  Requiring the leading import
+    // keyword anchors the match to JavaScript/TypeScript syntax.
+    // See: https://github.com/gsd-build/gsd-2/issues/4388
+    const importPattern = /(?:require\s*\(\s*['"]|import\b[\s\S]*?\bfrom\s+['"])([a-zA-Z0-9@/_-]+)['"\)]/g;
     let importMatch;
     while ((importMatch = importPattern.exec(description)) !== null) {
         // Skip relative imports and node builtins
@@ -276,9 +281,23 @@ function extractPathFromAnnotation(raw) {
     if (backtickMatch) {
         return backtickMatch[2].trim();
     }
+    // Strip leading/trailing double or single quotes wrapping the whole value.
+    // Plan documents sometimes emit `"src/foo.ts"` or `'src/bar.ts'` as input
+    // annotations. Stripping the wrapper allows the inner path to be checked
+    // correctly instead of producing a false-positive "file not found" error
+    // for a literal string with quote characters in it (#3747).
+    const quoteMatch = trimmed.match(/^(["'])([^"']+)\1$/);
+    if (quoteMatch) {
+        return quoteMatch[2].trim();
+    }
     const annotatedMatch = trimmed.match(/^(.+?)\s+[—–-]\s+.+$/);
     if (annotatedMatch) {
-        return annotatedMatch[1].trim();
+        const prefix = annotatedMatch[1].trim();
+        const prefixBacktickMatch = prefix.match(/`([^`]+)`/);
+        if (prefixBacktickMatch && looksLikePathOrUrl(prefixBacktickMatch[1].trim())) {
+            return prefixBacktickMatch[1].trim();
+        }
+        return prefix.replace(/`/g, "").trim();
     }
     // Fallback: scan all backticked tokens and return the first one that looks
     // like a path or URL. Handles prose-annotated bullets such as:
@@ -333,13 +352,19 @@ function containsGlobPattern(candidate) {
 }
 /**
  * Build a set of files that will be created by tasks up to (but not including) taskIndex.
+ * Also includes outputs of completed tasks at any position — a completed task has already
+ * run and its outputs are available regardless of sequence position or disk state (#4071).
  * All paths are normalized for consistent comparison.
  */
 function getExpectedOutputsUpTo(tasks, taskIndex) {
     const outputs = new Set();
-    for (let i = 0; i < taskIndex; i++) {
-        for (const file of tasks[i].expected_output) {
-            outputs.add(normalizeFilePath(file));
+    for (let i = 0; i < tasks.length; i++) {
+        const task = tasks[i];
+        // Include prior tasks (i < taskIndex) OR completed tasks at any position
+        if (i < taskIndex || task.status === "completed") {
+            for (const file of task.expected_output) {
+                outputs.add(normalizeFilePath(file));
+            }
         }
     }
     return outputs;
@@ -416,8 +441,14 @@ export function checkTaskOrdering(tasks, basePath) {
         const task = tasks[i];
         for (const file of task.expected_output) {
             const normalizedFile = normalizeFilePath(file);
-            if (!fileCreators.has(normalizedFile)) {
-                fileCreators.set(normalizedFile, { taskId: task.id, index: i, originalPath: file });
+            const existing = fileCreators.get(normalizedFile);
+            if (!existing || (!existing.completed && task.status === "completed")) {
+                fileCreators.set(normalizedFile, {
+                    taskId: task.id,
+                    index: i,
+                    originalPath: file,
+                    completed: task.status === "completed",
+                });
             }
         }
     }
@@ -441,7 +472,11 @@ export function checkTaskOrdering(tasks, basePath) {
             const creator = fileCreators.get(normalizedFile);
             const absolutePath = resolve(basePath, normalizedFile);
             const existsOnDisk = existsSync(absolutePath);
-            if (creator && creator.index > i && !existsOnDisk) {
+            // Skip if the creating task has already completed — its output is available
+            // regardless of disk state (e.g. file was a temp artifact cleaned up after
+            // the task ran, or a replan introduced a new earlier-sequence task that
+            // reads this pre-execution output). (#4071)
+            if (creator && creator.index > i && !existsOnDisk && !creator.completed) {
                 // Task reads file that is created later — impossible ordering
                 results.push({
                     category: "file",

package/dist/resources/extensions/gsd/preferences-types.js

@@ -5,6 +5,14 @@
  * both the validation and runtime modules can import them without pulling
  * in filesystem or loading logic.
  */
+/**
+ * Resolve whether context-mode features (gsd_exec sandbox + compaction
+ * snapshot) should be active. Default is ON: missing config or missing
+ * `enabled` is treated as true. Only `enabled: false` disables.
+ */
+export function isContextModeEnabled(prefs) {
+    return prefs?.context_mode?.enabled !== false;
+}
 /** Default preference values for each workflow mode. */
 export const MODE_DEFAULTS = {
     solo: {
@@ -87,6 +95,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "flat_rate_providers",
     "language",
     "context_window_override",
+    "context_mode",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -660,6 +660,55 @@ export function validatePreferences(preferences) {
             errors.push("context_management must be an object");
         }
     }
+    // ─── Context Mode (gsd_exec sandbox) ────────────────────────────────────
+    if (preferences.context_mode !== undefined) {
+        if (typeof preferences.context_mode === "object" && preferences.context_mode !== null) {
+            const cmode = preferences.context_mode;
+            const validCmode = {};
+            if (cmode.enabled !== undefined) {
+                if (typeof cmode.enabled === "boolean")
+                    validCmode.enabled = cmode.enabled;
+                else
+                    errors.push("context_mode.enabled must be a boolean");
+            }
+            if (cmode.exec_timeout_ms !== undefined) {
+                const t = cmode.exec_timeout_ms;
+                if (typeof t === "number" && t >= 1000 && t <= 600_000)
+                    validCmode.exec_timeout_ms = Math.floor(t);
+                else
+                    errors.push("context_mode.exec_timeout_ms must be a number between 1000 and 600000");
+            }
+            if (cmode.exec_stdout_cap_bytes !== undefined) {
+                const b = cmode.exec_stdout_cap_bytes;
+                if (typeof b === "number" && b >= 4096 && b <= 16_777_216)
+                    validCmode.exec_stdout_cap_bytes = Math.floor(b);
+                else
+                    errors.push("context_mode.exec_stdout_cap_bytes must be a number between 4096 and 16777216");
+            }
+            if (cmode.exec_digest_chars !== undefined) {
+                const c = cmode.exec_digest_chars;
+                if (typeof c === "number" && c >= 0 && c <= 4000)
+                    validCmode.exec_digest_chars = Math.floor(c);
+                else
+                    errors.push("context_mode.exec_digest_chars must be a number between 0 and 4000");
+            }
+            if (cmode.exec_env_allowlist !== undefined) {
+                if (Array.isArray(cmode.exec_env_allowlist) &&
+                    cmode.exec_env_allowlist.every((v) => typeof v === "string" && /^[A-Z_][A-Z0-9_]*$/i.test(v))) {
+                    validCmode.exec_env_allowlist = cmode.exec_env_allowlist;
+                }
+                else {
+                    errors.push("context_mode.exec_env_allowlist must be an array of valid env var names");
+                }
+            }
+            if (Object.keys(validCmode).length > 0) {
+                validated.context_mode = validCmode;
+            }
+        }
+        else {
+            errors.push("context_mode must be an object");
+        }
+    }
     // ─── Parallel Config ────────────────────────────────────────────────────
     if (preferences.parallel && typeof preferences.parallel === "object") {
         const p = preferences.parallel;
@@ -716,6 +765,40 @@ export function validatePreferences(preferences) {
             validated.parallel = parallel;
         }
     }
+    // ─── Slice Parallel Config ───────────────────────────────────────────────
+    if (preferences.slice_parallel !== undefined) {
+        if (typeof preferences.slice_parallel === "object" && preferences.slice_parallel !== null) {
+            const sp = preferences.slice_parallel;
+            const validSp = {};
+            if (sp.enabled !== undefined) {
+                if (typeof sp.enabled === "boolean")
+                    validSp.enabled = sp.enabled;
+                else
+                    errors.push("slice_parallel.enabled must be a boolean");
+            }
+            if (sp.max_workers !== undefined) {
+                const maxWorkers = typeof sp.max_workers === "number" ? sp.max_workers : Number(sp.max_workers);
+                if (Number.isFinite(maxWorkers) && maxWorkers >= 1 && maxWorkers <= 8) {
+                    validSp.max_workers = Math.floor(maxWorkers);
+                }
+                else {
+                    errors.push("slice_parallel.max_workers must be a number between 1 and 8");
+                }
+            }
+            const knownSliceParallelKeys = new Set(["enabled", "max_workers"]);
+            for (const key of Object.keys(sp)) {
+                if (!knownSliceParallelKeys.has(key)) {
+                    warnings.push(`unknown slice_parallel key "${key}" — ignored`);
+                }
+            }
+            if (Object.keys(validSp).length > 0) {
+                validated.slice_parallel = validSp;
+            }
+        }
+        else {
+            errors.push("slice_parallel must be an object");
+        }
+    }
     // ─── Reactive Execution ─────────────────────────────────────────────────
     if (preferences.reactive_execution !== undefined) {
         if (typeof preferences.reactive_execution === "object" && preferences.reactive_execution !== null) {

package/dist/resources/extensions/gsd/preferences.js

@@ -26,12 +26,12 @@ export { resolveAllSkillReferences } from "./preferences-skills.js";
 // These lived in preferences-skills.ts but imported loadEffectiveGSDPreferences
 // back from this file, creating a circular dependency. Moved here since they
 // are trivial wrappers over loadEffectiveGSDPreferences.
-export function resolveSkillDiscoveryMode() {
-    const prefs = loadEffectiveGSDPreferences();
+export function resolveSkillDiscoveryMode(basePath) {
+    const prefs = loadEffectiveGSDPreferences(basePath);
     return prefs?.preferences.skill_discovery ?? "suggest";
 }
-export function resolveSkillStalenessDays() {
-    const prefs = loadEffectiveGSDPreferences();
+export function resolveSkillStalenessDays(basePath) {
+    const prefs = loadEffectiveGSDPreferences(basePath);
     return prefs?.preferences.skill_staleness_days ?? 60;
 }
 // ─── Re-exports: models ─────────────────────────────────────────────────────
@@ -46,16 +46,16 @@ function globalPreferencesPath() {
 function legacyGlobalPreferencesPath() {
     return join(homedir(), ".pi", "agent", "gsd-preferences.md");
 }
-function projectPreferencesPath() {
-    return join(gsdRoot(process.cwd()), "PREFERENCES.md");
+function projectPreferencesPath(basePath = process.cwd()) {
+    return join(gsdRoot(basePath), "PREFERENCES.md");
 }
 // Legacy lowercase files can still exist in older projects. Keep them as a
 // compatibility-only fallback, but route new reads/writes through PREFERENCES.md.
 function legacyGlobalPreferencesPathLowercase() {
     return join(gsdHome(), "preferences.md");
 }
-function legacyProjectPreferencesPathLowercase() {
-    return join(gsdRoot(process.cwd()), "preferences.md");
+function legacyProjectPreferencesPathLowercase(basePath = process.cwd()) {
+    return join(gsdRoot(basePath), "preferences.md");
 }
 export function getGlobalGSDPreferencesPath() {
     return globalPreferencesPath();
@@ -63,8 +63,8 @@ export function getGlobalGSDPreferencesPath() {
 export function getLegacyGlobalGSDPreferencesPath() {
     return legacyGlobalPreferencesPath();
 }
-export function getProjectGSDPreferencesPath() {
-    return projectPreferencesPath();
+export function getProjectGSDPreferencesPath(basePath) {
+    return projectPreferencesPath(basePath);
 }
 // ─── Loading ────────────────────────────────────────────────────────────────
 export function loadGlobalGSDPreferences() {
@@ -72,13 +72,13 @@ export function loadGlobalGSDPreferences() {
         ?? loadPreferencesFile(legacyGlobalPreferencesPathLowercase(), "global")
         ?? loadPreferencesFile(legacyGlobalPreferencesPath(), "global");
 }
-export function loadProjectGSDPreferences() {
-    return loadPreferencesFile(projectPreferencesPath(), "project")
-        ?? loadPreferencesFile(legacyProjectPreferencesPathLowercase(), "project");
+export function loadProjectGSDPreferences(basePath) {
+    return loadPreferencesFile(projectPreferencesPath(basePath), "project")
+        ?? loadPreferencesFile(legacyProjectPreferencesPathLowercase(basePath), "project");
 }
-export function loadEffectiveGSDPreferences() {
+export function loadEffectiveGSDPreferences(basePath) {
     const globalPreferences = loadGlobalGSDPreferences();
-    const projectPreferences = loadProjectGSDPreferences();
+    const projectPreferences = loadProjectGSDPreferences(basePath);
     if (!globalPreferences && !projectPreferences)
         return null;
     let result;
@@ -489,8 +489,8 @@ export function resolvePreDispatchHooks() {
  * Worktree isolation requires explicit opt-in because it depends on git
  * branch infrastructure that must be set up before use.
  */
-export function getIsolationMode() {
-    const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
+export function getIsolationMode(basePath) {
+    const prefs = loadEffectiveGSDPreferences(basePath)?.preferences?.git;
     if (prefs?.isolation === "worktree")
         return "worktree";
     if (prefs?.isolation === "branch")

package/dist/resources/extensions/gsd/prompt-loader.js

@@ -22,6 +22,27 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 import { logWarning } from "./workflow-logger.js";
+function hasRequiredExtensionAssets(rootDir, exists = existsSync) {
+    return (exists(join(rootDir, "prompts")) &&
+        exists(join(rootDir, "templates", "task-summary.md")));
+}
+export function resolveExtensionDirFromCandidates(moduleDir, agentGsdDir, exists = existsSync) {
+    const moduleUsable = hasRequiredExtensionAssets(moduleDir, exists);
+    const agentUsable = hasRequiredExtensionAssets(agentGsdDir, exists);
+    // Prefer the user-local extension tree when both are valid. This avoids
+    // leaking npm/global-install paths into prompts on Windows.
+    if (agentUsable)
+        return agentGsdDir;
+    if (moduleUsable)
+        return moduleDir;
+    // Degraded fallback: if required template is missing in both locations,
+    // keep previous behavior and prefer whichever still has prompts/.
+    if (exists(join(moduleDir, "prompts")))
+        return moduleDir;
+    if (exists(join(agentGsdDir, "prompts")))
+        return agentGsdDir;
+    return moduleDir;
+}
 /**
  * Resolve the GSD extension directory.
  *
@@ -34,15 +55,9 @@ import { logWarning } from "./workflow-logger.js";
  */
 function resolveExtensionDir() {
     const moduleDir = dirname(fileURLToPath(import.meta.url));
-    if (existsSync(join(moduleDir, "prompts")))
-        return moduleDir;
-    // Fallback: user-local agent directory
     const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
     const agentGsdDir = join(gsdHome, "agent", "extensions", "gsd");
-    if (existsSync(join(agentGsdDir, "prompts")))
-        return agentGsdDir;
-    // Last resort: return the module dir (warmCache will silently handle the miss)
-    return moduleDir;
+    return resolveExtensionDirFromCandidates(moduleDir, agentGsdDir);
 }
 const __extensionDir = resolveExtensionDir();
 const promptsDir = join(__extensionDir, "prompts");

package/dist/resources/extensions/gsd/prompts/discuss-headless.md

@@ -162,6 +162,10 @@ Preserve the specification's exact terminology, emphasis, and specific framing.
 6. For each architectural or pattern decision, call `gsd_decision_save` — the tool auto-assigns IDs and regenerates `.gsd/DECISIONS.md` automatically.
 7. {{commitInstruction}}
 
+### Ready-phrase pre-condition (NON-BYPASSABLE)
+
+Before emitting the ready phrase, verify in the CURRENT turn that you have written `.gsd/PROJECT.md`, `.gsd/REQUIREMENTS.md`, `{{contextPath}}`, and called `gsd_plan_milestone`. If any is missing, **STOP** — emit the missing tool calls in this same turn. The system rejects premature ready signals and retries are capped.
+
 After writing the files, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
 
 ### Multi-Milestone
@@ -234,6 +238,10 @@ For single-milestone projects, do NOT write this file.
 
 7. {{multiMilestoneCommitInstruction}}
 
+### Ready-phrase pre-condition (NON-BYPASSABLE)
+
+Before emitting the ready phrase, verify in the CURRENT turn that you have written `.gsd/PROJECT.md`, `.gsd/REQUIREMENTS.md`, the primary `CONTEXT.md`, called `gsd_plan_milestone` for the primary milestone, and written `.gsd/DISCUSSION-MANIFEST.json` with `gates_completed === total`. If any is missing, **STOP** — emit the missing tool calls in this same turn. The system rejects premature ready signals and retries are capped.
+
 After writing the files, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
 
 ## Critical Rules

package/dist/resources/extensions/gsd/prompts/discuss.md

@@ -339,7 +339,20 @@ These sections are in addition to whatever other context the discussion surfaced
 6. For each architectural or pattern decision made during discussion, call `gsd_decision_save` — the tool auto-assigns IDs and regenerates `.gsd/DECISIONS.md` automatically.
 7. {{commitInstruction}}
 
-After writing the files, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
+### Ready-phrase pre-condition (NON-BYPASSABLE)
+
+Before emitting the ready phrase, verify in the CURRENT turn that you have:
+
+- [ ] Written `.gsd/PROJECT.md` (step 2)
+- [ ] Written `.gsd/REQUIREMENTS.md` (step 3)
+- [ ] Written `{{contextPath}}` (step 4)
+- [ ] Called `gsd_plan_milestone` (step 5)
+
+If ANY box is unchecked, **STOP**. Do NOT emit the ready phrase. Emit the missing tool calls in this same turn. The system detects missing artifacts and will reject premature ready signals — you will be asked again and retries are capped.
+
+Do not announce the ready phrase as something you are "about to" do. Do not narrate "now writing the files" as a substitute for actually writing them. The ready phrase is a post-write signal, not an intent signal.
+
+After completing steps 1–7 above, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
 
 ### Multi-Milestone
 
@@ -418,6 +431,20 @@ For single-milestone projects, do NOT write this file — it is only for multi-m
 
 7. {{multiMilestoneCommitInstruction}}
 
-After writing the files, say exactly: "Milestone M001 ready." — nothing else. Auto-mode will start automatically.
+### Ready-phrase pre-condition (NON-BYPASSABLE)
+
+Before emitting the ready phrase, verify in the CURRENT turn that you have:
+
+- [ ] Written `.gsd/PROJECT.md` (Phase 1)
+- [ ] Written `.gsd/REQUIREMENTS.md` (Phase 1)
+- [ ] Written primary-milestone `CONTEXT.md` (Phase 2)
+- [ ] Called `gsd_plan_milestone` for the primary milestone (Phase 2)
+- [ ] Written `.gsd/DISCUSSION-MANIFEST.json` with `gates_completed === total` (Phase 3)
+
+If ANY box is unchecked, **STOP**. Do NOT emit the ready phrase. Emit the missing tool calls in this same turn. The system detects missing artifacts and will reject premature ready signals — you will be asked again and retries are capped.
+
+Do not announce the ready phrase as something you are "about to" do. Do not narrate "now writing the files" as a substitute for actually writing them. The ready phrase is a post-write signal, not an intent signal.
+
+After completing all phases above, say exactly: "Milestone M001 ready." — nothing else. Auto-mode will start automatically.
 
 {{inlinedTemplates}}

package/dist/resources/extensions/gsd/prompts/parallel-research-slices.md

@@ -15,8 +15,11 @@ Dispatch ALL slices simultaneously using the `subagent` tool in **parallel mode*
 1. Call `subagent` with `tasks: [...]` containing one entry per slice below
 2. Wait for ALL subagents to complete
 3. Verify each slice's RESEARCH file was written (check the `.gsd/{{mid}}/` directory)
-4. If any subagent failed to write its RESEARCH file, re-run it individually
-5. Report which slices completed research and which (if any) failed
+4. If a subagent failed to write its RESEARCH file, retry it **once** individually
+5. If it fails a second time, write a partial RESEARCH file for that slice with a `## BLOCKER` section explaining the failure — do NOT retry again
+6. Report which slices completed research and which (if any) needed a blocker note
+
+**Important**: Each failed slice gets exactly one retry. After that, write the blocker and move on. Never retry the same slice more than once.
 
 ## Subagent Prompts
 

package/dist/resources/extensions/gsd/safety/evidence-collector.js

@@ -3,9 +3,17 @@
  * Tracks every bash command, file write, and file edit during a unit execution.
  * Evidence is compared against LLM completion claims in evidence-cross-ref.ts.
  *
+ * Evidence is persisted to .gsd/safety/evidence-<mid>-<sid>-<tid>.json so it
+ * survives session restarts (pause/resume, crash recovery). On unit start,
+ * call resetEvidence() then loadEvidenceFromDisk(). On every new tool call,
+ * saveEvidenceToDisk() is called automatically by recordToolCall/recordToolResult.
+ *
  * Follows the same module-level Map pattern as auto-tool-tracking.ts.
  * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
  */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, } from "node:fs";
+import { join, dirname } from "node:path";
+import { randomBytes } from "node:crypto";
 // ─── Module State ───────────────────────────────────────────────────────────
 let unitEvidence = [];
 // ─── Public API ─────────────────────────────────────────────────────────────
@@ -27,6 +35,94 @@ export function getFilePaths() {
         .filter((e) => e.kind === "write" || e.kind === "edit")
         .map(e => e.path);
 }
+// ─── Persistence (Bug #4385 — evidence must survive session restarts) ────────
+/**
+ * Build the path for the evidence JSON file for a given unit.
+ * Lives under .gsd/safety/ which is gitignored and session-scoped.
+ */
+function evidencePath(basePath, milestoneId, sliceId, taskId) {
+    return join(basePath, ".gsd", "safety", `evidence-${milestoneId}-${sliceId}-${taskId}.json`);
+}
+/**
+ * Validate that a parsed value is an array of EvidenceEntry objects.
+ * Rejects corrupt / schema-mismatch data rather than letting it poison state.
+ */
+function isEvidenceArray(data) {
+    if (!Array.isArray(data))
+        return false;
+    return data.every((e) => {
+        if (e === null || typeof e !== "object")
+            return false;
+        const rec = e;
+        if (typeof rec.toolCallId !== "string")
+            return false;
+        if (typeof rec.timestamp !== "number")
+            return false;
+        if (rec.kind === "bash") {
+            return (typeof rec.command === "string" &&
+                typeof rec.exitCode === "number" &&
+                typeof rec.outputSnippet === "string");
+        }
+        if (rec.kind === "write" || rec.kind === "edit") {
+            return typeof rec.path === "string";
+        }
+        return false;
+    });
+}
+/**
+ * Persist the current in-memory evidence to disk so it survives a session
+ * restart. Called from saveEvidenceToDisk after recordToolCall/recordToolResult.
+ * Non-fatal — persistence failures must never break unit execution.
+ */
+export function saveEvidenceToDisk(basePath, milestoneId, sliceId, taskId) {
+    try {
+        const path = evidencePath(basePath, milestoneId, sliceId, taskId);
+        mkdirSync(dirname(path), { recursive: true });
+        const tmp = `${path}.tmp.${randomBytes(4).toString("hex")}`;
+        writeFileSync(tmp, JSON.stringify(unitEvidence, null, 2) + "\n", "utf-8");
+        renameSync(tmp, path);
+    }
+    catch {
+        // Non-fatal — don't let persistence failures break unit execution
+    }
+}
+/**
+ * Load persisted evidence from disk into the in-memory array.
+ * Call after resetEvidence() on session resume to restore context for a
+ * partially-executed unit. If the file does not exist (fresh unit), this
+ * is a no-op — getEvidence() will return [] which is correct.
+ */
+export function loadEvidenceFromDisk(basePath, milestoneId, sliceId, taskId) {
+    try {
+        const path = evidencePath(basePath, milestoneId, sliceId, taskId);
+        if (!existsSync(path))
+            return;
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (isEvidenceArray(parsed)) {
+            unitEvidence = parsed;
+        }
+    }
+    catch {
+        // Non-fatal — corrupt / missing file is treated as empty evidence
+    }
+}
+/**
+ * Delete the persisted evidence file for a unit after it has been fully
+ * processed. Prevents stale evidence from affecting future retries of
+ * the same unit ID.
+ */
+export function clearEvidenceFromDisk(basePath, milestoneId, sliceId, taskId) {
+    try {
+        const path = evidencePath(basePath, milestoneId, sliceId, taskId);
+        if (existsSync(path)) {
+            unlinkSync(path);
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+}
 // ─── Recording (called from register-hooks.ts) ─────────────────────────────
 /**
  * Record a tool call at dispatch time (before execution).

package/dist/resources/extensions/gsd/safety/file-change-validator.js

@@ -4,13 +4,18 @@
  *
  * Uses tasks.expected_output (DB column, populated from per-task ## Expected Output)
  * and tasks.files (from slice PLAN.md - Files: subline) as the expected set.
- * Compares against git diff HEAD~1 --name-only after auto-commit.
+ * Compares against `git diff-tree --root --no-commit-id -r --name-only HEAD` after auto-commit.
+ * Using diff-tree --root handles initial commits, shallow clones, and merge commits correctly
+ * (Bug #4385 — git diff HEAD~1 failed on initial commits).
  *
  * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
  */
+import { createRequire } from "node:module";
 import { execFileSync } from "node:child_process";
 import { normalizePlannedFileReference } from "../files.js";
 import { logWarning } from "../workflow-logger.js";
+const _require = createRequire(import.meta.url);
+const picomatch = _require("picomatch");
 // ─── Public API ─────────────────────────────────────────────────────────────
 /**
  * Validate file changes after auto-commit for an execute-task unit.
@@ -20,7 +25,7 @@ import { logWarning } from "../workflow-logger.js";
  * @param expectedOutput - JSON array from tasks.expected_output DB column
  * @param plannedFiles - JSON array from tasks.files DB column
  */
-export function validateFileChanges(basePath, expectedOutput, plannedFiles) {
+export function validateFileChanges(basePath, expectedOutput, plannedFiles, fileChangeAllowlist = []) {
     const allExpected = new Set([...expectedOutput, ...plannedFiles]);
     // If no expected files were planned, skip validation
     if (allExpected.size === 0)
@@ -33,8 +38,11 @@ export function validateFileChanges(basePath, expectedOutput, plannedFiles) {
     const projectFiles = actualFiles.filter(f => !f.startsWith(".gsd/") && !f.startsWith(".gsd\\"));
     // Normalize expected paths (strip leading ./ or /)
     const normalizedExpected = new Set([...allExpected].map((f) => normalizePlannedFileReference(f).replace(/^\.\//, "").replace(/^\//, "")));
-    // Compute symmetric difference
-    const unexpectedFiles = projectFiles.filter(f => !normalizedExpected.has(f));
+    // Build allowlist matchers once (dot: true so patterns like `**/.hidden` work).
+    const allowlistMatchers = fileChangeAllowlist.map(p => picomatch(p, { dot: true }));
+    const isAllowlisted = (f) => allowlistMatchers.some(m => m(f));
+    // Compute symmetric difference, excluding allowlisted files
+    const unexpectedFiles = projectFiles.filter(f => !normalizedExpected.has(f) && !isAllowlisted(f));
     const missingFiles = [...normalizedExpected].filter(f => !projectFiles.includes(f));
     const violations = [];
     for (const f of unexpectedFiles) {
@@ -62,7 +70,7 @@ export function validateFileChanges(basePath, expectedOutput, plannedFiles) {
 // ─── Internals ──────────────────────────────────────────────────────────────
 function getChangedFilesFromLastCommit(basePath) {
     try {
-        const result = execFileSync("git", ["diff", "--name-only", "HEAD~1", "HEAD"], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+        const result = execFileSync("git", ["diff-tree", "--root", "--no-commit-id", "-r", "--name-only", "HEAD"], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
         return result ? result.split("\n").filter(Boolean) : [];
     }
     catch (e) {