gsd-pi 2.78.1-dev.0fdacd524 → 2.78.1-dev.42ef05fbe

package/README.md

@@ -318,7 +318,7 @@ Auto mode is a state machine driven by files on disk. It reads `.gsd/STATE.md`,
 
 2. **Context pre-loading** — The dispatch prompt includes inlined task plans, slice plans, prior task summaries, dependency summaries, roadmap excerpts, and decisions register. The LLM starts with everything it needs instead of spending tool calls reading files.
 
-3. **Git isolation** — When `git.isolation` is set to `worktree` or `branch`, each milestone runs on its own `milestone/<MID>` branch (in a worktree or in-place). All slice work commits sequentially — no branch switching, no merge conflicts. When the milestone completes, it's squash-merged to main as one clean commit. The default is `none` (work on the current branch), configurable via preferences.
+3. **Git isolation** — When `git.isolation` is set to `worktree` or `branch`, each milestone runs on its own `milestone/<MID>` branch (in a worktree or in-place). All slice work commits sequentially — no branch switching, no merge conflicts. When the milestone completes, it's squash-merged to main as one clean commit. The default is `none` (work on the current branch), configurable via preferences. If `worktree` is configured in a repo with no committed `HEAD`, GSD temporarily behaves as `none` until the first commit exists because git worktrees need a committed start point.
 
 4. **Crash recovery** — A lock file tracks the current unit. If the session dies, the next `/gsd auto` reads the surviving session file, synthesizes a recovery briefing from every tool call that made it to disk, and resumes with full context. Parallel orchestrator state is persisted to disk with PID liveness detection, so multi-worker sessions survive crashes too. In headless mode, crashes trigger automatic restart with exponential backoff (default 3 attempts).
 
@@ -450,6 +450,7 @@ On first run, GSD launches a branded setup wizard that walks you through LLM pro
 | `/gsd`                  | Step mode — executes one unit at a time, pauses between each                  |
 | `/gsd next`             | Explicit step mode (same as bare `/gsd`)                                      |
 | `/gsd auto`             | Autonomous mode — researches, plans, executes, commits, repeats               |
+| `/gsd new-project [--deep]` | Bootstrap a project with staged project-level discovery                  |
 | `/gsd quick`            | Execute a quick task with GSD guarantees, skip planning overhead              |
 | `/gsd stop`             | Stop auto mode gracefully                                                     |
 | `/gsd steer`            | Hard-steer plan documents during execution                                    |
@@ -499,9 +500,12 @@ Every dispatch is carefully constructed. The LLM never wastes tool calls on orie
 | Artifact           | Purpose                                                         |
 | ------------------ | --------------------------------------------------------------- |
 | `PROJECT.md`       | Living doc — what the project is right now                      |
+| `REQUIREMENTS.md`  | Project-level capability contract and out-of-scope list         |
 | `DECISIONS.md`     | Append-only register of architectural decisions                 |
 | `KNOWLEDGE.md`     | Cross-session rules, patterns, and lessons learned              |
 | `RUNTIME.md`       | Runtime context — API endpoints, env vars, services (v2.39)     |
+| `runtime/research-decision.json` | Deep-mode marker for project research vs skip       |
+| `research/*.md`    | Optional deep-mode project research: stack, features, architecture, pitfalls |
 | `STATE.md`         | Quick-glance dashboard — always read first                      |
 | `M001-ROADMAP.md`  | Milestone plan with slice checkboxes, risk levels, dependencies |
 | `M001-CONTEXT.md`  | User decisions from the discuss phase                           |
@@ -598,6 +602,7 @@ auto_report: true
 | Setting                           | What it controls                                                                                      |
 | --------------------------------- | ----------------------------------------------------------------------------------------------------- |
 | `models.*`                        | Per-phase model selection — string for a single model, or `{model, fallbacks}` for automatic failover |
+| `planning_depth`                  | `light` / `deep` — opt into staged project discovery before milestone planning                         |
 | `skill_discovery`                 | `auto` / `suggest` / `off` — how GSD finds and applies skills                                         |
 | `auto_supervisor.*`               | Timeout thresholds for auto mode supervision                                                          |
 | `budget_ceiling`                  | USD ceiling — auto mode pauses when reached                                                           |
@@ -606,7 +611,7 @@ auto_report: true
 | `skill_rules`                     | Situational rules for skill routing                                                                   |
 | `skill_staleness_days`            | Skills unused for N days get deprioritized (default: 60, 0 = disabled)                                |
 | `unique_milestone_ids`            | Uses unique milestone names to avoid clashes when working in teams of people                          |
-| `git.isolation`                   | `none` (default), `worktree`, or `branch` — enable worktree or branch isolation for milestone work    |
+| `git.isolation`                   | `none` (default), `worktree`, or `branch` — enable worktree or branch isolation for milestone work. `worktree` requires a committed `HEAD`; zero-commit repos temporarily run as `none`    |
 | `git.manage_gitignore`            | Set `false` to prevent GSD from modifying `.gitignore`                                                |
 | `verification_commands`           | Array of shell commands to run after task execution (e.g., `["npm run lint", "npm run test"]`)        |
 | `verification_auto_fix`           | Auto-retry on verification failures (default: true)                                                   |

package/dist/cli-auto-routing.d.ts

@@ -0,0 +1 @@
+export declare function shouldRedirectAutoToHeadless(subcommand: string | undefined, stdinIsTTY: boolean | undefined, stdoutIsTTY: boolean | undefined): boolean;

package/dist/cli-auto-routing.js

@@ -0,0 +1,5 @@
+export function shouldRedirectAutoToHeadless(subcommand, stdinIsTTY, stdoutIsTTY) {
+    if (subcommand !== 'auto')
+        return false;
+    return stdinIsTTY !== true || stdoutIsTTY !== true;
+}

package/dist/cli.js

@@ -9,6 +9,7 @@ import { shouldRunOnboarding, runOnboarding } from './onboarding.js';
 import chalk from 'chalk';
 import { checkForUpdates } from './update-check.js';
 import { shouldBypassManagedResourceMismatchGate } from './cli-policy.js';
+import { shouldRedirectAutoToHeadless } from './cli-auto-routing.js';
 import { printHelp, printSubcommandHelp } from './help-text.js';
 import { applySecurityOverrides } from './security-overrides.js';
 import { validateConfiguredModel } from './startup-model-validation.js';
@@ -409,10 +410,10 @@ function flushPendingProviderRegistrations(resourceLoader, modelRegistry) {
     }
     runtime.pendingProviderRegistrations = [];
 }
-// `gsd auto [args...]` — shorthand for `gsd headless auto [args...]` (#2732)
-// Without this, `gsd auto` falls through to the interactive TUI which hangs
-// when stdin/stdout are piped (non-TTY environments).
-if (cliFlags.messages[0] === 'auto') {
+// `gsd auto [args...]` with piped stdin/stdout — shorthand for
+// `gsd headless auto [args...]` (#2732). Keep terminal TTY launches in the
+// interactive path so Warp/iTerm/Terminal retain foreground ownership.
+if (shouldRedirectAutoToHeadless(cliFlags.messages[0], process.stdin.isTTY, process.stdout.isTTY)) {
     await runHeadlessFromAuto(buildHeadlessAutoArgs(cliFlags));
 }
 // ---------------------------------------------------------------------------
@@ -656,16 +657,6 @@ if (!cliFlags.worktree && !isPrintMode) {
 }
 markStartup('worktreeStatusBanner');
 // ---------------------------------------------------------------------------
-// Auto-redirect: `gsd auto` with piped stdout → headless mode (#2732)
-// When stdout is not a TTY (e.g. `gsd auto | cat`, `gsd auto > file`),
-// the TUI cannot render and the process hangs. Redirect to headless mode
-// which handles non-interactive output gracefully.
-// ---------------------------------------------------------------------------
-if (cliFlags.messages[0] === 'auto' && !process.stdout.isTTY) {
-    process.stderr.write('[gsd] stdout is not a terminal — running auto-mode in headless mode.\n');
-    await runHeadlessFromAuto(cliFlags.messages.slice(1));
-}
-// ---------------------------------------------------------------------------
 // Interactive mode — normal TTY session
 // ---------------------------------------------------------------------------
 await ensureRtkBootstrap();

package/dist/loader.js

@@ -113,9 +113,21 @@ const { Module } = await import('module');
 Module._initPaths?.();
 // GSD_VERSION — expose package version so extensions can display it
 process.env.GSD_VERSION = gsdVersion;
-// GSD_BIN_PATH — absolute path to this loader (dist/loader.js), used by patched subagent
-// to spawn gsd instead of pi when dispatching workflow tasks
-process.env.GSD_BIN_PATH = process.argv[1];
+// GSD_BIN_PATH — absolute path to the CLI entrypoint, used by patched
+// subagent/parallel workers to spawn gsd instead of pi when dispatching
+// workflow tasks. In source-dev mode this must remain scripts/dev-cli.js, not
+// src/loader.ts, because child processes need the --import resolve-ts wrapper.
+const invokedBinPath = process.argv[1];
+const sourceLoaderPath = join(gsdRoot, 'src', 'loader.ts');
+const devCliPath = process.env.GSD_DEV_CLI_PATH?.trim() || join(gsdRoot, 'scripts', 'dev-cli.js');
+const explicitCliPath = process.env.GSD_CLI_PATH?.trim() || process.env.GSD_BIN_PATH?.trim();
+const isSourceLoader = invokedBinPath && resolve(invokedBinPath) === sourceLoaderPath;
+const rawGsdBinPath = explicitCliPath || (isSourceLoader && existsSync(devCliPath) ? devCliPath : invokedBinPath);
+const resolvedGsdBinPath = rawGsdBinPath ? resolve(rawGsdBinPath) : undefined;
+process.env.GSD_BIN_PATH = resolvedGsdBinPath;
+if (!process.env.GSD_CLI_PATH) {
+    process.env.GSD_CLI_PATH = resolvedGsdBinPath;
+}
 // GSD_WORKFLOW_PATH — absolute path to bundled GSD-WORKFLOW.md, used by patched gsd extension
 // when dispatching workflow prompts. Prefers dist/resources/ (stable, set at build time)
 // over src/resources/ (live working tree) — see resource-loader.ts for rationale.

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-4ec0444c08b7f2ca
+583b74179690c579

package/dist/resources/extensions/async-jobs/job-manager.js

@@ -159,6 +159,10 @@ export class AsyncJobManager {
             this.evictionTimers.delete(id);
             this.jobs.delete(id);
         }, this.evictionMs);
+        // Eviction is housekeeping; it should not keep short-lived test/CLI
+        // processes alive after the real work has finished.
+        if (typeof timer === "object" && "unref" in timer)
+            timer.unref();
         this.evictionTimers.set(id, timer);
     }
     evictOldest() {

package/dist/resources/extensions/bg-shell/bg-shell-lifecycle.js

@@ -6,6 +6,7 @@ import { truncateToWidth, visibleWidth, } from "@gsd/pi-tui";
 import { processes, pendingAlerts, pushAlert, cleanupAll, cleanupSessionProcesses, persistManifest, loadManifest, pruneDeadProcesses, } from "./process-manager.js";
 import { formatUptime, getBgShellLiveCwd, resolveBgShellPersistenceCwd } from "./utilities.js";
 import { formatTokenCount } from "../shared/format-utils.js";
+import { homedir } from "node:os";
 export function registerBgShellLifecycle(pi, state) {
     function syncLatestCtxCwd() {
         if (!state.latestCtx)
@@ -177,8 +178,8 @@ export function registerBgShellLifecycle(pi, state) {
                 render(width) {
                     // ── Line 1: pwd (branch) [session]  ...  bg status ──
                     let pwd = getBgShellLiveCwd(state.latestCtx?.cwd);
-                    const home = process.env.HOME || process.env.USERPROFILE;
-                    if (home && pwd.startsWith(home)) {
+                    const home = homedir();
+                    if (pwd.startsWith(home)) {
                         pwd = `~${pwd.slice(home.length)}`;
                     }
                     const branch = footerData.getGitBranch();

package/dist/resources/extensions/bg-shell/utilities.js

@@ -32,6 +32,7 @@ export function restoreWindowsVTInput() {
 }
 // ── Time Formatting ────────────────────────────────────────────────────────
 import { formatDuration } from "../shared/mod.js";
+import { homedir } from "node:os";
 export const formatUptime = formatDuration;
 export function formatTimeAgo(timestamp) {
     return formatDuration(Date.now() - timestamp) + " ago";
@@ -48,7 +49,7 @@ export function getBgShellLiveCwd(cachedCwd, pathExists = existsSync, getCwd = (
     }
     catch {
         const projectRoot = deriveProjectRootFromAutoWorktree(cachedCwd);
-        const home = process.env.HOME || process.env.USERPROFILE;
+        const home = homedir();
         const fallbacks = [projectRoot, cachedCwd, home, "/"].filter((candidate) => Boolean(candidate));
         for (const candidate of fallbacks) {
             if (candidate !== "/" && !pathExists(candidate))

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -860,6 +860,21 @@ export function createClaudeCodeCanUseToolHandler(ui) {
                             }];
                     }
                 }
+                else if (!perms || (Array.isArray(perms) && perms.length === 0)) {
+                    // Non-Bash tool with no SDK-supplied suggestions. Without a
+                    // fallback rule the SDK would return `behavior: "allow"`
+                    // with no `updatedPermissions`, so "Always Allow" silently
+                    // fails to persist for tools whose input varies per call
+                    // (e.g. AskUserQuestion with different `questions` payloads).
+                    // A bare `{ toolName }` rule matches any input.
+                    perms = [{
+                            type: "addRules",
+                            rules: [{ toolName }],
+                            behavior: "allow",
+                            destination: "localSettings",
+                        }];
+                    notifyLabel = toolName;
+                }
                 // Notify with the resolved pattern (label already previewed it)
                 if (notifyLabel) {
                     ui.notify(`Saved: ${notifyLabel}`, "info");
@@ -1019,13 +1034,13 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
     const { reasoning, ...sdkExtraOptions } = extraOptions;
     const mcpServers = buildWorkflowMcpServers();
     const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
-    // Globally unblock all tools. Users reported that the `acceptEdits` default
-    // plus a narrow allowlist silently declined most Bash/Agent/WebFetch calls
-    // when `extensionUIContext` wasn't threaded through. Default to
-    // bypassPermissions and an empty disallow list so every tool — including
-    // `AskUserQuestion` and every `mcp__*` workflow tool — is auto-approved.
+    // Globally unblock the tools GSD expects Claude Code to run. When the
+    // workflow MCP server is available, prefer its `ask_user_questions` tool over
+    // Claude Code's native `AskUserQuestion`; the MCP path carries stable IDs and
+    // routes responses through the GSD elicitation bridge.
     // Opt back into gated mode with GSD_CLAUDE_CODE_PERMISSION_MODE=acceptEdits.
-    const disallowedTools = [];
+    const workflowMcpTools = mcpServers ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`) : [];
+    const disallowedTools = workflowMcpTools.length > 0 ? ["AskUserQuestion"] : [];
     const allowedTools = [
         "Read",
         "Write",
@@ -1036,8 +1051,7 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
         "Agent",
         "WebFetch",
         "WebSearch",
-        "AskUserQuestion",
-        ...(mcpServers ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`) : []),
+        ...(workflowMcpTools.length > 0 ? workflowMcpTools : ["AskUserQuestion"]),
     ];
     const supportsAdaptive = modelSupportsAdaptiveThinking(modelId);
     const effort = reasoning && supportsAdaptive

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,44 @@ 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);
+    if ((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 +472,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 +667,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 +687,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 +1077,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 +1255,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 +1394,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 +1500,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,7 +3,7 @@
 // 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, resolveMilestonePath, resolveSlicePath, relMilestoneFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, } from "./paths.js";
 import { parseUnitId } from "./unit-id.js";
 import { join } from "node:path";
 /**
@@ -12,6 +12,16 @@ import { join } from "node: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;
@@ -96,6 +106,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;
         }