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

package/dist/resources/extensions/github-sync/sync.js

@@ -140,8 +140,8 @@ async function syncMilestonePlan(basePath, mapping, config, mid) {
     });
 }
 async function syncSlicePlan(basePath, mapping, config, mid, sid) {
-    // Skip if already synced
-    if (getSliceRecord(mapping, mid, sid))
+    const existingSlice = getSliceRecord(mapping, mid, sid);
+    if (existingSlice)
         return;
     // Ensure milestone is synced first
     if (!getMilestoneRecord(mapping, mid)) {
@@ -157,7 +157,6 @@ async function syncSlicePlan(basePath, mapping, config, mid, sid) {
         return;
     const plan = parsePlan(content);
     const sliceBranch = `milestone/${mid}/${sid}`;
-    const milestoneBranch = `milestone/${mid}`;
     // Create task sub-issues first (so we can link them in the PR body)
     const taskIssueNumbers = [];
     if (plan.tasks) {
@@ -199,69 +198,80 @@ async function syncSlicePlan(basePath, mapping, config, mid, sid) {
             }
         }
     }
-    if (config.slice_prs === false) {
-        // Slice PRs disabled — just record without PR
-        setSliceRecord(mapping, mid, sid, {
-            issueNumber: 0,
-            prNumber: 0,
-            branch: sliceBranch,
-            lastSyncedAt: new Date().toISOString(),
-            state: "open",
-        });
-        return;
-    }
-    // Create slice branch from milestone branch
+    setSliceRecord(mapping, mid, sid, {
+        issueNumber: 0,
+        prNumber: 0,
+        branch: sliceBranch,
+        lastSyncedAt: new Date().toISOString(),
+        state: "open",
+    });
+    debugLog("github-sync", {
+        phase: "slice-synced",
+        mid,
+        sid,
+        pr: 0,
+        taskIssues: taskIssueNumbers.filter(t => t.issueNumber).length,
+    });
+}
+async function ensureSlicePullRequest(basePath, mapping, mid, sid) {
+    const sliceRecord = getSliceRecord(mapping, mid, sid);
+    if (!sliceRecord)
+        return null;
+    if (sliceRecord.prNumber)
+        return sliceRecord.prNumber;
+    const planPath = resolveSliceFile(basePath, mid, sid, "PLAN");
+    if (!planPath)
+        return null;
+    const content = await loadFile(planPath);
+    if (!content)
+        return null;
+    const plan = parsePlan(content);
+    const sliceBranch = sliceRecord.branch || `milestone/${mid}/${sid}`;
+    const milestoneBranch = `milestone/${mid}`;
     const branchResult = ghCreateBranch(basePath, sliceBranch, milestoneBranch);
     if (!branchResult.ok) {
         debugLog("github-sync", { phase: "create-slice-branch", error: branchResult.error });
-        // Branch might already exist — continue anyway
     }
-    // Push the slice branch
     const pushResult = ghPushBranch(basePath, sliceBranch);
     if (!pushResult.ok) {
         debugLog("github-sync", { phase: "push-slice-branch", error: pushResult.error });
+        return null;
     }
-    // Create draft PR
-    const prBody = formatSlicePRBody({
-        id: sid,
-        title: plan.title || sid,
-        goal: plan.goal,
-        mustHaves: plan.mustHaves,
-        demoCriterion: plan.demo,
-        tasks: taskIssueNumbers,
-    });
+    const tasks = (plan.tasks ?? []).map((task) => ({
+        id: task.id,
+        title: task.title,
+        issueNumber: getTaskRecord(mapping, mid, sid, task.id)?.issueNumber,
+    }));
     const prResult = ghCreatePR(basePath, {
         repo: mapping.repo,
         base: milestoneBranch,
         head: sliceBranch,
         title: `${sid}: ${plan.title || sid}`,
-        body: prBody,
+        body: formatSlicePRBody({
+            id: sid,
+            title: plan.title || sid,
+            goal: plan.goal,
+            mustHaves: plan.mustHaves,
+            demoCriterion: plan.demo,
+            tasks,
+        }),
         draft: true,
     });
-    const prNumber = prResult.ok ? prResult.data : 0;
     if (!prResult.ok) {
         debugLog("github-sync", { phase: "create-slice-pr", error: prResult.error });
+        return null;
     }
-    setSliceRecord(mapping, mid, sid, {
-        issueNumber: 0, // Slice doesn't get its own issue — tracked via PR
-        prNumber,
-        branch: sliceBranch,
-        lastSyncedAt: new Date().toISOString(),
-        state: "open",
-    });
-    debugLog("github-sync", {
-        phase: "slice-synced",
-        mid,
-        sid,
-        pr: prNumber,
-        taskIssues: taskIssueNumbers.filter(t => t.issueNumber).length,
-    });
+    sliceRecord.prNumber = prResult.data;
+    sliceRecord.lastSyncedAt = new Date().toISOString();
+    setSliceRecord(mapping, mid, sid, sliceRecord);
+    return sliceRecord.prNumber;
 }
 async function syncTaskComplete(basePath, mapping, config, mid, sid, tid) {
     const taskRecord = getTaskRecord(mapping, mid, sid, tid);
     if (!taskRecord || taskRecord.state === "closed")
         return;
     // Load task summary
+    let commentOk = true;
     const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
     if (summaryPath) {
         const content = await loadFile(summaryPath);
@@ -272,20 +282,37 @@ async function syncTaskComplete(basePath, mapping, config, mid, sid, tid) {
                 body: summary.whatHappened,
                 frontmatter: summary.frontmatter,
             });
-            ghAddComment(basePath, mapping.repo, taskRecord.issueNumber, comment);
+            const commentResult = ghAddComment(basePath, mapping.repo, taskRecord.issueNumber, comment);
+            commentOk = commentResult.ok;
+            if (!commentResult.ok) {
+                debugLog("github-sync", { phase: "task-comment-failed", mid, sid, tid, error: commentResult.error });
+            }
         }
     }
-    // Close the task issue
-    ghCloseIssue(basePath, mapping.repo, taskRecord.issueNumber);
-    taskRecord.state = "closed";
+    if (!commentOk)
+        return;
+    // Do not close the GitHub issue here. The task commit may still be local-only;
+    // closing before the commit/PR reaches GitHub breaks the remote audit trail.
+    // Commit trailers / PR merge should close linked issues once code is delivered.
+    taskRecord.state = "open";
     taskRecord.lastSyncedAt = new Date().toISOString();
     setTaskRecord(mapping, mid, sid, tid, taskRecord);
-    debugLog("github-sync", { phase: "task-closed", mid, sid, tid, issue: taskRecord.issueNumber });
+    debugLog("github-sync", { phase: "task-complete-commented", mid, sid, tid, issue: taskRecord.issueNumber });
 }
 async function syncSliceComplete(basePath, mapping, config, mid, sid) {
-    const sliceRecord = getSliceRecord(mapping, mid, sid);
+    let sliceRecord = getSliceRecord(mapping, mid, sid);
+    if (!sliceRecord) {
+        await syncSlicePlan(basePath, mapping, config, mid, sid);
+        sliceRecord = getSliceRecord(mapping, mid, sid);
+    }
     if (!sliceRecord || sliceRecord.state === "closed")
         return;
+    if (!sliceRecord.prNumber && config.slice_prs !== false) {
+        await ensureSlicePullRequest(basePath, mapping, mid, sid);
+        sliceRecord = getSliceRecord(mapping, mid, sid);
+        if (!sliceRecord || !sliceRecord.prNumber)
+            return;
+    }
     // Post slice summary as PR comment
     const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
     if (summaryPath && sliceRecord.prNumber) {
@@ -374,28 +401,29 @@ export async function bootstrapSync(basePath) {
     return counts;
 }
 // ─── Config Loading ─────────────────────────────────────────────────────────
-let _cachedConfig;
-function loadGitHubSyncConfig(_basePath) {
-    if (_cachedConfig !== undefined)
-        return _cachedConfig;
+const _cachedConfigByBasePath = new Map();
+function loadGitHubSyncConfig(basePath) {
+    if (_cachedConfigByBasePath.has(basePath))
+        return _cachedConfigByBasePath.get(basePath);
     try {
-        const prefs = loadEffectiveGSDPreferences();
+        const prefs = loadEffectiveGSDPreferences(basePath);
         const github = prefs?.preferences?.github;
         if (!github || typeof github !== "object") {
-            _cachedConfig = null;
+            _cachedConfigByBasePath.set(basePath, null);
             return null;
         }
-        _cachedConfig = github;
-        return _cachedConfig;
+        const config = github;
+        _cachedConfigByBasePath.set(basePath, config);
+        return config;
     }
     catch {
-        _cachedConfig = null;
+        _cachedConfigByBasePath.set(basePath, null);
         return null;
     }
 }
 /** Reset config cache (for testing). */
 export function _resetConfigCache() {
-    _cachedConfig = undefined;
+    _cachedConfigByBasePath.clear();
 }
 function resolveRepo(basePath) {
     const result = ghDetectRepo(basePath);

package/dist/resources/extensions/gsd/auto/phases.js

@@ -7,6 +7,7 @@
  * Imports from: auto/types, auto/detect-stuck, auto/run-unit, auto/loop-deps
  */
 import { importExtensionModule } from "@gsd/pi-coding-agent";
+import { USER_DRIVEN_DEEP_UNITS, isAwaitingUserInput, } from "../auto-post-unit.js";
 import { MAX_RECOVERY_CHARS, BUDGET_THRESHOLDS, MAX_FINALIZE_TIMEOUTS, } from "./types.js";
 import { detectStuck } from "./detect-stuck.js";
 import { runUnit } from "./run-unit.js";
@@ -28,7 +29,7 @@ import { withTimeout, FINALIZE_PRE_TIMEOUT_MS, FINALIZE_POST_TIMEOUT_MS } from "
 import { getEligibleSlices } from "../slice-parallel-eligibility.js";
 import { startSliceParallel } from "../slice-parallel-orchestrator.js";
 import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
-import { ensurePlanV2Graph, isMissingFinalizedContextResult } from "../uok/plan-v2.js";
+import { ensurePlanV2Graph, isEmptyPlanV2GraphResult, isMissingFinalizedContextResult } from "../uok/plan-v2.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { UokGateRunner } from "../uok/gate-runner.js";
 import { resetEvidence, loadEvidenceFromDisk } from "../safety/evidence-collector.js";
@@ -285,8 +286,48 @@ export async function runPreDispatch(ic, loopState) {
     }
     // Derive state
     let state = await deps.deriveState(s.basePath);
-    if (prefs?.uok?.plan_v2?.enabled && shouldRunPlanV2Gate(state.phase)) {
-        const compiled = ensurePlanV2Graph(s.basePath, state);
+    const { getDeepStageGate } = await import("../auto-dispatch.js");
+    const deepStageGate = getDeepStageGate(prefs, s.basePath);
+    const canRunDeepSetupGate = state.phase === "pre-planning" ||
+        state.phase === "needs-discussion" ||
+        state.phase === "planning";
+    if (canRunDeepSetupGate &&
+        (deepStageGate.status === "pending" || deepStageGate.status === "blocked")) {
+        debugLog("autoLoop", {
+            phase: "deep-project-stage-gate",
+            stage: deepStageGate.stage,
+            status: deepStageGate.status,
+            reason: deepStageGate.reason,
+        });
+        return {
+            action: "next",
+            data: {
+                state: {
+                    ...state,
+                    phase: "pre-planning",
+                    activeMilestone: null,
+                    activeSlice: null,
+                    activeTask: null,
+                    nextAction: deepStageGate.reason,
+                },
+                mid: "PROJECT",
+                midTitle: "Project setup",
+            },
+        };
+    }
+    if (uokFlags.planV2 && shouldRunPlanV2Gate(state.phase)) {
+        let compiled = ensurePlanV2Graph(s.basePath, state);
+        if (isEmptyPlanV2GraphResult(compiled)) {
+            deps.invalidateAllCaches();
+            state = await deps.deriveState(s.basePath);
+            compiled = shouldRunPlanV2Gate(state.phase)
+                ? ensurePlanV2Graph(s.basePath, state)
+                : {
+                    ok: true,
+                    reason: "empty plan-v2 graph recovered by state rederive",
+                    nodeCount: 0,
+                };
+        }
         if (!compiled.ok) {
             const reason = compiled.reason ?? "Plan v2 compilation failed";
             if (isMissingFinalizedContextResult(compiled)) {
@@ -435,7 +476,7 @@ export async function runPreDispatch(ic, loopState) {
         mid = state.activeMilestone?.id;
         midTitle = state.activeMilestone?.title;
         if (mid) {
-            if (deps.getIsolationMode() !== "none") {
+            if (deps.getIsolationMode(s.basePath) !== "none") {
                 deps.captureIntegrationBranch(s.basePath, mid);
             }
             deps.resolver.enterMilestone(mid, ctx.ui);
@@ -630,10 +671,16 @@ export async function runDispatch(ic, preData, loopState) {
         ? ctx.modelRegistry.getProviderAuthMode(provider)
         : undefined;
     const activeTools = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
-    const structuredQuestionsAvailable = supportsStructuredQuestions(activeTools, {
-        authMode,
-        baseUrl: ctx.model?.baseUrl,
-    }) ? "true" : "false";
+    // Deep planning intentionally keeps human checkpoints in plain chat. In
+    // Claude Code/local MCP transports, structured question requests can be
+    // cancelled outside the normal chat flow, which made approval gates easy to
+    // skip or bury under tool output.
+    const structuredQuestionsAvailable = prefs?.planning_depth === "deep"
+        ? "false"
+        : supportsStructuredQuestions(activeTools, {
+            authMode,
+            baseUrl: ctx.model?.baseUrl,
+        }) ? "true" : "false";
     debugLog("autoLoop", { phase: "dispatch-resolve", iteration: ic.iteration });
     const dispatchResult = await deps.resolveDispatch({
         basePath: s.basePath,
@@ -644,6 +691,7 @@ export async function runDispatch(ic, preData, loopState) {
         session: s,
         structuredQuestionsAvailable,
         sessionContextWindow: ctx.model?.contextWindow,
+        sessionProvider: ctx.model?.provider,
         modelRegistry: ctx.modelRegistry,
     });
     if (dispatchResult.action === "stop") {
@@ -1033,6 +1081,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
     s.lastGitActionFailure = null;
     s.lastGitActionStatus = null;
+    s.lastUnitAgentEndMessages = null;
     setCurrentPhase(unitType);
     s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
     const unitStartSeq = ic.nextSeq();
@@ -1210,6 +1259,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         unitId,
     });
     const unitResult = await runUnit(ctx, pi, s, unitType, unitId, finalPrompt);
+    s.lastUnitAgentEndMessages = unitResult.event?.messages ?? null;
     debugLog("autoLoop", {
         phase: "runUnit-end",
         iteration: ic.iteration,
@@ -1348,16 +1398,25 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         if (currentLedger?.units) {
             const lastUnit = [...currentLedger.units].reverse().find((u) => u.type === unitType && u.id === unitId && u.startedAt === s.currentUnit?.startedAt);
             if (lastUnit && lastUnit.toolCalls === 0) {
-                debugLog("runUnitPhase", {
-                    phase: "zero-tool-calls",
-                    unitType,
-                    unitId,
-                    warning: "Unit completed with 0 tool calls — likely context exhaustion, marking as failed",
-                });
-                ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — context exhaustion, will retry`, "warning");
-                // Fall through to next iteration where dispatch will re-derive
-                // and re-dispatch this unit.
-                return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt, requestDispatchedAt: unitResult.requestDispatchedAt } };
+                if (USER_DRIVEN_DEEP_UNITS.has(unitType) && isAwaitingUserInput(s.lastUnitAgentEndMessages ?? undefined)) {
+                    debugLog("runUnitPhase", {
+                        phase: "zero-tool-calls-awaiting-user-input",
+                        unitType,
+                        unitId,
+                    });
+                }
+                else {
+                    debugLog("runUnitPhase", {
+                        phase: "zero-tool-calls",
+                        unitType,
+                        unitId,
+                        warning: "Unit completed with 0 tool calls — likely context exhaustion, marking as failed",
+                    });
+                    ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — context exhaustion, will retry`, "warning");
+                    // Fall through to next iteration where dispatch will re-derive
+                    // and re-dispatch this unit.
+                    return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt, requestDispatchedAt: unitResult.requestDispatchedAt } };
+                }
             }
         }
     }
@@ -1445,9 +1504,9 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
     // Sidecar items use lightweight pre-verification opts
     const preVerificationOpts = sidecarItem
         ? sidecarItem.kind === "hook"
-            ? { skipSettleDelay: true, skipWorktreeSync: true }
-            : { skipSettleDelay: true }
-        : undefined;
+            ? { skipSettleDelay: true, skipWorktreeSync: true, agentEndMessages: s.lastUnitAgentEndMessages ?? undefined }
+            : { skipSettleDelay: true, agentEndMessages: s.lastUnitAgentEndMessages ?? undefined }
+        : { agentEndMessages: s.lastUnitAgentEndMessages ?? undefined };
     const preUnitSnapshot = s.currentUnit
         ? { type: s.currentUnit.type, id: s.currentUnit.id, startedAt: s.currentUnit.startedAt }
         : null;

package/dist/resources/extensions/gsd/auto/session.js

@@ -93,6 +93,8 @@ export class AutoSession {
     /** Set when a GSD tool execution ends with isError due to malformed/truncated
      *  JSON arguments. Checked by postUnitPreVerification to break retry loops. */
     lastToolInvocationError = null;
+    /** Agent-end messages from the just-finished unit, consumed during finalize. */
+    lastUnitAgentEndMessages = null;
     /** Set when turn-level git action fails during closeout. */
     lastGitActionFailure = null;
     /** Last turn-level git action status captured during finalize. */
@@ -219,6 +221,7 @@ export class AutoSession {
         this.consecutiveCompleteBootstraps = 0;
         this.lastPreExecFailure = null;
         this.lastToolInvocationError = null;
+        this.lastUnitAgentEndMessages = null;
         this.lastGitActionFailure = null;
         this.lastGitActionStatus = null;
         this.isolationDegraded = false;

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -3,30 +3,50 @@
 // resolveExpectedArtifactPath and diagnoseExpectedArtifact moved here from
 // auto-recovery.ts (Phase 5 dead-code cleanup). The artifact verification
 // function was removed entirely — callers now query WorkflowEngine directly.
-import { resolveMilestonePath, resolveSlicePath, relMilestoneFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, } from "./paths.js";
+import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, relMilestoneFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, } from "./paths.js";
 import { parseUnitId } from "./unit-id.js";
 import { join } from "node:path";
+function resolveMilestoneArtifactPath(base, mid, suffix) {
+    const existing = resolveMilestoneFile(base, mid, suffix);
+    if (existing)
+        return existing;
+    const dir = resolveMilestonePath(base, mid);
+    return dir ? join(dir, buildMilestoneFileName(mid, suffix)) : null;
+}
+function resolveSliceArtifactPath(base, mid, sid, suffix) {
+    const existing = resolveSliceFile(base, mid, sid, suffix);
+    if (existing)
+        return existing;
+    const dir = resolveSlicePath(base, mid, sid);
+    return dir ? join(dir, buildSliceFileName(sid, suffix)) : null;
+}
 /**
  * Resolve the expected artifact for a unit to an absolute path.
  */
 export function resolveExpectedArtifactPath(unitType, unitId, base) {
     const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     switch (unitType) {
+        case "workflow-preferences":
+            return join(gsdRoot(base), "PREFERENCES.md");
+        case "discuss-project":
+            return join(gsdRoot(base), "PROJECT.md");
+        case "discuss-requirements":
+            return join(gsdRoot(base), "REQUIREMENTS.md");
+        case "research-decision":
+            return join(gsdRoot(base), "runtime", "research-decision.json");
+        case "research-project":
+            return join(gsdRoot(base), "research", "PROJECT-RESEARCH-BLOCKER.md");
         case "discuss-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "CONTEXT")) : null;
+            return resolveMilestoneArtifactPath(base, mid, "CONTEXT");
         }
         case "discuss-slice": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "CONTEXT")) : null;
+            return resolveSliceArtifactPath(base, mid, sid, "CONTEXT");
         }
         case "research-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "RESEARCH")) : null;
+            return resolveMilestoneArtifactPath(base, mid, "RESEARCH");
         }
         case "plan-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "ROADMAP")) : null;
+            return resolveMilestoneArtifactPath(base, mid, "ROADMAP");
         }
         case "research-slice": {
             // #4414: Sentinel unitId "{mid}/parallel-research" fans out across
@@ -34,30 +54,22 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             // blocker escalation has somewhere to write. Verification for this
             // sentinel is handled directly in verifyExpectedArtifact.
             if (sid === "parallel-research") {
-                const mdir = resolveMilestonePath(base, mid);
-                return mdir
-                    ? join(mdir, buildMilestoneFileName(mid, "PARALLEL-BLOCKER"))
-                    : null;
+                return resolveMilestoneArtifactPath(base, mid, "PARALLEL-BLOCKER");
             }
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "RESEARCH")) : null;
+            return resolveSliceArtifactPath(base, mid, sid, "RESEARCH");
         }
         case "plan-slice": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "PLAN")) : null;
+            return resolveSliceArtifactPath(base, mid, sid, "PLAN");
         }
         case "refine-slice": {
             // ADR-011: refine-slice expands a sketch and writes the same PLAN.md as plan-slice.
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "PLAN")) : null;
+            return resolveSliceArtifactPath(base, mid, sid, "PLAN");
         }
         case "reassess-roadmap": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "ASSESSMENT")) : null;
+            return resolveSliceArtifactPath(base, mid, sid, "ASSESSMENT");
         }
         case "run-uat": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "ASSESSMENT")) : null;
+            return resolveSliceArtifactPath(base, mid, sid, "ASSESSMENT");
         }
         case "execute-task": {
             const dir = resolveSlicePath(base, mid, sid);
@@ -66,20 +78,16 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
                 : null;
         }
         case "complete-slice": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "SUMMARY")) : null;
+            return resolveSliceArtifactPath(base, mid, sid, "SUMMARY");
         }
         case "validate-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "VALIDATION")) : null;
+            return resolveMilestoneArtifactPath(base, mid, "VALIDATION");
         }
         case "complete-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "SUMMARY")) : null;
+            return resolveMilestoneArtifactPath(base, mid, "SUMMARY");
         }
         case "replan-slice": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "REPLAN")) : null;
+            return resolveSliceArtifactPath(base, mid, sid, "REPLAN");
         }
         case "rewrite-docs":
             return null;
@@ -96,6 +104,16 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
 export function diagnoseExpectedArtifact(unitType, unitId, base) {
     const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     switch (unitType) {
+        case "workflow-preferences":
+            return ".gsd/PREFERENCES.md with workflow_prefs_captured: true";
+        case "discuss-project":
+            return ".gsd/PROJECT.md (valid project context)";
+        case "discuss-requirements":
+            return ".gsd/REQUIREMENTS.md (valid requirements registry)";
+        case "research-decision":
+            return ".gsd/runtime/research-decision.json with decision research|skip";
+        case "research-project":
+            return ".gsd/research/{STACK,FEATURES,ARCHITECTURE,PITFALLS}.md with at least one real research file; blocker-only outputs stop";
         case "discuss-milestone":
             return `${relMilestoneFile(base, mid, "CONTEXT")} (milestone context from discussion)`;
         case "discuss-slice":

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

@@ -10,7 +10,6 @@ import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { getErrorMessage } from "./error-utils.js";
 import { nativeIsRepo } from "./native-git-bridge.js";
-import { getHomeDir } from "./home-dir.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
@@ -25,6 +24,7 @@ import { parseUnitId } from "./unit-id.js";
 import { formatRtkSavingsLabel, getRtkSessionSavings, } from "../shared/rtk-session-stats.js";
 import { logWarning } from "./workflow-logger.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
+import { homedir } from "node:os";
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 /**
  * Extract the target slice ID from a run-uat unit ID (e.g. "M001/S01" → "S01").
@@ -262,6 +262,17 @@ function refreshLastCommit(basePath) {
             cachedLastCommit = null;
             return;
         }
+        try {
+            execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+                cwd: basePath,
+                stdio: ["pipe", "pipe", "pipe"],
+                timeout: 3000,
+            });
+        }
+        catch {
+            cachedLastCommit = null;
+            return;
+        }
         const raw = execFileSync("git", ["log", "-1", "--format=%cr|%s"], {
             cwd: basePath,
             encoding: "utf-8",
@@ -462,7 +473,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
     let widgetPwd;
     {
         let fullPwd = process.cwd();
-        const widgetHome = getHomeDir();
+        const widgetHome = homedir();
         if (widgetHome && (fullPwd === widgetHome || fullPwd.startsWith(widgetHome + "/") || fullPwd.startsWith(widgetHome + "\\"))) {
             fullPwd = `~${fullPwd.slice(widgetHome.length)}`;
         }

package/dist/resources/extensions/gsd/auto-direct-dispatch.js

@@ -79,6 +79,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, dispatchBase, undefined, {
                     sessionContextWindow: ctx.model?.contextWindow,
                     modelRegistry: ctx.modelRegistry,
+                    sessionProvider: ctx.model?.provider,
                 });
             }
             else {
@@ -107,6 +108,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, dispatchBase, {
                 sessionContextWindow: ctx.model?.contextWindow,
                 modelRegistry: ctx.modelRegistry,
+                sessionProvider: ctx.model?.provider,
             });
             break;
         }