@vellumai/assistant 0.8.3 → 0.8.4

package/src/daemon/conversation-lifecycle.ts

@@ -31,6 +31,7 @@ import { type AbortReason, createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import { unregisterCallNotifiers } from "./conversation-notifiers.js";
 import type { MessageQueue } from "./conversation-queue-manager.js";
+import { stripInjectionsForCompaction } from "./conversation-runtime-assembly.js";
 import { resetSkillToolProjection } from "./conversation-skill-tools.js";
 import { resolveTrustClass } from "./conversation-tool-setup.js";
 import { repairHistory } from "./history-repair.js";
@@ -188,6 +189,19 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
     ctx.contextCompactedAt = conv?.contextCompactedAt ?? null;
   }
 
+  // `/clean` persists a timestamp; messages older than this should skip
+  // metadata rehydration and have any injection prefixes still embedded in
+  // their content stripped, so the cleaned state survives reload and forks.
+  const cleanedAt = conv?.cleanedAt ?? null;
+  const slicedDbMessages = dbMessages.slice(ctx.contextCompactedMessageCount);
+  let preCleanCount = 0;
+  if (cleanedAt != null) {
+    const boundary = slicedDbMessages.findIndex(
+      (m) => m.createdAt >= cleanedAt,
+    );
+    preCleanCount = boundary === -1 ? slicedDbMessages.length : boundary;
+  }
+
   // Mirror the injection-time gate (`shouldExposePersonalMemory` in
   // `conversation-agent-loop.ts`) so background/local conversations
   // (sourceChannel `undefined` or `"vellum"`) can rehydrate the persisted
@@ -198,129 +212,141 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
     sourceChannel: ctx.trustContext?.sourceChannel,
     isTrustedActor: resolveTrustClass(ctx.trustContext) === "guardian",
   });
-  const parsedMessages: Message[] = dbMessages
-    .slice(ctx.contextCompactedMessageCount)
-    .map((m, index, arr) => {
-      const role = m.role as "user" | "assistant";
-      let content: ContentBlock[];
+  const parsedMessages: Message[] = slicedDbMessages.map((m, index, arr) => {
+    const isPreClean = index < preCleanCount;
+    const role = m.role as "user" | "assistant";
+    let content: ContentBlock[];
+    try {
+      const parsed = JSON.parse(m.content);
+      content = Array.isArray(parsed)
+        ? parsed
+        : [{ type: "text", text: m.content }];
+    } catch {
+      log.warn(
+        { conversationId: ctx.conversationId, messageId: m.id },
+        "Invalid JSON in persisted message content, replacing with safe text block",
+      );
+      content = [{ type: "text", text: m.content }];
+    }
+
+    content = reinjectImageSourcePaths(content, role, m.metadata);
+
+    // Re-inject persisted injection blocks from metadata so it survives
+    // conversation reloads (eviction, restart, fork).
+    if (role === "user" && m.metadata && !isPreClean) {
       try {
-        const parsed = JSON.parse(m.content);
-        content = Array.isArray(parsed)
-          ? parsed
-          : [{ type: "text", text: m.content }];
-      } catch {
-        log.warn(
-          { conversationId: ctx.conversationId, messageId: m.id },
-          "Invalid JSON in persisted message content, replacing with safe text block",
-        );
-        content = [{ type: "text", text: m.content }];
-      }
+        const meta = JSON.parse(m.metadata);
+        const isTail = index === arr.length - 1;
+
+        // Rehydrate in reverse injection order (innermost block first)
+        // so the resulting layout matches `applyRuntimeInjections`'s
+        // after-memory-prefix splices in ascending injector order
+        // (pkb-context 30, pkb-reminder 35, memory-v2-static 38,
+        // now-md 40 — the v2 static block lands inside the memory
+        // prefix, so now-md splices *after* it):
+        //   [<workspace>, <turn_context>, <memory __injected>,
+        //    <memory>\n…</memory>, <NOW.md>, <system_reminder>,
+        //    <knowledge_base>, ...original]
+        // Required so Anthropic's prefix cache keeps matching msg[0]
+        // across daemon restart and conversation eviction. The tail
+        // row only rehydrates `memoryInjectedBlock` — the next turn
+        // re-injects the rest fresh.
+        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,
+          ];
+        }
 
-      content = reinjectImageSourcePaths(content, role, m.metadata);
+        if (!isTail && typeof meta.nowScratchpadBlock === "string") {
+          content = [
+            { type: "text" as const, text: meta.nowScratchpadBlock },
+            ...content,
+          ];
+        }
 
-      // 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;
-
-          // Rehydrate in reverse injection order (innermost block first)
-          // so the resulting layout matches `applyRuntimeInjections`'s
-          // after-memory-prefix splices in ascending injector order
-          // (pkb-context 30, pkb-reminder 35, memory-v2-static 38,
-          // now-md 40 — the v2 static block lands inside the memory
-          // prefix, so now-md splices *after* it):
-          //   [<workspace>, <turn_context>, <memory __injected>,
-          //    <memory>\n…</memory>, <NOW.md>, <system_reminder>,
-          //    <knowledge_base>, ...original]
-          // Required so Anthropic's prefix cache keeps matching msg[0]
-          // across daemon restart and conversation eviction. The tail
-          // row only rehydrates `memoryInjectedBlock` — the next turn
-          // re-injects the rest fresh.
-          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,
-            ];
-          }
-
-          if (!isTail && typeof meta.nowScratchpadBlock === "string") {
-            content = [
-              { type: "text" as const, text: meta.nowScratchpadBlock },
-              ...content,
-            ];
-          }
-
-          // The v2 static memory block (essentials/threads/recent/buffer
-          // wrapped in `<memory>…</memory>`) carries personal user memory.
-          // Trust-gated to mirror `shouldExposePersonalMemory` at injection
-          // time — untrusted-actor views must not read persisted personal
-          // memory back through metadata. Skipped on the tail row because
-          // the next turn re-injects fresh content on full-mode turns.
-          if (
-            !isTail &&
-            personalMemoryAllowed &&
-            typeof meta.memoryV2StaticBlock === "string"
-          ) {
-            content = [
-              { type: "text" as const, text: meta.memoryV2StaticBlock },
-              ...content,
-            ];
-          }
-
-          // Memory remains rehydrated on all rows (existing behavior).
-          // Strip any pre-existing wrapper before re-wrapping so historical
-          // rows persisted with the wrapper (v2 path before the
-          // injectedBlockText contract was unified with v1's unwrapped form)
-          // don't render double-wrapped after rehydrate. Only unwrap when
-          // the full <memory>...</memory> pair is present so we don't mutate
-          // legitimate unwrapped payloads that happen to start with
-          // "<memory>\n" or end with "\n</memory>".
-          if (typeof meta.memoryInjectedBlock === "string") {
-            const block = meta.memoryInjectedBlock;
-            const inner =
-              block.startsWith("<memory>\n") && block.endsWith("\n</memory>")
-                ? block.slice("<memory>\n".length, -"\n</memory>".length)
-                : block;
-            content = [
-              {
-                type: "text" as const,
-                text: `<memory>\n${inner}\n</memory>`,
-              },
-              ...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 */
+        // The v2 static memory block (essentials/threads/recent/buffer
+        // wrapped in `<memory>…</memory>`) carries personal user memory.
+        // Trust-gated to mirror `shouldExposePersonalMemory` at injection
+        // time — untrusted-actor views must not read persisted personal
+        // memory back through metadata. Skipped on the tail row because
+        // the next turn re-injects fresh content on full-mode turns.
+        if (
+          !isTail &&
+          personalMemoryAllowed &&
+          typeof meta.memoryV2StaticBlock === "string"
+        ) {
+          content = [
+            { type: "text" as const, text: meta.memoryV2StaticBlock },
+            ...content,
+          ];
         }
+
+        // Memory remains rehydrated on all rows (existing behavior).
+        // Strip any pre-existing wrapper before re-wrapping so historical
+        // rows persisted with the wrapper (v2 path before the
+        // injectedBlockText contract was unified with v1's unwrapped form)
+        // don't render double-wrapped after rehydrate. Only unwrap when
+        // the full <memory>...</memory> pair is present so we don't mutate
+        // legitimate unwrapped payloads that happen to start with
+        // "<memory>\n" or end with "\n</memory>".
+        if (typeof meta.memoryInjectedBlock === "string") {
+          const block = meta.memoryInjectedBlock;
+          const inner =
+            block.startsWith("<memory>\n") && block.endsWith("\n</memory>")
+              ? block.slice("<memory>\n".length, -"\n</memory>".length)
+              : block;
+          content = [
+            {
+              type: "text" as const,
+              text: `<memory>\n${inner}\n</memory>`,
+            },
+            ...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 */
       }
+    }
 
-      return { role, content };
-    });
+    return { role, content };
+  });
 
-  const { messages: repairedMessages, stats } = repairHistory(parsedMessages);
+  // Strip pre-clean messages only; post-clean messages keep the fresh
+  // injections they were generated with.
+  const messagesBeforeRepair =
+    preCleanCount === 0
+      ? parsedMessages
+      : [
+          ...stripInjectionsForCompaction(
+            parsedMessages.slice(0, preCleanCount),
+          ),
+          ...parsedMessages.slice(preCleanCount),
+        ];
+
+  const { messages: repairedMessages, stats } =
+    repairHistory(messagesBeforeRepair);
   if (
     stats.assistantToolResultsMigrated > 0 ||
     stats.missingToolResultsInserted > 0 ||

package/src/daemon/conversation-messaging.ts

@@ -36,6 +36,7 @@ import {
   updateMetaFile,
 } from "../memory/conversation-disk-view.js";
 import {
+  buildSlackTimezoneMetadata,
   type SlackMessageMetadata,
   writeSlackMetadata,
 } from "../messaging/providers/slack/message-metadata.js";
@@ -270,6 +271,7 @@ export function buildSlackMetaForPersistence(params: {
   const slackMeta: SlackMessageMetadata = {
     source: "slack",
     channelId: candidate.channelId,
+    ...(candidate.channelName ? { channelName: candidate.channelName } : {}),
     channelTs: candidate.channelTs,
     eventKind: "message",
     ...(candidate.threadTs ? { threadTs: candidate.threadTs } : {}),
@@ -277,6 +279,7 @@ export function buildSlackMetaForPersistence(params: {
     ...(candidate.actorExternalUserId
       ? { actorExternalUserId: candidate.actorExternalUserId }
       : {}),
+    ...buildSlackTimezoneMetadata(candidate),
   };
   return writeSlackMetadata(slackMeta);
 }

package/src/daemon/conversation-process.ts

@@ -33,6 +33,7 @@ import type { Message } from "../providers/types.js";
 import { routeGuardianReply } from "../runtime/guardian-reply-router.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
+import type { CleanResult } from "./conversation.js";
 import {
   persistQueuedMessageBody,
   serializePersistedUserMessageContent,
@@ -84,6 +85,22 @@ export function formatCompactResult(result: ContextWindowResult): string {
       result.maxInputTokens,
     )} tokens`,
     `Messages: ${fmt(result.compactedMessages)} compacted`,
+    `Tail:     ${fmt(result.preservedTailMessages)} preserved`,
+  ].join("\n");
+}
+
+/** Format the result of a forced clean into a user-facing message. */
+export function formatCleanResult(result: CleanResult): string {
+  const fmt = (n: number | undefined) => (n ?? 0).toLocaleString("en-US");
+  const reclaimed =
+    result.previousEstimatedInputTokens - result.estimatedInputTokens;
+  return [
+    "Context Cleaned\n",
+    `Tokens:   ${fmt(result.previousEstimatedInputTokens)} → ${fmt(result.estimatedInputTokens)} (${fmt(reclaimed)} reclaimed)`,
+    `Context:  ${fmt(result.estimatedInputTokens)} / ${fmt(
+      result.maxInputTokens,
+    )} tokens`,
+    `Messages: ${fmt(result.preservedMessages)} preserved`,
   ].join("\n");
 }
 
@@ -122,6 +139,9 @@ export interface ProcessConversationContext {
   readonly surfaceActionRequestIds: Set<string>;
   currentActiveSurfaceId?: string;
   currentPage?: string;
+  /** When true, the drain path should inject synthetic tool_result messages
+   *  for any pending tool_use blocks abandoned by a steered abort. */
+  pendingSteerRepair?: boolean;
   /** Cumulative token usage stats for the conversation. */
   readonly usageStats: UsageStats;
   /** Request-scoped skill IDs preactivated via config or programmatic injection. */
@@ -187,6 +207,8 @@ export interface ProcessConversationContext {
   forceCompact(options?: {
     targetInputTokensOverride?: number;
   }): Promise<ContextWindowResult>;
+  /** Strip runtime injections and reset memory-injection state. */
+  forceClean(): Promise<CleanResult>;
   /** Set transport-derived hints for the conversation. */
   setTransportHints(hints: string[] | undefined): void;
   /** IANA timezone reported by the active client for the current turn. */
@@ -346,6 +368,76 @@ async function buildPassthroughBatch(
   return conversation.queue.shiftN(matched);
 }
 
+// ── Steer repair ────────────────────────────────────────────────────
+
+/**
+ * When a steer-to-message abort interrupts an in-flight tool call, the
+ * conversation history may end with an assistant message containing one
+ * or more `tool_use` blocks that have no corresponding `tool_result`.
+ * LLM providers reject this sequence. This helper scans the tail of the
+ * history and injects synthetic error `tool_result` messages for any
+ * unmatched `tool_use` blocks.
+ */
+function repairPendingToolUseBlocks(
+  conversation: ProcessConversationContext,
+): void {
+  if (!conversation.pendingSteerRepair) return;
+  conversation.pendingSteerRepair = false;
+
+  const messages = conversation.messages;
+  if (messages.length === 0) return;
+
+  // Walk backwards from the tail to find the last assistant message with
+  // tool_use blocks. Collect resolved IDs from any user messages between
+  // the tail and that assistant message, then subtract them.
+  const resolvedToolUseIds = new Set<string>();
+  const pendingToolUseIds: string[] = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "user") {
+      for (const block of msg.content) {
+        if (
+          block.type === "tool_result" ||
+          block.type === "web_search_tool_result"
+        ) {
+          resolvedToolUseIds.add(block.tool_use_id);
+        }
+      }
+    } else if (msg.role === "assistant") {
+      for (const block of msg.content) {
+        if (block.type === "tool_use" && !resolvedToolUseIds.has(block.id)) {
+          pendingToolUseIds.push(block.id);
+        }
+      }
+      // Only repair tool_use blocks from the last assistant message that
+      // has them — earlier history should already be consistent.
+      break;
+    }
+  }
+
+  if (pendingToolUseIds.length === 0) return;
+
+  log.info(
+    {
+      conversationId: conversation.conversationId,
+      pendingToolUseCount: pendingToolUseIds.length,
+    },
+    "Injecting synthetic tool_result for pending tool_use blocks after steer",
+  );
+
+  // Build a single user message with tool_result blocks for all pending IDs.
+  const syntheticContent = pendingToolUseIds.map((toolUseId) => ({
+    type: "tool_result" as const,
+    tool_use_id: toolUseId,
+    content: "Tool execution was interrupted by user steering.",
+    is_error: true,
+  }));
+  conversation.messages.push({
+    role: "user",
+    content: syntheticContent,
+  });
+}
+
 // ── drainQueue ───────────────────────────────────────────────────────
 
 /**
@@ -362,6 +454,20 @@ export async function drainQueue(
   conversation: ProcessConversationContext,
   reason: QueueDrainReason = "loop_complete",
 ): Promise<void> {
+  // After a steer, drain only the promoted head message — don't batch
+  // the remaining queue items into the same turn.
+  const steered = conversation.pendingSteerRepair;
+
+  // Repair any pending tool_use blocks left over from a steered abort
+  // before the drain path sends the next message to the LLM.
+  repairPendingToolUseBlocks(conversation);
+
+  if (steered) {
+    const next = conversation.queue.shift();
+    if (!next) return;
+    return drainSingleMessage(conversation, next, reason);
+  }
+
   const batch = await buildPassthroughBatch(conversation);
   if (batch.length === 0) {
     // Head is a slash / verification intent / empty queue. If the queue has
@@ -701,6 +807,94 @@ async function drainSingleMessage(
     return;
   }
 
+  // /clean — strip runtime injections and reset memory state, no LLM call.
+  if (slashResult.kind === "clean") {
+    let persistedCleanMessage = false;
+    try {
+      const drainProvenance = provenanceFromTrustContext(
+        conversation.trustContext,
+      );
+      const drainChannelMeta = {
+        ...drainProvenance,
+        ...(queuedTurnCtx
+          ? {
+              userMessageChannel: queuedTurnCtx.userMessageChannel,
+              assistantMessageChannel: queuedTurnCtx.assistantMessageChannel,
+            }
+          : {}),
+        ...(queuedInterfaceCtx
+          ? {
+              userMessageInterface: queuedInterfaceCtx.userMessageInterface,
+              assistantMessageInterface:
+                queuedInterfaceCtx.assistantMessageInterface,
+            }
+          : {}),
+        sentAt: next.sentAt,
+      };
+      const cleanUserMsg = createUserMessage(next.content, next.attachments);
+      await addMessage(
+        conversation.conversationId,
+        "user",
+        serializePersistedUserMessageContent(
+          next.content,
+          next.attachments,
+          next.displayContent,
+        ),
+        drainChannelMeta,
+      );
+      persistedCleanMessage = true;
+      conversation.messages.push(cleanUserMsg);
+
+      const result = await conversation.forceClean();
+      const responseText = formatCleanResult(result);
+
+      const assistantMsg = createAssistantMessage(responseText);
+      await addMessage(
+        conversation.conversationId,
+        "assistant",
+        JSON.stringify(assistantMsg.content),
+        { ...drainChannelMeta, sentAt: Date.now() },
+      );
+      conversation.messages.push(assistantMsg);
+
+      next.onEvent({
+        type: "assistant_text_delta",
+        text: responseText,
+        conversationId: conversation.conversationId,
+      });
+      conversation.traceEmitter.emit(
+        "message_complete",
+        "Clean slash command handled",
+        { requestId: next.requestId, status: "success" },
+      );
+      next.onEvent({
+        type: "message_complete",
+        conversationId: conversation.conversationId,
+      });
+      publishConversationMessagesChanged(conversation.conversationId);
+    } catch (err) {
+      if (persistedCleanMessage) {
+        publishConversationMessagesChanged(conversation.conversationId);
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      log.error(
+        {
+          err,
+          conversationId: conversation.conversationId,
+          requestId: next.requestId,
+        },
+        "Failed to execute /clean",
+      );
+      next.onEvent({
+        type: "error",
+        conversationId: conversation.conversationId,
+        message,
+      });
+    }
+    await drainQueue(conversation);
+    return;
+  }
+
   const resolvedContent = slashResult.content;
 
   // Guardian verification intent interception for queued messages.
@@ -1560,6 +1754,85 @@ export async function processMessage(
     }
   }
 
+  // /clean — strip runtime injections, return message ID. No LLM call.
+  if (slashResult.kind === "clean") {
+    conversation.processing = true;
+    let persistedCleanMessage = false;
+    try {
+      const pmTurnCtx = conversation.getTurnChannelContext();
+      const pmInterfaceCtx = conversation.getTurnInterfaceContext();
+      const pmProvenance = provenanceFromTrustContext(
+        conversation.trustContext,
+      );
+      const pmChannelMeta = {
+        ...pmProvenance,
+        ...(pmTurnCtx
+          ? {
+              userMessageChannel: pmTurnCtx.userMessageChannel,
+              assistantMessageChannel: pmTurnCtx.assistantMessageChannel,
+            }
+          : {}),
+        ...(pmInterfaceCtx
+          ? {
+              userMessageInterface: pmInterfaceCtx.userMessageInterface,
+              assistantMessageInterface:
+                pmInterfaceCtx.assistantMessageInterface,
+            }
+          : {}),
+      };
+      const cleanUserMsg = createUserMessage(content, attachments);
+      const persisted = await addMessage(
+        conversation.conversationId,
+        "user",
+        serializePersistedUserMessageContent(
+          content,
+          attachments,
+          displayContent,
+        ),
+        pmChannelMeta,
+      );
+      persistedCleanMessage = true;
+      conversation.messages.push(cleanUserMsg);
+
+      const result = await conversation.forceClean();
+      const responseText = formatCleanResult(result);
+
+      const assistantMsg = createAssistantMessage(responseText);
+      await addMessage(
+        conversation.conversationId,
+        "assistant",
+        JSON.stringify(assistantMsg.content),
+        pmChannelMeta,
+      );
+      conversation.messages.push(assistantMsg);
+
+      onEvent({
+        type: "assistant_text_delta",
+        text: responseText,
+        conversationId: conversation.conversationId,
+      });
+      conversation.traceEmitter.emit(
+        "message_complete",
+        "Clean slash command handled",
+        { requestId, status: "success" },
+      );
+      onEvent({
+        type: "message_complete",
+        conversationId: conversation.conversationId,
+      });
+      publishConversationMessagesChanged(conversation.conversationId);
+      return persisted.id;
+    } catch (err) {
+      if (persistedCleanMessage) {
+        publishConversationMessagesChanged(conversation.conversationId);
+      }
+      throw err;
+    } finally {
+      conversation.processing = false;
+      await drainQueue(conversation);
+    }
+  }
+
   const resolvedContent = slashResult.content;
 
   // Guardian verification intent interception — force direct guardian

package/src/daemon/conversation-queue-manager.ts

@@ -158,6 +158,20 @@ export class MessageQueue {
     return this.currentBytes;
   }
 
+  /**
+   * Move a queued message to the head of the queue (index 0) by its requestId.
+   * Returns the promoted message, or undefined if not found.
+   * Byte accounting is unchanged — the item stays in the queue, just reordered.
+   */
+  promoteToHead(requestId: string): QueuedMessage | undefined {
+    const idx = this.items.findIndex((m) => m.requestId === requestId);
+    if (idx === -1) return undefined;
+    if (idx === 0) return this.items[0]; // already at head
+    const [promoted] = this.items.splice(idx, 1);
+    this.items.unshift(promoted);
+    return promoted;
+  }
+
   /**
    * Remove a queued message by its requestId.
    * Returns the removed message, or undefined if not found.