@opengsd/gsd-pi 1.4.0-dev.5fc22c6f → 1.4.0-dev.c18009cd

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

@@ -1 +1 @@
-b92be6014924117b
+f30abebf080db301

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

@@ -21,7 +21,7 @@ import { resolveWorkflowQuestionToolSurface } from "../gsd/question-transport.js
 import { buildProjectGsdMcpServers, ensureProjectWorkflowMcpConfig } from "../gsd/mcp-project-config.js";
 import { loadProjectGSDPreferences } from "../gsd/preferences.js";
 import { markToolStart, markToolEnd } from "../gsd/auto.js";
-import { markInteractiveElicitationStart, markInteractiveElicitationEnd, } from "../gsd/auto-tool-tracking.js";
+import { markInteractiveElicitationStart, markInteractiveElicitationEnd, isInteractiveElicitationInFlight, } from "../gsd/auto-tool-tracking.js";
 import { discoverBrowserMcpServerName, discoverMcpServers, discoverMcpServerNames, discoverUserMcpServerNames, discoverWorkflowMcpServerName, computeMcpDisallowedTools, } from "../gsd/mcp-filter.js";
 import { RUN_UAT_CLAUDE_NATIVE_TOOL_NAMES, RUN_UAT_FORBIDDEN_TOOL_NAMES, RUN_UAT_WORKFLOW_TOOL_NAMES, resolveToolPresentationPlan } from "../gsd/tool-presentation-plan.js";
 import { getUnitToolSurfaceContract } from "../gsd/unit-tool-contracts.js";
@@ -51,6 +51,27 @@ export function resolveClaudeCodeCwd(options) {
 const OTHER_OPTION_LABEL = "None of the above";
 /** Regex pattern that identifies field names and descriptions that should be treated as sensitive/secure inputs. */
 const SENSITIVE_FIELD_PATTERN = /(password|passphrase|secret|token|api[_\s-]*key|private[_\s-]*key|credential)/i;
+/** Mirrors @opengsd/mcp-server's ask_user_questions host elicitation timeout. */
+const WORKFLOW_ELICIT_TIMEOUT_MS = 10 * 60 * 1000;
+/** Close the local form just before the server drops the MCP elicitation request. */
+const WORKFLOW_ELICIT_TIMEOUT_SKEW_MS = 1_000;
+export const CLAUDE_CODE_INTERVIEW_FORM_TIMEOUT_MS = Math.max(1, WORKFLOW_ELICIT_TIMEOUT_MS - WORKFLOW_ELICIT_TIMEOUT_SKEW_MS);
+const ELICITATION_EXPIRED_NOTICE = "Question expired before you answered - the form was closed and no answers were sent.";
+const activeAskUserQuestionElicitationTimeoutAborters = new Set();
+function isAskUserQuestionsToolName(toolName) {
+    const name = String(toolName ?? "");
+    return name === "ask_user_questions" || name.endsWith("__ask_user_questions");
+}
+function isAskUserQuestionsTimedOutResult(toolCall, result) {
+    return isAskUserQuestionsToolName(toolCall.name) && result.details?.timed_out === true;
+}
+function abortActiveAskUserQuestionElicitationsForTimeout() {
+    if (!isInteractiveElicitationInFlight())
+        return;
+    for (const abort of [...activeAskUserQuestionElicitationTimeoutAborters]) {
+        abort();
+    }
+}
 // ---------------------------------------------------------------------------
 // Stream factory
 // ---------------------------------------------------------------------------
@@ -1238,17 +1259,40 @@ export function createClaudeCodeElicitationHandler(ui) {
             // it does not tear down the very elicitation that IS the human boundary
             // (#cc-elicitation-self-cancel). It clears in the finally on every exit.
             const elicId = "cc-elicit-" + (request.id ?? `${Date.now()}-${nextElicitationSeq()}`);
+            const formAbortController = new AbortController();
+            let expiryNoticeShown = false;
+            const abortExpiredForm = () => {
+                if (formAbortController.signal.aborted)
+                    return;
+                formAbortController.abort();
+                if (!expiryNoticeShown) {
+                    expiryNoticeShown = true;
+                    ui.notify(ELICITATION_EXPIRED_NOTICE, "warning");
+                }
+            };
+            const forwardSdkAbort = () => {
+                if (!formAbortController.signal.aborted)
+                    formAbortController.abort();
+            };
+            if (signal.aborted) {
+                forwardSdkAbort();
+            }
+            else {
+                signal.addEventListener("abort", forwardSdkAbort, { once: true });
+            }
+            const expiryTimer = setTimeout(abortExpiredForm, CLAUDE_CODE_INTERVIEW_FORM_TIMEOUT_MS);
             markInteractiveElicitationStart();
             markToolStart(elicId, "ask_user_questions");
+            activeAskUserQuestionElicitationTimeoutAborters.add(abortExpiredForm);
             try {
-                const interviewResult = await showInterviewRound(questions, { signal, overlay: true }, { ui }).catch(() => undefined);
+                const interviewResult = await showInterviewRound(questions, { signal: formAbortController.signal, overlay: true }, { ui }).catch(() => undefined);
                 if (interviewResult === undefined) {
                     // `await` so the dialog human-wait stays inside try/finally and the
                     // in-flight guard is held until the dialog resolves. Without it,
                     // `finally` runs the moment the promise is created and the fallback
                     // wait runs with zero in-flight tools — reintroducing the
                     // self-cancel on this path (Bugbot #1c00624d).
-                    return await promptElicitationWithDialogs(request, questions, ui, signal);
+                    return await promptElicitationWithDialogs(request, questions, ui, formAbortController.signal);
                 }
                 if (Object.keys(interviewResult.answers).length === 0) {
                     // A system/host teardown (compaction, session_switch, true
@@ -1265,6 +1309,9 @@ export function createClaudeCodeElicitationHandler(ui) {
                 };
             }
             finally {
+                clearTimeout(expiryTimer);
+                signal.removeEventListener("abort", forwardSdkAbort);
+                activeAskUserQuestionElicitationTimeoutAborters.delete(abortExpiredForm);
                 markToolEnd(elicId);
                 markInteractiveElicitationEnd();
             }
@@ -2052,6 +2099,9 @@ async function pumpSdkMessages(model, context, options, stream) {
                                     // Push synthetic completion events with result attached so the
                                     // chat-controller can update pending ToolExecutionComponents.
                                     if (block.type === "toolCall") {
+                                        if (isAskUserQuestionsTimedOutResult(block, extResult)) {
+                                            abortActiveAskUserQuestionElicitationsForTimeout();
+                                        }
                                         if (suppressDuplicateUnavailable) {
                                             delete block.externalResult;
                                             stream.push({
@@ -2082,9 +2132,13 @@ async function pumpSdkMessages(model, context, options, stream) {
                                         emittedExternalToolResultIds.add(block.id);
                                     }
                                     else if (block.type === "serverToolUse") {
+                                        const toolCall = serverToolUseToToolCallLike(block);
+                                        if (isAskUserQuestionsTimedOutResult(toolCall, extResult)) {
+                                            abortActiveAskUserQuestionElicitationsForTimeout();
+                                        }
                                         try {
                                             await onExternalToolResult?.({
-                                                toolCall: serverToolUseToToolCallLike(block),
+                                                toolCall,
                                                 result: extResult,
                                             });
                                         }

package/dist/resources/extensions/gsd/artifact-verification.js

@@ -314,6 +314,19 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             try {
                 let taskIds = null;
                 let dbPrimary = false;
+                const planContent = readFileSync(absPath, "utf-8");
+                let parsedTaskIds = null;
+                const getParsedTaskIds = () => {
+                    if (parsedTaskIds)
+                        return parsedTaskIds;
+                    parsedTaskIds = parseLegacyPlan(planContent).tasks.map((t) => t.id);
+                    return parsedTaskIds;
+                };
+                const tasksBlockMatch = planContent.match(/<tasks>([\s\S]*?)<\/tasks>/i);
+                const tasksBlock = tasksBlockMatch?.[1] ?? "";
+                const hasEmbeddedTaskEntries = tasksBlock.length > 0 &&
+                    (/^\s*- \[[xX ]\] \*\*T\d+/m.test(tasksBlock) ||
+                        /^\s*#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(tasksBlock));
                 if (isDbAvailable()) {
                     const refreshed = refreshWorkflowDatabaseFromDisk();
                     if (refreshed) {
@@ -325,18 +338,17 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
                     }
                 }
                 if (!taskIds) {
-                    const planContent = readFileSync(absPath, "utf-8");
                     const hasCheckboxTask = /^\s*- \[[xX ]\] \*\*T\d+/m.test(planContent);
                     const hasHeadingTask = /^\s*#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
                     if (!hasCheckboxTask && !hasHeadingTask) {
                         logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
                         return false;
                     }
-                    const plan = parseLegacyPlan(planContent);
-                    if (plan.tasks.length > 0)
-                        taskIds = plan.tasks.map((t) => t.id);
+                    const parsedIds = getParsedTaskIds();
+                    if (parsedIds.length > 0)
+                        taskIds = parsedIds;
                 }
-                if (taskIds && taskIds.length > 0) {
+                if (taskIds && taskIds.length > 0 && !hasEmbeddedTaskEntries) {
                     const tasksDir = join(dirname(absPath), "tasks");
                     if (existsSync(tasksDir)) {
                         for (const tid of taskIds) {

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

@@ -37,62 +37,51 @@ export async function restorePreflightStashOrStop(ic, preflight, milestoneId) {
     return stopOnPostflightRecoveryNeeded(ic, result, milestoneId);
 }
 /**
- * Run a milestone merge surrounded by preflight stash + always-on postflight
- * pop. The previous code popped the stash only after a successful merge, which
- * leaked `gsd-preflight-stash:M00x:*` entries whenever `mergeAndExit` threw —
- * leaving the user's pre-merge working tree silently stashed away after a
- * merge-conflict or other merge error. This helper restores the stash on
- * every exit path, then surfaces the merge or stash failure (in priority
- * order) as the loop's stop reason.
+ * Run a milestone merge through Worktree Lifecycle's guarded merge option,
+ * which surrounds the inner merge with preflight stash + always-on postflight
+ * pop. The previous closeout code popped the stash only after a successful
+ * merge, which leaked `gsd-preflight-stash:M00x:*` entries whenever
+ * `mergeAndExit` threw — leaving the user's pre-merge working tree silently
+ * stashed away after a merge-conflict or other merge error. Lifecycle now
+ * restores the stash on every attempted merge path, then this adapter surfaces
+ * the merge or stash failure (in priority order) as the loop's stop reason.
  *
  * Returns a `break` action when auto-mode must stop, or `null` when the merge
  * succeeded and the stash (if any) was restored cleanly.
  */
 export async function _runMilestoneMergeWithStashRestore(ic, milestoneId, options = {}) {
     const { ctx, pi, s, deps } = ic;
-    const preflight = deps.preflightCleanRoot(s.originalBasePath || s.basePath, milestoneId, ctx.ui.notify.bind(ctx.ui));
-    if (preflight.blocked) {
-        const reason = preflight.blockedReason === "unmerged-conflicts"
+    const projectRoot = s.originalBasePath || s.basePath;
+    const mergeResult = deps.lifecycle.exitMilestone(milestoneId, {
+        merge: true,
+        guardedMerge: {
+            projectRoot,
+            preflightCleanRoot: deps.preflightCleanRoot,
+            postflightPopStash: deps.postflightPopStash,
+        },
+    }, ctx.ui);
+    if (mergeResult.ok) {
+        await markMilestoneMergedAndRebuild(s);
+        return null;
+    }
+    if (mergeResult.reason === "postflight-stash-restore-failed") {
+        await markMilestoneMergedAndRebuild(s);
+    }
+    if (mergeResult.reason === "preflight-dirty-overlap" || mergeResult.reason === "preflight-unmerged-conflicts") {
+        const reason = mergeResult.reason === "preflight-unmerged-conflicts"
             ? `Pre-merge unresolved Git conflicts block milestone ${milestoneId}`
             : `Pre-merge dirty working tree overlaps milestone ${milestoneId}`;
         await deps.stopAuto(ctx, pi, reason, {
             preserveCompletedMilestoneBranch: true,
             preserveCloseoutTranscript: options.preserveCloseoutTranscript,
         });
-        return {
-            action: "break",
-            reason: preflight.blockedReason === "unmerged-conflicts"
-                ? "preflight-unmerged-conflicts"
-                : "preflight-dirty-overlap",
-        };
-    }
-    let mergeError = null;
-    const exitResult = deps.lifecycle.exitMilestone(milestoneId, { merge: true }, ctx.ui);
-    if (exitResult.ok) {
-        s.milestoneMergedInPhases = true;
-        try {
-            const projectRoot = s.originalBasePath || s.canonicalProjectRoot || s.basePath;
-            const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.js");
-            await rebuildMarkdownProjectionsFromDb(projectRoot);
-        }
-        catch (err) {
-            logWarning("engine", `markdown projection rebuild after milestone merge failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    else {
-        mergeError = exitResult.cause ?? new Error(`exit ${exitResult.reason}`);
-    }
-    // Always attempt to restore the stashed working tree, even on merge error.
-    // postflightPopStash itself does not throw; failures surface via the
-    // PostflightResult.needsManualRecovery flag.
-    let stashResult = null;
-    if (preflight.stashPushed) {
-        stashResult = deps.postflightPopStash(s.originalBasePath || s.basePath, milestoneId, preflight.stashMarker, ctx.ui.notify.bind(ctx.ui));
+        return { action: "break", reason: mergeResult.reason };
     }
     // Merge failure takes priority over stash recovery — the merge is the
     // authoritative gate. If the stash also needed manual recovery, the user
     // already saw the postflightPopStash notify above.
-    if (mergeError) {
+    if (mergeResult.reason === "merge-conflict") {
+        const mergeError = mergeResult.cause;
         if (mergeError instanceof MergeConflictError) {
             // A merge conflict is a recoverable human checkpoint, not an
             // infrastructure failure — the user resolves the conflict and runs
@@ -109,6 +98,9 @@ export async function _runMilestoneMergeWithStashRestore(ic, milestoneId, option
             });
             return { action: "break", reason: "merge-conflict" };
         }
+    }
+    if (mergeResult.reason === "merge-failed" || mergeResult.reason === "merge-conflict") {
+        const mergeError = mergeResult.cause;
         logError("engine", "Milestone merge failed with non-conflict error", {
             milestone: milestoneId,
             error: String(mergeError),
@@ -125,11 +117,22 @@ export async function _runMilestoneMergeWithStashRestore(ic, milestoneId, option
         });
         return { action: "break", reason: "merge-failed" };
     }
-    if (stashResult) {
-        return stopOnPostflightRecoveryNeeded(ic, stashResult, milestoneId);
+    if (mergeResult.postflight) {
+        return stopOnPostflightRecoveryNeeded(ic, mergeResult.postflight, milestoneId);
     }
     return null;
 }
+async function markMilestoneMergedAndRebuild(s) {
+    s.milestoneMergedInPhases = true;
+    try {
+        const rebuildBasePath = s.originalBasePath || s.canonicalProjectRoot || s.basePath;
+        const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.js");
+        await rebuildMarkdownProjectionsFromDb(rebuildBasePath);
+    }
+    catch (err) {
+        logWarning("engine", `markdown projection rebuild after milestone merge failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 export async function _runMilestoneMergeOnceWithStashRestore(ic, milestoneId, options = {}) {
     if (ic.s.milestoneMergedInPhases) {
         debugLog("autoLoop", {

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

@@ -280,6 +280,15 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
                 files: leak.files.map((file) => ({ path: file.path, status: file.status })),
             });
             ctx.ui.notify(message, "error");
+            try {
+                deps.checkpointWorkflowDatabase?.();
+            }
+            catch (err) {
+                debugLog("autoLoop", {
+                    phase: "root-write-leak-checkpoint-failed",
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
             await deps.stopAuto(ctx, pi, "Root-write leak during isolated auto-mode", {
                 preserveCompletedMilestoneBranch: true,
             });

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

@@ -560,7 +560,7 @@ export class AutoOrchestrator {
                 return new GitServiceImpl(basePath, gitConfig);
             },
             worktreeProjection: new WorktreeStateProjection(),
-            mergeMilestoneToMain: createMilestoneMergeTransaction(mergeMilestoneToMain),
+            mergeMilestone: createMilestoneMergeTransaction(mergeMilestoneToMain),
         });
     }
     rebuildScope(rawPath, milestoneId) {

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

@@ -6,7 +6,7 @@ import { debugLog } from "../debug-logger.js";
 import { logWarning } from "../workflow-logger.js";
 import { resolveAutoSupervisorConfig } from "../preferences.js";
 import { readUnitRuntimeRecord } from "../unit-runtime.js";
-import { consumeAutoWakeup } from "./schedule-wakeup.js";
+import { clearAutoWakeup, consumeAutoWakeup } from "./schedule-wakeup.js";
 import { applyUnitSkillVisibility } from "../skill-scope.js";
 const UNIT_FAILSAFE_BUFFER_MS = 30_000;
 const UNIT_FAILSAFE_RECHECK_MS = 30_000;
@@ -192,7 +192,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const UNIT_HARD_TIMEOUT_MS = Math.max(UNIT_FAILSAFE_BUFFER_MS, ((supervisor.hard_timeout_minutes ?? 30) * 60 * 1000) + UNIT_FAILSAFE_BUFFER_MS);
     const freshProgressMs = Math.max(UNIT_FAILSAFE_BUFFER_MS, ((supervisor.idle_timeout_minutes ?? 10) * 60 * 1000) + UNIT_FAILSAFE_BUFFER_MS);
     let unitTimeoutHandle;
-    let result;
+    let result = { status: "cancelled" };
     try {
         const awaitAgentEndWithTimeout = (agentEndPromise) => {
             const timeoutResult = new Promise((resolve) => {
@@ -297,6 +297,9 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     finally {
         if (unitTimeoutHandle)
             clearTimeout(unitTimeoutHandle);
+        if (result.status !== "completed") {
+            clearAutoWakeup(s.basePath, unitType, unitId);
+        }
         ctx.ui.setWorkingMessage?.(undefined);
         setVisibleSkills?.(undefined);
     }

package/dist/resources/extensions/gsd/auto/schedule-wakeup.js

@@ -13,6 +13,9 @@ export function consumeAutoWakeup(basePath, unitType, unitId) {
     pendingWakeups.delete(key);
     return wakeup;
 }
+export function clearAutoWakeup(basePath, unitType, unitId) {
+    pendingWakeups.delete(wakeupKey(basePath, unitType, unitId));
+}
 export function _resetAutoWakeupsForTest() {
     pendingWakeups.clear();
 }

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

@@ -68,7 +68,7 @@ import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { updateProgressWidget as _updateProgressWidget, setCompletionProgressWidget, setAutoOutcomeWidget, setAutoActiveStatus, updateSliceProgressCache, clearSliceProgressCache, unitVerb, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
 import { isDbAvailable, getMilestone, getMilestoneSlices, } from "./gsd-db.js";
-import { closeWorkflowDatabase } from "./db-workspace.js";
+import { checkpointWorkflowDatabase, closeWorkflowDatabase } from "./db-workspace.js";
 import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
 import { writeUnitRuntimeRecord } from "./unit-runtime.js";
 import { countPendingCaptures } from "./captures.js";
@@ -1102,6 +1102,12 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
     const installTerminalCloseoutOutcome = completionStopRequested && preserveCloseoutTranscript;
     const preserveCompletionSurface = completionStopRequested || preserveCloseoutTranscript;
     s.completionStopInProgress = preserveCompletionSurface;
+    try {
+        checkpointWorkflowDatabase();
+    }
+    catch (e) {
+        debugLog("stop-checkpoint-failed", { error: e instanceof Error ? e.message : String(e) });
+    }
     playNotificationBell("stop", loadedPreferences?.notifications);
     // #4764 — telemetry: record the exit reason, isolation mode, whether an auto
     // worktree was active, and whether the current milestone was merged before
@@ -1732,7 +1738,7 @@ export function buildWorktreeLifecycleDeps() {
     //   C4 (#5627) — GitServiceImpl constructor → gitServiceFactory
     //
     // Final WorktreeLifecycleDeps shape: 3 fields (gitServiceFactory,
-    // worktreeProjection, mergeMilestoneToMain transaction runner). Down from 18 at slice-7
+    // worktreeProjection, mergeMilestone transaction runner). Down from 18 at slice-7
     // closure.
     return {
         gitServiceFactory: (basePath) => {
@@ -1740,7 +1746,7 @@ export function buildWorktreeLifecycleDeps() {
             return new GitServiceImpl(basePath, gitConfig);
         },
         worktreeProjection: new WorktreeStateProjection(),
-        mergeMilestoneToMain: createMilestoneMergeTransaction(mergeMilestoneToMain),
+        mergeMilestone: createMilestoneMergeTransaction(mergeMilestoneToMain),
     };
 }
 function buildLifecycle() {
@@ -1783,6 +1789,7 @@ function buildLoopDeps(pi, ctx) {
         stopAuto,
         pauseAuto,
         clearUnitTimeout,
+        checkpointWorkflowDatabase,
         updateProgressWidget,
         ...cmux,
         handleLostSessionLock: (ctx, lockStatus) => {

package/dist/resources/extensions/gsd/bootstrap/schedule-wakeup-tool.js

@@ -3,19 +3,63 @@
 import { Type } from "@sinclair/typebox";
 import { getAutoRuntimeSnapshot } from "../auto-runtime-state.js";
 import { scheduleAutoWakeup } from "../auto/schedule-wakeup.js";
+import { logWarning } from "../workflow-logger.js";
 import { resolveCtxCwd } from "./dynamic-tools.js";
 const MAX_WAKEUP_DELAY_SECONDS = 24 * 60 * 60;
+const INTERACTIVE_WAKEUP_CUSTOM_TYPE = "gsd-schedule-wakeup";
+// One pending interactive wakeup per session, keyed by base path — the same
+// scoping auto-mode uses for its wakeup map (see `wakeupKey`). Re-arming cancels
+// only that session's prior timer, so repeated polling never stacks overlapping
+// wakeups, and concurrent projects in one host process don't cancel each other.
+const pendingInteractiveWakeups = new Map();
+function scheduleInteractiveWakeup(pi, key, delaySeconds, prompt, reason) {
+    const existing = pendingInteractiveWakeups.get(key);
+    if (existing)
+        clearTimeout(existing);
+    const handle = setTimeout(() => {
+        if (pendingInteractiveWakeups.get(key) === handle) {
+            pendingInteractiveWakeups.delete(key);
+        }
+        try {
+            void Promise.resolve(pi.sendMessage({
+                customType: INTERACTIVE_WAKEUP_CUSTOM_TYPE,
+                content: prompt,
+                display: true,
+                details: { delaySeconds, reason },
+            }, { triggerTurn: true })).catch((error) => {
+                logWarning("bootstrap", `ScheduleWakeup interactive dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }
+        catch (error) {
+            logWarning("bootstrap", `ScheduleWakeup interactive dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }, delaySeconds * 1000);
+    pendingInteractiveWakeups.set(key, handle);
+    if (typeof handle === "object" &&
+        handle !== null &&
+        "unref" in handle &&
+        typeof handle.unref === "function") {
+        handle.unref();
+    }
+}
+export function _resetInteractiveWakeupsForTest() {
+    for (const handle of pendingInteractiveWakeups.values()) {
+        clearTimeout(handle);
+    }
+    pendingInteractiveWakeups.clear();
+}
 export function registerScheduleWakeupTool(pi) {
     pi.registerTool({
         name: "ScheduleWakeup",
         label: "Schedule Wakeup",
-        description: "In GSD auto-mode, pause the current unit and continue the same session after a delay. " +
-            "Use this for long external processes that need polling without ending the unit as no-artifact.",
-        promptSnippet: "Schedule a same-session auto-mode wakeup after a delay.",
+        description: "Schedule a delayed continuation turn. In GSD auto-mode, continue the current unit in the same session; " +
+            "outside auto-mode, start a new triggered turn with the supplied wakeup prompt.",
+        promptSnippet: "Schedule a wakeup prompt after a delay.",
         promptGuidelines: [
             "Use ScheduleWakeup at the end of an execute-task turn when waiting for a long external process.",
             "Include a prompt that says exactly what external state to check next and what artifact to write when done.",
             "Re-arm ScheduleWakeup on each polling turn if the external process is still running.",
+            "Outside auto-mode, use ScheduleWakeup when the user asks you to check back or poll later.",
         ],
         parameters: Type.Object({
             delaySeconds: Type.Number({
@@ -34,22 +78,27 @@ export function registerScheduleWakeupTool(pi) {
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
             const dash = getAutoRuntimeSnapshot();
             const currentUnit = dash.currentUnit;
-            const basePath = dash.basePath || resolveCtxCwd(ctx);
+            const delaySeconds = Math.max(1, Math.min(MAX_WAKEUP_DELAY_SECONDS, Math.floor(params.delaySeconds)));
+            const reason = params.reason ?? "";
             if (!dash.active || !currentUnit) {
+                const interactiveKey = dash.basePath || resolveCtxCwd(ctx);
+                scheduleInteractiveWakeup(pi, interactiveKey, delaySeconds, params.prompt, reason);
                 return {
-                    content: [{ type: "text", text: "ScheduleWakeup is only available during an active GSD auto-mode unit." }],
-                    details: { operation: "schedule_wakeup", error: "auto_mode_inactive" },
-                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: `Wakeup scheduled for ${delaySeconds}s. GSD will start a new turn with the wakeup prompt.`,
+                        }],
+                    details: { operation: "schedule_wakeup", delaySeconds, mode: "interactive" },
                 };
             }
-            const delaySeconds = Math.max(1, Math.min(MAX_WAKEUP_DELAY_SECONDS, Math.floor(params.delaySeconds)));
+            const basePath = dash.basePath || resolveCtxCwd(ctx);
             scheduleAutoWakeup({
                 basePath,
                 unitType: currentUnit.type,
                 unitId: currentUnit.id,
                 delayMs: delaySeconds * 1000,
                 prompt: params.prompt,
-                reason: params.reason ?? "",
+                reason,
                 createdAt: Date.now(),
             });
             return {