@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.4fb2d460

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

@@ -51,10 +51,16 @@ import { atomicWriteSync } from "./atomic-write.js";
 import { captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, } from "./worktree.js";
 import { GitServiceImpl } from "./git-service.js";
 import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
-import { createAutoWorktree, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, checkResourcesStale, escapeStaleWorktree, } from "./auto-worktree.js";
+import { autoWorktreeBranch } from "./auto-worktree-branch-lifecycle.js";
+import { createAutoWorktree } from "./auto-worktree-creation.js";
+import { isInAutoWorktree } from "./auto-worktree-entry.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
+import { checkResourcesStale } from "./auto-worktree-resource-version.js";
+import { escapeStaleWorktree } from "./auto-worktree-runtime-cleanup.js";
+import { teardownAutoWorktree } from "./auto-worktree-teardown.js";
 import { pruneQueueOrder } from "./queue-order.js";
 import { startCommandPolling as _startCommandPolling, isRemoteConfigured } from "../remote-questions/manager.js";
-import { createMilestoneMergeTransaction } from "./milestone-merge-transaction.js";
+import { createDefaultMilestoneMergeTransaction } from "./milestone-merge-transaction.js";
 import { debugLog, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
 import { reconcileMergeState, verifyExpectedArtifact, } from "./auto-recovery.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
@@ -68,7 +74,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";
@@ -651,6 +657,11 @@ export function stopAutoRemote(projectRoot) {
  * The normal stop path stays SIGTERM-only so cooperative sessions can clean up;
  * this path is only for the explicit "Force start" action.
  */
+// Grace window between SIGTERM and SIGKILL so the target can run its cleanup
+// handler (lock release, DB snapshot flush, worktree teardown). Polled so a
+// process that exits early is not made to wait the full window.
+const FORCE_STOP_GRACE_MS = 3000;
+const FORCE_STOP_POLL_MS = 100;
 export function forceStopAutoRemote(projectRoot) {
     const lock = readCrashLock(projectRoot);
     if (!lock)
@@ -665,6 +676,14 @@ export function forceStopAutoRemote(projectRoot) {
     }
     try {
         process.kill(lock.pid, "SIGTERM");
+        // Poll for graceful exit before escalating. Synchronous sleep keeps this
+        // function sync for its callers (Atomics.wait times out with no notify).
+        const deadline = Date.now() + FORCE_STOP_GRACE_MS;
+        while (Date.now() < deadline) {
+            if (!isLockProcessAlive(lock))
+                break;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, FORCE_STOP_POLL_MS);
+        }
         if (isLockProcessAlive(lock)) {
             process.kill(lock.pid, "SIGKILL");
         }
@@ -1089,6 +1108,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
@@ -1719,7 +1744,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) => {
@@ -1727,7 +1752,7 @@ export function buildWorktreeLifecycleDeps() {
             return new GitServiceImpl(basePath, gitConfig);
         },
         worktreeProjection: new WorktreeStateProjection(),
-        mergeMilestoneToMain: createMilestoneMergeTransaction(mergeMilestoneToMain),
+        mergeMilestone: createDefaultMilestoneMergeTransaction(),
     };
 }
 function buildLifecycle() {
@@ -1770,6 +1795,7 @@ function buildLoopDeps(pi, ctx) {
         stopAuto,
         pauseAuto,
         clearUnitTimeout,
+        checkpointWorkflowDatabase,
         updateProgressWidget,
         ...cmux,
         handleLostSessionLock: (ctx, lockStatus) => {

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

@@ -674,12 +674,14 @@ export function registerDbTools(pi) {
                 inputs: Type.Array(Type.String(), { description: "Array<string> of input files or references; pass [\"path\"] or [], never a single string" }),
                 expectedOutput: Type.Array(Type.String(), { description: "Array<string> of files this task creates or overwrites; pass [\"path\"] or [], never prose or a single string" }),
                 observabilityImpact: Type.Optional(Type.String({ description: "Task observability impact" })),
+                targetRepositories: Type.Optional(Type.Array(Type.String(), { description: "Repository id(s) this task touches (parent workspace); must match a Declared Repository. Omit for single-repo projects." })),
             }), { description: "Optional full task replacement for the slice. Omit for incremental planning, then call gsd_plan_task once per task." })),
             // ── Enrichment metadata (optional — defaults to empty) ────────────
             successCriteria: Type.Optional(Type.String({ description: "Slice success criteria block" })),
             proofLevel: Type.Optional(Type.String({ description: "Slice proof level" })),
             integrationClosure: Type.Optional(Type.String({ description: "Slice integration closure" })),
             observabilityImpact: Type.Optional(Type.String({ description: "Slice observability impact" })),
+            targetRepositories: Type.Optional(Type.Array(Type.String(), { description: "Slice-wide default repository id(s) (parent workspace); must match a Declared Repository. Omit for single-repo projects." })),
             // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
             actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
             triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'plan-phase complete')" })),
@@ -749,6 +751,7 @@ export function registerDbTools(pi) {
             inputs: Type.Array(Type.String(), { description: "Array<string> of input files or references; pass [\"path\"] or [], never a single string" }),
             expectedOutput: Type.Array(Type.String(), { description: "Array<string> of files this task creates or overwrites; pass [\"path\"] or [], never prose or a single string" }),
             observabilityImpact: Type.Optional(Type.String({ description: "Task observability impact" })),
+            targetRepositories: Type.Optional(Type.Array(Type.String(), { description: "Repository id(s) this task touches (parent workspace); must match a Declared Repository. Omit for single-repo projects." })),
             // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
             actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
             triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'plan-phase complete')" })),

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

@@ -6,7 +6,7 @@ import { join } from "node:path";
 import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@gsd/pi-coding-agent";
 import { logWarning } from "../workflow-logger.js";
 import { getWorkflowDatabaseStatus, openWorkflowDatabase, } from "../db-workspace.js";
-import { getAutoWorktreePath } from "../auto-worktree.js";
+import { getAutoWorktreePath } from "../auto-worktree-path-resolution.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { worktreesDirs } from "../worktree-placement.js";
 export function safeWorkspaceCwd() {

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

@@ -13,8 +13,9 @@ import { resolveManifest } from "../unit-context-manifest.js";
 import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from "../write-intercept.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
 import { clearAutoCompletionStopInProgress, clearToolInvocationError, getAutoRuntimeSnapshot, getSourceObservationStore, isAutoActive, isAutoCompletionStopInProgress, isAutoPaused, isInteractiveElicitationInFlight, markToolEnd, markToolStart, recordAutoToolSurfaceSnapshot, recordToolInvocationError, } from "../auto-runtime-state.js";
+import { isDeterministicPolicyError, isQueuedUserMessageSkip, isToolInvocationError, isToolUnavailableError, } from "../auto-tool-tracking.js";
 import { applyProviderPayloadPolicy } from "../provider-payload-policy.js";
-import { checkToolCallLoop, recordToolCallLoopMutation, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
+import { checkToolCallLoop, configureToolCallLoopGuard, recordToolCallLoopMutation, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { MINIMAL_AUTO_BASE_TOOL_NAMES } from "./core-session-tools.js";
 import { maybePauseAutoForApprovalGate, resetPendingGatePauseGuard } from "./pending-gate-pause.js";
 import { saveActivityLog } from "../activity-log.js";
@@ -44,7 +45,14 @@ import { clearPendingAutoStart } from "../pending-auto-start.js";
 import { resolveWorkflowToolBasePath } from "./dynamic-tools.js";
 import { getRequiredWorkflowToolsForUnit } from "../unit-tool-contracts.js";
 import { flushAllManifests } from "../workflow-manifest.js";
+import { recordUnitHarnessAbort } from "../unit-runtime.js";
 let approvalQuestionAbortInFlight = false;
+function recordCurrentUnitHarnessAbort(abort) {
+    const dash = getAutoRuntimeSnapshot();
+    if (!dash.active || !dash.basePath || !dash.currentUnit)
+        return;
+    recordUnitHarnessAbort(dash.basePath, dash.currentUnit.type, dash.currentUnit.id, dash.currentUnit.startedAt, abort);
+}
 async function loadWelcomeScreenModule() {
     const candidates = [];
     const gsdBinPath = process.env.GSD_BIN_PATH;
@@ -160,9 +168,23 @@ const WORKFLOW_GSD_TOOL_NAMES = [
     ...MINIMAL_GSD_TOOL_NAMES,
     ...Object.values(AUTO_UNIT_SCOPED_TOOLS).flat(),
 ].filter(isGsdManagedTool);
+const WORKFLOW_ONLY_AUTO_BASE_TOOL_NAMES = [
+    "find",
+    "glob",
+    "grep",
+    "ls",
+    "read",
+    "subagent",
+];
 function isGsdManagedTool(name) {
     return name.startsWith("gsd_") || name === "memory_query" || name === "capture_thought" || name === "gsd_graph";
 }
+function autoBaseToolNamesForUnit(unitType) {
+    const manifest = unitType ? resolveManifest(unitType) : null;
+    return manifest?.tools.mode === "workflow-only"
+        ? WORKFLOW_ONLY_AUTO_BASE_TOOL_NAMES
+        : MINIMAL_AUTO_BASE_TOOL_NAMES;
+}
 /**
  * Resolves requested tool names against active tools using exact and MCP-scoped matches.
  *
@@ -213,7 +235,7 @@ export function buildMinimalAutoGsdToolSet(activeToolNames, unitType, registered
         return buildRunUatGsdToolSet(activeToolNames, registeredToolNames);
     }
     const unitTools = unitType ? AUTO_UNIT_SCOPED_TOOLS[unitType] ?? [] : [];
-    const autoBaseTools = new Set(MINIMAL_AUTO_BASE_TOOL_NAMES);
+    const autoBaseTools = new Set(autoBaseToolNamesForUnit(unitType));
     const availableBaseTools = registeredToolNames.filter((name) => autoBaseTools.has(name));
     const preserved = [...new Set([
             ...activeToolNames.filter((name) => autoBaseTools.has(name)),
@@ -410,6 +432,22 @@ async function applyCompactionThresholdOverride(ctx) {
         ctx.setCompactionThresholdOverride?.(0.6);
     }
 }
+/**
+ * Apply user-tunable tool-call loop guard thresholds (#1198) from GSD
+ * preferences plus GSD_TOOL_LOOP_* env overrides. Runs at session boundaries
+ * so both interactive sessions and `/gsd auto` pick up the configuration.
+ * Non-fatal: falls back to built-in defaults when preferences cannot be loaded.
+ */
+async function applyToolCallLoopGuardConfig(basePath) {
+    try {
+        const { loadEffectiveGSDPreferences } = await import("../preferences.js");
+        const prefs = loadEffectiveGSDPreferences(basePath);
+        configureToolCallLoopGuard(prefs?.preferences.tool_call_loop_guard);
+    }
+    catch {
+        configureToolCallLoopGuard(null);
+    }
+}
 function clearDeferredApprovalGate(basePath) {
     if (!basePath) {
         deferredApprovalGates.clear();
@@ -446,6 +484,75 @@ function formatLoopGuardBlockReason(reason) {
         return reason;
     return LOOP_GUARD_INTERACTIVE_INSTRUCTIONS.reduce((formatted, instruction) => formatted.replace(instruction, LOOP_GUARD_AUTO_INSTRUCTION), reason);
 }
+function isGateResultPersistenceTool(toolName) {
+    return toolName === "gsd_save_gate_result" || toolName === "gsd_uat_result_save";
+}
+function resultDetails(result) {
+    if (!result || typeof result !== "object")
+        return {};
+    const details = result.details;
+    return details && typeof details === "object" ? details : {};
+}
+function isAbortedExecutionToolResult(toolName, result) {
+    if (toolName !== "gsd_exec" && toolName !== "gsd_uat_exec")
+        return false;
+    const details = resultDetails(result);
+    return details.aborted === true || details.force_resolved === true || details.timed_out === true;
+}
+function isRetryableHarnessToolError(toolName, result, errorText) {
+    if (isGateResultPersistenceTool(toolName))
+        return false;
+    if (isDeterministicPolicyError(errorText))
+        return false;
+    if (toolName === "gsd_exec" || toolName === "gsd_uat_exec") {
+        if (isAbortedExecutionToolResult(toolName, result))
+            return true;
+        if (isToolUnavailableError(errorText))
+            return true;
+        if (isQueuedUserMessageSkip(errorText))
+            return true;
+        return isToolInvocationError(errorText);
+    }
+    if (isToolUnavailableError(errorText))
+        return true;
+    if (isQueuedUserMessageSkip(errorText))
+        return true;
+    return false;
+}
+function recordRetryableHarnessToolError(toolName, result, errorText) {
+    if (!isRetryableHarnessToolError(toolName, result, errorText))
+        return;
+    recordCurrentUnitHarnessAbort({
+        kind: "tool-error",
+        reason: errorText || "Tool execution failed before the unit could complete its gate evaluation.",
+        toolName,
+    });
+}
+function recordRetryableTurnAbort(event) {
+    const origin = typeof event.abortOrigin === "string" ? event.abortOrigin : undefined;
+    if (origin === "session-transition")
+        return;
+    const messages = Array.isArray(event.messages) ? event.messages : [];
+    const lastMsg = messages[messages.length - 1];
+    const stopReason = lastMsg && typeof lastMsg === "object"
+        ? lastMsg.stopReason
+        : undefined;
+    if (stopReason !== "aborted" && stopReason !== "error")
+        return;
+    const errorMessage = lastMsg && typeof lastMsg === "object"
+        ? lastMsg.errorMessage
+        : undefined;
+    const reason = [
+        "Agent turn aborted before the unit could complete its gate evaluation.",
+        origin ? `origin=${origin}` : undefined,
+        typeof stopReason === "string" ? `stopReason=${stopReason}` : undefined,
+        typeof errorMessage === "string" && errorMessage.trim() ? `error=${errorMessage.trim()}` : undefined,
+    ].filter(Boolean).join(" ");
+    recordCurrentUnitHarnessAbort({
+        kind: "turn-abort",
+        reason,
+    });
+}
 function beginSourceObservationStoreForCurrentUnit(ctx) {
     if (!isAutoActive())
         return null;
@@ -688,6 +795,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
         resetWriteGateState(basePath);
         resetToolCallLoopGuard();
+        await applyToolCallLoopGuardConfig(basePath);
         approvalQuestionAbortInFlight = false;
         clearDeferredApprovalGate();
         await resetAskUserQuestionsTurnCache();
@@ -696,8 +804,8 @@ export function registerHooks(pi, ecosystemHandlers) {
         await applyCompactionThresholdOverride(ctx);
         await prepareWorkflowMcpForHookContext(ctx, basePath);
         // Migrate legacy .gsd/milestones/ to flat-phase .gsd/phases/ when detected.
-        // Best-effort — never blocks session startup. Skipped inside auto-worktrees
-        // (migration already ran on the project root before the worktree was created).
+        // Fail closed on migration errors: resolvers assume flat-phase paths after
+        // startup, so continuing with nested disk state corrupts later checks.
         try {
             const { isInAutoWorktree } = await import("../auto-worktree.js");
             if (!isInAutoWorktree(basePath)) {
@@ -710,10 +818,18 @@ export function registerHooks(pi, ecosystemHandlers) {
                         await migrateToFlatPhase(basePath);
                     }
                     else {
-                        safetyLogWarning("bootstrap", "flat-phase migration deferred: legacy .gsd/milestones/ layout detected but the workflow database could not be opened — will retry on next session");
+                        safetyLogWarning("bootstrap", "flat-phase migration required: legacy .gsd/milestones/ layout detected but the workflow database could not be opened — fix database access before starting GSD");
+                        throw new Error("flat-phase migration required but the workflow database could not be opened; fix database access before starting GSD");
                     }
                 }
             }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            safetyLogWarning("bootstrap", `flat-phase migration failed: ${message}`);
+            throw new Error(`flat-phase migration failed: ${message}`);
+        }
+        try {
             const projectRoot = resolveWorktreeProjectRoot(basePath);
             const { pruneStaleFlatPhaseBackups } = await import("../flat-phase-migration.js");
             const pruned = pruneStaleFlatPhaseBackups(projectRoot);
@@ -722,7 +838,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             }
         }
         catch (err) {
-            safetyLogWarning("bootstrap", `flat-phase migration: ${err instanceof Error ? err.message : String(err)}`);
+            safetyLogWarning("bootstrap", `flat-phase backup pruning: ${err instanceof Error ? err.message : String(err)}`);
         }
         // Apply show_token_cost preference (#1515)
         try {
@@ -765,6 +881,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         initSessionNotifications(ctx);
         resetWriteGateState(basePath);
         resetToolCallLoopGuard();
+        await applyToolCallLoopGuardConfig(basePath);
         clearDeferredApprovalGate();
         await resetAskUserQuestionsTurnCache();
         clearDiscussionFlowState(basePath);
@@ -871,6 +988,7 @@ export function registerHooks(pi, ecosystemHandlers) {
     });
     pi.on("agent_end", async (event, ctx) => {
         approvalQuestionAbortInFlight = false;
+        recordRetryableTurnAbort(event);
         resetToolCallLoopGuard();
         resetPendingGatePauseGuard();
         await resetAskUserQuestionsTurnCache();
@@ -1077,6 +1195,12 @@ export function registerHooks(pi, ecosystemHandlers) {
         // ── Loop guard: block repeated identical tool calls ──
         const loopCheck = checkToolCallLoop(toolName, event.input);
         if (loopCheck.block) {
+            recordCurrentUnitHarnessAbort({
+                kind: "tool-loop-guard",
+                reason: loopCheck.reason ?? "Tool-call loop guard blocked a repeated tool call.",
+                toolName,
+                count: loopCheck.count,
+            });
             return { block: true, reason: formatLoopGuardBlockReason(loopCheck.reason) };
         }
         const deferredGateGuard = shouldBlockDeferredApprovalTool(toolName, event.input, discussionBasePath);
@@ -1283,7 +1407,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             }
         }
         if (!event.isError) {
-            recordToolCallLoopMutation(toolName);
+            recordToolCallLoopMutation(toolName, event.details);
             refreshSourceObservationAfterMutation(toolName, event.input, ctx);
             clearSourceObservationsAfterShell(toolName);
         }
@@ -1299,6 +1423,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             // Let recordToolInvocationError classify the failure so non-gsd_ harness
             // errors and deterministic policy rejections are handled consistently.
             recordToolInvocationError(event.toolName, errorText);
+            recordRetryableHarnessToolError(toolName, resultPayload, errorText);
         }
         else if (isAutoActive()) {
             clearToolInvocationError();
@@ -1466,6 +1591,7 @@ export function registerHooks(pi, ecosystemHandlers) {
     // for every finalized tool call on every engine, so error classification
     // and evidence persistence here cover external engines that skip tool_result.
     pi.on("tool_execution_end", async (event) => {
+        const toolName = canonicalToolName(event.toolName);
         markToolEnd(event.toolCallId);
         // #2883/#4974: Capture deterministic invocation/policy errors
         // so postUnitPreVerification can break the retry loop instead of re-dispatching.
@@ -1476,6 +1602,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             // Let recordToolInvocationError classify the failure so non-gsd_ harness
             // errors and deterministic policy rejections are handled consistently.
             recordToolInvocationError(event.toolName, errorText);
+            recordRetryableHarnessToolError(toolName, event.result, errorText);
         }
         else if (isAutoActive()) {
             clearToolInvocationError();

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 {

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -11,7 +11,7 @@ import { resolveModelWithFallbacksForUnit } from "../preferences-models.js";
 import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile } from "../paths.js";
 import { extractIntroAndRules } from "../knowledge-parser.js";
 import { ensureCodebaseMapFresh, readCodebaseMap } from "../codebase-generator.js";
-import { getActiveAutoWorktreeContext } from "../auto-worktree.js";
+import { getActiveAutoWorktreeContext } from "../auto-worktree-session-registry.js";
 import { getActiveWorktreeName, getWorktreeOriginalCwd } from "../worktree-session-state.js";
 import { deriveState } from "../state.js";
 import { formatOverridesSection, formatShortcut, loadActiveOverrides, loadFile, parseContinue, parseSummary } from "../files.js";