@vellumai/assistant 0.8.6 → 0.8.7

package/src/config/schemas/memory-v2.ts

@@ -388,256 +388,3 @@ export const MemoryV2ConfigSchema = z
   });
 
 export type MemoryV2Config = z.infer<typeof MemoryV2ConfigSchema>;
-
-/**
- * Per-lane system-prompt override for a v3 LLM call site. `override` is an
- * inline prompt string (highest precedence); `path` points at a file whose
- * contents replace the bundled prompt. Both default to `null` (use the bundled
- * prompt). Shared by the filter, descent, and gate entries under
- * `memory.v3.prompts`. The whole object is `.default(...)`-wrapped so an
- * omitted lane parses to `{ override: null, path: null }`.
- */
-const V3PromptOverrideSchema = z
-  .object({
-    override: z
-      .string({ error: "memory.v3.prompts.*.override must be a string" })
-      .nullable()
-      .default(null)
-      .describe(
-        "Optional inline system-prompt string that replaces the bundled prompt for this lane. Takes precedence over `path`. An empty or whitespace-only string is ignored (falls back to `path` / bundled).",
-      ),
-    path: z
-      .string({ error: "memory.v3.prompts.*.path must be a string" })
-      .nullable()
-      .default(null)
-      .describe(
-        "Optional path to a file whose contents replace the bundled prompt for this lane. Absolute paths are used as-is, a leading `~/` expands to the home directory, otherwise the path resolves under the workspace root. If the file is missing, unreadable, or empty, the bundled prompt is used and a warning is logged.",
-      ),
-  })
-  .default({ override: null, path: null });
-
-/**
- * Memory v3 (multi-lane, bounded-descent retrieval) configuration.
- *
- * Additive scaffolding only — defaults to `enabled: false` so existing
- * configs are untouched and the v3 retrieval loop stays inert until later
- * PRs wire it up. Every field carries a default and the whole block is
- * `.default(...)`-wrapped so a config that omits `memory.v3` entirely still
- * parses to these documented defaults.
- */
-export const MemoryV3ConfigSchema = z
-  .object({
-    enabled: z
-      .boolean({ error: "memory.v3.enabled must be a boolean" })
-      .default(false)
-      .describe(
-        "Whether the v3 memory subsystem (multi-lane bounded-descent retrieval) is enabled. Off by default until the v3 loop is wired up.",
-      ),
-    shadow: z
-      .boolean({ error: "memory.v3.shadow must be a boolean" })
-      .default(false)
-      .describe(
-        "Live-shadow toggle: when on, the v3 retrieval loop runs alongside the active path for comparison without affecting injected context. Consumed by a later PR.",
-      ),
-    passCap: z
-      .number({ error: "memory.v3.passCap must be a number" })
-      .int("memory.v3.passCap must be an integer")
-      .default(3)
-      .describe(
-        "Maximum number of retrieval passes (router → descent rounds) the v3 loop may run per turn.",
-      ),
-    breadthBudget: z
-      .number({ error: "memory.v3.breadthBudget must be a number" })
-      .int("memory.v3.breadthBudget must be an integer")
-      .default(6)
-      .describe(
-        "Per-pass breadth budget — the number of frontier candidates the v3 loop may expand at each step.",
-      ),
-    maxDepth: z
-      .number({ error: "memory.v3.maxDepth must be a number" })
-      .int("memory.v3.maxDepth must be an integer")
-      .default(6)
-      .describe(
-        "Maximum descent depth the v3 loop traverses through the memory tree before stopping.",
-      ),
-    denseQuota: z
-      .object({
-        activeDomain: z
-          .number({
-            error: "memory.v3.denseQuota.activeDomain must be a number",
-          })
-          .default(30)
-          .describe(
-            "Dense-lane candidate quota allocated to the conversation's active domain.",
-          ),
-        offDomain: z
-          .number({ error: "memory.v3.denseQuota.offDomain must be a number" })
-          .default(8)
-          .describe(
-            "Dense-lane candidate quota allocated to off-domain (exploratory) retrieval.",
-          ),
-      })
-      .default({ activeDomain: 30, offDomain: 8 })
-      .describe(
-        "Dense-lane candidate quotas split between the active domain and off-domain exploration.",
-      ),
-    hotLimit: z
-      .number({ error: "memory.v3.hotLimit must be a number" })
-      .int("memory.v3.hotLimit must be an integer")
-      .positive("memory.v3.hotLimit must be positive")
-      .default(50)
-      .describe(
-        "Top-N cap on the hot scout lane, ranked by injection-frequency EMA. Hot hits are sticky (kept past the gate), so this bounds how many always-on pages the lane forces into the selection. Without a cap a mature corpus — where nearly every page has been injected at some point — surfaces the entire corpus.",
-      ),
-    lanes: z
-      .object({
-        hot: z
-          .boolean()
-          .default(true)
-          .describe("Whether the hot (recently-touched) retrieval lane is on."),
-        sparse: z
-          .boolean()
-          .default(true)
-          .describe("Whether the sparse (BM25-style keyword) lane is on."),
-        dense: z
-          .boolean()
-          .default(true)
-          .describe("Whether the dense (embedding-similarity) lane is on."),
-        tree: z
-          .boolean()
-          .default(true)
-          .describe("Whether the tree (hierarchical descent) lane is on."),
-        edges: z
-          .boolean()
-          .default(true)
-          .describe("Whether the edges (graph-adjacency) lane is on."),
-      })
-      .default({
-        hot: true,
-        sparse: true,
-        dense: true,
-        tree: true,
-        edges: true,
-      })
-      .describe(
-        "Per-lane on/off toggles for the v3 multi-lane retrieval fanout. All lanes on by default.",
-      ),
-    edges: z
-      .object({
-        learnedAdjacencyThreshold: z
-          .number({
-            error: "memory.v3.edges.learnedAdjacencyThreshold must be a number",
-          })
-          .min(0, "memory.v3.edges.learnedAdjacencyThreshold must be >= 0")
-          .default(0)
-          .describe(
-            "Association-strength cutoff for merging the learned co-retrieval graph (memory_v3_auto_edges) into the edge-expansion lane. Seeded edges are weighted seedWeight × NPMI, so this is effectively a minimum-NPMI gate: NPMI ≥ threshold / seedWeight (e.g. with the default seedWeight 2.0, threshold 1.0 ≈ NPMI ≥ 0.5, 1.2 ≈ NPMI ≥ 0.6). When > 0, edges at or above this weight are read via aboveThreshold() and merged with the curated frontmatter graph as expandEdges' extraAdjacency. 0 (default) = OFF: the edge lane uses curated edges only and behavior is unchanged. Seed the learned graph with `assistant memory v3 seed-edges`.",
-          ),
-        maxPulls: z
-          .number({ error: "memory.v3.edges.maxPulls must be a number" })
-          .min(0, "memory.v3.edges.maxPulls must be >= 0")
-          .default(400)
-          .describe(
-            "Hard cap on the edge lane's contribution to the gate's candidate pool (the unioned 1–2 hop curated∪learned neighborhood). The shipped default 400 lets a dense curated graph dominate the pool and drown the gate's recall of high-precision hits; lower values (~40) keep the lane focused. 0 effectively disables edge pulls.",
-          ),
-      })
-      .default({ learnedAdjacencyThreshold: 0, maxPulls: 400 })
-      .describe(
-        "Edge-expansion lane configuration. Gates whether the learned co-retrieval graph augments the curated edge graph.",
-      ),
-    ks: z
-      .array(z.number({ error: "memory.v3.ks entries must be numbers" }))
-      .default([5, 10, 25, 50])
-      .describe(
-        "Evaluation top-K cutoffs the v3 loop reports metrics at (e.g. recall@K).",
-      ),
-    write: z
-      .object({
-        enabled: z
-          .boolean({ error: "memory.v3.write.enabled must be a boolean" })
-          .default(false)
-          .describe(
-            "Whether v3 consolidation owns the shared-buffer drain + tree build. Off by default — v2 consolidation stays the sole buffer-drainer. Does NOT introduce a separate buffer.",
-          ),
-        consolidateIntervalMs: z
-          .number({
-            error: "memory.v3.write.consolidateIntervalMs must be a number",
-          })
-          .int("memory.v3.write.consolidateIntervalMs must be an integer")
-          .positive("memory.v3.write.consolidateIntervalMs must be positive")
-          .default(3600000)
-          .describe(
-            "Interval, in milliseconds, between scheduled v3 consolidation runs once the v3 write path owns the drain. Default 1 hour.",
-          ),
-        coactivation: z
-          .boolean({ error: "memory.v3.write.coactivation must be a boolean" })
-          .default(false)
-          .describe(
-            "Whether v3 consolidation learns co-activation edges during the tree build. Off by default; consumed by a later PR.",
-          ),
-      })
-      .default({
-        enabled: false,
-        consolidateIntervalMs: 3600000,
-        coactivation: false,
-      })
-      .describe(
-        "Memory v3 write-path configuration. All default-off scaffolding — controls whether v3 consolidation owns the shared-buffer drain + tree build. Consumed by later PRs.",
-      ),
-    prompts: z
-      .object({
-        filter: V3PromptOverrideSchema.describe(
-          "Override for the dense-hit filter lane's system prompt.",
-        ),
-        descent: V3PromptOverrideSchema.describe(
-          "Override for the tree-walk descent driver's system prompt.",
-        ),
-        gate: V3PromptOverrideSchema.describe(
-          "Override for the selection gate's system prompt.",
-        ),
-      })
-      .default({
-        filter: { override: null, path: null },
-        descent: { override: null, path: null },
-        gate: { override: null, path: null },
-      })
-      .describe(
-        "Per-lane system-prompt overrides for the three v3 LLM call sites (filter, descent, gate). Each entry takes an inline `override` string (highest precedence) and/or a file `path` whose contents replace the bundled prompt; absolute paths are used as-is, a leading `~/` expands to the home directory, otherwise the path resolves under the workspace root. An empty/whitespace inline override or a missing/unreadable/empty file falls back to the bundled prompt. Lets the prompts be iterated at runtime without a rebuild/restart — mirroring `memory.v2.router.router_prompt_path`.",
-      ),
-    gateCandidateSummaries: z
-      .boolean({
-        error: "memory.v3.gateCandidateSummaries must be a boolean",
-      })
-      .default(false)
-      .describe(
-        "When true, the selection gate sees each candidate as `slug — summary` instead of the bare slug, so it can judge relevance on page content. Off by default: with the bundled (precision-leaning) gate prompt this makes the gate more selective. It pays off paired with a recall-leaning gate prompt override, where the summaries let the gate recognize non-obvious associative/emotional matches it would otherwise pass over. Adds the candidate summaries to the gate prompt (larger input).",
-      ),
-  })
-  .default({
-    enabled: false,
-    shadow: false,
-    passCap: 3,
-    breadthBudget: 6,
-    maxDepth: 6,
-    denseQuota: { activeDomain: 30, offDomain: 8 },
-    hotLimit: 50,
-    lanes: { hot: true, sparse: true, dense: true, tree: true, edges: true },
-    edges: { learnedAdjacencyThreshold: 0, maxPulls: 400 },
-    ks: [5, 10, 25, 50],
-    write: {
-      enabled: false,
-      consolidateIntervalMs: 3600000,
-      coactivation: false,
-    },
-    prompts: {
-      filter: { override: null, path: null },
-      descent: { override: null, path: null },
-      gate: { override: null, path: null },
-    },
-    gateCandidateSummaries: false,
-  })
-  .describe(
-    "Memory v3 — multi-lane bounded-descent retrieval. Additive scaffolding, disabled by default.",
-  );
-
-export type MemoryV3Config = z.infer<typeof MemoryV3ConfigSchema>;

package/src/config/schemas/memory-v3.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+
+/**
+ * Memory v3 (topic-tree routing) working-set configuration.
+ *
+ * The working set is the per-conversation set of concept pages carried
+ * forward across turns. Eviction keeps it bounded: pages unseen for longer
+ * than `evictWindow` turns are dropped, and the set is capped at `maxPages`.
+ */
+export const MemoryV3WorkingSetSchema = z
+  .object({
+    maxPages: z
+      .number({ error: "memory.v3.workingSet.maxPages must be a number" })
+      .int("memory.v3.workingSet.maxPages must be an integer")
+      .positive("memory.v3.workingSet.maxPages must be a positive integer")
+      .default(150)
+      .describe(
+        "Upper bound on the number of pages retained in the working set. Once exceeded, the least-salient non-pinned pages are evicted until the set fits.",
+      ),
+    evictWindow: z
+      .number({ error: "memory.v3.workingSet.evictWindow must be a number" })
+      .int("memory.v3.workingSet.evictWindow must be an integer")
+      .positive("memory.v3.workingSet.evictWindow must be a positive integer")
+      .default(5)
+      .describe(
+        "Number of turns a non-pinned page may go unseen before it is evicted from the working set.",
+      ),
+  })
+  .describe("Memory v3 working-set retention/eviction tuning.");
+
+export const MemoryV3ConfigSchema = z
+  .object({
+    workingSet: MemoryV3WorkingSetSchema.default(
+      MemoryV3WorkingSetSchema.parse({}),
+    ),
+  })
+  .describe("Memory v3 — topic-tree routing with a carry-forward working set");
+
+export type MemoryV3Config = z.infer<typeof MemoryV3ConfigSchema>;

package/src/config/schemas/memory.ts

@@ -3,6 +3,7 @@ import { z } from "zod";
 import {
   MemoryCleanupConfigSchema,
   MemoryJobsConfigSchema,
+  MemoryMaintenanceConfigSchema,
   MemoryRetentionConfigSchema,
 } from "./memory-lifecycle.js";
 import {
@@ -16,7 +17,8 @@ import {
   MemorySegmentationConfigSchema,
   QdrantConfigSchema,
 } from "./memory-storage.js";
-import { MemoryV2ConfigSchema, MemoryV3ConfigSchema } from "./memory-v2.js";
+import { MemoryV2ConfigSchema } from "./memory-v2.js";
+import { MemoryV3ConfigSchema } from "./memory-v3.js";
 
 export const MemoryConfigSchema = z
   .object({
@@ -43,6 +45,9 @@ export const MemoryConfigSchema = z
     cleanup: MemoryCleanupConfigSchema.default(
       MemoryCleanupConfigSchema.parse({}),
     ),
+    maintenance: MemoryMaintenanceConfigSchema.default(
+      MemoryMaintenanceConfigSchema.parse({}),
+    ),
     extraction: MemoryExtractionConfigSchema.default(
       MemoryExtractionConfigSchema.parse({}),
     ),

package/src/config/schemas/timeouts.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
 
+import { DEFAULT_TOOL_EXECUTION_TIMEOUT_SEC } from "../../api/constants/tool-execution.js";
+
 export const TimeoutConfigSchema = z
   .object({
     shellMaxTimeoutSec: z
@@ -30,7 +32,7 @@ export const TimeoutConfigSchema = z
       .number({ error: "timeouts.toolExecutionTimeoutSec must be a number" })
       .finite("timeouts.toolExecutionTimeoutSec must be finite")
       .positive("timeouts.toolExecutionTimeoutSec must be a positive number")
-      .default(120)
+      .default(DEFAULT_TOOL_EXECUTION_TIMEOUT_SEC)
       .describe("Default timeout for tool execution in seconds"),
     providerStreamTimeoutSec: z
       .number({ error: "timeouts.providerStreamTimeoutSec must be a number" })

package/src/context/compactor.ts

@@ -22,6 +22,7 @@ import { optimizeImageForTransport } from "../agent/image-optimize.js";
 import type { CompactionConfig } from "../config/schemas/compaction.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { stripInjectionsForCompaction } from "../daemon/conversation-runtime-assembly.js";
+import { filterMessagesForUntrustedActor } from "../daemon/message-provenance.js";
 import {
   getAttachmentContent,
   getAttachmentMetadataForMessage,
@@ -36,6 +37,10 @@ import type {
   ProviderResponse,
   ToolDefinition,
 } from "../providers/types.js";
+import {
+  isUntrustedTrustClass,
+  type TrustClass,
+} from "../runtime/actor-trust-resolver.js";
 import { getLogger } from "../util/logger.js";
 import { estimatePromptTokens } from "./token-estimator.js";
 
@@ -181,6 +186,13 @@ export interface CompactionRunArgs {
   force?: boolean;
   signal?: AbortSignal;
   overrideProfile?: string | null;
+  /**
+   * Trust class of the actor whose turn triggered compaction. When the
+   * actor is untrusted, the image manifest is filtered to exclude
+   * guardian-only attachments so they cannot be retained back into the
+   * untrusted actor's context.
+   */
+  actorTrustClass?: TrustClass;
   /**
    * Number of leading non-persisted messages (e.g. inherited summary from a
    * parent fork). Compacted-persisted-count subtracts this so the DB
@@ -337,9 +349,21 @@ interface ManifestEntry {
  * `filename` is the attachment's `originalFilename`; collisions across
  * messages are kept as separate entries (the model can disambiguate via
  * the timestamp it sees in the manifest).
+ *
+ * For untrusted actors the rows are first filtered through
+ * {@link filterMessagesForUntrustedActor} — the same provenance filter
+ * `loadFromDb` applies when assembling history — so guardian-only images
+ * never enter the manifest and therefore can never be retained back into
+ * an untrusted actor's view.
  */
-export function collectImageManifest(conversationId: string): ManifestEntry[] {
-  const rows = getMessages(conversationId);
+export function collectImageManifest(
+  conversationId: string,
+  actorTrustClass?: TrustClass,
+): ManifestEntry[] {
+  const allRows = getMessages(conversationId);
+  const rows = isUntrustedTrustClass(actorTrustClass)
+    ? filterMessagesForUntrustedActor(allRows)
+    : allRows;
   const entries: ManifestEntry[] = [];
   for (const row of rows) {
     const atts = getAttachmentMetadataForMessage(row.id);
@@ -682,7 +706,12 @@ export async function runAssistantDrivenCompaction(
 
   // Build image manifest from the DB before invoking the model so the
   // instruction message carries a faithful picture of available images.
-  const manifest = collectImageManifest(args.conversationId);
+  // Filtered by actor trust so untrusted turns never see guardian-only
+  // attachments.
+  const manifest = collectImageManifest(
+    args.conversationId,
+    args.actorTrustClass,
+  );
   const manifestText = renderImageManifest(manifest);
   const instruction = buildInstructionMessage(
     args.compaction.prompt ?? null,
@@ -695,21 +724,18 @@ export async function runAssistantDrivenCompaction(
 
   let response: ProviderResponse;
   try {
-    response = await args.provider.sendMessage(
-      requestMessages,
-      args.tools,
-      args.systemPrompt,
-      {
-        signal: args.signal,
-        config: {
-          callSite: COMPACTION_CALL_SITE,
-          usageTracking: "manual",
-          ...(args.overrideProfile
-            ? { overrideProfile: args.overrideProfile }
-            : {}),
-        },
+    response = await args.provider.sendMessage(requestMessages, {
+      tools: args.tools,
+      systemPrompt: args.systemPrompt,
+      signal: args.signal,
+      config: {
+        callSite: COMPACTION_CALL_SITE,
+        usageTracking: "manual",
+        ...(args.overrideProfile
+          ? { overrideProfile: args.overrideProfile }
+          : {}),
       },
-    );
+    });
   } catch (err) {
     log.warn({ err }, "Compaction provider call failed");
     return {
@@ -1068,21 +1094,18 @@ export async function runEmergencyCompaction(
 
   let response: ProviderResponse;
   try {
-    response = await args.provider.sendMessage(
-      requestMessages,
-      args.tools,
-      args.systemPrompt,
-      {
-        signal: args.signal,
-        config: {
-          callSite: COMPACTION_CALL_SITE,
-          usageTracking: "manual",
-          ...(args.overrideProfile
-            ? { overrideProfile: args.overrideProfile }
-            : {}),
-        },
+    response = await args.provider.sendMessage(requestMessages, {
+      tools: args.tools,
+      systemPrompt: args.systemPrompt,
+      signal: args.signal,
+      config: {
+        callSite: COMPACTION_CALL_SITE,
+        usageTracking: "manual",
+        ...(args.overrideProfile
+          ? { overrideProfile: args.overrideProfile }
+          : {}),
       },
-    );
+    });
   } catch (err) {
     log.warn({ err }, "Emergency compaction provider call failed");
     return {

package/src/context/token-estimator.ts

@@ -1,3 +1,7 @@
+import {
+  estimateGeminiAudioTokens,
+  normalizeGeminiAudioMime,
+} from "../providers/gemini/inline-media.js";
 import type {
   ContentBlock,
   Message,
@@ -116,6 +120,16 @@ function estimateFileDataTokens(
     return estimateAnthropicPdfTokens(block.source.data);
   }
 
+  // Gemini hears audio natively (inline base64) but bills it at ~32 tokens/sec.
+  // Estimate from duration, not payload size, to avoid a ~170x over-count that
+  // would trigger spurious compaction.
+  if (
+    providerName === "gemini" &&
+    normalizeGeminiAudioMime(block.source.media_type) !== null
+  ) {
+    return estimateGeminiAudioTokens(block.source.data);
+  }
+
   // Gemini sends certain file types inline as base64
   if (
     providerName === "gemini" &&
@@ -225,6 +239,11 @@ export function estimateContentBlockTokens(
             tokens += estimateContentBlockTokens(cb, options);
           } else if (cb.type === "image" && !anthropicDropsErrorImage) {
             tokens += estimateContentBlockTokens(cb, options);
+          } else if (cb.type === "file") {
+            // Audio file sub-blocks (e.g. file_read on an .mp3) are sent inline
+            // to Gemini; estimateFileDataTokens charges the ~32 tok/sec audio
+            // rate for Gemini and ~0 for providers that drop the block.
+            tokens += estimateContentBlockTokens(cb, options);
           }
         }
       }

package/src/context/tool-result-truncation.ts

@@ -1,9 +1,9 @@
+import { truncateToolResultText } from "../plugins/defaults/tool-result-truncate/terminal.js";
 import type {
   ContentBlock,
   Message,
   ToolResultContent,
 } from "../providers/types.js";
-import { safeStringSlice } from "../util/unicode.js";
 
 /**
  * Maximum share of the context window that a single tool result may occupy.
@@ -15,48 +15,6 @@ const MAX_TOOL_RESULT_CONTEXT_SHARE = 0.3;
  */
 export const HARD_MAX_TOOL_RESULT_CHARS = 400_000;
 
-/**
- * Minimum number of characters to preserve when truncating.
- */
-export const MIN_KEEP_CHARS = 2_000;
-
-/**
- * Suffix appended to truncated tool results.
- */
-export const TRUNCATION_SUFFIX =
-  "\n\n[Content truncated — original exceeded size limit. Use offset/limit parameters or request specific sections for large content.]";
-
-/**
- * Truncate text with newline-boundary awareness.
- *
- * If `text.length <= maxChars`, the text is returned as-is.
- * Otherwise we look for the last newline that falls within 80% of the budget
- * so we get a clean cut. At least `MIN_KEEP_CHARS` characters are always
- * preserved.
- */
-export function truncateToolResultText(text: string, maxChars: number): string {
-  if (text.length <= maxChars) {
-    return text;
-  }
-
-  const effectiveMax = Math.max(maxChars, MIN_KEEP_CHARS);
-  const cutPoint = effectiveMax - TRUNCATION_SUFFIX.length;
-
-  // Look for a newline within the last 20% of the budget for a clean break.
-  const threshold = Math.floor(cutPoint * 0.8);
-  const lastNewline = text.lastIndexOf("\n", cutPoint);
-
-  const sliceEnd = lastNewline >= threshold ? lastNewline : cutPoint;
-
-  // If sliceEnd covers the full text, nothing was actually removed — return
-  // the original text without appending the suffix.
-  if (sliceEnd >= text.length) {
-    return text;
-  }
-
-  return safeStringSlice(text, 0, sliceEnd) + TRUNCATION_SUFFIX;
-}
-
 /**
  * Calculate the maximum allowed characters for a tool result based on the
  * context window size. Uses ~4 chars per token as a rough heuristic.