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

package/src/resources/extensions/gsd/auto.ts

@@ -107,7 +107,7 @@ import {
 } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { recoverTimedOutUnit } from "./auto-timeout-recovery.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 {
   checkPostUnitHooks,
@@ -542,8 +542,26 @@ function handlePausedSessionResumeRecovery(
 ): { skippedReplay: boolean } {
   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,
@@ -1228,7 +1246,7 @@ export async function cleanupAfterLoopExit(ctx: ExtensionContext): Promise<void>
   const preserveStepSurface = s.preserveStepSurfaceAfterLoopExit;
   const preserveCompletionSurface = s.completionStopInProgress;
   const preservePausedSurface = s.paused;
-  s.currentUnit = null;
+  s.clearCurrentUnit();
   s.active = false;
   deactivateGSD();
   clearUnitTimeout();
@@ -1251,11 +1269,14 @@ export async function cleanupAfterLoopExit(ctx: ExtensionContext): Promise<void>
   // 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);
       ctx.ui.setWidget("gsd-progress", undefined);
@@ -1969,7 +1990,7 @@ export async function pauseAuto(
       // 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.
@@ -2154,7 +2175,10 @@ export function createWiredDispatchAdapter(
         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.
@@ -2201,6 +2225,9 @@ export function createWiredDispatchAdapter(
         sessionContextWindow,
         sessionProvider,
         modelRegistry,
+        activeTools,
+        sessionAuthMode: authMode,
+        sessionBaseUrl: ctx.model?.baseUrl,
       });
 
       if (action.action === "stop") {
@@ -3284,7 +3311,7 @@ export async function dispatchHookUnit(
     s.stepMode = true;
     s.cmdCtx = ctx as ExtensionCommandContext;
     s.autoStartTime = Date.now();
-    s.currentUnit = null;
+    s.clearCurrentUnit();
     s.pendingQuickTasks = [];
   }
 
@@ -3301,12 +3328,12 @@ export async function dispatchHookUnit(
   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) {
@@ -3314,12 +3341,12 @@ export async function dispatchHookUnit(
     return false;
   }
 
-  s.currentUnit = {
+  s.setCurrentUnit({
     type: hookUnitType,
     id: triggerUnitId,
     startedAt: hookStartedAt,
     workspaceRoot: s.basePath,
-  };
+  });
 
   if (hookModel) {
     const availableModels = ctx.modelRegistry.getAvailable();

package/src/resources/extensions/gsd/bootstrap/db-tools.ts

@@ -699,7 +699,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
         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) ────────────
@@ -779,7 +779,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
       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')" })),
@@ -1160,7 +1160,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
           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)" },
       ),

package/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -1,7 +1,7 @@
 // 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";
 
@@ -12,12 +12,22 @@ import { ALWAYS_PRESERVED_SHIM_TOOL_NAMES } from "@gsd/pi-ai";
 import type { GSDEcosystemBeforeAgentStartHandler } from "../ecosystem/gsd-extension-api.js";
 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";
@@ -39,6 +49,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;
 
@@ -259,7 +270,19 @@ export function buildRunUatGsdToolSet(
       ...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(
@@ -462,6 +485,55 @@ function contextBasePath(ctx?: { cwd?: string }): string {
   return typeof ctx?.cwd === "string" ? ctx.cwd : process.cwd();
 }
 
+function beginSourceObservationStoreForCurrentUnit(
+  ctx?: { cwd?: string },
+): ReturnType<typeof getSourceObservationStore> | null {
+  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: string,
+  input: unknown,
+  ctx?: { cwd?: string },
+): void {
+  if (canonicalName !== "edit" && canonicalName !== "write") return;
+  if (!input || typeof input !== "object") return;
+
+  const store = beginSourceObservationStoreForCurrentUnit(ctx);
+  if (!store) return;
+  store.observeMutation(input as { path?: unknown; file_path?: unknown });
+}
+
+function clearSourceObservationsAfterShell(
+  canonicalName: string,
+): void {
+  if (!isAutoActive()) return;
+  if (!isShellExecutionTool(canonicalName)) return;
+  const dash = getAutoRuntimeSnapshot();
+  if (!dash.currentUnit || !supportsSourceObservationsForUnit(dash.currentUnit.type)) return;
+  getSourceObservationStore().clear();
+}
+
+function isShellExecutionTool(canonicalName: string): boolean {
+  return canonicalName === "bash" ||
+    canonicalName === "bg_shell" ||
+    canonicalName === "async_bash" ||
+    canonicalName === "shell" ||
+    canonicalName === "powershell";
+}
+
 function activateDeferredApprovalGate(basePath: string): void {
   if (deferredApprovalGate?.basePath !== basePath) return;
   setPendingGate(deferredApprovalGate.gateId, basePath);
@@ -485,6 +557,109 @@ function isContextDraftSummarySave(toolName: string, input: unknown): boolean {
   return (input as { artifact_type?: unknown }).artifact_type === "CONTEXT-DRAFT";
 }
 
+type StructuredQuestion = {
+  id?: string;
+  header?: string;
+  question?: string;
+  options?: Array<{ label?: string; description?: string }>;
+};
+
+type StructuredAnswer = {
+  selected?: unknown;
+  notes?: unknown;
+};
+
+function selectedAnswerLabel(selected: unknown): string {
+  if (Array.isArray(selected)) return selected.map(String).join(", ");
+  if (selected == null) return "";
+  return String(selected);
+}
+
+function formatQuestionExchange(
+  questions: StructuredQuestion[],
+  answers: Record<string, StructuredAnswer> | undefined,
+): string {
+  const lines: string[] = [];
+  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: string, milestoneId: string): Promise<string> {
+  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 as Error).message}`);
+  }
+
+  return milestoneDir;
+}
+
+async function saveDiscussionQuestionRound(
+  basePath: string,
+  milestoneId: string,
+  questions: StructuredQuestion[],
+  details: any,
+): Promise<void> {
+  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<T extends { block: boolean; reason?: string }>(
   result: T,
   displayReason = "Depth confirmation is waiting for your answer.",
@@ -577,6 +752,17 @@ export function registerHooks(
     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) => {
@@ -1106,6 +1292,17 @@ export function registerHooks(
     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) as any;
       const errorText = typeof resultPayload === "string"
@@ -1121,11 +1318,9 @@ export function registerHooks(
     } 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 as any;
 
@@ -1204,36 +1399,8 @@ export function registerHooks(
       }
     }
 
-    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: string[] = [`## 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) => {
@@ -1287,52 +1454,57 @@ export function registerHooks(
     const payload = event.payload as Record<string, unknown> | null;
     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);
         }
+        const input = payload.input;
+        if (Array.isArray(input)) {
+          payload.input = createResponsesInputObservationMask(keepTurns)(input);
+        }
+      }
 
-        // 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: Record<string, unknown>) => {
-            // Match toolResult messages (role: "toolResult", content is array of content blocks)
-            if (msg?.role === "toolResult" && Array.isArray(msg.content)) {
-              const blocks = msg.content as Array<Record<string, unknown>>;
-              const totalLen = blocks.reduce((sum: number, 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;
-          });
+      // 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 as any, maxChars);
+      }
+      const input = payload.input;
+      if (Array.isArray(input)) {
+        payload.input = truncateResponsesInputResultItems(input as any, 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;

package/src/resources/extensions/gsd/bootstrap/system-context.ts

@@ -61,7 +61,7 @@ export const BUNDLED_SKILL_TRIGGERS: Array<{ trigger: string; skill: string }> =
   { 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" },