@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/surface-completion-compaction-boundary.test.ts

@@ -0,0 +1,124 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  findPersistedSurfaceInfo,
+  markSurfaceCompleted,
+} from "../daemon/conversation-surfaces.js";
+import { getMessages } from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { conversations, messages } from "../persistence/schema/index.js";
+import { findPersistedSurfaceState } from "../runtime/routes/surface-conversation-resolver.js";
+import { getDbPath } from "../util/platform.js";
+import { assertNotLiveDb } from "./assert-not-live-db.js";
+
+await initializeDb();
+
+const CONVERSATION_ID = "conv-compaction-boundary-1";
+const SURFACE_ID = "surface-behind-boundary-1";
+/** The surface sits in row 1, so this boundary drops it from live history. */
+const COMPACTED_MESSAGE_COUNT = 3;
+
+const GUARDIAN = { requesterCanAccessMemory: true };
+
+/**
+ * Four real message rows, the oldest carrying a `choice` surface between two
+ * text siblings, plus a conversation compacted past that row.
+ */
+function seedCompactedConversation(): void {
+  const db = getDb();
+  // Without the test preload these deletes would clear the user's live
+  // workspace database.
+  assertNotLiveDb(getDbPath());
+  db.delete(messages).run();
+  db.delete(conversations).run();
+  db.insert(conversations)
+    .values({
+      id: CONVERSATION_ID,
+      title: null,
+      createdAt: 1,
+      updatedAt: 1,
+      contextCompactedMessageCount: COMPACTED_MESSAGE_COUNT,
+    })
+    .run();
+
+  const rows = [
+    [
+      { type: "text", text: "Which one?" },
+      {
+        type: "ui_surface",
+        surfaceId: SURFACE_ID,
+        surfaceType: "choice",
+        data: { options: [{ id: "inbox", title: "Clean up my inbox" }] },
+      },
+      { type: "text", text: "Take your time." },
+    ],
+    [{ type: "text", text: "still waiting" }],
+    [{ type: "text", text: "still waiting" }],
+    [{ type: "text", text: "still waiting" }],
+  ];
+  rows.forEach((content, i) => {
+    db.insert(messages)
+      .values({
+        id: `msg-${i + 1}`,
+        conversationId: CONVERSATION_ID,
+        role: "assistant",
+        content: JSON.stringify(content),
+        createdAt: i + 1,
+        metadata: null,
+      })
+      .run();
+  });
+}
+
+/** The surface block as a history reseed would read it back. */
+function readPersistedBlocks(): Array<Record<string, unknown>> {
+  const row = getMessages(CONVERSATION_ID).find((r) => r.id === "msg-1")!;
+  return row.content as unknown as Array<Record<string, unknown>>;
+}
+
+describe("a surface behind the context-compaction boundary", () => {
+  beforeEach(seedCompactedConversation);
+
+  test("is invisible to the compaction-bounded read", () => {
+    expect(
+      findPersistedSurfaceState(CONVERSATION_ID, SURFACE_ID, {
+        liveHistoryStartRow: COMPACTED_MESSAGE_COUNT,
+        ...GUARDIAN,
+      }),
+    ).toBeUndefined();
+  });
+
+  test("is found by the same read once the boundary is lifted", () => {
+    expect(
+      findPersistedSurfaceState(CONVERSATION_ID, SURFACE_ID, {
+        liveHistoryStartRow: 0,
+        ...GUARDIAN,
+      })?.surfaceType,
+    ).toBe("choice");
+  });
+
+  test("still yields its type to the completion path's read", () => {
+    expect(
+      findPersistedSurfaceInfo(CONVERSATION_ID, SURFACE_ID, GUARDIAN)
+        ?.surfaceType,
+    ).toBe("choice");
+  });
+
+  test("is completed by the write, leaving its sibling blocks intact", () => {
+    expect(
+      markSurfaceCompleted(
+        { conversationId: CONVERSATION_ID },
+        SURFACE_ID,
+        'User chose: "Clean up my inbox"',
+      ),
+    ).toBe(true);
+
+    const blocks = readPersistedBlocks();
+    const surface = blocks.find((b) => b.type === "ui_surface");
+    expect(surface?.completed).toBe(true);
+    expect(surface?.completionSummary).toBe('User chose: "Clean up my inbox"');
+    expect(surface?.surfaceType).toBe("choice");
+    expect(blocks.map((b) => b.type)).toEqual(["text", "ui_surface", "text"]);
+  });
+});

package/src/__tests__/surface-completion-in-flight-snapshot.test.ts

@@ -0,0 +1,298 @@
+/**
+ * A one-shot surface shown with `await_action: false` can be answered before
+ * the turn that created it finishes. At that moment the surface exists only in
+ * `ctx.currentTurnSurfaces`: there is no persisted `ui_surface` block for
+ * `markSurfaceCompleted` to patch, and both turn-finalization appenders build
+ * the block fresh from that snapshot. Unless the completion rides the snapshot,
+ * the appended block lands pending and the next history reseed reactivates an
+ * already-answered card.
+ *
+ * Both appenders are covered because either one alone leaves the card live:
+ *   - `buildPersistedAssistantContent` (message_complete, no tools in the turn)
+ *   - `annotatePersistedAssistantMessage` (end of tool execution)
+ *
+ * The genuinely-ephemeral case is asserted alongside: a standalone surface owns
+ * neither a persisted block nor a snapshot, and must still complete.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { AssistantEvent } from "../api/index.js";
+import { createMockLoggerModule } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => createMockLoggerModule());
+
+let broadcasts: AssistantEvent[] = [];
+const realEventHub = await import("../runtime/assistant-event-hub.js");
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  ...realEventHub,
+  broadcastMessage: (msg: AssistantEvent) => {
+    broadcasts.push(msg);
+  },
+}));
+
+/**
+ * Stand-in message store. `getMessages` stays empty for the in-flight cases so
+ * the completion write finds nothing to patch, which is the whole premise;
+ * `getMessageById` serves the reserved assistant row the tool-result appender
+ * rewrites.
+ */
+let reservedRow: Array<Record<string, unknown>> | null = null;
+let updates: Array<{ id: string; blocks: Array<Record<string, unknown>> }> = [];
+
+const realCrud = await import("../persistence/conversation-crud.js");
+mock.module("../persistence/conversation-crud.js", () => ({
+  ...realCrud,
+  getMessages: () => [],
+  getMessageById: (id: string) =>
+    reservedRow ? { id, content: reservedRow } : null,
+  updateMessageContent: (id: string, content: string) => {
+    updates.push({
+      id,
+      blocks: JSON.parse(content) as Array<Record<string, unknown>>,
+    });
+  },
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
+  addMessage: () => ({ id: "mock-msg-id" }),
+  provenanceFromTrustContext: () => ({}),
+  reserveMessage: async () => ({ id: "msg-reserve" }),
+}));
+
+const realLogStore = await import("../persistence/llm-request-log-store.js");
+mock.module("../persistence/llm-request-log-store.js", () => ({
+  ...realLogStore,
+  recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
+}));
+
+// Imports must follow the mocks so both modules bind the stubs above.
+const { createSurfaceMutex, handleSurfaceAction, markSurfaceCompleted } =
+  await import("../daemon/conversation-surfaces.js");
+const {
+  buildPersistedAssistantContent,
+  createEventHandlerState,
+  handleToolResult,
+} = await import("../daemon/conversation-agent-loop-handlers.js");
+
+import type { Conversation } from "../daemon/conversation.js";
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import type { CurrentTurnSurface } from "../daemon/conversation-surface-state.js";
+import type { SurfaceStateEntry } from "../daemon/conversation-surface-state.js";
+import type { SurfaceType } from "../daemon/message-protocol.js";
+
+const CONVERSATION_ID = "conv-in-flight-surface-1";
+const SURFACE_ID = "surface-in-flight-1";
+const CHOICE_DATA = {
+  options: [
+    { id: "inbox", title: "Clean up my inbox" },
+    { id: "calendar", title: "Plan my week" },
+  ],
+};
+const CHOICE_PAYLOAD = {
+  choiceId: "inbox",
+  choiceTitle: "Clean up my inbox",
+  selectedIds: ["inbox"],
+  selectedTitles: ["Clean up my inbox"],
+};
+const EXPECTED_SUMMARY = 'User chose: "Clean up my inbox"';
+
+function makeContext(): Conversation {
+  return {
+    conversationId: CONVERSATION_ID,
+    trustContext: { trustClass: "guardian", sourceChannel: "vellum" },
+    sendToClient: () => {},
+    pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
+    lastSurfaceAction: new Map(),
+    surfaceState: new Map(),
+    surfaceUndoStacks: new Map<string, string[]>(),
+    accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
+    surfaceActionRequestIds: new Set<string>(),
+    currentTurnSurfaces: [],
+    pendingStandaloneSurfaces: new Map(),
+    recentlyCompletedStandaloneSurfaces: new Map(),
+    isProcessing: () => false,
+    enqueueMessage: () => ({ queued: true, requestId: "req-1" }),
+    getQueueDepth: () => 0,
+    processMessage: async () => "msg-1",
+    withSurface: createSurfaceMutex(),
+  } as unknown as Conversation;
+}
+
+/**
+ * What `ui_show` leaves behind for a one-shot `choice` shown with
+ * `await_action: false`: live state and a turn snapshot, but no
+ * `pendingSurfaceActions` entry and nothing persisted yet.
+ */
+function showOneShotChoice(ctx: Conversation): void {
+  ctx.surfaceState.set(SURFACE_ID, {
+    surfaceType: "choice",
+    title: "Pick one",
+    data: CHOICE_DATA,
+  } as unknown as SurfaceStateEntry);
+  ctx.currentTurnSurfaces.push({
+    surfaceId: SURFACE_ID,
+    surfaceType: "choice",
+    title: "Pick one",
+    data: CHOICE_DATA,
+    display: "inline",
+  } as CurrentTurnSurface);
+}
+
+function makeHandlerDeps(ctx: Conversation): EventHandlerDeps {
+  return {
+    ctx: {
+      ...ctx,
+      provider: { name: "anthropic" },
+      streamThinking: false,
+      emitActivityState: () => {},
+      markWorkspaceTopLevelDirty: () => {},
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: () => {},
+    reqId: "req-in-flight",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as unknown as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "web",
+      assistantMessageInterface: "web",
+    } as unknown as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
+  } as EventHandlerDeps;
+}
+
+/** Prime a finished tool call so the tool-result appender runs. */
+function makeToolState(toolUseId: string): EventHandlerState {
+  const state = createEventHandlerState();
+  state.lastAssistantMessageId = "msg-reserve";
+  state.toolUseIdToName.set(toolUseId, "ui_show");
+  state.toolCallTimestamps.set(toolUseId, { startedAt: 1 });
+  state.currentTurnToolUseIds.push(toolUseId);
+  return state;
+}
+
+function surfaceBlockFrom(
+  blocks: Array<Record<string, unknown>>,
+): Record<string, unknown> | undefined {
+  return blocks.find(
+    (b) => b.type === "ui_surface" && b.surfaceId === SURFACE_ID,
+  );
+}
+
+describe("a one-shot surface answered before its turn persists", () => {
+  beforeEach(() => {
+    broadcasts = [];
+    updates = [];
+    reservedRow = null;
+  });
+
+  test("carries its completion through the message_complete appender", async () => {
+    const ctx = makeContext();
+    showOneShotChoice(ctx);
+
+    await handleSurfaceAction(ctx, SURFACE_ID, "inbox", CHOICE_PAYLOAD);
+
+    expect(
+      broadcasts.filter((m) => m.type === "ui_surface_complete"),
+    ).toHaveLength(1);
+
+    const built = buildPersistedAssistantContent(
+      [{ type: "text", text: "Which one?" }] as never,
+      ctx.currentTurnSurfaces,
+    ) as unknown as Array<Record<string, unknown>>;
+
+    const block = surfaceBlockFrom(built);
+    expect(block?.completed).toBe(true);
+    expect(block?.completionSummary).toBe(EXPECTED_SUMMARY);
+  });
+
+  test("carries its completion through the tool-result appender", async () => {
+    const ctx = makeContext();
+    showOneShotChoice(ctx);
+    reservedRow = [{ type: "text", text: "Which one?" }];
+
+    await handleSurfaceAction(ctx, SURFACE_ID, "inbox", CHOICE_PAYLOAD);
+
+    const toolUseId = "toolu_ui_show_1";
+    handleToolResult(makeToolState(toolUseId), makeHandlerDeps(ctx), {
+      type: "tool_result",
+      toolUseId,
+      content: "Surface displayed",
+      isError: false,
+    });
+
+    expect(updates).toHaveLength(1);
+    const block = surfaceBlockFrom(updates[0].blocks);
+    expect(block?.completed).toBe(true);
+    expect(block?.completionSummary).toBe(EXPECTED_SUMMARY);
+  });
+
+  test("survives a ui_update that respreads the snapshot before the turn ends", async () => {
+    const ctx = makeContext();
+    showOneShotChoice(ctx);
+
+    await handleSurfaceAction(ctx, SURFACE_ID, "inbox", CHOICE_PAYLOAD);
+
+    // The `ui_update` merge path replaces the entry with a spread copy.
+    ctx.currentTurnSurfaces[0] = {
+      ...ctx.currentTurnSurfaces[0],
+      data: { ...CHOICE_DATA, title: "Pick one (updated)" },
+    } as CurrentTurnSurface;
+
+    const built = buildPersistedAssistantContent(
+      [],
+      ctx.currentTurnSurfaces,
+    ) as unknown as Array<Record<string, unknown>>;
+
+    expect(surfaceBlockFrom(built)?.completed).toBe(true);
+  });
+});
+
+describe("a surface with neither a persisted block nor a turn snapshot", () => {
+  beforeEach(() => {
+    broadcasts = [];
+    updates = [];
+    reservedRow = null;
+  });
+
+  test("still reports the completion as safe to announce", () => {
+    const ctx = makeContext();
+
+    expect(markSurfaceCompleted(ctx, "surface-ephemeral-1", "Done")).toBe(true);
+    expect(ctx.currentTurnSurfaces).toHaveLength(0);
+    expect(updates).toHaveLength(0);
+  });
+
+  test("completes a standalone surface and broadcasts it", async () => {
+    const ctx = makeContext();
+    let resolved: unknown;
+    ctx.pendingStandaloneSurfaces!.set(SURFACE_ID, {
+      resolve: (result: unknown) => {
+        resolved = result;
+      },
+      timer: setTimeout(() => {}, 0),
+      surfaceType: "choice",
+    } as never);
+    ctx.surfaceState.set(SURFACE_ID, {
+      surfaceType: "choice",
+      data: CHOICE_DATA,
+    } as unknown as SurfaceStateEntry);
+
+    await handleSurfaceAction(ctx, SURFACE_ID, "inbox", CHOICE_PAYLOAD);
+
+    expect(resolved).toBeDefined();
+    expect(
+      broadcasts.filter((m) => m.type === "ui_surface_complete"),
+    ).toHaveLength(1);
+    // Nothing to stamp: a standalone surface never enters the turn snapshot.
+    expect(ctx.currentTurnSurfaces).toHaveLength(0);
+  });
+});

package/src/__tests__/system-prompt.test.ts

@@ -1518,10 +1518,7 @@ describe("ensurePromptFiles", () => {
     writeFileSync(join(TEST_DIR, "SOUL.md"), "My soul");
     writeFileSync(join(TEST_DIR, "BOOTSTRAP.md"), "# Stale bootstrap");
 
-    // Create a conversations directory with at least one entry
-    const convDir = join(TEST_DIR, "conversations");
-    mkdirSync(convDir, { recursive: true });
-    writeFileSync(join(convDir, "conv-001.json"), "{}");
+    writeConversationDir("conv-001", "standard");
 
     ensurePromptFiles();
 
@@ -1533,15 +1530,93 @@ describe("ensurePromptFiles", () => {
     // will be re-seeded from templates) but still carries prior
     // conversations.  Existing conversation history signals a non-fresh
     // install, so onboarding must not re-trigger.
-    const convDir = join(TEST_DIR, "conversations");
-    mkdirSync(convDir, { recursive: true });
-    writeFileSync(join(convDir, "conv-001.json"), "{}");
+    writeConversationDir("conv-001", "standard");
 
     ensurePromptFiles();
 
     expect(existsSync(join(TEST_DIR, "BOOTSTRAP.md"))).toBe(false);
   });
 
+  /** Project a conversation onto disk the way `initConversationDir` does. */
+  function writeConversationDir(id: string, type: string): void {
+    const dir = join(
+      TEST_DIR,
+      "conversations",
+      `2026-01-01T00-00-00.000Z_${id}`,
+    );
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "meta.json"), JSON.stringify({ id, type }));
+  }
+
+  test("keeps BOOTSTRAP.md when the only conversations are background side threads", () => {
+    // Onboarding mints throwaway background threads (research, personality and
+    // identity rewrites) before the user's first visible chat, and each gets a
+    // disk-view directory.  A daemon restart in that window must not read them
+    // as evidence that onboarding ended.
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "My identity");
+    writeFileSync(join(TEST_DIR, "SOUL.md"), "My soul");
+    writeFileSync(join(TEST_DIR, "BOOTSTRAP.md"), "# Bootstrap");
+    writeConversationDir("bg-001", "background");
+    writeConversationDir("bg-002", "background");
+
+    ensurePromptFiles();
+
+    expect(existsSync(join(TEST_DIR, "BOOTSTRAP.md"))).toBe(true);
+  });
+
+  test("keeps BOOTSTRAP.md when a stray file sits beside background side threads", () => {
+    // The disk view is browsable, so a file explorer can drop `.DS_Store` into
+    // the conversations directory.  It is not a conversation and must not be
+    // classified as one.
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "My identity");
+    writeFileSync(join(TEST_DIR, "SOUL.md"), "My soul");
+    writeFileSync(join(TEST_DIR, "BOOTSTRAP.md"), "# Bootstrap");
+    writeConversationDir("bg-001", "background");
+    writeFileSync(join(TEST_DIR, "conversations", ".DS_Store"), "junk");
+
+    ensurePromptFiles();
+
+    expect(existsSync(join(TEST_DIR, "BOOTSTRAP.md"))).toBe(true);
+  });
+
+  test("auto-deletes stale BOOTSTRAP.md when a conversation directory has no meta.json", () => {
+    // A directory the daemon cannot classify counts as standard: it is far
+    // likelier to be legacy history than a side thread, and over-counting only
+    // suppresses an onboarding re-run.
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "My identity");
+    writeFileSync(join(TEST_DIR, "SOUL.md"), "My soul");
+    writeFileSync(join(TEST_DIR, "BOOTSTRAP.md"), "# Stale bootstrap");
+    mkdirSync(join(TEST_DIR, "conversations", "2026-01-01T00-00-00.000Z_old"), {
+      recursive: true,
+    });
+
+    ensurePromptFiles();
+
+    expect(existsSync(join(TEST_DIR, "BOOTSTRAP.md"))).toBe(false);
+  });
+
+  test("auto-deletes stale BOOTSTRAP.md when a standard conversation sits alongside background ones", () => {
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "My identity");
+    writeFileSync(join(TEST_DIR, "SOUL.md"), "My soul");
+    writeFileSync(join(TEST_DIR, "BOOTSTRAP.md"), "# Stale bootstrap");
+    writeConversationDir("bg-001", "background");
+    writeConversationDir("std-001", "standard");
+
+    ensurePromptFiles();
+
+    expect(existsSync(join(TEST_DIR, "BOOTSTRAP.md"))).toBe(false);
+  });
+
+  test("seeds BOOTSTRAP.md on a fresh workspace whose only conversations are background", () => {
+    // Background side threads must not make a fresh workspace look like an
+    // upgraded one, or onboarding never gets its bootstrap file at all.
+    writeConversationDir("bg-001", "background");
+
+    ensurePromptFiles();
+
+    expect(existsSync(join(TEST_DIR, "BOOTSTRAP.md"))).toBe(true);
+  });
+
   test("keeps BOOTSTRAP.md when no conversations exist yet", () => {
     // Non-first-run but no conversations — user hasn't chatted yet
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), "My identity");

package/src/__tests__/tool-grant-request-escalation.test.ts

@@ -101,17 +101,20 @@ import {
   getRegisteredKinds,
   getResolver,
 } from "../approvals/guardian-request-resolvers.js";
+import { getConfig } from "../config/loader.js";
 import { getDb } from "../persistence/db-connection.js";
 import { getSqlite } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { scopedApprovalGrants } from "../persistence/schema/index.js";
 import {
+  TC_GRANT_WAIT_MAX_MS,
   ToolApprovalHandler,
   waitForInlineGrant,
 } from "../tools/tool-approval-handler.js";
 import type { ToolContext } from "../tools/types.js";
+import { setConfig } from "./helpers/set-config.js";
 
-/** Short wait config for tests — avoids blocking test suite on the 60s default. */
+/** Short wait config for tests: keeps escalation cases off the real budget. */
 const TEST_INLINE_WAIT_CONFIG = { maxWaitMs: 100, intervalMs: 20 };
 
 await initializeDb();
@@ -490,6 +493,42 @@ describe("inline wait-and-resume", () => {
     expect(elapsed).toBeLessThan(500);
   });
 
+  test("waitForInlineGrant spends timeouts.permissionTimeoutSec when no explicit budget is given", async () => {
+    // The guardian's escalation window must track the configured approval
+    // budget rather than a compiled-in constant, so an operator raising
+    // permissionTimeoutSec actually widens the window a guardian has to
+    // answer in. Omitting maxWaitMs is what production does.
+    const priorTimeouts = getConfig().timeouts;
+    setConfig("timeouts", {
+      ...priorTimeouts,
+      permissionTimeoutSec: 0.15,
+    });
+    try {
+      const req = seedGrantRequest("sha256:configbudget");
+
+      const start = Date.now();
+      const result = await waitForInlineGrant(
+        req.id,
+        {
+          toolName: "bash",
+          inputDigest: "sha256:configbudget",
+          consumingRequestId: "consume-config-budget",
+        },
+        { intervalMs: 20 },
+      );
+      const elapsed = Date.now() - start;
+
+      expect(result.outcome).toBe("timeout");
+      // Bounded well under TC_GRANT_WAIT_MAX_MS: a regression that ignores
+      // config and falls back to the constant blows this ceiling by ~400x.
+      expect(elapsed).toBeGreaterThanOrEqual(120);
+      expect(elapsed).toBeLessThan(3_000);
+      expect(elapsed).toBeLessThan(TC_GRANT_WAIT_MAX_MS);
+    } finally {
+      setConfig("timeouts", priorTimeouts);
+    }
+  }, 10_000);
+
   test("waitForInlineGrant returns aborted when signal fires during wait", async () => {
     const req = seedGrantRequest("sha256:abortwait");