@opengsd/gsd-pi 1.9.0-dev.5c1a3ff2 → 1.9.0-dev.d2070876

package/dist/headless.js

@@ -29,7 +29,8 @@ export function buildHeadlessSlashCommand(options) {
     if (options.command === 'new-milestone' && options.auto && !commandArgs.includes(HEADLESS_CHAIN_AUTO_FLAG)) {
         commandArgs.push(HEADLESS_CHAIN_AUTO_FLAG);
     }
-    return `/gsd ${options.command}${commandArgs.length > 0 ? ' ' + commandArgs.join(' ') : ''}`;
+    const serializedArgs = commandArgs.map(arg => /\s/.test(arg) ? JSON.stringify(arg) : arg);
+    return `/gsd ${options.command}${serializedArgs.length > 0 ? ' ' + serializedArgs.join(' ') : ''}`;
 }
 /**
  * Commands classified as multi-turn in headless mode: they involve multiple

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

@@ -1 +1 @@
-1252616a01ee43bc
+5f0f1c788a126951

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

@@ -261,7 +261,22 @@ async function enforceMinRequestInterval(s, prefs) {
         await new Promise(r => setTimeout(r, decision.waitMs));
     }
 }
-function closeOutCrashedUnit(s, iterData, err) {
+async function snapshotCrashedUnitWork(ctx, s, deps, iterData) {
+    try {
+        const commitMsg = await deps.autoCommitUnit?.(s.basePath, iterData.unitType, iterData.unitId, ctx);
+        if (commitMsg) {
+            debugLog("autoLoop", {
+                phase: "crash-snapshot-commit",
+                unitType: iterData.unitType,
+                unitId: iterData.unitId,
+            });
+        }
+    }
+    catch (snapshotErr) {
+        logWarning("dispatch", `unit crash snapshot failed: ${snapshotErr instanceof Error ? snapshotErr.message : String(snapshotErr)}`);
+    }
+}
+async function closeOutCrashedUnit(ctx, s, deps, iterData, err) {
     const summary = formatDispatchExceptionSummary({ error: err });
     try {
         emitOpenUnitEndForUnit(s.basePath, iterData.unitType, iterData.unitId, "cancelled", {
@@ -278,6 +293,7 @@ function closeOutCrashedUnit(s, iterData, err) {
     catch (closeoutErr) {
         logWarning("dispatch", `unit crash closeout failed: ${closeoutErr instanceof Error ? closeoutErr.message : String(closeoutErr)}`);
     }
+    await snapshotCrashedUnitWork(ctx, s, deps, iterData);
 }
 /**
  * Main auto-mode execution loop. Iterates: orchestration.advance → guards →
@@ -400,11 +416,15 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             active: s.active,
             iteration,
             maxIterations: MAX_LOOP_ITERATIONS,
-            hasCommandContext: Boolean(s.cmdCtx),
+            hasCommandContext: typeof s.cmdCtx?.newSession === "function",
             sessionLockValid: true,
         });
         if (commandContextDecision.action === "stop" && commandContextDecision.reason === "missing-command-context") {
             debugLog("autoLoop", { phase: "exit", reason: "no-cmdCtx" });
+            if (s.currentUnit) {
+                await deps.autoCommitUnit?.(s.basePath, s.currentUnit.type, s.currentUnit.id, ctx);
+            }
+            await deps.stopAuto(ctx, pi, commandContextDecision.message, { preserveWorktree: true });
             finishTurn("stopped", "manual-attention", commandContextDecision.reason);
             break;
         }
@@ -586,7 +606,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     if (err instanceof ModelPolicyDispatchBlockedError) {
                         throw err;
                     }
-                    closeOutCrashedUnit(s, iterData, err);
+                    await closeOutCrashedUnit(ctx, s, deps, iterData, err);
                     throw err;
                 }
                 if (unitPhaseResult.action === "next") {
@@ -1109,7 +1129,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 if (err instanceof ModelPolicyDispatchBlockedError) {
                     throw err;
                 }
-                closeOutCrashedUnit(s, iterData, err);
+                await closeOutCrashedUnit(ctx, s, deps, iterData, err);
                 dispatchSettled = settleDispatchFailed(dispatchId, formatDispatchExceptionSummary({ error: err }), {
                     markFailed: markDispatchFailed,
                     logWriteFailure: logDispatchLedgerWriteFailure,

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

@@ -58,6 +58,24 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     debugLog("runUnit", { phase: "start", unitType, unitId });
     // ── Session creation with timeout ──
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
+    const cmdCtx = s.cmdCtx;
+    if (typeof cmdCtx?.newSession !== "function") {
+        const msg = "command context is missing newSession";
+        debugLog("runUnit", {
+            phase: "session-error",
+            unitType,
+            unitId,
+            error: msg,
+        });
+        return {
+            status: "cancelled",
+            errorContext: {
+                message: `Session creation failed: ${msg}`,
+                category: "session-failed",
+                isTransient: false,
+            },
+        };
+    }
     let sessionResult;
     let sessionTimeoutHandle;
     const mySessionSwitchGeneration = ++sessionSwitchGeneration;
@@ -67,7 +85,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const sessionAbortController = new AbortController();
     _setSessionSwitchInFlight(true);
     try {
-        const sessionPromise = s.cmdCtx.newSession({
+        const sessionPromise = cmdCtx.newSession({
             abortSignal: sessionAbortController.signal,
             workspaceRoot: s.basePath,
         }).finally(() => {

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

@@ -30,6 +30,25 @@ import { isIsolatedWorktreeSession, _resolveCurrentUnitStartedAtForTest, emitCan
 import { MAX_RECOVERY_CHARS } from "./types.js";
 const ZERO_TOOL_PROVIDER_ERROR_PREFIX_RE = /^(?:api error(?::|$|\s*\()|provider error(?::|$|\s*\()|request failed\b|(?:http\s*)?(?:429|500|502|503)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|socket hang up\b|fetch failed\b|(?:network|connection|server) error(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|dns\b.*(?:fail|error|timeout)|unexpected eof\b|stream idle timeout\b|partial response received\b|stream_exhausted\b|terminated(?::|$)|(?:connection|stream|request)\b.{0,40}\bterminated\b|other side closed\b|rate.?limit(?:ed| exceeded| reached| error)|too many requests\b|you(?:'ve| have) (?:hit|reached) your (?:\w+ )?limit\b|.*\b(?:usage|session|weekly|daily|monthly|quota) limit\b|limit\b.{0,40}\bresets?\b|out of extra usage\b|service.?unavailable\b|internal(?: server)? error(?::|$)|internal(?:[_-]server)?[_-]error\b|server[_-]error\b|(?:provider|server|api|model|codex|claude|openai|anthropic|gemini)\b.{0,80}\boverloaded\b|overloaded\b.{0,80}\b(?:provider|server|api|model)\b|context (?:window|length) exceed|context window exceed)/i;
 const ZERO_TOOL_PROVIDER_ERROR_SIGNAL_RE = /(?:\b(?:http|status(?: code)?|code|error:)\s*(?:429|500|502|503)\b|\b(?:api|provider) error\s*[:(]?\s*(?:429|500|502|503)\b|\b(?:typeerror|error):\s*(?:fetch failed\b|socket hang up\b|terminated(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|(?:network|connection|server) error(?::|$)|stream idle timeout\b|partial response received\b|unexpected eof\b)|\b(?:server_error|api_error|stream_exhausted(?:_without_result)?)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|context (?:window|length) exceed|context window exceed)/i;
+const ZERO_TOOL_PSEUDO_TOOL_CALL_RE = /<arg_key>[\s\S]*?<\/arg_key>\s*<arg_value>[\s\S]*?<\/arg_value>[\s\S]*?<\/tool_call>/i;
+const ZERO_TOOL_PSEUDO_TOOL_CALL_SNIPPET_CHARS = 200;
+function zeroToolMessageSnippet(message) {
+    const compact = message.trim().replace(/\s+/g, " ");
+    if (compact.length <= ZERO_TOOL_PSEUDO_TOOL_CALL_SNIPPET_CHARS)
+        return compact;
+    return `${compact.slice(0, ZERO_TOOL_PSEUDO_TOOL_CALL_SNIPPET_CHARS - 3)}...`;
+}
+// Provider serialization drift: the model emitted a tool call as plain assistant
+// text (`toolName<arg_key>…</arg_key><arg_value>…</arg_value></tool_call>`)
+// instead of a structured tool call. Returns an operator-visible snippet when
+// detected. Kept separate from error classification so a drift snippet is never
+// conflated with an ErrorClass (which would force a fragile union whose
+// narrowing the root and extensions tsconfigs disagree on).
+function zeroToolPseudoToolCallSnippet(message) {
+    if (!ZERO_TOOL_PSEUDO_TOOL_CALL_RE.test(message))
+        return null;
+    return zeroToolMessageSnippet(message);
+}
 function classifyZeroToolProviderMessage(message) {
     const firstLine = message.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
     if (!firstLine ||
@@ -39,6 +58,7 @@ function classifyZeroToolProviderMessage(message) {
     return classifyError(firstLine);
 }
 export const _classifyZeroToolProviderMessageForTest = classifyZeroToolProviderMessage;
+export const _zeroToolPseudoToolCallSnippetForTest = zeroToolPseudoToolCallSnippet;
 export function resolveDispatchRecoveryAttempts(unitRecoveryCount, unitType, unitId) {
     return (unitRecoveryCount.get(`${unitType}/${unitId}`) ?? 0) > 0
         ? 0
@@ -572,11 +592,23 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             const lastUnit = [...currentLedger.units].reverse().find((u) => u.type === unitType && u.id === unitId && u.startedAt === _resolveCurrentUnitStartedAtForTest(s.currentUnit));
             if (lastUnit && lastUnit.toolCalls === 0) {
                 const lastAssistantMessage = lastAssistantText(s.lastUnitAgentEndMessages);
-                const providerMessageClass = classifyZeroToolProviderMessage(lastAssistantMessage);
-                if (providerMessageClass && isTransient(providerMessageClass)) {
-                    const retryAfterMs = "retryAfterMs" in providerMessageClass ? providerMessageClass.retryAfterMs : 15_000;
+                const pseudoToolCallSnippet = zeroToolPseudoToolCallSnippet(lastAssistantMessage);
+                if (pseudoToolCallSnippet) {
+                    debugLog("runUnitPhase", {
+                        phase: "zero-tool-serialization-drift",
+                        unitType,
+                        unitId,
+                        snippet: pseudoToolCallSnippet,
+                    });
+                    ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls - provider serialization drift: model emitted pseudo-tool-call text. Snippet: ${pseudoToolCallSnippet}`, "error");
+                    await deps.pauseAuto(ctx, pi);
+                    return { action: "break", reason: "zero-tool-serialization-drift" };
+                }
+                const providerErrorClass = classifyZeroToolProviderMessage(lastAssistantMessage);
+                if (providerErrorClass && isTransient(providerErrorClass)) {
+                    const retryAfterMs = "retryAfterMs" in providerErrorClass ? providerErrorClass.retryAfterMs : 15_000;
                     await pauseAutoForProviderError(ctx.ui, ` for ${unitType} ${unitId}`, () => deps.pauseAuto(ctx, pi), {
-                        isRateLimit: providerMessageClass.kind === "rate-limit",
+                        isRateLimit: providerErrorClass.kind === "rate-limit",
                         isTransient: true,
                         retryAfterMs,
                         resume: () => {
@@ -593,7 +625,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                     });
                     return {
                         action: "break",
-                        reason: providerMessageClass.kind === "rate-limit" ? "rate-limit" : "api-timeout",
+                        reason: providerErrorClass.kind === "rate-limit" ? "rate-limit" : "api-timeout",
                     };
                 }
                 if (USER_DRIVEN_DEEP_UNITS.has(unitType) && isAwaitingUserInput(s.lastUnitAgentEndMessages ?? undefined)) {

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

@@ -1603,6 +1603,8 @@ function applyLanguageDirectiveToDispatch(action, prefs) {
     const directive = renderLanguageDirectiveForPrompt(prefs);
     if (!directive)
         return action;
+    if (action.prompt.startsWith(directive))
+        return action;
     return { ...action, prompt: `${directive}\n\n${action.prompt}` };
 }
 // ─── Resolver ─────────────────────────────────────────────────────────────

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

@@ -11,7 +11,7 @@ import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverr
 import { extractVerdict } from "./verdict-parser.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, taskIdFromTaskFileName, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, relTaskFile, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
-import { resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
+import { resolveInlineLevel, loadEffectiveGSDPreferences, renderLanguageDirectiveForPrompt } from "./preferences.js";
 import { createRepositoryRegistryFromPreferences } from "./repository-registry.js";
 import { isContextModeEnabled } from "./preferences-types.js";
 import { parseRoadmap } from "./parsers-legacy.js";
@@ -47,6 +47,12 @@ export { buildSkillActivationBlock, buildSkillDiscoveryVars };
  * from their configured executor window.
  */
 const MAX_PREAMBLE_CHARS = 20_000;
+function prependLanguageDirectiveForBase(base, prompt) {
+    const directive = renderLanguageDirectiveForPrompt(loadEffectiveGSDPreferences(base)?.preferences);
+    if (!directive || prompt.startsWith(directive))
+        return prompt;
+    return `${directive}\n\n${prompt}`;
+}
 /**
  * Resolve prompt budgets from the configured executor context window.
  *
@@ -1463,7 +1469,7 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
     if (headless) {
         const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
         const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
-        return loadPrompt("discuss-headless", {
+        const prompt = loadPrompt("discuss-headless", {
             seedContext: roadmapContent ?? "",
             inlinedTemplates: contextTemplate,
             workingDirectory: base,
@@ -1472,6 +1478,7 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
             commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
             multiMilestoneCommitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
         });
+        return prependLanguageDirectiveForBase(base, prompt);
     }
     const rawInlinedContext = await buildDiscussMilestoneInlinedContext(mid, base);
     const cappedInlinedContext = capPreamble(rawInlinedContext);
@@ -1498,9 +1505,10 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
         const truncationNote = cappedDraftSeed !== draftSeed
             ? `\n\n_(Draft seed truncated; read the full draft at \`${draftRelPath}\` if needed.)_`
             : "";
-        return `${promptWithContextMode}\n\n## Prior Discussion (Draft Seed)\n\nThe following draft was captured from a prior multi-milestone discussion. Use it as seed material — the user has already provided this context. Start with a brief reflection on what the draft covers, then probe for any gaps or open questions before writing the full CONTEXT.md.\n\n${cappedDraftSeed}${truncationNote}`;
+        const promptWithDraftSeed = `${promptWithContextMode}\n\n## Prior Discussion (Draft Seed)\n\nThe following draft was captured from a prior multi-milestone discussion. Use it as seed material — the user has already provided this context. Start with a brief reflection on what the draft covers, then probe for any gaps or open questions before writing the full CONTEXT.md.\n\n${cappedDraftSeed}${truncationNote}`;
+        return prependLanguageDirectiveForBase(base, promptWithDraftSeed);
     }
-    return promptWithContextMode;
+    return prependLanguageDirectiveForBase(base, promptWithContextMode);
 }
 /**
  * Build a prompt for the workflow-preferences unit type (deep mode).

package/dist/resources/extensions/gsd/auto-runtime-state.js

@@ -1,6 +1,6 @@
 // GSD auto-mode runtime state
 import { AutoSession } from "./auto/session.js";
-import { isDeterministicPolicyError, isQueuedUserMessageSkip, isToolInvocationError, markToolEnd as markTrackedToolEnd, markToolStart as markTrackedToolStart, } from "./auto-tool-tracking.js";
+import { markToolEnd as markTrackedToolEnd, markToolStart as markTrackedToolStart, shouldClearToolInvocationErrorAfterSuccess, updateToolInvocationError, } from "./auto-tool-tracking.js";
 // Re-exported as a pure pass-through. Must stay UNGATED (no autoSession.active
 // argument, unlike markToolStart at the bottom of this file) so it is true in
 // foreground where the foreground approval-gate pause consults it.
@@ -61,13 +61,13 @@ export function markToolEnd(toolCallId) {
 export function recordToolInvocationError(toolName, errorMsg) {
     if (!autoSession.active)
         return;
-    if (isToolInvocationError(errorMsg) || isQueuedUserMessageSkip(errorMsg) || isDeterministicPolicyError(errorMsg)) {
-        autoSession.lastToolInvocationError = `${toolName}: ${errorMsg}`;
-    }
+    autoSession.lastToolInvocationError = updateToolInvocationError(autoSession.lastToolInvocationError, toolName, errorMsg);
 }
-export function clearToolInvocationError() {
+export function clearToolInvocationError(successfulToolName) {
     if (!autoSession.active)
         return;
+    if (!shouldClearToolInvocationErrorAfterSuccess(autoSession.lastToolInvocationError, successfulToolName))
+        return;
     autoSession.lastToolInvocationError = null;
 }
 export function getSourceObservationStore() {

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

@@ -46,9 +46,10 @@ import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.
 import { extractVerdict } from "./verdict-parser.js";
 import { auditOrphanedPreflightStashes } from "./orphan-stash-audit.js";
 import { parseProject } from "./schemas/parsers.js";
+import { LAYOUT_SEGMENTS } from "./layout-policy.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
-import { existsSync, mkdirSync, readFileSync, rmSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, } from "node:fs";
 import { join } from "node:path";
 import { validateDirectory } from "./validate-directory.js";
 import { isCustomProvider, resolveDefaultSessionModel, resolveDynamicRoutingConfig, } from "./preferences-models.js";
@@ -73,6 +74,30 @@ const MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS = 2;
 export function hasGitIndexLockForTest(basePath) {
     return existsSync(join(basePath, ".git", "index.lock"));
 }
+function isEmptyDirectory(dirPath) {
+    try {
+        return existsSync(dirPath) && readdirSync(dirPath).length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function reconcileFlatPhaseBootstrapLayout(basePath) {
+    const gsdDir = join(basePath, ".gsd");
+    const phasesPath = join(gsdDir, LAYOUT_SEGMENTS.level1);
+    const milestonesPath = join(gsdDir, "milestones");
+    if (isEmptyDirectory(milestonesPath)) {
+        if (!existsSync(phasesPath))
+            mkdirSync(phasesPath, { recursive: true });
+        rmSync(milestonesPath, { recursive: true, force: true });
+        return true;
+    }
+    if (!existsSync(phasesPath) && !existsSync(milestonesPath)) {
+        mkdirSync(phasesPath, { recursive: true });
+        return true;
+    }
+    return false;
+}
 export function _shouldAbortBootstrapForUnavailableDbForTest(gsdDbPath, dbAvailable, pathExists = existsSync) {
     return pathExists(gsdDbPath) && !dbAvailable;
 }
@@ -868,20 +893,15 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         ensureGitignore(base, { manageGitignore });
         if (manageGitignore !== false)
             untrackRuntimeFiles(base);
-        // Bootstrap milestones/ if it doesn't exist.
-        // Check milestones/ directly — ensureGsdSymlink above already created .gsd/,
-        // so checking .gsd/ existence would be dead code (#2942).
-        const gsdDir = join(base, ".gsd");
-        const milestonesPath = join(gsdDir, "milestones");
-        if (!existsSync(milestonesPath)) {
-            mkdirSync(milestonesPath, { recursive: true });
+        // Bootstrap the flat-phase projection root and clean empty legacy scaffolds.
+        if (reconcileFlatPhaseBootstrapLayout(base)) {
             try {
                 nativeAddAll(base);
                 nativeCommit(base, "chore: init gsd");
             }
             catch (err) {
                 /* nothing to commit */
-                logWarning("engine", `mkdir failed: ${err instanceof Error ? err.message : String(err)}`);
+                logWarning("engine", `layout bootstrap commit failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
         {

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -118,6 +118,8 @@ export function clearInFlightTools() {
  */
 const TOOL_INVOCATION_ERROR_RE = /Validation failed for tool|Input validation error|Invalid arguments for tool|MCP error -32602|No such tool available|Expected ',' or '\}'(?: after property value)?(?: in JSON)?|Unexpected end of JSON|Unexpected token.*in JSON|does not provide an export named|Named export .* not found|Cannot find module|ERR_MODULE_NOT_FOUND|ERR_MODULE_NOT_EXPORTED|ERR_PACKAGE_PATH_NOT_EXPORTED/i;
 const DETERMINISTIC_POLICY_ERROR_RE = /(?:^|\b)(?:HARD BLOCK:|Blocked: \/gsd queue is a planning tool|Direct writes to \.gsd\/STATE\.md and \.gsd\/gsd\.db are blocked|This is a mechanical gate)/i;
+const SCHEDULE_WAKEUP_TOOL_NAME = "ScheduleWakeup";
+const SCHEDULE_WAKEUP_CONTINUATION_ERROR = "`prompt` is required when `stop` is not true";
 /**
  * Matches the runtime's "tool not registered" error. Unlike the deterministic
  * invocation failures above, this one is usually transient: the workflow MCP
@@ -135,6 +137,44 @@ export function isToolInvocationError(errorMsg) {
         return false;
     return TOOL_INVOCATION_ERROR_RE.test(errorMsg) || isDeterministicPolicyError(errorMsg);
 }
+/**
+ * Claude Code validates its native ScheduleWakeup tool outside GSD's schema.
+ * Keep this exact and tool-scoped so similarly worded business validation from
+ * unrelated tools does not pause auto-mode.
+ */
+export function isScheduleWakeupContinuationError(toolName, errorMsg) {
+    return stripMcpToolPrefix(toolName) === SCHEDULE_WAKEUP_TOOL_NAME
+        && errorMsg.trim() === SCHEDULE_WAKEUP_CONTINUATION_ERROR;
+}
+function shouldRecordToolInvocationError(toolName, errorMsg) {
+    return isScheduleWakeupContinuationError(toolName, errorMsg)
+        || isToolInvocationError(errorMsg)
+        || isQueuedUserMessageSkip(errorMsg);
+}
+function isRecordedScheduleWakeupContinuationError(recordedError) {
+    if (!recordedError)
+        return false;
+    const separator = recordedError.indexOf(": ");
+    return separator >= 0 && isScheduleWakeupContinuationError(recordedError.slice(0, separator), recordedError.slice(separator + 2));
+}
+export function updateToolInvocationError(recordedError, toolName, errorMsg) {
+    if (!shouldRecordToolInvocationError(toolName, errorMsg))
+        return recordedError;
+    if (isRecordedScheduleWakeupContinuationError(recordedError)
+        && !isScheduleWakeupContinuationError(toolName, errorMsg))
+        return recordedError;
+    return `${toolName}: ${errorMsg}`;
+}
+/**
+ * A failed continuation must survive successful diagnostic/read calls in the
+ * same turn. Only a later successful ScheduleWakeup proves the continuation
+ * was armed; all other invocation errors retain their existing clear-on-success
+ * behavior.
+ */
+export function shouldClearToolInvocationErrorAfterSuccess(recordedError, successfulToolName) {
+    return !isRecordedScheduleWakeupContinuationError(recordedError)
+        || stripMcpToolPrefix(successfulToolName ?? "") === SCHEDULE_WAKEUP_TOOL_NAME;
+}
 /**
  * Returns true if the error message indicates the called tool was not on the
  * session's tool surface (MCP startup race — see TOOL_UNAVAILABLE_ERROR_RE).

package/dist/resources/extensions/gsd/auto-worktree-sync.js

@@ -5,7 +5,7 @@
 import { cpSync, existsSync, lstatSync as lstatSyncFn, mkdirSync, readdirSync, } from "node:fs";
 import { join } from "node:path";
 import { _isSamePath as isSamePath, } from "./auto-worktree-cleanup.js";
-import { resolveGsdPathContract } from "./paths.js";
+import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { logWarning } from "./workflow-logger.js";
 const PROJECT_PREFERENCES_FILE = "PREFERENCES.md";
@@ -143,10 +143,14 @@ function syncMilestoneLayout(mainGsd, wtGsd, layoutSegment, synced) {
     if (!existsSync(mainMilestonesDir))
         return;
     try {
-        mkdirSync(wtMilestonesDir, { recursive: true });
         const mainMilestones = readdirSync(mainMilestonesDir, { withFileTypes: true })
             .filter((entry) => entry.isDirectory())
-            .map((entry) => entry.name);
+            .map((entry) => entry.name)
+            .filter((name) => layoutSegment !== "milestones" ||
+            dirIsContentBearingLegacyMilestone(join(mainMilestonesDir, name)));
+        if (mainMilestones.length === 0)
+            return;
+        mkdirSync(wtMilestonesDir, { recursive: true });
         for (const milestoneId of mainMilestones) {
             syncMilestoneDirectory(mainMilestonesDir, wtMilestonesDir, milestoneId, synced);
         }

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

@@ -28,7 +28,7 @@ import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSes
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, loadEffectiveGSDPreferencesWithRegistry, resolveProfileAnchorProvider, getIsolationMode, resolveEffectiveUnitIsolationMode, } from "./preferences.js";
 import { playNotificationBell, sendDesktopNotification } from "./notifications.js";
 import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, HARD_CONTEXT_REROOT_THRESHOLD_PERCENT, resolveCompactionThresholdPercent, shouldRerootStepSessionForContext, shouldWarnStepSessionForContext, } from "./auto-budget.js";
-import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, isQueuedUserMessageSkip, isDeterministicPolicyError, } from "./auto-tool-tracking.js";
+import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, updateToolInvocationError, } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { selectAndApplyModel, resolveModelId, clearToolBaseline, isModelUnavailable, applyThinkingLevelForModel } from "./auto-model-selection.js";
 import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
@@ -617,15 +617,14 @@ export function markToolEnd(toolCallId) {
  * Called from tool_execution_end when a GSD tool fails with isError.
  * Stores the error if it matches:
  *   - tool-invocation-error pattern (malformed/truncated JSON)
+ *   - failed ScheduleWakeup continuation validation (#1379)
  *   - queued-user-message skip pattern
  *   - deterministic policy rejection (#4973, e.g. context_write_blocked)
  */
 export function recordToolInvocationError(toolName, errorMsg) {
     if (!s.active)
         return;
-    if (isToolInvocationError(errorMsg) || isQueuedUserMessageSkip(errorMsg) || isDeterministicPolicyError(errorMsg)) {
-        s.lastToolInvocationError = `${toolName}: ${errorMsg}`;
-    }
+    s.lastToolInvocationError = updateToolInvocationError(s.lastToolInvocationError, toolName, errorMsg);
 }
 export function getOldestInFlightToolAgeMs() {
     return _getOldestInFlightToolAgeMs();
@@ -2441,7 +2440,18 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         startedAt: hookStartedAt,
         workspaceRoot: s.basePath,
     });
-    const result = await s.cmdCtx.newSession({ workspaceRoot: s.basePath });
+    const cmdCtx = s.cmdCtx;
+    if (typeof cmdCtx?.newSession !== "function") {
+        const message = "Auto-mode has no command context for dispatch.";
+        ctx.ui.notify(message, "error");
+        const unitToCommit = previousCurrentUnit ?? s.currentUnit;
+        if (unitToCommit) {
+            await autoCommitUnit(s.basePath, unitToCommit.type, unitToCommit.id, ctx);
+        }
+        await stopAuto(ctx, pi, message, { preserveWorktree: true });
+        return false;
+    }
+    const result = await cmdCtx.newSession({ workspaceRoot: s.basePath });
     if (result.cancelled) {
         await stopAuto(ctx, pi);
         return false;

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -1448,7 +1448,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             recordRetryableHarnessToolError(toolName, resultPayload, errorText);
         }
         else if (isAutoActive()) {
-            clearToolInvocationError();
+            clearToolInvocationError(event.toolName);
         }
         // Interactive Closeout adapter (ADR-032): auto-mode owns closeout for its
         // own units; interactive completions get the durable git subset (commit +
@@ -1631,7 +1631,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             recordRetryableHarnessToolError(toolName, event.result, errorText);
         }
         else if (isAutoActive()) {
-            clearToolInvocationError();
+            clearToolInvocationError(event.toolName);
         }
         // Safety harness: record tool execution results for evidence cross-referencing
         if (isAutoActive()) {

package/dist/resources/extensions/gsd/commands-verdict.js

@@ -8,6 +8,7 @@ import { executeValidateMilestone } from "./tools/workflow-tool-executors.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { getLatestAssessmentByScope } from "./gsd-db.js";
 import { checkpointWorkflowDatabase } from "./db-workspace.js";
+import { formatVerdictRecordedNotice, formatVerdictRejectedNotice } from "./stop-notice.js";
 import { VALIDATION_VERDICTS, extractVerdict, isValidMilestoneVerdict, } from "./verdict-parser.js";
 const USAGE = 'Usage: /gsd verdict <pass|needs-attention|needs-remediation> [--milestone Mxxx] [--rationale "..."]';
 function tokenize(raw) {
@@ -123,35 +124,35 @@ async function loadExistingValidation(basePath, milestoneId) {
 }
 export async function handleVerdict(rawArgs, ctx, basePath) {
     if (!rawArgs.trim()) {
-        ctx.ui.notify(USAGE, "warning");
+        ctx.ui.notify(formatVerdictRejectedNotice(USAGE), "warning");
         return;
     }
     const parsed = parseArgs(rawArgs);
     if ("error" in parsed) {
-        ctx.ui.notify(`${parsed.error}\n${USAGE}`, "warning");
+        ctx.ui.notify(formatVerdictRejectedNotice(`${parsed.error}\n${USAGE}`), "warning");
         return;
     }
     if (!parsed.verdict) {
-        ctx.ui.notify(USAGE, "warning");
+        ctx.ui.notify(formatVerdictRejectedNotice(USAGE), "warning");
         return;
     }
     let milestoneId = parsed.milestoneId;
     if (!milestoneId) {
         const state = await deriveState(basePath);
         if (!state.activeMilestone) {
-            ctx.ui.notify("No active milestone — pass --milestone Mxxx to target a specific milestone.", "warning");
+            ctx.ui.notify(formatVerdictRejectedNotice("No active milestone — pass --milestone Mxxx to target a specific milestone."), "warning");
             return;
         }
         milestoneId = state.activeMilestone.id;
     }
     const existingValidation = await loadExistingValidation(basePath, milestoneId);
     if (!existingValidation) {
-        ctx.ui.notify(`No milestone validation found for ${milestoneId}. Run /gsd auto to validate first, then retry /gsd verdict.`, "warning");
+        ctx.ui.notify(formatVerdictRejectedNotice(`No milestone validation found for ${milestoneId}. Run /gsd auto to validate first, then retry /gsd verdict.`), "warning");
         return;
     }
     const current = parseValidationFile(existingValidation.content);
     if (parsed.verdict !== "pass" && !parsed.rationale) {
-        ctx.ui.notify(`--rationale is required when overriding to ${parsed.verdict}.`, "warning");
+        ctx.ui.notify(formatVerdictRejectedNotice(`--rationale is required when overriding to ${parsed.verdict}.`), "warning");
         return;
     }
     const verdictRationale = parsed.rationale ?? "Manually overridden via /gsd verdict";
@@ -169,17 +170,17 @@ export async function handleVerdict(rawArgs, ctx, basePath) {
     }, basePath, parsed.verdict === "pass" ? { skipBrowserEvidenceGate: true } : undefined);
     if (result.isError) {
         const msg = result.content[0]?.type === "text" ? result.content[0].text : "Unknown error";
-        ctx.ui.notify(msg, "error");
+        ctx.ui.notify(formatVerdictRejectedNotice(msg), "error");
         return;
     }
     checkpointWorkflowDatabase();
     const prevVerdict = current.verdict ?? "unknown";
     const effectiveVerdict = extractEffectiveVerdict(result.details, parsed.verdict);
     if (effectiveVerdict !== parsed.verdict) {
-        ctx.ui.notify(`Milestone ${milestoneId} verdict requested: ${parsed.verdict}, effective: ${effectiveVerdict} (${existingValidation.source})`, "warning");
+        ctx.ui.notify(formatVerdictRecordedNotice(`Milestone ${milestoneId} verdict requested: ${parsed.verdict}, effective: ${effectiveVerdict} (${existingValidation.source})`), "warning");
     }
     else {
-        ctx.ui.notify(`Milestone ${milestoneId} verdict: ${prevVerdict} -> ${effectiveVerdict} (${existingValidation.source})`, "success");
+        ctx.ui.notify(formatVerdictRecordedNotice(`Milestone ${milestoneId} verdict: ${prevVerdict} -> ${effectiveVerdict} (${existingValidation.source})`), "success");
     }
     if (effectiveVerdict === "needs-remediation") {
         ctx.ui.notify("Follow up with /gsd dispatch reassess to add remediation slices, then re-run /gsd auto.", "info");