@vellumai/assistant 0.8.1 → 0.8.3

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 {
@@ -69,7 +71,9 @@ import {
   isReplaceableTitle,
   queueRegenerateConversationTitle,
 } from "../memory/conversation-title-service.js";
+import { isBackgroundConversationType } from "../memory/conversation-types.js";
 import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
+import { backfillMessageIdOnLogs } from "../memory/llm-request-log-store.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";
@@ -79,6 +83,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 +96,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,
@@ -105,6 +111,7 @@ import type {
   MemoryResult,
   OverflowReduceArgs,
   OverflowReduceResult,
+  PersistAddResult,
   PersistArgs,
   PersistResult,
   TurnContext as PluginTurnContext,
@@ -124,6 +131,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 +210,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 +467,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 +788,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 +904,13 @@ export async function runAgentLoopImpl(
             conversationId: ctx.conversationId,
             title,
           });
+          onEvent({
+            type: "sync_changed",
+            tags: [
+              SYNC_TAGS.conversationsList,
+              conversationMetadataSyncTag(ctx.conversationId),
+            ],
+          });
         },
       };
       setTimeout(() => {
@@ -892,8 +932,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 +1147,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 +1372,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 +1487,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 +1597,7 @@ export async function runAgentLoopImpl(
     const injectionOpts = {
       diskPressureContext,
       activeSurface,
+      activeDocuments,
       workspaceTopLevelContext: shouldInjectWorkspace
         ? ctx.workspaceTopLevelContext
         : null,
@@ -1556,6 +1619,9 @@ export async function runAgentLoopImpl(
       transportHints: ctx.transportHints ?? null,
       slackRuntimeContextNotice: ctx.slackRuntimeContextNotice ?? null,
       isNonInteractive: !isInteractiveResolved,
+      isBackgroundConversation: isBackgroundConversationType(
+        turnStartConversation?.conversationType,
+      ),
       subagentStatusBlock,
       slackChronologicalMessages,
       slackActiveThreadFocusBlock,
@@ -1968,6 +2034,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 +2498,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;
 
@@ -2800,7 +2948,7 @@ export async function runAgentLoopImpl(
       const errorAssistantMessage = createAssistantMessage(
         state.providerErrorUserMessage,
       );
-      await runPipeline<PersistArgs, PersistResult>(
+      const errorPersistResult = (await runPipeline<PersistArgs, PersistResult>(
         "persistence",
         getMiddlewaresFor("persistence"),
         defaultPersistenceTerminal,
@@ -2813,8 +2961,30 @@ export async function runAgentLoopImpl(
         },
         buildPluginTurnContext(ctx, reqId),
         DEFAULT_TIMEOUTS.persistence,
-      );
+      )) as PersistAddResult;
+      persistedErrorAssistantMessage = true;
       newMessages.push(errorAssistantMessage);
+      // Pipe the just-assigned message id into any orphaned LLM request log
+      // row(s) for this turn. The success path links rows via
+      // `handleMessageComplete` -> `backfillMessageIdOnLogs`, but provider-
+      // failure turns never fire `message_complete` (the synthetic assistant
+      // message is persisted directly above), so without this call the rows
+      // from `handleProviderError` stay with `message_id IS NULL` and a
+      // later turn's backfill sweep would wrong-attach them to that turn's
+      // assistant message. Scope is per-conversation, so concurrent runs on
+      // other conversations cannot collide. Non-fatal — a DB hiccup must
+      // not escalate a provider rejection into a turn-level throw.
+      try {
+        backfillMessageIdOnLogs(
+          ctx.conversationId,
+          errorPersistResult.message.id,
+        );
+      } catch (err) {
+        rlog.warn(
+          { err },
+          "Failed to backfill message_id on provider-error LLM request logs (non-fatal)",
+        );
+      }
       // Do NOT send assistant_text_delta here — handleProviderError already
       // emitted a conversation_error event for this same error text, and the
       // client renders it as an InlineChatErrorAlert. Sending a text delta
@@ -2889,7 +3059,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 +3077,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 +3118,7 @@ export async function runAgentLoopImpl(
           type: "generation_cancelled",
           conversationId: ctx.conversationId,
         });
+        publishLoopMessagesChanged();
       } else if (yieldedForHandoff) {
         ctx.traceEmitter.emit(
           "generation_handoff",
@@ -2976,6 +3147,7 @@ export async function runAgentLoopImpl(
             ? { displayMessageId: clientDisplayMessageId }
             : {}),
         });
+        publishLoopMessagesChanged();
       } else {
         ctx.emitActivityState("idle", "message_complete", "global", reqId);
         ctx.traceEmitter.emit(
@@ -3002,6 +3174,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 +3229,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 +3260,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 +3285,7 @@ export async function runAgentLoopImpl(
         errorCategory: classified.errorCategory,
       });
       onEvent(buildConversationErrorMessage(ctx.conversationId, classified));
+      publishLoopMessagesChanged();
     }
   } finally {
     if (turnStarted) {
@@ -3234,6 +3416,7 @@ export interface CompactionApplyContext {
   messages: Message[];
   contextCompactedMessageCount: number;
   contextCompactedAt: number | null;
+  pendingPostCompactReinject: boolean;
   readonly graphMemory: ConversationGraphMemory;
   readonly provider: Provider;
   usageStats: UsageStats;
@@ -3283,6 +3466,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,