@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/daemon/reaction-history-render.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, test } from "bun:test";
+
+import type { ProviderMessageMetadata } from "../messaging/provider-message-metadata.js";
+import { renderReactionHistoryText } from "./reaction-history-render.js";
+
+function reactionMeta(
+  overrides: Omit<Partial<ProviderMessageMetadata>, "reaction"> & {
+    reaction?: Partial<NonNullable<ProviderMessageMetadata["reaction"]>>;
+  } = {},
+): ProviderMessageMetadata {
+  const { reaction, ...rest } = overrides;
+  return {
+    source: "slack",
+    conversationExternalId: "C123",
+    eventKind: "reaction",
+    reaction: {
+      targetMessageId: "1716000000.000001",
+      emoji: "thumbsup",
+      op: "added",
+      actorDisplayName: "Alice",
+      ...reaction,
+    },
+    ...rest,
+  } as ProviderMessageMetadata;
+}
+
+const noTarget = () => undefined;
+
+describe("renderReactionHistoryText", () => {
+  test("renders an added reaction with the quoted target", () => {
+    const rendered = renderReactionHistoryText(
+      reactionMeta(),
+      () => "Deploy is done",
+    );
+    expect(rendered).toContain(
+      'Alice reacted with :thumbsup: to the message "Deploy is done"',
+    );
+  });
+
+  test("renders a removed reaction", () => {
+    const rendered = renderReactionHistoryText(
+      reactionMeta({ reaction: { op: "removed" } }),
+      noTarget,
+    );
+    expect(rendered).toContain(
+      "Alice removed their :thumbsup: reaction from an earlier message",
+    );
+  });
+
+  test("fences the line as untrusted channel content", () => {
+    const rendered = renderReactionHistoryText(
+      reactionMeta({ actorExternalId: "U123" }),
+      noTarget,
+    );
+    expect(rendered).toContain('<external_content source="slack"');
+    expect(rendered).toContain('origin="U123"');
+    expect(rendered).toContain("</external_content>");
+  });
+
+  test("non-slack channels fence with the webhook source", () => {
+    const rendered = renderReactionHistoryText(
+      reactionMeta({ source: "discord" }),
+      noTarget,
+    );
+    expect(rendered).toContain('<external_content source="webhook"');
+  });
+
+  test("keeps a Discord custom-emoji mention form as-is", () => {
+    const rendered = renderReactionHistoryText(
+      reactionMeta({ reaction: { emoji: "<:vex:12345>" } }),
+      noTarget,
+    );
+    expect(rendered).toContain("reacted with <:vex:12345> to");
+  });
+
+  test("keeps a unicode emoji as-is", () => {
+    const rendered = renderReactionHistoryText(
+      reactionMeta({ reaction: { emoji: "👍" } }),
+      noTarget,
+    );
+    expect(rendered).toContain("reacted with 👍 to");
+  });
+
+  test("strips ingress fences and collapses whitespace in the quote", () => {
+    const rendered = renderReactionHistoryText(
+      reactionMeta(),
+      () =>
+        '<external_content source="slack">\nline one\n  line two\n</external_content>',
+    );
+    expect(rendered).toContain('the message "line one line two"');
+  });
+
+  test("truncates a long quoted target", () => {
+    const rendered = renderReactionHistoryText(reactionMeta(), () =>
+      "x".repeat(500),
+    );
+    expect(rendered).toContain(`"${"x".repeat(120)}..."`);
+    expect(rendered).not.toContain("x".repeat(121));
+  });
+
+  test("falls back to Someone when no display name is stored", () => {
+    const rendered = renderReactionHistoryText(
+      reactionMeta({ reaction: { actorDisplayName: undefined } }),
+      noTarget,
+    );
+    expect(rendered).toContain("Someone reacted with");
+  });
+
+  test("prefers the row-level display name over the fallback", () => {
+    const rendered = renderReactionHistoryText(
+      reactionMeta({
+        displayName: "Bob",
+        reaction: { actorDisplayName: undefined },
+      }),
+      noTarget,
+    );
+    expect(rendered).toContain("Bob reacted with");
+  });
+
+  test("a self-authored row is second-person with the quoted target fenced", () => {
+    const rendered = renderReactionHistoryText(
+      reactionMeta({ source: "discord" }),
+      () => "Deploy is done",
+      { selfAuthored: true },
+    );
+    expect(rendered).toContain("You reacted with :thumbsup: to this message:");
+    expect(rendered).toContain('<external_content source="webhook"');
+    expect(rendered).toContain("Deploy is done");
+    expect(rendered).toContain("</external_content>");
+  });
+
+  test("a self-authored row with no target stays unfenced", () => {
+    const rendered = renderReactionHistoryText(
+      reactionMeta({ source: "discord" }),
+      noTarget,
+      { selfAuthored: true },
+    );
+    expect(rendered).toBe("You reacted with :thumbsup: to an earlier message");
+    expect(rendered).not.toContain("<external_content");
+  });
+
+  test("a self-authored removal reads as your reaction", () => {
+    const rendered = renderReactionHistoryText(
+      reactionMeta({ reaction: { op: "removed" } }),
+      noTarget,
+      { selfAuthored: true },
+    );
+    expect(rendered).toContain(
+      "You removed your :thumbsup: reaction from an earlier message",
+    );
+  });
+
+  test("returns null for a message row", () => {
+    const meta: ProviderMessageMetadata = {
+      source: "slack",
+      conversationExternalId: "C123",
+      messageId: "1716000000.000001",
+      eventKind: "message",
+    } as ProviderMessageMetadata;
+    expect(renderReactionHistoryText(meta, noTarget)).toBeNull();
+  });
+});

package/src/daemon/reaction-history-render.ts

@@ -0,0 +1,115 @@
+/**
+ * Render a persisted reaction row into the text the model reads.
+ *
+ * A reaction is stored as a user row whose content is the "[reaction]"
+ * sentinel; the fact lives in the row's metadata (`providerMeta.reaction`:
+ * who reacted, with which emoji, on which message). The stored row stays
+ * canonical and rendering happens at history-load time, so every stored row
+ * renders regardless of when it was written and no formatting is frozen
+ * into persistence.
+ *
+ * Two authorship contracts share the renderer. An inbound row (role user)
+ * is sender activity: the actor's display name and the quoted target are
+ * sender-authored, so the whole line is fenced as untrusted content the
+ * same way channel text is fenced at ingress (`inbound-content-prep.ts`).
+ * A self-authored row (role assistant, written by the react tool) renders
+ * second-person with the verb unfenced, but the quoted target stays
+ * fenced: the emoji and act are the model's own output, the text it
+ * reacted to is not.
+ *
+ * Serves consumers of `Conversation.loadFromDb` history. Slack channel
+ * turns build their provider history from rows instead and render
+ * reactions through their own transcript renderer
+ * (`messaging/providers/slack/render-transcript.ts`), whose tag-line
+ * format references targets by alias rather than by quote.
+ */
+import type { ProviderMessageMetadata } from "../messaging/provider-message-metadata.js";
+import {
+  unwrapExternalContentForDisplay,
+  wrapUntrustedContent,
+} from "../security/untrusted-content.js";
+
+/**
+ * Slack-style emoji names render in colon form. Anything else (a unicode
+ * emoji, Discord's `<:name:id>` mention form) is already self-delimiting.
+ */
+const EMOJI_NAME_PATTERN = /^[\w+'-]+$/;
+
+const TARGET_SNIPPET_MAX_CHARS = 120;
+
+function formatEmoji(emoji: string): string {
+  return EMOJI_NAME_PATTERN.test(emoji) ? `:${emoji}:` : emoji;
+}
+
+/**
+ * Flatten a quoted target to one line: the ingress fence is markup around
+ * the target's own text, not part of it, so it is unwrapped rather than
+ * quoted.
+ */
+function snippetOf(text: string): string {
+  const flat = unwrapExternalContentForDisplay(text)
+    .replace(/\s+/g, " ")
+    .trim();
+  if (flat.length <= TARGET_SNIPPET_MAX_CHARS) {
+    return flat;
+  }
+  return `${flat.slice(0, TARGET_SNIPPET_MAX_CHARS)}...`;
+}
+
+/**
+ * The readable line for a reaction row, fenced, or null when the metadata
+ * does not describe a reaction (callers keep the row's stored content then).
+ *
+ * `resolveTargetText` maps the reaction's `targetMessageId` to the target
+ * row's text in the same provider id namespace; returning undefined (target
+ * compacted away, or never stored) degrades to "an earlier message".
+ */
+export function renderReactionHistoryText(
+  meta: ProviderMessageMetadata,
+  resolveTargetText: (targetMessageId: string) => string | undefined,
+  options?: {
+    /**
+     * The row is the assistant's own reaction (an assistant-role row the
+     * react tool persisted). Rendered second-person and unfenced: the actor
+     * and emoji are the model's own output, not sender-authored text.
+     */
+    selfAuthored?: boolean;
+  },
+): string | null {
+  if (meta.eventKind !== "reaction" || !meta.reaction) {
+    return null;
+  }
+  const { emoji, op, targetMessageId } = meta.reaction;
+  const target = resolveTargetText(targetMessageId);
+  const snippet = target ? snippetOf(target) : "";
+
+  if (options?.selfAuthored) {
+    const verb =
+      op === "removed"
+        ? `removed your ${formatEmoji(emoji)} reaction from`
+        : `reacted with ${formatEmoji(emoji)} to`;
+    if (!snippet) {
+      return `You ${verb} an earlier message`;
+    }
+    // The quoted target is sender-authored text entering an assistant-role
+    // message; unfenced it would replay as trusted content, so a sender
+    // could plant instructions and induce a reaction to launder them.
+    const fencedSnippet = wrapUntrustedContent(snippet, {
+      source: meta.source === "slack" ? "slack" : "webhook",
+    });
+    return `You ${verb} this message: ${fencedSnippet}`;
+  }
+
+  const actor = meta.reaction.actorDisplayName ?? meta.displayName ?? "Someone";
+  const verb =
+    op === "removed"
+      ? `removed their ${formatEmoji(emoji)} reaction from`
+      : `reacted with ${formatEmoji(emoji)} to`;
+  const line = snippet
+    ? `${actor} ${verb} the message "${snippet}"`
+    : `${actor} ${verb} an earlier message`;
+  return wrapUntrustedContent(line, {
+    source: meta.source === "slack" ? "slack" : "webhook",
+    ...(meta.actorExternalId ? { sourceDetail: meta.actorExternalId } : {}),
+  });
+}

package/src/daemon/reaction-record.test.ts

@@ -0,0 +1,162 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { QueuedReactionRecord } from "./reaction-record.js";
+
+let persisted: Array<{
+  conversationId: string;
+  role: string;
+  content: string;
+  metadata: Record<string, unknown> | undefined;
+}> = [];
+let failNext = false;
+const actualCrud = await import("../persistence/conversation-crud.js");
+mock.module("../persistence/conversation-crud.js", () => ({
+  ...actualCrud,
+  addMessage: async (
+    conversationId: string,
+    role: string,
+    content: string,
+    opts?: { metadata?: Record<string, unknown> },
+  ) => {
+    if (failNext) {
+      failNext = false;
+      throw new Error("db closed");
+    }
+    persisted.push({ conversationId, role, content, metadata: opts?.metadata });
+    return { id: `row-${persisted.length}` };
+  },
+}));
+
+const { persistReactionRecords } = await import("./reaction-record.js");
+const { drainQueuedReactionRecords } =
+  await import("./conversation-agent-loop.js");
+
+function record(
+  overrides: Partial<QueuedReactionRecord> = {},
+): QueuedReactionRecord {
+  return {
+    channel: "discord",
+    chatId: "chan-1",
+    messageId: "555.1",
+    emoji: "🎉",
+    op: "added",
+    provenanceTrustClass: "guardian",
+    ...overrides,
+  };
+}
+
+describe("persistReactionRecords", () => {
+  beforeEach(() => {
+    persisted = [];
+    failNext = false;
+  });
+
+  test("a neutral-channel record writes the providerMeta envelope", async () => {
+    await persistReactionRecords("conv-1", [record()]);
+    expect(persisted).toHaveLength(1);
+    const row = persisted[0]!;
+    expect(row.role).toBe("assistant");
+    expect(row.content).toBe("[reaction]");
+    expect(row.metadata?.messageKind).toBe("reaction");
+    expect(row.metadata?.provenanceTrustClass).toBe("guardian");
+    expect(row.metadata?.provenanceSourceChannel).toBe("discord");
+    const envelope = JSON.parse(String(row.metadata?.providerMeta)) as {
+      source: string;
+      eventKind: string;
+      reaction: { targetMessageId: string; emoji: string; op: string };
+    };
+    expect(envelope.source).toBe("discord");
+    expect(envelope.eventKind).toBe("reaction");
+    expect(envelope.reaction).toEqual({
+      targetMessageId: "555.1",
+      emoji: "🎉",
+      op: "added",
+    });
+    expect(row.metadata?.slackMeta).toBeUndefined();
+  });
+
+  test("a Slack record writes the slackMeta envelope the Slack context reads", async () => {
+    await persistReactionRecords("conv-1", [
+      record({ channel: "slack", chatId: "C1", messageId: "1700.1" }),
+    ]);
+    const row = persisted[0]!;
+    expect(row.metadata?.providerMeta).toBeUndefined();
+    const slackMeta = JSON.parse(String(row.metadata?.slackMeta)) as {
+      source: string;
+      channelId: string;
+      channelTs: string;
+      eventKind: string;
+      reaction: { emoji: string; targetChannelTs: string; op: string };
+    };
+    expect(slackMeta.source).toBe("slack");
+    expect(slackMeta.channelId).toBe("C1");
+    expect(slackMeta.channelTs).toBe("1700.1");
+    expect(slackMeta.eventKind).toBe("reaction");
+    expect(slackMeta.reaction).toEqual({
+      emoji: "🎉",
+      targetChannelTs: "1700.1",
+      op: "added",
+    });
+  });
+
+  test("the terminal drain persists the turn's owned records and stale-marks", async () => {
+    // The drain runs in the agent loop's finally, so an error exit still
+    // reaches it: a delivered reaction's record must not depend on the turn
+    // finishing cleanly.
+    let staleMarked = 0;
+    const owned = [record(), record({ emoji: "👍" })];
+    await drainQueuedReactionRecords(
+      {
+        conversationId: "conv-1",
+        markHistoryStale: () => {
+          staleMarked += 1;
+        },
+      },
+      owned,
+    );
+    expect(persisted).toHaveLength(2);
+    expect(owned).toHaveLength(0);
+    expect(staleMarked).toBe(1);
+  });
+
+  test("one turn's drain never consumes a following turn's live queue", async () => {
+    // Ownership is captured at release, while the turn is still exclusive;
+    // the drain takes only that captured array. A record a following turn
+    // queued on the conversation's live field stays untouched until that
+    // turn's own boundary, so its row cannot land before its tool_result.
+    const followingTurnQueue = [record({ emoji: "🆕" })];
+    const ctx = {
+      conversationId: "conv-1",
+      pendingReactionRecords: followingTurnQueue,
+      markHistoryStale: () => {},
+    };
+    await drainQueuedReactionRecords(ctx, []);
+    expect(persisted).toHaveLength(0);
+    expect(followingTurnQueue).toHaveLength(1);
+  });
+
+  test("the terminal drain is a no-op on an empty or absent owned set", async () => {
+    let staleMarked = 0;
+    await drainQueuedReactionRecords(
+      {
+        conversationId: "conv-1",
+        markHistoryStale: () => {
+          staleMarked += 1;
+        },
+      },
+      undefined,
+    );
+    expect(persisted).toHaveLength(0);
+    expect(staleMarked).toBe(0);
+  });
+
+  test("a failed write is logged, not thrown, and later records still persist", async () => {
+    failNext = true;
+    await persistReactionRecords("conv-1", [record(), record({ emoji: "👍" })]);
+    expect(persisted).toHaveLength(1);
+    const envelope = JSON.parse(
+      String(persisted[0]?.metadata?.providerMeta),
+    ) as { reaction: { emoji: string } };
+    expect(envelope.reaction.emoji).toBe("👍");
+  });
+});

package/src/daemon/reaction-record.ts

@@ -0,0 +1,83 @@
+/**
+ * Durable records of the assistant's own delivered reactions.
+ *
+ * A reaction happens mid-turn (the react tool fans out to the channel while
+ * the agent loop is still running), but its row must not be written then: an
+ * assistant row inserted between a `tool_use` and its `tool_result` breaks
+ * the pairing history repair enforces, and a reload would then teach the
+ * model its own reaction failed. The tool queues the record on the live
+ * conversation instead, and the agent loop drains the queue at the turn
+ * boundary, after the turn's rows are settled.
+ *
+ * Slack rows write the `slackMeta` envelope (the Slack transcript context
+ * builds provider history from rows and reads only that shape); every other
+ * channel writes the neutral `providerMeta` that `readProviderMetadata`
+ * serves to channel-agnostic readers, `Conversation.loadFromDb`'s renderer
+ * included.
+ */
+import type { ChannelId } from "../channels/types.js";
+import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
+import {
+  buildNeutralReactionMeta,
+  buildSlackReactionMeta,
+} from "../messaging/reaction-envelopes.js";
+import {
+  addMessage,
+  REACTION_MESSAGE_KIND,
+} from "../persistence/conversation-crud.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("reaction-record");
+
+export interface QueuedReactionRecord {
+  channel: ChannelId;
+  chatId: string;
+  /** Target message id, in the channel's own id space. */
+  messageId: string;
+  emoji: string;
+  op: "added" | "removed";
+  /** The turn's provenance, so actor-scoped loads keep the row. */
+  provenanceTrustClass?: string;
+}
+
+/**
+ * Persist queued reaction records as standalone assistant rows. Non-throwing:
+ * the reactions already happened on the channel, so a persistence failure
+ * loses the record, never the act, and is logged rather than raised.
+ */
+export async function persistReactionRecords(
+  conversationId: string,
+  records: readonly QueuedReactionRecord[],
+): Promise<void> {
+  for (const record of records) {
+    try {
+      const facts = {
+        channel: record.channel,
+        chatId: record.chatId,
+        targetMessageId: record.messageId,
+        emoji: record.emoji,
+        op: record.op,
+      };
+      const envelope =
+        record.channel === "slack"
+          ? { slackMeta: writeSlackMetadata(buildSlackReactionMeta(facts)) }
+          : { providerMeta: JSON.stringify(buildNeutralReactionMeta(facts)) };
+      await addMessage(conversationId, "assistant", "[reaction]", {
+        metadata: {
+          messageKind: REACTION_MESSAGE_KIND,
+          ...(record.provenanceTrustClass
+            ? { provenanceTrustClass: record.provenanceTrustClass }
+            : {}),
+          provenanceSourceChannel: record.channel,
+          ...envelope,
+        },
+        skipIndexing: true,
+      });
+    } catch (err) {
+      log.warn(
+        { err, conversationId, channel: record.channel, op: record.op },
+        "Failed to persist the assistant's reaction record",
+      );
+    }
+  }
+}

package/src/daemon/shutdown-handlers.ts

@@ -21,7 +21,6 @@ import { stopScheduler } from "../schedule/scheduler.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { stopUsageTelemetryReporter } from "../telemetry/usage-telemetry-reporter.js";
 import { browserManager } from "../tools/browser/browser-manager.js";
-import { cleanupShellOutputTempFiles } from "../tools/shared/shell-output.js";
 import { getLogger } from "../util/logger.js";
 import { APP_VERSION } from "../version.js";
 import { getEnrichmentService } from "../workspace/commit-message-enrichment-service.js";
@@ -167,7 +166,6 @@ async function shutdown(): Promise<void> {
 
   await stopRuntimeHttpServer();
   await browserManager.closeAllPages();
-  cleanupShellOutputTempFiles();
   stopScheduler();
 
   // The memory jobs worker process is SIGTERM'd by the memory plugin's own

package/src/daemon/summarize-boundary.ts

@@ -1,4 +1,5 @@
 import { isToolResultOnlyUserMessage } from "../conversations/message-consolidation.js";
+import { readProviderMetadata } from "../messaging/read-provider-metadata.js";
 import type { MessageRow } from "../persistence/conversation-crud.js";
 import { UserError } from "../util/errors.js";
 
@@ -19,6 +20,17 @@ export function startsNewTurn(msg: MessageRow): boolean {
   if (msg.role !== "user") {
     return false;
   }
+  // A reaction row is a channel fact attached to the turn it landed in, not
+  // a message that ran one: the agent loop never dispatches for reactions,
+  // so counting them would rehydrate a `turnCount` above the live counter
+  // and shift turn-indexed memory selection. The substring guard keeps the
+  // metadata parse off rows that cannot carry the envelope.
+  if (
+    msg.metadata?.includes("reaction") &&
+    readProviderMetadata(msg.metadata)?.eventKind === "reaction"
+  ) {
+    return false;
+  }
   return !isToolResultOnlyUserMessage(msg);
 }
 

package/src/daemon/video-thumbnail.ts

@@ -35,7 +35,7 @@ async function extractThumbnail(inputPath: string): Promise<string | null> {
         "5",
         outputPath,
       ],
-      { stderr: "pipe" },
+      { stderr: "pipe", windowsHide: true },
     );
 
     let timer: ReturnType<typeof setTimeout>;

package/src/home/feed-types.ts

@@ -33,10 +33,14 @@ export {
   type FeedItemCategory,
   type FeedItemDetailPanel,
   type FeedItemDetailPanelKind,
+  type FeedItemGuardianIntent,
+  type FeedItemGuardianRequest,
+  type FeedItemGuardianStatus,
   FeedItemSchema as feedItemSchema,
   type FeedItemStatus,
   type FeedItemType,
   type FeedItemUrgency,
+  isPendingGuardianFeedItem,
   type SuggestedPrompt,
   SuggestedPromptSchema as suggestedPromptSchema,
   type SuggestedPromptSource,

package/src/home/feed-writer.ts

@@ -37,6 +37,10 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
+import {
+  type FeedItemGuardianRequest,
+  isPendingGuardianFeedItem,
+} from "../api/responses/home.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getLogger } from "../util/logger.js";
 import { getDataDir } from "../util/platform.js";
@@ -182,6 +186,16 @@ export interface FeedItemContentPatch {
   summary?: string;
   urgency?: FeedItemUrgency;
   status?: FeedItemStatus;
+  /**
+   * Updater for the item's guardian projection, applied inside the
+   * coalescing queue so it reads the projection as of write time (a
+   * plain replacement value would race concurrent patches). Only runs
+   * when the item carries a `guardianRequest`; items without one are
+   * left untouched.
+   */
+  guardianRequest?: (
+    existing: FeedItemGuardianRequest,
+  ) => FeedItemGuardianRequest;
 }
 
 export async function patchFeedItemContent(
@@ -387,6 +401,9 @@ async function runWrite(): Promise<void> {
     if (patch.status !== undefined) {
       updated.status = patch.status;
     }
+    if (patch.guardianRequest !== undefined && existing.guardianRequest) {
+      updated.guardianRequest = patch.guardianRequest(existing.guardianRequest);
+    }
     items[idx] = updated;
     contentPatchResults.push({ resolve, value: updated });
   }
@@ -431,6 +448,14 @@ async function runWrite(): Promise<void> {
       if (idSet && !idSet.has(current.id)) {
         continue;
       }
+      // Bulk dismissal ("Clear all") never clears the live projection of
+      // an unresolved guardian request: the item is the request's one
+      // canonical home, and only resolution may retire it. A terminal
+      // receipt is not pending and clears like any other item, and a
+      // deliberate single-item dismissal stays available.
+      if (op.to === "dismissed" && isPendingGuardianFeedItem(current)) {
+        continue;
+      }
       items[i] = { ...current, status: op.to };
       count++;
     }