@vellumai/assistant 0.6.4 → 0.6.6

package/src/daemon/conversation-attachments.ts

@@ -107,7 +107,7 @@ export async function approveHostAttachmentRead(
   const response = await prompter.prompt(
     toolName,
     input,
-    await classifyRisk(toolName, input, workingDir),
+    (await classifyRisk(toolName, input, workingDir)).level,
     await generateAllowlistOptions(toolName, input),
     generateScopeOptions(workingDir, toolName),
     undefined,
@@ -116,8 +116,7 @@ export async function approveHostAttachmentRead(
   );
 
   if (
-    (response.decision === "always_allow" ||
-      response.decision === "always_allow_high_risk") &&
+    response.decision === "always_allow" &&
     response.selectedPattern &&
     response.selectedScope
   ) {
@@ -127,9 +126,6 @@ export async function approveHostAttachmentRead(
       response.selectedScope,
       "allow",
       100,
-      response.decision === "always_allow_high_risk"
-        ? { allowHighRisk: true }
-        : undefined,
     );
   }
   if (

package/src/daemon/conversation-error.ts

@@ -86,6 +86,14 @@ const WEB_SEARCH_ORDERING_PATTERNS = [
   /web_search.*tool_result/i,
 ];
 
+// Stale/invalid opaque `encrypted_content` token in replayed web-search results.
+// Anthropic's tokens have bounded validity; the daemon replaces historical
+// `web_search_tool_result` blocks with text summaries to avoid this, but this
+// classifier remains as defense-in-depth for any path that bypasses the strip.
+const STALE_WEB_SEARCH_CONTENT_PATTERNS = [
+  /invalid\s+`?encrypted_content`?\s+in\s+`?(?:web_)?search_result`?\s+block/i,
+];
+
 // Streaming corruption patterns (Anthropic SDK throws non-HTTP errors for SSE issues)
 const STREAMING_ERROR_PATTERNS = [
   /unexpected event order/i,
@@ -113,7 +121,7 @@ export interface ErrorContext {
  * 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.")`),
+ * (e.g. `ProviderError("Anthropic API error: 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
@@ -302,6 +310,15 @@ function classifyCore(
           errorCategory: "web_search_ordering",
         };
       }
+      if (isStaleWebSearchContent(message)) {
+        return {
+          code: "PROVIDER_WEB_SEARCH",
+          userMessage:
+            "Stale web-search results in conversation history. Please try again.",
+          retryable: true,
+          errorCategory: "stale_web_search_content",
+        };
+      }
       if (isOrderingError(message)) {
         return {
           code: "PROVIDER_ORDERING",
@@ -354,6 +371,15 @@ export function isWebSearchOrderingError(message: string): boolean {
   return WEB_SEARCH_ORDERING_PATTERNS.some((p) => p.test(message));
 }
 
+/**
+ * Check whether an error message indicates a stale/invalid `encrypted_content`
+ * opaque token in a replayed `web_search_tool_result`. See
+ * `stripHistoricalWebSearchResults()` for the proactive mitigation.
+ */
+export function isStaleWebSearchContent(message: string): boolean {
+  return STALE_WEB_SEARCH_CONTENT_PATTERNS.some((p) => p.test(message));
+}
+
 /** Check whether an error message indicates a tool_use/tool_result ordering failure. */
 export function isOrderingError(message: string): boolean {
   return ORDERING_ERROR_PATTERNS.some((p) => p.test(message));
@@ -414,6 +440,15 @@ function classifyByMessage(
       errorCategory: "web_search_ordering",
     };
   }
+  if (isStaleWebSearchContent(message)) {
+    return {
+      code: "PROVIDER_WEB_SEARCH",
+      userMessage:
+        "Stale web-search results in conversation history. Please try again.",
+      retryable: true,
+      errorCategory: "stale_web_search_content",
+    };
+  }
 
   // General tool_use/tool_result ordering errors
   if (isOrderingError(message)) {

package/src/daemon/conversation-history.ts

@@ -191,10 +191,7 @@ export function consolidateAssistantMessages(
 
     // Clean up Qdrant vectors (fire-and-forget)
     if (allSegmentIds.length > 0) {
-      cleanupQdrantVectors(
-        conversationId,
-        allSegmentIds,
-      ).catch((err) => {
+      cleanupQdrantVectors(conversationId, allSegmentIds).catch((err) => {
         log.warn(
           { err, conversationId },
           "Qdrant cleanup after consolidation failed (non-fatal)",
@@ -326,10 +323,7 @@ export function consolidateAssistantMessages(
 
   // Clean up Qdrant vectors (fire-and-forget)
   if (allSegmentIds.length > 0) {
-    cleanupQdrantVectors(
-      conversationId,
-      allSegmentIds,
-    ).catch((err) => {
+    cleanupQdrantVectors(conversationId, allSegmentIds).catch((err) => {
       log.warn(
         { err, conversationId },
         "Qdrant cleanup after consolidation failed (non-fatal)",
@@ -365,7 +359,6 @@ export interface HistoryConversationContext {
     userMessageId: string,
     onEvent: (msg: ServerMessage) => void,
     options?: {
-      skipPreMessageRollback?: boolean;
       isUserMessage?: boolean;
       titleText?: string;
     },
@@ -534,15 +527,14 @@ export async function regenerate(
   }
 
   // Clean up Qdrant vectors (fire-and-forget).
-  cleanupQdrantVectors(
-    conversation.conversationId,
-    allSegmentIds,
-  ).catch((err) => {
-    log.warn(
-      { err, conversationId: conversation.conversationId },
-      "Qdrant cleanup after regenerate failed (non-fatal)",
-    );
-  });
+  cleanupQdrantVectors(conversation.conversationId, allSegmentIds).catch(
+    (err) => {
+      log.warn(
+        { err, conversationId: conversation.conversationId },
+        "Qdrant cleanup after regenerate failed (non-fatal)",
+      );
+    },
+  );
 
   // Re-extract the user message content for the agent loop.
   // Use all content blocks (text, image, file) so attachments are
@@ -581,7 +573,6 @@ export async function regenerate(
   // observability contract is preserved on those paths too.
   void conversation
     .runAgentLoop(content, existingUserMessageId, onEvent, {
-      skipPreMessageRollback: true,
       isUserMessage: true,
     })
     .catch((err) => {

package/src/daemon/conversation-lifecycle.ts

@@ -8,7 +8,6 @@ import { createContextSummaryMessage } from "../context/window-manager.js";
 import type { EventBus } from "../events/bus.js";
 import type { AssistantDomainEvents } from "../events/domain-events.js";
 import type { ToolProfiler } from "../events/tool-profiling-listener.js";
-import { getHookManager } from "../hooks/manager.js";
 import { enqueueAutoAnalysisIfEnabled } from "../memory/auto-analysis-enqueue.js";
 import { isAutoAnalysisConversation } from "../memory/auto-analysis-guard.js";
 import {
@@ -25,15 +24,9 @@ import {
   type TrustClass,
 } from "../runtime/actor-trust-resolver.js";
 import { unregisterConversationSender } from "../tools/browser/browser-screencast.js";
-import {
-  type AbortReason,
-  createAbortReason,
-} from "../util/abort-reasons.js";
+import { type AbortReason, createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
-import {
-  unregisterCallNotifiers,
-  unregisterWatchNotifiers,
-} from "./conversation-notifiers.js";
+import { unregisterCallNotifiers } from "./conversation-notifiers.js";
 import type { MessageQueue } from "./conversation-queue-manager.js";
 import { resetSkillToolProjection } from "./conversation-skill-tools.js";
 import { repairHistory } from "./history-repair.js";
@@ -65,7 +58,9 @@ function parseProvenanceTrustClass(
   return undefined;
 }
 
-function filterMessagesForUntrustedActor(messages: MessageRow[]): MessageRow[] {
+export function filterMessagesForUntrustedActor(
+  messages: MessageRow[],
+): MessageRow[] {
   return messages.filter((m) => {
     const provenanceTrustClass = parseProvenanceTrustClass(m.metadata);
     return (
@@ -191,7 +186,7 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
 
   const parsedMessages: Message[] = dbMessages
     .slice(ctx.contextCompactedMessageCount)
-    .map((m) => {
+    .map((m, index, arr) => {
       const role = m.role as "user" | "assistant";
       let content: ContentBlock[];
       try {
@@ -209,11 +204,42 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
 
       content = reinjectImageSourcePaths(content, role, m.metadata);
 
-      // Re-inject persisted memory block from metadata so it survives
+      // Re-inject persisted injection blocks from metadata so it survives
       // conversation reloads (eviction, restart, fork).
       if (role === "user" && m.metadata) {
         try {
           const meta = JSON.parse(m.metadata);
+          const isTail = index === arr.length - 1;
+
+          // All rehydration steps are prepends — the ordering below
+          // (innermost block first, outermost last) builds the documented
+          // shape right-to-left, since each prepend shifts previously-
+          // prepended blocks one slot right:
+          //   [<workspace>, <turn_context>, <NOW.md>, <memory __injected>,
+          //    <system_reminder>, <knowledge_base>, ...original]
+          //
+          // Persisted non-tail rows rehydrate the full set so Anthropic's
+          // prefix cache keeps matching msg[0] across daemon restarts and
+          // conversation eviction. The tail row gets fresh blocks via
+          // applyRuntimeInjections on the next turn, so rehydration for the
+          // tail is limited to blocks that the next turn's injection pipeline
+          // cannot reconstruct (currently just `memoryInjectedBlock`, which
+          // is not always re-injected on the next turn).
+          if (!isTail && typeof meta.pkbContextBlock === "string") {
+            content = [
+              { type: "text" as const, text: meta.pkbContextBlock },
+              ...content,
+            ];
+          }
+
+          if (!isTail && typeof meta.pkbSystemReminderBlock === "string") {
+            content = [
+              { type: "text" as const, text: meta.pkbSystemReminderBlock },
+              ...content,
+            ];
+          }
+
+          // Memory remains rehydrated on all rows (existing behavior).
           if (typeof meta.memoryInjectedBlock === "string") {
             content = [
               {
@@ -223,6 +249,27 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
               ...content,
             ];
           }
+
+          if (!isTail && typeof meta.nowScratchpadBlock === "string") {
+            content = [
+              { type: "text" as const, text: meta.nowScratchpadBlock },
+              ...content,
+            ];
+          }
+
+          if (!isTail && typeof meta.turnContextBlock === "string") {
+            content = [
+              { type: "text" as const, text: meta.turnContextBlock },
+              ...content,
+            ];
+          }
+
+          if (!isTail && typeof meta.workspaceBlock === "string") {
+            content = [
+              { type: "text" as const, text: meta.workspaceBlock },
+              ...content,
+            ];
+          }
         } catch {
           /* ignore parse errors — metadata may be malformed */
         }
@@ -290,7 +337,6 @@ export function abortConversation(
     ctx.surfaceActionRequestIds.clear();
     ctx.surfaceState.clear();
     ctx.accumulatedSurfaceState.clear();
-    unregisterWatchNotifiers(ctx.conversationId);
     for (const queued of ctx.queue) {
       queued.onEvent({
         type: "generation_cancelled",
@@ -304,10 +350,6 @@ export function abortConversation(
 // ── dispose ──────────────────────────────────────────────────────────
 
 export function disposeConversation(ctx: DisposeContext): void {
-  void getHookManager().trigger("conversation-end", {
-    conversationId: ctx.conversationId,
-  });
-
   // Trigger graph extraction for end-of-conversation sweep.
   // Only extract from guardian conversations to preserve the memory trust
   // boundary — untrusted content must not influence future memory retrieval.

package/src/daemon/conversation-messaging.ts

@@ -32,11 +32,16 @@ import {
   syncMessageToDisk,
   updateMetaFile,
 } from "../memory/conversation-disk-view.js";
+import {
+  type SlackMessageMetadata,
+  writeSlackMetadata,
+} from "../messaging/providers/slack/message-metadata.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { Message } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
 import type { MessageQueue } from "./conversation-queue-manager.js";
 import type { TrustContext } from "./conversation-runtime-assembly.js";
+import type { SlackInboundMessageMetadata } from "./handlers/shared.js";
 import type {
   ServerMessage,
   UserMessageAttachment,
@@ -100,17 +105,17 @@ const INGRESS_SECRET_TARGETS: Record<string, IngressSecretTarget> = {
     label: "SendGrid API Key",
   },
   "Slack Bot Token": {
-    service: "slack",
+    service: "slack_channel",
     field: "bot_token",
     label: "Slack Bot Token",
   },
   "Slack User Token": {
-    service: "slack",
+    service: "slack_channel",
     field: "user_token",
     label: "Slack User Token",
   },
   "Slack Webhook": {
-    service: "slack",
+    service: "slack_channel",
     field: "webhook_url",
     label: "Slack Webhook URL",
   },
@@ -210,6 +215,53 @@ function extractTurnInterfaceContext(
   return { userMessageInterface, assistantMessageInterface };
 }
 
+/**
+ * Build the Slack metadata envelope persisted under the `slackMeta` key on a
+ * user message's `metadata` JSON. Returns `null` (do not include the key) when
+ * the turn is not Slack-originated or the channel ingress did not supply
+ * Slack-specific metadata.
+ *
+ * The conversation is the source of truth for the inbound channel for this
+ * turn — `userMessageChannel` is set by `Server.processMessage` from
+ * `transport.channelId`. Guarding on this ensures non-Slack flows (telegram,
+ * voice, etc.) never get a `slackMeta` key even if a stale plumbing field
+ * leaks through.
+ */
+export function buildSlackMetaForPersistence(params: {
+  slackInbound: unknown;
+  turnChannel: string | undefined;
+}): string | null {
+  if (params.turnChannel !== "slack") {
+    return null;
+  }
+  const inbound = params.slackInbound;
+  if (
+    inbound === null ||
+    typeof inbound !== "object" ||
+    Array.isArray(inbound)
+  ) {
+    return null;
+  }
+  const candidate = inbound as Partial<SlackInboundMessageMetadata>;
+  if (
+    typeof candidate.channelId !== "string" ||
+    !candidate.channelId ||
+    typeof candidate.channelTs !== "string" ||
+    !candidate.channelTs
+  ) {
+    return null;
+  }
+  const slackMeta: SlackMessageMetadata = {
+    source: "slack",
+    channelId: candidate.channelId,
+    channelTs: candidate.channelTs,
+    eventKind: "message",
+    ...(candidate.threadTs ? { threadTs: candidate.threadTs } : {}),
+    ...(candidate.displayName ? { displayName: candidate.displayName } : {}),
+  };
+  return writeSlackMetadata(slackMeta);
+}
+
 // ── enqueueMessage ───────────────────────────────────────────────────
 
 export function enqueueMessage(
@@ -224,6 +276,7 @@ export function enqueueMessage(
   options?: { isInteractive?: boolean },
   displayContent?: string,
   transport?: ConversationTransportMetadata,
+  clientMessageId?: string,
 ): { queued: boolean; requestId: string; rejected?: boolean } {
   if (!ctx.processing) {
     return { queued: false, requestId };
@@ -251,6 +304,7 @@ export function enqueueMessage(
     transport,
     displayContent,
     sentAt: Date.now(),
+    clientMessageId,
   });
   if (!accepted) {
     onEvent({
@@ -362,8 +416,22 @@ export async function persistQueuedMessageBody(
       }
     }
 
+    // Strip the transient `slackInbound` carrier key from the persisted
+    // metadata — it's an in-memory plumbing field, not a stored column value.
+    // The caller-supplied metadata may include it (channel ingress threads it
+    // through `Server.processMessage`); we materialize it into the typed
+    // `slackMeta` sub-key below when the turn channel is Slack.
+    const { slackInbound: rawSlackInbound, ...metadataWithoutSlackInbound } =
+      (metadata ?? {}) as Record<string, unknown> & {
+        slackInbound?: SlackInboundMessageMetadata;
+      };
+    const slackMeta = buildSlackMetaForPersistence({
+      slackInbound: rawSlackInbound,
+      turnChannel: turnCtx?.userMessageChannel,
+    });
+
     const mergedMetadata = {
-      ...(metadata ?? {}),
+      ...metadataWithoutSlackInbound,
       ...provenance,
       ...(turnCtx
         ? {
@@ -378,6 +446,7 @@ export async function persistQueuedMessageBody(
           }
         : {}),
       ...(Object.keys(imageSourcePaths).length > 0 ? { imageSourcePaths } : {}),
+      ...(slackMeta ? { slackMeta } : {}),
     };
 
     // When displayContent is provided (e.g. original text before recording

package/src/daemon/conversation-notifiers.ts

@@ -1,5 +1,5 @@
 /**
- * Watch and call notifier registration/unregistration, extracted from
+ * Call notifier registration/unregistration, extracted from
  * the Conversation constructor and dispose/abort methods.
  *
  * Notifier callbacks read from the provided context object at invocation
@@ -22,24 +22,9 @@ import {
   addMessage,
   provenanceFromTrustContext,
 } from "../memory/conversation-crud.js";
-import { setMessageIdOnLogs } from "../memory/llm-request-log-store.js";
 import type { Message } from "../providers/types.js";
-import type { WatchSession } from "../tools/watch/watch-state.js";
-import {
-  pruneWatchSessions,
-  registerWatchCommentaryNotifier,
-  registerWatchCompletionNotifier,
-  registerWatchStartNotifier,
-  unregisterWatchCommentaryNotifier,
-  unregisterWatchCompletionNotifier,
-  unregisterWatchStartNotifier,
-} from "../tools/watch/watch-state.js";
 import type { TrustContext } from "./conversation-runtime-assembly.js";
 import type { ServerMessage } from "./message-protocol.js";
-import {
-  lastCommentaryByConversation,
-  lastSummaryByConversation,
-} from "./watch-handler.js";
 
 /**
  * Subset of Conversation state that notifier callbacks need to read at
@@ -52,7 +37,7 @@ export interface NotifierConversationContext {
 }
 
 /**
- * Register watch and call notifiers for a conversation. Call once during
+ * Register call notifiers for a conversation. Call once during
  * construction; the notifier callbacks close over `ctx` so they see
  * live sendToClient/messages values.
  */
@@ -60,88 +45,6 @@ export function registerConversationNotifiers(
   conversationId: string,
   ctx: NotifierConversationContext,
 ): void {
-  registerWatchStartNotifier(conversationId, (session: WatchSession) => {
-    ctx.sendToClient({
-      type: "watch_started",
-      conversationId: conversationId,
-      watchId: session.watchId,
-      durationSeconds: session.durationSeconds,
-      intervalSeconds: session.intervalSeconds,
-    });
-  });
-
-  registerWatchCommentaryNotifier(
-    conversationId,
-    async (_session: WatchSession) => {
-      const result = lastCommentaryByConversation.get(conversationId);
-      if (result) {
-        lastCommentaryByConversation.delete(conversationId);
-
-        const msg = await addMessage(
-          conversationId,
-          "assistant",
-          JSON.stringify([{ type: "text", text: result.text }]),
-          provenanceFromTrustContext(ctx.trustContext),
-        );
-        ctx.messages.push(createAssistantMessage(result.text));
-
-        try {
-          setMessageIdOnLogs(result.logIds, msg.id);
-        } catch {
-          // non-fatal — message is persisted even if log linkage fails
-        }
-
-        ctx.sendToClient({
-          type: "assistant_text_delta",
-          text: result.text,
-          conversationId: conversationId,
-        });
-        ctx.sendToClient({
-          type: "message_complete",
-          conversationId: conversationId,
-          messageId: msg.id,
-          source: "aux",
-        });
-      }
-    },
-  );
-
-  registerWatchCompletionNotifier(
-    conversationId,
-    async (_session: WatchSession) => {
-      const result = lastSummaryByConversation.get(conversationId);
-      if (result) {
-        lastSummaryByConversation.delete(conversationId);
-
-        const msg = await addMessage(
-          conversationId,
-          "assistant",
-          JSON.stringify([{ type: "text", text: result.text }]),
-          provenanceFromTrustContext(ctx.trustContext),
-        );
-        ctx.messages.push(createAssistantMessage(result.text));
-
-        try {
-          setMessageIdOnLogs(result.logIds, msg.id);
-        } catch {
-          // non-fatal — message is persisted even if log linkage fails
-        }
-
-        ctx.sendToClient({
-          type: "assistant_text_delta",
-          text: result.text,
-          conversationId: conversationId,
-        });
-        ctx.sendToClient({
-          type: "message_complete",
-          conversationId: conversationId,
-          messageId: msg.id,
-          source: "aux",
-        });
-      }
-    },
-  );
-
   registerCallQuestionNotifier(
     conversationId,
     async (callSessionId: string, question: string) => {
@@ -213,17 +116,6 @@ export function registerConversationNotifiers(
   });
 }
 
-/**
- * Unregister watch notifiers and prune watch sessions. Called during
- * abort when the conversation is actively processing.
- */
-export function unregisterWatchNotifiers(conversationId: string): void {
-  unregisterWatchStartNotifier(conversationId);
-  unregisterWatchCommentaryNotifier(conversationId);
-  unregisterWatchCompletionNotifier(conversationId);
-  pruneWatchSessions(conversationId);
-}
-
 /**
  * Unregister call notifiers. Called during dispose regardless of
  * processing state (notifiers are registered in the constructor).