@vellumai/assistant 0.8.7-dev.202606052232.2ddc989 → 0.8.8

package/src/daemon/conversation-agent-loop.ts

@@ -47,10 +47,7 @@ import {
   estimatePromptTokensWithTools,
   getCalibrationProviderKey,
 } from "../context/token-estimator.js";
-import type {
-  ContextWindowCompactOptions,
-  ContextWindowManager,
-} from "../context/window-manager.js";
+import type { ContextWindowManager } from "../context/window-manager.js";
 import type { ToolProfiler } from "../events/tool-profiling-listener.js";
 import { writeRelationshipState } from "../home/relationship-state-writer.js";
 import {
@@ -86,14 +83,22 @@ import { enqueueMemoryRetrospectiveOnCompaction } from "../memory/memory-retrosp
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import { HOOKS } from "../plugin-api/constants.js";
 import type { UserPromptSubmitContext } from "../plugin-api/types.js";
-import { defaultCompact } from "../plugins/defaults/compaction/compact.js";
+import { defaultCompactionTerminal } from "../plugins/defaults/compaction/terminal.js";
 import { deepRepairHistory } from "../plugins/defaults/history-repair/terminal.js";
 import postCompactReinject from "../plugins/defaults/memory-retrieval/hooks/post-compact.js";
 import userPromptSubmitMemoryRetrieval, {
   type MemoryRetrievalHookContext,
 } from "../plugins/defaults/memory-retrieval/hooks/user-prompt-submit-temp.js";
-import { runHook } from "../plugins/pipeline.js";
-import type { TurnContext as PluginTurnContext } from "../plugins/types.js";
+import { DEFAULT_TIMEOUTS, runHook, runPipeline } from "../plugins/pipeline.js";
+import { getMiddlewaresFor } from "../plugins/registry.js";
+import type {
+  CompactionArgs,
+  CompactionResult,
+  OverflowReduceArgs,
+  OverflowReduceResult,
+  TurnContext as PluginTurnContext,
+} from "../plugins/types.js";
+import { PluginExecutionError, PluginTimeoutError } from "../plugins/types.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
 import { resolveActorTrust } from "../runtime/actor-trust-resolver.js";
@@ -144,8 +149,11 @@ import type {
 } from "./conversation-runtime-assembly.js";
 import {
   applyRuntimeInjections,
+  buildActiveDocuments,
+  buildActiveSurfaceContext,
   buildSubagentStatusBlock,
   buildUnifiedTurnContextBlock,
+  buildWorkspaceTopLevelContext,
   getSlackCompactionWatermarkForPrefix,
   inboundActorContextFromTrust,
   inboundActorContextFromTrustContext,
@@ -170,10 +178,6 @@ import type {
   UsageStats,
 } from "./message-protocol.js";
 import type { ConfirmationStateChanged } from "./message-types/messages.js";
-import {
-  type OverflowReduceArgs,
-  runOverflowReductionLoop,
-} from "./overflow-reduction-loop.js";
 import { parseActualTokensFromError } from "./parse-actual-tokens-from-error.js";
 import {
   persistUnsendableImageDowngrades,
@@ -213,12 +217,12 @@ function formatDiskPressureBlockedMessage(): string {
 // ── Plugin pipeline helpers ──────────────────────────────────────────
 //
 // Canonical {@link PluginTurnContext} builder threaded into every
-// `runHook` call inside `runAgentLoopImpl`. The orchestrator composes
+// `runPipeline` call inside `runAgentLoopImpl`. The orchestrator composes
 // the context on demand at each call site from ambient state rather than
 // carrying a persistent `TurnContext` instance across the turn.
 
 /**
- * Synthetic fallback trust context used when the orchestrator fires a hook
+ * Synthetic fallback trust context used when the orchestrator fires a pipeline
  * before the per-turn trust snapshot has been captured (e.g. invocations that
  * bypass `processMessage` / `drainQueue`). We bias to `unknown` rather than
  * `guardian` so a missing snapshot cannot accidentally grant elevated trust
@@ -230,14 +234,14 @@ const FALLBACK_TURN_TRUST: TrustContext = {
 };
 
 /**
- * Build the {@link TurnContext} passed to {@link runHook}.
+ * Build the {@link TurnContext} passed to {@link runPipeline}.
  *
- * Canonical source of truth for every hook call site inside the agent
- * loop. Every `runHook` invocation in `runAgentLoopImpl` (and in the
+ * Canonical source of truth for every pipeline call site inside the agent
+ * loop. Every `runPipeline` invocation in `runAgentLoopImpl` (and in the
  * handlers that share its ambient state) must route through this helper
  * rather than constructing a `TurnContext` literal inline — this keeps
  * `turnIndex`, trust resolution, and the `contextWindowManager` attachment
- * consistent across hooks, which in turn keeps structured logs
+ * consistent across pipeline slots, which in turn keeps structured logs
  * filtered by `conversationId`/`turnIndex` coherent across slots.
  *
  * Behavior:
@@ -249,9 +253,9 @@ const FALLBACK_TURN_TRUST: TrustContext = {
  *   level context, then {@link FALLBACK_TURN_TRUST}. The cascade matches
  *   the one inside the orchestrator's inline injection assembly so
  *   middleware reads the same trust class the runtime sees.
- * - `contextWindowManager` is attached unconditionally. Hooks that
- *   don't need it can ignore it; it remains available via the typed
- *   optional field on `TurnContext`.
+ * - `contextWindowManager` is attached unconditionally. Pipelines that
+ *   don't need it can ignore it; the default compaction plugin reads it
+ *   via the typed optional field on `TurnContext`.
  */
 function buildPluginTurnContext(
   ctx: AgentLoopConversationContext,
@@ -363,6 +367,8 @@ export interface AgentLoopConversationContext {
   currentTurnSurfaces: AssistantSurface[];
 
   workingDir: string;
+  workspaceTopLevelContext: string | null;
+  workspaceTopLevelDirty: boolean;
   channelCapabilities?: ChannelCapabilities;
   /** Per-turn snapshot of trustContext, frozen at message-processing start. */
   currentTurnTrustContext?: TrustContext;
@@ -388,6 +394,8 @@ export interface AgentLoopConversationContext {
   /** Task-run scope for the current turn. Cleared at turn end so queued/drained turns don't inherit it. */
   taskRunId?: string;
   assistantId?: string;
+  voiceCallControlPrompt?: string;
+  transportHints?: string[];
   clientTimezone?: string;
 
   readonly coreToolNames: Set<string>;
@@ -462,6 +470,7 @@ export interface AgentLoopConversationContext {
   getWorkspaceGitService?: (workspaceDir: string) => GitServiceInitializer;
   commitTurnChanges?: typeof commitTurnChanges;
 
+  refreshWorkspaceTopLevelContextIfNeeded(): void;
   markWorkspaceTopLevelDirty(): void;
   getQueueDepth(): number;
   hasQueuedMessages(): boolean;
@@ -763,6 +772,10 @@ export async function runAgentLoopImpl(
         : null,
     },
   );
+  const diskPressureContext =
+    diskPressureDecision.action === "allow-cleanup-mode"
+      ? { cleanupModeActive: true }
+      : null;
   ctx.diskPressureCleanupModeActive =
     diskPressureDecision.action === "allow-cleanup-mode";
 
@@ -872,6 +885,7 @@ export async function runAgentLoopImpl(
     // so this fires exactly once per `/compact` event.
     const consumedPostCompactReinject = ctx.pendingPostCompactReinject;
     ctx.pendingPostCompactReinject = false;
+    state.shouldInjectWorkspace = isFirstMessage || consumedPostCompactReinject;
     let compactedThisTurn = consumedPostCompactReinject;
     let slackCompactedThisTurn = false;
     const isSlackConversation = ctx.channelCapabilities?.channel === "slack";
@@ -1009,24 +1023,58 @@ export async function runAgentLoopImpl(
     // Skip auto-compaction while the circuit breaker is open. Force paths
     // and user-initiated /compact bypass this check.
     const autoCompactAllowed =
-      !(await ctx.agentLoop.compactionCircuit.isOpen());
+      !(await ctx.agentLoop.compactionCircuit.isOpen(ctx));
     if (compactCheck.needed && autoCompactAllowed) {
       ctx.emitActivityState("thinking", "context_compacting", {
         requestId: reqId,
       });
     }
+    const compactionOptions = {
+      precomputedEstimate: compactCheck.estimatedTokens,
+      overrideProfile: resolveCurrentOverrideProfile() ?? null,
+      actorTrustClass: resolveTurnActorTrustClass(ctx),
+    };
     let compacted: Awaited<
       ReturnType<typeof ctx.contextWindowManager.maybeCompact>
     > | null = null;
     if (autoCompactAllowed) {
-      compacted = await defaultCompact({
-        manager: ctx.contextWindowManager,
-        messages: messagesForStartOfTurnCompaction,
-        signal: abortController.signal,
-        precomputedEstimate: compactCheck.estimatedTokens,
-        overrideProfile: resolveCurrentOverrideProfile() ?? null,
-        actorTrustClass: resolveTurnActorTrustClass(ctx),
-      });
+      try {
+        compacted = (await runPipeline<CompactionArgs, CompactionResult>(
+          "compaction",
+          getMiddlewaresFor("compaction"),
+          (args) =>
+            defaultCompactionTerminal(args, buildPluginTurnContext(ctx, reqId)),
+          {
+            messages: messagesForStartOfTurnCompaction,
+            signal: abortController.signal,
+            options: compactionOptions,
+          },
+          buildPluginTurnContext(ctx, reqId),
+          DEFAULT_TIMEOUTS.compaction,
+        )) as Awaited<ReturnType<typeof ctx.contextWindowManager.maybeCompact>>;
+      } catch (err) {
+        if (err instanceof PluginTimeoutError) {
+          // Pipeline exceeded its budget. Record the failure so the circuit
+          // breaker tracks consecutive timeouts (it trips after three),
+          // then degrade gracefully by skipping compaction this turn —
+          // the turn proceeds with the un-compacted history rather than
+          // hard-failing. The inner summary call has been aborted by the
+          // runner's signal-linking, so updateSummary's local fallback
+          // also ran before this catch block is reached.
+          rlog.warn(
+            { err, phase: "start-of-turn-compaction" },
+            "Compaction pipeline timed out — skipping compaction this turn",
+          );
+          await ctx.agentLoop.compactionCircuit.recordOutcome(
+            ctx,
+            true,
+            onEvent,
+          );
+          compacted = null;
+        } else {
+          throw err;
+        }
+      }
     }
     // Only track circuit-breaker state when a summary LLM call actually ran.
     // `summaryFailed` is `undefined` on early returns (compaction disabled,
@@ -1035,6 +1083,7 @@ export async function runAgentLoopImpl(
     // the 3-strike counter and break the invariant.
     if (compacted && compacted.summaryFailed !== undefined) {
       await ctx.agentLoop.compactionCircuit.recordOutcome(
+        ctx,
         compacted.summaryFailed,
         onEvent,
       );
@@ -1044,6 +1093,7 @@ export async function runAgentLoopImpl(
         compacted,
         messagesForStartOfTurnCompaction,
       );
+      state.shouldInjectWorkspace = true;
       if (compacted.compactedPersistedMessages > 0) {
         compactedThisTurn = true;
       }
@@ -1301,7 +1351,26 @@ export async function runAgentLoopImpl(
 
     // Shared injection options — reused whenever we need to re-inject after reduction.
     const injectionOpts = {
+      diskPressureContext,
+      // Resolved from the conversation's surface state here, where the
+      // runtime injector is the only consumer of the active-surface block.
+      activeSurface: buildActiveSurfaceContext({
+        currentActiveSurfaceId: ctx.currentActiveSurfaceId,
+        currentPage: ctx.currentPage,
+        surfaceState: ctx.surfaceState,
+      }),
+      // Resolved here, where the runtime injector is the only consumer of the
+      // active-documents block.
+      activeDocuments: buildActiveDocuments(ctx.conversationId),
+      workspaceTopLevelContext: buildWorkspaceTopLevelContext(
+        ctx,
+        state.shouldInjectWorkspace,
+      ),
+      channelCapabilities: ctx.channelCapabilities ?? null,
+      channelCommandContext: ctx.commandIntent ?? null,
       unifiedTurnContext: unifiedTurnContextStr,
+      voiceCallControlPrompt: ctx.voiceCallControlPrompt ?? null,
+      transportHints: ctx.transportHints ?? null,
       isNonInteractive: !isInteractiveResolved,
       isBackgroundConversation: isBackgroundConversationType(
         turnStartConversation?.conversationType,
@@ -1406,12 +1475,16 @@ export async function runAgentLoopImpl(
         "Preflight budget exceeded — running overflow reducer before provider call",
       );
 
-      // `runOverflowReductionLoop` drives the tier loop — forced compaction →
-      // tool-result truncation → media stubbing → injection downgrade — plus
-      // the re-inject/re-estimate convergence check. The callbacks below are
-      // the orchestrator-specific side effects it coordinates per iteration
-      // (activity emission, compaction application, runtime injection
-      // reassembly, token re-estimation).
+      // Overflow reduction runs through the plugin pipeline. The default
+      // middleware (`default-overflow-reduce`, registered at bootstrap)
+      // contains the historical tier loop — forced compaction → tool-result
+      // truncation → media stubbing → injection downgrade — plus the
+      // re-inject/re-estimate convergence check. The callbacks below are
+      // the orchestrator-specific side effects that the plugin coordinates
+      // per iteration (activity emission, compaction application, runtime
+      // injection reassembly, token re-estimation). Registered plugins that
+      // wrap the `overflowReduce` slot see each iteration through their own
+      // middleware `next` callback.
       const messagesForPreflightOverflowReduction =
         slackChronologicalContext?.messages ?? ctx.messages;
       const overflowArgs: OverflowReduceArgs = {
@@ -1425,18 +1498,72 @@ export async function runAgentLoopImpl(
         maxAttempts: resolveCurrentContextBudget().overflowRecovery.maxAttempts,
         abortSignal: abortController.signal,
         compactFn: async (msgs, signal, opts) => {
-          // Delegate the reducer's forced-compaction tier to the default
-          // compaction plugin, overlaying the turn's resolved inference
-          // profile and actor trust class onto the reducer-supplied options.
-          const reducerOptions = (opts ?? {}) as ContextWindowCompactOptions;
-          return defaultCompact({
-            manager: ctx.contextWindowManager,
-            messages: msgs,
-            signal,
-            ...reducerOptions,
-            overrideProfile: resolveCurrentOverrideProfile() ?? null,
-            actorTrustClass: resolveTurnActorTrustClass(ctx),
-          });
+          // Route the reducer's forced-compaction tier through the
+          // `compaction` pipeline so registered plugins observe these
+          // invocations. Without this, custom compaction middleware only
+          // sees the three orchestrator-owned call sites and misses the
+          // reducer-initiated forced compactions entirely.
+          //
+          // Pipeline timeouts must be caught locally — a `PluginTimeoutError`
+          // bubbling out of here would abort the overflow-reducer tier loop
+          // entirely, skipping fallback tiers (tool-result truncation, media
+          // stubbing, injection downgrade) and bypassing circuit-breaker
+          // bookkeeping. On timeout, record the failure and return a
+          // `compacted: false` result so the reducer falls through to the
+          // next tier.
+          try {
+            return (await runPipeline<CompactionArgs, CompactionResult>(
+              "compaction",
+              getMiddlewaresFor("compaction"),
+              (args) =>
+                defaultCompactionTerminal(
+                  args,
+                  buildPluginTurnContext(ctx, reqId),
+                ),
+              {
+                messages: msgs,
+                signal,
+                options: {
+                  ...(opts ?? {}),
+                  overrideProfile: resolveCurrentOverrideProfile() ?? null,
+                  actorTrustClass: resolveTurnActorTrustClass(ctx),
+                },
+              },
+              buildPluginTurnContext(ctx, reqId),
+              DEFAULT_TIMEOUTS.compaction,
+            )) as Awaited<
+              ReturnType<typeof ctx.contextWindowManager.maybeCompact>
+            >;
+          } catch (err) {
+            if (err instanceof PluginTimeoutError) {
+              rlog.warn(
+                { err, phase: "overflow-reducer-forced-compaction" },
+                "Compaction pipeline timed out — falling through to next reducer tier",
+              );
+              await ctx.agentLoop.compactionCircuit.recordOutcome(
+                ctx,
+                true,
+                onEvent,
+              );
+              return {
+                messages: msgs,
+                compacted: false,
+                previousEstimatedInputTokens: 0,
+                estimatedInputTokens: 0,
+                maxInputTokens: 0,
+                thresholdTokens: 0,
+                compactedMessages: 0,
+                compactedPersistedMessages: 0,
+                summaryCalls: 0,
+                summaryInputTokens: 0,
+                summaryOutputTokens: 0,
+                summaryModel: "",
+                summaryText: "",
+                reason: "compaction pipeline timed out",
+              };
+            }
+            throw err;
+          }
         },
         emitActivityState: () => {
           ctx.emitActivityState("thinking", "context_compacting", {
@@ -1455,12 +1582,14 @@ export async function runAgentLoopImpl(
           // breaker.
           if (result.summaryFailed !== undefined) {
             await ctx.agentLoop.compactionCircuit.recordOutcome(
+              ctx,
               result.summaryFailed,
               onEvent,
             );
           }
           if (result.compacted) {
             await applySuccessfulCompaction(result, compactedBasis);
+            state.shouldInjectWorkspace = true;
           }
         },
         reinjectForMode: async (
@@ -1471,10 +1600,9 @@ export async function runAgentLoopImpl(
         ) => {
           // Mirror the pre-PR-23 behavior: `ctx.messages` must track the
           // reducer's latest output before re-injection runs, because other
-          // sites consulted through `injectionOpts` (slack history, etc.) and
-          // the injectors' own message-presence scans depend on it, and
-          // `applyCompactionResult` only updates `ctx.messages` on a
-          // compaction tier. Assigning here
+          // sites consulted through `injectionOpts` (`workspaceTopLevelContext`,
+          // slack history, etc.) depend on it and `applyCompactionResult`
+          // only updates `ctx.messages` on a compaction tier. Assigning here
           // keeps non-compaction tiers (tool-result truncation, media
           // stubbing, injection downgrade) observable to downstream
           // injection assembly on the same turn.
@@ -1490,6 +1618,10 @@ export async function runAgentLoopImpl(
           // present in `reducedMessages`.)
           const injection = await applyRuntimeInjections(reducedMessages, {
             ...injectionOpts,
+            workspaceTopLevelContext: buildWorkspaceTopLevelContext(
+              ctx,
+              state.shouldInjectWorkspace,
+            ),
             // Once ANY iteration has compacted `ctx.messages`, the captured
             // `slackChronologicalMessages` snapshot (built from the full
             // persisted transcript) would overwrite the compacted history
@@ -1515,7 +1647,29 @@ export async function runAgentLoopImpl(
           }),
       };
 
-      const overflowResult = await runOverflowReductionLoop(overflowArgs);
+      const overflowResult = await runPipeline<
+        OverflowReduceArgs,
+        OverflowReduceResult
+      >(
+        "overflowReduce",
+        getMiddlewaresFor("overflowReduce"),
+        // Terminal — only reached when every registered middleware calls
+        // `next` and delegates past the innermost layer. The default plugin
+        // is a terminal itself (it doesn't call `next`), so in practice
+        // this fallback fires only when the default has been explicitly
+        // deregistered (tests) and no user plugin replaces it. Strict-fail
+        // semantics: throw so the missing terminal surfaces as a visible
+        // error instead of silently returning the history untouched.
+        async () => {
+          throw new PluginExecutionError(
+            "overflowReduce pipeline has no terminal handler — every reducer middleware called next() without providing a replacement",
+            "overflowReduce",
+          );
+        },
+        overflowArgs,
+        buildPluginTurnContext(ctx, reqId),
+        DEFAULT_TIMEOUTS.overflowReduce,
+      );
 
       ctx.messages = overflowResult.messages;
       runMessages = overflowResult.runMessages;
@@ -1618,6 +1772,10 @@ export async function runAgentLoopImpl(
         // presence.
         const injection = await postCompactReinject({
           ...injectionOpts,
+          workspaceTopLevelContext: buildWorkspaceTopLevelContext(
+            ctx,
+            state.shouldInjectWorkspace,
+          ),
           // Suppress the chronological-transcript snapshot once the reducer
           // has collapsed `ctx.messages`; the captured snapshot reflects the
           // full persisted transcript and would overwrite compaction.
@@ -1627,6 +1785,7 @@ export async function runAgentLoopImpl(
           mode: currentInjectionMode,
           turnContext,
           history,
+          isTrustedActor,
           logger: rlog,
         });
         return injection.messages;
@@ -1905,12 +2064,14 @@ export async function runAgentLoopImpl(
             );
             if (emergencyResult.summaryFailed !== undefined) {
               await ctx.agentLoop.compactionCircuit.recordOutcome(
+                ctx,
                 emergencyResult.summaryFailed,
                 onEvent,
               );
             }
             if (emergencyResult.compacted) {
               await applySuccessfulCompaction(emergencyResult, ctx.messages);
+              state.shouldInjectWorkspace = true;
             }
             // Clear the overflow flag and re-run the agent loop with
             // the compacted context.
@@ -1979,6 +2140,7 @@ export async function runAgentLoopImpl(
           step.compactionResult.summaryFailed !== undefined
         ) {
           await ctx.agentLoop.compactionCircuit.recordOutcome(
+            ctx,
             step.compactionResult.summaryFailed,
             onEvent,
           );
@@ -1989,6 +2151,7 @@ export async function runAgentLoopImpl(
             step.compactionResult,
             convergenceCompactionBasis,
           );
+          state.shouldInjectWorkspace = true;
           state.reducerCompacted = true;
         }
 
@@ -1999,6 +2162,10 @@ export async function runAgentLoopImpl(
         // present in `ctx.messages`.)
         const injection = await applyRuntimeInjections(ctx.messages, {
           ...injectionOpts,
+          workspaceTopLevelContext: buildWorkspaceTopLevelContext(
+            ctx,
+            state.shouldInjectWorkspace,
+          ),
           slackChronologicalMessages: state.reducerCompacted
             ? null
             : injectionOpts.slackChronologicalMessages,
@@ -2061,25 +2228,71 @@ export async function runAgentLoopImpl(
           ctx.emitActivityState("thinking", "context_compacting", {
             requestId: reqId,
           });
-          const emergencyCompact = await defaultCompact({
-            manager: ctx.contextWindowManager,
-            messages: ctx.messages,
-            signal: abortController.signal,
-            force: true,
-            minKeepRecentUserTurns: 0,
-            overrideProfile: resolveCurrentOverrideProfile() ?? null,
-          });
+          let emergencyCompact: Awaited<
+            ReturnType<typeof ctx.contextWindowManager.maybeCompact>
+          > | null = null;
+          try {
+            emergencyCompact = (await runPipeline<
+              CompactionArgs,
+              CompactionResult
+            >(
+              "compaction",
+              getMiddlewaresFor("compaction"),
+              (args) =>
+                defaultCompactionTerminal(
+                  args,
+                  buildPluginTurnContext(ctx, reqId),
+                ),
+              {
+                messages: ctx.messages,
+                signal: abortController.signal,
+                options: {
+                  force: true,
+                  minKeepRecentUserTurns: 0,
+                  overrideProfile: resolveCurrentOverrideProfile() ?? null,
+                },
+              },
+              buildPluginTurnContext(ctx, reqId),
+              DEFAULT_TIMEOUTS.compaction,
+            )) as Awaited<
+              ReturnType<typeof ctx.contextWindowManager.maybeCompact>
+            >;
+          } catch (err) {
+            if (err instanceof PluginTimeoutError) {
+              // Emergency compaction timed out. Record the circuit-breaker
+              // failure and fall through to the graceful-error path below
+              // (the unsuccessful-compaction fallback) rather than hard-
+              // failing the turn.
+              rlog.warn(
+                { err, phase: "emergency-compaction" },
+                "Emergency compaction pipeline timed out — continuing with overflow fallback",
+              );
+              await ctx.agentLoop.compactionCircuit.recordOutcome(
+                ctx,
+                true,
+                onEvent,
+              );
+              emergencyCompact = null;
+            } else {
+              throw err;
+            }
+          }
           // Only track when the summary LLM actually ran; `force: true`
           // bypasses the auto-threshold gate but not the early-return paths.
-          if (emergencyCompact.summaryFailed !== undefined) {
+          if (
+            emergencyCompact &&
+            emergencyCompact.summaryFailed !== undefined
+          ) {
             await ctx.agentLoop.compactionCircuit.recordOutcome(
+              ctx,
               emergencyCompact.summaryFailed,
               onEvent,
             );
           }
-          if (emergencyCompact.compacted) {
+          if (emergencyCompact?.compacted) {
             await applySuccessfulCompaction(emergencyCompact, ctx.messages);
             state.reducerCompacted = true;
+            state.shouldInjectWorkspace = true;
           }
 
           // Only re-inject the memory-static block when ctx.messages was
@@ -2089,6 +2302,10 @@ export async function runAgentLoopImpl(
           // present in `ctx.messages`.)
           const injection = await applyRuntimeInjections(ctx.messages, {
             ...injectionOpts,
+            workspaceTopLevelContext: buildWorkspaceTopLevelContext(
+              ctx,
+              state.shouldInjectWorkspace,
+            ),
             slackChronologicalMessages: state.reducerCompacted
               ? null
               : injectionOpts.slackChronologicalMessages,