gsd-pi 2.78.1-dev.82bcf6b71 → 2.78.1-dev.84c045fd2

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -1,6 +1,6 @@
 /**
  * Post-unit processing for auto-loop — auto-commit, doctor run,
- * state rebuild, worktree sync, DB dual-write, hooks, triage, and
+ * state rebuild, projection checks, DB tool closeout, hooks, triage, and
  * quick-task dispatch.
  *
  * Split into two functions called sequentially by auto-loop with
@@ -14,6 +14,7 @@ import { deriveState } from "./state.js";
 import { logWarning, logError } from "./workflow-logger.js";
 import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
+import { isAwaitingUserInput } from "./user-input-boundary.js";
 import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { rebuildState } from "./doctor.js";
@@ -23,7 +24,7 @@ import { runTurnGitAction, } from "./git-service.js";
 import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceholder, diagnoseExpectedArtifact, } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
 import { syncStateToProjectRoot } from "./auto-worktree.js";
-import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, updateSliceStatus, _getAdapter } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
@@ -37,7 +38,7 @@ import { validateFileChanges } from "./safety/file-change-validator.js";
 import { validateContent } from "./safety/content-validator.js";
 import { resolveSafetyHarnessConfig } from "./safety/safety-harness.js";
 import { resolveExpectedArtifactPath as resolveArtifactForContent } from "./auto-artifact-paths.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { getIsolationMode, loadEffectiveGSDPreferences } from "./preferences.js";
 import { getSliceTasks } from "./gsd-db.js";
 import { runPreExecutionChecks } from "./pre-execution-checks.js";
 import { writePreExecutionEvidence } from "./verification-evidence.js";
@@ -48,6 +49,8 @@ import { writeTurnGitTransaction } from "./uok/gitops.js";
 import { isClosedStatus } from "./status-guards.js";
 import { detectAbandonMilestone } from "./abandon-detect.js";
 import { isDeterministicPolicyError } from "./auto-tool-tracking.js";
+import { clearProjectResearchInflightMarker, finalizeProjectResearchTimeout, } from "./project-research-policy.js";
+import { validateArtifact } from "./schemas/validate.js";
 /** Maximum verification retry attempts before escalating to blocker placeholder (#2653). */
 const MAX_VERIFICATION_RETRIES = 3;
 /** Keep failure toasts short while still showing concrete examples. */
@@ -106,9 +109,8 @@ import { autoCommitCurrentBranch } from "./worktree.js";
  * the completion tool. A "rogue" file is one that exists on disk but has
  * no corresponding DB row with status "complete".
  *
- * This is a safety-net diagnostic (D003). The existing migrateFromMarkdown()
- * in postUnitPostVerification() eventually ingests rogue files, but explicit
- * detection provides immediate diagnostics so operators know the prompt failed.
+ * This is a safety-net diagnostic (D003). Runtime detection never imports
+ * markdown into the DB; explicit migration/import/recovery commands own that.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function hasNonEmptyFields(row, fields) {
@@ -142,15 +144,7 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
             return [];
         const dbRow = getSlice(mid, sid);
         if (!dbRow || dbRow.status !== "complete") {
-            // Auto-remediate: SUMMARY exists on disk but DB is stale — sync DB to
-            // match filesystem instead of reporting as rogue (#3633).
-            try {
-                updateSliceStatus(mid, sid, "complete", new Date().toISOString());
-            }
-            catch {
-                // If DB update fails, fall back to rogue detection so the issue is visible
-                rogues.push({ path: summaryPath, unitType, unitId });
-            }
+            rogues.push({ path: summaryPath, unitType, unitId });
         }
     }
     else if (unitType === "plan-milestone") {
@@ -226,6 +220,43 @@ export function buildStepCompleteMessage(nextState) {
     return `Step complete. Next: ${next.label}\n`
         + `Run /clear, then /gsd to continue (or /gsd auto to run continuously).`;
 }
+export const USER_DRIVEN_DEEP_UNITS = new Set([
+    "discuss-project",
+    "discuss-requirements",
+    "discuss-milestone",
+    "research-decision",
+]);
+export { isAwaitingUserInput } from "./user-input-boundary.js";
+function artifactValidationKind(unitType) {
+    if (unitType === "discuss-project")
+        return "project";
+    if (unitType === "discuss-requirements")
+        return "requirements";
+    return null;
+}
+function describeArtifactVerificationFailure(unitType, unitId, basePath) {
+    const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
+    if (!artifactPath) {
+        return `Artifact verification failed: ${unitType} "${unitId}" has no resolvable artifact path.`;
+    }
+    const relPath = relative(basePath, artifactPath);
+    if (!existsSync(artifactPath)) {
+        return `Artifact verification failed: ${relPath} was not found on disk after unit execution.`;
+    }
+    const validationKind = artifactValidationKind(unitType);
+    if (validationKind) {
+        const result = validateArtifact(artifactPath, validationKind);
+        if (!result.ok) {
+            const errors = result.errors
+                .slice(0, MAX_NOTIFICATION_DETAILS)
+                .map((error) => `${error.code}: ${error.message}`)
+                .join("; ");
+            return `Artifact verification failed: ${relPath} exists but is invalid${errors ? ` (${errors})` : ""}.`;
+        }
+    }
+    const expected = diagnoseExpectedArtifact(unitType, unitId, basePath);
+    return `Artifact verification failed: ${relPath} exists but did not satisfy the ${unitType} completion contract${expected ? ` (${expected})` : ""}.`;
+}
 export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
     try {
         let taskContext;
@@ -425,17 +456,14 @@ export async function postUnitPreVerification(pctx, opts) {
                         });
                     }
                     const failureMsg = `Git ${turnAction} failed: ${(gitResult.error ?? "unknown error").split("\n")[0]}`;
-                    if (uokFlags.gitops) {
-                        ctx.ui.notify(failureMsg, "error");
-                        await pauseAuto(ctx, pi);
-                        return "dispatched";
-                    }
-                    ctx.ui.notify(failureMsg, "warning");
+                    ctx.ui.notify(failureMsg, "error");
                     debugLog("postUnit", {
-                        phase: "git-action-failed-nonblocking",
+                        phase: "git-action-failed-blocking",
                         action: turnAction,
                         error: gitResult.error ?? "unknown error",
                     });
+                    await pauseAuto(ctx, pi);
+                    return "dispatched";
                 }
                 s.lastGitActionStatus = "ok";
                 if (turnAction === "commit" && gitResult.commitMessage) {
@@ -550,7 +578,7 @@ export async function postUnitPreVerification(pctx, opts) {
                 const { getCollapseCadence, mergeSliceToMain } = await import("./slice-cadence.js");
                 if (getCollapseCadence(prefs) !== "slice")
                     return;
-                if (prefs?.git?.isolation !== "worktree")
+                if (getIsolationMode(s.originalBasePath || s.basePath) !== "worktree")
                     return;
                 if (s.isolationDegraded)
                     return;
@@ -591,7 +619,7 @@ export async function postUnitPreVerification(pctx, opts) {
                         ctx.ui.notify(`slice-cadence merge conflict in ${sid}: ${err.conflictedFiles.join(", ")}. ` +
                             `Resolve manually on main and run \`/gsd auto\` to resume.`, "error");
                         // Stop auto AND signal the outer postUnit flow to exit early.
-                        // Without the flag, subsequent hooks (triage, rogue detection,
+                        // Without the flag, subsequent hooks (triage,
                         // DB writes) would keep running against a conflicted main
                         // checkout after the loop was already told to stop.
                         const { stopAuto } = await import("./auto.js");
@@ -611,7 +639,7 @@ export async function postUnitPreVerification(pctx, opts) {
                 }
             });
             // Exit early after stopAuto so the rest of post-unit processing
-            // (triage, rogue detection, hook dispatch, DB writes) doesn't run
+            // (triage, hook dispatch, DB writes) doesn't run
             // against a conflicted main checkout. Return "dispatched" to match
             // the convention used by other stop/pauseAuto paths in this function
             // (see signal handling earlier: stop/pause also return "dispatched").
@@ -652,17 +680,6 @@ export async function postUnitPreVerification(pctx, opts) {
                 logError("engine", "triage resolution failed", { error: err.message });
             }
         }
-        // Rogue file detection — safety net for LLM bypassing completion tools (D003)
-        try {
-            const rogueFiles = detectRogueFileWrites(s.currentUnit.type, s.currentUnit.id, s.basePath);
-            for (const rogue of rogueFiles) {
-                logWarning("engine", "rogue file write detected", { path: rogue.path, unitId: rogue.unitId });
-                ctx.ui.notify(`Rogue file write detected: ${rogue.path}`, "warning");
-            }
-        }
-        catch (e) {
-            debugLog("postUnit", { phase: "rogue-detection", error: String(e) });
-        }
         // ── Safety harness: post-unit validation ──
         try {
             const { loadEffectiveGSDPreferences } = await import("./preferences.js");
@@ -796,13 +813,40 @@ export async function postUnitPreVerification(pctx, opts) {
                     debugLog("postUnit", { phase: "regenerate-projection", error: String(e) });
                 }
             }
+            if (s.currentUnit.type === "research-project") {
+                try {
+                    clearProjectResearchInflightMarker(s.basePath);
+                }
+                catch (e) {
+                    debugLog("postUnit", { phase: "research-project-inflight-cleanup", error: String(e) });
+                }
+            }
+            if (!triggerArtifactVerified && s.currentUnit.type === "research-project") {
+                const retryKey = `${s.currentUnit.type}:${s.currentUnit.id}`;
+                const outcome = finalizeProjectResearchTimeout(s.basePath, "Project research unit ended before all required dimensions produced durable files.");
+                s.pendingVerificationRetry = null;
+                s.verificationRetryCount.delete(retryKey);
+                triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
+                if (triggerArtifactVerified) {
+                    invalidateAllCaches();
+                    ctx.ui.notify(outcome.kind === "partial-blockers"
+                        ? "Project research finished partially; wrote blockers for missing dimensions and advancing without rerunning all scouts."
+                        : "Project research artifacts are now terminal.", "warning");
+                }
+                else {
+                    ctx.ui.notify("Project research produced no usable research files; wrote PROJECT-RESEARCH-BLOCKER.md and continuing fail-closed.", "error");
+                    return "continue";
+                }
+            }
             // When artifact verification fails for a unit type that has a known expected
-            // artifact, return "retry" so the caller re-dispatches with failure context
+            // artifact, ask the caller to retry so it re-dispatches with failure context
             // instead of blindly re-dispatching the same unit (#1571).
             // Retries are capped at MAX_ARTIFACT_VERIFICATION_RETRIES to prevent
             // unbounded loops (#2007).
             //
             // Pre-checks short-circuit retry for known-unrecoverable failures:
+            // - User-input waits in deep setup: pause instead of retrying or writing
+            //   placeholders while the agent is waiting for approval.
             // - Deterministic policy rejection (#4973): structural write-gate failure
             //   that will recur on every retry, so write a blocker placeholder.
             // - DB infra failure (#2517): completion tool returned db_unavailable, so
@@ -810,11 +854,22 @@ export async function postUnitPreVerification(pctx, opts) {
             // - Tool invocation error (#2883/#3595): malformed JSON args or queued
             //   user message — retry will produce the same failure.
             //
-            // #4973: Deterministic policy rejections (e.g. context_write_blocked from the
-            // write-gate) are checked FIRST — before the DB-availability check — because
-            // they are structural gates that will fire on every retry regardless of DB or
-            // model tier. Short-circuit immediately by writing a blocker placeholder.
-            if (!triggerArtifactVerified && s.lastToolInvocationError && isDeterministicPolicyError(s.lastToolInvocationError)) {
+            // User-driven deep setup prompts may ask for approval before the final
+            // root artifact write. If a premature write hits the write gate in the
+            // same turn, the user wait is the meaningful state; pause instead of
+            // writing a placeholder over PROJECT/REQUIREMENTS.
+            if (!triggerArtifactVerified && USER_DRIVEN_DEEP_UNITS.has(s.currentUnit.type) && isAwaitingUserInput(opts?.agentEndMessages)) {
+                debugLog("postUnit", {
+                    phase: "artifact-verify-awaiting-user",
+                    unitType: s.currentUnit.type,
+                    unitId: s.currentUnit.id,
+                });
+                ctx.ui.notify(`${s.currentUnit.type} ${s.currentUnit.id} is waiting for your input — pausing auto-mode instead of retrying the missing artifact.`, "info");
+                s.lastToolInvocationError = null;
+                await pauseAuto(ctx, pi);
+                return "dispatched";
+            }
+            else if (!triggerArtifactVerified && s.lastToolInvocationError && isDeterministicPolicyError(s.lastToolInvocationError)) {
                 const retryKey = `${s.currentUnit.type}:${s.currentUnit.id}`;
                 debugLog("postUnit", { phase: "deterministic-policy-error-placeholder", unitType: s.currentUnit.type, unitId: s.currentUnit.id, error: s.lastToolInvocationError });
                 const reason = `Deterministic policy rejection for ${s.currentUnit.type} "${s.currentUnit.id}": ${s.lastToolInvocationError}. Retrying cannot resolve this gate — writing blocker placeholder to advance pipeline.`;
@@ -846,21 +901,22 @@ export async function postUnitPreVerification(pctx, opts) {
                 if (hasExpectedArtifact) {
                     const retryKey = `${s.currentUnit.type}:${s.currentUnit.id}`;
                     const attempt = (s.verificationRetryCount.get(retryKey) ?? 0) + 1;
+                    const failureDetails = describeArtifactVerificationFailure(s.currentUnit.type, s.currentUnit.id, s.basePath);
                     if (attempt > MAX_ARTIFACT_VERIFICATION_RETRIES) {
                         s.verificationRetryCount.delete(retryKey);
                         debugLog("postUnit", { phase: "artifact-verify-exhausted", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
-                        ctx.ui.notify(`Artifact still missing for ${s.currentUnit.type} ${s.currentUnit.id} after ${MAX_ARTIFACT_VERIFICATION_RETRIES} retries — pausing auto-mode`, "error");
+                        ctx.ui.notify(`${failureDetails} Pausing auto-mode after ${MAX_ARTIFACT_VERIFICATION_RETRIES} retries.`, "error");
                         await pauseAuto(ctx, pi);
                         return "dispatched";
                     }
                     s.verificationRetryCount.set(retryKey, attempt);
                     s.pendingVerificationRetry = {
                         unitId: s.currentUnit.id,
-                        failureContext: `Artifact verification failed: expected artifact for ${s.currentUnit.type} "${s.currentUnit.id}" was not found on disk after unit execution (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}).`,
+                        failureContext: `${failureDetails} (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}).`,
                         attempt,
                     };
                     debugLog("postUnit", { phase: "artifact-verify-retry", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
-                    ctx.ui.notify(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} — retrying (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES})`, "warning");
+                    ctx.ui.notify(`${failureDetails} Retrying (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}).`, "warning");
                     return "retry";
                 }
             }

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -77,17 +77,17 @@ function capPreamble(preamble) {
  * Uses the budget engine to compute task count ranges and inline context budgets
  * based on the configured executor model's context window.
  */
-function formatExecutorConstraints(sessionContextWindow, modelRegistry) {
+function formatExecutorConstraints(sessionContextWindow, modelRegistry, sessionProvider) {
     let windowTokens;
     try {
         const prefs = loadEffectiveGSDPreferences();
-        windowTokens = resolveExecutorContextWindow(modelRegistry, prefs?.preferences, sessionContextWindow);
+        windowTokens = resolveExecutorContextWindow(modelRegistry, prefs?.preferences, sessionContextWindow, sessionProvider);
     }
     catch (e) {
         logWarning("prompt", `resolveExecutorContextWindow failed: ${e.message}`);
         // Delegate to the budget engine without prefs (the path that just threw)
         // so DEFAULT_CONTEXT_WINDOW stays the single source of truth.
-        windowTokens = resolveExecutorContextWindow(undefined, undefined, sessionContextWindow);
+        windowTokens = resolveExecutorContextWindow(undefined, undefined, sessionContextWindow, sessionProvider);
     }
     const budgets = computeBudgets(windowTokens);
     const { min, max } = budgets.taskCountRange;
@@ -1136,6 +1136,73 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
     }
     return basePrompt;
 }
+/**
+ * Build a prompt for the workflow-preferences unit type (deep mode).
+ * Default-writing stage: records high-impact workflow defaults in
+ * .gsd/PREFERENCES.md. Runs ONCE per project, early
+ * in deep-mode bootstrap before discuss-project.
+ */
+export async function buildWorkflowPreferencesPrompt(base, structuredQuestionsAvailable = "false") {
+    return loadPrompt("guided-workflow-preferences", {
+        workingDirectory: base,
+        structuredQuestionsAvailable,
+    });
+}
+/**
+ * Build a prompt for the research-project (parallel) unit type (deep mode).
+ * Orchestrator that spawns 4 parallel Task() calls covering stack, features,
+ * architecture, and pitfalls. Each subagent writes its findings to .gsd/research/.
+ * Fires after research-decision marker says "research" and project research files
+ * are missing. Skipped entirely if user picked "skip".
+ */
+export async function buildResearchProjectPrompt(base, structuredQuestionsAvailable = "false") {
+    return loadPrompt("guided-research-project", {
+        workingDirectory: base,
+        structuredQuestionsAvailable,
+    });
+}
+/**
+ * Build a prompt for the research-decision unit type (deep mode).
+ * Fixed-question stage: asks "research first or skip?" via ask_user_questions
+ * and writes .gsd/runtime/research-decision.json. Fires after discuss-requirements
+ * and before research-project-parallel.
+ */
+export async function buildResearchDecisionPrompt(base, structuredQuestionsAvailable = "false") {
+    return loadPrompt("guided-research-decision", {
+        workingDirectory: base,
+        structuredQuestionsAvailable,
+    });
+}
+/**
+ * Build a prompt for the discuss-project unit type (deep mode).
+ * Project-level interview: produces .gsd/PROJECT.md.
+ * Fires before any milestone-level work when planning_depth === "deep" and
+ * PROJECT.md is missing.
+ */
+export async function buildDiscussProjectPrompt(base, structuredQuestionsAvailable = "false") {
+    const inlinedTemplates = inlineTemplate("project", "Project");
+    return loadPrompt("guided-discuss-project", {
+        workingDirectory: base,
+        inlinedTemplates,
+        structuredQuestionsAvailable,
+        commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
+    });
+}
+/**
+ * Build a prompt for the discuss-requirements unit type (deep mode).
+ * Requirements-level interview: produces .gsd/REQUIREMENTS.md using the
+ * structured R### format. Reads PROJECT.md as authoritative context.
+ * Fires when planning_depth === "deep", PROJECT.md exists, and REQUIREMENTS.md is missing.
+ */
+export async function buildDiscussRequirementsPrompt(base, structuredQuestionsAvailable = "false") {
+    const inlinedTemplates = inlineTemplate("requirements", "Requirements");
+    return loadPrompt("guided-discuss-requirements", {
+        workingDirectory: base,
+        inlinedTemplates,
+        structuredQuestionsAvailable,
+        commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
+    });
+}
 export async function buildResearchMilestonePrompt(mid, midTitle, base) {
     // #4782 phase 3: research-milestone migrated through the composer.
     // Declared inline order: milestone-context, project, requirements,
@@ -1367,7 +1434,7 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
  * sketch-scope constraint).
  */
 async function renderSlicePrompt(options) {
-    const { mid, sid, sTitle, base, level, promptTemplate, prependBlocks = [], extraVars = {}, sessionContextWindow, modelRegistry, } = options;
+    const { mid, sid, sTitle, base, level, promptTemplate, prependBlocks = [], extraVars = {}, sessionContextWindow, modelRegistry, sessionProvider, } = options;
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
     const researchPath = resolveSliceFile(base, mid, sid, "RESEARCH");
@@ -1417,7 +1484,7 @@ async function renderSlicePrompt(options) {
     if (overridesInline)
         inlined.unshift(overridesInline);
     const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
-    const executorContextConstraints = formatExecutorConstraints(sessionContextWindow, modelRegistry);
+    const executorContextConstraints = formatExecutorConstraints(sessionContextWindow, modelRegistry, sessionProvider);
     const outputRelPath = relSliceFile(base, mid, sid, "PLAN");
     const commitInstruction = "Do not commit — .gsd/ planning docs are managed externally and not tracked in git.";
     return loadPrompt(promptTemplate, {
@@ -1474,6 +1541,7 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
         prependBlocks,
         sessionContextWindow: options?.sessionContextWindow,
         modelRegistry: options?.modelRegistry,
+        sessionProvider: options?.sessionProvider,
     });
 }
 /**
@@ -1508,6 +1576,7 @@ export async function buildRefineSlicePrompt(mid, _midTitle, sid, sTitle, base,
         extraVars: { sketchScope },
         sessionContextWindow: options?.sessionContextWindow,
         modelRegistry: options?.modelRegistry,
+        sessionProvider: options?.sessionProvider,
     });
 }
 export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, level) {
@@ -1573,7 +1642,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const overridesSection = formatOverridesSection(activeOverrides);
     // Compute verification budget for the executor's context window (issue #707)
     const prefs = loadEffectiveGSDPreferences();
-    const contextWindow = resolveExecutorContextWindow(opts.modelRegistry, prefs?.preferences, opts.sessionContextWindow);
+    const contextWindow = resolveExecutorContextWindow(opts.modelRegistry, prefs?.preferences, opts.sessionContextWindow, opts.sessionProvider);
     const budgets = computeBudgets(contextWindow);
     const verificationBudget = `~${Math.round(budgets.verificationBudgetChars / 1000)}K chars`;
     // Truncate carry-forward section when it exceeds 40% of inline context budget.
@@ -2243,6 +2312,7 @@ export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, rea
             carryForwardPaths: depPaths,
             sessionContextWindow: opts?.sessionContextWindow,
             modelRegistry: opts?.modelRegistry,
+            sessionProvider: opts?.sessionProvider,
         });
         const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
         subagentSections.push([

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -25,10 +25,51 @@ import { execFileSync } from "node:child_process";
 import { dirname, join } from "node:path";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-artifact-paths.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
+import { validateArtifact } from "./schemas/validate.js";
+import { getProjectResearchStatus } from "./project-research-policy.js";
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
 export { classifyMilestoneSummaryContent, } from "./milestone-summary-classifier.js";
 // ─── Artifact Resolution & Verification ───────────────────────────────────────
+function hasCapturedWorkflowPrefs(base) {
+    const prefsPath = resolveExpectedArtifactPath("workflow-preferences", "WORKFLOW-PREFS", base);
+    if (!prefsPath || !existsSync(prefsPath))
+        return false;
+    const content = readFileSync(prefsPath, "utf-8");
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    return !!match && /^workflow_prefs_captured:\s*true\s*$/m.test(match[1]);
+}
+function hasValidResearchDecision(base) {
+    const decisionPath = resolveExpectedArtifactPath("research-decision", "RESEARCH-DECISION", base);
+    if (!decisionPath || !existsSync(decisionPath))
+        return false;
+    try {
+        const cfg = JSON.parse(readFileSync(decisionPath, "utf-8"));
+        return cfg.decision === "research" || cfg.decision === "skip";
+    }
+    catch {
+        return false;
+    }
+}
+function hasCompleteProjectResearch(base) {
+    return getProjectResearchStatus(base).complete;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasCheckedTaskCompletionOnDisk(base, mid, sid, tid) {
+    const tasksDir = resolveTasksDir(base, mid, sid);
+    if (!tasksDir)
+        return false;
+    if (!existsSync(join(tasksDir, `${tid}-SUMMARY.md`)))
+        return false;
+    const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
+    if (!planAbs || !existsSync(planAbs))
+        return false;
+    const planContent = readFileSync(planAbs, "utf-8");
+    const cbRe = new RegExp(`^\\s*-\\s+\\[[xX]\\]\\s+\\*\\*${escapeRegExp(tid)}:`, "m");
+    return cbRe.test(planContent);
+}
 /**
  * Check whether a milestone produced implementation artifacts (non-`.gsd/`
  * files) in git history. The primary signal is the branch diff against the
@@ -296,6 +337,23 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         const content = readFileSync(overridesPath, "utf-8");
         return !content.includes("**Scope:** active");
     }
+    if (unitType === "workflow-preferences") {
+        return hasCapturedWorkflowPrefs(base);
+    }
+    if (unitType === "discuss-project") {
+        const projectPath = resolveExpectedArtifactPath(unitType, unitId, base);
+        return !!projectPath && existsSync(projectPath) && validateArtifact(projectPath, "project").ok;
+    }
+    if (unitType === "discuss-requirements") {
+        const requirementsPath = resolveExpectedArtifactPath(unitType, unitId, base);
+        return !!requirementsPath && existsSync(requirementsPath) && validateArtifact(requirementsPath, "requirements").ok;
+    }
+    if (unitType === "research-decision") {
+        return hasValidResearchDecision(base);
+    }
+    if (unitType === "research-project") {
+        return hasCompleteProjectResearch(base);
+    }
     // Reactive-execute: verify that each dispatched task's summary exists.
     // The unitId encodes the batch: "{mid}/{sid}/reactive+T02,T03"
     if (unitType === "reactive-execute") {
@@ -453,32 +511,25 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         }
     }
     // execute-task: DB status is authoritative. Fall back to checked-checkbox
-    // detection when the DB is unavailable (unmigrated projects).
+    // detection when the DB is unavailable (unmigrated projects), or when the
+    // disk artifacts already reflect completion but the DB replay is one beat
+    // behind the completion write.
     if (unitType === "execute-task") {
         const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
         if (mid && sid && tid) {
             const dbTask = getTask(mid, sid, tid);
             if (dbTask) {
-                // DB available — trust it
-                if (dbTask.status !== "complete" && dbTask.status !== "done")
+                if (dbTask.status !== "complete" && dbTask.status !== "done" && !hasCheckedTaskCompletionOnDisk(base, mid, sid, tid)) {
                     return false;
+                }
             }
             else if (!isDbAvailable()) {
                 // LEGACY: Pre-migration fallback for projects without DB.
                 // Require a CHECKED checkbox — a bare heading or unchecked checkbox
                 // does not prove gsd_complete_task ran. Summary file on disk alone
                 // is not sufficient evidence (could be a rogue write) (#3607).
-                const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
-                if (planAbs && existsSync(planAbs)) {
-                    const planContent = readFileSync(planAbs, "utf-8");
-                    const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-                    const cbRe = new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m");
-                    if (!cbRe.test(planContent))
-                        return false;
-                }
-                else {
-                    return false; // no plan file → cannot verify
-                }
+                if (!hasCheckedTaskCompletionOnDisk(base, mid, sid, tid))
+                    return false;
             }
             else {
                 // DB available but task row not found — completion tool never ran (#3607)
@@ -599,6 +650,9 @@ export function writeBlockerPlaceholder(unitType, unitId, base, reason) {
     const dir = dirname(absPath);
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
+    const recoveryLine = unitType === "research-project"
+        ? "This placeholder was written by auto-mode so the project research gate can stop fail-closed."
+        : "This placeholder was written by auto-mode so the pipeline can advance.";
     const content = [
         `# BLOCKER — auto-mode recovery failed`,
         ``,
@@ -606,7 +660,7 @@ export function writeBlockerPlaceholder(unitType, unitId, base, reason) {
         ``,
         `**Reason**: ${reason}`,
         ``,
-        `This placeholder was written by auto-mode so the pipeline can advance.`,
+        recoveryLine,
         `Review and replace this file before relying on downstream artifacts.`,
     ].join("\n");
     writeFileSync(absPath, content, "utf-8");