@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/memory/conversation-crud.ts

@@ -25,6 +25,7 @@ import { parseChannelId, parseInterfaceId } from "../channels/types.js";
 import { CHANNEL_IDS, isChannelId } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
 import { findDisplayTurnEndIndex } from "../conversations/message-consolidation.js";
+import { findConversation } from "../daemon/conversation-registry.js";
 import { conversationMetadataSyncTag } from "../daemon/message-types/sync.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import { clearAllConversationIds } from "../home/feed-writer.js";
@@ -44,6 +45,11 @@ import {
   linkAttachmentToMessage,
 } from "./attachments-store.js";
 import { AUTO_ANALYSIS_SOURCE } from "./auto-analysis-constants.js";
+import {
+  appendCompactionEvent,
+  forkCompactionLedger,
+  getLatestCompactionEventAtOrBefore,
+} from "./compaction-ledger-store.js";
 import {
   projectAssistantMessage,
   seedForkedConversationAttention,
@@ -304,6 +310,7 @@ export interface ConversationRow {
   inferenceProfileSessionId: string | null;
   inferenceProfileExpiresAt: number | null;
   lastNotifiedInferenceProfile: string | null;
+  processingStartedAt: number | null;
 }
 
 export const parseConversation = createRowMapper<
@@ -339,6 +346,7 @@ export const parseConversation = createRowMapper<
   inferenceProfileSessionId: "inferenceProfileSessionId",
   inferenceProfileExpiresAt: "inferenceProfileExpiresAt",
   lastNotifiedInferenceProfile: "lastNotifiedInferenceProfile",
+  processingStartedAt: "processingStartedAt",
 });
 
 /** Allowed values for the `role` column on `messages`. */
@@ -925,16 +933,6 @@ export function forkConversation(params: {
     initialBoundaryIndex,
   );
 
-  const visibleWindowStartIndex = Math.max(
-    0,
-    Math.min(
-      sourceConversation.contextCompactedMessageCount,
-      sourceMessages.length,
-    ),
-  );
-  const preserveSourceCompactionState =
-    copyBoundaryIndex >= visibleWindowStartIndex;
-
   const messagesToCopy =
     copyBoundaryIndex >= 0
       ? sourceMessages.slice(0, copyBoundaryIndex + 1)
@@ -950,6 +948,23 @@ export function forkConversation(params: {
     sourceHistoryStrippedAt != null &&
     boundaryMessageCreatedAt != null &&
     boundaryMessageCreatedAt >= sourceHistoryStrippedAt;
+
+  // Inherit compaction by the same temporal rule: apply the most recent
+  // compaction whose event time is at-or-before the forked-from message. A
+  // compaction that ran after the boundary message did not exist at that point
+  // in the conversation, so the fork branches from full uncompacted history.
+  const inheritedCompaction = getLatestCompactionEventAtOrBefore(
+    sourceConversation.id,
+    boundaryMessageCreatedAt,
+  );
+  // The Slack chronological-context watermark is single-valued on the source
+  // row and reflects only the latest compaction, so carry it only when the
+  // fork inherits that latest compaction. Pairing the latest watermark with an
+  // older inherited summary (a fork between two compactions) would filter out
+  // Slack messages the older summary does not cover.
+  const inheritsLatestCompaction =
+    inheritedCompaction != null &&
+    inheritedCompaction.compactedAt === sourceConversation.contextCompactedAt;
   const forkParentMessageId = messagesToCopy.at(-1)?.id ?? null;
   const forkTitle =
     params.title ?? `${sourceConversation.title ?? "Untitled"} (Fork)`;
@@ -981,19 +996,14 @@ export function forkConversation(params: {
       .set({
         forkParentConversationId: sourceConversation.id,
         forkParentMessageId,
-        contextSummary: preserveSourceCompactionState
-          ? sourceConversation.contextSummary
-          : null,
-        contextCompactedMessageCount: preserveSourceCompactionState
-          ? sourceConversation.contextCompactedMessageCount
-          : 0,
-        contextCompactedAt: preserveSourceCompactionState
-          ? sourceConversation.contextCompactedAt
-          : null,
-        slackContextCompactionWatermarkTs: preserveSourceCompactionState
+        contextSummary: inheritedCompaction?.summary ?? null,
+        contextCompactedMessageCount:
+          inheritedCompaction?.compactedMessageCount ?? 0,
+        contextCompactedAt: inheritedCompaction?.compactedAt ?? null,
+        slackContextCompactionWatermarkTs: inheritsLatestCompaction
           ? sourceConversation.slackContextCompactionWatermarkTs
           : null,
-        slackContextCompactionWatermarkAt: preserveSourceCompactionState
+        slackContextCompactionWatermarkAt: inheritsLatestCompaction
           ? sourceConversation.slackContextCompactionWatermarkAt
           : null,
         historyStrippedAt: inheritsHistoryStrippedAt
@@ -1039,8 +1049,8 @@ export function forkConversation(params: {
       forkedMessageIds,
       latestForkedAssistant,
       isFullHistoryFork: copyBoundaryIndex === sourceMessages.length - 1,
-      preserveSourceCompactionState,
-      visibleWindowStartIndex,
+      inheritedCompactedMessageCount:
+        inheritedCompaction?.compactedMessageCount ?? 0,
       diskSyncQueue,
     });
 
@@ -1073,8 +1083,13 @@ interface PopulateForkContentsArgs {
   latestForkedAssistant: { messageId: string; messageAt: number } | null;
   /** `copyBoundaryIndex === sourceMessages.length - 1` for the source. */
   isFullHistoryFork: boolean;
-  preserveSourceCompactionState: boolean;
-  visibleWindowStartIndex: number;
+  /**
+   * Count of leading messages behind the compaction event this fork inherits
+   * (0 when the fork branches from uncompacted history). Memory-slug seeding
+   * skips this prefix, since rows behind the fork's summary are not rendered
+   * and must stay re-injectable.
+   */
+  inheritedCompactedMessageCount: number;
   /**
    * When provided, a disk-sync entry is appended per copied message for the
    * caller to flush after commit. Omitted by the retrospective fork, whose
@@ -1106,8 +1121,7 @@ function populateForkContentsInProcess(args: PopulateForkContentsArgs): void {
     forkedMessageIds,
     latestForkedAssistant,
     isFullHistoryFork,
-    preserveSourceCompactionState,
-    visibleWindowStartIndex,
+    inheritedCompactedMessageCount,
     diskSyncQueue,
   } = args;
   const db = getDb();
@@ -1215,9 +1229,10 @@ function populateForkContentsInProcess(args: PopulateForkContentsArgs): void {
     // The v2 and v3 layers persist under separate metadata keys with the
     // same `# memory/concepts/<slug>.md` header convention, so each seeds
     // its own dedup record from its own blocks.
-    const visibleStartIndex = preserveSourceCompactionState
-      ? visibleWindowStartIndex
-      : 0;
+    const visibleStartIndex = Math.min(
+      inheritedCompactedMessageCount,
+      messagesToCopy.length,
+    );
     const inheritedSlugs = new Set<string>();
     const inheritedV3Slugs = new Set<string>();
     for (const message of messagesToCopy.slice(visibleStartIndex)) {
@@ -1253,6 +1268,15 @@ function populateForkContentsInProcess(args: PopulateForkContentsArgs): void {
     forkedMessageIds,
     lastCopiedSourceMessageId: messagesToCopy.at(-1)?.id ?? null,
   });
+
+  // Carry the source's compaction events that predate the fork boundary so the
+  // fork owns a correct ledger for its own future forks/compactions.
+  forkCompactionLedger(
+    db,
+    sourceConversationId,
+    fork.id,
+    messagesToCopy.at(-1)?.createdAt ?? null,
+  );
 }
 
 /**
@@ -1342,15 +1366,6 @@ export async function forkConversationForRetrospective(params: {
     sourceMessages,
     initialBoundaryIndex,
   );
-  const visibleWindowStartIndex = Math.max(
-    0,
-    Math.min(
-      sourceConversation.contextCompactedMessageCount,
-      sourceMessages.length,
-    ),
-  );
-  const preserveSourceCompactionState =
-    copyBoundaryIndex >= visibleWindowStartIndex;
   const messagesToCopy =
     copyBoundaryIndex >= 0
       ? sourceMessages.slice(0, copyBoundaryIndex + 1)
@@ -1362,6 +1377,17 @@ export async function forkConversationForRetrospective(params: {
     sourceHistoryStrippedAt != null &&
     boundaryMessageCreatedAt != null &&
     boundaryMessageCreatedAt >= sourceHistoryStrippedAt;
+  // Inherit the most recent compaction whose event time is at-or-before the
+  // forked-from message (see `forkConversation`).
+  const inheritedCompaction = getLatestCompactionEventAtOrBefore(
+    sourceConversation.id,
+    boundaryMessageCreatedAt,
+  );
+  // Carry the Slack watermark only when inheriting the latest compaction
+  // (see `forkConversation`).
+  const inheritsLatestCompaction =
+    inheritedCompaction != null &&
+    inheritedCompaction.compactedAt === sourceConversation.contextCompactedAt;
   const forkParentMessageId = messagesToCopy.at(-1)?.id ?? null;
   const forkTitle =
     params.title ?? `${sourceConversation.title ?? "Untitled"} (Fork)`;
@@ -1390,19 +1416,14 @@ export async function forkConversationForRetrospective(params: {
       .set({
         forkParentConversationId: sourceConversation.id,
         forkParentMessageId,
-        contextSummary: preserveSourceCompactionState
-          ? sourceConversation.contextSummary
-          : null,
-        contextCompactedMessageCount: preserveSourceCompactionState
-          ? sourceConversation.contextCompactedMessageCount
-          : 0,
-        contextCompactedAt: preserveSourceCompactionState
-          ? sourceConversation.contextCompactedAt
-          : null,
-        slackContextCompactionWatermarkTs: preserveSourceCompactionState
+        contextSummary: inheritedCompaction?.summary ?? null,
+        contextCompactedMessageCount:
+          inheritedCompaction?.compactedMessageCount ?? 0,
+        contextCompactedAt: inheritedCompaction?.compactedAt ?? null,
+        slackContextCompactionWatermarkTs: inheritsLatestCompaction
           ? sourceConversation.slackContextCompactionWatermarkTs
           : null,
-        slackContextCompactionWatermarkAt: preserveSourceCompactionState
+        slackContextCompactionWatermarkAt: inheritsLatestCompaction
           ? sourceConversation.slackContextCompactionWatermarkAt
           : null,
         historyStrippedAt: inheritsHistoryStrippedAt
@@ -1442,8 +1463,8 @@ export async function forkConversationForRetrospective(params: {
         forkedMessageIds,
         latestForkedAssistant,
         isFullHistoryFork: copyBoundaryIndex === sourceMessages.length - 1,
-        preserveSourceCompactionState,
-        visibleWindowStartIndex,
+        inheritedCompactedMessageCount:
+          inheritedCompaction?.compactedMessageCount ?? 0,
       });
     });
 
@@ -2114,15 +2135,27 @@ export function updateConversationContextWindow(
   contextCompactedMessageCount: number,
 ): void {
   const db = getDb();
-  db.update(conversations)
-    .set({
-      contextSummary,
-      contextCompactedMessageCount,
-      contextCompactedAt: Date.now(),
-      updatedAt: Date.now(),
-    })
-    .where(eq(conversations.id, id))
-    .run();
+  const now = Date.now();
+  // Update the hot-path cache columns and append the event to the ledger in a
+  // single transaction so the latest ledger event always matches the cache.
+  db.transaction(() => {
+    db.update(conversations)
+      .set({
+        contextSummary,
+        contextCompactedMessageCount,
+        contextCompactedAt: now,
+        updatedAt: now,
+      })
+      .where(eq(conversations.id, id))
+      .run();
+    if (contextCompactedMessageCount > 0) {
+      appendCompactionEvent(id, {
+        compactedAt: now,
+        summary: contextSummary,
+        compactedMessageCount: contextCompactedMessageCount,
+      });
+    }
+  });
 }
 
 export function setConversationHistoryStrippedAt(
@@ -2180,6 +2213,41 @@ export function unarchiveConversation(id: string): boolean {
   return true;
 }
 
+/**
+ * Persist the processing-start timestamp for a conversation. Called by
+ * `Conversation.setProcessing(true)` so out-of-process callers can detect
+ * mid-turn state by reading the `conversations` row directly. Pass `null`
+ * to clear (turn ended).
+ */
+export function setConversationProcessingStartedAt(
+  id: string,
+  startedAt: number | null,
+): void {
+  rawRun(
+    "UPDATE conversations SET processing_started_at = ? WHERE id = ?",
+    startedAt,
+    id,
+  );
+}
+
+/**
+ * Read whether a conversation is currently processing. Checks the in-memory
+ * `Conversation._processing` flag first (hot path for resident conversations),
+ * falling back to the persisted `processing_started_at` column for cold
+ * (evicted / never-loaded) conversations. This is the single entry point for
+ * processing state — callers don't need to layer `findConversation` themselves.
+ * Returns `false` when the conversation row doesn't exist.
+ */
+export function isConversationProcessing(id: string): boolean {
+  const inMemory = findConversation(id)?.isProcessing();
+  if (inMemory != null) return inMemory;
+  const row = rawGet<{ processing_started_at: number | null }>(
+    "SELECT processing_started_at FROM conversations WHERE id = ?",
+    id,
+  );
+  return row?.processing_started_at != null;
+}
+
 /**
  * Set or clear the `surfaced_at` promotion marker for a conversation.
  *

package/src/memory/db-connection.ts

@@ -8,6 +8,7 @@ import { drizzle } from "drizzle-orm/bun-sqlite";
 import { getLogsDbPath } from "../util/logs-db-path.js";
 import { getMemoryDbPath } from "../util/memory-db-path.js";
 import { ensureDataDir, getDbPath } from "../util/platform.js";
+import { getTelemetryDbPath } from "../util/telemetry-db-path.js";
 import { clearStoredDb, getStoredDb, setStoredDb } from "./db-singleton.js";
 import * as schema from "./schema.js";
 
@@ -136,7 +137,7 @@ export function getSqliteFrom(drizzleDb: DrizzleDb): Database {
  * path so this file stays import-light. Callers tolerate a `null` result.
  */
 function openDedicatedDb(
-  key: "logs" | "memory",
+  key: "logs" | "memory" | "telemetry",
   dbPath: string,
 ): DrizzleDb | null {
   assertTestDbIsIsolated();
@@ -192,11 +193,28 @@ export function getMemorySqlite(): Database | null {
   return db ? getSqliteFrom(db) : null;
 }
 
+/**
+ * The telemetry database (`assistant-telemetry.db`), opened lazily as its own
+ * connection. Houses telemetry event tables (starting with `watchdog_events`).
+ * Returns `null` if the file cannot be opened (logged; the daemon stays up).
+ */
+export function getTelemetryDb(): DrizzleDb | null {
+  const existing = getStoredDb<DrizzleDb>("telemetry");
+  if (existing) return existing;
+  return openDedicatedDb("telemetry", getTelemetryDbPath());
+}
+
+/** Underlying bun:sqlite Database for the telemetry connection, or `null`. */
+export function getTelemetrySqlite(): Database | null {
+  const db = getTelemetryDb();
+  return db ? getSqliteFrom(db) : null;
+}
+
 /**
  * Reset all DB singletons. Used by production callers that need to close the
  * live connections so the files can be replaced (post-migration, post-restore,
- * post-vbundle-import) and on graceful shutdown. Clears the main, logs, and
- * memory slots together so none lingers open against a swapped-out file.
+ * post-vbundle-import) and on graceful shutdown. Clears the main, logs, memory,
+ * and telemetry slots together so none lingers open against a swapped-out file.
  *
  * Tests should use `resetDbForTesting()` from
  * `__tests__/db-test-helpers.ts` instead so they don't depend on this
@@ -206,4 +224,5 @@ export function resetDb(): void {
   clearStoredDb("main");
   clearStoredDb("logs");
   clearStoredDb("memory");
+  clearStoredDb("telemetry");
 }