@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

package/src/persistence/conversation-crud.ts

@@ -32,6 +32,7 @@ import type { ChannelId, InterfaceId } from "../channels/types.js";
 import { parseChannelId, parseInterfaceId } from "../channels/types.js";
 import { CHANNEL_IDS, isChannelId } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
+import { isSidebarDoneEnabled } from "../config/sidebar-done-gate.js";
 import { findDisplayTurnEndIndex } from "../conversations/message-consolidation.js";
 import { findConversation } from "../daemon/conversation-registry.js";
 import { conversationMetadataSyncTag } from "../daemon/message-types/sync.js";
@@ -48,6 +49,7 @@ import { indexMessageNow } from "../plugins/defaults/memory/indexer.js";
 import { runHook } from "../plugins/pipeline.js";
 import type { ContentBlock } from "../providers/types.js";
 import { getCurrentSeq } from "../runtime/assistant-stream-state.js";
+import { publishConversationListAndMetadataChanged } from "../runtime/sync/resource-sync-events.js";
 import { publishSyncInvalidation } from "../runtime/sync/sync-publisher.js";
 import { UserError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
@@ -100,6 +102,7 @@ import {
   computerUseScreenshotAttachmentIdsFromMetadata,
   type ConversationCreateType,
   type ConversationOrigin,
+  isEchoSuppressedUserMessage,
   isHiddenMessageMetadata,
   isNoResponseMetadata,
   isReactionMessageMetadata,
@@ -942,6 +945,11 @@ interface InsertMessageCoreParams {
   /** Answered synchronously at the top of every insert attempt. See
    *  {@link AddMessageOptions.insertPrecondition}. */
   insertPrecondition?: () => boolean;
+  /** The row is a reservation booked ahead of the content that will fill it
+   *  ({@link reserveMessage}), so it carries nothing to read yet. */
+  reserved?: boolean;
+  /** See {@link AddMessageOptions.skipResurface}. */
+  skipResurface?: boolean;
 }
 
 /**
@@ -1029,6 +1037,8 @@ async function insertMessageCore(
     clientMessageId,
     id,
     insertPrecondition,
+    reserved,
+    skipResurface,
   } = params;
   warnOnModelInvisibleContent(content, conversationId);
   const db = getDb();
@@ -1054,7 +1064,7 @@ async function insertMessageCore(
 
   // The timestamp is recomputed each attempt so a late retry doesn't persist a
   // stale `updatedAt`.
-  return withSqliteRetry(
+  const inserted = await withSqliteRetry(
     (): InsertedMessage => {
       // Asked at the top of EVERY attempt, and synchronously, because that is
       // the scope the answer holds for. Contention retries this function after
@@ -1179,6 +1189,32 @@ async function insertMessageCore(
     },
     { op: "insertMessageCore", context: { conversationId } },
   );
+
+  // A message the user reads brings a Done conversation back to the list.
+  // Four kinds of insert are not that: the echo-suppressed set, which never
+  // renders in the transcript; the empty row `reserveMessage` books for an LLM
+  // call that has not run yet, whose content arrives at the finalize seam and
+  // resurfaces from there; a row whose producer declared it bookkeeping ABOUT
+  // the conversation rather than activity in it (`skipResurface`); and a
+  // deduplicated insert, which wrote no row at all. Best-effort: a failure
+  // here must not escalate into a failed persist.
+  if (
+    !inserted.deduplicated &&
+    !reserved &&
+    !skipResurface &&
+    !isEchoSuppressedUserMessage(metadata)
+  ) {
+    try {
+      resurfaceArchivedConversation(conversationId, inserted.createdAt);
+    } catch (err) {
+      log.warn(
+        { err, conversationId, messageId: inserted.id },
+        "Failed to resurface Done conversation after message insert",
+      );
+    }
+  }
+
+  return inserted;
 }
 
 /**
@@ -2653,6 +2689,17 @@ export interface AddMessageOptions {
    * during that sleep.
    */
   insertPrecondition?: () => boolean;
+  /**
+   * The row is the assistant's bookkeeping ABOUT this conversation rather than
+   * activity in it, so it must not bring the conversation back from Done (see
+   * {@link resurfaceArchivedConversation}). The producer declares this, because
+   * only the producer knows which of the two a row is.
+   *
+   * The retrospective skill card is the case: a pass runs once a conversation
+   * has gone idle, which is exactly when the user has just marked it done, so
+   * a card that resurfaced would bounce fresh done chats back into the sidebar.
+   */
+  skipResurface?: boolean;
 }
 
 /**
@@ -2666,8 +2713,14 @@ export async function addMessage(
   content: string,
   options?: AddMessageOptions,
 ) {
-  const { metadata, skipIndexing, clientMessageId, id, insertPrecondition } =
-    options ?? {};
+  const {
+    metadata,
+    skipIndexing,
+    clientMessageId,
+    id,
+    insertPrecondition,
+    skipResurface,
+  } = options ?? {};
   const inserted = await insertMessageCore({
     conversationId,
     role,
@@ -2676,6 +2729,7 @@ export async function addMessage(
     clientMessageId,
     id,
     ...(insertPrecondition ? { insertPrecondition } : {}),
+    ...(skipResurface ? { skipResurface } : {}),
   });
 
   if (inserted.deduplicated) {
@@ -3521,6 +3575,62 @@ export function unarchiveConversation(id: string): boolean {
   return true;
 }
 
+/**
+ * Bring a Done conversation back to the list because a message the user reads
+ * landed in it at `activityAt`.
+ *
+ * Under the `sidebar-done` gate "Done" is a completion mark, not a deletion:
+ * the conversation keeps its schedules and its channel threads, so anything
+ * the user would read arriving in it has to be reachable again. Two seams call
+ * this, which between them cover every ingest path without a per-provider
+ * hook: {@link insertMessageCore}, where each durable append lands (channel
+ * inbound, web and CLI sends, wake tail messages, assistant-initiated
+ * notification bodies), and the turn's finalize effect, where a streamed
+ * assistant reply becomes readable content.
+ *
+ * Rows the user never reads resurface nothing. `insertMessageCore` excludes
+ * the echo-suppressed set (hidden signals, subagent and ACP notifications, and
+ * the `<background_event>` trigger each wake persists); the empty row an LLM
+ * call reserves before it runs, so a call rejected before producing anything
+ * leaves the conversation Done; and any row whose producer passed
+ * {@link AddMessageOptions.skipResurface}. Retrospectives and memory
+ * consolidation are excluded by construction: they append to a fork or to a
+ * conversation of their own, never to the conversation under review.
+ *
+ * The clear is conditional on `archived_at <= activityAt` in one statement, so
+ * a Done mark the user makes after this activity (while a turn's deferred tail
+ * is still settling, or from the daemon while a worker runs the turn) wins
+ * instead of being erased by it.
+ *
+ * No-ops when the gate is off, which is the shipped behavior: nothing but the
+ * unarchive route clears `archived_at`.
+ */
+export function resurfaceArchivedConversation(
+  conversationId: string,
+  activityAt: number,
+): boolean {
+  if (!isSidebarDoneEnabled(getConfig())) {
+    return false;
+  }
+  const now = Date.now();
+  const changed = rawRun(
+    "conversation:resurface",
+    "UPDATE conversations SET archived_at = NULL, updated_at = ? WHERE id = ? AND archived_at IS NOT NULL AND archived_at <= ?",
+    now,
+    conversationId,
+    activityAt,
+  );
+  if (changed === 0) {
+    return false;
+  }
+  publishConversationListAndMetadataChanged("reordered", conversationId);
+  log.info(
+    { conversationId },
+    "Resurfaced Done conversation on user-visible activity",
+  );
+  return true;
+}
+
 /**
  * Persist the processing-start timestamp for a conversation. Called by
  * `Conversation.setProcessing(true)` so out-of-process callers can detect
@@ -4530,6 +4640,7 @@ export async function reserveMessage(
     content: inflightRef ? JSON.stringify({ ref: inflightRef }) : "[]",
     ...(inflightRef ? { finalized: 0 as const } : {}),
     metadata,
+    reserved: true,
   });
 }
 

package/src/persistence/conversation-queries.ts

@@ -116,6 +116,16 @@ export function hasLexicalTokens(text: string): boolean {
  */
 export type ArchiveStatusFilter = "active" | "archived" | "all";
 
+/**
+ * Which bucket a listing covers.
+ *
+ * The persisted {@link ConversationType} values plus `"all"`, a read-side
+ * union that exists only here: no row carries it, and nothing writes it. It
+ * lets one paginated request span a user's whole history, which is what a
+ * full-history view needs and what three interleaved cursors cannot give it.
+ */
+export type ConversationListTypeFilter = ConversationType | "all";
+
 function archiveStatusClause(status: ArchiveStatusFilter) {
   switch (status) {
     case "active":
@@ -196,6 +206,25 @@ function surfacedVisibilitySql(alias = "conversations"): string {
   );
 }
 
+/**
+ * Raw SQL predicate for the background **umbrella**: background and scheduled
+ * rows together, matched on `conversation_type` or on the system group the
+ * producer filed them in, with subagent runs excluded so the sidebar never
+ * surfaces them.
+ *
+ * Shared by the `"background"` bucket of {@link conversationTypeClause} and by
+ * the `"all"` bucket, which is the union of that one with the standard
+ * listing, so the combined read can never admit a row either bucket alone
+ * would have withheld.
+ */
+function backgroundUmbrellaSql(alias = "conversations"): string {
+  return (
+    `((${alias}.conversation_type IN ('background', 'scheduled')` +
+    ` OR COALESCE(${alias}.group_id, 'system:all') IN ('system:background', 'system:scheduled'))` +
+    ` AND (${alias}.source IS NULL OR ${alias}.source != 'subagent'))`
+  );
+}
+
 /**
  * Raw SQL predicate for "not an automated background/scheduled row".
  *
@@ -289,6 +318,11 @@ function ungroupedSql(alias = "conversations"): string {
  *   Background and Scheduled sidebar sections from one request.
  * - `"scheduled"` — scheduled rows only, so the Scheduled section can load
  *   independently of the broader background backlog without over-fetching it.
+ * - `"all"`: the union of `"standard"` and `"background"`, so one paginated
+ *   request covers a user's whole history instead of interleaving three. Not
+ *   a bypass of the visibility rules: it is exactly those two predicates
+ *   OR-ed, with the legacy `private` type excluded on top, so nothing reaches
+ *   it that neither bucket would have returned.
  *
  * `group_id` is matched alongside `conversationType` so conversations routed to
  * `system:background` / `system:scheduled` (heartbeat, reminders, schedule-job
@@ -296,7 +330,7 @@ function ungroupedSql(alias = "conversations"): string {
  * correct bucket. Subagent runs are excluded from the background/scheduled
  * buckets so the sidebar never surfaces them.
  */
-function conversationTypeClause(type: ConversationType) {
+function conversationTypeClause(type: ConversationListTypeFilter) {
   const notSubagent = sql`(${conversations.source} IS NULL OR ${conversations.source} != 'subagent')`;
   switch (type) {
     case "standard":
@@ -305,9 +339,20 @@ function conversationTypeClause(type: ConversationType) {
       // standardListingVisibilitySql for the full predicate semantics.
       return sql.raw(standardListingVisibilitySql());
     case "background":
-      return sql`(${conversations.conversationType} IN ('background', 'scheduled') OR group_id IN ('system:background', 'system:scheduled')) AND ${notSubagent}`;
+      return sql.raw(backgroundUmbrellaSql());
     case "scheduled":
       return sql`(${conversations.conversationType} = 'scheduled' OR group_id = 'system:scheduled') AND ${notSubagent}`;
+    case "all":
+      /* `private` is excluded explicitly rather than left to the two arms.
+         The standard arm already drops it everywhere, but the umbrella
+         matches on the system group as well as on the type, so a legacy
+         private row filed in `system:background` would otherwise arrive
+         through it. Those rows exist transiently after an in-place snapshot
+         restore, before migration cleanup deletes them. */
+      return sql.raw(
+        `((${standardListingVisibilitySql()} OR ${backgroundUmbrellaSql()})` +
+          ` AND conversations.conversation_type != 'private')`,
+      );
   }
 }
 
@@ -321,7 +366,7 @@ function conversationTypeClause(type: ConversationType) {
  * transposition waiting to happen.
  */
 export interface ConversationListFilter {
-  conversationType?: ConversationType;
+  conversationType?: ConversationListTypeFilter;
   archiveStatus?: ArchiveStatusFilter;
   originChannel?: string;
   /**