gsd-pi 2.82.0-dev.2841a1e44 → 2.82.0-dev.3a3c6509d

package/README.md

@@ -376,7 +376,7 @@ The database is authoritative for milestones, slices, tasks, requirements, summa
 
 10. **Adaptive replanning** — After each slice completes, the roadmap is reassessed. If the work revealed new information that changes the plan, slices are reordered, added, or removed before continuing.
 
-11. **Verification enforcement** — Configure shell commands (`npm run lint`, `npm run test`, etc.) that run automatically after task execution. Failures trigger auto-fix retries before advancing. Execute-task commits and snapshots are deferred until verification passes; failed or incomplete verification blocks closeout instead of publishing changes. Auto-discovered checks from `package.json` run in advisory mode — they log warnings but don't block on pre-existing errors. Configurable via `verification_commands`, `verification_auto_fix`, and `verification_max_retries` preferences.
+11. **Verification enforcement** — Configure simple executable commands (`npm run lint`, `npm run test`, etc.) that run automatically after task execution. Verification commands must not use shell composition or control syntax such as pipes, redirects, semicolons, backticks, or command substitution. Failures trigger auto-fix retries before advancing. Execute-task commits and snapshots are deferred until verification passes; failed or incomplete verification blocks closeout instead of publishing changes. Auto-discovered checks from `package.json` and Python pytest project markers (`python-project`) run in advisory mode — they log warnings but don't block on pre-existing errors. Configurable via `verification_commands`, `verification_auto_fix`, and `verification_max_retries` preferences.
 
 12. **Milestone validation** — After all slices complete, a `validate-milestone` gate compares roadmap success criteria against actual results before sealing the milestone.
 
@@ -503,7 +503,7 @@ On first run, GSD launches a branded setup wizard that walks you through LLM pro
 | `/gsd mcp`              | MCP server status and connectivity                                            |
 | `/gsd status`           | Progress dashboard                                                            |
 | `/gsd brief <mode>`     | Generate a visual HTML brief (diagram, plan, diff, recap, table, slides)      |
-| `/gsd queue`            | Queue future milestones (safe during auto mode)                               |
+| `/gsd queue`            | Queue/reorder future milestones (`pending`, `queued`, or legacy `planned`; safe during auto mode) |
 | `/gsd prefs`            | Model selection, timeouts, budget ceiling                                     |
 | `/gsd migrate`          | Migrate a v1 `.planning` directory to `.gsd` format                           |
 | `/gsd help`             | Categorized command reference for all GSD subcommands                         |
@@ -670,7 +670,7 @@ auto_report: true
 | `context_mode.exec_stdout_cap_bytes` | Persisted stdout cap for `gsd_exec` output (default: 1048576)                                      |
 | `context_mode.exec_digest_chars`  | Trailing stdout characters returned to the agent context (default: 300)                              |
 | `context_mode.exec_env_allowlist` | Environment variables forwarded to sandboxed `gsd_exec` runs in addition to `PATH` and `HOME`        |
-| `verification_commands`           | Array of shell commands to run after task execution (e.g., `["npm run lint", "npm run test"]`)        |
+| `verification_commands`           | Array of simple executable commands to run after task execution (e.g., `["npm run lint", "npm run test"]`); avoid pipes, redirects, semicolons, backticks, and command substitution |
 | `verification_auto_fix`           | Auto-retry on verification failures (default: true)                                                   |
 | `verification_max_retries`        | Max retries for verification failures (default: 2)                                                    |
 | `phases.require_slice_discussion` | Pause auto-mode before each slice for human discussion review                                         |

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

@@ -1 +1 @@
-0829fe9060dc3f75
+b9c1b29c0681f84f

package/dist/resources/GSD-WORKFLOW.md

@@ -448,6 +448,13 @@ What differed from the plan and why (or "None").
 
 The one-liner must be substantive: "JWT auth with refresh rotation using jose" not "Authentication implemented."
 
+When `key_files` or `key_decisions` are empty, render them as empty YAML lists:
+
+```yaml
+key_files: []
+key_decisions: []
+```
+
 **Slice summary:** Written when all tasks in a slice complete. Compresses all task summaries. Includes `drill_down_paths` to each task summary. During slice completion, review task summaries for `key_decisions` and ensure any significant ones are captured in `.gsd/DECISIONS.md`.
 
 **Milestone summary:** Updated each time a slice completes. Compresses all slice summaries. This is what gets injected into later slice planning instead of loading many individual summaries.

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

@@ -105,9 +105,10 @@ export function mapUsage(sdkUsage, totalCostUsd) {
         output: sdkUsage.output_tokens,
         cacheRead: sdkUsage.cache_read_input_tokens,
         cacheWrite: sdkUsage.cache_creation_input_tokens,
+        // Claude Agent SDK result usage is cumulative across its internal loop;
+        // repeated cache reads do not represent additional live context.
         totalTokens: sdkUsage.input_tokens +
             sdkUsage.output_tokens +
-            sdkUsage.cache_read_input_tokens +
             sdkUsage.cache_creation_input_tokens,
         cost: {
             input: 0,

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

@@ -269,7 +269,7 @@ function makeErrorMessage(model, errorMsg) {
 export function isClaudeCodeAbortErrorMessage(message) {
     if (!message)
         return false;
-    return /\b(?:claude code process aborted by user|request aborted by user|process aborted by user)\b/i.test(message);
+    return /\b(?:claude code process aborted by user|request aborted by user|process aborted by user|aborterror)\b/i.test(message);
 }
 function isBareClaudeCodeAbortErrorMessage(message) {
     if (!message)

package/dist/resources/extensions/gsd/auto/infra-errors.js

@@ -6,9 +6,14 @@
  * failures that merit retry.
  */
 /**
- * Error codes indicating infrastructure failures that cannot be recovered by
- * retrying. Each retry re-dispatches the unit at full LLM cost, so we bail
- * immediately rather than burning budget on guaranteed failures.
+ * Error codes indicating infrastructure-level failures from the OS,
+ * filesystem, or network. This set includes permanent resource failures
+ * (ENOSPC, ENOMEM, EROFS), transient resource exhaustion (EAGAIN, ENOBUFS),
+ * and network/offline errors (ECONNREFUSED, ENOTFOUND, ENETUNREACH).
+ *
+ * Transient git failures are retried separately through
+ * TRANSIENT_GIT_RETRY_CODES in native-git-bridge.ts before escalating to the
+ * auto-loop.
  */
 export const INFRA_ERROR_CODES = new Set([
     "ENOSPC", // disk full
@@ -18,6 +23,7 @@ export const INFRA_ERROR_CODES = new Set([
     "EMFILE", // too many open files (process)
     "ENFILE", // too many open files (system)
     "EAGAIN", // resource temporarily unavailable (resource exhaustion)
+    "ENOBUFS", // no buffer space available (transient pipe exhaustion)
     "ECONNREFUSED", // connection refused (offline / local server down)
     "ENOTFOUND", // DNS lookup failed (offline / no network)
     "ENETUNREACH", // network unreachable (offline / no route)

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

@@ -35,7 +35,7 @@ import { createWorkflowTurnReporter } from "./workflow-turn-reporter.js";
 import { validateWorkflowSessionLock } from "./workflow-session-lock.js";
 import { dequeueSidecarItem } from "./workflow-sidecar-queue.js";
 import { maintainWorkerHeartbeat } from "./workflow-worker-heartbeat.js";
-import { measureMemoryPressure } from "./workflow-memory-pressure.js";
+import { measureMemoryPressure, shouldCheckMemoryPressure, } from "./workflow-memory-pressure.js";
 import { buildSidecarIterationData } from "./workflow-sidecar-iteration.js";
 import { createExecutionGraphUnitDispatchDeps, runUnitPhaseViaContract, } from "./workflow-unit-dispatch.js";
 import { handleCustomEngineDispatchOutcome } from "./workflow-custom-engine-dispatch-outcome.js";
@@ -130,9 +130,9 @@ function logCustomVerifyRetrySaveFailure(err) {
     });
 }
 // ── Memory pressure monitoring (#3331) ──────────────────────────────────
-// Check heap usage every N iterations and trigger graceful shutdown before
-// the OS OOM killer sends SIGKILL. The threshold is 90% of the V8 heap
-// limit (--max-old-space-size or default ~1.5-4GB depending on platform).
+// Check heap usage on session startup, then every N iterations, and trigger
+// graceful shutdown before the OS OOM killer sends SIGKILL. The threshold is
+// 90% of the V8 heap limit (--max-old-space-size or default ~1.5-4GB depending on platform).
 const MEMORY_CHECK_INTERVAL = 5; // check every 5 iterations
 const MAX_CUSTOM_ENGINE_VERIFY_RETRIES = 3;
 async function enforceMinRequestInterval(s, prefs) {
@@ -262,7 +262,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
         }
         // ── Memory pressure check (#3331) ──
         // Graceful shutdown before OOM killer sends SIGKILL.
-        if (iteration % MEMORY_CHECK_INTERVAL === 0) {
+        if (shouldCheckMemoryPressure(iteration, MEMORY_CHECK_INTERVAL)) {
             const mem = measureMemoryPressure();
             debugLog("autoLoop", { phase: "memory-check", ...mem });
             const memoryDecision = decideMemoryPressure({ ...mem, iteration });

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

@@ -117,6 +117,17 @@ export class AutoOrchestrator {
                 await this.deps.health.postAdvanceRecord(stopped);
                 return stopped;
             }
+            if (!("unitType" in decision)) {
+                const blocked = {
+                    kind: "blocked",
+                    reason: decision.reason,
+                    action: decision.action,
+                    stateSnapshot: reconciliation.stateSnapshot,
+                };
+                await this.deps.runtime.journalTransition({ name: "advance-blocked", reason: blocked.reason });
+                await this.deps.health.postAdvanceRecord(blocked);
+                return blocked;
+            }
             const nextKey = `${decision.unitType}:${decision.unitId}`;
             // Record every dispatch decision in the ring buffer before pre-flight
             // checks so the stuck-loop detector observes the full decision history

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

@@ -44,6 +44,7 @@ import { resolveManifest } from "../unit-context-manifest.js";
 import { createWorktreeSafetyModule } from "../worktree-safety.js";
 import { isSuspiciousGhostCompletion } from "../auto-unit-closeout.js";
 import { decideVerificationRetry, verificationRetryKey } from "./verification-retry-policy.js";
+import { buildPhaseHandoffOutcome, setAutoOutcomeWidget } from "../auto-dashboard.js";
 // ─── Path Comparison Helper ───────────────────────────────────────────────
 /** Compare two paths for physical identity, tolerating trailing slashes and symlinks. */
 function isSamePathLocal(a, b) {
@@ -103,6 +104,12 @@ function unitWritesSource(unitType) {
 function formatWorktreeSafetyFailure(result) {
     return `Worktree Safety failed (${result.kind}): ${result.reason} ${result.remediation}`;
 }
+function formatWorktreeSafetyStopReason(result) {
+    if (result.kind === "empty-worktree-with-project-content") {
+        return `Worktree Safety failed (${result.kind}). Run /gsd doctor fix, then /gsd auto.`;
+    }
+    return `Worktree Safety failed (${result.kind}).`;
+}
 function resolveEmptyWorktreeWithProjectContent(unitRoot, projectRoot) {
     if (isSamePathLocal(unitRoot, projectRoot))
         return false;
@@ -176,7 +183,7 @@ async function validateSourceWriteWorktreeSafety(ic, unitType, unitId, milestone
         projectRoot,
     });
     ctx.ui.notify(msg, "error");
-    await deps.stopAuto(ctx, pi, msg);
+    await deps.stopAuto(ctx, pi, formatWorktreeSafetyStopReason(result));
     return { action: "break", reason: result.kind };
 }
 // ─── Session timeout auto-resume state ────────────────────────────────────────
@@ -968,7 +975,14 @@ export async function runDispatch(ic, preData, loopState) {
         prompt = preDispatchResult.prompt;
     }
     const guardBasePath = _resolveDispatchGuardBasePath(s);
-    const priorSliceBlocker = deps.getPriorSliceCompletionBlocker(guardBasePath, deps.getMainBranch(guardBasePath), unitType, unitId);
+    let mainBranch = "main";
+    try {
+        mainBranch = deps.getMainBranch(guardBasePath);
+    }
+    catch (err) {
+        debugLog("autoLoop", { phase: "getMainBranch-failed", error: String(err) });
+    }
+    const priorSliceBlocker = deps.getPriorSliceCompletionBlocker(guardBasePath, mainBranch, unitType, unitId);
     if (priorSliceBlocker) {
         await deps.stopAuto(ctx, pi, priorSliceBlocker);
         debugLog("autoLoop", { phase: "exit", reason: "prior-slice-blocker" });
@@ -1324,35 +1338,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.currentUnit.type === unitType &&
         s.currentUnit.id === unitId);
     const previousTier = s.currentUnitRouting?.tier;
-    // Scope workflow-logger buffer to this unit so post-finalize drains are
-    // per-unit. Without this, the module-level _buffer accumulates across every
-    // unit in the same Node process (see workflow-logger.ts module header).
-    _resetLogs();
     const dispatchKey = `${unitType}/${unitId}`;
-    s.unitDispatchCount.set(dispatchKey, (s.unitDispatchCount.get(dispatchKey) ?? 0) + 1);
-    s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
-    s.lastGitActionFailure = null;
-    s.lastGitActionStatus = null;
-    s.lastUnitAgentEndMessages = null;
-    setCurrentPhase(unitType, {
-        basePath: s.basePath,
-        traceId: ic.flowId,
-        turnId: `iter-${ic.iteration}`,
-        causedBy: "unit-start",
-    });
-    s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
-    const unitStartSeq = ic.nextSeq();
-    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: unitStartSeq, eventType: "unit-start", data: { unitType, unitId } });
-    deps.captureAvailableSkills();
-    writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
-        phase: "dispatched",
-        wrapupWarningSent: false,
-        timeoutAt: null,
-        lastProgressAt: s.currentUnit.startedAt,
-        progressCount: 0,
-        lastProgressKind: "dispatch",
-        recoveryAttempts: 0, // Reset so re-dispatched units get full recovery budget (#2322)
-    });
+    const nextDispatchCount = (s.unitDispatchCount.get(dispatchKey) ?? 0) + 1;
     // Status bar (widget + preconditions deferred until after model selection — see #2899)
     ctx.ui.setStatus("gsd-auto", "auto");
     if (mid)
@@ -1406,7 +1393,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         finalPrompt = `${capped}\n\n---\n\n${finalPrompt}`;
         s.pendingCrashRecovery = null;
     }
-    else if ((s.unitDispatchCount.get(dispatchKey) ?? 0) > 1) {
+    else if (nextDispatchCount > 1) {
         const diagnostic = deps.getDeepDiagnostic(s.basePath);
         if (diagnostic) {
             const cappedDiag = diagnostic.length > MAX_RECOVERY_CHARS
@@ -1445,6 +1432,11 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         logWarning("engine", "Prompt reorder failed", { error: msg });
     }
     // Select and apply model (with tier escalation on retry — normal units only)
+    const prevUnitRouting = s.currentUnitRouting;
+    const prevUnitModel = s.currentUnitModel;
+    const prevDispatchedModelId = s.currentDispatchedModelId;
+    const prevSessionModel = ctx.model;
+    const prevSessionThinkingLevel = pi.getThinkingLevel();
     const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier }, undefined, s.manualSessionModelOverride, s.autoModeStartThinkingLevel);
     s.currentUnitRouting =
         modelResult.routing;
@@ -1488,12 +1480,58 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                 ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
                 : undefined,
         baseUrl: s.currentUnitModel?.baseUrl ?? ctx.model?.baseUrl,
+        activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
     });
     if (compatibilityError) {
+        s.currentUnitRouting = prevUnitRouting;
+        s.currentUnitModel = prevUnitModel;
+        s.currentDispatchedModelId = prevDispatchedModelId;
+        if (s.checkpointSha) {
+            cleanupCheckpoint(s.basePath, unitId);
+            s.checkpointSha = null;
+        }
+        if (prevSessionModel) {
+            const ok = await pi.setModel(prevSessionModel, { persist: false });
+            if (!ok) {
+                ctx.ui.notify("Failed to restore previous session model after compatibility check failure.", "warning");
+            }
+            if (prevSessionThinkingLevel) {
+                pi.setThinkingLevel(prevSessionThinkingLevel);
+            }
+        }
         ctx.ui.notify(compatibilityError, "error");
         await deps.stopAuto(ctx, pi, compatibilityError);
         return { action: "break", reason: "workflow-capability" };
     }
+    // Scope workflow-logger buffer to this unit so post-finalize drains are
+    // per-unit. Without this, the module-level _buffer accumulates across every
+    // unit in the same Node process (see workflow-logger.ts module header).
+    _resetLogs();
+    const unitStartedAt = Date.now();
+    s.unitDispatchCount.set(dispatchKey, nextDispatchCount);
+    s.currentUnit = { type: unitType, id: unitId, startedAt: unitStartedAt };
+    s.lastGitActionFailure = null;
+    s.lastGitActionStatus = null;
+    s.lastUnitAgentEndMessages = null;
+    setCurrentPhase(unitType, {
+        basePath: s.basePath,
+        traceId: ic.flowId,
+        turnId: `iter-${ic.iteration}`,
+        causedBy: "unit-start",
+    });
+    s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
+    const unitStartSeq = ic.nextSeq();
+    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: unitStartSeq, eventType: "unit-start", data: { unitType, unitId } });
+    deps.captureAvailableSkills();
+    writeUnitRuntimeRecord(s.basePath, unitType, unitId, unitStartedAt, {
+        phase: "dispatched",
+        wrapupWarningSent: false,
+        timeoutAt: null,
+        lastProgressAt: unitStartedAt,
+        progressCount: 0,
+        lastProgressKind: "dispatch",
+        recoveryAttempts: 0, // Reset so re-dispatched units get full recovery budget (#2322)
+    });
     // Progress widget + preconditions — deferred to after model selection so the
     // widget's first render tick shows the correct model (#2899).
     deps.updateProgressWidget(ctx, unitType, unitId, state);
@@ -1923,6 +1961,18 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
             lastProgressAt: Date.now(),
             lastProgressKind: "finalize-success",
         });
+        if (!preUnitSnapshot.type.startsWith("hook/") &&
+            preUnitSnapshot.type !== "custom-step" &&
+            preUnitSnapshot.type !== "complete-milestone") {
+            setAutoOutcomeWidget(ctx, {
+                ...buildPhaseHandoffOutcome({
+                    unitType: preUnitSnapshot.type,
+                    unitId: preUnitSnapshot.id,
+                    agentEndMessages: s.lastUnitAgentEndMessages,
+                }),
+                startedAt: s.autoStartTime,
+            });
+        }
     }
     s.currentUnit = null;
     clearCurrentPhase();

package/dist/resources/extensions/gsd/auto/workflow-memory-pressure.js

@@ -4,6 +4,18 @@ import { createRequire } from "node:module";
 const require = createRequire(import.meta.url);
 const DEFAULT_MEMORY_PRESSURE_THRESHOLD = 0.85;
 const DEFAULT_HEAP_LIMIT_MB = 4096;
+/**
+ * Returns true on auto-mode startup, then every configured interval.
+ *
+ * Iteration 1 is checked explicitly so early session memory pressure cannot
+ * bypass the periodic interval guard.
+ */
+export function shouldCheckMemoryPressure(iteration, interval) {
+    if (!Number.isInteger(interval) || interval <= 0) {
+        throw new Error("Memory pressure check interval must be a positive integer");
+    }
+    return iteration === 1 || iteration % interval === 0;
+}
 function defaultHeapLimitBytes() {
     const v8 = require("node:v8");
     const limit = v8.getHeapStatistics?.().heap_size_limit;

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

@@ -27,6 +27,19 @@ export function extractUatSliceId(unitId) {
         return slice;
     return null;
 }
+export function buildPhaseHandoffOutcome(input) {
+    const phase = unitPhaseLabel(input.unitType);
+    const detail = extractLastAssistantSummary(input.agentEndMessages) ??
+        `Completed ${unitVerb(input.unitType)} ${input.unitId}.`;
+    return {
+        status: "complete",
+        title: `${phase} complete`,
+        detail,
+        unitLabel: `${unitVerb(input.unitType)} ${input.unitId}`,
+        nextAction: "Preparing the next phase. Review this handoff while the next session starts.",
+        commands: ["/gsd status for overview", "/gsd visualize to inspect", "/gsd notifications for history"],
+    };
+}
 // ─── Unit Description Helpers ─────────────────────────────────────────────────
 export function unitVerb(unitType) {
     if (unitType.startsWith("hook/"))
@@ -464,7 +477,6 @@ export function _resetWidgetModeForTests() {
 export function updateProgressWidget(ctx, unitType, unitId, state, accessors, tierBadge) {
     if (!ctx.hasUI)
         return;
-    ctx.ui.setWidget("gsd-outcome", undefined);
     // Welcome header is a startup-only banner — permanently suppress it once
     // auto-mode activates. The dashboard widget owns all status from here.
     // Note: setHeader(undefined) restores the built-in header (logo +
@@ -927,3 +939,56 @@ function normalizeRollupText(value) {
         return null;
     return clean;
 }
+function isAssistantMessage(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    if (record.role === "assistant")
+        return true;
+    const message = record.message;
+    if (message && typeof message === "object") {
+        return message.role === "assistant";
+    }
+    return false;
+}
+function extractLastAssistantSummary(messages) {
+    if (!messages || messages.length === 0)
+        return null;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (!isAssistantMessage(messages[i]))
+            continue;
+        const text = extractMessageText(messages[i]);
+        const clean = normalizeRollupText(text);
+        if (clean)
+            return truncateToWidth(clean, 220, "…");
+    }
+    return null;
+}
+function extractMessageText(value) {
+    if (typeof value === "string")
+        return value;
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (typeof record.content === "string")
+        return record.content;
+    const message = record.message;
+    if (message && typeof message === "object") {
+        return extractMessageText(message);
+    }
+    const content = record.content;
+    if (Array.isArray(content)) {
+        const parts = content
+            .map((part) => {
+            if (typeof part === "string")
+                return part;
+            if (!part || typeof part !== "object")
+                return "";
+            const partRecord = part;
+            return typeof partRecord.text === "string" ? partRecord.text : "";
+        })
+            .filter(Boolean);
+        return parts.length > 0 ? parts.join(" ") : null;
+    }
+    return null;
+}

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

@@ -224,6 +224,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
         unitType,
         authMode: ctx.model?.provider ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider) : undefined,
         baseUrl: ctx.model?.baseUrl,
+        activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
     });
     if (compatibilityError) {
         ctx.ui.notify(compatibilityError, "error");

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

@@ -102,6 +102,9 @@ function missingSliceStop(mid, phase) {
         level: "error",
     };
 }
+function isRegistryMilestoneComplete(state, mid) {
+    return state.registry.some((milestone) => milestone.id === mid && milestone.status === "complete");
+}
 /**
  * Check for milestone slices missing SUMMARY files.
  * Returns array of missing slice IDs, or empty array if all present or DB unavailable.
@@ -247,6 +250,8 @@ export const DISPATCH_RULES = [
                 return null;
             if (!MILESTONE_ID_RE.test(mid))
                 return null;
+            if (isRegistryMilestoneComplete(state, mid))
+                return null;
             // Align with the plan-v2 gate's lookup semantics: whitespace-only counts
             // as missing, and an auto worktree may fall back to GSD_PROJECT_ROOT.
             if (hasFinalizedMilestoneContext(basePath, mid))
@@ -294,9 +299,7 @@ export const DISPATCH_RULES = [
             const attempts = incrementUatCount(basePath, mid, sliceId);
             if (attempts > MAX_UAT_ATTEMPTS) {
                 return {
-                    action: "stop",
-                    reason: `run-uat for ${mid}/${sliceId} has been dispatched ${attempts - 1} times without producing a verdict. Verification commands may be broken — fix the UAT spec or manually write an ASSESSMENT verdict.`,
-                    level: "warning",
+                    action: "skip",
                 };
             }
             const uatFile = resolveSliceFile(basePath, mid, sliceId, "UAT");
@@ -557,6 +560,8 @@ export const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath, prefs, structuredQuestionsAvailable }) => {
             if (state.phase !== "pre-planning")
                 return null;
+            if (isRegistryMilestoneComplete(state, mid))
+                return null;
             const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
             const hasContext = !!(contextFile && (await loadFile(contextFile)));
             if (hasContext)
@@ -609,7 +614,7 @@ export const DISPATCH_RULES = [
         },
     },
     {
-        name: "planning (require_slice_discussion) → pause for discussion (#3454)",
+        name: "planning (require_slice_discussion) → pause for discussion",
         match: async ({ state, mid, basePath, prefs }) => {
             if (state.phase !== "planning")
                 return null;
@@ -1016,7 +1021,7 @@ export const DISPATCH_RULES = [
                         mkdirSync(mDir, { recursive: true });
                     const validationPath = join(mDir, buildMilestoneFileName(mid, "VALIDATION"));
                     const skipSource = trivialVariant
-                        ? "trivial-scope pipeline variant (#4781)"
+                        ? "trivial-scope pipeline variant"
                         : "`skip_milestone_validation` preference";
                     const skipValidationReason = trivialVariant ? "trivial-scope" : "preference";
                     const content = [
@@ -1091,19 +1096,19 @@ export const DISPATCH_RULES = [
                     return { action: "skip" };
                 }
             }
-            // Safety guard (#2675): block completion when VALIDATION verdict is
-            // needs-remediation. The state machine treats needs-remediation as
-            // terminal (to prevent validate-milestone loops per #832), but
-            // completing-milestone should NOT proceed — remediation work is needed.
+            // Safety guard (#2675, #5747, #5920): block completion when VALIDATION
+            // verdict is anything other than pass. The state machine treats these
+            // verdicts as terminal, but completing-milestone should NOT proceed —
+            // remediation or human attention is needed.
             const validationFile = resolveMilestoneFile(basePath, mid, "VALIDATION");
             if (validationFile) {
                 const validationContent = await loadFile(validationFile);
                 if (validationContent) {
                     const verdict = extractVerdict(validationContent);
-                    if (verdict === "needs-remediation") {
+                    if (verdict !== "pass") {
                         return {
                             action: "stop",
-                            reason: `Cannot complete milestone ${mid}: VALIDATION verdict is "needs-remediation". Address the remediation findings and re-run validation, or update the verdict manually.`,
+                            reason: `Cannot complete milestone ${mid}: VALIDATION verdict is "${verdict}". Address the validation findings and re-run validation, or update the verdict manually.`,
                             level: "warning",
                         };
                     }
@@ -1118,16 +1123,12 @@ export const DISPATCH_RULES = [
                     level: "error",
                 };
             }
-            // Safety guard (#1703): verify the milestone produced implementation
-            // artifacts (non-.gsd/ files). A milestone with only plan files and
-            // zero implementation code should not be marked complete.
+            // Safety signal (#1703, #5097): detect milestones with only .gsd/
+            // artifacts. This no longer hard-blocks completion because some
+            // milestones are intentionally planning/documentation-only.
             const artifactCheck = hasImplementationArtifacts(basePath, mid);
             if (artifactCheck === "absent") {
-                return {
-                    action: "stop",
-                    reason: `Cannot complete milestone ${mid}: no implementation files found outside .gsd/. The milestone has only plan files — actual code changes are required.`,
-                    level: "error",
-                };
+                logWarning("dispatch", `Milestone ${mid} has no implementation files outside .gsd/ — continuing complete-milestone dispatch (planning-only/documentation-only milestone).`);
             }
             if (artifactCheck === "unknown") {
                 logWarning("dispatch", `Implementation artifact check inconclusive for ${mid} — proceeding (git context unavailable)`);

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -494,6 +494,8 @@ autoModeStartThinkingLevel) {
  * Handles formats: "provider/model", "bare-id", "org/model-name" (OpenRouter).
  */
 export function resolveModelId(modelId, availableModels, currentProvider) {
+    if (!modelId)
+        return undefined;
     const slashIdx = modelId.indexOf("/");
     if (slashIdx !== -1) {
         const maybeProvider = modelId.substring(0, slashIdx);