@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/src/permissions/confirmation-guardian-request.test.ts

@@ -19,17 +19,19 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../daemon/conversation-registry.js", () => ({
-  findConversation: () => ({
-    assistantId: "self",
-    trustContext: {
-      sourceChannel: "telegram",
-      requesterExternalUserId: "tg-user-1",
-      requesterChatId: "tg-chat-1",
-      guardianExternalUserId: "tg-guardian-1",
-      guardianPrincipalId: "principal-1",
-    },
-    hasPendingConfirmation: () => confirmationPending,
-  }),
+  findConversation: () =>
+    asConversation({
+      assistantId: "self",
+      trustContext: {
+        trustClass: "trusted_contact",
+        sourceChannel: "telegram",
+        requesterExternalUserId: "tg-user-1",
+        requesterChatId: "tg-chat-1",
+        guardianExternalUserId: "tg-guardian-1",
+        guardianPrincipalId: "principal-1",
+      } satisfies TrustContext,
+      hasPendingConfirmation: () => confirmationPending,
+    }),
 }));
 
 mock.module("../channels/gateway-guardian-requests.js", () => ({
@@ -50,7 +52,9 @@ mock.module("../runtime/confirmation-request-guardian-bridge.js", () => ({
   },
 }));
 
+import { asConversation } from "../__tests__/helpers/mock-conversation.js";
 import type { AssistantEvent } from "../api/index.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import { createGuardianRequestForConfirmation } from "./confirmation-guardian-request.js";
 
 const MSG = {

package/src/permissions/confirmation-guardian-request.ts

@@ -66,8 +66,8 @@ export async function createGuardianRequestForConfirmation(
 
     const conversation = findConversation(conversationId);
     const trustContext = opts?.preferTurnSnapshot
-      ? (conversation?.currentTurnTrustContext ?? conversation?.trustContext)
-      : conversation?.trustContext;
+      ? conversation?.getTurnOrRestingTrust()
+      : conversation?.getTrustContext();
     const sourceChannel = trustContext?.sourceChannel ?? "vellum";
     const inputRecord = msg.input as Record<string, unknown>;
     const activityRaw =

package/src/permissions/prompter.ts

@@ -36,7 +36,7 @@ export class PermissionPrompter {
    * pendingInteractions, matching the host proxy pattern.
    */
   private ownedIds = new Set<string>();
-  private sendToClient: (msg: AssistantEvent) => void;
+  private readonly sendToClient: (msg: AssistantEvent) => void;
   private onStateChanged?: ConfirmationStateCallback;
 
   constructor(sendToClient: (msg: AssistantEvent) => void) {
@@ -47,10 +47,6 @@ export class PermissionPrompter {
     this.onStateChanged = cb;
   }
 
-  updateSender(sendToClient: (msg: AssistantEvent) => void): void {
-    this.sendToClient = sendToClient;
-  }
-
   async prompt(
     toolName: string,
     input: Record<string, unknown>,

package/src/permissions/question-guardian-request.test.ts

@@ -7,7 +7,10 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { mockTrustContext } from "../__tests__/helpers/mock-actor-context.js";
+import { asConversation } from "../__tests__/helpers/mock-conversation.js";
 import type { QuestionRequestEvent } from "../api/events/question-request.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 
 const createGuardianRequestMock = mock(
   (params: Record<string, unknown>): Promise<Record<string, unknown>> =>
@@ -21,13 +24,18 @@ const withdrawCardsMock = mock((_params: Record<string, unknown>) =>
   Promise.resolve(),
 );
 
-let trustContext: Record<string, unknown> | undefined;
+let trustContext: TrustContext | undefined;
 let pendingInteraction: { kind: string } | undefined;
 let rowAfterExpire: Record<string, unknown> | null = null;
 
 mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (_id: string) =>
-    trustContext ? { trustContext, assistantId: "self" } : undefined,
+    trustContext
+      ? asConversation({
+          trustContext,
+          assistantId: "self",
+        })
+      : undefined,
 }));
 mock.module("../channels/gateway-guardian-requests.js", () => ({
   createGuardianRequest: (params: Record<string, unknown>) =>
@@ -77,9 +85,9 @@ function makeEvent(
 }
 
 function guardianTrustContext(
-  overrides: Record<string, unknown> = {},
-): Record<string, unknown> {
-  return {
+  overrides: Partial<TrustContext> = {},
+): TrustContext {
+  return mockTrustContext({
     trustClass: "guardian",
     sourceChannel: "telegram",
     guardianPrincipalId: "prin-guardian",
@@ -87,7 +95,7 @@ function guardianTrustContext(
     requesterExternalUserId: "tg-guardian",
     requesterChatId: "chat-1",
     ...overrides,
-  };
+  });
 }
 
 beforeEach(() => {

package/src/permissions/question-guardian-request.ts

@@ -107,8 +107,7 @@ export async function createGuardianRequestForQuestion(
     const conversation = findConversation(conversationId);
     // The prompter runs inside the emitting turn — bind to the turn's trust
     // snapshot so a concurrent context mutation can't repoint the request.
-    const trustContext =
-      conversation?.currentTurnTrustContext ?? conversation?.trustContext;
+    const trustContext = conversation?.getTurnOrRestingTrust();
     if (!conversation || !trustContext) {
       return;
     }

package/src/persistence/attachments-store.ts

@@ -137,6 +137,9 @@ function getAttachmentRow(attachmentId: string): AttachmentRow | null {
 function getMessageConversationContext(
   messageId: string,
 ): { conversationId: string; conversationCreatedAt: number } | null {
+  // Any-state read, deliberately: the id names a message the caller is
+  // already linking an attachment to, and a rendered row may still be
+  // streaming. Existence and ownership are the question, not completeness.
   return (
     rawGet<{ conversationId: string; conversationCreatedAt: number }>(
       "attachments:getMessageConversationContext",
@@ -474,6 +477,11 @@ const ALLOWED_MIME_TYPES = new Set([
   // Source code
   "text/javascript",
   "text/typescript",
+  // Shell scripts (browsers and OS file pickers report these for .sh files)
+  "application/x-sh",
+  "application/x-shellscript",
+  "text/x-sh",
+  "text/x-shellscript",
   // Archives
   "application/zip",
   "application/gzip",
@@ -501,7 +509,6 @@ const ALLOWED_MIME_TYPES = new Set([
  */
 const DANGEROUS_EXTENSIONS = new Set([
   "exe",
-  "sh",
   "bat",
   "cmd",
   "com",

package/src/persistence/bookmark-crud.ts

@@ -3,6 +3,7 @@ import { v4 as uuid } from "uuid";
 
 import type { DrizzleDb } from "./db-connection.js";
 import { stringifyMessageContent } from "./message-content.js";
+import { messageConversationId } from "./message-reads.js";
 import { conversations, messageBookmarks, messages } from "./schema.js";
 
 /**
@@ -138,15 +139,10 @@ export function createBookmark(
   params: { messageId: string },
 ): CreateBookmarkResult {
   const { messageId } = params;
-  const message = db
-    .select({ conversationId: messages.conversationId })
-    .from(messages)
-    .where(eq(messages.id, messageId))
-    .get();
-  if (!message) {
+  const conversationId = messageConversationId(messageId, { db });
+  if (conversationId === null) {
     throw new Error(`Message ${messageId} not found`);
   }
-  const conversationId = message.conversationId;
 
   const existing = db
     .select({ id: messageBookmarks.id })

package/src/persistence/conversation-attention-store.ts

@@ -21,11 +21,14 @@ import { v4 as uuid } from "uuid";
 
 import { UserError } from "../util/errors.js";
 import { getDb } from "./db-connection.js";
+import {
+  latestAssistantMessage,
+  latestAssistantMessageBefore,
+} from "./message-reads.js";
 import {
   conversationAssistantAttentionState,
   conversationAttentionEvents,
   conversations,
-  messages,
 } from "./schema/index.js";
 
 // ── Types ────────────────────────────────────────────────────────────
@@ -361,19 +364,11 @@ export function recordConversationSeenSignal(params: {
     if (!state) {
       // No state row yet — look up the conversation's latest assistant message so
       // upgraded databases (with existing messages but no attention row) correctly
-      // initialize the full state on the first seen signal.
-      const latestMsg = tx
-        .select({ id: messages.id, createdAt: messages.createdAt })
-        .from(messages)
-        .where(
-          and(
-            eq(messages.conversationId, conversationId),
-            eq(messages.role, "assistant"),
-          ),
-        )
-        .orderBy(desc(messages.createdAt))
-        .limit(1)
-        .get();
+      // initialize the full state on the first seen signal. Finalized-only via
+      // the accessor: a still-streaming reply is not a reply the user has seen,
+      // and anchoring the watermark on it would classify the finished reply as
+      // seen the moment it completes.
+      const latestMsg = latestAssistantMessage(conversationId, { db: tx });
 
       const latestMsgId = latestMsg?.id ?? null;
       const latestMsgAt = latestMsg?.createdAt ?? null;
@@ -461,26 +456,11 @@ function resolveAssistantCursor(params: {
     latestAssistantMessageAt,
   } = params;
 
-  // Unread classification compares timestamps strictly, so rewinding to a
-  // same-timestamp sibling would leave the latest reply classified as seen.
-  const previousAssistantMessageBefore = (before: number) =>
-    db
-      .select({ id: messages.id, createdAt: messages.createdAt })
-      .from(messages)
-      .where(
-        and(
-          eq(messages.conversationId, conversationId),
-          eq(messages.role, "assistant"),
-          lt(messages.createdAt, before),
-        ),
-      )
-      .orderBy(desc(messages.createdAt), desc(messages.id))
-      .limit(1)
-      .get();
-
   if (latestAssistantMessageId && latestAssistantMessageAt != null) {
-    const previousMessage = previousAssistantMessageBefore(
+    const previousMessage = latestAssistantMessageBefore(
+      conversationId,
       latestAssistantMessageAt,
+      { db },
     );
 
     return {
@@ -491,25 +471,16 @@ function resolveAssistantCursor(params: {
     };
   }
 
-  const latestMessage = db
-    .select({ id: messages.id, createdAt: messages.createdAt })
-    .from(messages)
-    .where(
-      and(
-        eq(messages.conversationId, conversationId),
-        eq(messages.role, "assistant"),
-      ),
-    )
-    .orderBy(desc(messages.createdAt), desc(messages.id))
-    .limit(1)
-    .get();
+  const latestMessage = latestAssistantMessage(conversationId, { db });
 
   if (!latestMessage) {
     return null;
   }
 
-  const previousMessage = previousAssistantMessageBefore(
+  const previousMessage = latestAssistantMessageBefore(
+    conversationId,
     latestMessage.createdAt,
+    { db },
   );
   return {
     latestAssistantMessageId: latestMessage.id,

package/src/persistence/conversation-crud.ts

@@ -498,6 +498,25 @@ export function parseMessageMetadata(
   }
 }
 
+/**
+ * Rows a fork may copy: finalized ones. A `finalized = 0` row is mid-write,
+ * its content a `{ ref }` into the source turn's in-flight delta file, which
+ * the source deletes when the turn completes. A copied row would point at a
+ * file another conversation is about to delete, leaving a permanently empty
+ * message that reads as final and is invisible to crash recovery (which scans
+ * `finalized = 0` only). Unfinalized is not "unsent": the message was sent
+ * and is still being written, so there is no completed content to copy. A
+ * fork reflects the conversation at a completed point.
+ *
+ * Callers apply this to `messagesToCopy` itself, upstream of the boundary
+ * timestamp, compaction inheritance, `forkParentMessageId`, and the id map,
+ * so every derivation describes the rows actually copied and the lineage
+ * anchor can never reference a row the fork does not hold.
+ */
+function dropUnfinalizedRows(rows: MessageRow[]): MessageRow[] {
+  return rows.filter((message) => message.finalized === 1);
+}
+
 function cloneForkMessageMetadata(
   metadata: string | null,
   sourceMessageId: string,
@@ -1336,7 +1355,7 @@ export function forkConversation(params: {
 
   const messagesToCopy =
     copyBoundaryIndex >= 0
-      ? sourceMessages.slice(0, copyBoundaryIndex + 1)
+      ? dropUnfinalizedRows(sourceMessages.slice(0, copyBoundaryIndex + 1))
       : ([] as MessageRow[]);
 
   // Inherit the history-strip marker only when the fork boundary is at-or-
@@ -1461,7 +1480,13 @@ export function forkConversation(params: {
       messagesToCopy,
       forkedMessageIds,
       latestForkedAssistant,
-      isFullHistoryFork: copyBoundaryIndex === sourceMessages.length - 1,
+      // The wholesale memory-state carry requires the fork's window to equal
+      // the source's rendered window; a boundary at the tip no longer
+      // guarantees that when the unfinalized filter dropped rows from the
+      // slice, so both conditions gate it.
+      isFullHistoryFork:
+        copyBoundaryIndex === sourceMessages.length - 1 &&
+        messagesToCopy.length === copyBoundaryIndex + 1,
       inheritedCompactedMessageCount:
         inheritedCompaction?.compactedMessageCount ?? 0,
       diskSyncQueue,
@@ -1772,7 +1797,7 @@ export async function forkConversationForRetrospective(params: {
   );
   const messagesToCopy =
     copyBoundaryIndex >= 0
-      ? sourceMessages.slice(0, copyBoundaryIndex + 1)
+      ? dropUnfinalizedRows(sourceMessages.slice(0, copyBoundaryIndex + 1))
       : ([] as MessageRow[]);
 
   const sourceHistoryStrippedAt = sourceConversation.historyStrippedAt ?? null;
@@ -1936,8 +1961,12 @@ export async function forkConversationForRetrospective(params: {
               messagesToCopy: rowsToCopy,
               forkedMessageIds,
               latestForkedAssistant,
+              // Both conditions, for the same reason as `forkConversation`:
+              // a tip boundary no longer implies an equal window once the
+              // unfinalized filter dropped rows from the slice.
               isFullHistoryFork:
-                copyBoundaryIndex === sourceMessages.length - 1,
+                copyBoundaryIndex === sourceMessages.length - 1 &&
+                messagesToCopy.length === copyBoundaryIndex + 1,
               // The copied range already starts at the visible window.
               inheritedCompactedMessageCount: forkCompactedMessageCount,
               skipCompactionLedgerCopy: inheritedCompaction != null,

package/src/persistence/conversation-lineage.ts

@@ -184,6 +184,14 @@ export function isSingleSegmentLineage(segments: LineageSegment[]): boolean {
  * strictly-earlier `createdAt`, or an equal `createdAt` with an id that does
  * not sort after the bound. The fork message itself is included, because a
  * fork is taken THROUGH that message.
+ *
+ * Ancestor segments additionally exclude unfinalized rows. An ancestor's
+ * `finalized = 0` row is a message its own live turn is still writing; a
+ * descendant reading it would see partial content that the ancestor rewrites
+ * inline when the turn completes. The row enters the window on its own once
+ * it finalizes. A segment with no bound is the conversation's own tail and
+ * keeps its unfinalized rows: a conversation always sees its own in-flight
+ * message.
  */
 export function lineageMessageFilter(segments: LineageSegment[]): SQL {
   const clauses = segments.map((segment) => {
@@ -194,6 +202,7 @@ export function lineageMessageFilter(segments: LineageSegment[]): SQL {
     const { createdAt, id } = segment.through;
     return and(
       owner,
+      eq(messages.finalized, 1),
       or(
         lt(messages.createdAt, createdAt),
         and(