@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292116.41f7caa

package/src/daemon/lifecycle.ts

@@ -13,6 +13,7 @@ import {
 } from "../config/loader.js";
 import { seedInferenceProfiles } from "../config/seed-inference-profiles.js";
 import { reconcileFlagGatedProfiles } from "../config/sync-gated-profiles.js";
+import { startConversationAutoArchive } from "../conversations/auto-archive.js";
 import { startCes } from "../credential-execution/ces-runtime.js";
 import { refreshManagedConnectionCache } from "../credential-execution/managed-catalog.js";
 import { startHeartbeatService } from "../heartbeat/heartbeat-service.js";
@@ -57,6 +58,7 @@ import { startScheduler } from "../schedule/scheduler.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { startUsageTelemetryReporter } from "../telemetry/usage-telemetry-reporter.js";
 import { getLogger, initLogger } from "../util/logger.js";
+import { DAEMON_OOM_SCORE_ADJ, setOomScoreAdj } from "../util/oom-priority.js";
 import {
   ensureDataDir,
   getDotEnvPath,
@@ -114,6 +116,9 @@ export async function runDaemon(): Promise<void> {
   // the event hub real clients subscribe to, so plugin-facing publishes made
   // here fan out locally rather than routing to a daemon over IPC.
   markCurrentProcessAsMainDaemon();
+  // Before the first spawn: every child inherits this value and resets its
+  // own, so the kernel OOM killer takes a tool or worker before the daemon.
+  const oomProtected = setOomScoreAdj(DAEMON_OOM_SCORE_ADJ);
 
   const startupStartedAt = Date.now();
   // dotenv loads before the first log call so the lazy root logger
@@ -121,7 +126,13 @@ export async function runDaemon(): Promise<void> {
   // whatever was in the live environment at process spawn.
   loadDotEnv();
   validateEnv();
-  log.info({ version: APP_VERSION }, "Daemon starting");
+  log.info(
+    {
+      version: APP_VERSION,
+      oomScoreAdj: oomProtected ? DAEMON_OOM_SCORE_ADJ : undefined,
+    },
+    "Daemon starting",
+  );
 
   // Signal handlers install before any blocking startup work — a boot that
   // inherits a large WAL can spend minutes inside `initializeDb()`, and
@@ -860,13 +871,15 @@ export async function runDaemon(): Promise<void> {
   // CES, which the startup sequence above just brought up. Fire-and-forget:
   // the resumes run sequentially in the background while the daemon serves
   // requests; per-conversation failures are logged inside.
+  let startupRecovery = Promise.resolve();
   if (conversationsToResume.length > 0) {
     log.info(
       { count: conversationsToResume.length },
       "Resuming conversations interrupted by the previous process",
     );
-    void resumeInterruptedConversations(conversationsToResume);
+    startupRecovery = resumeInterruptedConversations(conversationsToResume);
   }
+  startConversationAutoArchive(startupRecovery);
 
   log.info(
     {

package/src/daemon/process-message.ts

@@ -19,6 +19,7 @@ import {
   parseChannelId,
   parseInterfaceId,
 } from "../channels/types.js";
+import type { SupportedLocale } from "../i18n/index.js";
 import { resolveAttachmentsForPersist } from "../persistence/attachments-store.js";
 import {
   addMessage,
@@ -88,6 +89,8 @@ type ProcessMessageOptions = ConversationCreateOptions & {
   sourceChannel?: string;
   /** Originating interface (e.g. "cli", "web"). Defaults to "web". */
   sourceInterface?: string;
+  /** Locale for daemon-authored text emitted during this turn. */
+  locale?: SupportedLocale;
   /**
    * Origin tag of the turn (the conversation's `TitleOrigin`, e.g.
    * "memory_consolidation"), threaded from `runBackgroundJob`. Propagated
@@ -780,6 +783,7 @@ export async function processMessage(
       onEvent: emitEvent,
       isInteractive: options?.isInteractive ?? false,
       isUserMessage: true,
+      locale: options?.locale,
       ...(options?.callSite ? { callSite: options.callSite } : {}),
       ...(options?.overrideProfile
         ? { overrideProfile: options.overrideProfile }
@@ -854,6 +858,7 @@ export async function processMessageInBackground(
       onEvent: emitEvent,
       isInteractive: options?.isInteractive ?? false,
       isUserMessage: true,
+      locale: options?.locale,
       ...(options?.callSite ? { callSite: options.callSite } : {}),
       ...(options?.overrideProfile
         ? { overrideProfile: options.overrideProfile }

package/src/daemon/shutdown-handlers.ts

@@ -1,4 +1,5 @@
 import { disposeAcpSessionManager } from "../acp/index.js";
+import { stopConversationAutoArchive } from "../conversations/auto-archive.js";
 import { stopCes } from "../credential-execution/ces-runtime.js";
 import { stopHeartbeatService } from "../heartbeat/heartbeat-service.js";
 import { stopCliIpcServer } from "../ipc/assistant-server.js";
@@ -43,6 +44,7 @@ const log = getLogger("lifecycle");
  * leaves a stale PID file or orphaned timers behind.
  */
 function stopBackgroundServicesAndCleanupPidFile(): void {
+  stopConversationAutoArchive();
   stopGatewayFlagListener();
   stopDiskPressureGuardForLifecycle();
   stopResourcePressureGuardForLifecycle();
@@ -63,6 +65,7 @@ async function shutdown(): Promise<void> {
     return;
   }
   shuttingDown = true;
+  stopConversationAutoArchive();
 
   // Force exit if graceful shutdown takes too long.
   // Set this BEFORE awaiting heartbeat stop so it covers all

package/src/daemon/turn-finalization.ts

@@ -23,6 +23,10 @@ const pendingFinalizations = new Map<
   { promise: Promise<void>; settle: () => void }
 >();
 
+export function hasPendingTurnFinalization(conversationId: string): boolean {
+  return pendingFinalizations.has(conversationId);
+}
+
 /**
  * Open the barrier for a turn that is starting. Returns the closer, which the
  * turn calls once everything the next turn must not overlap with is done.

package/src/desktop/desktop-browser-endpoint.ts

@@ -2,9 +2,14 @@ import { readdir, readFile, readlink, realpath } from "node:fs/promises";
 import { createServer } from "node:net";
 import { join } from "node:path";
 
+import { z } from "zod";
+
 import { shouldRestoreDesktopChromeSession } from "./desktop-chrome-session.js";
 
 export const DESKTOP_CHROME_WINDOW_CLASS = "vellum-desktop-chrome";
+const DesktopVersionResponseSchema = z.object({
+  webSocketDebuggerUrl: z.unknown().optional(),
+});
 
 export async function allocateDesktopDebugPort(): Promise<number> {
   const server = createServer();
@@ -119,9 +124,12 @@ export async function discoverDesktopBrowser(
   if (body.length > 16_384) {
     throw new Error("Desktop browser discovery exceeded its size limit");
   }
-  const data = JSON.parse(body) as { webSocketDebuggerUrl?: unknown };
+  const parsed = DesktopVersionResponseSchema.safeParse(JSON.parse(body));
   await assertDesktopListener(pid, port);
-  return validateDesktopWebSocket(data.webSocketDebuggerUrl, port);
+  return validateDesktopWebSocket(
+    parsed.success ? parsed.data.webSocketDebuggerUrl : undefined,
+    port,
+  );
 }
 
 export function desktopChromeArguments(
@@ -134,6 +142,7 @@ export function desktopChromeArguments(
     `--class=${DESKTOP_CHROME_WINDOW_CLASS}`,
     "--force-renderer-accessibility",
     "--disable-dev-shm-usage",
+    `--disk-cache-size=${250 * 1024 * 1024}`,
     "--disable-features=Prerender2",
     ...(shouldRestoreDesktopChromeSession(profileDir)
       ? ["--restore-last-session", "--hide-crash-restore-bubble"]

package/src/desktop/desktop-chrome-policy.test.ts

@@ -35,6 +35,7 @@ test("preserves unrelated policies and does not rewrite on repeated startup", ()
     path,
     JSON.stringify({
       CommandLineFlagSecurityWarningsEnabled: false,
+      PasswordManagerEnabled: false,
       DownloadRestrictions: 1,
     }),
   );

package/src/desktop/desktop-chrome-policy.ts

@@ -23,16 +23,22 @@ export function writeDesktopChromePolicy(policyDir: string): void {
     }
   }
   if (
+    policy.NetworkPredictionOptions === 2 &&
     policy.CommandLineFlagSecurityWarningsEnabled === false &&
-    policy.PasswordManagerEnabled === false
+    policy.PasswordManagerEnabled === false &&
+    policy.HighEfficiencyModeEnabled === true &&
+    policy.MemorySaverModeSavings === 1
   ) {
     return;
   }
 
+  policy.NetworkPredictionOptions = 2;
   // This suppresses command-line warnings; Chrome's sandbox stays unchanged.
   policy.CommandLineFlagSecurityWarningsEnabled = false;
   // Suppress save prompts while keeping previously saved passwords usable.
   policy.PasswordManagerEnabled = false;
+  policy.HighEfficiencyModeEnabled = true;
+  policy.MemorySaverModeSavings = 1;
   mkdirSync(policyDir, { recursive: true });
   const staging = mkdtempSync(join(policyDir, ".vellum-desktop-"));
   try {

package/src/desktop/desktop-computer-use.test.ts

@@ -1,5 +1,7 @@
 import { describe, expect, mock, spyOn, test } from "bun:test";
 
+import sharp from "sharp";
+
 import { run as click } from "../config/bundled-skills/computer-use/tools/computer-use-click.js";
 import * as configLoader from "../config/loader.js";
 import { HostCuProxy } from "../daemon/host-cu-proxy.js";
@@ -14,12 +16,20 @@ import {
 } from "./desktop-computer-use.js";
 import * as sessionManager from "./desktop-session-manager.js";
 
+const SCREENSHOT = (
+  await sharp({
+    create: { width: 1440, height: 810, channels: 3, background: "white" },
+  })
+    .jpeg()
+    .toBuffer()
+).toString("base64");
+
 function driver(userGuidance?: string) {
   return {
     input: mock(async (_args: string[], _signal?: AbortSignal) => {}),
     capture: mock(async (_signal: AbortSignal) => ({
       userGuidance,
-      screenshot: "anBlZw==",
+      screenshot: SCREENSHOT,
       screenshotWidthPx: 1440,
       screenshotHeightPx: 810,
       screenWidthPt: 1440,
@@ -52,7 +62,7 @@ describe("virtual desktop computer use", () => {
         signal(),
         backend,
       );
-      expect(result.screenshot).toBe("anBlZw==");
+      expect(result.screenshot).toBe(SCREENSHOT);
     }
     expect(backend.input).not.toHaveBeenCalled();
     expect(backend.capture).toHaveBeenCalledTimes(2);
@@ -161,7 +171,7 @@ describe("virtual desktop computer use", () => {
     );
     expect(backend.input).toHaveBeenCalledTimes(1);
     expect(result.executionError).toBe("Input failed");
-    expect(result.screenshot).toBe("anBlZw==");
+    expect(result.screenshot).toBe(SCREENSHOT);
   });
 
   test("done releases only its conversation without starting the desktop", async () => {
@@ -316,7 +326,7 @@ describe("virtual desktop computer use", () => {
         source: {
           type: "base64",
           media_type: "image/jpeg",
-          data: "anBlZw==",
+          data: SCREENSHOT,
         },
       },
     ]);

package/src/desktop/desktop-session-manager.ts

@@ -15,6 +15,7 @@ import { getIsContainerized } from "../config/env-registry.js";
 import { connectCdpWsTransport } from "../tools/browser/cdp-client/cdp-inspect/ws-transport.js";
 import { terminateProcessTree } from "../util/host-process.js";
 import { getLogger } from "../util/logger.js";
+import { CHILD_OOM_SCORE_ADJ, withOomScoreAdj } from "../util/oom-priority.js";
 import { getDataDir, getWorkspaceDir } from "../util/platform.js";
 import { sleep } from "../util/retry.js";
 import { DesktopBrowserClient } from "./desktop-browser-client.js";
@@ -46,7 +47,7 @@ const log = getLogger("desktop-session");
 
 export const DESKTOP_VNC_PORT = 5999;
 const DESKTOP_GEOMETRY = `${DESKTOP_WIDTH}x${DESKTOP_HEIGHT}`;
-const DESKTOP_LINGER_MS = 24 * 60 * 60_000;
+const DESKTOP_LINGER_MS = 8 * 60 * 60_000;
 const VNC_READY_DEADLINE_MS = 10_000;
 const VNC_PROBE_INTERVAL_MS = 100;
 const KILL_GRACE_MS = 2_000;
@@ -928,8 +929,9 @@ function spawnDetached(
   request: DesktopSpawnRequest,
 ): DesktopChild {
   // Each child leads its own process group so teardown can kill everything
-  // it forked (Chrome's renderers, openbox's autostart) in one signal.
-  return Bun.spawn([...request.cmd], {
+  // it forked (Chrome's renderers, openbox's autostart) in one signal. The
+  // OOM wrapper execs in place, so pid and process group are unchanged.
+  return Bun.spawn(withOomScoreAdj(request.cmd, CHILD_OOM_SCORE_ADJ), {
     env: request.env,
     detached: true,
     stdio: ["ignore", "ignore", "ignore"],

package/src/documents/document-revisions-store.ts

@@ -0,0 +1,153 @@
+/**
+ * Document revision history: snapshots of a document's title and body as they
+ * stood at a revision, taken just before a write replaces that state.
+ *
+ * Snapshot writes run inside the caller's transaction, next to the document
+ * write they precede, so a snapshot exists exactly when its write landed.
+ */
+import { rawAll, rawGet, rawRun } from "../persistence/raw-query.js";
+
+/** Who made the write a snapshot was taken ahead of. */
+export type DocumentRevisionAuthor = "user" | "assistant";
+
+/** Snapshots kept per document; older ones are pruned on each insert. */
+export const MAX_REVISIONS_PER_DOCUMENT = 100;
+
+/**
+ * A user save snapshots the prior state at most this often per document,
+ * unless the latest snapshot preceded an assistant edit.
+ */
+export const USER_SNAPSHOT_INTERVAL_MS = 10 * 60 * 1000;
+
+export interface DocumentRevisionSummary {
+  revision: number;
+  author: DocumentRevisionAuthor;
+  createdAt: number;
+  wordCount: number;
+  title: string;
+}
+
+export interface DocumentRevisionRecord extends DocumentRevisionSummary {
+  content: string;
+}
+
+/** The document state a snapshot preserves. */
+export interface DocumentSnapshotSource {
+  surfaceId: string;
+  revision: number;
+  title: string;
+  content: string;
+  wordCount: number;
+}
+
+interface RevisionRow {
+  revision: number;
+  author: DocumentRevisionAuthor;
+  created_at: number;
+  word_count: number;
+  title: string;
+  content: string;
+}
+
+function mapRowToSummary(
+  row: Omit<RevisionRow, "content">,
+): DocumentRevisionSummary {
+  return {
+    revision: row.revision,
+    author: row.author,
+    createdAt: row.created_at,
+    wordCount: row.word_count,
+    title: row.title,
+  };
+}
+
+/**
+ * Store `state` as the snapshot for its revision and prune the document's
+ * history to the newest {@link MAX_REVISIONS_PER_DOCUMENT}. A revision that is
+ * already snapshotted keeps its first snapshot.
+ */
+export function recordDocumentSnapshot(
+  state: DocumentSnapshotSource,
+  author: DocumentRevisionAuthor,
+): void {
+  rawRun(
+    "documentRevisions:record",
+    /*sql*/ `INSERT OR IGNORE INTO document_revisions (surface_id, revision, title, content, word_count, author, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    state.surfaceId,
+    state.revision,
+    state.title,
+    state.content,
+    state.wordCount,
+    author,
+    Date.now(),
+  );
+  rawRun(
+    "documentRevisions:prune",
+    /*sql*/ `DELETE FROM document_revisions
+     WHERE surface_id = ?
+       AND revision NOT IN (
+         SELECT revision FROM document_revisions
+         WHERE surface_id = ?
+         ORDER BY revision DESC
+         LIMIT ?
+       )`,
+    state.surfaceId,
+    state.surfaceId,
+    MAX_REVISIONS_PER_DOCUMENT,
+  );
+}
+
+/**
+ * Whether a user save should snapshot the state it replaces: when the document
+ * has no snapshot yet, when the latest one is older than
+ * {@link USER_SNAPSHOT_INTERVAL_MS}, or when the latest one preceded an
+ * assistant edit, so the assistant's result survives the user's next edits.
+ */
+export function shouldSnapshotBeforeUserSave(surfaceId: string): boolean {
+  const latest = rawGet<{ author: string; created_at: number }>(
+    "documentRevisions:latest",
+    /*sql*/ `SELECT author, created_at FROM document_revisions
+     WHERE surface_id = ?
+     ORDER BY revision DESC
+     LIMIT 1`,
+    surfaceId,
+  );
+  if (!latest) {
+    return true;
+  }
+  return (
+    latest.author === "assistant" ||
+    Date.now() - latest.created_at >= USER_SNAPSHOT_INTERVAL_MS
+  );
+}
+
+/** A document's snapshots, newest first, without their bodies. */
+export function listDocumentRevisions(
+  surfaceId: string,
+): DocumentRevisionSummary[] {
+  return rawAll<Omit<RevisionRow, "content">>(
+    "documentRevisions:list",
+    /*sql*/ `SELECT revision, author, created_at, word_count, title
+     FROM document_revisions
+     WHERE surface_id = ?
+     ORDER BY revision DESC`,
+    surfaceId,
+  ).map(mapRowToSummary);
+}
+
+/** One snapshot with its body, or `null` when it does not exist. */
+export function getDocumentRevision(
+  surfaceId: string,
+  revision: number,
+): DocumentRevisionRecord | null {
+  const row = rawGet<RevisionRow>(
+    "documentRevisions:get",
+    /*sql*/ `SELECT revision, author, created_at, word_count, title, content
+     FROM document_revisions
+     WHERE surface_id = ? AND revision = ?`,
+    surfaceId,
+    revision,
+  );
+  return row ? { ...mapRowToSummary(row), content: row.content } : null;
+}