gsd-pi 2.66.1-dev.3c26b49 → 2.66.1-dev.3cea7ac

package/dist/resources/extensions/ask-user-questions.js

@@ -58,6 +58,51 @@ export function questionSignature(questions) {
 export function resetAskUserQuestionsCache() {
     turnCache.clear();
 }
+/**
+ * Race a remote channel dispatch against the local TUI. The first to produce
+ * a valid (non-error, non-timeout) result wins. The loser is cancelled via
+ * the shared AbortController.
+ *
+ * If the local TUI responds first, the remote poll is aborted (the message
+ * stays in Discord/Slack but polling stops). If remote responds first, the
+ * local TUI prompt is cancelled.
+ *
+ * Returns null only when both sides fail or are cancelled.
+ */
+async function raceRemoteAndLocal(startRemote, startLocal, controller, questions) {
+    // Wrap local TUI result into the same shape as remote results
+    const localPromise = startLocal().then((result) => {
+        if (!result || Object.keys(result.answers).length === 0)
+            return null;
+        return {
+            content: [{ type: "text", text: formatForLLM(result) }],
+            details: { questions, response: result, cancelled: false },
+        };
+    }).catch(() => null);
+    const remotePromise = startRemote().then((result) => {
+        if (!result)
+            return null;
+        const details = result.details;
+        // Treat timeouts and errors as non-wins — let the local TUI win instead
+        if (details?.timed_out || details?.error)
+            return null;
+        return result;
+    }).catch(() => null);
+    // Race: first non-null result wins
+    const winner = await Promise.race([
+        localPromise.then((r) => r ? { source: "local", result: r } : null),
+        remotePromise.then((r) => r ? { source: "remote", result: r } : null),
+    ]);
+    if (winner) {
+        // Cancel the loser
+        controller.abort();
+        return winner.result;
+    }
+    // First to resolve was null — wait for the other
+    const [localResult, remoteResult] = await Promise.all([localPromise, remotePromise]);
+    controller.abort();
+    return localResult ?? remoteResult;
+}
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 const OTHER_OPTION_LABEL = "None of the above";
 function errorResult(message, questions = []) {
@@ -116,19 +161,42 @@ export default function AskUserQuestions(pi) {
                     return errorResult(`Error: ask_user_questions requires non-empty options for every question (question "${q.id}" has none)`, params.questions);
                 }
             }
-            // Try remote first if configured (works in both interactive and headless modes).
-            // tryRemoteQuestions returns null when no remote channel is configured, so
-            // this is a no-op when the user has not set up Slack/Discord/Telegram.
-            const { tryRemoteQuestions } = await import("./remote-questions/manager.js");
-            const remoteResult = await tryRemoteQuestions(params.questions, signal);
-            if (remoteResult) {
-                // Cache successful remote results to prevent duplicate Discord dispatches
-                const remoteDetails = remoteResult.details;
-                if (remoteDetails && !remoteDetails.timed_out && !remoteDetails.error) {
-                    turnCache.set(sig, remoteResult);
+            // ── Routing: race remote + local, remote-only, or local-only ────────
+            const { tryRemoteQuestions, isRemoteConfigured } = await import("./remote-questions/manager.js");
+            const hasRemote = isRemoteConfigured();
+            // Case 1: Both remote and local UI available — race them.
+            // The first response wins; the loser is cancelled via AbortController.
+            if (hasRemote && ctx.hasUI) {
+                const raceController = new AbortController();
+                // Merge the parent signal so external cancellation propagates.
+                const onParentAbort = () => raceController.abort();
+                signal?.addEventListener("abort", onParentAbort, { once: true });
+                const raceSignal = raceController.signal;
+                const raceResult = await raceRemoteAndLocal(() => tryRemoteQuestions(params.questions, raceSignal), () => showInterviewRound(params.questions, { signal: raceSignal }, ctx), raceController, params.questions);
+                signal?.removeEventListener("abort", onParentAbort);
+                if (raceResult) {
+                    const details = raceResult.details;
+                    if (details && !details.timed_out && !details.error && !details.cancelled) {
+                        turnCache.set(sig, raceResult);
+                    }
+                    return { ...raceResult, details: raceResult.details };
+                }
+                // Both sides failed/cancelled — fall through to error
+                return errorResult("ask_user_questions: no response received from local UI or remote channel", params.questions);
+            }
+            // Case 2: Remote configured but no local UI (headless) — remote only.
+            if (hasRemote && !ctx.hasUI) {
+                const remoteResult = await tryRemoteQuestions(params.questions, signal);
+                if (remoteResult) {
+                    const remoteDetails = remoteResult.details;
+                    if (remoteDetails && !remoteDetails.timed_out && !remoteDetails.error) {
+                        turnCache.set(sig, remoteResult);
+                    }
+                    return { ...remoteResult, details: remoteResult.details };
                 }
-                return { ...remoteResult, details: remoteResult.details };
+                return errorResult("Error: remote channel configured but returned no result", params.questions);
             }
+            // Case 3: No remote — local UI only.
             if (!ctx.hasUI) {
                 return errorResult("Error: UI not available (non-interactive mode)", params.questions);
             }

package/dist/resources/extensions/claude-code-cli/partial-builder.js

@@ -4,7 +4,7 @@
  * Translates the Claude Agent SDK's `BetaRawMessageStreamEvent` sequence
  * into GSD's `AssistantMessageEvent` deltas for incremental TUI rendering.
  */
-import { repairToolJson } from "@gsd/pi-ai";
+import { hasXmlParameterTags, repairToolJson } from "@gsd/pi-ai";
 // ---------------------------------------------------------------------------
 // Content-block mapping helpers
 // ---------------------------------------------------------------------------
@@ -207,14 +207,15 @@ export class PartialMessageBuilder {
                 }
                 if (block.type === "toolCall") {
                     const jsonStr = this.toolJsonAccum.get(streamIndex) ?? "{}";
+                    const jsonForParse = hasXmlParameterTags(jsonStr) ? repairToolJson(jsonStr) : jsonStr;
                     try {
-                        block.arguments = JSON.parse(jsonStr);
+                        block.arguments = JSON.parse(jsonForParse);
                     }
                     catch {
                         // JSON.parse failed — attempt repair for YAML-style bullet
                         // lists that LLMs copy from template formatting (#2660).
                         try {
-                            block.arguments = JSON.parse(repairToolJson(jsonStr));
+                            block.arguments = JSON.parse(repairToolJson(jsonForParse));
                         }
                         catch {
                             // Repair also failed — stream was truncated or garbage.

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

@@ -29,6 +29,15 @@ function createAssistantStream() {
 // Claude binary resolution
 // ---------------------------------------------------------------------------
 let cachedClaudePath = null;
+export function getClaudeLookupCommand(platform = process.platform) {
+    return platform === "win32" ? "where claude" : "which claude";
+}
+export function parseClaudeLookupOutput(output) {
+    return output
+        .toString()
+        .trim()
+        .split(/\r?\n/)[0] ?? "";
+}
 /**
  * Resolve the path to the system-installed `claude` binary.
  * The SDK defaults to a bundled cli.js which doesn't exist when
@@ -38,9 +47,7 @@ function getClaudePath() {
     if (cachedClaudePath)
         return cachedClaudePath;
     try {
-        cachedClaudePath = execSync("which claude", { timeout: 5_000, stdio: "pipe" })
-            .toString()
-            .trim();
+        cachedClaudePath = parseClaudeLookupOutput(execSync(getClaudeLookupCommand(), { timeout: 5_000, stdio: "pipe" }));
     }
     catch {
         cachedClaudePath = "claude"; // fall back to PATH resolution

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

@@ -150,7 +150,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 }
                 // Verification passed — mark step complete
                 debugLog("autoLoop", { phase: "custom-engine-reconcile", iteration, unitId: iterData.unitId });
-                await engine.reconcile(engineState, {
+                const reconcileResult = await engine.reconcile(engineState, {
                     unitType: iterData.unitType,
                     unitId: iterData.unitId,
                     startedAt: s.currentUnit?.startedAt ?? Date.now(),
@@ -161,6 +161,18 @@ export async function autoLoop(ctx, pi, s, deps) {
                 recentErrorMessages.length = 0;
                 deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
                 debugLog("autoLoop", { phase: "iteration-complete", iteration });
+                if (reconcileResult.outcome === "milestone-complete") {
+                    await deps.stopAuto(ctx, pi, "Workflow complete");
+                    break;
+                }
+                if (reconcileResult.outcome === "pause") {
+                    await deps.pauseAuto(ctx, pi);
+                    break;
+                }
+                if (reconcileResult.outcome === "stop") {
+                    await deps.stopAuto(ctx, pi, reconcileResult.reason ?? "Engine stopped");
+                    break;
+                }
                 continue;
             }
             if (!sidecarItem) {

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

@@ -338,7 +338,13 @@ export async function runPreDispatch(ic, loopState) {
         ctx.ui.notify(`Milestone ${mid} has no title in roadmap — using ID as fallback.`, "warning");
     }
     // Mid-merge safety check
-    if (deps.reconcileMergeState(s.basePath, ctx)) {
+    const mergeReconcileResult = deps.reconcileMergeState(s.basePath, ctx);
+    if (mergeReconcileResult === "blocked") {
+        await deps.pauseAuto(ctx, pi);
+        debugLog("autoLoop", { phase: "exit", reason: "merge-reconciliation-blocked" });
+        return { action: "break", reason: "merge-reconciliation-blocked" };
+    }
+    if (mergeReconcileResult === "reconciled") {
         deps.invalidateAllCaches();
         state = await deps.deriveState(s.basePath);
         mid = state.activeMilestone?.id;
@@ -948,13 +954,13 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             return { action: "break", reason: "provider-pause" };
         }
         // Session creation timeout (not a structural error): pause auto-mode
-        // and let the provider-error-resume timer handle recovery. This matches
-        // the provider-pause path — break out cleanly, don't hard-stop.
+        // and let the provider-error-resume timer handle recovery (#3767). This
+        // matches the provider-pause path — break out cleanly, don't hard-stop.
         // Structural errors (TypeError, is not a function) are NOT transient
         // and must hard-stop to avoid infinite retry loops.
         if (unitResult.errorContext?.isTransient &&
             unitResult.errorContext?.category === "timeout") {
-            ctx.ui.notify(`Session creation timed out for ${unitType} ${unitId}. Will retry.`, "warning");
+            ctx.ui.notify(`Session creation timed out for ${unitType} ${unitId}. Pausing auto-mode (recoverable).`, "warning");
             debugLog("autoLoop", { phase: "session-timeout-pause", unitType, unitId });
             await deps.pauseAuto(ctx, pi);
             return { action: "break", reason: "session-timeout" };

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

@@ -7,6 +7,10 @@ import { NEW_SESSION_TIMEOUT_MS } from "./session.js";
 import { _setCurrentResolve, _setSessionSwitchInFlight } from "./resolve.js";
 import { debugLog } from "../debug-logger.js";
 import { logWarning } from "../workflow-logger.js";
+import { resolveAutoSupervisorConfig } from "../preferences.js";
+// Tracks the latest session-switch attempt so a late timeout settlement from an
+// older runUnit() call cannot clear the guard for a newer one.
+let sessionSwitchGeneration = 0;
 /**
  * Execute a single unit: create a new session, send the prompt, and await
  * the agent_end promise. Returns a UnitResult describing what happened.
@@ -21,10 +25,13 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
     let sessionResult;
     let sessionTimeoutHandle;
+    const mySessionSwitchGeneration = ++sessionSwitchGeneration;
     _setSessionSwitchInFlight(true);
     try {
         const sessionPromise = s.cmdCtx.newSession().finally(() => {
-            _setSessionSwitchInFlight(false);
+            if (sessionSwitchGeneration === mySessionSwitchGeneration) {
+                _setSessionSwitchInFlight(false);
+            }
         });
         const timeoutPromise = new Promise((resolve) => {
             sessionTimeoutHandle = setTimeout(() => resolve({ cancelled: true }), NEW_SESSION_TIMEOUT_MS);
@@ -83,7 +90,8 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     // If supervision fails to resolve unitPromise within 30s, treat as cancelled.
     // Without this, a crashed agent that never emits agent_end hangs the loop (#3161).
     debugLog("runUnit", { phase: "awaiting-agent-end", unitType, unitId });
-    const UNIT_HARD_TIMEOUT_MS = 30_000;
+    const supervisor = resolveAutoSupervisorConfig();
+    const UNIT_HARD_TIMEOUT_MS = Math.max(30_000, ((supervisor.hard_timeout_minutes ?? 30) * 60 * 1000) + 30_000);
     let unitTimeoutHandle;
     const timeoutResult = new Promise((resolve) => {
         unitTimeoutHandle = setTimeout(() => {

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

@@ -19,7 +19,7 @@
 export const MAX_UNIT_DISPATCHES = 3;
 export const STUB_RECOVERY_THRESHOLD = 2;
 export const MAX_LIFETIME_DISPATCHES = 6;
-export const NEW_SESSION_TIMEOUT_MS = 30_000;
+export const NEW_SESSION_TIMEOUT_MS = 120_000;
 // ─── AutoSession ─────────────────────────────────────────────────────────────
 export class AutoSession {
     // ── Lifecycle ────────────────────────────────────────────────────────────

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

@@ -8,6 +8,7 @@
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
+import { getErrorMessage } from "./error-utils.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { formatShortcut } from "./files.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
@@ -17,7 +18,7 @@ import { makeUI } from "../shared/tui.js";
 import { GLYPH, INDENT } from "../shared/mod.js";
 import { computeProgressScore } from "./progress-score.js";
 import { getActiveWorktreeName } from "./worktree-command.js";
-import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
+import { getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, parsePreferencesMarkdown, } from "./preferences.js";
 import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.js";
 import { parseUnitId } from "./unit-id.js";
 import { formatRtkSavingsLabel, getRtkSessionSavings, } from "../shared/rtk-session-stats.js";
@@ -293,26 +294,68 @@ export const hideFooter = () => ({
 const WIDGET_MODES = ["full", "small", "min", "off"];
 let widgetMode = "full";
 let widgetModeInitialized = false;
+let widgetModePreferencePath = null;
+function safeReadTextFile(path) {
+    try {
+        if (!existsSync(path))
+            return null;
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function readWidgetModeFromFile(path) {
+    const raw = safeReadTextFile(path);
+    if (!raw)
+        return undefined;
+    const prefs = parsePreferencesMarkdown(raw);
+    const saved = prefs?.widget_mode;
+    if (saved && WIDGET_MODES.includes(saved)) {
+        return saved;
+    }
+    return undefined;
+}
+function resolveWidgetModePreferencePath(projectPath = getProjectGSDPreferencesPath(), globalPath = getGlobalGSDPreferencesPath()) {
+    if (readWidgetModeFromFile(projectPath)) {
+        return projectPath;
+    }
+    if (readWidgetModeFromFile(globalPath)) {
+        return globalPath;
+    }
+    if (safeReadTextFile(projectPath) !== null)
+        return projectPath;
+    if (safeReadTextFile(globalPath) !== null)
+        return globalPath;
+    return getGlobalGSDPreferencesPath();
+}
 /** Load widget mode from preferences (once). */
-function ensureWidgetModeLoaded() {
+function ensureWidgetModeLoaded(projectPath, globalPath) {
     if (widgetModeInitialized)
         return;
     widgetModeInitialized = true;
     try {
-        const loaded = loadEffectiveGSDPreferences();
-        const saved = loaded?.preferences?.widget_mode;
+        const resolvedProjectPath = projectPath ?? getProjectGSDPreferencesPath();
+        const resolvedGlobalPath = globalPath ?? getGlobalGSDPreferencesPath();
+        const saved = readWidgetModeFromFile(resolvedProjectPath) ?? readWidgetModeFromFile(resolvedGlobalPath);
         if (saved && WIDGET_MODES.includes(saved)) {
             widgetMode = saved;
         }
+        widgetModePreferencePath = resolveWidgetModePreferencePath(resolvedProjectPath, resolvedGlobalPath);
     }
     catch (err) { /* non-fatal — use default */
-        logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
+        logWarning("dashboard", `operation failed: ${getErrorMessage(err)}`);
+        widgetModePreferencePath = getGlobalGSDPreferencesPath();
     }
 }
-/** Persist widget mode to global preferences YAML. */
-function persistWidgetMode(mode) {
+/**
+ * Persist widget mode to the preference file that owns the effective value.
+ * Project-scoped widget_mode wins over global; if neither scope defines it,
+ * we prefer an existing project preferences file and otherwise fall back to
+ * the global preferences file.
+ */
+function persistWidgetMode(mode, prefsPath = widgetModePreferencePath ?? resolveWidgetModePreferencePath()) {
     try {
-        const prefsPath = getGlobalGSDPreferencesPath();
         let content = "";
         if (existsSync(prefsPath)) {
             content = readFileSync(prefsPath, "utf-8");
@@ -332,23 +375,30 @@ function persistWidgetMode(mode) {
     }
 }
 /** Cycle to the next widget mode. Returns the new mode. */
-export function cycleWidgetMode() {
-    ensureWidgetModeLoaded();
+export function cycleWidgetMode(projectPath, globalPath) {
+    ensureWidgetModeLoaded(projectPath, globalPath);
     const idx = WIDGET_MODES.indexOf(widgetMode);
     widgetMode = WIDGET_MODES[(idx + 1) % WIDGET_MODES.length];
-    persistWidgetMode(widgetMode);
+    persistWidgetMode(widgetMode, widgetModePreferencePath ?? resolveWidgetModePreferencePath(projectPath, globalPath));
     return widgetMode;
 }
 /** Set widget mode directly. */
-export function setWidgetMode(mode) {
+export function setWidgetMode(mode, projectPath, globalPath) {
+    ensureWidgetModeLoaded(projectPath, globalPath);
     widgetMode = mode;
-    persistWidgetMode(widgetMode);
+    persistWidgetMode(widgetMode, widgetModePreferencePath ?? resolveWidgetModePreferencePath(projectPath, globalPath));
 }
 /** Get current widget mode. */
-export function getWidgetMode() {
-    ensureWidgetModeLoaded();
+export function getWidgetMode(projectPath, globalPath) {
+    ensureWidgetModeLoaded(projectPath, globalPath);
     return widgetMode;
 }
+/** Test-only reset for widget mode caching. */
+export function _resetWidgetModeForTests() {
+    widgetMode = "full";
+    widgetModeInitialized = false;
+    widgetModePreferencePath = null;
+}
 export function updateProgressWidget(ctx, unitType, unitId, state, accessors, tierBadge) {
     if (!ctx.hasUI)
         return;

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

@@ -291,34 +291,8 @@ export const DISPATCH_RULES = [
         },
     },
     {
-        name: "planning (no research, not S01) → research-slice",
-        match: async ({ state, mid, midTitle, basePath, prefs }) => {
-            if (state.phase !== "planning")
-                return null;
-            // Phase skip: skip research when preference or profile says so
-            if (prefs?.phases?.skip_research || prefs?.phases?.skip_slice_research)
-                return null;
-            if (!state.activeSlice)
-                return missingSliceStop(mid, state.phase);
-            const sid = state.activeSlice.id;
-            const sTitle = state.activeSlice.title;
-            const researchFile = resolveSliceFile(basePath, mid, sid, "RESEARCH");
-            if (researchFile)
-                return null; // has research, fall through
-            // Skip slice research for S01 when milestone research already exists —
-            // the milestone research already covers the same ground for the first slice.
-            const milestoneResearchFile = resolveMilestoneFile(basePath, mid, "RESEARCH");
-            if (milestoneResearchFile && sid === "S01")
-                return null; // fall through to plan-slice
-            return {
-                action: "dispatch",
-                unitType: "research-slice",
-                unitId: `${mid}/${sid}`,
-                prompt: await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, basePath),
-            };
-        },
-    },
-    {
+        // Keep this rule before the single-slice research rule so the multi-slice
+        // path wins whenever 2+ slices are ready.
         name: "planning (multiple slices need research) → parallel-research-slices",
         match: async ({ state, mid, midTitle, basePath, prefs }) => {
             if (state.phase !== "planning")
@@ -360,6 +334,34 @@ export const DISPATCH_RULES = [
             };
         },
     },
+    {
+        name: "planning (no research, not S01) → research-slice",
+        match: async ({ state, mid, midTitle, basePath, prefs }) => {
+            if (state.phase !== "planning")
+                return null;
+            // Phase skip: skip research when preference or profile says so
+            if (prefs?.phases?.skip_research || prefs?.phases?.skip_slice_research)
+                return null;
+            if (!state.activeSlice)
+                return missingSliceStop(mid, state.phase);
+            const sid = state.activeSlice.id;
+            const sTitle = state.activeSlice.title;
+            const researchFile = resolveSliceFile(basePath, mid, sid, "RESEARCH");
+            if (researchFile)
+                return null; // has research, fall through
+            // Skip slice research for S01 when milestone research already exists —
+            // the milestone research already covers the same ground for the first slice.
+            const milestoneResearchFile = resolveMilestoneFile(basePath, mid, "RESEARCH");
+            if (milestoneResearchFile && sid === "S01")
+                return null; // fall through to plan-slice
+            return {
+                action: "dispatch",
+                unitType: "research-slice",
+                unitId: `${mid}/${sid}`,
+                prompt: await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+            };
+        },
+    },
     {
         name: "planning → plan-slice",
         match: async ({ state, mid, midTitle, basePath }) => {

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

@@ -1410,7 +1410,7 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
     catch (err) {
         logWarning("prompt", `buildValidateMilestonePrompt verification classes lookup failed: ${err instanceof Error ? err.message : String(err)}`);
     }
-    // Inline all slice summaries and UAT results
+    // Inline all slice summaries and assessment results
     let valSliceIds = [];
     try {
         const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
@@ -1436,11 +1436,11 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         const summaryPath = resolveSliceFile(base, mid, sid, "SUMMARY");
         const summaryRel = relSliceFile(base, mid, sid, "SUMMARY");
         inlined.push(await inlineFile(summaryPath, summaryRel, `${sid} Summary`));
-        const uatPath = resolveSliceFile(base, mid, sid, "UAT");
-        const uatRel = relSliceFile(base, mid, sid, "UAT");
-        const uatInline = await inlineFileOptional(uatPath, uatRel, `${sid} UAT Result`);
-        if (uatInline)
-            inlined.push(uatInline);
+        const assessmentPath = resolveSliceFile(base, mid, sid, "ASSESSMENT");
+        const assessmentRel = relSliceFile(base, mid, sid, "ASSESSMENT");
+        const assessmentInline = await inlineFileOptional(assessmentPath, assessmentRel, `${sid} Assessment`);
+        if (assessmentInline)
+            inlined.push(assessmentInline);
     }
     // Aggregate unresolved follow-ups and known limitations across slices
     const outstandingItems = [];

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

@@ -10,7 +10,7 @@ import { parseUnitId } from "./unit-id.js";
 import { appendEvent } from "./workflow-events.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -198,8 +198,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         if (gateIds.length === 0)
             return true;
         try {
-            const { getPendingGates: getPending } = require("./gsd-db.js");
-            const pending = getPending(mid, sid, "slice");
+            const pending = getPendingGates(mid, sid, "slice");
             const pendingIds = new Set(pending.map((g) => g.gate_id));
             // All dispatched gates must no longer be pending
             for (const gid of gateIds) {
@@ -454,9 +453,8 @@ function abortAndResetMerge(basePath, hasMergeHead, squashMsgPath) {
 /**
  * Detect leftover merge state from a prior session and reconcile it.
  * If MERGE_HEAD or SQUASH_MSG exists, check whether conflicts are resolved.
- * If resolved: finalize the commit. If still conflicted: abort and reset.
- *
- * Returns true if state was dirty and re-derivation is needed.
+ * If resolved: finalize the commit. If only .gsd conflicts remain: auto-resolve.
+ * If code conflicts remain: fail safe without modifying the worktree.
  */
 export function reconcileMergeState(basePath, ctx) {
     const mergeHeadPath = join(basePath, ".git", "MERGE_HEAD");
@@ -464,7 +462,7 @@ export function reconcileMergeState(basePath, ctx) {
     const hasMergeHead = existsSync(mergeHeadPath);
     const hasSquashMsg = existsSync(squashMsgPath);
     if (!hasMergeHead && !hasSquashMsg)
-        return false;
+        return "clean";
     const conflictedFiles = nativeConflictFiles(basePath);
     if (conflictedFiles.length === 0) {
         // All conflicts resolved — finalize the merge/squash commit
@@ -481,7 +479,7 @@ export function reconcileMergeState(basePath, ctx) {
         catch (err) {
             const errorMessage = getErrorMessage(err);
             ctx.ui.notify(`Failed to finalize leftover merge/squash commit: ${errorMessage}`, "error");
-            return false;
+            return "blocked";
         }
     }
     else {
@@ -515,12 +513,13 @@ export function reconcileMergeState(basePath, ctx) {
             }
         }
         else {
-            // Code conflicts present — abort and reset
-            abortAndResetMerge(basePath, hasMergeHead, squashMsgPath);
-            ctx.ui.notify("Detected leftover merge state with unresolved conflicts — cleaned up. Re-deriving state.", "warning");
+            // Code conflicts present — fail safe and preserve any manual resolution
+            // work instead of discarding it with merge --abort/reset --hard.
+            ctx.ui.notify("Detected leftover merge state with unresolved code conflicts. Auto-mode will pause without modifying the worktree so manual conflict resolution is preserved.", "error");
+            return "blocked";
         }
     }
-    return true;
+    return "reconciled";
 }
 // ─── Loop Remediation ─────────────────────────────────────────────────────────
 /**

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -5,6 +5,11 @@ import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { ensureDbOpen } from "./dynamic-tools.js";
 import { StringEnum } from "@gsd/pi-ai";
 import { logError } from "../workflow-logger.js";
+import { shouldBlockContextArtifactSave } from "./write-gate.js";
+const SUPPORTED_SUMMARY_ARTIFACT_TYPES = ["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT", "CONTEXT-DRAFT"];
+export function isSupportedSummaryArtifactType(artifactType) {
+    return SUPPORTED_SUMMARY_ARTIFACT_TYPES.includes(artifactType);
+}
 /**
  * Register an alias tool that shares the same execute function as its canonical counterpart.
  * The alias description and promptGuidelines direct the LLM to prefer the canonical name.
@@ -274,13 +279,19 @@ export function registerDbTools(pi) {
                 details: { operation: "save_summary", error: "db_unavailable" },
             };
         }
-        const validTypes = ["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT"];
-        if (!validTypes.includes(params.artifact_type)) {
+        if (!isSupportedSummaryArtifactType(params.artifact_type)) {
             return {
-                content: [{ type: "text", text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${validTypes.join(", ")}` }],
+                content: [{ type: "text", text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${SUPPORTED_SUMMARY_ARTIFACT_TYPES.join(", ")}` }],
                 details: { operation: "save_summary", error: "invalid_artifact_type" },
             };
         }
+        const contextGuard = shouldBlockContextArtifactSave(params.artifact_type, params.milestone_id ?? null, params.slice_id ?? null);
+        if (contextGuard.block) {
+            return {
+                content: [{ type: "text", text: `Error saving artifact: ${contextGuard.reason ?? "context write blocked"}` }],
+                details: { operation: "save_summary", error: "context_write_blocked" },
+            };
+        }
         try {
             let relativePath;
             if (params.task_id && params.slice_id) {
@@ -322,16 +333,17 @@ export function registerDbTools(pi) {
             "Computes the file path from milestone/slice/task IDs automatically.",
         promptSnippet: "Save a GSD artifact (summary/research/context/assessment) to DB and disk",
         promptGuidelines: [
-            "Use gsd_summary_save to persist structured artifacts (SUMMARY, RESEARCH, CONTEXT, ASSESSMENT).",
+            "Use gsd_summary_save to persist structured artifacts (SUMMARY, RESEARCH, CONTEXT, ASSESSMENT, CONTEXT-DRAFT).",
             "milestone_id is required. slice_id and task_id are optional — they determine the file path.",
             "The tool computes the relative path automatically: milestones/M001/M001-SUMMARY.md, milestones/M001/slices/S01/S01-SUMMARY.md, etc.",
-            "artifact_type must be one of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT.",
+            "artifact_type must be one of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT, CONTEXT-DRAFT.",
+            "Use CONTEXT-DRAFT for incremental draft persistence; use CONTEXT for the final milestone context after depth verification.",
         ],
         parameters: Type.Object({
             milestone_id: Type.String({ description: "Milestone ID (e.g. M001)" }),
             slice_id: Type.Optional(Type.String({ description: "Slice ID (e.g. S01)" })),
             task_id: Type.Optional(Type.String({ description: "Task ID (e.g. T01)" })),
-            artifact_type: Type.String({ description: "One of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT" }),
+            artifact_type: Type.String({ description: "One of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT, CONTEXT-DRAFT" }),
             content: Type.String({ description: "The full markdown content of the artifact" }),
         }),
         execute: summarySaveExecute,