@vellumai/assistant 0.11.2 → 0.11.3-staging.2

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

@@ -0,0 +1,352 @@
+/**
+ * End-to-end guards over referential forking: `forkStrategy: "reference"`
+ * builds a fork that copies no rows and reads its inherited window back
+ * through `fork_parent_message_id`.
+ *
+ * The load-bearing claim is equivalence. A referential fork must present the
+ * same message list a copied fork presents, because the retrospective agent
+ * reads the fork natively and every downstream consumer (accounting, dedup,
+ * the fork-boundary scan) reads it through the same helpers. The parity test
+ * against the cloning path is what pins that.
+ */
+
+import { rmSync, writeFileSync } from "node:fs";
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+import { invalidateConfigCache } from "../config/loader.js";
+import {
+  addMessage,
+  countMessagesAfter,
+  createConversation,
+  deleteConversation,
+  deleteConversationGently,
+  forkConversationForRetrospective,
+  getMessages,
+  getMessagesAfter,
+  getMessagesPaginated,
+  hasMessages,
+  isReferentialHistoryOrphaned,
+} from "../persistence/conversation-crud.js";
+import { getDb, getLogsDb, getMemoryDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import {
+  conversations,
+  llmRequestLogs,
+  memoryJobs,
+  memoryRetrospectiveState,
+  messages,
+} from "../persistence/schema/index.js";
+import { getWorkspaceConfigPath } from "../util/platform.js";
+
+await initializeDb();
+
+const configPath = getWorkspaceConfigPath();
+
+/**
+ * Point `memory.retrospective.forkStrategy` at a strategy. The fork path reads
+ * it from config rather than taking a parameter, so exercising both branches
+ * means writing the workspace config the loader reads.
+ */
+function setForkStrategy(strategy: "cloning" | "reference"): void {
+  writeFileSync(
+    configPath,
+    JSON.stringify(
+      { memory: { retrospective: { forkStrategy: strategy } } },
+      null,
+      2,
+    ) + "\n",
+  );
+  invalidateConfigCache();
+}
+
+function clearConfig(): void {
+  rmSync(configPath, { force: true });
+  invalidateConfigCache();
+}
+
+afterAll(clearConfig);
+
+function resetTables(): void {
+  const db = getDb();
+  getMemoryDb()!.delete(memoryRetrospectiveState).run();
+  getMemoryDb()!.delete(memoryJobs).run();
+  getLogsDb()!.delete(llmRequestLogs).run();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM conversation_compaction_events");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+async function seedSource(title: string): Promise<{ id: string }> {
+  const source = createConversation(title);
+  await addMessage(source.id, "user", "draft a launch plan", {
+    skipIndexing: true,
+  });
+  await addMessage(source.id, "assistant", "here is a first pass", {
+    skipIndexing: true,
+  });
+  await addMessage(source.id, "user", "tweak the timeline", {
+    skipIndexing: true,
+  });
+  await addMessage(source.id, "assistant", "updated", { skipIndexing: true });
+  return source;
+}
+
+/** Ids of every conversation currently in the database. */
+function conversationIds(): string[] {
+  return getDb()
+    .select({ id: conversations.id })
+    .from(conversations)
+    .all()
+    .map((row) => row.id);
+}
+
+/** Rows physically stored on a conversation, ignoring anything inherited. */
+function ownedRowCount(conversationId: string): number {
+  return getDb()
+    .select()
+    .from(messages)
+    .where(eq(messages.conversationId, conversationId))
+    .all().length;
+}
+
+/** Flatten each row's content blocks down to their text, for readable asserts. */
+function textOf(rows: Array<{ content: unknown }>): string[] {
+  return rows.map((row) => {
+    if (typeof row.content === "string") {
+      return row.content;
+    }
+    const blocks = Array.isArray(row.content) ? row.content : [];
+    return blocks
+      .map((block: unknown) =>
+        typeof block === "object" && block !== null && "text" in block
+          ? String((block as { text: unknown }).text)
+          : "",
+      )
+      .join("");
+  });
+}
+
+describe("referential forking", () => {
+  beforeEach(() => {
+    resetTables();
+    clearConfig();
+  });
+
+  test("copies no message rows and stamps the strategy", async () => {
+    const source = await seedSource("Launch");
+
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    expect(ownedRowCount(fork.id)).toBe(0);
+    expect(fork.forkStrategy).toBe("reference");
+    expect(fork.forkParentConversationId).toBe(source.id);
+    expect(fork.forkParentMessageId).not.toBeNull();
+  });
+
+  test("reads the source's history through the fork pointer", async () => {
+    const source = await seedSource("Launch");
+
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    expect(textOf(getMessages(fork.id))).toEqual([
+      "draft a launch plan",
+      "here is a first pass",
+      "tweak the timeline",
+      "updated",
+    ]);
+    expect(hasMessages(fork.id)).toBe(true);
+  });
+
+  test("presents the same messages a cloning fork does", async () => {
+    const source = await seedSource("Launch");
+
+    setForkStrategy("cloning");
+    const cloned = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+    setForkStrategy("reference");
+    const referenced = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    expect(textOf(getMessages(referenced.id))).toEqual(
+      textOf(getMessages(cloned.id)),
+    );
+    expect(countMessagesAfter(referenced.id, null)).toBe(
+      countMessagesAfter(cloned.id, null),
+    );
+  });
+
+  test("rows written on the fork interleave after the inherited ones", async () => {
+    const source = await seedSource("Launch");
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    await addMessage(fork.id, "user", "review this conversation", {
+      skipIndexing: true,
+    });
+
+    expect(textOf(getMessages(fork.id)).at(-1)).toBe(
+      "review this conversation",
+    );
+    expect(ownedRowCount(fork.id)).toBe(1);
+  });
+
+  test("messages written on the source after the fork point are excluded", async () => {
+    const source = await seedSource("Launch");
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    await addMessage(source.id, "user", "written after the fork", {
+      skipIndexing: true,
+    });
+
+    const forkText = textOf(getMessages(fork.id));
+    expect(forkText).not.toContain("written after the fork");
+    expect(textOf(getMessages(source.id))).toContain("written after the fork");
+  });
+
+  test("a cutoff bounds the inherited window", async () => {
+    const source = await seedSource("Launch");
+    const sourceRows = getMessages(source.id);
+
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+      throughMessageId: sourceRows[1]!.id,
+    });
+
+    expect(textOf(getMessages(fork.id))).toEqual([
+      "draft a launch plan",
+      "here is a first pass",
+    ]);
+  });
+
+  test("getMessagesAfter and countMessagesAfter cross the lineage boundary", async () => {
+    const source = await seedSource("Launch");
+    const sourceRows = getMessages(source.id);
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+    await addMessage(fork.id, "user", "own row", { skipIndexing: true });
+
+    // The cursor sits on an ancestor row while the rows it must return span
+    // both the ancestor's tail and the fork's own writes.
+    const after = getMessagesAfter(fork.id, sourceRows[1]!.id);
+
+    expect(textOf(after)).toEqual(["tweak the timeline", "updated", "own row"]);
+    expect(countMessagesAfter(fork.id, sourceRows[1]!.id)).toBe(3);
+  });
+
+  test("pagination returns the inherited rows", async () => {
+    const source = await seedSource("Launch");
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    const unlimited = getMessagesPaginated(fork.id, undefined);
+    expect(textOf(unlimited.messages)).toHaveLength(4);
+
+    const page = getMessagesPaginated(fork.id, 2);
+    expect(page.messages).toHaveLength(2);
+    expect(page.hasMore).toBe(true);
+    // Newest-first paging, so the page holds the tail of the inherited window.
+    expect(textOf(page.messages)).toContain("updated");
+  });
+
+  test("deleting the source orphans the fork instead of blocking or cascading", async () => {
+    const source = await seedSource("Launch");
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+    await addMessage(fork.id, "user", "own row", { skipIndexing: true });
+
+    deleteConversation(source.id);
+
+    // The delete touches only what it names: the fork survives, keeps the rows
+    // it owns, and the lineage read truncates at the missing parent instead of
+    // throwing.
+    expect(conversationIds()).toContain(fork.id);
+    expect(textOf(getMessages(fork.id))).toEqual(["own row"]);
+    expect(hasMessages(fork.id)).toBe(true);
+    expect(countMessagesAfter(fork.id, null)).toBe(1);
+  });
+
+  test("the gentle delete path orphans the same way", async () => {
+    const source = await seedSource("Launch");
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    // `deleteConversationGently` is a separate implementation of the same
+    // operation and is what the plugin facade exposes, so it must not diverge.
+    await deleteConversationGently(source.id);
+
+    expect(conversationIds()).toContain(fork.id);
+    expect(getMessages(fork.id)).toHaveLength(0);
+  });
+
+  test("an orphaned fork reports the loss so clients can explain it", async () => {
+    const source = await seedSource("Launch");
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    expect(isReferentialHistoryOrphaned(fork)).toBe(false);
+    deleteConversation(source.id);
+
+    const orphan = getDb()
+      .select()
+      .from(conversations)
+      .where(eq(conversations.id, fork.id))
+      .get()!;
+    expect(isReferentialHistoryOrphaned(orphan)).toBe(true);
+  });
+
+  test("a cloning fork whose source is deleted is not reported as orphaned", async () => {
+    const source = await seedSource("Launch");
+    setForkStrategy("cloning");
+    const cloned = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    deleteConversation(source.id);
+
+    // It holds its own copy, so a missing parent costs it nothing and there is
+    // nothing to tell the user about.
+    expect(isReferentialHistoryOrphaned(cloned)).toBe(false);
+    expect(textOf(getMessages(cloned.id))).toHaveLength(4);
+  });
+
+  test("deleting a fork leaves its source alone", async () => {
+    const source = await seedSource("Launch");
+    setForkStrategy("reference");
+    const fork = await forkConversationForRetrospective({
+      conversationId: source.id,
+    });
+
+    deleteConversation(fork.id);
+
+    expect(conversationIds()).toContain(source.id);
+    expect(textOf(getMessages(source.id))).toHaveLength(4);
+  });
+});

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

@@ -198,7 +198,11 @@ describe("forkConversationForRetrospective", () => {
     const assistant = await addMessage(source.id, "assistant", "see mockup", {
       skipIndexing: true,
     });
-    const uploaded = uploadAttachment("wireframe.png", "image/png", "iVBORw0K");
+    const uploaded = await uploadAttachment(
+      "wireframe.png",
+      "image/png",
+      "iVBORw0K",
+    );
     linkAttachmentToMessage(assistant.id, uploaded.id, 0);
 
     const asyncFork = await forkConversationForRetrospective({

package/src/__tests__/conversation-group-tools.test.ts

@@ -257,7 +257,7 @@ describe("conversation_move_to_group tool", () => {
     expect(result.content).toContain("no conversation found");
   });
 
-  test("notes hidden conversation types", async () => {
+  test("tells the model a custom group surfaces a hidden conversation", async () => {
     createConversation({ id: "conv-bg", conversationType: "background" });
     await executeConversationGroupCreate({ name: "Visible" }, ctx);
 
@@ -267,7 +267,37 @@ describe("conversation_move_to_group tool", () => {
     );
 
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("hidden from the sidebar");
+    expect(result.content).toContain("surfaces it into the sidebar");
+  });
+
+  test("does not claim a move to Recents surfaces a hidden conversation", async () => {
+    // Recents is a removal target, not a promotion: the write path leaves an
+    // unpromoted background row hidden there, so saying otherwise would report
+    // an outcome to the model that did not happen.
+    createConversation({ id: "conv-bg-all", conversationType: "background" });
+
+    const result = await executeConversationMoveToGroup(
+      { group: "system:all", conversation_id: "conv-bg-all" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).not.toContain("surfaces it into the sidebar");
+  });
+
+  test("does not claim a move to Background surfaces a hidden conversation", async () => {
+    createConversation({
+      id: "conv-bg-demote",
+      conversationType: "background",
+    });
+
+    const result = await executeConversationMoveToGroup(
+      { group: "system:background", conversation_id: "conv-bg-demote" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).not.toContain("surfaces it into the sidebar");
   });
 
   test("rejects missing group", async () => {

package/src/__tests__/conversation-inference-profile-route.test.ts

@@ -1,4 +1,16 @@
-import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// The profiles pinned below are managed presets judged for real by the
+// session handler's availability guard. Stand in for a signed-in platform
+// session so the pin path under test is the healthy one — same pattern as
+// inference-profile-session-handler.test.ts.
+mock.module("../providers/platform-proxy/context.js", () => ({
+  resolveManagedProxyContext: async () => ({
+    enabled: true,
+    platformBaseUrl: "https://platform.example",
+    assistantApiKey: "key",
+  }),
+}));
 
 import {
   conversationMetadataSyncTag,
@@ -10,6 +22,7 @@ import {
 } from "../persistence/conversation-crud.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import { providerConnections } from "../persistence/schema/inference.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES } from "../runtime/routes/conversation-management-routes.js";
 import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
@@ -18,6 +31,19 @@ import { waitFor } from "./helpers/wait-for.js";
 
 await initializeDb();
 
+// The Vellum-managed connection row the managed presets resolve to.
+getDb()
+  .insert(providerConnections)
+  .values({
+    name: "vellum",
+    provider: "vellum",
+    auth: JSON.stringify({ type: "platform" }),
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  })
+  .onConflictDoNothing()
+  .run();
+
 const profileRoute = ROUTES.find(
   (r) => r.operationId === "setConversationInferenceProfile",
 )!;

package/src/__tests__/conversation-initial-prompt.test.ts

@@ -3,11 +3,12 @@
  *
  * A conversation's system prompt is built once at construction and frozen for
  * every turn (the agent loop never re-resolves it), so the persona slot must
- * resolve correctly here. With no construction-time identity the default-build
- * path must warm the gateway guardian binding BEFORE building (else a cold cache
- * pins `users/default.md`); a channel-routed conversation that already carries
- * the requester's trust context must build with it so the requester's profile
- * resolves instead of the guardian/default one.
+ * resolve correctly here. With no construction-time identity OR a
+ * guardian-class trust context (background/scheduled turns, memory
+ * consolidation, managed desktop) the guardian binding must be warmed BEFORE
+ * building (else a cold cache pins `users/default.md`); a channel-routed
+ * conversation carrying a non-guardian requester trust context must build with
+ * it directly so the requester's profile resolves via the DB contact lookup.
  *
  * Dependency seams are injected so this exercises the sequencing without mocking
  * the widely-imported guardian-delivery / system-prompt modules (those global
@@ -15,10 +16,7 @@
  */
 import { describe, expect, test } from "bun:test";
 
-import {
-  resolveInitialSystemPrompt,
-  warmGuardianBindings,
-} from "../daemon/conversation-initial-prompt.js";
+import { resolveInitialSystemPrompt } from "../daemon/conversation-initial-prompt.js";
 import type { ConversationCreateOptions } from "../daemon/handlers/shared.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 
@@ -47,18 +45,22 @@ const REQUESTER_TRUST = {
   requesterExternalUserId: "user-123",
 } as unknown as TrustContext;
 
-describe("warmGuardianBindings", () => {
-  test("warms both the vellum-channel key and the unfiltered fallback key", async () => {
-    const keys: string[] = [];
-    await warmGuardianBindings(async (input) => {
-      keys.push(input?.channelTypes?.join(",") ?? "ALL");
-      return null;
-    });
-    // Both keys the persona resolver reads — peekGuardianForChannel("vellum")
-    // and its peekAnyGuardian() fallback — must be warmed.
-    expect(keys.sort()).toEqual(["ALL", "vellum"]);
-  });
-});
+// The shape scheduler execute/reuse runs, memory consolidation, and other
+// runBackgroundJob callers pass at construction: guardian class, no
+// per-actor identity.
+const GUARDIAN_BACKGROUND_TRUST = {
+  sourceChannel: "vellum",
+  trustClass: "guardian",
+} as unknown as TrustContext;
+
+// Managed desktop: guardian class WITH a requester principal id. The persona
+// resolution may still need the guardian-delivery cache (contact lookup miss
+// or null userFile falls through to the guardian file).
+const GUARDIAN_REQUESTER_TRUST = {
+  sourceChannel: "vellum",
+  trustClass: "guardian",
+  requesterExternalUserId: "principal-123",
+} as unknown as TrustContext;
 
 describe("resolveInitialSystemPrompt", () => {
   test("no construction-time identity: warms the guardian binding, then builds with no trust context", async () => {
@@ -72,7 +74,7 @@ describe("resolveInitialSystemPrompt", () => {
     expect(builtWith).toEqual([undefined]);
   });
 
-  test("channel-routed: threads the requester trust context and skips the guardian warm", async () => {
+  test("non-guardian channel-routed: threads the requester trust context and skips the guardian warm", async () => {
     const { calls, builtWith, deps } = spyDeps();
     const result = await resolveInitialSystemPrompt(
       { trustContext: REQUESTER_TRUST } as ConversationCreateOptions,
@@ -86,6 +88,33 @@ describe("resolveInitialSystemPrompt", () => {
     expect(builtWith).toEqual([REQUESTER_TRUST]);
   });
 
+  test("guardian-class background shape: warms the guardian binding, then builds with the trust context", async () => {
+    const { calls, builtWith, deps } = spyDeps();
+    const result = await resolveInitialSystemPrompt(
+      { trustContext: GUARDIAN_BACKGROUND_TRUST } as ConversationCreateOptions,
+      deps,
+    );
+
+    expect(result).toBe("BUILD");
+    // Scheduled tasks and memory consolidation construct conversations in
+    // worker processes whose guardian-delivery cache starts cold; the warm
+    // MUST precede the build or the persona slot pins users/default.md.
+    expect(calls).toEqual(["warm", "build"]);
+    expect(builtWith).toEqual([GUARDIAN_BACKGROUND_TRUST]);
+  });
+
+  test("guardian-class with requester identity (managed desktop): still warms before building", async () => {
+    const { calls, builtWith, deps } = spyDeps();
+    const result = await resolveInitialSystemPrompt(
+      { trustContext: GUARDIAN_REQUESTER_TRUST } as ConversationCreateOptions,
+      deps,
+    );
+
+    expect(result).toBe("BUILD");
+    expect(calls).toEqual(["warm", "build"]);
+    expect(builtWith).toEqual([GUARDIAN_REQUESTER_TRUST]);
+  });
+
   test("an explicit override is used verbatim and skips the warm and build", async () => {
     const { calls, deps } = spyDeps();
     const result = await resolveInitialSystemPrompt(

package/src/__tests__/conversation-key-store-bootstrap-cleanup.test.ts

@@ -0,0 +1,119 @@
+/**
+ * `getOrCreateConversation` doubles as the first-conversation bootstrap
+ * bookkeeper: the first standard conversation is the onboarding one (keep
+ * BOOTSTRAP.md), and the second means onboarding is over (delete it).
+ *
+ * Onboarding also mints internal side threads (research, personality rewrite,
+ * identity rewrite) as `conversationType: "background"` rows that the user
+ * never opens. Those must be completely inert with respect to this bookkeeping:
+ * if a hidden side thread consumed the first-conversation slot, the user's
+ * FIRST visible chat would look like the second conversation and lose
+ * BOOTSTRAP.md before its opening turn.
+ */
+
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { assertNotLiveDb } from "./assert-not-live-db.js";
+
+const testDir = process.env.VELLUM_WORKSPACE_DIR!;
+const conversationsDir = join(testDir, "conversations");
+mkdirSync(conversationsDir, { recursive: true });
+
+import {
+  _resetFirstConversationSeenForTesting,
+  getOrCreateConversation,
+} from "../persistence/conversation-key-store.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import {
+  conversationKeys,
+  conversations,
+} from "../persistence/schema/index.js";
+
+await initializeDb();
+
+const bootstrapPath = join(testDir, "BOOTSTRAP.md");
+const bootstrapReferencePath = join(testDir, "BOOTSTRAP-REFERENCE.md");
+
+function seedBootstrapFiles(): void {
+  writeFileSync(bootstrapPath, "# First run\n", "utf-8");
+  writeFileSync(bootstrapReferencePath, "# Reference\n", "utf-8");
+}
+
+beforeEach(() => {
+  const db = getDb();
+  db.delete(conversationKeys).run();
+  db.delete(conversations).run();
+
+  assertNotLiveDb(conversationsDir);
+  rmSync(conversationsDir, { recursive: true, force: true });
+  mkdirSync(conversationsDir, { recursive: true });
+
+  // `firstConversationSeen` is module-level (process-global) state, so each
+  // test has to replay the fresh-install sequence from a known-clean flag.
+  _resetFirstConversationSeenForTesting();
+  seedBootstrapFiles();
+});
+
+describe("getOrCreateConversation bootstrap bookkeeping", () => {
+  test("background side threads do not consume the first-conversation slot", () => {
+    // The exact onboarding sequence: three hidden side threads, then the
+    // user's first real chat.
+    for (const key of ["onboarding-research", "personality", "identity"]) {
+      const created = getOrCreateConversation(key, {
+        conversationType: "background",
+      });
+      expect(created.created).toBe(true);
+      expect(created.conversationType).toBe("background");
+      expect(existsSync(bootstrapPath)).toBe(true);
+    }
+
+    const firstVisible = getOrCreateConversation("user-first-chat");
+    expect(firstVisible.created).toBe(true);
+    expect(firstVisible.conversationType).toBe("standard");
+
+    // The user's first visible chat is still the FIRST conversation as far as
+    // onboarding is concerned, so its first-run context survives.
+    expect(existsSync(bootstrapPath)).toBe(true);
+    expect(existsSync(bootstrapReferencePath)).toBe(true);
+  });
+
+  test("a background create after the first standard one is still inert", () => {
+    getOrCreateConversation("user-first-chat");
+    expect(existsSync(bootstrapPath)).toBe(true);
+
+    getOrCreateConversation("side-thread", { conversationType: "background" });
+    expect(existsSync(bootstrapPath)).toBe(true);
+    expect(existsSync(bootstrapReferencePath)).toBe(true);
+  });
+
+  test("the second standard conversation still deletes the bootstrap files", () => {
+    getOrCreateConversation("first-chat");
+    expect(existsSync(bootstrapPath)).toBe(true);
+
+    getOrCreateConversation("second-chat");
+    expect(existsSync(bootstrapPath)).toBe(false);
+    expect(existsSync(bootstrapReferencePath)).toBe(false);
+  });
+
+  test("background creates interleaved with standard ones do not shift the slot", () => {
+    getOrCreateConversation("bg-a", { conversationType: "background" });
+    getOrCreateConversation("first-chat");
+    getOrCreateConversation("bg-b", { conversationType: "background" });
+    expect(existsSync(bootstrapPath)).toBe(true);
+
+    // Only the second STANDARD conversation ends onboarding.
+    getOrCreateConversation("second-chat");
+    expect(existsSync(bootstrapPath)).toBe(false);
+  });
+
+  test("resolving an existing key never re-runs the bookkeeping", () => {
+    const first = getOrCreateConversation("first-chat");
+    const again = getOrCreateConversation("first-chat");
+    expect(again.created).toBe(false);
+    expect(again.conversationId).toBe(first.conversationId);
+    expect(existsSync(bootstrapPath)).toBe(true);
+  });
+});