@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

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

@@ -194,6 +194,14 @@ export const MemoryV2ConfigSchema = z
       .describe(
         "Hours between scheduled consolidation runs that synthesize buffered memories into concept pages",
       ),
+    consolidation_enabled: z
+      .boolean({
+        error: "memory.v2.consolidation_enabled must be a boolean",
+      })
+      .default(true)
+      .describe(
+        "Whether automatic scheduled consolidation runs are enabled. Manual run-now requests remain available while memory.v2.enabled is true.",
+      ),
     consolidation_max_buffer_lines: z
       .number({
         error: "memory.v2.consolidation_max_buffer_lines must be a number",
@@ -388,256 +396,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,47 @@
+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({}),
+    ),
+    l2Concurrency: z
+      .number({ error: "memory.v3.l2Concurrency must be a number" })
+      .int("memory.v3.l2Concurrency must be an integer")
+      .positive("memory.v3.l2Concurrency must be a positive integer")
+      .default(16)
+      .describe(
+        "Bounded fan-out for the per-leaf L2 selection (number of leaf selector calls in flight at once).",
+      ),
+  })
+  .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/platform.ts

@@ -87,6 +87,14 @@ export const DaemonConfigSchema = z
       .describe(
         "Whether the daemon records conversations even when no client is connected",
       ),
+    reapOrphanedSubprocesses: z
+      .boolean({
+        error: "daemon.reapOrphanedSubprocesses must be a boolean",
+      })
+      .default(false)
+      .describe(
+        "Whether the daemon, when running as PID 1 in a container, periodically reaps orphaned subprocesses that reparented to it. Off by default while the behavior is being validated.",
+      ),
   })
   .describe("Background daemon process configuration");
 

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/config/seed-inference-profiles.ts

@@ -58,7 +58,7 @@ const MANAGED_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
     label: "Quality",
     description: "Best results with the most capable model",
     maxTokens: 32000,
-    effort: "max",
+    effort: "high",
     thinking: { enabled: true, streamThinking: true },
     contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
   },
@@ -104,7 +104,7 @@ const USER_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
     label: "Quality",
     description: "Best results with the most capable model",
     maxTokens: 32000,
-    effort: "max",
+    effort: "high",
     thinking: { enabled: true, streamThinking: true },
     contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
   },

package/src/config/skills.ts

@@ -52,6 +52,7 @@ const VellumMetadataSchema = z
 
 const SkillMetadataSchema = z
   .object({
+    icon: z.string().optional(),
     emoji: z.string().optional(),
     vellum: VellumMetadataSchema.optional(),
   })
@@ -210,6 +211,7 @@ interface ParsedFrontmatter {
   displayName: string;
   description: string;
   body: string;
+  icon?: string;
   emoji?: string;
   includes?: string[];
   featureFlag?: string;
@@ -253,6 +255,7 @@ function parseFrontmatter(
   }
 
   // metadata is already a parsed object from YAML — validate with Zod schema
+  let icon: string | undefined;
   let emoji: string | undefined;
   let parsedMeta: z.infer<typeof SkillMetadataSchema> | undefined;
   let vellum: z.infer<typeof VellumMetadataSchema> | undefined;
@@ -271,6 +274,7 @@ function parseFrontmatter(
       if (zodResult.success) {
         parsedMeta = zodResult.data;
         vellum = parsedMeta.vellum;
+        icon = parsedMeta.icon;
         emoji = vellum?.emoji ?? parsedMeta.emoji;
       } else {
         // Zod validation failed — fall back to raw parsed object so we don't
@@ -284,6 +288,9 @@ function parseFrontmatter(
         const raw = metadataRaw as Record<string, unknown>;
         parsedMeta = raw as z.infer<typeof SkillMetadataSchema>;
         vellum = raw?.vellum as z.infer<typeof VellumMetadataSchema>;
+        if (typeof parsedMeta?.icon === "string") {
+          icon = parsedMeta.icon;
+        }
         if (vellum && typeof vellum === "object") {
           emoji = typeof vellum.emoji === "string" ? vellum.emoji : undefined;
         }
@@ -337,6 +344,7 @@ function parseFrontmatter(
     displayName,
     description,
     body: strippedBody,
+    icon,
     emoji,
     includes,
     featureFlag,
@@ -489,6 +497,7 @@ function readSkillFromDirectory(
       directoryPath,
       skillFilePath,
       body: parsed.body,
+      icon: parsed.icon,
       emoji: parsed.emoji,
 
       source,
@@ -540,6 +549,7 @@ function readBundledSkillFromDirectory(
       skillFilePath,
       body: parsed.body,
       bundled: true,
+      icon: parsed.icon,
       emoji: parsed.emoji,
 
       source: "bundled",
@@ -599,6 +609,7 @@ function loadBundledSkills(): SkillSummary[] {
       directoryPath: skill.directoryPath,
       skillFilePath: skill.skillFilePath,
       bundled: true,
+      icon: skill.icon,
       emoji: skill.emoji,
 
       source: "bundled",
@@ -649,6 +660,7 @@ function skillSummaryFromDefinition(
     directoryPath: skill.directoryPath,
     skillFilePath: skill.skillFilePath,
     bundled: skill.bundled,
+    icon: skill.icon,
     emoji: skill.emoji,
     source,
     toolManifest: skill.toolManifest,
@@ -836,6 +848,7 @@ export function loadSkillCatalog(
           description: parsed.description,
           directoryPath: directory,
           skillFilePath,
+          icon: parsed.icon,
           emoji: parsed.emoji,
 
           source: "workspace",

package/src/context/compactor.ts

@@ -21,7 +21,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,7 +36,12 @@ 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 { stripInjectionsForCompaction } from "./strip-injections.js";
 import { estimatePromptTokens } from "./token-estimator.js";
 
 const log = getLogger("compactor");
@@ -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 {