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

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -472,6 +472,8 @@ mock.module("../memory/archive-store.js", () => ({
 import { AgentLoop } from "../agent/loop.js";
 import type { Conversation } from "../daemon/conversation.js";
 import { runAgentLoopImpl } from "../daemon/conversation-agent-loop.js";
+import type { QueueDrainReason } from "../daemon/conversation-queue-manager.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 import {
   createMockProvider,
   type ScriptedResponse,
@@ -519,7 +521,7 @@ function makeCtx(
     toolExecutor,
   });
 
-  const ctx = {
+  const ctx = asConversation({
     conversationId: "test-conv",
     messages: [
       { role: "user", content: [{ type: "text", text: "Hello" }] },
@@ -572,12 +574,7 @@ function makeCtx(
     skillProjectionCache:
       new Map() as unknown as Conversation["skillProjectionCache"],
 
-    usageStats: {
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalEstimatedCost: 0,
-      model: "",
-    },
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     turnCount: 0,
 
     lastAssistantAttachments: [],
@@ -595,12 +592,12 @@ function makeCtx(
     getQueueDepth: () => 0,
     hasQueuedMessages: () => false,
     canHandoffAtCheckpoint: () => false,
-    drainQueue: (_reason?: string) => {},
+    drainQueue: async (_reason?: QueueDrainReason) => {},
     // Forwards to drainQueue so tests that spy the drain observe the agent
     // loop's post-turn kick through the guarded entry point.
     kickDrainQueue(
-      this: { drainQueue: (reason?: string) => unknown },
-      reason: string = "loop_complete",
+      this: { drainQueue: (reason?: QueueDrainReason) => Promise<void> },
+      reason: QueueDrainReason = "loop_complete",
       _origin?: string,
     ) {
       return this.drainQueue(reason);
@@ -632,7 +629,7 @@ function makeCtx(
     } as unknown as Conversation["graphMemory"],
 
     ...ctxOverrides,
-  } as unknown as Conversation;
+  });
   // The convergence driver resolves the turn-scoped overflow ladder off the
   // manager; give every fake manager the ladder methods unless a test supplied
   // its own.

package/src/__tests__/conversation-agent-loop.test.ts

@@ -268,7 +268,18 @@ const setConversationHistoryStrippedAtMock = mock(
 const updateConversationSlackContextWatermarkMock = mock(
   (_conversationId: string, _watermarkTs: string, _compactedAt?: number) => {},
 );
-let mockConversationRow: Record<string, unknown> = {
+interface MockConversationRow {
+  conversationType?: string;
+  source?: string;
+  contextSummary?: string | null;
+  contextCompactedMessageCount?: number;
+  contextCompactedAt?: number | null;
+  slackContextCompactionWatermarkTs?: string | null;
+  lastNotifiedInferenceProfile?: string | null;
+  processingStartedAt?: string | null;
+  [key: string]: unknown;
+}
+let mockConversationRow: MockConversationRow = {
   id: "conv-1",
   createdAt: 1_700_000_000_000,
   contextSummary: null,
@@ -675,7 +686,9 @@ import {
   applyCompactionResult,
   runAgentLoopImpl,
 } from "../daemon/conversation-agent-loop.js";
+import type { QueueDrainReason } from "../daemon/conversation-queue-manager.js";
 import { settleTurnTail } from "../daemon/turn-tail-chain.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 import {
   createMockProvider,
   type ScriptedResponse,
@@ -731,7 +744,7 @@ function makeCtx(
     toolExecutor,
   });
 
-  const ctx = {
+  const ctx = asConversation({
     conversationId: "test-conv",
     messages: [
       { role: "user", content: [{ type: "text", text: "Hello" }] },
@@ -791,12 +804,7 @@ function makeCtx(
     skillProjectionCache:
       new Map() as unknown as Conversation["skillProjectionCache"],
 
-    usageStats: {
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalEstimatedCost: 0,
-      model: "",
-    },
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     turnCount: 0,
 
     lastAssistantAttachments: [],
@@ -814,12 +822,12 @@ function makeCtx(
     getQueueDepth: () => 0,
     hasQueuedMessages: () => false,
     canHandoffAtCheckpoint: () => false,
-    drainQueue: (_reason?: string) => {},
+    drainQueue: async (_reason?: QueueDrainReason) => {},
     // Forwards to drainQueue so tests that spy the drain observe the agent
     // loop's post-turn kick through the guarded entry point.
     kickDrainQueue(
-      this: { drainQueue: (reason?: string) => unknown },
-      reason: string = "loop_complete",
+      this: { drainQueue: (reason?: QueueDrainReason) => Promise<void> },
+      reason: QueueDrainReason = "loop_complete",
       _origin?: string,
     ) {
       return this.drainQueue(reason);
@@ -851,7 +859,7 @@ function makeCtx(
     } as unknown as Conversation["graphMemory"],
 
     ...ctxOverrides,
-  } as unknown as Conversation;
+  });
   // Reactive overflow recovery resolves the turn-scoped reduction ladder off
   // the manager; give every fake manager the ladder methods unless a test
   // supplied its own.
@@ -1337,7 +1345,10 @@ describe("session-agent-loop", () => {
       });
       const cleanupFlagDuringInjection = captureCleanupFlagDuringInjection(ctx);
 
-      await runAgentLoopImpl(ctx, "free up space", "msg-1", () => {});
+      // Presence is declared per turn; the policy input must carry it.
+      await runAgentLoopImpl(ctx, "free up space", "msg-1", () => {}, {
+        isInteractive: true,
+      });
 
       expect(classifyDiskPressureTurnPolicyMock).toHaveBeenCalledWith(
         mockDiskPressureStatus,
@@ -1795,7 +1806,7 @@ describe("session-agent-loop", () => {
         ],
         toolExecutor: async () => ({ content: "file content", isError: false }),
         canHandoffAtCheckpoint: () => true,
-      } as unknown as Partial<Conversation>);
+      });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
@@ -1826,7 +1837,7 @@ describe("session-agent-loop", () => {
         ],
         toolExecutor: async () => ({ content: "content", isError: false }),
         canHandoffAtCheckpoint: () => false,
-      } as unknown as Partial<Conversation>);
+      });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
@@ -1975,13 +1986,13 @@ describe("session-agent-loop", () => {
 
     test("drains queue after completion", async () => {
       // GIVEN a real loop that answers in a single text turn
-      let drainReason: string | undefined;
+      let drainReason: QueueDrainReason | undefined;
       const ctx = makeCtx({
         providerResponses: [textResponse("ok")],
-        drainQueue: (reason: string) => {
+        drainQueue: async (reason?: QueueDrainReason) => {
           drainReason = reason;
         },
-      } as unknown as Partial<Conversation>);
+      });
 
       // WHEN the orchestrator runs the turn to completion
       await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
@@ -2018,10 +2029,10 @@ describe("session-agent-loop", () => {
         abortController,
         // Fire the watchdog quickly instead of the ~45s production default.
         abortWatchdogMs: 30,
-        drainQueue: (reason: string) => {
+        drainQueue: async (reason?: QueueDrainReason) => {
           drainReason = reason;
         },
-      } as unknown as Partial<Conversation>);
+      });
 
       try {
         // WHEN the orchestrator runs the turn
@@ -2520,7 +2531,7 @@ describe("session-agent-loop", () => {
           },
         ],
         toolExecutor: async () => ({ content: "file content", isError: false }),
-      } as unknown as Partial<Conversation>);
+      });
 
       await runAgentLoopImpl(ctx, "hello", "msg-user-daily", () => {});
 

package/src/__tests__/conversation-attachments.test.ts

@@ -15,7 +15,6 @@ mock.module("../permissions/checker.js", () => ({
   isDynamicSkillLoadInvocation: () => false,
   check: checkSpy,
   classifyRisk: () => Promise.resolve({ level: "low" }),
-  generateAllowlistOptions: () => Promise.resolve([]),
   generateScopeOptions: () => [],
 }));
 

package/src/__tests__/conversation-attention-store.test.ts

@@ -832,3 +832,66 @@ describe("conversation-attention-store", () => {
     });
   });
 });
+
+describe("attention watermarks and streaming rows", () => {
+  test("state init from an upgraded database anchors on the latest finalized reply", () => {
+    clearTables();
+    ensureConversation("conv-1");
+    insertAssistantMessage("conv-1", "msg-done", 1_000);
+    getDb()
+      .insert(messages)
+      .values({
+        id: "msg-streaming",
+        conversationId: "conv-1",
+        role: "assistant",
+        content: "still being written",
+        createdAt: 2_000,
+        metadata: null,
+        finalized: 0,
+      })
+      .run();
+
+    // No attention row exists, so the seen signal initializes state from the
+    // messages table. The streaming row is newest but is not a reply yet;
+    // anchoring the watermark on it would classify the finished reply as
+    // already seen the moment it completes.
+    recordConversationSeenSignal({
+      conversationId: "conv-1",
+      sourceChannel: "vellum",
+      signalType: "macos_conversation_opened",
+      confidence: "explicit",
+      source: "desktop-client",
+    });
+
+    const state = getAttentionStateByConversationIds(["conv-1"]).get("conv-1")!;
+    expect(state.latestAssistantMessageId).toBe("msg-done");
+    expect(state.lastSeenAssistantMessageId).toBe("msg-done");
+  });
+});
+
+describe("markConversationUnread with only a streaming reply", () => {
+  test("reports no assistant message rather than rewinding onto the streaming row", () => {
+    clearTables();
+    ensureConversation("conv-1");
+    getDb()
+      .insert(messages)
+      .values({
+        id: "msg-streaming-only",
+        conversationId: "conv-1",
+        role: "assistant",
+        content: "still being written",
+        createdAt: 1_000,
+        metadata: null,
+        finalized: 0,
+      })
+      .run();
+
+    // The write-path projection anchors at the finalize seam
+    // (`reserveMessage` deliberately skips it), so attention state for this
+    // conversation says "no reply yet". The rewind fallback must agree with
+    // the projection rather than anchoring on the streaming row.
+    expect(() => markConversationUnread("conv-1")).toThrow(
+      /no assistant message/i,
+    );
+  });
+});

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -431,3 +431,115 @@ describe("sendToClient receives state signals", () => {
     });
   });
 });
+
+describe("the sink is fixed for the conversation's life", () => {
+  test("a cold instance delivers activity state with no turn ever having run", () => {
+    // The summarize-up-to route resolves its conversation outside the send
+    // path and emits a thinking indicator before any turn: it must reach the
+    // sink the conversation was built with, not depend on a send having wired
+    // one (LUM-2987).
+    const clientMsgs: AssistantEvent[] = [];
+    const conversation = makeConversation((msg) => clientMsgs.push(msg));
+
+    conversation.emitActivityState("thinking", "context_compacting", {
+      statusText: "Summarizing conversation",
+    });
+
+    const activity = clientMsgs.filter(
+      (m) => m.type === "assistant_activity_state",
+    );
+    expect(activity).toHaveLength(1);
+    expect((activity[0] as { statusText?: string }).statusText).toBe(
+      "Summarizing conversation",
+    );
+  });
+
+  test("presence is a property of the turn, not of delivery", () => {
+    // Nothing is in flight, so no human is asserted present, even though the
+    // sink is live and delivering.
+    const clientMsgs: AssistantEvent[] = [];
+    const conversation = makeConversation((msg) => clientMsgs.push(msg));
+    expect(conversation.hasNoClient).toBe(true);
+    conversation.emitActivityState("thinking", "message_dequeued");
+    expect(clientMsgs).toHaveLength(1);
+    expect(conversation.hasNoClient).toBe(true);
+  });
+});
+
+describe("event observers", () => {
+  test("an observer sees each event after the sink delivered it, and detaches", () => {
+    const order: string[] = [];
+    const conversation = makeConversation((msg) => {
+      order.push(`sink:${msg.type}`);
+    });
+    const detach = conversation.addEventObserver((msg) => {
+      order.push(`observer:${msg.type}`);
+    });
+
+    conversation.emitActivityState("thinking", "message_dequeued");
+    expect(order).toEqual([
+      "sink:assistant_activity_state",
+      "observer:assistant_activity_state",
+    ]);
+
+    detach();
+    conversation.emitActivityState("idle", "message_complete");
+    expect(order).toEqual([
+      "sink:assistant_activity_state",
+      "observer:assistant_activity_state",
+      "sink:assistant_activity_state",
+    ]);
+  });
+
+  test("a throwing observer neither blocks the sink nor its siblings", () => {
+    const seen: string[] = [];
+    const conversation = makeConversation((msg) => {
+      seen.push(`sink:${msg.type}`);
+    });
+    conversation.addEventObserver(() => {
+      throw new Error("observer boom");
+    });
+    conversation.addEventObserver((msg) => {
+      seen.push(`second:${msg.type}`);
+    });
+
+    conversation.emitActivityState("thinking", "message_dequeued");
+    expect(seen).toEqual([
+      "sink:assistant_activity_state",
+      "second:assistant_activity_state",
+    ]);
+  });
+
+  test("the prompter's confirmation_request reaches observers after the sink", () => {
+    // Voice auto-resolves approval prompts it has no UI for; it must observe
+    // the request only once the sink has put it on the wire, so its resolution
+    // lands after the request it answers.
+    const order: string[] = [];
+    const conversation = makeConversation((msg) => {
+      order.push(`sink:${msg.type}`);
+    });
+    conversation.addEventObserver((msg) => {
+      if (msg.type === "confirmation_request") {
+        order.push("observer:confirmation_request");
+        conversation.handleConfirmationResponse(msg.requestId, "deny", {
+          emissionContext: { source: "system" },
+        });
+      }
+    });
+
+    void conversation.prompter.prompt(
+      "bash",
+      { command: "rm -rf /tmp/x" },
+      "high",
+      [],
+      [],
+      undefined,
+      conversation.conversationId,
+      "sandbox",
+      false,
+    );
+
+    expect(order[0]).toBe("sink:confirmation_request");
+    expect(order[1]).toBe("observer:confirmation_request");
+  });
+});

package/src/__tests__/conversation-delete-schedule-cleanup.test.ts

@@ -10,10 +10,6 @@ mock.module("../config/env.js", () => ({
   hasUngatedHttpAuthDisabled: () => false,
 }));
 
-mock.module("../daemon/conversation-store.js", () => ({
-  destroyActiveConversation: () => {},
-}));
-
 mock.module("../daemon/handlers/conversations.js", () => ({
   cancelGeneration: () => true,
   clearAllConversations: async () => 0,

package/src/__tests__/conversation-fork-crud.test.ts

@@ -1794,3 +1794,72 @@ describe("forkConversation + memory_retrospective_state", () => {
     expect(fork.slackContextCompactionWatermarkAt).toBe(compactedAt);
   });
 });
+
+describe("forkConversation with unfinalized rows", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("skips unfinalized rows and anchors the fork at the last finalized message", async () => {
+    const source = createConversation("Mid-turn fork");
+    await addMessage(source.id, "user", "question", { skipIndexing: true });
+    const lastFinalized = await addMessage(
+      source.id,
+      "assistant",
+      "completed reply",
+      { skipIndexing: true },
+    );
+    const streaming = await addMessage(
+      source.id,
+      "assistant",
+      "partial reply still being written",
+      { skipIndexing: true },
+    );
+    rawRun(
+      "test:markUnfinalized",
+      "UPDATE messages SET finalized = 0 WHERE id = ?",
+      streaming.id,
+    );
+
+    const fork = forkConversation({ conversationId: source.id });
+    const forkMessages = getMessages(fork.id);
+
+    // The invariant, not mere presence: exactly the finalized rows were
+    // copied, every copy reads as finalized, no copy descends from the
+    // unfinalized source row, and the lineage anchor is a row the fork
+    // actually holds.
+    expect(forkMessages).toHaveLength(2);
+    expect(forkMessages.every((row) => row.finalized === 1)).toBe(true);
+    const forkedFromIds = forkMessages.map(
+      (row) =>
+        (parseMetadata(row.metadata) as { forkSourceMessageId?: string })
+          ?.forkSourceMessageId,
+    );
+    expect(forkedFromIds).not.toContain(streaming.id);
+    expect(fork.forkParentMessageId).toBe(lastFinalized.id);
+    // The source still owns its in-flight row untouched.
+    expect(getMessages(source.id)).toHaveLength(3);
+  });
+
+  test("a stale mid-history unfinalized row is skipped without shifting the anchor", async () => {
+    const source = createConversation("Stale row fork");
+    await addMessage(source.id, "user", "first", { skipIndexing: true });
+    const stale = await addMessage(source.id, "assistant", "orphaned partial", {
+      skipIndexing: true,
+    });
+    const tail = await addMessage(source.id, "user", "latest", {
+      skipIndexing: true,
+    });
+    rawRun(
+      "test:markUnfinalized",
+      "UPDATE messages SET finalized = 0 WHERE id = ?",
+      stale.id,
+    );
+
+    const fork = forkConversation({ conversationId: source.id });
+    const forkMessages = getMessages(fork.id);
+
+    expect(forkMessages).toHaveLength(2);
+    expect(fork.forkParentMessageId).toBe(tail.id);
+  });
+});

package/src/__tests__/conversation-fork-referential.test.ts

@@ -350,3 +350,70 @@ describe("referential forking", () => {
     expect(textOf(getMessages(source.id))).toHaveLength(4);
   });
 });
+
+describe("referential forking with unfinalized rows", () => {
+  beforeEach(() => {
+    resetTables();
+    clearConfig();
+  });
+
+  test("ancestor rows are hidden while unfinalized and appear once finalized", async () => {
+    const source = await seedSource("Launch");
+    const midRow = getMessages(source.id)[1]!;
+    getDb()
+      .update(messages)
+      .set({ finalized: 0 })
+      .where(eq(messages.id, midRow.id))
+      .run();
+
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    // The fork's lineage read excludes the ancestor's in-flight row; the
+    // source's own read keeps it.
+    expect(textOf(getMessages(fork.id))).toEqual([
+      "draft a launch plan",
+      "tweak the timeline",
+      "updated",
+    ]);
+    expect(getMessages(source.id)).toHaveLength(4);
+
+    getDb()
+      .update(messages)
+      .set({ finalized: 1 })
+      .where(eq(messages.id, midRow.id))
+      .run();
+
+    // Once the row finalizes it enters the inherited window on its own.
+    expect(textOf(getMessages(fork.id))).toEqual([
+      "draft a launch plan",
+      "here is a first pass",
+      "tweak the timeline",
+      "updated",
+    ]);
+  });
+
+  test("an unfinalized tail is not the fork anchor", async () => {
+    const source = await seedSource("Launch");
+    const tail = getMessages(source.id).at(-1)!;
+    getDb()
+      .update(messages)
+      .set({ finalized: 0 })
+      .where(eq(messages.id, tail.id))
+      .run();
+
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    expect(fork.forkParentMessageId).not.toBe(tail.id);
+    expect(textOf(getMessages(fork.id))).toEqual([
+      "draft a launch plan",
+      "here is a first pass",
+      "tweak the timeline",
+    ]);
+  });
+});

package/src/__tests__/conversation-fork-retrospective.test.ts

@@ -723,3 +723,27 @@ describe("forkConversationForRetrospective — compacted source", () => {
     });
   });
 });
+
+describe("forkConversationForRetrospective with unfinalized rows", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("skips the unfinalized tail and anchors at the last finalized message", async () => {
+    const source = await seedSource("Mid-turn retro");
+    const tail = getMessages(source.id).at(-1)!;
+    const db = getDb();
+    db.run(`UPDATE messages SET finalized = 0 WHERE id = '${tail.id}'`);
+
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+    const forkMessages = getMessages(fork.id);
+
+    // Invariant: only finalized rows are copied, and the lineage anchor is a
+    // row the fork actually holds.
+    expect(forkMessages).toHaveLength(3);
+    expect(forkMessages.every((row) => row.finalized === 1)).toBe(true);
+    expect(fork.forkParentMessageId).not.toBe(tail.id);
+  });
+});