@vellumai/assistant 0.8.0 → 0.8.2

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

@@ -11,6 +11,7 @@ import { join } from "node:path";
 
 import { v4 as uuid } from "uuid";
 
+import { optimizeImageForTransport } from "../agent/image-optimize.js";
 import type {
   AgentEvent,
   AgentLoop,
@@ -28,9 +29,11 @@ import {
   contextWindowConfigFromEffective,
   resolveEffectiveContextWindow,
 } from "../config/llm-context-resolution.js";
+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,
@@ -40,10 +43,9 @@ 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 { emitFeedEvent } from "../home/emit-feed-event.js";
 import { writeRelationshipState } from "../home/relationship-state-writer.js";
-import { rewriteFeedTitle } from "../home/rewrite-feed-title.js";
 import {
   clearSentryConversationContext,
   setSentryConversationContext,
@@ -71,13 +73,16 @@ import {
 } from "../memory/conversation-title-service.js";
 import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import { recordMemoryRecallLog } from "../memory/memory-recall-log-store.js";
+import { enqueueMemoryRetrospectiveOnCompaction } from "../memory/memory-retrospective-enqueue.js";
 import { PKB_WORKSPACE_SCOPE } from "../memory/pkb/types.js";
 import type { QdrantSparseVector } from "../memory/qdrant-client.js";
 import {
   readMemoryV2StaticContent,
-  shouldLoadMemoryV2Static,
+  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 {
@@ -89,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,
@@ -123,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";
@@ -147,6 +153,7 @@ import {
   createEventHandlerState,
   dispatchAgentEvent,
   type EventHandlerDeps,
+  getClientDisplayMessageId,
 } from "./conversation-agent-loop-handlers.js";
 import {
   approveHostAttachmentRead,
@@ -200,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";
@@ -453,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. */
@@ -679,7 +699,9 @@ export async function runAgentLoopImpl(
     overrideProfile: turnOverrideProfile ?? undefined,
   });
   const turnContextWindowConfig = contextWindowConfigFromEffective(
-    config.llm.default.contextWindow,
+    resolveCallSiteConfig(turnCallSite, config.llm, {
+      overrideProfile: turnOverrideProfile ?? undefined,
+    }).contextWindow,
     effectiveContextWindow,
   );
   (
@@ -763,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
@@ -867,6 +901,13 @@ export async function runAgentLoopImpl(
             conversationId: ctx.conversationId,
             title,
           });
+          onEvent({
+            type: "sync_changed",
+            tags: [
+              SYNC_TAGS.conversationsList,
+              conversationMetadataSyncTag(ctx.conversationId),
+            ],
+          });
         },
       };
       setTimeout(() => {
@@ -888,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 =
@@ -1097,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 = (
@@ -1324,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.
@@ -1411,33 +1470,48 @@ export async function runAgentLoopImpl(
 
     // The `remember` tool handles scratchpad-style memory writes directly to the graph.
 
+    // Personal-memory trust gate: PKB, NOW.md, and v2 static blocks all
+    // hold private user content. Block exposure to non-guardian actors
+    // arriving over a remote channel; internal/local flows pass through.
+    // See `shouldExposePersonalMemory` for the threat model.
+    const personalMemoryAllowed = shouldExposePersonalMemory({
+      sourceChannel: ctx.trustContext?.sourceChannel,
+      isTrustedActor,
+    });
+
     // Inject NOW.md and PKB content only on the first turn (or after
     // compaction re-strips them).  Old injections persist in history and
     // 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 = memoryResult.nowContent;
+    // 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;
 
-    const currentPkbContent = memoryResult.pkbContent;
+    const currentPkbContent = personalMemoryAllowed
+      ? memoryResult.pkbContent
+      : null;
     const pkbContext = shouldInjectNowAndPkb ? currentPkbContent : null;
     const pkbActive = currentPkbContent !== null;
 
-    // V2 static memory block (essentials/threads/recent/buffer). Same
-    // first-turn / post-compaction cadence as PKB. `shouldLoadMemoryV2Static`
-    // also blocks remote-channel non-guardian actors from inducing the
-    // model to recite private memory; `readMemoryV2StaticContent` self-gates
-    // on the v2 flag + config and returns null when v2 is off, so the file
-    // reads are skipped on non-injection turns.
-    const currentMemoryV2Static = shouldLoadMemoryV2Static({
-      shouldInjectNowAndPkb,
-      sourceChannel: ctx.trustContext?.sourceChannel,
-      isTrustedActor,
-    })
+    // V2 static memory block (essentials/threads/recent/buffer).
+    // `currentMemoryV2Static` is the trust-gated content reused by every
+    // re-injection path — it stays non-null on non-full-mode turns so
+    // that mid-turn reducer compaction (which strips the prior `<memory>`
+    // block) can restore the freshest content. `memoryV2Static` is the
+    // first-turn / post-compaction cadence-gated value for initial
+    // injection only. `readMemoryV2StaticContent` self-gates on the v2
+    // flag + config and returns null when v2 is off.
+    const currentMemoryV2Static = personalMemoryAllowed
       ? readMemoryV2StaticContent()
       : null;
-    const memoryV2Static = currentMemoryV2Static;
+    const memoryV2Static = shouldInjectNowAndPkb ? currentMemoryV2Static : null;
 
     // PKB relevance-hint inputs. Resolved once per turn and reused across
     // re-injections so post-compaction rebuilds pick up fresh hints against
@@ -1520,6 +1594,7 @@ export async function runAgentLoopImpl(
     const injectionOpts = {
       diskPressureContext,
       activeSurface,
+      activeDocuments,
       workspaceTopLevelContext: shouldInjectWorkspace
         ? ctx.workspaceTopLevelContext
         : null,
@@ -1575,7 +1650,8 @@ export async function runAgentLoopImpl(
       injection.blocks.pkbSystemReminder ||
       injection.blocks.workspaceBlock ||
       injection.blocks.nowScratchpadBlock ||
-      injection.blocks.pkbContextBlock
+      injection.blocks.pkbContextBlock ||
+      injection.blocks.memoryV2StaticBlock
     ) {
       try {
         const metadataUpdates: Record<string, unknown> = {};
@@ -1597,6 +1673,10 @@ export async function runAgentLoopImpl(
         if (injection.blocks.pkbContextBlock) {
           metadataUpdates.pkbContextBlock = injection.blocks.pkbContextBlock;
         }
+        if (injection.blocks.memoryV2StaticBlock) {
+          metadataUpdates.memoryV2StaticBlock =
+            injection.blocks.memoryV2StaticBlock;
+        }
         await runPipeline<PersistArgs, PersistResult>(
           "persistence",
           getMiddlewaresFor("persistence"),
@@ -1948,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(
@@ -2240,6 +2344,83 @@ export async function runAgentLoopImpl(
       }
     }
 
+    // ── Image-dimension overflow recovery ──────────────────────────
+    // When the provider rejects because an image block exceeds its pixel
+    // cap, strip every image block from ctx.messages and retry once.
+    // optimizeImageForTransport already ran at upload time; if sips was
+    // unavailable (non-macOS) it returns the same bytes unchanged.  In
+    // that case we swap the block for a text note so the model can tell
+    // the user what happened instead of hard-failing with a red banner.
+    if (state.imageTooLargeDetected) {
+      state.imageTooLargeDetected = false;
+      rlog.warn(
+        { phase: "image-recovery" },
+        "Image too large — stripping oversized image blocks and retrying",
+      );
+      ctx.messages = ctx.messages.map((msg) => {
+        if (!Array.isArray(msg.content)) return msg;
+        if (!msg.content.some((b) => b.type === "image")) return msg;
+        return {
+          ...msg,
+          content: msg.content.flatMap((b): ContentBlock[] => {
+            if (b.type !== "image") return [b];
+            const resized = optimizeImageForTransport(
+              b.source.data,
+              b.source.media_type,
+            );
+            if (resized.data !== b.source.data) {
+              // sips managed to downscale — use the smaller version
+              return [
+                {
+                  ...b,
+                  source: {
+                    type: "base64" as const,
+                    media_type: resized.mediaType,
+                    data: resized.data,
+                  },
+                },
+              ];
+            }
+            // Can't resize — replace with a text annotation so the model
+            // can explain the situation rather than silently dropping context
+            return [
+              {
+                type: "text" as const,
+                text: "(An image was attached but could not be sent — its dimensions exceed the provider limit and automatic resize was not available. Please resize the image and try again.)",
+              },
+            ];
+          }),
+        };
+      });
+      runMessages = ctx.messages;
+      updatedHistory = await ctx.agentLoop.run(
+        runMessages,
+        eventHandler,
+        abortController.signal,
+        reqId,
+        onCheckpoint,
+        turnCallSite,
+        loopTurnCtx,
+        turnOverrideProfile,
+        effectiveContextWindow.maxInputTokens,
+      );
+      if (state.imageTooLargeDetected) {
+        rlog.error(
+          { phase: "image-recovery" },
+          "Image-recovery retry also failed — surfacing error to user",
+        );
+        const classified = classifyConversationError(
+          new Error("Image dimensions too large"),
+          { phase: "agent_loop" },
+        );
+        deps.onEvent(
+          buildConversationErrorMessage(deps.ctx.conversationId, classified),
+        );
+        state.providerErrorUserMessage = classified.userMessage;
+        state.imageTooLargeDetected = false;
+      }
+    }
+
     // ── Bounded context overflow convergence loop ──────────────────
     // When the provider rejects with context-too-large, iterate through
     // reducer tiers (forced compaction, tool-result truncation, media
@@ -2311,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;
 
@@ -2717,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
@@ -2792,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.
@@ -2811,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(
@@ -2834,6 +3074,7 @@ export async function runAgentLoopImpl(
       ctx.lastAssistantAttachments = assistantAttachments;
       ctx.lastAttachmentWarnings = attachmentResult.directiveWarnings;
       syncLastAssistantMessageToDisk();
+      const clientDisplayMessageId = getClientDisplayMessageId(state);
 
       // Re-check: the user may have cancelled during attachment resolution
       if (abortController.signal.aborted) {
@@ -2850,6 +3091,7 @@ export async function runAgentLoopImpl(
           type: "generation_cancelled",
           conversationId: ctx.conversationId,
         });
+        publishLoopMessagesChanged();
       } else if (yieldedForHandoff) {
         ctx.traceEmitter.emit(
           "generation_handoff",
@@ -2874,7 +3116,11 @@ export async function runAgentLoopImpl(
           ...(state.lastAssistantMessageId
             ? { messageId: state.lastAssistantMessageId }
             : {}),
+          ...(clientDisplayMessageId
+            ? { displayMessageId: clientDisplayMessageId }
+            : {}),
         });
+        publishLoopMessagesChanged();
       } else {
         ctx.emitActivityState("idle", "message_complete", "global", reqId);
         ctx.traceEmitter.emit(
@@ -2897,85 +3143,11 @@ export async function runAgentLoopImpl(
           ...(state.lastAssistantMessageId
             ? { messageId: state.lastAssistantMessageId }
             : {}),
+          ...(clientDisplayMessageId
+            ? { displayMessageId: clientDisplayMessageId }
+            : {}),
         });
-
-        // Emit a home-feed event for background/scheduled conversation completions.
-        // Scoped to message_complete only (not cancelled/handoff), wrapped in
-        // try-catch so malformed message content can never propagate errors.
-        try {
-          const conv = getConversation(ctx.conversationId);
-          if (
-            conv &&
-            (conv.conversationType === "background" ||
-              conv.conversationType === "scheduled")
-          ) {
-            const lastMsg = state.lastAssistantMessageId
-              ? getMessageById(state.lastAssistantMessageId, ctx.conversationId)
-              : undefined;
-            let summary: string;
-            if (lastMsg) {
-              const parsed: unknown = JSON.parse(lastMsg.content);
-              if (typeof parsed === "string") {
-                summary = parsed.slice(0, 200);
-              } else if (Array.isArray(parsed)) {
-                const textBlock = parsed.find(
-                  (b: { type?: string }) => b.type === "text",
-                );
-                summary =
-                  typeof textBlock?.text === "string"
-                    ? textBlock.text.slice(0, 200)
-                    : (conv.title ?? "Background task completed.");
-              } else {
-                summary = conv.title ?? "Background task completed.";
-              }
-            } else {
-              summary = conv.title ?? "Background task completed.";
-            }
-            const feedTitle =
-              conv.title && !isReplaceableTitle(conv.title)
-                ? conv.title
-                : "Background task";
-            const dedupKey = `bg-conv:${ctx.conversationId}`;
-            void emitFeedEvent({
-              source: "assistant",
-              title: feedTitle,
-              summary,
-              dedupKey,
-              conversationId: ctx.conversationId,
-            }).catch((err) => {
-              log.warn(
-                { err, conversationId: ctx.conversationId },
-                "Failed to emit background conversation feed event",
-              );
-            });
-
-            if (isReplaceableTitle(conv.title ?? null)) {
-              void rewriteFeedTitle(feedTitle)
-                .then((prose) => {
-                  if (prose && prose !== feedTitle) {
-                    return emitFeedEvent({
-                      source: "assistant",
-                      title: prose,
-                      summary,
-                      dedupKey,
-                      conversationId: ctx.conversationId,
-                    });
-                  }
-                })
-                .catch((err) => {
-                  log.warn(
-                    { err, conversationId: ctx.conversationId },
-                    "Failed to update feed event with prose title rewrite",
-                  );
-                });
-            }
-          }
-        } catch (feedErr) {
-          log.warn(
-            { err: feedErr, conversationId: ctx.conversationId },
-            "Failed to build home-feed event for background conversation",
-          );
-        }
+        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).
@@ -3030,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,
       });
@@ -3054,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);
@@ -3078,6 +3258,7 @@ export async function runAgentLoopImpl(
         errorCategory: classified.errorCategory,
       });
       onEvent(buildConversationErrorMessage(ctx.conversationId, classified));
+      publishLoopMessagesChanged();
     }
   } finally {
     if (turnStarted) {
@@ -3208,6 +3389,7 @@ export interface CompactionApplyContext {
   messages: Message[];
   contextCompactedMessageCount: number;
   contextCompactedAt: number | null;
+  pendingPostCompactReinject: boolean;
   readonly graphMemory: ConversationGraphMemory;
   readonly provider: Provider;
   usageStats: UsageStats;
@@ -3257,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,
@@ -3274,6 +3460,10 @@ export async function applyCompactionResult(
     ctx.conversationId,
     ctx.trustContext?.trustClass,
   );
+  enqueueMemoryRetrospectiveOnCompaction(
+    ctx.conversationId,
+    ctx.trustContext?.trustClass,
+  );
   const summarySignals = computeSummaryQualitySignals(result.summaryText);
   onEvent({
     type: "context_compacted",