@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/conversation-key-store-origin.test.ts

@@ -0,0 +1,105 @@
+/**
+ * The key store attributes a channel conversation when it materializes it.
+ *
+ * This is the principal inbound seam: a new Slack, Telegram, or phone
+ * conversation gets its row here, before the daemon's own creation path is
+ * ever consulted. Stamping only in `createConversation` therefore misses the
+ * case that matters most, which is why these cases exist separately.
+ *
+ * The trust assertion at the end is the one worth protecting. `origin_channel`
+ * is what `recoverRestingTrustContext` reads, and the native channel recovers
+ * INTERNAL_GUARDIAN_TRUST_CONTEXT on every later wake and boot-resume. A
+ * remote conversation that reached this seam unattributed, or attributed as
+ * native, would resume as the guardian's own.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { recoverRestingTrustContext } from "../daemon/conversation-resting-trust.js";
+import { setConversationOriginChannelIfUnset } from "../persistence/conversation-crud.js";
+import { getOrCreateConversation } from "../persistence/conversation-key-store.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { conversations } from "../persistence/schema/index.js";
+
+await initializeDb();
+
+function rawOriginChannel(id: string): string | null {
+  const row = getDb()
+    .all(`SELECT origin_channel FROM conversations WHERE id = '${id}'`)
+    .at(0) as { origin_channel: string | null } | undefined;
+  return row?.origin_channel ?? null;
+}
+
+beforeEach(() => {
+  getDb().delete(conversations).run();
+});
+
+describe("materializing a conversation from a channel key", () => {
+  test("stamps the channel at creation, before any message", () => {
+    const { conversationId, created } = getOrCreateConversation(
+      "default:slack:slack",
+      { origin: "slack" },
+    );
+
+    expect(created).toBe(true);
+    expect(rawOriginChannel(conversationId)).toBe("slack");
+  });
+
+  test("the first message does not change what creation established", () => {
+    // Attribution is guarded on `IS NULL`, so a row attributed at creation is
+    // never re-claimed. Before and after the first message agree.
+    const { conversationId } = getOrCreateConversation("default:slack:slack", {
+      origin: "slack",
+    });
+    const atCreation = rawOriginChannel(conversationId);
+
+    setConversationOriginChannelIfUnset(conversationId, "telegram");
+
+    expect(rawOriginChannel(conversationId)).toBe(atCreation);
+    expect(rawOriginChannel(conversationId)).toBe("slack");
+  });
+
+  test("reusing an existing key does not re-attribute it", () => {
+    const first = getOrCreateConversation("default:slack:slack", {
+      origin: "slack",
+    });
+
+    const second = getOrCreateConversation("default:slack:slack", {
+      origin: "vellum",
+    });
+
+    expect(second.created).toBe(false);
+    expect(second.conversationId).toBe(first.conversationId);
+    expect(rawOriginChannel(first.conversationId)).toBe("slack");
+  });
+
+  test("a caller that states no origin leaves the column unset", () => {
+    const { conversationId } = getOrCreateConversation("some:other:key");
+
+    expect(rawOriginChannel(conversationId)).toBeNull();
+  });
+});
+
+describe("what the attribution protects", () => {
+  test("a channel conversation recovers no resting trust", () => {
+    // The property the whole change exists to hold. Driven through the
+    // creation seam rather than a raw column write, so it fails if creation
+    // ever stops attributing the row.
+    const { conversationId } = getOrCreateConversation("default:slack:slack", {
+      origin: "slack",
+    });
+
+    expect(recoverRestingTrustContext(conversationId)).toBeNull();
+  });
+
+  test("a native conversation still recovers guardian trust", () => {
+    // The other half: attributing at creation must not withdraw trust from
+    // the guardian's own conversations, or every local wake regresses.
+    const { conversationId } = getOrCreateConversation("native-key", {
+      origin: "vellum",
+    });
+
+    expect(recoverRestingTrustContext(conversationId)).not.toBeNull();
+  });
+});

package/src/__tests__/conversation-list-recency-ordering.test.ts

@@ -0,0 +1,104 @@
+import type { Database } from "bun:sqlite";
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { createConversation } from "../persistence/conversation-crud.js";
+import { ensureGroupMigration } from "../persistence/conversation-group-migration.js";
+import {
+  listConversations,
+  listPinnedConversations,
+} from "../persistence/conversation-queries.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { createGroup } from "../persistence/group-crud.js";
+
+await initializeDb();
+ensureGroupMigration();
+
+function getRawDb(): Database {
+  return (getDb() as unknown as { $client: Database }).$client;
+}
+
+/**
+ * Every conversation list orders by recency, pinned and custom groups
+ * included.
+ *
+ * `display_order` is a live column and some rows carry a value in it, so
+ * "nothing writes it" is not enough to make the order consistent: a read that
+ * consulted it would serve those rows in an arrangement no user can change,
+ * while every other surface shows recency.
+ *
+ * Each test sets `display_order` to contradict recency, so a read that
+ * consults it fails here rather than passing by coincidence.
+ */
+describe("conversation list ordering ignores display_order", () => {
+  beforeEach(() => {
+    const raw = getRawDb();
+    raw.run("DELETE FROM conversations");
+    raw.run("DELETE FROM conversation_groups WHERE is_system_group = 0");
+  });
+
+  /** Give a row a `display_order` and a recency stamp that disagree. */
+  function arrange(id: string, displayOrder: number, lastMessageAt: number) {
+    getRawDb().run(
+      "UPDATE conversations SET display_order = ?, last_message_at = ? WHERE id = ?",
+      [displayOrder, lastMessageAt, id],
+    );
+  }
+
+  test("a custom group orders by recency, ignoring display_order", () => {
+    const groupId = createGroup("Briefs").id;
+    createConversation({ id: "conv-old", source: "user", groupId });
+    createConversation({ id: "conv-new", source: "user", groupId });
+    // `display_order` says old-then-new; recency says the opposite.
+    arrange("conv-old", 0, 1_000);
+    arrange("conv-new", 1, 9_000);
+
+    expect(listConversations({ groupId }).map((c) => c.id)).toEqual([
+      "conv-new",
+      "conv-old",
+    ]);
+  });
+
+  test("the pinned group orders by recency, ignoring display_order", () => {
+    createConversation({
+      id: "pin-old",
+      source: "user",
+      groupId: "system:pinned",
+    });
+    createConversation({
+      id: "pin-new",
+      source: "user",
+      groupId: "system:pinned",
+    });
+    arrange("pin-old", 0, 1_000);
+    arrange("pin-new", 1, 9_000);
+
+    expect(
+      listConversations({ groupId: "system:pinned" }).map((c) => c.id),
+    ).toEqual(["pin-new", "pin-old"]);
+  });
+
+  /* The page-one pinned injection reads through its own query, so it needs
+     the same guarantee: one section must not have two orderings depending on
+     which read served it. */
+  test("listPinnedConversations orders by recency too", () => {
+    createConversation({
+      id: "pin-old",
+      source: "user",
+      groupId: "system:pinned",
+    });
+    createConversation({
+      id: "pin-new",
+      source: "user",
+      groupId: "system:pinned",
+    });
+    getRawDb().run("UPDATE conversations SET is_pinned = 1");
+    arrange("pin-old", 0, 1_000);
+    arrange("pin-new", 1, 9_000);
+
+    expect(listPinnedConversations().map((c) => c.id)).toEqual([
+      "pin-new",
+      "pin-old",
+    ]);
+  });
+});

package/src/__tests__/conversation-origin-at-creation.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Conversation provenance is stated at creation.
+ *
+ * `createConversation` accepts the origin so the row is attributed from the
+ * moment it exists, rather than being patched afterward by
+ * `setConversationOriginChannelIfUnset` on the first inbound message. See
+ * JARVIS-1466 for why the post-hoc path leaves the column in a third
+ * "not yet attributed" state that different readers resolve in opposite
+ * directions.
+ *
+ * The omitted-origin case is pinned deliberately: while call sites are being
+ * migrated, omitting the argument has to behave exactly as it did before the
+ * parameter existed, or migrating them stops being safe to do piecemeal.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  createConversation,
+  getConversationOriginChannel,
+  setConversationOriginChannelIfUnset,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { conversations } from "../persistence/schema/index.js";
+
+await initializeDb();
+
+/** The raw column, not the parsed accessor, so NULL stays distinguishable. */
+function rawOriginChannel(id: string): string | null {
+  const row = getDb()
+    .all(`SELECT origin_channel FROM conversations WHERE id = '${id}'`)
+    .at(0) as { origin_channel: string | null } | undefined;
+  return row?.origin_channel ?? null;
+}
+
+beforeEach(() => {
+  getDb().delete(conversations).run();
+});
+
+describe("stating the origin at creation", () => {
+  test("stamps a native conversation", () => {
+    const conv = createConversation({ title: "in-app", origin: "vellum" });
+
+    expect(rawOriginChannel(conv.id)).toBe("vellum");
+  });
+
+  test("stamps an external channel", () => {
+    const conv = createConversation({ title: "from-slack", origin: "slack" });
+
+    expect(rawOriginChannel(conv.id)).toBe("slack");
+  });
+
+  test("a stamped row is attributed before any message arrives", () => {
+    // The point of the change: the row is already correct, so nothing has to
+    // run afterward to make it so.
+    const conv = createConversation({ title: "from-slack", origin: "slack" });
+
+    expect(getConversationOriginChannel(conv.id)).toBe("slack");
+  });
+});
+
+describe("inheriting the origin from a parent", () => {
+  test("a fork lands on its parent's channel", () => {
+    const parent = createConversation({ title: "parent", origin: "telegram" });
+
+    const fork = createConversation({
+      title: "fork",
+      origin: { inheritFrom: parent.id },
+    });
+
+    expect(rawOriginChannel(fork.id)).toBe("telegram");
+  });
+
+  test("inheriting from a native parent stays native", () => {
+    const parent = createConversation({ title: "parent", origin: "vellum" });
+
+    const fork = createConversation({
+      title: "fork",
+      origin: { inheritFrom: parent.id },
+    });
+
+    expect(rawOriginChannel(fork.id)).toBe("vellum");
+  });
+
+  test("a parent whose own origin is unset yields an unset origin", () => {
+    // Faithful inheritance, not an error. Most rows sit unattributed until a
+    // message claims them or startup sweeps them, so treating this as a
+    // failure would break the majority of forks and subagent spawns.
+    const parent = createConversation({ title: "unattributed-parent" });
+
+    const fork = createConversation({
+      title: "fork",
+      origin: { inheritFrom: parent.id },
+    });
+
+    expect(rawOriginChannel(fork.id)).toBeNull();
+  });
+
+  test("a parent that does not exist fails the insert rather than defaulting", () => {
+    // Defaulting here would be a trust grant, not a cosmetic guess:
+    // `recoverRestingTrustContext` recovers INTERNAL_GUARDIAN_TRUST_CONTEXT
+    // for the native channel, so a fork of a remote conversation whose parent
+    // we failed to read would come back as the guardian's own on every later
+    // wake and boot-resume.
+    expect(() =>
+      createConversation({
+        title: "orphan",
+        origin: { inheritFrom: "no-such-conversation" },
+      }),
+    ).toThrow(/Cannot inherit conversation origin/);
+  });
+
+  test("a remote parent's fork does not become native", () => {
+    // The property that matters for trust, stated directly.
+    const parent = createConversation({ title: "parent", origin: "slack" });
+
+    const fork = createConversation({
+      title: "fork",
+      origin: { inheritFrom: parent.id },
+    });
+
+    expect(rawOriginChannel(fork.id)).not.toBe("vellum");
+    expect(rawOriginChannel(fork.id)).toBe("slack");
+  });
+});
+
+describe("callers that have not been migrated yet", () => {
+  test("omitting the origin leaves the column unset", () => {
+    const conv = createConversation({ title: "unmigrated" });
+
+    expect(rawOriginChannel(conv.id)).toBeNull();
+  });
+
+  test("attribution still claims an unstamped row", () => {
+    const conv = createConversation({ title: "unmigrated" });
+
+    setConversationOriginChannelIfUnset(conv.id, "slack");
+
+    expect(rawOriginChannel(conv.id)).toBe("slack");
+  });
+
+  test("attribution does not overwrite an origin stated at creation", () => {
+    // The `isNull` guard is what makes stamping and attribution able to
+    // coexist during the migration: a row that already knows its origin is
+    // never re-claimed by a later message.
+    const conv = createConversation({ title: "from-slack", origin: "slack" });
+
+    setConversationOriginChannelIfUnset(conv.id, "telegram");
+
+    expect(rawOriginChannel(conv.id)).toBe("slack");
+  });
+});

package/src/__tests__/conversation-origin-channel-filter.test.ts

@@ -0,0 +1,95 @@
+import type { Database } from "bun:sqlite";
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { createConversation } from "../persistence/conversation-crud.js";
+import { ensureGroupMigration } from "../persistence/conversation-group-migration.js";
+import { listConversations } from "../persistence/conversation-queries.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+
+await initializeDb();
+ensureGroupMigration();
+
+function getRawDb(): Database {
+  return (getDb() as unknown as { $client: Database }).$client;
+}
+
+/**
+ * `originChannel` is what lets each sidebar channel card fetch its own rows,
+ * and what lets the Chats card ask for the ones no channel claimed.
+ *
+ * The asymmetry under test: `origin_channel` is deliberately NULL at insert so
+ * an inbound message can claim the conversation for its channel, and migration
+ * 288 settles the unclaimed ones to 'vellum' at daemon startup. So NULL means
+ * "not yet attributed", and between one boot and the next it is what most rows
+ * carry. Reading `vellum` strictly would leave every one of them in no section
+ * at all: not native, not any channel.
+ */
+describe("listConversations originChannel filter", () => {
+  beforeEach(() => {
+    const raw = getRawDb();
+    raw.run("DELETE FROM conversations");
+  });
+
+  /** Set `origin_channel` directly; `createConversation` leaves it unset. */
+  function stamp(id: string, originChannel: string | null): void {
+    getRawDb().run("UPDATE conversations SET origin_channel = ? WHERE id = ?", [
+      originChannel,
+      id,
+    ]);
+  }
+
+  function listedIds(originChannel: string): string[] {
+    return listConversations({ originChannel } as Parameters<
+      typeof listConversations
+    >[0]).map((c) => c.id);
+  }
+
+  test("vellum matches rows that were never attributed", () => {
+    createConversation({ id: "conv-unattributed", source: "user" });
+    stamp("conv-unattributed", null);
+
+    expect(listedIds("vellum")).toEqual(["conv-unattributed"]);
+  });
+
+  test("vellum matches rows explicitly stamped vellum", () => {
+    createConversation({ id: "conv-native", source: "user" });
+    stamp("conv-native", "vellum");
+
+    expect(listedIds("vellum")).toEqual(["conv-native"]);
+  });
+
+  /* The whole point: an unattributed row and a stamped native row are the same
+     section. Asserting both are returned together, rather than each alone,
+     is what fails if the predicate goes back to a strict equality. */
+  test("vellum returns unattributed and stamped rows together", () => {
+    createConversation({ id: "conv-native", source: "user" });
+    stamp("conv-native", "vellum");
+    createConversation({ id: "conv-unattributed", source: "user" });
+    stamp("conv-unattributed", null);
+
+    expect(listedIds("vellum").sort()).toEqual([
+      "conv-native",
+      "conv-unattributed",
+    ]);
+  });
+
+  test("vellum does not claim a row belonging to a channel", () => {
+    createConversation({ id: "conv-slack", source: "user" });
+    stamp("conv-slack", "slack");
+
+    expect(listedIds("vellum")).toEqual([]);
+  });
+
+  /* Only `vellum` is tolerant. A row is claimed for a channel by that channel
+     alone, so there is no ambiguity for the others to absorb - and a tolerant
+     `slack` would pull every unattributed row into the Slack card. */
+  test("a channel matches exactly and never absorbs unattributed rows", () => {
+    createConversation({ id: "conv-slack", source: "user" });
+    stamp("conv-slack", "slack");
+    createConversation({ id: "conv-unattributed", source: "user" });
+    stamp("conv-unattributed", null);
+
+    expect(listedIds("slack")).toEqual(["conv-slack"]);
+  });
+});

package/src/__tests__/conversation-placement-promotion.test.ts

@@ -0,0 +1,172 @@
+/**
+ * Filing a background or scheduled conversation into a section the user reads
+ * promotes it durably.
+ *
+ * Placement into Pinned or a custom group stamps `surfaced_at`, so the
+ * promotion outlives the placement that caused it: taking the conversation
+ * back out returns it to Recents rather than hiding it. Demotion is the
+ * mirror image, and filing into `system:background` / `system:scheduled`
+ * clears the stamp.
+ *
+ * The cases below pin both edges. Under-promoting hides a conversation the
+ * user deliberately filed somewhere; over-promoting drags hidden automation
+ * into the sidebar, so the "what promotion must not do" block is as
+ * load-bearing as the rest.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  batchSetConversationPlacement,
+  createConversation,
+} from "../persistence/conversation-crud.js";
+import { listConversations } from "../persistence/conversation-queries.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { createGroup } from "../persistence/group-crud.js";
+import { rawRun } from "../persistence/raw-query.js";
+import { conversations } from "../persistence/schema/index.js";
+
+await initializeDb();
+
+function seedRoutedBackground(title: string, type: "background" | "scheduled") {
+  const conv = createConversation({ title, conversationType: type });
+  rawRun(
+    "test:routeToSystemBucket",
+    "UPDATE conversations SET group_id = ? WHERE id = ?",
+    type === "scheduled" ? "system:scheduled" : "system:background",
+    conv.id,
+  );
+  return conv;
+}
+
+/** Titles the sidebar's standard listing would render. */
+function visibleTitles(): string[] {
+  return listConversations({ limit: 100 }).map((c) => c.title ?? "");
+}
+
+function titlesInGroup(groupId: string): string[] {
+  return listConversations({ limit: 100, groupId }).map((c) => c.title ?? "");
+}
+
+beforeEach(() => {
+  getDb().delete(conversations).run();
+});
+
+describe("pinning a background conversation", () => {
+  test("shows it in Pinned", () => {
+    const conv = seedRoutedBackground("bg-job", "background");
+    expect(visibleTitles()).toEqual([]);
+
+    batchSetConversationPlacement([{ id: conv.id, groupId: "system:pinned" }]);
+
+    expect(titlesInGroup("system:pinned")).toEqual(["bg-job"]);
+  });
+
+  test("unpinning lands it in Recents rather than hiding it again", () => {
+    const conv = seedRoutedBackground("bg-job", "background");
+    batchSetConversationPlacement([{ id: conv.id, groupId: "system:pinned" }]);
+
+    batchSetConversationPlacement([{ id: conv.id, groupId: "system:all" }]);
+
+    expect(titlesInGroup("system:all")).toEqual(["bg-job"]);
+  });
+});
+
+describe("filing a background conversation into a custom group", () => {
+  test("shows it in that group", () => {
+    const group = createGroup("Car Chat");
+    const conv = seedRoutedBackground("bg-job", "background");
+
+    batchSetConversationPlacement([{ id: conv.id, groupId: group.id }]);
+
+    expect(titlesInGroup(group.id)).toEqual(["bg-job"]);
+  });
+
+  test("removing it from the group lands it in Recents rather than losing it", () => {
+    const group = createGroup("Car Chat");
+    const conv = seedRoutedBackground("bg-job", "background");
+    batchSetConversationPlacement([{ id: conv.id, groupId: group.id }]);
+
+    batchSetConversationPlacement([{ id: conv.id, groupId: "system:all" }]);
+
+    expect(titlesInGroup("system:all")).toEqual(["bg-job"]);
+    expect(visibleTitles()).toEqual(["bg-job"]);
+  });
+
+  test("applies to scheduled conversations too", () => {
+    const group = createGroup("Morning Briefs");
+    const conv = seedRoutedBackground("sched-job", "scheduled");
+
+    batchSetConversationPlacement([{ id: conv.id, groupId: group.id }]);
+    batchSetConversationPlacement([{ id: conv.id, groupId: "system:all" }]);
+
+    expect(titlesInGroup("system:all")).toEqual(["sched-job"]);
+  });
+});
+
+describe("what promotion must not do", () => {
+  test("filing into system:background still demotes", () => {
+    const conv = seedRoutedBackground("bg-job", "background");
+    // Promote first, so the demotion has something to undo.
+    batchSetConversationPlacement([{ id: conv.id, groupId: "system:pinned" }]);
+    expect(titlesInGroup("system:pinned")).toEqual(["bg-job"]);
+
+    batchSetConversationPlacement([
+      { id: conv.id, groupId: "system:background" },
+    ]);
+
+    expect(visibleTitles()).toEqual([]);
+  });
+
+  test("a background conversation nobody placed anywhere stays hidden", () => {
+    seedRoutedBackground("untouched", "background");
+
+    expect(visibleTitles()).toEqual([]);
+  });
+
+  test("moving to system:all does not by itself promote", () => {
+    // Removal is not a promotion: a row that was never filed into a section
+    // the user reads must not become visible just by being moved out of its
+    // system bucket.
+    const conv = seedRoutedBackground("bg-job", "background");
+
+    batchSetConversationPlacement([{ id: conv.id, groupId: "system:all" }]);
+
+    expect(visibleTitles()).toEqual([]);
+  });
+
+  test("unpinning through the legacy isPinned path still lands in Recents", () => {
+    // Old clients send `isPinned: false` with no `groupId`, and that branch
+    // restores the row's original system bucket to keep its provenance. It
+    // deliberately does not clear the promotion: unpinning is not a demotion,
+    // so the conversation belongs in Recents afterwards, the same as the
+    // modern path that sends `groupId: "system:all"`.
+    //
+    // The row therefore sits in `system:background` while remaining visible.
+    // That is the intended split: the bucket records where the conversation
+    // came from, `surfaced_at` records that the user promoted it, and only
+    // an explicit demotion clears the latter.
+    const conv = seedRoutedBackground("bg-job", "background");
+    batchSetConversationPlacement([{ id: conv.id, groupId: "system:pinned" }]);
+
+    batchSetConversationPlacement([{ id: conv.id, isPinned: false }]);
+
+    expect(visibleTitles()).toEqual(["bg-job"]);
+    expect(titlesInGroup("system:all")).toEqual(["bg-job"]);
+  });
+
+  test("standard conversations are not stamped as surfaced", () => {
+    // They are already visible, so stamping them would leave `surfaced_at`
+    // meaning nothing.
+    const group = createGroup("Car Chat");
+    const conv = createConversation("plain-chat");
+
+    batchSetConversationPlacement([{ id: conv.id, groupId: group.id }]);
+
+    const row = getDb()
+      .all(`SELECT surfaced_at FROM conversations WHERE id = '${conv.id}'`)
+      .at(0) as { surfaced_at: number | null };
+    expect(row.surfaced_at).toBeNull();
+  });
+});