@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/daemon/conversation-turn-finalize.ts

@@ -0,0 +1,211 @@
+/**
+ * End-of-turn finalize work that runs OFF the send-button critical path.
+ *
+ * The web/Capacitor/CLI clients re-enable the composer the moment they observe
+ * the terminal `message_complete` / `assistant_activity_state("idle")` SSE, so
+ * any awaited work between the last streamed token and that emission is what the
+ * user perceives as the "still spinning after the reply finished" gap.
+ *
+ * None of the work here gates delivery of the reply: memory/attention indexing
+ * only feeds the NEXT turn's retrieval and a sidebar indicator, tool-result
+ * truncation only reshapes the in-memory history the next turn is built from,
+ * and the disk-view mirror is a durability convenience. The agent loop persists
+ * the reply content synchronously and emits the terminal SSE first, then drains
+ * this module's work before the turn's `finally` starts the next turn — so the
+ * bookkeeping still completes within the turn, just after the composer is free.
+ */
+
+import type pino from "pino";
+
+import { getConfig } from "../config/loader.js";
+import {
+  derefToolResultReReads,
+  postTurnTruncateToolResults,
+} from "../context/post-turn-tool-result-truncation.js";
+import { projectAssistantMessage } from "../persistence/conversation-attention-store.js";
+import {
+  getConversation,
+  getMessageById,
+  parseMessageMetadata,
+} from "../persistence/conversation-crud.js";
+import { getResolvedConversationDirPath } from "../persistence/conversation-directories.js";
+import { syncMessageToDisk } from "../persistence/conversation-disk-view.js";
+import { enqueueLexicalIndexForMessage } from "../persistence/job-handlers/message-lexical.js";
+import { indexMessageNow } from "../plugins/defaults/memory/indexer.js";
+import type { Message } from "../providers/types.js";
+import { publishSyncInvalidation } from "../runtime/sync/sync-publisher.js";
+import { conversationMetadataSyncTag } from "./message-types/sync.js";
+
+/** Minimal live-conversation surface the deferred tail reads and rewrites. */
+interface TurnTailContext {
+  readonly conversationId: string;
+  messages: Message[];
+}
+
+/** Minimal per-run handler state the deferred tail consumes. */
+interface TurnTailState {
+  readonly deferredFinalizeEffects: ReadonlyArray<() => Promise<void>>;
+  readonly lastAssistantMessageId: string | undefined;
+}
+
+/**
+ * Build the deferred finalize side-effect for one finalized assistant row:
+ * memory segment indexing, lexical indexing, and attention projection.
+ *
+ * `reserveMessage` + `updateMessageContent` are CRUD-only — unlike `addMessage`,
+ * they don't run the memory indexer or the attention-cursor projector as insert
+ * side-effects — so the assistant row's external state (Qdrant segments,
+ * attention cursor) is brought into lockstep with the finalized content here.
+ * The returned closure captures the row id and its already-persisted content
+ * JSON, and is drained by {@link runDeferredTurnTail} after the terminal SSE.
+ * Each step is best-effort: a memory hiccup must not escalate a delivered reply
+ * into a turn-level throw.
+ */
+export function buildDeferredFinalizeEffect(params: {
+  conversationId: string;
+  assistantMessageId: string;
+  contentJson: string;
+  rlog: pino.Logger;
+}): () => Promise<void> {
+  const { conversationId, assistantMessageId, contentJson, rlog } = params;
+  return async () => {
+    const finalizedRow = getMessageById(assistantMessageId, conversationId);
+    if (!finalizedRow) {
+      return;
+    }
+    // Provenance/automation flags for the memory write-gate come off the
+    // persisted metadata via the shared `parseMessageMetadata` (the single
+    // source of truth for its shape) rather than a hand-copied union.
+    const metadata = parseMessageMetadata(finalizedRow.metadata);
+    try {
+      await indexMessageNow(
+        {
+          messageId: assistantMessageId,
+          conversationId,
+          role: "assistant",
+          content: contentJson,
+          createdAt: finalizedRow.createdAt,
+          scopeId: "default",
+          provenanceTrustClass: metadata?.provenanceTrustClass,
+          automated: metadata?.automated,
+        },
+        getConfig().memory,
+      );
+    } catch (err) {
+      rlog.warn(
+        { err, conversationId, messageId: assistantMessageId },
+        "Failed to index assistant message for memory (non-fatal)",
+      );
+    }
+    // Dual-write the finalized assistant content into the lexical index. The
+    // reserve+finalize path bypasses `onMessagePersisted`, so enqueue here to
+    // keep the lexical index in lockstep with the segment index.
+    enqueueLexicalIndexForMessage(assistantMessageId);
+    try {
+      const attentionStateChanged = projectAssistantMessage({
+        conversationId,
+        messageId: assistantMessageId,
+        messageAt: finalizedRow.createdAt,
+      });
+      if (attentionStateChanged) {
+        void publishSyncInvalidation([
+          conversationMetadataSyncTag(conversationId),
+        ]);
+      }
+    } catch (err) {
+      rlog.warn(
+        { err, conversationId, messageId: assistantMessageId },
+        "Failed to project assistant message for attention tracking (non-fatal)",
+      );
+    }
+  };
+}
+
+/**
+ * Drain a turn's deferred bookkeeping after the terminal SSE has re-enabled the
+ * composer but before the agent loop's `finally` commits and drains the queue
+ * for the next turn. Ordering with the next turn is preserved (this completes
+ * before `drainQueue`), while the last-token→send-button latency no longer
+ * includes it. Every step is best-effort.
+ *
+ * `generationCompletedAt` is stamped when the agent loop returns; the emitted
+ * `criticalSectionMs` / `deferredTailMs` split makes the previously-uninstrumented
+ * end-of-turn window measurable.
+ */
+export async function runDeferredTurnTail(params: {
+  ctx: TurnTailContext;
+  state: TurnTailState;
+  rlog: pino.Logger;
+  generationCompletedAt: number;
+}): Promise<void> {
+  const { ctx, state, rlog, generationCompletedAt } = params;
+  const tailStartedAt = Date.now();
+
+  // Per-message memory/attention finalize side-effects deferred from
+  // `handleMessageComplete` — one closure per assistant row produced this turn,
+  // in production order.
+  for (const effect of state.deferredFinalizeEffects) {
+    try {
+      await effect();
+    } catch (err) {
+      rlog.warn({ err }, "Deferred finalize side-effect failed (non-fatal)");
+    }
+  }
+
+  // Post-turn tool-result truncation: spool oversized results to disk and
+  // replace their in-context content with a stub + pointer, shrinking the next
+  // turn's context. Rewrites only the in-memory history, so it has no bearing on
+  // the reply already delivered to the client.
+  try {
+    const conv = getConversation(ctx.conversationId);
+    if (conv) {
+      const convDir = getResolvedConversationDirPath(
+        ctx.conversationId,
+        conv.createdAt,
+      );
+      const { messages: derefMessages, dereferencedCount } =
+        derefToolResultReReads(ctx.messages);
+      const { messages: truncatedMessages, truncatedCount } =
+        postTurnTruncateToolResults(derefMessages, {
+          conversationDir: convDir,
+        });
+      if (truncatedCount > 0 || dereferencedCount > 0) {
+        rlog.info(
+          { truncatedCount, dereferencedCount },
+          "Post-turn tool result truncation applied",
+        );
+      }
+      ctx.messages = truncatedMessages;
+    }
+  } catch (err) {
+    rlog.warn({ err }, "Post-turn tool result truncation failed (non-fatal)");
+  }
+
+  // Mirror the final assistant row into the JSONL disk view. Guarded like the
+  // steps above: this runs AFTER the terminal SSE, so a throw here (e.g. a
+  // SQLite read failure in `getConversation`) must not escape into the loop's
+  // outer catch and emit a second, contradictory terminal event for a turn the
+  // client already saw complete.
+  try {
+    if (state.lastAssistantMessageId) {
+      const convForDisk = getConversation(ctx.conversationId);
+      if (convForDisk) {
+        syncMessageToDisk(
+          ctx.conversationId,
+          state.lastAssistantMessageId,
+          convForDisk.createdAt,
+        );
+      }
+    }
+  } catch (err) {
+    rlog.warn({ err }, "Failed to sync assistant message to disk (non-fatal)");
+  }
+
+  rlog.info(
+    {
+      criticalSectionMs: tailStartedAt - generationCompletedAt,
+      deferredTailMs: Date.now() - tailStartedAt,
+    },
+    "End-of-turn work complete",
+  );
+}

package/src/daemon/conversation.ts

@@ -52,10 +52,12 @@ import {
   getConversation,
   getMessages,
   resolveOverrideProfile,
+  setConversationEnabledPlugins,
   setConversationHistoryStrippedAt,
   setConversationProcessingStartedAt,
 } from "../persistence/conversation-crud.js";
 import { getResolvedConversationDirPath } from "../persistence/conversation-directories.js";
+import { reportSlowSync } from "../persistence/slow-sync-log.js";
 import { defaultCompact } from "../plugins/defaults/compaction/compact.js";
 import {
   createContextWindowManager,
@@ -329,6 +331,16 @@ export class Conversation {
   inferenceProfile: string | null = null;
   /** @internal */ inferenceProfileSessionId: string | null = null;
   /** @internal */ inferenceProfileExpiresAt: number | null = null;
+  /**
+   * Per-conversation plugin scope mirrored from the DB row. `null` means no
+   * per-chat restriction (all globally-enabled plugins apply). Hydrated on load
+   * and kept in sync by {@link setEnabledPlugins}, which also persists the value
+   * back to the row, so the live instance is the source of truth; later
+   * tool/skill/hook filters intersect their candidate set against this via
+   * `getEffectiveEnabledPluginSet`.
+   * @internal
+   */
+  enabledPlugins: string[] | null = null;
   /** @internal */ currentRequestId?: string;
   /**
    * The {@link LLMCallSite} of the in-flight turn, set at turn start from
@@ -532,6 +544,25 @@ export class Conversation {
    */
   hostUsername?: string;
   /** @internal */ clientTimezone?: string;
+  /**
+   * @internal
+   * The client's OS surface ("web" | "ios" | "macos"), reported separately
+   * from the transport `interfaceId` so the assistant's per-turn context can
+   * show the real platform without affecting host-proxy/transport gating.
+   * This is the LIVE value (re-applied from transport on every inbound
+   * message); the assembly reads the frozen {@link currentTurnClientOs}.
+   */
+  clientOs?: string;
+  /**
+   * Per-turn frozen copy of {@link clientOs}, captured by the agent loop at
+   * turn start (like {@link currentTurnTemporalSnapshot}). The assembly reads
+   * THIS rather than the live `clientOs` so a newer message from a different
+   * OS surface — which re-applies transport metadata via
+   * `getOrCreateConversation` before it is enqueued — cannot leak its
+   * `client_os` into the in-flight turn's prompt.
+   * @internal
+   */
+  currentTurnClientOs?: string;
   /**
    * Per-turn temporal snapshot frozen by the agent loop and read by
    * `applyRuntimeInjections` to build the `<turn_context>` timezone-mismatch
@@ -818,6 +849,32 @@ export class Conversation {
         });
   }
 
+  /**
+   * Re-resolve the system prompt for the current turn's persona context and
+   * push it into the agent loop when it changed. The loop snapshots its prompt
+   * at construction and reuses it every turn; flows that bind persona context
+   * after construction — a voice call resolves the caller's trust only after
+   * the conversation is created — would otherwise stay pinned to the
+   * construction-time persona (the guardian, or `users/default.md`) for the
+   * whole conversation.
+   *
+   * Pushing only when the rebuilt prompt actually differs keeps the provider's
+   * prefix cache intact for the common case (a stable-identity conversation
+   * rebuilds to the same bytes, so no update is sent). A system-prompt override
+   * resolves verbatim via {@link buildCurrentSystemPrompt}, so override
+   * conversations (subagent forks, stored overrides) are inherently a no-op.
+   *
+   * Called by the turn runner before `agentLoop.run()`, once the turn's
+   * persona snapshots ({@link currentTurnTrustContext},
+   * {@link currentTurnChannelCapabilities}) are set.
+   */
+  syncLoopSystemPrompt(): void {
+    const next = this.buildCurrentSystemPrompt();
+    if (next === this.systemPrompt) return;
+    this.systemPrompt = next;
+    this.agentLoop.setSystemPrompt(next);
+  }
+
   // ── Prompt Cache Warming ─────────────────────────────────────────
 
   /**
@@ -868,6 +925,7 @@ export class Conversation {
   // ── Lifecycle ────────────────────────────────────────────────────
 
   async loadFromDb(): Promise<void> {
+    const loadStartedAt = performance.now();
     const trustClass = this.trustContext?.trustClass;
     const canAccessMemory = resolveCapabilities(trustClass).canAccessMemory;
     const allDbMessages = getMessages(this.conversationId);
@@ -902,6 +960,7 @@ export class Conversation {
     this.inferenceProfile = conv?.inferenceProfile ?? null;
     this.inferenceProfileSessionId = conv?.inferenceProfileSessionId ?? null;
     this.inferenceProfileExpiresAt = conv?.inferenceProfileExpiresAt ?? null;
+    this.enabledPlugins = conv?.enabledPlugins ?? null;
     this.contextCompactedMessageCount = Math.max(
       0,
       conv?.contextCompactedMessageCount ?? 0,
@@ -1201,10 +1260,22 @@ export class Conversation {
     this.loadedHistoryTrustClass = trustClass;
     this.loadedHistoryPersonalMemoryAllowed = personalMemoryAllowed;
 
+    const loadElapsedMs = performance.now() - loadStartedAt;
     log.info(
-      { conversationId: this.conversationId, count: this.messages.length },
+      {
+        conversationId: this.conversationId,
+        count: this.messages.length,
+        elapsedMs: loadElapsedMs,
+      },
       "Loaded messages from DB",
     );
+    // Whole read+parse+repair section — attributes an event-loop freeze to
+    // this conversation load (getMessages times the read alone; the delta is
+    // parse/repair CPU). See slow-sync-log / event-loop-watchdog.
+    reportSlowSync("conversation:load-from-db", loadElapsedMs, {
+      conversationId: this.conversationId,
+      messageCount: this.messages.length,
+    });
 
     this.restoreSurfaceStateFromHistory();
     this.graphMemory.restoreState();
@@ -1305,6 +1376,20 @@ export class Conversation {
     this.subagentAllowedTools = tools;
   }
 
+  /**
+   * Set the conversation's per-chat plugin scope, updating both the persisted
+   * `enabled_plugins` row and the live instance (source of truth for the
+   * current turn). `null` clears the per-chat restriction. Callers do not
+   * persist separately.
+   *
+   * Persist first, then mutate the live instance: if the write throws, the
+   * live scope is left untouched rather than diverging from the row.
+   */
+  setEnabledPlugins(plugins: string[] | null): void {
+    setConversationEnabledPlugins(this.conversationId, plugins);
+    this.enabledPlugins = plugins;
+  }
+
   setIsSubagent(value: boolean): void {
     this.isSubagent = value;
   }
@@ -1953,6 +2038,10 @@ export class Conversation {
       canonicalizeTimeZone(transport.clientTimezone) ?? undefined;
   }
 
+  applyClientOsFromTransport(transport: ConversationTransportMetadata): void {
+    this.clientOs = transport.clientOs ?? undefined;
+  }
+
   setAssistantId(assistantId: string | null): void {
     this.assistantId = assistantId ?? undefined;
   }
@@ -2024,6 +2113,8 @@ export class Conversation {
       isInteractive?: boolean;
       isUserMessage?: boolean;
       titleText?: string;
+      /** See {@link runAgentLoopImpl} — hidden machine-signal turn marker. */
+      isHiddenPrompt?: boolean;
       callSite?: LLMCallSite;
       /**
        * Optional ad-hoc inference-profile override applied to every LLM call

package/src/daemon/disk-pressure-policy.ts

@@ -1,6 +1,7 @@
 import type { InterfaceId } from "../channels/types.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { resolveCapabilities } from "../runtime/capabilities.js";
+import { isContactTrustClass } from "../runtime/trust-class.js";
 import type { DiskPressureStatus } from "./disk-pressure-guard.js";
 import type { ConversationType } from "./message-types/shared.js";
 import type { TrustContext } from "./trust-context.js";
@@ -79,7 +80,7 @@ export function classifyDiskPressureTurnPolicy(
     return { action: "allow-cleanup-mode", reason: "guardian" };
   }
 
-  if (trustClass === "trusted_contact" || trustClass === "unverified_contact") {
+  if (isContactTrustClass(trustClass)) {
     return { action: "block", reason: "trusted-contact" };
   }
 

package/src/daemon/event-loop-watchdog.ts

@@ -20,11 +20,12 @@
  * What it does NOT do: capture the JS stack of the blocking operation. JS is
  * single-threaded, so while the loop is blocked no callback — including this one
  * — can run; by the time the tick fires, the offending synchronous call has
- * returned and its stack is gone. The watchdog reports *that* and *how long* a
- * freeze happened, not *what* caused it. The report lands at unblock, so the
- * surrounding log lines (which job or turn was active) are the correlation
- * handle. For deterministic attribution of a specific subsystem, time that
- * subsystem's synchronous calls at their source.
+ * returned and its stack is gone. Instead, each freeze report carries the
+ * section trail (`persistence/slow-sync-log.ts`): the recent instrumented
+ * sections with their start/end ages relative to the report. The newest entry
+ * older than `blockedMs` that hadn't ended when the block began names — or
+ * brackets — the code that froze. For sub-threshold contributors, time the
+ * subsystem's synchronous calls at their source with `timeSyncSection`.
  *
  * A cumulative event-loop-delay histogram is separately exposed pull-based over
  * SSE diagnostics (`runtime/routes/events-routes.ts`); this watchdog is the
@@ -33,6 +34,10 @@
 
 import * as Sentry from "@sentry/node";
 
+import {
+  getSectionTrail,
+  type SectionTrailEntry,
+} from "../persistence/slow-sync-log.js";
 import { recordWatchdogEvent } from "../telemetry/watchdog-events-store.js";
 import { getLogger } from "../util/logger.js";
 
@@ -84,8 +89,17 @@ export function evaluateTick(
 export const EVENT_LOOP_BLOCKED_CHECK_NAME = "event_loop_blocked";
 
 function reportBlock(blockedMs: number, thresholdMs: number): void {
+  // Attribution breadcrumbs: the block began ~`blockedMs` before this report,
+  // so the newest trail entry started at least that long ago — and not yet
+  // ended by then — is the section that was running when the loop froze.
+  let sectionTrail: SectionTrailEntry[] = [];
+  try {
+    sectionTrail = getSectionTrail();
+  } catch {
+    // Diagnostics-only — never let it escape the timer callback.
+  }
   log.warn(
-    { blockedMs, thresholdMs, tickIntervalMs: TICK_INTERVAL_MS },
+    { blockedMs, thresholdMs, tickIntervalMs: TICK_INTERVAL_MS, sectionTrail },
     "event loop blocked",
   );
   // Persist a `watchdog` telemetry event so the platform can surface
@@ -101,6 +115,7 @@ function reportBlock(blockedMs: number, thresholdMs: number): void {
       detail: {
         threshold_ms: thresholdMs,
         tick_interval_ms: TICK_INTERVAL_MS,
+        section_trail: sectionTrail,
       },
     });
   } catch {
@@ -114,6 +129,7 @@ function reportBlock(blockedMs: number, thresholdMs: number): void {
         blocked_ms: blockedMs,
         threshold_ms: thresholdMs,
         tick_interval_ms: TICK_INTERVAL_MS,
+        section_trail: sectionTrail,
       });
       Sentry.captureMessage(EVENT_LOOP_BLOCKED_CHECK_NAME);
     });