@vellumai/assistant 0.8.11 → 0.8.12-staging.1

package/src/__tests__/workspace-release-notes-feature-flag-guard.test.ts

@@ -1,37 +1,29 @@
-import { readdirSync, readFileSync } from "node:fs";
+import { readdirSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
-type Registry = {
-  flags: Array<{
-    key: string;
-    scope: string;
-    defaultEnabled: boolean;
-  }>;
-};
-
-const LEGACY_FLAGGED_RELEASE_NOTE_ALLOWLIST = new Map<string, string>([
-  [
-    "045-release-notes-meet-avatar.ts",
-    "Historical bulletin that already shipped before this guard existed.",
-  ],
-]);
-
-const FLAGGED_FEATURE_LANGUAGE_PATTERNS: Array<{
-  label: string;
-  pattern: RegExp;
-}> = [
-  { label: "feature flag", pattern: /\bfeature[- ]flag(?:ged)?\b/i },
-  { label: "rollout flag", pattern: /\brollout flag\b/i },
-  { label: "behind ... flag", pattern: /\bbehind\b[^\n.]{0,120}\bflag\b/i },
-  { label: "gated on", pattern: /\bgated on\b/i },
-  { label: "when enabled", pattern: /\bwhen enabled\b/i },
+/**
+ * The historical release-note workspace migrations. These appended bulletins
+ * to `<workspace>/UPDATES.md`, which a background job processed at daemon
+ * startup. That job has been removed — nothing consumes UPDATES.md release
+ * notes anymore — so the set below is frozen. Migration files themselves are
+ * append-only and must never be deleted (see the migrations AGENTS.md), but
+ * no new ones of this shape may be added.
+ */
+const FROZEN_RELEASE_NOTE_MIGRATIONS = [
+  "043-release-notes-latex-rendering.ts",
+  "045-release-notes-meet-avatar.ts",
+  "049-release-notes-default-sonnet.ts",
+  "053-release-notes-acp-codex.ts",
+  "055-release-notes-agentic-recall.ts",
+  "056-release-notes-inference-profile-reordering.ts",
+  "058-release-notes-acp-sessions-ui.ts",
+  "063-release-notes-dynamic-model-context.ts",
+  "067-release-notes-safe-storage-limits.ts",
+  "068-release-notes-local-timezone.ts",
+  "078-release-notes-tavily-web-search.ts",
 ];
 
-function getRepoRoot(): string {
-  return join(process.cwd(), "..");
-}
-
 function getReleaseNoteMigrationFiles(): string[] {
   const migrationsDir = join(process.cwd(), "src", "workspace", "migrations");
   return readdirSync(migrationsDir)
@@ -39,77 +31,35 @@ function getReleaseNoteMigrationFiles(): string[] {
     .sort();
 }
 
-function loadDefaultDisabledAssistantFlagKeys(): string[] {
-  const registryPath = join(
-    getRepoRoot(),
-    "meta",
-    "feature-flags",
-    "feature-flag-registry.json",
-  );
-  const registry = JSON.parse(readFileSync(registryPath, "utf-8")) as Registry;
-  return registry.flags
-    .filter((flag) => flag.scope === "assistant" && !flag.defaultEnabled)
-    .map((flag) => flag.key)
-    .sort();
-}
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function featureFlagKeyPattern(key: string): RegExp {
-  const escaped = escapeRegExp(key);
-  if (key.includes("-")) {
-    return new RegExp(`(?:^|[^a-z0-9-])${escaped}(?:$|[^a-z0-9-])`, "i");
-  }
-
-  return new RegExp("[`'\"]" + escaped + "[`'\"]", "i");
-}
+describe("workspace release-note migrations guard", () => {
+  test("no new release-note migrations are added", () => {
+    const found = getReleaseNoteMigrationFiles();
+    const newMigrations = found.filter(
+      (fileName) => !FROZEN_RELEASE_NOTE_MIGRATIONS.includes(fileName),
+    );
 
-describe("workspace release-note migrations feature flag guard", () => {
-  test("new release-note migrations do not announce default-disabled feature-flagged work", () => {
-    const migrationsDir = join(process.cwd(), "src", "workspace", "migrations");
-    const defaultDisabledFlagKeys = loadDefaultDisabledAssistantFlagKeys();
-    const violations: string[] = [];
-
-    for (const fileName of getReleaseNoteMigrationFiles()) {
-      if (LEGACY_FLAGGED_RELEASE_NOTE_ALLOWLIST.has(fileName)) {
-        continue;
-      }
-
-      const content = readFileSync(join(migrationsDir, fileName), "utf-8");
-
-      for (const { label, pattern } of FLAGGED_FEATURE_LANGUAGE_PATTERNS) {
-        if (pattern.test(content)) {
-          violations.push(
-            `${fileName}: contains flagged-feature language "${label}"`,
-          );
-        }
-      }
-
-      for (const key of defaultDisabledFlagKeys) {
-        if (featureFlagKeyPattern(key).test(content)) {
-          violations.push(
-            `${fileName}: references default-disabled assistant feature flag "${key}"`,
-          );
-        }
-      }
-    }
-
-    if (violations.length > 0) {
+    if (newMigrations.length > 0) {
       const message = [
-        "Release-note migrations write to UPDATES.md, which is processed without checking feature flags.",
-        "Do not announce features that are still behind default-disabled assistant flags or rollout flags.",
-        "Wait until GA and add a new append-only release-note migration with a new marker.",
-        "",
-        "Violations:",
-        ...violations.map((violation) => `  - ${violation}`),
+        "Release-note migrations append to <workspace>/UPDATES.md, but the",
+        "background job that processed that file has been removed — nothing",
+        "consumes release notes written there. Do not add new release-note",
+        "migrations until a replacement surfacing mechanism is designed.",
         "",
-        "If this is an already-shipped historical bulletin, add a narrow entry to",
-        "LEGACY_FLAGGED_RELEASE_NOTE_ALLOWLIST in workspace-release-notes-feature-flag-guard.test.ts.",
+        "New release-note migrations found:",
+        ...newMigrations.map((fileName) => `  - ${fileName}`),
       ].join("\n");
 
-      expect(violations, message).toEqual([]);
+      expect(newMigrations, message).toEqual([]);
+    }
+  });
+
+  test("frozen release-note migrations are never deleted", () => {
+    // Migrations are append-only: even though their bulletins are no longer
+    // processed, deleting an entry breaks the sequential migration chain on
+    // existing installs.
+    const found = getReleaseNoteMigrationFiles();
+    for (const fileName of FROZEN_RELEASE_NOTE_MIGRATIONS) {
+      expect(found).toContain(fileName);
     }
   });
 });

package/src/agent/loop.ts

@@ -11,6 +11,7 @@ import {
   estimateToolsTokens,
   getCalibrationProviderKey,
 } from "../context/token-estimator.js";
+import { spoolAndStubOversizedToolResults } from "../context/tool-result-spool.js";
 import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import { parseActualTokensFromError } from "../daemon/parse-actual-tokens-from-error.js";
 import type { TrustContext } from "../daemon/trust-context.js";
@@ -298,25 +299,27 @@ export type AgentEvent =
       /** The running history before injection stripping and compaction. */
       messages: Message[];
     }
-  | {
+  | ({
       /**
        * Emitted after the loop's inline mid-loop compaction pipeline runs,
        * immediately before re-injection — whether or not the pipeline actually
-       * compacted. The daemon's event dispatcher always commits `messages` (the
-       * stripped pre-compaction history) as the conversation's durable message
-       * state, so re-injection (the post-compaction hook) re-applies
-       * injections onto the stripped base rather than stacking on top of the
-       * still-injected messages. When `result.compacted` is set it
-       * additionally commits the durable compaction result (DB-record fields,
-       * graph-memory side effects, SSE) and flips the per-turn re-injection
-       * guards on the handler state.
+       * compacted. Carries the pipeline's `ContextWindowResult` unnested into
+       * the event, so `messages` here is the pipeline's output history. The
+       * pre-compaction history lives on the paired `context_compacting` start
+       * event (correlated by `compactionId`); consumers that need the
+       * stripped pre-compaction base re-derive it from the start event via
+       * `stripInjectionsForCompaction`.
+       *
+       * The daemon's event dispatcher commits the stripped pre-compaction
+       * base as the conversation's durable message state, so re-injection
+       * (the post-compaction hook) re-applies injections onto the stripped
+       * base rather than stacking on top of the still-injected messages.
+       * When `compacted` is set it additionally commits the durable
+       * compaction result (DB-record fields, graph-memory side effects, SSE)
+       * and projects Slack provenance from the pre-compaction base.
        *
        * Treated as a critical event: a failed durable commit re-throws so the
        * turn aborts rather than re-injecting against half-applied state.
-       *
-       * `messages` is the stripped pre-compaction history the summary was
-       * built from; the dispatcher uses it to project Slack provenance onto
-       * the compacted result.
        */
       type: "compaction_completed";
       /** Correlates this end event with its `context_compacting` pair. */
@@ -330,9 +333,7 @@ export type AgentEvent =
       startedAt: number;
       /** Epoch ms when the compaction pipeline returned. */
       finishedAt: number;
-      result: ContextWindowResult;
-      messages: Message[];
-    }
+    } & ContextWindowResult)
   | {
       /**
        * Emitted right after the loop strips runtime injections from the
@@ -595,6 +596,16 @@ export interface AgentLoopConstructorOptions {
    * post-compaction re-injection resolve the live conversation through.
    */
   conversationId: string;
+  /**
+   * Resolve the conversation's on-disk directory, used to spool oversized
+   * tool results to `.tool-results/` and swap the inline copy for the
+   * post-turn pass's stub at result time — before the result joins history,
+   * so the provider-bound prefix stays append-only for prompt caching.
+   * Returns `null` while the directory cannot be resolved (e.g. the
+   * conversation row is not yet persisted); the loop then skips the
+   * result-time pass and the post-turn truncation covers the turn instead.
+   */
+  resolveConversationDir?: () => string | null;
 }
 
 export class AgentLoop {
@@ -616,6 +627,9 @@ export class AgentLoop {
    */
   private readonly conversationId: string;
 
+  /** See {@link AgentLoopConstructorOptions.resolveConversationDir}. */
+  private readonly resolveConversationDir: (() => string | null) | null;
+
   /**
    * Loop-held compaction circuit breaker. The loop has a 1:1 lifetime with its
    * conversation, so it is the source of truth for the cross-turn failure
@@ -635,6 +649,7 @@ export class AgentLoop {
       resolveTools,
       resolveSystemPrompt,
       conversationId,
+      resolveConversationDir,
     } = options;
     this.provider = provider;
     this.systemPrompt = systemPrompt;
@@ -644,6 +659,7 @@ export class AgentLoop {
     this.resolveSystemPrompt = resolveSystemPrompt ?? null;
     this.toolExecutor = toolExecutor ?? null;
     this.conversationId = conversationId;
+    this.resolveConversationDir = resolveConversationDir ?? null;
     this.compactionCircuit = new CompactionCircuit(this.conversationId);
   }
 
@@ -782,10 +798,10 @@ export class AgentLoop {
         onEvent,
       );
     }
-    // Emit unconditionally: the dispatcher commits the stripped `messages` as the
-    // durable message base whether or not the pipeline compacted (re-injection
-    // reads it), and runs the durable compaction commit only when
-    // `result.compacted`.
+    // Emit unconditionally: the dispatcher commits the stripped pre-compaction
+    // base (re-derived from the start event) as the durable message base
+    // whether or not the pipeline compacted (re-injection reads it), and runs
+    // the durable compaction commit only when `compacted`.
     await onEvent({
       type: "compaction_completed",
       compactionId,
@@ -793,8 +809,7 @@ export class AgentLoop {
       trigger,
       startedAt,
       finishedAt: Date.now(),
-      result: compactResult,
-      messages: rawHistory,
+      ...compactResult,
     });
     const exhausted = compactResult.exhausted ?? false;
     const autoCompressApplied = compactResult.autoCompressApplied ?? false;
@@ -886,6 +901,19 @@ export class AgentLoop {
     let overflowAutoCompressApplied = false;
     const rlog = log.child({ requestId });
 
+    // Conversation directory for the result-time tool-result spool/stub pass.
+    // Resolved once per run; `null` disables the pass for this run and the
+    // post-turn truncation covers the turn instead.
+    let conversationDir: string | null = null;
+    try {
+      conversationDir = this.resolveConversationDir?.() ?? null;
+    } catch (err) {
+      rlog.warn(
+        { err },
+        "Resolving conversation dir for tool-result spooling failed (non-fatal)",
+      );
+    }
+
     // Resolve the inference-profile override that applies right now. The
     // optional resolver lets a turn observe a confirmed mid-turn profile switch
     // before the next model call; absent a resolver the turn-start value holds.
@@ -1724,11 +1752,39 @@ export class AgentLoop {
           }),
         );
 
+        // Spool oversized results to `.tool-results/` and swap the inline
+        // copy for the post-turn pass's stub now — on the raw blocks, before
+        // the post-tool-use hooks, event emission, and history append. Running
+        // ahead of the hooks means the spooled file holds the tool's full
+        // output rather than the truncate plugin's tail-dropped copy, and the
+        // hooks then see the stub. Stubbing before the first send keeps the
+        // provider-bound history strictly append-only (rewriting an earlier
+        // message between calls would invalidate the prompt-cache prefix on
+        // every iteration).
+        if (conversationDir) {
+          const toolNameByUseId = new Map(
+            toolUseBlocks.map((tu) => [tu.id, tu.name]),
+          );
+          try {
+            spoolAndStubOversizedToolResults(rawResultBlocks, {
+              conversationDir,
+              toolNameById: (id) => toolNameByUseId.get(id),
+            });
+          } catch (err) {
+            rlog.warn(
+              { err, turn: toolUseTurns },
+              "Spooling oversized tool results to disk failed (non-fatal)",
+            );
+          }
+        }
+
         // Run the `post-tool-use` hook once per tool result, after the tool
         // returns and before the result joins the provider-bound history.
         // The default tool-result-truncate plugin tail-drops oversized output
-        // to fit the context window; user hooks can swap in a smarter strategy
-        // (e.g. a summariser) or observe results for side effects.
+        // to fit the context window (spool-stubbed results are already tiny;
+        // spool-exempt ones still rely on it); user hooks can swap in a
+        // smarter strategy (e.g. a summariser) or observe results for side
+        // effects.
         const contextWindowTokens =
           resolveContextWindow?.().maxInputTokens ??
           this.config.maxInputTokens ??
@@ -1746,6 +1802,7 @@ export class AgentLoop {
             toolResponse: block as ToolResultContent,
             messages: history,
             additionalContext: null,
+            model: response.model,
             maxInputTokens: contextWindowTokens,
             logger: rlog,
           };

package/src/api/events/usage-progress.ts

@@ -0,0 +1,28 @@
+/**
+ * `usage_progress` SSE event.
+ *
+ * Emitted after each LLM call with per-call token deltas and estimated
+ * cost. Clients accumulate these additively for live-updating usage
+ * metrics (e.g. inline subagent token counters). A UI-only hint — it
+ * does not persist to the DB or affect billing.
+ *
+ * Unlike `usage_update`, which carries the conversation's running
+ * totals, this event carries only the deltas for a single LLM call.
+ *
+ * Canonical wire-contract source. Daemon code imports the type
+ * directly from this file; external consumers import via
+ * `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+export const UsageProgressEventSchema = z.object({
+  type: z.literal("usage_progress"),
+  conversationId: z.string(),
+  inputTokens: z.number(),
+  outputTokens: z.number(),
+  estimatedCost: z.number(),
+  model: z.string(),
+});
+
+export type UsageProgressEvent = z.infer<typeof UsageProgressEventSchema>;

package/src/api/index.ts

@@ -49,6 +49,7 @@ import { UISurfaceCompleteEventSchema } from "./events/ui-surface-complete.js";
 import { UISurfaceDismissEventSchema } from "./events/ui-surface-dismiss.js";
 import { UISurfaceShowEventSchema } from "./events/ui-surface-show.js";
 import { UISurfaceUpdateEventSchema } from "./events/ui-surface-update.js";
+import { UsageProgressEventSchema } from "./events/usage-progress.js";
 import { UsageUpdateEventSchema } from "./events/usage-update.js";
 import { UserMessageEchoEventSchema } from "./events/user-message-echo.js";
 
@@ -310,6 +311,10 @@ export {
   type UISurfaceUpdateEvent,
   UISurfaceUpdateEventSchema,
 } from "./events/ui-surface-update.js";
+export {
+  type UsageProgressEvent,
+  UsageProgressEventSchema,
+} from "./events/usage-progress.js";
 export {
   type UsageUpdateEvent,
   UsageUpdateEventSchema,
@@ -497,6 +502,7 @@ export const AssistantEventSchema = z.discriminatedUnion("type", [
   UISurfaceDismissEventSchema,
   UISurfaceShowEventSchema,
   UISurfaceUpdateEventSchema,
+  UsageProgressEventSchema,
   UsageUpdateEventSchema,
   UserMessageEchoEventSchema,
 ]);

package/src/background-wake/wake-intent-hooks.test.ts

@@ -52,6 +52,8 @@ mock.module("../util/platform.js", () => ({
   getWorkspaceRoutesDir: () => workspacePath("routes"),
   vellumRoot: () => testWorkspaceDir,
   getDataDir: () => workspacePath("data"),
+  getConfigQuarantineNoticePath: () =>
+    workspacePath("data", "config-quarantine-notice.json"),
   getDbPath: () => workspacePath("data", "db", "assistant.db"),
   ensureDataDir: () => {
     mkdirSync(workspacePath("data", "db"), { recursive: true });

package/src/bundler/app-bundler.ts

@@ -6,12 +6,11 @@
  */
 
 import { createHash } from "node:crypto";
-import { createWriteStream, existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { readFile, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import archiver from "archiver";
 import JSZip from "jszip";
 
 import { getApp, getAppDirPath, isMultifileApp } from "../memory/app-store.js";
@@ -37,6 +36,14 @@ export interface BundleResult {
   iconImageBase64?: string;
 }
 
+function generateZipBuffer(zip: JSZip): Promise<Buffer> {
+  return zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 9 },
+  });
+}
+
 function isDefaultMainScaffold(source: string): boolean {
   const normalized = source.replace(/\s+/g, " ").trim();
   return (
@@ -177,54 +184,31 @@ export async function packageApp(
   const bundleFilename = `${safeName}-${uniqueSuffix}.vellum`;
   const bundlePath = join(tmpdir(), bundleFilename);
 
-  await new Promise<void>((resolve, reject) => {
-    const output = createWriteStream(bundlePath);
-    const archive = archiver("zip", { zlib: { level: 9 } });
-
-    output.on("close", () => resolve());
-    output.on("error", (err: Error) => reject(err));
-    archive.on("error", (err: Error) => reject(err));
-    archive.on("warning", (err: Error) => {
-      // Only reject on fatal warnings
-      if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
-        reject(err);
-      }
-    });
-
-    archive.pipe(output);
+  const zip = new JSZip();
 
-    // Add manifest.json at root level
-    archive.append(serializeManifest(manifest), { name: "manifest.json" });
+  // Add manifest.json at root level
+  zip.file("manifest.json", serializeManifest(manifest));
 
-    // Add compiled dist/ files
-    for (const file of compiledFiles) {
-      archive.append(file.data, { name: file.name });
-    }
+  // Add compiled dist/ files
+  for (const file of compiledFiles) {
+    zip.file(file.name, file.data);
+  }
 
-    // Include app icon if one was generated
-    const iconPath = join(getAppDirPath(appId), "icon.png");
-    if (existsSync(iconPath)) {
-      archive.append(readFileSync(iconPath), { name: "icon.png" });
-    }
+  // Include app icon if one was generated
+  const iconPath = join(appDir, "icon.png");
+  if (existsSync(iconPath)) {
+    zip.file("icon.png", readFileSync(iconPath));
+  }
 
-    archive.finalize();
-  });
+  await writeFile(bundlePath, await generateZipBuffer(zip));
 
   // Sign the bundle if a signing callback is provided
   if (requestSignature) {
     try {
       const signatureJson = await signBundle(bundlePath, requestSignature);
 
-      // Re-open the zip and add signature.json
-      const zipBuffer = await readFile(bundlePath);
-      const zip = await JSZip.loadAsync(zipBuffer);
       zip.file("signature.json", JSON.stringify(signatureJson, null, 2));
-      const signedBuffer = await zip.generateAsync({
-        type: "nodebuffer",
-        compression: "DEFLATE",
-        compressionOptions: { level: 9 },
-      });
-      await writeFile(bundlePath, signedBuffer);
+      await writeFile(bundlePath, await generateZipBuffer(zip));
 
       bundlerLog.info({ appId }, "Bundle signed successfully");
     } catch (err) {
@@ -250,9 +234,8 @@ export async function packageApp(
 
   // Read icon for inclusion in the response
   let iconImageBase64: string | undefined;
-  const iconFilePath = join(getAppDirPath(appId), "icon.png");
-  if (existsSync(iconFilePath)) {
-    iconImageBase64 = readFileSync(iconFilePath).toString("base64");
+  if (existsSync(iconPath)) {
+    iconImageBase64 = readFileSync(iconPath).toString("base64");
   }
 
   return { bundlePath, manifest, iconImageBase64 };

package/src/calls/call-controller.ts

@@ -1312,7 +1312,7 @@ export class CallController {
 
       // Mark the linked guardian action request as timed out and
       // send expiry notices to guardian destinations. Deliveries
-      // must be captured before markTimedOutWithReason changes
+      // must be captured before expiring the request changes
       // their status.
       const pendingActionRequest = getPendingCanonicalRequestByCallSessionId(
         this.callSessionId,