gsd-pi 2.78.0-dev.aeeb2ca00 → 2.78.1-dev.0fdacd524

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

@@ -5,24 +5,16 @@ import { isToolCallEventType } from "@gsd/pi-coding-agent";
 
 import type { GSDEcosystemBeforeAgentStartHandler } from "../ecosystem/gsd-extension-api.js";
 import { updateSnapshot } from "../ecosystem/gsd-extension-api.js";
-import { getEcosystemReadyPromise } from "../ecosystem/loader.js";
 
 import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
-import { buildBeforeAgentStartResult } from "./system-context.js";
-import { handleAgentEnd } from "./agent-end-recovery.js";
-import { clearDiscussionFlowState, isDepthConfirmationAnswer, isQueuePhaseActive, markDepthVerified, resetWriteGateState, shouldBlockContextWrite, shouldBlockQueueExecution, isGateQuestionId, setPendingGate, clearPendingGate, getPendingGate, shouldBlockPendingGate, shouldBlockPendingGateBash, extractDepthVerificationMilestoneId } from "./write-gate.js";
+import { clearDiscussionFlowState, isDepthConfirmationAnswer, isQueuePhaseActive, markDepthVerified, resetWriteGateState, shouldBlockContextWrite, shouldBlockPlanningUnit, shouldBlockQueueExecution, 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 { cleanupQuickBranch } from "../quick.js";
-import { getDiscussionMilestoneId } from "../guided-flow.js";
-import { loadToolApiKeys } from "../commands-config.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
-import { deriveState } from "../state.js";
-import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto.js";
+import { getAutoRuntimeSnapshot, isAutoActive, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto-runtime-state.js";
 
-import { isParallelActive, shutdownParallel } from "../parallel-orchestrator.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { saveActivityLog } from "../activity-log.js";
-import { resetAskUserQuestionsCache } from "../../ask-user-questions.js";
 import { recordToolCall as safetyRecordToolCall, recordToolResult as safetyRecordToolResult, saveEvidenceToDisk } from "../safety/evidence-collector.js";
 import { parseUnitId } from "../unit-id.js";
 import { classifyCommand } from "../safety/destructive-guard.js";
@@ -30,17 +22,46 @@ import { logWarning as safetyLogWarning } from "../workflow-logger.js";
 import { installNotifyInterceptor } from "./notify-interceptor.js";
 import { initNotificationStore } from "../notification-store.js";
 import { initNotificationWidget } from "../notification-widget.js";
-import { initHealthWidget } from "../health-widget.js";
+import { extractSubagentAgentClasses } from "./subagent-input.js";
 
 // Skip the welcome screen on the very first session_start — cli.ts already
 // printed it before the TUI launched. Only re-print on /clear (subsequent sessions).
 let isFirstSession = true;
 
+async function deriveGsdState(basePath: string) {
+  const { deriveState } = await import("../state.js");
+  return deriveState(basePath);
+}
+
+async function getDiscussionMilestoneIdFor(basePath: string): Promise<string | null> {
+  const { getDiscussionMilestoneId } = await import("../guided-flow.js");
+  return getDiscussionMilestoneId(basePath);
+}
+
+async function loadToolApiKeysForSession(): Promise<void> {
+  const { loadToolApiKeys } = await import("../commands-config.js");
+  loadToolApiKeys();
+}
+
+async function resetAskUserQuestionsTurnCache(): Promise<void> {
+  const { resetAskUserQuestionsCache } = await import("../../ask-user-questions.js");
+  resetAskUserQuestionsCache();
+}
+
 async function syncServiceTierStatus(ctx: ExtensionContext): Promise<void> {
   const { getEffectiveServiceTier, formatServiceTierFooterStatus } = await import("../service-tier.js");
   ctx.ui.setStatus("gsd-fast", formatServiceTierFooterStatus(getEffectiveServiceTier(), ctx.model?.id));
 }
 
+async function applyDisabledModelProviderPolicy(ctx: ExtensionContext): Promise<void> {
+  try {
+    const { resolveDisabledModelProvidersFromPreferences } = await import("../preferences.js");
+    ctx.modelRegistry.setDisabledModelProviders(resolveDisabledModelProvidersFromPreferences());
+  } catch {
+    // Non-fatal: keep default provider visibility if preferences cannot be loaded.
+  }
+}
+
 export function registerHooks(
   pi: ExtensionAPI,
   ecosystemHandlers: GSDEcosystemBeforeAgentStartHandler[],
@@ -50,12 +71,14 @@ export function registerHooks(
     installNotifyInterceptor(ctx);
     initNotificationWidget(ctx);
     if (!isAutoActive()) {
+      const { initHealthWidget } = await import("../health-widget.js");
       initHealthWidget(ctx);
     }
     resetWriteGateState();
     resetToolCallLoopGuard();
-    resetAskUserQuestionsCache();
+    await resetAskUserQuestionsTurnCache();
     await syncServiceTierStatus(ctx);
+    await applyDisabledModelProviderPolicy(ctx);
     // Skip MCP auto-prep when running inside an auto-worktree (see session_switch below).
     const { isInAutoWorktree } = await import("../auto-worktree.js");
     if (!isInAutoWorktree(process.cwd())) {
@@ -91,7 +114,7 @@ export function registerHooks(
         }
       } catch { /* non-fatal */ }
     }
-    loadToolApiKeys();
+    await loadToolApiKeysForSession();
     if (isAutoActive()) {
       ctx.ui.setWidget("gsd-health", undefined);
     }
@@ -102,9 +125,10 @@ export function registerHooks(
     installNotifyInterceptor(ctx);
     resetWriteGateState();
     resetToolCallLoopGuard();
-    resetAskUserQuestionsCache();
+    await resetAskUserQuestionsTurnCache();
     clearDiscussionFlowState();
     await syncServiceTierStatus(ctx);
+    await applyDisabledModelProviderPolicy(ctx);
     // Skip MCP auto-prep when running inside an auto-worktree. The worktree
     // already has .mcp.json from createAutoWorktree, and re-running the writer
     // post-chdir rewrites the file mid-run (non-idempotent due to cwd-relative
@@ -114,23 +138,28 @@ export function registerHooks(
       const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
       prepareWorkflowMcpForProject(ctx, process.cwd());
     }
-    loadToolApiKeys();
-    if (isAutoActive()) {
+    await loadToolApiKeysForSession();
+    if (!isAutoActive()) {
+      const { initHealthWidget } = await import("../health-widget.js");
+      initHealthWidget(ctx);
+    } else {
       ctx.ui.setWidget("gsd-health", undefined);
     }
   });
 
   pi.on("before_agent_start", async (event, ctx: ExtensionContext) => {
     // Wait for ecosystem loader to finish (no-op after first turn).
+    const { getEcosystemReadyPromise } = await import("../ecosystem/loader.js");
     await getEcosystemReadyPromise();
 
     // GSD's own context injection (existing behavior — unchanged).
+    const { buildBeforeAgentStartResult } = await import("./system-context.js");
     const gsdResult = await buildBeforeAgentStartResult(event, ctx);
 
     // Refresh the snapshot used by ecosystem getPhase()/getActiveUnit().
     // deriveState has its own ~100ms cache so this is cheap on repeat calls.
     try {
-      const state = await deriveState(process.cwd());
+      const state = await deriveGsdState(process.cwd());
       updateSnapshot(state);
     } catch {
       updateSnapshot(null);
@@ -169,7 +198,8 @@ export function registerHooks(
 
   pi.on("agent_end", async (event, ctx: ExtensionContext) => {
     resetToolCallLoopGuard();
-    resetAskUserQuestionsCache();
+    await resetAskUserQuestionsTurnCache();
+    const { handleAgentEnd } = await import("./agent-end-recovery.js");
     await handleAgentEnd(pi, event, ctx);
   });
 
@@ -178,6 +208,7 @@ export function registerHooks(
   // quick-return state is pending, so this is safe to call on every turn.
   pi.on("turn_end", async () => {
     try {
+      const { cleanupQuickBranch } = await import("../quick.js");
       cleanupQuickBranch();
     } catch {
       // Best-effort: don't break the turn lifecycle if cleanup fails.
@@ -194,8 +225,8 @@ export function registerHooks(
     const basePath = process.cwd();
     const { ensureDbOpen } = await import("./dynamic-tools.js");
     await ensureDbOpen();
-    const state = await deriveState(basePath);
-    if (!state.activeMilestone || !state.activeSlice || !state.activeTask) return;
+    const state = await deriveGsdState(basePath);
+    if (!state.activeMilestone || !state.activeSlice) return;
     // Write checkpoint for ALL phases, not just "executing" — discuss, research,
     // and planning also carry in-memory state (user answers, gate verification)
     // that would be lost on compaction (#4258).
@@ -210,21 +241,31 @@ export function registerHooks(
     if (await loadFile(legacyContinue)) return;
 
     const continuePath = join(sliceDir, `${state.activeSlice.id}-CONTINUE.md`);
+    const taskId = state.activeTask?.id ?? "none";
+    const taskTitle = state.activeTask?.title ?? "";
+    const phaseLabel = state.phase.replace(/-/g, " ");
+
     await saveFile(continuePath, formatContinue({
       frontmatter: {
         milestone: state.activeMilestone.id,
         slice: state.activeSlice.id,
-        task: state.activeTask.id,
+        task: taskId,
         step: 0,
         totalSteps: 0,
         status: "compacted" as const,
         savedAt: new Date().toISOString(),
       },
-      completedWork: `Task ${state.activeTask.id} (${state.activeTask.title}) was in progress when compaction occurred.`,
-      remainingWork: "Check the task plan for remaining steps.",
+      completedWork: state.activeTask
+        ? `Task ${taskId} (${taskTitle}) was in progress when compaction occurred.`
+        : `Slice ${state.activeSlice.id} was in ${phaseLabel} phase when compaction occurred.`,
+      remainingWork: state.activeTask
+        ? "Check the task plan for remaining steps."
+        : "Continue this slice from the latest planning/research/discussion artifacts.",
       decisions: "Check task summary files for prior decisions.",
       context: "Session was auto-compacted by Pi. Resume with /gsd.",
-      nextAction: `Resume task ${state.activeTask.id}: ${state.activeTask.title}.`,
+      nextAction: state.activeTask
+        ? `Resume task ${taskId}: ${taskTitle}.`
+        : `Resume ${phaseLabel} work for slice ${state.activeSlice.id}.`,
     }));
   });
 
@@ -246,7 +287,7 @@ export function registerHooks(
       const basePath = process.cwd();
       let activeContext: string | null = null;
       try {
-        const state = await deriveState(basePath);
+        const state = await deriveGsdState(basePath);
         if (state.activeMilestone && state.activeSlice && state.activeTask) {
           activeContext =
             `Active: ${state.activeMilestone.id} / ${state.activeSlice.id} / ${state.activeTask.id}` +
@@ -265,6 +306,7 @@ export function registerHooks(
   });
 
   pi.on("session_shutdown", async (_event, ctx: ExtensionContext) => {
+    const { isParallelActive, shutdownParallel } = await import("../parallel-orchestrator.js");
     if (isParallelActive()) {
       try {
         await shutdownParallel(process.cwd());
@@ -273,7 +315,7 @@ export function registerHooks(
       }
     }
     if (!isAutoActive() && !isAutoPaused()) return;
-    const dash = getAutoDashboardData();
+    const dash = getAutoRuntimeSnapshot();
     if (dash.currentUnit) {
       saveActivityLog(ctx, dash.basePath, dash.currentUnit.type, dash.currentUnit.id);
     }
@@ -302,7 +344,7 @@ export function registerHooks(
     // If ask_user_questions was called with a gate ID but hasn't been confirmed,
     // block all non-read-only tool calls to prevent the model from skipping gates.
     if (getPendingGate()) {
-      const milestoneId = getDiscussionMilestoneId(discussionBasePath);
+      const milestoneId = await getDiscussionMilestoneIdFor(discussionBasePath);
       if (isToolCallEventType("bash", event)) {
         const bashGuard = shouldBlockPendingGateBash(
           event.input.command,
@@ -337,6 +379,41 @@ export function registerHooks(
       if (queueGuard.block) return queueGuard;
     }
 
+    // ── Planning-unit tools-policy enforcement (#4934): runtime half ─────
+    // The active auto-mode unit's manifest declares a ToolsPolicy. For
+    // planning/docs/read-only modes, deny writes outside .gsd/ (or the
+    // manifest's allowedPathGlobs), bash that isn't read-only, and
+    // subagent dispatch. Closes the b23 bug class where a discuss-milestone
+    // turn used the host Edit tool to modify user source files.
+    const dash = getAutoRuntimeSnapshot();
+    const activeUnitType = dash.currentUnit?.type;
+    if (activeUnitType) {
+      const manifest = resolveManifest(activeUnitType);
+      if (manifest) {
+        let planningInput = "";
+        let agentClasses: string[] | undefined;
+        if (isToolCallEventType("write", event)) {
+          planningInput = event.input.path;
+        } else if (isToolCallEventType("edit", event)) {
+          planningInput = event.input.path;
+        } else if (isToolCallEventType("bash", event)) {
+          planningInput = event.input.command;
+        } else if (event.toolName === "subagent" || event.toolName === "task") {
+          // Subagent inputs use { agent }, { tasks: [{ agent }] }, or { chain: [{ agent }] }.
+          agentClasses = extractSubagentAgentClasses((event as { input?: unknown }).input);
+        }
+        const planningGuard = shouldBlockPlanningUnit(
+          event.toolName,
+          planningInput,
+          dash.basePath || discussionBasePath,
+          activeUnitType,
+          manifest.tools,
+          agentClasses,
+        );
+        if (planningGuard.block) return planningGuard;
+      }
+    }
+
     // ── Single-writer engine: block direct writes to STATE.md ──────────
     // Covers write, edit, and bash tools to prevent bypass vectors.
     if (isToolCallEventType("write", event)) {
@@ -362,7 +439,7 @@ export function registerHooks(
     const result = shouldBlockContextWrite(
       event.toolName,
       event.input.path,
-      getDiscussionMilestoneId(discussionBasePath),
+      await getDiscussionMilestoneIdFor(discussionBasePath),
       isQueuePhaseActive(),
     );
     if (result.block) return result;
@@ -374,6 +451,19 @@ export function registerHooks(
     markToolStart(event.toolCallId, event.toolName);
     safetyRecordToolCall(event.toolCallId, event.toolName, event.input as Record<string, unknown>);
 
+    // Persist immediately at dispatch so a mid-unit re-dispatch — which calls
+    // resetEvidence() + loadEvidenceFromDisk() in runUnitPhase — cannot wipe
+    // the entry between tool_call and tool_execution_end. Without this, the
+    // race window equals the tool's runtime, producing the "no bash calls"
+    // false positive when the LLM clearly ran a verification command.
+    const callDash = getAutoRuntimeSnapshot();
+    if (callDash.basePath && callDash.currentUnit?.type === "execute-task") {
+      const { milestone: cMid, slice: cSid, task: cTid } = parseUnitId(callDash.currentUnit.id);
+      if (cMid && cSid && cTid) {
+        saveEvidenceToDisk(callDash.basePath, cMid, cSid, cTid);
+      }
+    }
+
     // Destructive command classification (warn only, never block)
     if (isToolCallEventType("bash", event)) {
       const classification = classifyCommand(event.input.command);
@@ -407,7 +497,7 @@ export function registerHooks(
       recordToolInvocationError(event.toolName, errorText);
     }
     if (event.toolName !== "ask_user_questions") return;
-    const milestoneId = getDiscussionMilestoneId(process.cwd());
+    const milestoneId = await getDiscussionMilestoneIdFor(process.cwd());
     const queueActive = isQueuePhaseActive();
 
     const details = event.details as any;
@@ -506,7 +596,7 @@ export function registerHooks(
       safetyRecordToolResult(event.toolCallId, event.toolName, event.result, event.isError);
       // Persist evidence to disk after each tool result so it survives a session
       // restart mid-unit (Bug #4385 — non-persisted evidence false positives).
-      const dash = getAutoDashboardData();
+      const dash = getAutoRuntimeSnapshot();
       if (dash.basePath && dash.currentUnit?.type === "execute-task") {
         const { milestone: pMid, slice: pSid, task: pTid } = parseUnitId(dash.currentUnit.id);
         if (pMid && pSid && pTid) {

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

@@ -4,13 +4,14 @@ import { join } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 import { Key } from "@gsd/pi-tui";
 
-import { GSDDashboardOverlay } from "../dashboard-overlay.js";
-import { GSDNotificationOverlay } from "../notification-overlay.js";
-import { ParallelMonitorOverlay } from "../parallel-monitor-overlay.js";
 import { GSD_SHORTCUTS } from "../shortcut-defs.js";
-import { projectRoot } from "../commands/context.js";
 import { shortcutDesc } from "../../shared/mod.js";
 
+async function getProjectRoot(): Promise<string> {
+  const { projectRoot } = await import("../commands/context.js");
+  return projectRoot();
+}
+
 export function registerShortcuts(pi: ExtensionAPI): void {
   const overlayOptions = {
     width: "90%",
@@ -20,7 +21,10 @@ export function registerShortcuts(pi: ExtensionAPI): void {
   } as const;
 
   const openDashboardOverlay = async (ctx: ExtensionContext) => {
-    const basePath = projectRoot();
+    const [{ GSDDashboardOverlay }, basePath] = await Promise.all([
+      import("../dashboard-overlay.js"),
+      getProjectRoot(),
+    ]);
     if (!existsSync(join(basePath, ".gsd"))) {
       ctx.ui.notify("No .gsd/ directory found. Run /gsd to start.", "info");
       return;
@@ -35,6 +39,7 @@ export function registerShortcuts(pi: ExtensionAPI): void {
   };
 
   const openNotificationsOverlay = async (ctx: ExtensionContext) => {
+    const { GSDNotificationOverlay } = await import("../notification-overlay.js");
     await ctx.ui.custom<boolean>(
       (tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done(true)),
       {
@@ -51,12 +56,13 @@ export function registerShortcuts(pi: ExtensionAPI): void {
   };
 
   const openParallelOverlay = async (ctx: ExtensionContext) => {
-    const basePath = projectRoot();
+    const basePath = await getProjectRoot();
     const parallelDir = join(basePath, ".gsd", "parallel");
     if (!existsSync(parallelDir)) {
       ctx.ui.notify("No parallel workers found. Run /gsd parallel start first.", "info");
       return;
     }
+    const { ParallelMonitorOverlay } = await import("../parallel-monitor-overlay.js");
     await ctx.ui.custom<boolean>(
       (tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done(true), basePath),
       {

package/src/resources/extensions/gsd/bootstrap/subagent-input.ts

@@ -0,0 +1,20 @@
+export function extractSubagentAgentClasses(input: unknown): string[] {
+  if (!input || typeof input !== "object") return [];
+
+  const record = input as Record<string, unknown>;
+  const agentClasses: string[] = [];
+  const addAgentClass = (value: unknown): void => {
+    if (typeof value === "string" && value.trim().length > 0) agentClasses.push(value.trim());
+  };
+  const addFromItems = (value: unknown): void => {
+    if (!Array.isArray(value)) return;
+    for (const item of value) {
+      if (item && typeof item === "object") addAgentClass((item as Record<string, unknown>).agent);
+    }
+  };
+
+  addAgentClass(record.agent);
+  addFromItems(record.tasks);
+  addFromItems(record.chain);
+  return agentClasses;
+}

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

@@ -15,7 +15,7 @@ import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile
 import { ensureCodebaseMapFresh, readCodebaseMap } from "../codebase-generator.js";
 import { hasSkillSnapshot, detectNewSkills, formatSkillsXml } from "../skill-discovery.js";
 import { getActiveAutoWorktreeContext } from "../auto-worktree.js";
-import { getActiveWorktreeName, getWorktreeOriginalCwd } from "../worktree-command.js";
+import { getActiveWorktreeName, getWorktreeOriginalCwd } from "../worktree-session-state.js";
 import { deriveState } from "../state.js";
 import { formatOverridesSection, formatShortcut, loadActiveOverrides, loadFile, parseContinue, parseSummary } from "../files.js";
 import { toPosixPath } from "../../shared/mod.js";
@@ -52,6 +52,17 @@ export const BUNDLED_SKILL_TRIGGERS: Array<{ trigger: string; skill: string }> =
   { trigger: "HTTP/REST/GraphQL API design — verbs, status codes, pagination, errors, idempotency, versioning", skill: "api-design" },
   { trigger: "Dependency upgrades — risk-batched, verified between batches, one major per commit", skill: "dependency-upgrade" },
   { trigger: "Agent-first observability — structured logs, persisted failure state, health surfaces, explicit failure modes", skill: "observability" },
+  { trigger: "React/Next.js performance — components, data fetching, bundle optimization, rendering patterns from Vercel Engineering", skill: "react-best-practices" },
+  { 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: "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" },
+  { trigger: "Author or refine a GSD skill — SKILL.md structure, frontmatter, and best practices", skill: "create-skill" },
+  { trigger: "Create or debug a GSD extension — tools, commands, event hooks, custom TUI, providers", skill: "create-gsd-extension" },
+  { trigger: "Author a YAML workflow definition — steps, triggers, and templates", skill: "create-workflow" },
+  { trigger: "Deep code optimization audit — perf anti-patterns, memory leaks, algorithmic complexity, bundle size, I/O, caching, dead code (parallel pattern-based hunt)", skill: "code-optimizer" },
 ];
 
 function buildBundledSkillsTable(): string {
@@ -207,7 +218,14 @@ export async function buildBeforeAgentStartResult(
     ? `\n\n## Subagent Model\n\nWhen spawning subagents via the \`subagent\` tool, always pass \`model: "${subagentModelConfig.primary}"\` in the tool call parameters. Never omit this — always specify it explicitly.`
     : "";
 
-  const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${memoryBlock}${newSkillsBlock}${worktreeBlock}${subagentModelBlock}`;
+  // memoryBlock is FTS-queried against the user prompt and changes per call.
+  // Removing it from `fullSystem` keeps the system-prompt cache breakpoint
+  // stable across calls — the only scoped goal of this fix. The pi-ai
+  // Anthropic adapter additionally cache-marks the last user turn, so the
+  // memoryBlock injected via the context message may itself be cached up to
+  // that boundary; that's orthogonal and unchanged from prior behavior. The
+  // load-bearing win here is preserving the system+tools cache hit. (#5019)
+  const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${newSkillsBlock}${worktreeBlock}${subagentModelBlock}`;
 
   stopContextTimer({
     systemPromptSize: fullSystem.length,
@@ -216,12 +234,7 @@ export async function buildBeforeAgentStartResult(
     hasNewSkills: newSkillsBlock.length > 0,
   });
 
-  // Determine which context message to inject (guided execute takes priority)
-  const contextMessage = injection
-    ? { customType: "gsd-guided-context", content: injection, display: false as const }
-    : forensicsInjection
-      ? { customType: "gsd-forensics", content: forensicsInjection, display: false as const }
-      : null;
+  const contextMessage = buildContextMessage({ memoryBlock, injection, forensicsInjection });
 
   return {
     systemPrompt: fullSystem,
@@ -229,6 +242,35 @@ export async function buildBeforeAgentStartResult(
   };
 }
 
+/**
+ * Route the per-call dynamic blocks (memory, guided-execute, forensics) into a
+ * single user-message context payload so they ride the volatile suffix instead
+ * of the cached system prefix. Priority when both memory and an injection are
+ * present: guided > forensics > memory-only. (#5019)
+ *
+ * Exported for direct unit testing — the surrounding bootstrap has too many
+ * filesystem and DB dependencies to exercise this routing logic in-place.
+ */
+export function buildContextMessage(opts: {
+  memoryBlock: string;
+  injection: string | null;
+  forensicsInjection: string | null;
+}): { customType: string; content: string; display: false } | null {
+  const memoryContent = opts.memoryBlock.trim();
+  if (opts.injection) {
+    const content = memoryContent ? `${memoryContent}\n\n${opts.injection}` : opts.injection;
+    return { customType: "gsd-guided-context", content, display: false as const };
+  }
+  if (opts.forensicsInjection) {
+    const content = memoryContent ? `${memoryContent}\n\n${opts.forensicsInjection}` : opts.forensicsInjection;
+    return { customType: "gsd-forensics", content, display: false as const };
+  }
+  if (memoryContent) {
+    return { customType: "gsd-memory", content: memoryContent, display: false as const };
+  }
+  return null;
+}
+
 /**
  * ADR-013 step 4 — auto-injection parity for the memories table.
  *