@opengsd/gsd-pi 1.1.1-dev.a5a2de8 → 1.1.1-dev.b2556262

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

@@ -41,3 +41,6 @@ export function clearToolInvocationError() {
         return;
     autoSession.lastToolInvocationError = null;
 }
+export function getSourceObservationStore() {
+    return autoSession.sourceObservations;
+}

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

@@ -1208,7 +1208,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         s.autoStartTime = Date.now();
         s.resourceVersionOnStart = readResourceVersion();
         s.pendingQuickTasks = [];
-        s.currentUnit = null;
+        s.clearCurrentUnit();
         s.currentMilestoneId ??=
             strandedRecoveryAction?.milestoneId ??
                 (deepProjectStagePending ? null : state.activeMilestone?.id ?? null);

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

@@ -104,6 +104,14 @@ export function startUnitSupervision(sctx) {
     const softTimeoutMs = supervisionTimeouts.softTimeoutMs;
     const idleTimeoutMs = supervisionTimeouts.idleTimeoutMs;
     const hardTimeoutMs = supervisionTimeouts.hardTimeoutMs;
+    // A single hung tool gets its own short budget, NOT the general idle window:
+    // a long-but-progressing session is not idle, but a tool stuck for minutes
+    // is. Falls back to the idle window only if misconfigured to zero. The
+    // hung-tool budget is intentionally not scaled by task estimate — a stuck
+    // tool call is stuck regardless of how long the overall task should take.
+    const stalledToolTimeoutMs = (supervisor.stalled_tool_timeout_minutes ?? 0) > 0
+        ? supervisor.stalled_tool_timeout_minutes * 60 * 1000
+        : idleTimeoutMs;
     // ── 1. Soft timeout warning ──
     s.wrapupWarningHandle = setTimeout(() => {
         s.wrapupWarningHandle = null;
@@ -144,10 +152,12 @@ export function startUnitSupervision(sctx) {
             const runtime = readUnitRuntimeRecord(s.basePath, unitType, unitId);
             if (!runtime)
                 return;
-            if (Date.now() - runtime.lastProgressAt < idleTimeoutMs)
-                return;
-            // Agent has tool calls currently executing — not idle, just waiting.
-            // But only suppress recovery if the tool started recently.
+            // In-flight tool handling runs on its own dedicated hung-tool budget,
+            // independent of the general idle gate below, so a genuinely stuck tool
+            // is caught in minutes instead of waiting out the (typically much longer)
+            // idle window (#2527, follow-up). A tool actively executing within budget
+            // is real progress, so refreshing lastProgressAt here also keeps the idle
+            // gate from firing during legitimate long-running tool calls.
             let stalledToolDetected = false;
             if (getInFlightToolCount() > 0) {
                 // User-interactive tools (ask_user_questions, secure_env_collect) block
@@ -161,21 +171,25 @@ export function startUnitSupervision(sctx) {
                 }
                 const oldestStart = getOldestInFlightToolStart();
                 const toolAgeMs = Date.now() - oldestStart;
-                if (toolAgeMs < idleTimeoutMs) {
+                if (toolAgeMs < stalledToolTimeoutMs) {
                     writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
                         lastProgressAt: Date.now(),
                         lastProgressKind: "tool-in-flight",
                     });
                     return;
                 }
-                // Tool has been in-flight longer than idle timeout — treat as hung.
-                // Clear the stale entries so subsequent ticks don't re-detect them,
-                // and set the flag so the filesystem-activity check below does not
-                // override the stall verdict (#2527).
+                // Tool has been in-flight longer than the hung-tool budget — treat as
+                // hung. Clear the stale entries so subsequent ticks don't re-detect
+                // them, and set the flag so the idle gate and filesystem-activity check
+                // below do not override the stall verdict (#2527).
                 stalledToolDetected = true;
                 clearInFlightTools();
-                ctx.ui.notify(`Stalled tool detected: a tool has been in-flight for ${Math.round(toolAgeMs / 60000)}min. Treating as hung — attempting idle recovery.`, "warning");
+                ctx.ui.notify(`Stalled tool detected: a tool has been in-flight for ${Math.round(toolAgeMs / 60000)}min (budget ${Math.round(stalledToolTimeoutMs / 60000)}min). Treating as hung — attempting idle recovery.`, "warning");
             }
+            // No hung tool — apply the general idle gate. A unit that has made
+            // meaningful progress within the idle window is not idle yet.
+            if (!stalledToolDetected && Date.now() - runtime.lastProgressAt < idleTimeoutMs)
+                return;
             // Check if the agent is producing work on disk.
             // Skip this when a stalled tool was just detected — filesystem changes
             // from earlier in the task should not override the stall verdict (#2527).

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

@@ -30,7 +30,7 @@ import { playNotificationBell, sendDesktopNotification } from "./notifications.j
 import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, resolveCompactionThresholdPercent, shouldRerootStepSessionForContext, } from "./auto-budget.js";
 import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, isQueuedUserMessageSkip, isDeterministicPolicyError, } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
-import { selectAndApplyModel, resolveModelId, clearToolBaseline } from "./auto-model-selection.js";
+import { selectAndApplyModel, resolveModelId, clearToolBaseline, getToolBaselineSnapshot } from "./auto-model-selection.js";
 import { resetRoutingHistory, recordOutcome } from "./routing-history.js";
 import { resetHookState, runPreDispatchHooks, restoreHookState, clearPersistedHookState, } from "./post-unit-hooks.js";
 import { runGSDDoctor, rebuildState } from "./doctor.js";
@@ -287,8 +287,24 @@ export function _synthesizePausedSessionRecoveryForTest(basePath, unitType, unit
 function handlePausedSessionResumeRecovery(basePath, state, notify) {
     if (!state.pausedSessionFile)
         return { skippedReplay: false };
-    const pausedRecoveryUnitType = state.currentUnit?.type ?? state.pausedUnitType ?? "unknown";
-    const pausedRecoveryUnitId = state.currentUnit?.id ?? state.pausedUnitId ?? "unknown";
+    const pausedRecoveryUnitType = state.currentUnit?.type ?? state.pausedUnitType ?? null;
+    const pausedRecoveryUnitId = state.currentUnit?.id ?? state.pausedUnitId ?? null;
+    // When the paused-session metadata never captured the unit identity (the
+    // pause happened between units, or the worker died before currentUnit was
+    // set), we have nothing to verify against and nothing correct to target. A
+    // replay synthesized with an "unknown" unit re-injects an unbounded,
+    // mis-identified tool-call blob into the fresh resume context — exactly the
+    // thrash that turns one stuck unit into several. Disk state has already been
+    // rebuilt (rebuildState + doctor) before this runs, so skip the replay and
+    // let the normal dispatcher recompute the next unit from disk.
+    if (!pausedRecoveryUnitType || !pausedRecoveryUnitId) {
+        state.pausedSessionFile = null;
+        state.pausedUnitType = null;
+        state.pausedUnitId = null;
+        state.pendingCrashRecovery = null;
+        notify("Paused session had no recorded unit identity. Skipping tool-call replay and resuming from disk state.");
+        return { skippedReplay: true };
+    }
     const completedPausedUnit = verifyExpectedArtifact(pausedRecoveryUnitType, pausedRecoveryUnitId, basePath);
     if (completedPausedUnit) {
         state.pausedSessionFile = null;
@@ -806,7 +822,7 @@ export async function cleanupAfterLoopExit(ctx) {
     const preserveStepSurface = s.preserveStepSurfaceAfterLoopExit;
     const preserveCompletionSurface = s.completionStopInProgress;
     const preservePausedSurface = s.paused;
-    s.currentUnit = null;
+    s.clearCurrentUnit();
     s.active = false;
     deactivateGSD();
     clearUnitTimeout();
@@ -831,12 +847,15 @@ export async function cleanupAfterLoopExit(ctx) {
     // A transient provider-error pause intentionally leaves the paused badge
     // visible so the user still has a resumable auto-mode signal on screen.
     if (!s.paused) {
-        if (preserveStepSurface) {
-            s.preserveStepSurfaceAfterLoopExit = false;
-        }
-        else if (preserveCompletionSurface) {
+        if (preserveCompletionSurface) {
             ctx.ui.setStatus("gsd-auto", undefined);
             s.completionStopInProgress = false;
+            if (preserveStepSurface) {
+                s.preserveStepSurfaceAfterLoopExit = false;
+            }
+        }
+        else if (preserveStepSurface) {
+            s.preserveStepSurfaceAfterLoopExit = false;
         }
         else {
             ctx.ui.setStatus("gsd-auto", undefined);
@@ -1476,7 +1495,7 @@ export async function pauseAuto(ctx, _pi, _errorContext, options = {}) {
             // Non-fatal — best-effort closeout on pause
             logWarning("engine", `unit closeout on pause failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
-        s.currentUnit = null;
+        s.clearCurrentUnit();
     }
     // Keep STATE.md aligned with the DB-backed state before releasing pause state.
     // Without this, an interrupted deep run can leave STATE.md saying "no active
@@ -1637,7 +1656,10 @@ export function createWiredDispatchAdapter(ctx, pi, dispatchBasePath, session) {
             const authMode = sessionProvider && typeof ctx.modelRegistry?.getProviderAuthMode === "function"
                 ? ctx.modelRegistry.getProviderAuthMode(sessionProvider)
                 : undefined;
-            const activeTools = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
+            // Use baseline snapshot — same reason as phases.ts:runDispatch: the live
+            // active set may be narrowed by the prior unit before selectAndApplyModel
+            // restores it, causing false transport-preflight failures (#477 follow-up).
+            const activeTools = getToolBaselineSnapshot(pi);
             // Mirrors runDispatch: deep-planning keeps approval gates in plain chat
             // because structured questions can be cancelled outside the chat turn on
             // some transports.
@@ -1678,6 +1700,9 @@ export function createWiredDispatchAdapter(ctx, pi, dispatchBasePath, session) {
                 sessionContextWindow,
                 sessionProvider,
                 modelRegistry,
+                activeTools,
+                sessionAuthMode: authMode,
+                sessionBaseUrl: ctx.model?.baseUrl,
             });
             if (action.action === "stop") {
                 if (session)
@@ -2605,7 +2630,7 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         s.stepMode = true;
         s.cmdCtx = ctx;
         s.autoStartTime = Date.now();
-        s.currentUnit = null;
+        s.clearCurrentUnit();
         s.pendingQuickTasks = [];
     }
     // ADR-016 phase 2 / B2 (#5620): hook-trigger basePath transition. Treats
@@ -2619,23 +2644,23 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
     }
     const hookUnitType = `hook/${hookName}`;
     const hookStartedAt = Date.now();
-    s.currentUnit = {
+    s.setCurrentUnit({
         type: triggerUnitType,
         id: triggerUnitId,
         startedAt: hookStartedAt,
         workspaceRoot: s.basePath,
-    };
+    });
     const result = await s.cmdCtx.newSession({ workspaceRoot: s.basePath });
     if (result.cancelled) {
         await stopAuto(ctx, pi);
         return false;
     }
-    s.currentUnit = {
+    s.setCurrentUnit({
         type: hookUnitType,
         id: triggerUnitId,
         startedAt: hookStartedAt,
         workspaceRoot: s.basePath,
-    };
+    });
     if (hookModel) {
         const availableModels = ctx.modelRegistry.getAvailable();
         const match = resolveModelId(hookModel, availableModels, ctx.model?.provider);

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

@@ -664,7 +664,7 @@ export function registerDbTools(pi) {
                 files: Type.Array(Type.String(), { description: "Array<string> of files likely touched; pass [\"path\"] or [], never a single string" }),
                 verify: Type.String({ description: "Verification command or block" }),
                 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 expected output files or artifacts; 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" })),
             }), { description: "Planned tasks for the slice" }),
             // ── Enrichment metadata (optional — defaults to empty) ────────────
@@ -740,7 +740,7 @@ export function registerDbTools(pi) {
             files: Type.Array(Type.String(), { description: "Array<string> of files likely touched; pass [\"path\"] or [], never a single string" }),
             verify: Type.String({ description: "Verification command or block" }),
             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 expected output files or artifacts; 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" })),
             // 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')" })),
@@ -1069,7 +1069,7 @@ export function registerDbTools(pi) {
                 files: Type.Array(Type.String(), { description: "Files likely touched" }),
                 verify: Type.String({ description: "Verification command or block" }),
                 inputs: Type.Array(Type.String(), { description: "Input files or references" }),
-                expectedOutput: Type.Array(Type.String(), { description: "Expected output files or artifacts" }),
+                expectedOutput: Type.Array(Type.String(), { description: "Files this task creates or overwrites" }),
             }), { description: "Tasks to upsert (update existing or insert new)" }),
             removedTaskIds: Type.Array(Type.String(), { description: "Task IDs to remove from the slice" }),
             // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.

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

@@ -1,17 +1,17 @@
 // Project/App: gsd-pi
 // File Purpose: Registers GSD extension runtime hooks and token-saving tool policies.
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { isToolCallEventType } from "@gsd/pi-coding-agent";
 import { ALWAYS_PRESERVED_SHIM_TOOL_NAMES } from "@gsd/pi-ai";
 import { updateSnapshot } from "../ecosystem/gsd-extension-api.js";
-import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
+import { buildMilestoneFileName, clearPathCache, milestonesDir, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
 import { canonicalToolName, clearDiscussionFlowState, isDepthConfirmationAnswer, isMilestoneDepthVerified, isQueuePhaseActive, markApprovalGateVerified, markDepthVerified, resetWriteGateState, shouldBlockContextWrite, shouldBlockPlanningUnit, shouldBlockQueueExecution, shouldBlockWorktreeWrite, isGateQuestionId, setPendingGate, clearPendingGate, getPendingGate, shouldBlockPendingGate, shouldBlockPendingGateBash, extractDepthVerificationMilestoneId } from "./write-gate.js";
 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 { clearToolInvocationError, getAutoRuntimeSnapshot, isAutoActive, isAutoCompletionStopInProgress, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto-runtime-state.js";
+import { clearToolInvocationError, getAutoRuntimeSnapshot, getSourceObservationStore, isAutoActive, isAutoCompletionStopInProgress, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError, } from "../auto-runtime-state.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { maybePauseAutoForApprovalGate, resetPendingGatePauseGuard } from "./pending-gate-pause.js";
 import { saveActivityLog } from "../activity-log.js";
@@ -31,6 +31,7 @@ import { registerPlanMilestoneSchemaRecovery } from "./plan-milestone-schema-rec
 import { AUTO_UNIT_SCOPED_TOOLS, RUN_UAT_BROWSER_TOOL_NAMES, isWorkflowAliasTool } from "../auto-unit-tool-scope.js";
 import { filterToolsForProvider } from "../model-router.js";
 import { RUN_UAT_READ_ONLY_TOOL_NAMES, RUN_UAT_WORKFLOW_TOOL_NAMES } from "../tool-presentation-plan.js";
+import { injectSourceContextBlockIntoPayload, supportsSourceObservationsForUnit } from "../source-observations.js";
 let approvalQuestionAbortInFlight = false;
 async function loadWelcomeScreenModule() {
     const candidates = [];
@@ -210,7 +211,12 @@ export function buildRunUatGsdToolSet(activeToolNames, registeredToolNames = act
         "subagent",
         ...RUN_UAT_BROWSER_TOOL_NAMES,
     ]);
-    return [...new Set(scoped)];
+    const resolved = [...new Set(scoped)];
+    const unresolved = RUN_UAT_WORKFLOW_TOOL_NAMES.filter((tool) => !resolved.some((name) => name === tool || (name.startsWith("mcp__") && name.endsWith(`__${tool}`))));
+    if (unresolved.length > 0) {
+        safetyLogWarning("bootstrap", `buildRunUatGsdToolSet: required run-uat workflow tool(s) not found in active/registered surface: ${unresolved.join(", ")}. Session may lack gsd-workflow MCP connection.`);
+    }
+    return resolved;
 }
 export function buildMinimalGsdWorkflowToolSet(activeToolNames, registeredToolNames = activeToolNames) {
     const autoBaseTools = new Set(MINIMAL_AUTO_BASE_TOOL_NAMES);
@@ -365,6 +371,50 @@ function deferApprovalGate(gateId, basePath) {
 function contextBasePath(ctx) {
     return typeof ctx?.cwd === "string" ? ctx.cwd : process.cwd();
 }
+function beginSourceObservationStoreForCurrentUnit(ctx) {
+    if (!isAutoActive())
+        return null;
+    const dash = getAutoRuntimeSnapshot();
+    if (!dash.currentUnit)
+        return null;
+    if (!supportsSourceObservationsForUnit(dash.currentUnit.type))
+        return null;
+    const store = getSourceObservationStore();
+    store.beginUnit({
+        unitType: dash.currentUnit.type,
+        unitId: dash.currentUnit.id,
+        startedAt: dash.currentUnit.startedAt,
+        basePath: dash.currentUnit.workspaceRoot ?? (dash.basePath || contextBasePath(ctx)),
+    });
+    return store;
+}
+function refreshSourceObservationAfterMutation(canonicalName, input, ctx) {
+    if (canonicalName !== "edit" && canonicalName !== "write")
+        return;
+    if (!input || typeof input !== "object")
+        return;
+    const store = beginSourceObservationStoreForCurrentUnit(ctx);
+    if (!store)
+        return;
+    store.observeMutation(input);
+}
+function clearSourceObservationsAfterShell(canonicalName) {
+    if (!isAutoActive())
+        return;
+    if (!isShellExecutionTool(canonicalName))
+        return;
+    const dash = getAutoRuntimeSnapshot();
+    if (!dash.currentUnit || !supportsSourceObservationsForUnit(dash.currentUnit.type))
+        return;
+    getSourceObservationStore().clear();
+}
+function isShellExecutionTool(canonicalName) {
+    return canonicalName === "bash" ||
+        canonicalName === "bg_shell" ||
+        canonicalName === "async_bash" ||
+        canonicalName === "shell" ||
+        canonicalName === "powershell";
+}
 function activateDeferredApprovalGate(basePath) {
     if (deferredApprovalGate?.basePath !== basePath)
         return;
@@ -387,6 +437,79 @@ function isContextDraftSummarySave(toolName, input) {
         return false;
     return input.artifact_type === "CONTEXT-DRAFT";
 }
+function selectedAnswerLabel(selected) {
+    if (Array.isArray(selected))
+        return selected.map(String).join(", ");
+    if (selected == null)
+        return "";
+    return String(selected);
+}
+function formatQuestionExchange(questions, answers) {
+    const lines = [];
+    for (const question of questions) {
+        lines.push(`### ${question.header ?? "Question"}`, "", question.question ?? "");
+        if (Array.isArray(question.options)) {
+            lines.push("");
+            for (const opt of question.options) {
+                lines.push(`- **${opt.label ?? ""}** — ${opt.description ?? ""}`);
+            }
+        }
+        const answer = question.id ? answers?.[question.id] : undefined;
+        if (answer) {
+            lines.push("");
+            const selected = selectedAnswerLabel(answer.selected);
+            if (selected)
+                lines.push(`**Selected:** ${selected}`);
+            if (answer.notes)
+                lines.push(`**Notes:** ${String(answer.notes)}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+async function ensureMilestoneShell(basePath, milestoneId) {
+    const milestoneDir = resolveMilestonePath(basePath, milestoneId)
+        ?? join(milestonesDir(basePath), milestoneId);
+    mkdirSync(milestoneDir, { recursive: true });
+    clearPathCache();
+    try {
+        const { ensureDbOpen } = await import("./dynamic-tools.js");
+        if (await ensureDbOpen(basePath)) {
+            const { getMilestone, insertMilestone } = await import("../gsd-db.js");
+            if (!getMilestone(milestoneId)) {
+                insertMilestone({
+                    id: milestoneId,
+                    title: `New milestone ${milestoneId}`,
+                    status: "queued",
+                });
+            }
+        }
+    }
+    catch (err) {
+        safetyLogWarning("guided", `failed to persist milestone shell for ${milestoneId}: ${err.message}`);
+    }
+    return milestoneDir;
+}
+async function saveDiscussionQuestionRound(basePath, milestoneId, questions, details) {
+    const milestoneDir = await ensureMilestoneShell(basePath, milestoneId);
+    const answers = details?.response?.answers;
+    const timestamp = new Date().toISOString();
+    const exchange = formatQuestionExchange(questions, answers);
+    const discussionPath = join(milestoneDir, buildMilestoneFileName(milestoneId, "DISCUSSION"));
+    const existingDiscussion = await loadFile(discussionPath) ?? `# ${milestoneId} Discussion Log\n\n`;
+    await saveFile(discussionPath, `${existingDiscussion}## Exchange — ${timestamp}\n\n${exchange}---\n\n`);
+    const draftPath = join(milestoneDir, buildMilestoneFileName(milestoneId, "CONTEXT-DRAFT"));
+    const existingDraft = await loadFile(draftPath);
+    const draftHeader = existingDraft
+        ?? [
+            `# ${milestoneId}: New milestone ${milestoneId}`,
+            "",
+            "This draft was captured automatically from structured question responses.",
+            "Use it so `/gsd` can resume the in-flight milestone discussion.",
+            "",
+        ].join("\n");
+    await saveFile(draftPath, `${draftHeader.trimEnd()}\n\n## Captured Question Round — ${timestamp}\n\n${exchange}`);
+}
 function withDepthGateDisplayReason(result, displayReason = "Depth confirmation is waiting for your answer.") {
     if (!result.block)
         return result;
@@ -463,6 +586,18 @@ export function registerHooks(pi, ecosystemHandlers) {
         if (isAutoActive() || preserveCloseoutSurface) {
             ctx.ui.setWidget("gsd-health", undefined);
         }
+        // Cold start after /quit relaunches with cwd at the project root. When
+        // auto-mode is neither active nor paused (its own resume path re-enters the
+        // worktree with a lease check — auto.ts:3032), proactively chdir back into
+        // the active milestone's worktree so subsequent work isn't stranded at the
+        // root. Best-effort and a no-op when already inside a worktree.
+        if (!isAutoActive() && !isAutoPaused() && !preserveCloseoutSurface) {
+            try {
+                const { reenterActiveWorktreeIfNeeded } = await import("../worktree-reentry.js");
+                await reenterActiveWorktreeIfNeeded(basePath);
+            }
+            catch { /* non-fatal */ }
+        }
     });
     pi.on("session_switch", async (_event, ctx) => {
         const basePath = contextBasePath(ctx);
@@ -901,6 +1036,17 @@ export function registerHooks(pi, ecosystemHandlers) {
         if (isAutoActive() && typeof event.toolCallId === "string") {
             markToolEnd(event.toolCallId);
         }
+        const toolName = canonicalToolName(event.toolName);
+        if (isAutoActive() && toolName === "read" && !event.isError) {
+            const store = beginSourceObservationStoreForCurrentUnit(ctx);
+            if (store) {
+                store.observeRead(event.input);
+            }
+        }
+        if (!event.isError) {
+            refreshSourceObservationAfterMutation(toolName, event.input, ctx);
+            clearSourceObservationsAfterShell(toolName);
+        }
         if (isAutoActive() && event.isError) {
             const resultPayload = ("result" in event ? event.result : undefined);
             const errorText = typeof resultPayload === "string"
@@ -917,12 +1063,10 @@ export function registerHooks(pi, ecosystemHandlers) {
         else if (isAutoActive()) {
             clearToolInvocationError();
         }
-        const toolName = canonicalToolName(event.toolName);
         if (toolName !== "ask_user_questions")
             return;
         const basePath = contextBasePath(ctx);
         const milestoneId = await getDiscussionMilestoneIdFor(basePath);
-        const queueActive = isQueuePhaseActive(basePath);
         const details = event.details;
         // ── Discussion gate enforcement: handle gate question responses ──
         // If the result is cancelled or has no response, the pending gate stays active
@@ -995,38 +1139,9 @@ export function registerHooks(pi, ecosystemHandlers) {
                 break;
             }
         }
-        if (!milestoneId && !queueActive)
-            return;
         if (!milestoneId)
             return;
-        const milestoneDir = resolveMilestonePath(basePath, milestoneId);
-        if (!milestoneDir)
-            return;
-        const discussionPath = join(milestoneDir, buildMilestoneFileName(milestoneId, "DISCUSSION"));
-        const timestamp = new Date().toISOString();
-        const lines = [`## Exchange — ${timestamp}`, ""];
-        for (const question of questions) {
-            lines.push(`### ${question.header ?? "Question"}`, "", question.question ?? "");
-            if (Array.isArray(question.options)) {
-                lines.push("");
-                for (const opt of question.options) {
-                    lines.push(`- **${opt.label}** — ${opt.description ?? ""}`);
-                }
-            }
-            const answer = details.response?.answers?.[question.id];
-            if (answer) {
-                lines.push("");
-                const selected = Array.isArray(answer.selected) ? answer.selected.join(", ") : answer.selected;
-                lines.push(`**Selected:** ${selected}`);
-                if (answer.notes) {
-                    lines.push(`**Notes:** ${answer.notes}`);
-                }
-            }
-            lines.push("");
-        }
-        lines.push("---", "");
-        const existing = await loadFile(discussionPath) ?? `# ${milestoneId} Discussion Log\n\n`;
-        await saveFile(discussionPath, existing + lines.join("\n"));
+        await saveDiscussionQuestionRound(basePath, milestoneId, questions, details);
     });
     pi.on("tool_execution_start", async (event, ctx) => {
         const basePath = contextBasePath(ctx);
@@ -1078,51 +1193,51 @@ export function registerHooks(pi, ecosystemHandlers) {
         const payload = event.payload;
         if (!payload || typeof payload !== "object")
             return;
-        // ── Observation Masking ─────────────────────────────────────────────
-        // Replace old tool results with placeholders to reduce context bloat.
-        // Only active during auto-mode when context_management.observation_masking is enabled.
-        if (isAutoActive()) {
-            try {
-                const { loadEffectiveGSDPreferences } = await import("../preferences.js");
-                const prefs = loadEffectiveGSDPreferences();
-                const cmConfig = prefs?.preferences.context_management;
-                // Observation masking: replace old tool results with placeholders
-                if (cmConfig?.observation_masking !== false) {
-                    const keepTurns = cmConfig?.observation_mask_turns ?? 8;
-                    const { createObservationMask } = await import("../context-masker.js");
-                    const mask = createObservationMask(keepTurns);
-                    const messages = payload.messages;
-                    if (Array.isArray(messages)) {
-                        payload.messages = mask(messages);
-                    }
+        // ── Context Management ──────────────────────────────────────────────
+        // Load preferences once for both masking and truncation.
+        try {
+            const { loadEffectiveGSDPreferences } = await import("../preferences.js");
+            const { createObservationMask, createResponsesInputObservationMask, truncateContextResultMessages, truncateResponsesInputResultItems, } = await import("../context-masker.js");
+            const prefs = loadEffectiveGSDPreferences();
+            const cmConfig = prefs?.preferences.context_management;
+            // Observation masking: replace old tool results with placeholders.
+            // Only active during auto-mode when context_management.observation_masking is enabled.
+            if (isAutoActive() && cmConfig?.observation_masking !== false) {
+                const keepTurns = cmConfig?.observation_mask_turns ?? 8;
+                const messages = payload.messages;
+                if (Array.isArray(messages)) {
+                    payload.messages = createObservationMask(keepTurns)(messages);
                 }
-                // Tool result truncation: cap individual tool result content length.
-                // In pi-ai format, toolResult messages have role: "toolResult" and content: TextContent[].
-                // Creates new objects to avoid mutating shared conversation state.
-                const maxChars = cmConfig?.tool_result_max_chars ?? 800;
-                const msgs = payload.messages;
-                if (Array.isArray(msgs)) {
-                    payload.messages = msgs.map((msg) => {
-                        // Match toolResult messages (role: "toolResult", content is array of content blocks)
-                        if (msg?.role === "toolResult" && Array.isArray(msg.content)) {
-                            const blocks = msg.content;
-                            const totalLen = blocks.reduce((sum, b) => sum + (typeof b.text === "string" ? b.text.length : 0), 0);
-                            if (totalLen > maxChars) {
-                                const truncated = blocks.map(b => {
-                                    if (typeof b.text === "string" && b.text.length > maxChars) {
-                                        return { ...b, text: b.text.slice(0, maxChars) + "\n…[truncated]" };
-                                    }
-                                    return b;
-                                });
-                                return { ...msg, content: truncated };
-                            }
-                        }
-                        return msg;
-                    });
+                const input = payload.input;
+                if (Array.isArray(input)) {
+                    payload.input = createResponsesInputObservationMask(keepTurns)(input);
+                }
+            }
+            // Tool result truncation: cap individual tool result content length.
+            // Applies in ALL modes (auto + interactive) to prevent context bloat.
+            // In pi-ai format, toolResult messages have role: "toolResult" and content: TextContent[].
+            // Creates new objects to avoid mutating shared conversation state.
+            const maxChars = cmConfig?.tool_result_max_chars ?? 800;
+            const msgs = payload.messages;
+            if (Array.isArray(msgs)) {
+                payload.messages = truncateContextResultMessages(msgs, maxChars);
+            }
+            const input = payload.input;
+            if (Array.isArray(input)) {
+                payload.input = truncateResponsesInputResultItems(input, maxChars);
+            }
+        }
+        catch { /* non-fatal */ }
+        try {
+            if (isAutoActive()) {
+                const sourceContextBlock = getSourceObservationStore().renderActiveBlock();
+                if (sourceContextBlock) {
+                    const nextPayload = injectSourceContextBlockIntoPayload(payload, sourceContextBlock);
+                    Object.assign(payload, nextPayload);
                 }
             }
-            catch { /* non-fatal */ }
         }
+        catch { /* non-fatal */ }
         // ── Service Tier ────────────────────────────────────────────────────
         const modelId = event.model?.id;
         if (!modelId)

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

@@ -56,7 +56,7 @@ export const BUNDLED_SKILL_TRIGGERS = [
     { trigger: "Core Web Vitals — fix LCP, CLS, INP; layout shifts; page experience optimization", skill: "core-web-vitals" },
     { trigger: "GitHub Actions CI/CD — write, run, and debug workflow files; live syntax and run monitoring", skill: "github-workflows" },
     { trigger: "Comprehensive web quality audit — performance, accessibility, SEO, and best-practices (Lighthouse-style)", skill: "web-quality-audit" },
-    { trigger: "gsd-browser UAT — default browser MCP/CLI for real UI verification, screenshots, assertions, console/network diagnostics", skill: "gsd-browser" },
+    { trigger: "gsd-browser opt-in and External MCP UAT — screenshots, assertions, console/network diagnostics", skill: "gsd-browser" },
     { trigger: "Browser automation — open sites, fill forms, click, screenshot, scrape, or test web apps programmatically", skill: "agent-browser" },
     { trigger: "Review UI code for Web Interface Guidelines compliance — UX, design, and accessibility patterns", skill: "web-design-guidelines" },
     { trigger: "UI/UX patterns reference — animations, CSS, typography, prefetching, icons (file:line findings)", skill: "userinterface-wiki" },