@vellumai/assistant 0.6.3 → 0.6.4

package/src/daemon/config-watcher.ts

@@ -10,11 +10,12 @@ import {
   readdirSync,
   watch,
 } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 
 import { clearFeatureFlagOverridesCache } from "../config/assistant-feature-flags.js";
 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 { clearCache as clearTrustCache } from "../permissions/trust-store.js";
 import { initializeProviders } from "../providers/registry.js";
@@ -30,6 +31,7 @@ import { getLogger } from "../util/logger.js";
 import {
   AVATAR_IMAGE_FILENAME,
   getAvatarDir,
+  getProtectedDir,
   getSignalsDir,
   getSoundsDir,
   getWorkspaceDir,
@@ -38,6 +40,17 @@ import {
 
 const log = getLogger("config-watcher");
 
+/**
+ * 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
+ * watched directory) are logged instead of crashing the process.
+ */
+function attachWatcherErrorHandler(watcher: FSWatcher, dir: string): void {
+  watcher.on("error", (err) => {
+    log.warn({ err, dir }, "FSWatcher error (non-fatal, continuing)");
+  });
+}
+
 export class ConfigWatcher {
   private watchers: FSWatcher[] = [];
   private debounceTimers = new DebouncerMap({
@@ -94,6 +107,7 @@ export class ConfigWatcher {
    * Returns true if config actually changed.
    */
   async refreshConfigFromSources(): Promise<boolean> {
+    const prevCleanup = safeGetCleanupConfig();
     invalidateConfigCache();
     const config = getConfig();
     const fingerprint = this.configFingerprint(config);
@@ -102,6 +116,13 @@ export class ConfigWatcher {
     }
     clearTrustCache();
     clearEmbeddingBackendCache();
+    // 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).
+    const nextCleanup = config.memory?.cleanup;
+    if (cleanupSettingsChanged(prevCleanup, nextCleanup)) {
+      resetCleanupScheduleThrottle();
+    }
     const isFirstInit = this.lastFingerprint === "";
     await initializeProviders(config);
     this.lastFingerprint = fingerprint;
@@ -151,7 +172,6 @@ export class ConfigWatcher {
         onConversationEvict();
         onIdentityChanged?.();
       },
-      "USER.md": () => onConversationEvict(),
       "UPDATES.md": () => onConversationEvict(),
     };
 
@@ -170,6 +190,7 @@ export class ConfigWatcher {
             handlers[file]();
           });
         });
+        attachWatcherErrorHandler(watcher, dir);
         this.watchers.push(watcher);
         log.info({ dir }, `Watching ${label}`);
       } catch (err) {
@@ -195,6 +216,7 @@ export class ConfigWatcher {
 
     this.startFeatureFlagsWatcher(onFeatureFlagsChanged);
     this.startSignalsWatcher();
+    this.startUsersWatcher(onConversationEvict);
     this.startSkillsWatchers(onConversationEvict);
   }
 
@@ -227,6 +249,7 @@ export class ConfigWatcher {
           onSoundsConfigChanged();
         });
       });
+      attachWatcherErrorHandler(watcher, soundsDir);
       this.watchers.push(watcher);
       log.info({ dir: soundsDir }, "Watching sounds directory for changes");
     } catch (err) {
@@ -237,6 +260,40 @@ export class ConfigWatcher {
     }
   }
 
+  private startUsersWatcher(onConversationEvict: () => void): void {
+    const usersDir = join(getWorkspaceDir(), "users");
+    try {
+      if (!existsSync(usersDir)) {
+        mkdirSync(usersDir, { recursive: true });
+      }
+    } catch {
+      // If we can't create it, watching will also fail — handled below.
+    }
+
+    try {
+      const watcher = watch(usersDir, (_eventType, filename) => {
+        if (!filename) return;
+        const file = String(filename);
+        if (!file.endsWith(".md")) return;
+        this.debounceTimers.schedule(`file:users/${file}`, () => {
+          log.info({ file }, "Users persona file changed, reloading");
+          onConversationEvict();
+        });
+      });
+      attachWatcherErrorHandler(watcher, usersDir);
+      this.watchers.push(watcher);
+      log.info(
+        { dir: usersDir },
+        "Watching users directory for persona changes",
+      );
+    } catch (err) {
+      log.warn(
+        { err, dir: usersDir },
+        "Failed to watch users directory. Persona file changes will require a restart.",
+      );
+    }
+  }
+
   private startAvatarWatcher(onAvatarChanged: () => void): void {
     const avatarDir = getAvatarDir();
     try {
@@ -259,6 +316,7 @@ export class ConfigWatcher {
           onAvatarChanged();
         });
       });
+      attachWatcherErrorHandler(watcher, avatarDir);
       this.watchers.push(watcher);
       log.info({ dir: avatarDir }, "Watching avatar directory for changes");
     } catch (err) {
@@ -270,9 +328,7 @@ export class ConfigWatcher {
   }
 
   private startFeatureFlagsWatcher(onFeatureFlagsChanged?: () => void): void {
-    const protectedDir = process.env.GATEWAY_SECURITY_DIR
-      ? process.env.GATEWAY_SECURITY_DIR
-      : join(homedir(), ".vellum", "protected");
+    const protectedDir = process.env.GATEWAY_SECURITY_DIR || getProtectedDir();
 
     try {
       if (!existsSync(protectedDir)) {
@@ -305,6 +361,7 @@ export class ConfigWatcher {
           500,
         );
       });
+      attachWatcherErrorHandler(watcher, protectedDir);
       this.watchers.push(watcher);
       log.info(
         { dir: protectedDir },
@@ -367,6 +424,7 @@ export class ConfigWatcher {
           }
         }
       });
+      attachWatcherErrorHandler(watcher, signalsDir);
       this.watchers.push(watcher);
       log.info({ dir: signalsDir }, "Watching signals directory");
     } catch (err) {
@@ -396,6 +454,7 @@ export class ConfigWatcher {
           scheduleSkillsReload(filename ? String(filename) : "(unknown)");
         },
       );
+      attachWatcherErrorHandler(recursiveWatcher, skillsDir);
       this.watchers.push(recursiveWatcher);
       log.info({ dir: skillsDir }, "Watching skills directory recursively");
       return;
@@ -416,6 +475,7 @@ export class ConfigWatcher {
         const watcher = watch(dirPath, (_eventType, filename) => {
           onChange(filename ? String(filename) : "(unknown)");
         });
+        attachWatcherErrorHandler(watcher, dirPath);
         this.watchers.push(watcher);
         return watcher;
       } catch (err) {
@@ -481,3 +541,37 @@ export class ConfigWatcher {
     );
   }
 }
+
+/**
+ * Snapshot the current cleanup config so we can compare it against the
+ * post-reload value. Tolerant of config-load failures — if the config can't
+ * be read (e.g. first-load), returns undefined so the comparison below
+ * treats it as "no previous value".
+ */
+function safeGetCleanupConfig(): MemoryCleanupConfig | undefined {
+  try {
+    return getConfig().memory?.cleanup;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Return true if any cleanup field the user can change via the UI differs
+ * between the previous and next config snapshots. Used to decide whether to
+ * reset the cleanup-scheduler throttle after a config reload so retention
+ * changes take effect immediately instead of waiting up to 6 hours.
+ *
+ * Exported for unit testing.
+ */
+export function cleanupSettingsChanged(
+  prev: MemoryCleanupConfig | undefined,
+  next: MemoryCleanupConfig | undefined,
+): boolean {
+  if (!prev || !next) return false;
+  return (
+    prev.llmRequestLogRetentionMs !== next.llmRequestLogRetentionMs ||
+    prev.conversationRetentionDays !== next.conversationRetentionDays ||
+    prev.enabled !== next.enabled
+  );
+}

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

@@ -64,6 +64,8 @@ export interface EventHandlerState {
   exchangeCacheCreationInputTokens: number;
   exchangeCacheReadInputTokens: number;
   exchangeOutputTokens: number;
+  /** Input tokens from the most recent LLM API call (overwritten, not accumulated). */
+  lastCallInputTokens: number;
   /** Number of actual LLM API calls within this exchange. */
   exchangeLlmCallCount: number;
   readonly exchangeRawResponses: unknown[];
@@ -135,6 +137,7 @@ export function createEventHandlerState(): EventHandlerState {
     exchangeCacheCreationInputTokens: 0,
     exchangeCacheReadInputTokens: 0,
     exchangeOutputTokens: 0,
+    lastCallInputTokens: 0,
     exchangeLlmCallCount: 0,
     exchangeRawResponses: [],
     model: "",
@@ -590,6 +593,7 @@ function annotatePersistedAssistantMessage(
         data: surface.data,
         actions: surface.actions,
         display: surface.display,
+        ...(surface.persistent ? { persistent: true } : {}),
       } as unknown as ContentBlock);
     }
     modified = true;
@@ -759,6 +763,7 @@ export async function handleMessageComplete(
       data: surface.data,
       actions: surface.actions,
       display: surface.display,
+      ...(surface.persistent ? { persistent: true } : {}),
     } as unknown as ContentBlock);
   }
 
@@ -831,6 +836,7 @@ export function handleUsage(
   state.exchangeProviderName = providerName;
   state.exchangeLlmCallCount += 1;
   state.exchangeInputTokens += event.inputTokens;
+  state.lastCallInputTokens = event.inputTokens;
   state.exchangeCacheCreationInputTokens += event.cacheCreationInputTokens ?? 0;
   state.exchangeCacheReadInputTokens += event.cacheReadInputTokens ?? 0;
   state.exchangeOutputTokens += event.outputTokens;

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

@@ -24,10 +24,14 @@ import type {
 } from "../channels/types.js";
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
-import { derefToolResultReReads,postTurnTruncateToolResults } from "../context/post-turn-tool-result-truncation.js";
+import {
+  derefToolResultReReads,
+  postTurnTruncateToolResults,
+} from "../context/post-turn-tool-result-truncation.js";
 import { estimatePromptTokens } from "../context/token-estimator.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 { getHookManager } from "../hooks/manager.js";
 import {
   clearSentryConversationContext,
@@ -35,12 +39,15 @@ import {
 } from "../instrument.js";
 import { commitAppTurnChanges } from "../memory/app-git-service.js";
 import { getApp, listAppFiles, resolveAppDir } from "../memory/app-store.js";
+import { enqueueAutoAnalysisOnCompaction } from "../memory/auto-analysis-enqueue.js";
 import {
   addMessage,
   deleteMessageById,
   getConversation,
   getConversationOriginChannel,
   getConversationOriginInterface,
+  getLastUserTimestampBefore,
+  getMessageById,
   provenanceFromTrustContext,
   updateConversationContextWindow,
   updateConversationTitle,
@@ -64,6 +71,7 @@ import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { getSubagentManager } from "../subagent/index.js";
 import type { UsageActor } from "../usage/actors.js";
 import { getLogger } from "../util/logger.js";
+import { timeAgo } from "../util/time.js";
 import { truncate } from "../util/truncate.js";
 import { getWorkspaceGitService } from "../workspace/git-service.js";
 import { commitTurnChanges } from "../workspace/turn-commit.js";
@@ -234,6 +242,7 @@ export interface AgentLoopConversationContext {
     data: SurfaceData;
     actions?: Array<{ id: string; label: string; style?: string }>;
     display?: string;
+    persistent?: boolean;
   }>;
 
   workingDir: string;
@@ -246,6 +255,8 @@ export interface AgentLoopConversationContext {
   currentTurnChannelCapabilities?: ChannelCapabilities;
   commandIntent?: { type: string; payload?: string; languageCode?: string };
   trustContext?: TrustContext;
+  /** 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[];
@@ -541,6 +552,13 @@ export async function runAgentLoopImpl(
         compacted.summaryText,
         ctx.contextCompactedMessageCount,
       );
+      // Fire auto-analysis on compaction so the reflective agent can
+      // crystallize anything worth remembering before the context window
+      // narrows further.
+      enqueueAutoAnalysisOnCompaction(
+        ctx.conversationId,
+        ctx.trustContext?.trustClass,
+      );
       onEvent({
         type: "context_compacted",
         previousEstimatedInputTokens: compacted.previousEstimatedInputTokens,
@@ -773,14 +791,35 @@ export async function runAgentLoopImpl(
     const isGuardian =
       resolvedInboundActorContext?.trustClass === "guardian" ||
       !resolvedInboundActorContext;
+
+    // Surface long gaps between user messages so the model can acknowledge
+    // the absence naturally. Gated at >12h to avoid noisy injection during
+    // normal back-and-forth turns.
+    const TWELVE_HOURS_MS = 12 * 60 * 60 * 1000;
+    let timeSinceLastMessage: string | null = null;
+    const currentUserMessage = getMessageById(userMessageId);
+    if (currentUserMessage) {
+      const prevUserTs = getLastUserTimestampBefore(
+        ctx.conversationId,
+        currentUserMessage.createdAt,
+      );
+      if (
+        prevUserTs > 0 &&
+        currentUserMessage.createdAt - prevUserTs > TWELVE_HOURS_MS
+      ) {
+        timeSinceLastMessage = timeAgo(prevUserTs);
+      }
+    }
+
     const unifiedTurnContextStr = buildUnifiedTurnContextBlock(
       isGuardian
-        ? { timestamp, interfaceName, channelName }
+        ? { timestamp, interfaceName, channelName, timeSinceLastMessage }
         : {
             timestamp,
             interfaceName,
             channelName,
             actorContext: resolvedInboundActorContext,
+            timeSinceLastMessage,
           },
     );
 
@@ -908,6 +947,11 @@ export async function runAgentLoopImpl(
             step.compactionResult.summaryText,
             ctx.contextCompactedMessageCount,
           );
+          // Fire auto-analysis on compaction — see forceCompact() for rationale.
+          enqueueAutoAnalysisOnCompaction(
+            ctx.conversationId,
+            ctx.trustContext?.trustClass,
+          );
           onEvent({
             type: "context_compacted",
             previousEstimatedInputTokens:
@@ -945,8 +989,12 @@ export async function runAgentLoopImpl(
         // value from injectionOpts to avoid duplicate injection.
         runMessages = applyRuntimeInjections(ctx.messages, {
           ...injectionOpts,
-          ...(step.compactionResult?.compacted && { pkbContext: currentPkbContent }),
-          ...(step.compactionResult?.compacted && { nowScratchpad: currentNowContent }),
+          ...(step.compactionResult?.compacted && {
+            pkbContext: currentPkbContent,
+          }),
+          ...(step.compactionResult?.compacted && {
+            nowScratchpad: currentNowContent,
+          }),
           workspaceTopLevelContext: shouldInjectWorkspace
             ? ctx.workspaceTopLevelContext
             : null,
@@ -1108,6 +1156,11 @@ export async function runAgentLoopImpl(
           midLoopCompact.summaryText,
           ctx.contextCompactedMessageCount,
         );
+        // Fire auto-analysis on compaction — see forceCompact() for rationale.
+        enqueueAutoAnalysisOnCompaction(
+          ctx.conversationId,
+          ctx.trustContext?.trustClass,
+        );
         onEvent({
           type: "context_compacted",
           previousEstimatedInputTokens:
@@ -1151,8 +1204,7 @@ export async function runAgentLoopImpl(
         mode: currentInjectionMode,
       });
       if (isTrustedActor && currentInjectionMode !== "minimal") {
-        const memResult = ctx.graphMemory.reinjectCachedMemory(runMessages);
-        runMessages = memResult.runMessages;
+        ctx.graphMemory.retrackCachedNodes();
       }
       preRepairMessages = runMessages;
       preRunHistoryLength = runMessages.length;
@@ -1326,6 +1378,11 @@ export async function runAgentLoopImpl(
             step.compactionResult.summaryText,
             ctx.contextCompactedMessageCount,
           );
+          // Fire auto-analysis on compaction — see forceCompact() for rationale.
+          enqueueAutoAnalysisOnCompaction(
+            ctx.conversationId,
+            ctx.trustContext?.trustClass,
+          );
           onEvent({
             type: "context_compacted",
             previousEstimatedInputTokens:
@@ -1370,8 +1427,7 @@ export async function runAgentLoopImpl(
           mode: currentInjectionMode,
         });
         if (isTrustedActor && currentInjectionMode !== "minimal") {
-          const memResult = ctx.graphMemory.reinjectCachedMemory(runMessages);
-          runMessages = memResult.runMessages;
+          ctx.graphMemory.retrackCachedNodes();
         }
         preRepairMessages = runMessages;
         preRunHistoryLength = runMessages.length;
@@ -1450,6 +1506,11 @@ export async function runAgentLoopImpl(
                 emergencyCompact.summaryText,
                 ctx.contextCompactedMessageCount,
               );
+              // Fire auto-analysis on compaction — see forceCompact() for rationale.
+              enqueueAutoAnalysisOnCompaction(
+                ctx.conversationId,
+                ctx.trustContext?.trustClass,
+              );
               onEvent({
                 type: "context_compacted",
                 previousEstimatedInputTokens:
@@ -1493,9 +1554,7 @@ export async function runAgentLoopImpl(
               mode: currentInjectionMode,
             });
             if (isTrustedActor && currentInjectionMode !== "minimal") {
-              const memResult =
-                ctx.graphMemory.reinjectCachedMemory(runMessages);
-              runMessages = memResult.runMessages;
+              ctx.graphMemory.retrackCachedNodes();
             }
             preRepairMessages = runMessages;
             preRunHistoryLength = runMessages.length;
@@ -1570,6 +1629,11 @@ export async function runAgentLoopImpl(
               emergencyCompact.summaryText,
               ctx.contextCompactedMessageCount,
             );
+            // Fire auto-analysis on compaction — see forceCompact() for rationale.
+            enqueueAutoAnalysisOnCompaction(
+              ctx.conversationId,
+              ctx.trustContext?.trustClass,
+            );
             onEvent({
               type: "context_compacted",
               previousEstimatedInputTokens:
@@ -1613,8 +1677,7 @@ export async function runAgentLoopImpl(
             mode: currentInjectionMode,
           });
           if (isTrustedActor && currentInjectionMode !== "minimal") {
-            const memResult = ctx.graphMemory.reinjectCachedMemory(runMessages);
-            runMessages = memResult.runMessages;
+            ctx.graphMemory.retrackCachedNodes();
           }
           preRepairMessages = runMessages;
           preRunHistoryLength = runMessages.length;
@@ -1753,9 +1816,16 @@ export async function runAgentLoopImpl(
       try {
         const conv = getConversation(ctx.conversationId);
         if (conv) {
-          const convDir = getResolvedConversationDirPath(ctx.conversationId, conv.createdAt);
-          const { messages: derefMessages, dereferencedCount } = derefToolResultReReads(restoredHistory);
-          const { messages: truncatedMessages, truncatedCount } = postTurnTruncateToolResults(derefMessages, { conversationDir: convDir });
+          const convDir = getResolvedConversationDirPath(
+            ctx.conversationId,
+            conv.createdAt,
+          );
+          const { messages: derefMessages, dereferencedCount } =
+            derefToolResultReReads(restoredHistory);
+          const { messages: truncatedMessages, truncatedCount } =
+            postTurnTruncateToolResults(derefMessages, {
+              conversationDir: convDir,
+            });
           if (truncatedCount > 0 || dereferencedCount > 0) {
             rlog.info(
               { truncatedCount, dereferencedCount },
@@ -1765,16 +1835,13 @@ export async function runAgentLoopImpl(
           restoredHistory = truncatedMessages;
         }
       } catch (err) {
-        rlog.warn({ err }, "Post-turn tool result truncation failed (non-fatal)");
+        rlog.warn(
+          { err },
+          "Post-turn tool result truncation failed (non-fatal)",
+        );
       }
     }
 
-    const postLoopContextEstimate = estimatePromptTokens(
-      restoredHistory,
-      ctx.systemPrompt,
-      { providerName: ctx.provider.name, toolTokenBudget },
-    );
-
     // Persist injections in history: runtime-injected context stays on
     // historical user messages so the conversation prefix is stable for
     // Anthropic's prefix caching.  Stripping only happens during
@@ -1795,7 +1862,7 @@ export async function runAgentLoopImpl(
       state.exchangeProviderName,
       state.exchangeLlmCallCount,
       {
-        tokens: postLoopContextEstimate,
+        tokens: state.lastCallInputTokens,
         maxTokens: config.contextWindow.maxInputTokens,
       },
     );
@@ -2014,6 +2081,12 @@ export async function runAgentLoopImpl(
 
       // Commit app changes (fire-and-forget — apps repo is separate from workspace)
       void commitAppTurnChanges(ctx.conversationId, ctx.turnCount);
+
+      // Recompute relationship-state.json at turn boundary (fire-and-forget).
+      // The writer swallows its own errors, but we still guard with catch()
+      // here so a regression in the writer can never bubble out of the
+      // agent loop and reject an otherwise-complete turn.
+      void writeRelationshipState().catch(() => {});
     }
 
     ctx.profiler.emitSummary(ctx.traceEmitter, reqId);
@@ -2029,6 +2102,10 @@ export async function runAgentLoopImpl(
     // Channel command intents (e.g. Telegram /start) are single-turn metadata.
     // Clear at turn end so they never leak into subsequent unrelated messages.
     ctx.commandIntent = undefined;
+    // taskRunId scopes ephemeral task-run permissions to a single turn. Clear
+    // before drainQueue so queued/drained turns on a reused conversation can't
+    // inherit stale in-task-run scope from the turn that just finished.
+    ctx.taskRunId = undefined;
 
     // Consolidation deferred to compaction: keeping assistant + tool_result
     // messages unconsolidated preserves the exact message structure sent to

package/src/daemon/conversation-error.ts

@@ -1,4 +1,5 @@
 import { getProviderRoutingSource } from "../providers/registry.js";
+import { isAbortReason } from "../util/abort-reasons.js";
 import { ProviderError, ProviderNotConfiguredError } from "../util/errors.js";
 import type {
   ConversationErrorCode,
@@ -110,11 +111,21 @@ export interface ErrorContext {
  * Returns true if the error looks like a user-initiated cancellation
  * (AbortError or explicit cancel). These should use `generation_cancelled`
  * instead of `conversation_error`.
+ *
+ * Provider SDKs wrap the underlying AbortError in their own error class
+ * (e.g. `ProviderError("Anthropic API error (undefined): Request was aborted.")`),
+ * which erases the `AbortError` name. To compensate, the daemon tags every
+ * `controller.abort(reason)` call with an `AbortReason` object — when the
+ * wrapped `ProviderError` carries that tagged reason, we treat it as a user
+ * cancellation regardless of error class.
  */
 export function isUserCancellation(error: unknown, ctx: ErrorContext): boolean {
   if (!ctx.aborted) return false;
   if (error instanceof DOMException && error.name === "AbortError") return true;
   if (error instanceof Error && error.name === "AbortError") return true;
+  if (error instanceof ProviderError && isAbortReason(error.abortReason)) {
+    return true;
+  }
   return false;
 }
 

package/src/daemon/conversation-history.ts

@@ -15,6 +15,7 @@ import { withQdrantBreaker } from "../memory/qdrant-circuit-breaker.js";
 import { getQdrantClient } from "../memory/qdrant-client.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
+import { truncate } from "../util/truncate.js";
 import type { ServerMessage } from "./message-protocol.js";
 import type { TraceEmitter } from "./trace-emitter.js";
 
@@ -564,10 +565,43 @@ export async function regenerate(
   // in both this.messages and the DB.
   conversation.processing = true;
   conversation.abortController = new AbortController();
-  conversation.currentRequestId = requestId ?? uuid();
-
-  await conversation.runAgentLoop(content, existingUserMessageId, onEvent, {
-    skipPreMessageRollback: true,
-    isUserMessage: true,
-  });
+  const resolvedRequestId = requestId ?? uuid();
+  conversation.currentRequestId = resolvedRequestId;
+
+  // Fire-and-forget: matches the /v1/messages pattern so the HTTP handler
+  // returns 202 immediately rather than blocking on the full agent turn.
+  // Otherwise the client's 15s POST timeout fires on any non-trivial
+  // regenerate and surfaces a misleading "Failed to regenerate message"
+  // banner even though the response streams in normally via SSE.
+  //
+  // runAgentLoop catches most errors internally and emits `request_error`
+  // itself, but anything thrown from its `finally` block (commit, drain,
+  // profiler) would otherwise escape silently because the caller does
+  // not await the agent loop. Emit a structured trace event so the
+  // observability contract is preserved on those paths too.
+  void conversation
+    .runAgentLoop(content, existingUserMessageId, onEvent, {
+      skipPreMessageRollback: true,
+      isUserMessage: true,
+    })
+    .catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      log.error(
+        { err, conversationId: conversation.conversationId },
+        "runAgentLoop after regenerate failed",
+      );
+      conversation.traceEmitter.emit(
+        "request_error",
+        truncate(message, 200, ""),
+        {
+          requestId: resolvedRequestId,
+          status: "error",
+          attributes: {
+            errorClass: err instanceof Error ? err.constructor.name : "Error",
+            message: truncate(message, 500, ""),
+            source: "regenerate_fire_and_forget",
+          },
+        },
+      );
+    });
 }