@vellumai/assistant 0.8.1 → 0.8.2

package/src/daemon/approval-generators.ts

@@ -1,6 +1,8 @@
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { loadConfig } from "../config/loader.js";
 import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
 import { resolveDefaultProvider } from "../providers/connection-resolution.js";
+import { listProviders } from "../providers/registry.js";
 import type { Provider } from "../providers/types.js";
 import {
   APPROVAL_COPY_MAX_TOKENS,
@@ -16,6 +18,7 @@ import type {
   ApprovalConversationResult,
   ApprovalCopyGenerator,
 } from "../runtime/http-types.js";
+import { ProviderNotConfiguredError } from "../util/errors.js";
 
 // ---------------------------------------------------------------------------
 // Approval conversation generator constants
@@ -142,14 +145,13 @@ export function createApprovalConversationGenerator(): ApprovalConversationGener
     // Connection-aware default + per-call routing. `resolveDefaultProvider`
     // throws `ConnectionResolutionError` on hard config errors (missing /
     // unknown / mismatched connection) and returns null on soft credential
-    // failures (vault miss, transient auth) — we treat null as "no
-    // provider available" and throw a domain-specific error below. We do
-    // not pre-gate on `listProviders()` because the default provider lives
-    // behind a `provider_connection` and never appears in the registry's
-    // initialization-time provider list.
+    // failures (missing credential, platform auth unavailable).
     const baseProvider = await resolveDefaultProvider(config);
     if (!baseProvider) {
-      throw new Error("No provider available for approval conversation");
+      const resolved = resolveCallSiteConfig("mainAgent", config.llm);
+      throw new ProviderNotConfiguredError(resolved.provider, listProviders(), {
+        connectionName: resolved.provider_connection,
+      });
     }
     const provider = wrapWithCallSiteRouting(baseProvider, config);
 

package/src/daemon/config-watcher.ts

@@ -4,6 +4,7 @@
  * for changes.
  */
 import {
+  type Dirent,
   existsSync,
   type FSWatcher,
   mkdirSync,
@@ -12,13 +13,12 @@ import {
   watch,
   watchFile,
 } from "node:fs";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 
 import { getConfig, invalidateConfigCache } from "../config/loader.js";
 import type { MemoryCleanupConfig } from "../config/schemas/memory-lifecycle.js";
 import { resetCleanupScheduleThrottle } from "../memory/cleanup-schedule-state.js";
 import { clearEmbeddingBackendCache } from "../memory/embedding-backend.js";
-import { invalidateLlmRequestLogSourceCache } from "../memory/llm-request-log-source.js";
 import { initializeProviders } from "../providers/registry.js";
 import { handleCancelSignal } from "../signals/cancel.js";
 import { handleConversationUndoSignal } from "../signals/conversation-undo.js";
@@ -38,6 +38,25 @@ import { reloadMcpServers } from "./mcp-reload-service.js";
 
 const log = getLogger("config-watcher");
 
+const SKILL_WATCH_SKIPPED_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "__pycache__",
+  ".install-staging",
+  ".cache",
+  ".next",
+  ".turbo",
+  ".venv",
+  "coverage",
+]);
+
+function isSkippedSkillWatchPath(relativePath: string): boolean {
+  if (relativePath === "(unknown)") return false;
+
+  const segments = relativePath.split(/[\\/]+/).filter(Boolean);
+  return segments.some((segment) => SKILL_WATCH_SKIPPED_DIRS.has(segment));
+}
+
 /**
  * Attach a resilient error handler to an FSWatcher so that async errors
  * (e.g. ENXIO when a Unix socket file like `gateway.sock` appears in a
@@ -141,7 +160,6 @@ export class ConfigWatcher {
       return false;
     }
     clearEmbeddingBackendCache();
-    invalidateLlmRequestLogSourceCache();
     // If cleanup retention settings changed, reset the cleanup scheduler
     // throttle so the next worker tick re-enqueues jobs with the new values
     // instead of waiting out the remaining enqueueIntervalMs (default 6h).
@@ -160,6 +178,8 @@ export class ConfigWatcher {
    * Start all file watchers. `onConversationEvict` is called when watched
    * files change and conversations need to be evicted for reload.
    * `onIdentityChanged` is called when IDENTITY.md changes on disk.
+   * `onSkillsChanged` is called after skill directory changes evict
+   * conversations.
    */
   start(
     onConversationEvict: () => void,
@@ -167,6 +187,7 @@ export class ConfigWatcher {
     onSoundsConfigChanged?: () => void,
     onAvatarChanged?: () => void,
     onConfigChanged?: () => void,
+    onSkillsChanged?: () => void,
   ): void {
     // Reset the stopped flag so a stop()→start() cycle on the same
     // instance resumes hot-reload instead of silently bailing in every
@@ -222,7 +243,7 @@ export class ConfigWatcher {
 
     this.startSignalsWatcher();
     this.startUsersWatcher(onConversationEvict);
-    this.startSkillsWatchers(onConversationEvict);
+    this.startSkillsWatchers(onConversationEvict, onSkillsChanged);
   }
 
   stop(): void {
@@ -422,14 +443,20 @@ export class ConfigWatcher {
     }
   }
 
-  private startSkillsWatchers(onConversationEvict: () => void): void {
+  private startSkillsWatchers(
+    onConversationEvict: () => void,
+    onSkillsChanged?: () => void,
+  ): void {
     const skillsDir = getWorkspaceSkillsDir();
     if (!existsSync(skillsDir)) return;
 
     const scheduleSkillsReload = (file: string): void => {
-      this.debounceTimers.schedule(`skills:${file}`, () => {
+      if (isSkippedSkillWatchPath(file)) return;
+
+      this.debounceTimers.schedule("skills:catalog", () => {
         log.info({ file }, "Skill file changed, reloading");
         onConversationEvict();
+        onSkillsChanged?.();
       });
     };
 
@@ -478,43 +505,79 @@ export class ConfigWatcher {
       }
     };
 
-    const refreshChildWatchers = (): void => {
-      const nextChildDirs = new Set<string>();
+    const formatSkillChangeLabel = (
+      dirPath: string,
+      filename: string,
+    ): string => {
+      if (filename === "(unknown)") {
+        const relativeDir = relative(skillsDir, dirPath);
+        return relativeDir || "(unknown)";
+      }
+      const relativeFile = relative(skillsDir, join(dirPath, filename));
+      return relativeFile || filename;
+    };
 
+    const enumerateSkillSubdirectories = (
+      dirPath: string,
+      acc: Set<string>,
+    ): boolean => {
+      let entries: Dirent[];
       try {
-        const entries = readdirSync(skillsDir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (!entry.isDirectory()) continue;
-          const childDir = join(skillsDir, entry.name);
-          nextChildDirs.add(childDir);
-
-          if (childWatchers.has(childDir)) continue;
-
-          const watcher = watchDir(childDir, (filename) => {
-            const label =
-              filename === "(unknown)"
-                ? entry.name
-                : `${entry.name}/${filename}`;
-            scheduleSkillsReload(label);
-          });
-          if (watcher) {
-            childWatchers.set(childDir, watcher);
-          }
-        }
+        entries = readdirSync(dirPath, { withFileTypes: true });
       } catch (err) {
-        log.warn({ err, skillsDir }, "Failed to enumerate skill directories");
+        log.warn({ err, dirPath }, "Failed to enumerate skill directories");
+        return dirPath !== skillsDir;
+      }
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (SKILL_WATCH_SKIPPED_DIRS.has(entry.name)) continue;
+        const childDir = join(dirPath, entry.name);
+        acc.add(childDir);
+        enumerateSkillSubdirectories(childDir, acc);
+      }
+      return true;
+    };
+
+    const closeChildWatcher = (dirPath: string, watcher: FSWatcher): void => {
+      watcher.close();
+      childWatchers.delete(dirPath);
+      removeWatcher(watcher);
+    };
+
+    const refreshChildWatchers = (): void => {
+      const nextChildDirs = new Set<string>();
+      if (!enumerateSkillSubdirectories(skillsDir, nextChildDirs)) {
+        for (const [childDir, watcher] of childWatchers.entries()) {
+          closeChildWatcher(childDir, watcher);
+        }
         return;
       }
 
       for (const [childDir, watcher] of childWatchers.entries()) {
         if (nextChildDirs.has(childDir)) continue;
-        watcher.close();
-        childWatchers.delete(childDir);
-        removeWatcher(watcher);
+        closeChildWatcher(childDir, watcher);
+      }
+
+      for (const childDir of nextChildDirs) {
+        if (childWatchers.has(childDir)) continue;
+
+        const watcher = watchDir(childDir, (filename) => {
+          const file = formatSkillChangeLabel(childDir, filename);
+          if (isSkippedSkillWatchPath(file)) return;
+
+          scheduleSkillsReload(file);
+          refreshChildWatchers();
+        });
+        if (watcher) {
+          childWatchers.set(childDir, watcher);
+        }
       }
     };
 
     const rootWatcher = watchDir(skillsDir, (filename) => {
+      if (isSkippedSkillWatchPath(filename)) return;
+
       scheduleSkillsReload(filename);
       refreshChildWatchers();
     });

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

@@ -33,6 +33,7 @@ import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import type { ContextWindowConfig } from "../config/types.js";
+import { runEmergencyCompaction } from "../context/compactor.js";
 import {
   derefToolResultReReads,
   postTurnTruncateToolResults,
@@ -42,6 +43,7 @@ import {
   getCalibrationProviderKey,
 } from "../context/token-estimator.js";
 import type { ContextWindowManager } from "../context/window-manager.js";
+import { getDocumentsForConversation } from "../documents/document-store.js";
 import type { ToolProfiler } from "../events/tool-profiling-listener.js";
 import { writeRelationshipState } from "../home/relationship-state-writer.js";
 import {
@@ -79,6 +81,8 @@ import {
   shouldExposePersonalMemory,
 } from "../memory/v2/static-context.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
+import { HOOKS } from "../plugin-api/constants.js";
+import type { UserPromptSubmitContext } from "../plugin-api/types.js";
 import { defaultCompactionTerminal } from "../plugins/defaults/compaction.js";
 import { defaultHistoryRepairTerminal } from "../plugins/defaults/history-repair.js";
 import {
@@ -90,7 +94,7 @@ import {
 import { defaultPersistenceTerminal } from "../plugins/defaults/persistence.js";
 import { defaultTitleGenerateTerminal } from "../plugins/defaults/title-generate.js";
 import { defaultTokenEstimateTerminal } from "../plugins/defaults/token-estimate.js";
-import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
+import { DEFAULT_TIMEOUTS, runHook, runPipeline } from "../plugins/pipeline.js";
 import { getMiddlewaresFor } from "../plugins/registry.js";
 import type {
   CircuitBreakerArgs,
@@ -124,6 +128,7 @@ import type { Provider } from "../providers/types.js";
 import { resolveActorTrust } from "../runtime/actor-trust-resolver.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { redactSecrets } from "../security/secret-scanner.js";
 import { getSubagentManager } from "../subagent/index.js";
 import type { UsageActor } from "../usage/actors.js";
@@ -202,6 +207,10 @@ import type {
 } from "./message-protocol.js";
 import type { MemoryRecalled } from "./message-types/memory.js";
 import type { ConfirmationStateChanged } from "./message-types/messages.js";
+import {
+  conversationMetadataSyncTag,
+  SYNC_TAGS,
+} from "./message-types/sync.js";
 import { parseActualTokensFromError } from "./parse-actual-tokens-from-error.js";
 import type { TraceEmitter } from "./trace-emitter.js";
 import type { TrustContext } from "./trust-context.js";
@@ -455,6 +464,15 @@ export interface AgentLoopConversationContext {
   readonly contextWindowManager: ContextWindowManager;
   contextCompactedMessageCount: number;
   contextCompactedAt: number | null;
+  /**
+   * Set by `applyCompactionResult` when compaction strips runtime injections
+   * from the preserved tail. The next agent loop turn promotes this into a
+   * `compactedThisTurn` signal so NOW.md, PKB, and the v2 static block are
+   * re-injected on the first turn following `/compact` (which runs outside
+   * the agent loop and so has no other way to surface that compaction
+   * happened just before this turn).
+   */
+  pendingPostCompactReinject: boolean;
   /** Tracks consecutive compaction failures (summary LLM call threw). */
   consecutiveCompactionFailures: number;
   /** Timestamp (ms since epoch) until which the circuit breaker is open. */
@@ -767,6 +785,18 @@ export async function runAgentLoopImpl(
 
   ctx.profiler.startRequest();
   let turnStarted = false;
+  const state = createEventHandlerState();
+  let persistedErrorAssistantMessage = false;
+
+  const publishLoopMessagesChanged = (): void => {
+    if (
+      state.lastAssistantMessageId ||
+      state.persistedToolUseIds.size > 0 ||
+      persistedErrorAssistantMessage
+    ) {
+      publishConversationMessagesChanged(ctx.conversationId);
+    }
+  };
 
   // Populate Sentry scope with conversation-specific tags so any exception
   // captured during this turn (e.g. inside agent/loop.ts) can be
@@ -871,6 +901,13 @@ export async function runAgentLoopImpl(
             conversationId: ctx.conversationId,
             title,
           });
+          onEvent({
+            type: "sync_changed",
+            tags: [
+              SYNC_TAGS.conversationsList,
+              conversationMetadataSyncTag(ctx.conversationId),
+            ],
+          });
         },
       };
       setTimeout(() => {
@@ -892,8 +929,14 @@ export async function runAgentLoopImpl(
     }
 
     const isFirstMessage = ctx.messages.length === 1;
-    let shouldInjectWorkspace = isFirstMessage;
-    let compactedThisTurn = false;
+    // Promote a pending post-compaction re-inject signal (e.g. from `/compact`)
+    // into `compactedThisTurn` so NOW.md / PKB / v2 static blocks land on this
+    // turn even when no mid-turn compaction fires. Clear the flag immediately
+    // so this fires exactly once per `/compact` event.
+    const consumedPostCompactReinject = ctx.pendingPostCompactReinject;
+    ctx.pendingPostCompactReinject = false;
+    let shouldInjectWorkspace = isFirstMessage || consumedPostCompactReinject;
+    let compactedThisTurn = consumedPostCompactReinject;
     let slackCompactedThisTurn = false;
     const isSlackConversation = ctx.channelCapabilities?.channel === "slack";
     let currentSlackContextSummary =
@@ -1101,8 +1144,6 @@ export async function runAgentLoopImpl(
       }
     }
 
-    const state = createEventHandlerState();
-
     // Register confirmation outcome tracker so the agent loop can link
     // confirmation decisions to tool_use_ids for persistence.
     ctx.onConfirmationOutcome = (
@@ -1328,6 +1369,20 @@ export async function runAgentLoopImpl(
       }
     }
 
+    // Query active documents for this conversation so the injector chain
+    // can surface them to the assistant (prevents duplicate document_create
+    // calls when existing documents should be targeted with document_update).
+    const conversationDocs = getDocumentsForConversation(ctx.conversationId);
+    const activeDocuments =
+      conversationDocs.length > 0
+        ? conversationDocs.map((d) => ({
+            surfaceId: d.surfaceId,
+            title: d.title,
+            wordCount: d.wordCount,
+            updatedAt: d.updatedAt,
+          }))
+        : null;
+
     ctx.refreshWorkspaceTopLevelContextIfNeeded();
 
     // Compute fresh turn timestamp for date grounding.
@@ -1429,9 +1484,13 @@ export async function runAgentLoopImpl(
     // are never stripped on normal turns — this preserves the cached prefix.
     // PKB/NOW content is sourced from the `memoryRetrieval` pipeline above
     // so plugins can override either source without touching the agent loop.
-    const currentNowContent = personalMemoryAllowed
-      ? memoryResult.nowContent
-      : null;
+    // NOW.md injection can be disabled via `memory.retrieval.scratchpadInjection.enabled`.
+    const scratchpadInjectionEnabled =
+      getConfig().memory.retrieval.scratchpadInjection.enabled;
+    const currentNowContent =
+      personalMemoryAllowed && scratchpadInjectionEnabled
+        ? memoryResult.nowContent
+        : null;
     const shouldInjectNowAndPkb = isFirstMessage || compactedThisTurn;
     const nowScratchpad = shouldInjectNowAndPkb ? currentNowContent : null;
 
@@ -1535,6 +1594,7 @@ export async function runAgentLoopImpl(
     const injectionOpts = {
       diskPressureContext,
       activeSurface,
+      activeDocuments,
       workspaceTopLevelContext: shouldInjectWorkspace
         ? ctx.workspaceTopLevelContext
         : null,
@@ -1968,6 +2028,30 @@ export async function runAgentLoopImpl(
       runMessages = webSearchStrip.messages;
     }
 
+    // user-prompt-submit hook: plugins may transform `runMessages` right
+    // before the agent loop receives them. Fires once per user turn at
+    // the primary `agentLoop.run` only — the re-entry / retry calls
+    // further down in this function do not refire it (they're not new
+    // user submissions). Plugins may mutate `ctx.latestMessages` in place
+    // OR return a new context with a fresh array; `runHook` forwards
+    // whichever the chain settles on. Order is plugin registration order.
+    //
+    // Fires BEFORE `preRunHistoryLength` is captured so the boundary
+    // between pre-existing and hook-emitted messages — consumed by the
+    // ordering-error retry gate, the post-run reconcile loop, and the
+    // new-message extraction for persistence — reflects exactly what
+    // `agentLoop.run` receives.
+    const userPromptCtx: UserPromptSubmitContext = {
+      conversationId: ctx.conversationId,
+      originalMessages: ctx.messages,
+      latestMessages: runMessages,
+    };
+    const finalUserPromptCtx = await runHook(
+      HOOKS.USER_PROMPT_SUBMIT,
+      userPromptCtx,
+    );
+    runMessages = finalUserPromptCtx.latestMessages;
+
     let preRunHistoryLength = runMessages.length;
 
     const shouldGenerateTitle = isReplaceableTitle(
@@ -2408,6 +2492,64 @@ export async function runAgentLoopImpl(
         }
       }
 
+      // ── Emergency mid-turn compaction ────────────────────────────
+      // Before entering the reducer tier loop, attempt a targeted
+      // emergency compaction: summarize everything before the last
+      // tool_use + tool_result pair and let the agent continue with
+      // [summary, last_tool_call, last_tool_result]. This preserves
+      // the agent's most recent action context while aggressively
+      // compressing history. Falls through to reducer tiers on failure.
+      {
+        try {
+          const emergencyConfig = getConfig().compaction;
+          const emergencyResult = await runEmergencyCompaction({
+            conversationId: ctx.conversationId,
+            messages: ctx.messages,
+            provider: ctx.provider,
+            systemPrompt: ctx.systemPrompt,
+            tools: undefined,
+            compaction: emergencyConfig,
+            maxInputTokens: effectiveContextWindow.maxInputTokens,
+            previousEstimatedInputTokens: estimatedTokensAtOverflow,
+            force: true,
+            signal: abortController.signal,
+            overrideProfile: turnOverrideProfile ?? null,
+            nonPersistedPrefixCount:
+              ctx.contextWindowManager.nonPersistedPrefixCount,
+          });
+          if (emergencyResult.compacted) {
+            rlog.info(
+              {
+                phase: "convergence",
+                compactedMessages: emergencyResult.compactedMessages,
+                summaryChars: emergencyResult.summaryText.length,
+              },
+              "Emergency mid-turn compaction succeeded — bypassing reducer tiers",
+            );
+            if (emergencyResult.summaryFailed !== undefined) {
+              await trackCompactionOutcome(
+                ctx,
+                emergencyResult.summaryFailed,
+                onEvent,
+              );
+            }
+            if (emergencyResult.compacted) {
+              await applySuccessfulCompaction(emergencyResult, ctx.messages);
+              shouldInjectWorkspace = true;
+            }
+            // Clear the overflow flag and re-run the agent loop with
+            // the compacted context.
+            state.contextTooLargeDetected = false;
+          }
+        } catch (err) {
+          rlog.warn(
+            { phase: "convergence", err },
+            "Emergency mid-turn compaction failed; continuing to reducer tiers",
+          );
+        }
+        // If emergency compaction failed, fall through to reducer tiers.
+      }
+
       let convergenceAttempts = 0;
       const maxAttempts = overflowRecovery.maxAttempts;
 
@@ -2814,6 +2956,7 @@ export async function runAgentLoopImpl(
         buildPluginTurnContext(ctx, reqId),
         DEFAULT_TIMEOUTS.persistence,
       );
+      persistedErrorAssistantMessage = true;
       newMessages.push(errorAssistantMessage);
       // Do NOT send assistant_text_delta here — handleProviderError already
       // emitted a conversation_error event for this same error text, and the
@@ -2889,7 +3032,6 @@ export async function runAgentLoopImpl(
         convForDisk.createdAt,
       );
     };
-
     // Fast-path: when the user cancelled, skip expensive post-loop work
     // (attachment resolution) and emit the cancellation event immediately
     // so the client can re-enable the UI without delay.
@@ -2908,6 +3050,7 @@ export async function runAgentLoopImpl(
         type: "generation_cancelled",
         conversationId: ctx.conversationId,
       });
+      publishLoopMessagesChanged();
     } else {
       // Resolve attachments (only when not cancelled — this is expensive async I/O)
       const attachmentResult = await resolveAssistantAttachments(
@@ -2948,6 +3091,7 @@ export async function runAgentLoopImpl(
           type: "generation_cancelled",
           conversationId: ctx.conversationId,
         });
+        publishLoopMessagesChanged();
       } else if (yieldedForHandoff) {
         ctx.traceEmitter.emit(
           "generation_handoff",
@@ -2976,6 +3120,7 @@ export async function runAgentLoopImpl(
             ? { displayMessageId: clientDisplayMessageId }
             : {}),
         });
+        publishLoopMessagesChanged();
       } else {
         ctx.emitActivityState("idle", "message_complete", "global", reqId);
         ctx.traceEmitter.emit(
@@ -3002,6 +3147,7 @@ export async function runAgentLoopImpl(
             ? { displayMessageId: clientDisplayMessageId }
             : {}),
         });
+        publishLoopMessagesChanged();
 
         // Proactive artifact: fire once when the processed turn was the 4th user message.
         // Only trigger for real user-authored turns (not subagent/system messages).
@@ -3056,6 +3202,13 @@ export async function runAgentLoopImpl(
             conversationId: ctx.conversationId,
             title,
           });
+          onEvent({
+            type: "sync_changed",
+            tags: [
+              SYNC_TAGS.conversationsList,
+              conversationMetadataSyncTag(ctx.conversationId),
+            ],
+          });
         },
         signal: abortController.signal,
       });
@@ -3080,6 +3233,7 @@ export async function runAgentLoopImpl(
         type: "generation_cancelled",
         conversationId: ctx.conversationId,
       });
+      publishLoopMessagesChanged();
     } else {
       ctx.emitActivityState("idle", "error_terminal", "global", reqId);
       const message = err instanceof Error ? err.message : String(err);
@@ -3104,6 +3258,7 @@ export async function runAgentLoopImpl(
         errorCategory: classified.errorCategory,
       });
       onEvent(buildConversationErrorMessage(ctx.conversationId, classified));
+      publishLoopMessagesChanged();
     }
   } finally {
     if (turnStarted) {
@@ -3234,6 +3389,7 @@ export interface CompactionApplyContext {
   messages: Message[];
   contextCompactedMessageCount: number;
   contextCompactedAt: number | null;
+  pendingPostCompactReinject: boolean;
   readonly graphMemory: ConversationGraphMemory;
   readonly provider: Provider;
   usageStats: UsageStats;
@@ -3283,6 +3439,10 @@ export async function applyCompactionResult(
   ctx.contextCompactedMessageCount += result.compactedPersistedMessages;
   const compactedAt = Date.now();
   ctx.contextCompactedAt = compactedAt;
+  // Signal to the next agent loop turn that NOW.md / PKB / v2 static blocks
+  // were stripped from the tail and need fresh re-injection. Consumed and
+  // cleared at the top of the next `runAgentLoopImpl` run.
+  ctx.pendingPostCompactReinject = true;
   await ctx.graphMemory.onCompacted(result.compactedPersistedMessages);
   updateConversationContextWindow(
     ctx.conversationId,