@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091853.fbaa2ae

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

@@ -7,19 +7,35 @@ describe("MemoryV3ConfigSchema", () => {
     const parsed = MemoryV3ConfigSchema.parse({});
     expect(parsed).toEqual({
       workingSet: { maxPages: 150, evictWindow: 5 },
-      l2Concurrency: 16,
+      needleK: 100,
+      denseK: 100,
+      edge: { hubDegree: 30, seedCount: 18, perSeed: 6, cap: 45 },
     });
   });
 
-  test("accepts an explicit l2Concurrency override", () => {
-    expect(MemoryV3ConfigSchema.parse({ l2Concurrency: 8 }).l2Concurrency).toBe(
-      8,
-    );
+  test("accepts explicit lane-K overrides", () => {
+    const parsed = MemoryV3ConfigSchema.parse({ needleK: 50, denseK: 75 });
+    expect(parsed.needleK).toBe(50);
+    expect(parsed.denseK).toBe(75);
   });
 
-  test("rejects a non-positive or non-integer l2Concurrency", () => {
-    expect(() => MemoryV3ConfigSchema.parse({ l2Concurrency: 0 })).toThrow();
-    expect(() => MemoryV3ConfigSchema.parse({ l2Concurrency: -4 })).toThrow();
-    expect(() => MemoryV3ConfigSchema.parse({ l2Concurrency: 1.5 })).toThrow();
+  test("accepts a partial edge override, defaulting the rest", () => {
+    const parsed = MemoryV3ConfigSchema.parse({ edge: { hubDegree: 10 } });
+    expect(parsed.edge).toEqual({
+      hubDegree: 10,
+      seedCount: 18,
+      perSeed: 6,
+      cap: 45,
+    });
+  });
+
+  test("rejects non-positive or non-integer lane knobs", () => {
+    expect(() => MemoryV3ConfigSchema.parse({ needleK: 0 })).toThrow();
+    expect(() => MemoryV3ConfigSchema.parse({ denseK: -4 })).toThrow();
+    expect(() => MemoryV3ConfigSchema.parse({ needleK: 1.5 })).toThrow();
+    expect(() =>
+      MemoryV3ConfigSchema.parse({ edge: { perSeed: 0 } }),
+    ).toThrow();
+    expect(() => MemoryV3ConfigSchema.parse({ edge: { cap: -1 } })).toThrow();
   });
 });

package/src/config/schemas/call-site-catalog.ts

@@ -121,13 +121,6 @@ const CATALOG_RECORD: CatalogRecord = {
       "Selects which concept pages to inject for the next agent turn by routing over a cached page index.",
     domain: "memory",
   },
-  memoryV3RouteL1: {
-    id: "memoryV3RouteL1",
-    displayName: "Memory V3 L1 Router",
-    description:
-      "Picks which leaves of the topic tree to open for the next agent turn by routing over a cache-warm static leaf block.",
-    domain: "memory",
-  },
   memoryV3SelectL2: {
     id: "memoryV3SelectL2",
     displayName: "Memory V3 L2 Selector",
@@ -300,20 +293,6 @@ const CATALOG_RECORD: CatalogRecord = {
     description: "General-purpose LLM inference call site for skill use.",
     domain: "skills",
   },
-  proactiveArtifactDecision: {
-    id: "proactiveArtifactDecision",
-    displayName: "Proactive Artifact Decision",
-    description:
-      "Decides what personalized artifact to build for new users based on conversation context.",
-    domain: "agentLoop",
-  },
-  proactiveArtifactBuild: {
-    id: "proactiveArtifactBuild",
-    displayName: "Proactive Artifact Build",
-    description:
-      "Builds the personalized artifact in a background conversation with tool access.",
-    domain: "agentLoop",
-  },
   homeGreeting: {
     id: "homeGreeting",
     displayName: "Home Greeting",

package/src/config/schemas/heartbeat.ts

@@ -56,6 +56,15 @@ export const HeartbeatConfigSchema = z
       .describe(
         "Maximum heartbeats that can run consecutively without a guardian message. Counter resets when the guardian sends a message. Set to null for unlimited.",
       ),
+    maxDailyRuns: z
+      .number({ error: "heartbeat.maxDailyRuns must be a number" })
+      .int("heartbeat.maxDailyRuns must be an integer")
+      .positive("heartbeat.maxDailyRuns must be a positive integer")
+      .nullable()
+      .default(2)
+      .describe(
+        "Maximum heartbeats that can run per calendar day. Resets at midnight local time. Set to null for unlimited.",
+      ),
     disposition: z
       .string({ error: "heartbeat.disposition must be a string" })
       .default(

package/src/config/schemas/llm.ts

@@ -50,7 +50,6 @@ export const LLMCallSiteEnum = z.enum([
   "memoryV2Migration",
   "memoryV2Sweep",
   "memoryRouter",
-  "memoryV3RouteL1",
   "memoryV3SelectL2",
   "memoryV2Consolidation",
   "memoryRetrospective",
@@ -77,8 +76,6 @@ export const LLMCallSiteEnum = z.enum([
   "meetChatOpportunity",
   "inference",
   "trustRuleSuggestion",
-  "proactiveArtifactDecision",
-  "proactiveArtifactBuild",
   "homeGreeting",
   "homeSuggestedPrompts",
 ]);
@@ -126,6 +123,17 @@ const VerbosityEnum = z.enum(["low", "medium", "high"]);
 const ModelSchema = z.string().min(1);
 const MaxTokensSchema = z.number().int().positive();
 const TemperatureSchema = z.number().min(0).max(2).nullable();
+// Named, code-resolved logit-bias preset a profile may opt into. The value is a
+// preset *name*, not an inline token→bias map, so the workspace config stays
+// small. This is profile-identity metadata, not inheritable config: the resolver
+// strips it from the deep-merge and re-attaches it from the winning profile (see
+// `profileConfigFragment` / `resolveCallSiteConfig`), and `RetryProvider`
+// resolves it to a `logit_bias` map at request time, forwarded only on the
+// Fireworks (OpenAI-compatible) path. Keep these literals in sync with the
+// presets handled by `resolveLogitBiasPreset` in
+// `providers/inference/logit-bias.ts` (kept separate to avoid a schema →
+// provider import cycle).
+const LogitBiasPresetSchema = z.enum(["suppress-cjk"]);
 
 // ---------------------------------------------------------------------------
 // Thinking & ContextWindow
@@ -318,6 +326,11 @@ export const LLMConfigBase = z.object({
   thinking: ThinkingSchema.default(ThinkingSchema.parse({})),
   contextWindow: ContextWindowSchema.default(ContextWindowSchema.parse({})),
   openrouter: OpenRouterSchema.default(OpenRouterSchema.parse({})),
+  // Not deep-merged like the other fields: `resolveCallSiteConfig` sets this
+  // from the single highest-precedence profile that won resolution (see
+  // `profileConfigFragment`, which strips it from the merge), so a preset
+  // can't bleed from a lower-precedence profile into one that didn't opt in.
+  logitBias: LogitBiasPresetSchema.optional(),
 });
 export type LLMConfigBase = z.infer<typeof LLMConfigBase>;
 
@@ -338,6 +351,7 @@ const LLMConfigFragment = z.object({
   thinking: ThinkingFragmentSchema.optional(),
   contextWindow: ContextWindowDeepPartialSchema.optional(),
   openrouter: OpenRouterDeepPartialSchema.optional(),
+  logitBias: LogitBiasPresetSchema.optional(),
 });
 type LLMConfigFragment = z.infer<typeof LLMConfigFragment>;
 

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 
 /**
- * Memory v3 (topic-tree routing) working-set configuration.
+ * Memory v3 (section-grain lane retrieval) 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
@@ -28,20 +28,70 @@ export const MemoryV3WorkingSetSchema = z
   })
   .describe("Memory v3 working-set retention/eviction tuning.");
 
+/**
+ * Edge-lane tuning for the link-graph expansion that folds a turn's lexical and
+ * dense seeds outward to their first-class neighbours.
+ */
+export const MemoryV3EdgeSchema = z
+  .object({
+    hubDegree: z
+      .number({ error: "memory.v3.edge.hubDegree must be a number" })
+      .int("memory.v3.edge.hubDegree must be an integer")
+      .positive("memory.v3.edge.hubDegree must be a positive integer")
+      .default(30)
+      .describe(
+        "In-degree above which an article is treated as a hub and excluded from edge expansion (too generic to be a useful surface).",
+      ),
+    seedCount: z
+      .number({ error: "memory.v3.edge.seedCount must be a number" })
+      .int("memory.v3.edge.seedCount must be an integer")
+      .positive("memory.v3.edge.seedCount must be a positive integer")
+      .default(18)
+      .describe(
+        "Number of top needle+dense seeds (in rank order) expanded by the edge lane.",
+      ),
+    perSeed: z
+      .number({ error: "memory.v3.edge.perSeed must be a number" })
+      .int("memory.v3.edge.perSeed must be an integer")
+      .positive("memory.v3.edge.perSeed must be a positive integer")
+      .default(6)
+      .describe("Maximum neighbours surfaced per expanded seed."),
+    cap: z
+      .number({ error: "memory.v3.edge.cap must be a number" })
+      .int("memory.v3.edge.cap must be an integer")
+      .positive("memory.v3.edge.cap must be a positive integer")
+      .default(45)
+      .describe(
+        "Hard cap on the total number of distinct articles surfaced by the edge lane.",
+      ),
+  })
+  .describe("Memory v3 edge-lane (link-graph expansion) 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)
+    needleK: z
+      .number({ error: "memory.v3.needleK must be a number" })
+      .int("memory.v3.needleK must be an integer")
+      .positive("memory.v3.needleK must be a positive integer")
+      .default(100)
+      .describe(
+        "Number of section-grain BM25 needle articles folded into the candidate pool each turn.",
+      ),
+    denseK: z
+      .number({ error: "memory.v3.denseK must be a number" })
+      .int("memory.v3.denseK must be an integer")
+      .positive("memory.v3.denseK must be a positive integer")
+      .default(100)
       .describe(
-        "Bounded fan-out for the per-leaf L2 selection (number of leaf selector calls in flight at once).",
+        "Number of dense-lane articles folded into the candidate pool each turn.",
       ),
+    edge: MemoryV3EdgeSchema.default(MemoryV3EdgeSchema.parse({})),
   })
-  .describe("Memory v3 — topic-tree routing with a carry-forward working set");
+  .describe(
+    "Memory v3 — section-grain lane retrieval with a carry-forward working set",
+  );
 
 export type MemoryV3Config = z.infer<typeof MemoryV3ConfigSchema>;

package/src/config/seed-inference-profiles.ts

@@ -74,6 +74,24 @@ const MANAGED_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
     thinking: { enabled: false, streamThinking: false },
     contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
   },
+  // Open-weight economy option: Kimi K2.6 served by Fireworks via managed
+  // platform inference. Carries the `suppress-cjk` logit-bias preset to
+  // discourage the model from spontaneously emitting Chinese in English
+  // output; the preset is profile-scoped and only forwarded on the Fireworks
+  // path (see `providers/inference/logit-bias.ts`).
+  "balanced-economy": {
+    intent: "balanced",
+    provider: "fireworks",
+    connectionName: "fireworks-managed",
+    source: "managed",
+    label: "Balanced Economy",
+    description: "Strong open model (Kimi K2.6) at a lower price point",
+    maxTokens: 16000,
+    effort: "high",
+    thinking: { enabled: true, streamThinking: true },
+    contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+    logitBias: "suppress-cjk",
+  },
 };
 
 /**

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 { filterMessagesForUntrustedActor } from "../daemon/message-provenance.js";
+import { stripHistoricalWebSearchResults } from "../daemon/web-search-history.js";
 import {
   getAttachmentContent,
   getAttachmentMetadataForMessage,
@@ -685,6 +686,25 @@ function extractTextFromResponse(content: ContentBlock[]): string {
     .join("\n");
 }
 
+// Build the outbound message list for a compaction provider call: convert
+// historical web_search_tool_result blocks to text, then append the
+// summarization instruction at the tail.
+//
+// Anthropic's opaque `encrypted_content` tokens are route-scoped and expire, so
+// replaying a stale one is rejected with `Invalid encrypted_content in
+// search_result block`. Sanitizing here — the single seam every compaction
+// provider call funnels through — keeps that error away from both the
+// assistant-driven and emergency summarization calls. Only this outbound copy
+// is sanitized; tail resolution and the persisted compaction result read the
+// caller's original messages, so durable history keeps the rich blocks. The
+// instruction stays at the tail so the prefix cache stays warm.
+function buildCompactionRequest(
+  history: Message[],
+  instruction: Message,
+): Message[] {
+  return [...stripHistoricalWebSearchResults(history).messages, instruction];
+}
+
 export async function runAssistantDrivenCompaction(
   args: CompactionRunArgs,
 ): Promise<CompactionRunResult> {
@@ -718,9 +738,7 @@ export async function runAssistantDrivenCompaction(
     manifestText,
   );
 
-  // Append instruction at the tail — prefix unchanged, so prefix cache
-  // stays warm.
-  const requestMessages = [...args.messages, instruction];
+  const requestMessages = buildCompactionRequest(args.messages, instruction);
 
   let response: ProviderResponse;
   try {
@@ -1090,7 +1108,7 @@ export async function runEmergencyCompaction(
     role: "user",
     content: [{ type: "text", text: EMERGENCY_COMPACTION_PROMPT }],
   };
-  const requestMessages = [...prefix, instruction];
+  const requestMessages = buildCompactionRequest(prefix, instruction);
 
   let response: ProviderResponse;
   try {

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

@@ -22,6 +22,34 @@ export const TOOL_RESULT_DIR = ".tool-results";
 /** Marker used to detect already-truncated results (idempotency guard). */
 export const TRUNCATION_MARKER = "\u2014 full result:";
 
+/**
+ * Tools whose results carry durable operating instructions the model relies on
+ * across later turns rather than one-off data it only needs in the moment.
+ * Their results must never be middle-truncated: paging out the middle silently
+ * strips the workflow (e.g. a `skill_load` body losing its "## Available Tools"
+ * section), leaving the model to fall back to generic priors. Skill bodies are
+ * bounded and authored to live in context, so exempting them is safe.
+ */
+export const TRUNCATION_EXEMPT_TOOLS = new Set<string>(["skill_load"]);
+
+/**
+ * Build a map of tool_use_id -> originating tool name by walking the tool_use
+ * blocks in assistant messages. A tool_result only carries `tool_use_id`, so
+ * this is the only way to recover which tool produced a given result.
+ */
+function buildToolNameById(messages: Message[]): Map<string, string> {
+  const byId = new Map<string, string>();
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue;
+    for (const block of msg.content) {
+      if (block.type !== "tool_use") continue;
+      const tu = block as ToolUseContent;
+      byId.set(tu.id, tu.name);
+    }
+  }
+  return byId;
+}
+
 /**
  * Deterministic file path for a tool result's full content on disk.
  * Uses the first 12 hex chars of the SHA-256 of the tool_use_id.
@@ -59,7 +87,8 @@ export function buildTruncatedContent(
  * - The in-context content is replaced with a prefix/suffix stub.
  *
  * Results are skipped if they are below threshold, are error results,
- * or have already been truncated (contain `TRUNCATION_MARKER`).
+ * have already been truncated (contain `TRUNCATION_MARKER`), or were produced
+ * by a tool in `TRUNCATION_EXEMPT_TOOLS` (durable instructions like skill bodies).
  *
  * Returns a shallow-copied messages array (only modified messages are cloned)
  * and the count of results that were truncated.
@@ -70,6 +99,8 @@ export function postTurnTruncateToolResults(
 ): { messages: Message[]; truncatedCount: number } {
   let truncatedCount = 0;
 
+  const toolNameById = buildToolNameById(messages);
+
   const mapped = messages.map((msg) => {
     let changed = false;
     const nextContent: ContentBlock[] = msg.content.map((block) => {
@@ -82,6 +113,13 @@ export function postTurnTruncateToolResults(
       // Skip error results.
       if (tr.is_error) return block;
 
+      // Skip results from tools whose output is durable operating instructions
+      // (e.g. skill_load); middle-truncating them strips the workflow.
+      const toolName = toolNameById.get(tr.tool_use_id);
+      if (toolName !== undefined && TRUNCATION_EXEMPT_TOOLS.has(toolName)) {
+        return block;
+      }
+
       // Skip already-truncated results (idempotency).
       if (tr.content.includes(TRUNCATION_MARKER)) return block;
 

package/src/context/strip-injections.ts

@@ -87,8 +87,14 @@ const RUNTIME_INJECTION_PREFIXES: InjectionMatcher[] = [
   { prefix: "<info>\n", suffix: "\n</info>" },
   "<voice_call_control>",
   "<workspace_top_level>", // backward-compat: strip legacy workspace blocks
-  // NOTE: <workspace> is intentionally NOT stripped — workspace context
-  // persists in history so the assistant retains workspace grounding.
+  // The `<workspace>` top-level block is stripped so each compaction re-injects
+  // a fresh directory snapshot rather than carrying a stale listing into the
+  // summary — matching the `<knowledge_base>`/`<NOW.md>` cadence and keeping the
+  // `workspace-context` injector's presence detection in lockstep (the block is
+  // present exactly when compaction would strip it). The full `{ prefix, suffix }`
+  // wrapper shape ensures user-authored text merely starting with `<workspace>\n`
+  // is never mistaken for an injected block.
+  { prefix: "<workspace>\n", suffix: "\n</workspace>" },
   "<temporal_context>\nToday:", // backward-compat: strip legacy temporal blocks
   "<active_subagents>",
   "<active_workspace>",

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -17,7 +17,6 @@ import type {
 import { getConfig } from "../config/loader.js";
 import { recordEstimate } from "../context/estimator-calibration.js";
 import { getCalibrationProviderKey } from "../context/token-estimator.js";
-import type { ContextWindowResult } from "../context/window-manager.js";
 import { projectAssistantMessage } from "../memory/conversation-attention-store.js";
 import {
   deleteMessageById,
@@ -46,6 +45,7 @@ import {
   type SlackMessageMetadata,
   writeSlackMetadata,
 } from "../messaging/providers/slack/message-metadata.js";
+import type { ContextWindowResult } from "../plugins/defaults/compaction/window-manager.js";
 import type {
   ContentBlock,
   ImageContent,
@@ -76,10 +76,8 @@ import {
   cleanAssistantContent,
   drainDirectiveDisplayBuffer,
 } from "./assistant-attachments.js";
-import type {
-  AgentLoopConversationContext,
-  AssistantSurface,
-} from "./conversation-agent-loop.js";
+import type { Conversation } from "./conversation.js";
+import type { AssistantSurface } from "./conversation-agent-loop.js";
 import {
   buildConversationErrorMessage,
   classifyConversationError,
@@ -295,29 +293,11 @@ export interface EventHandlerState {
    * never claims content a flush has not yet written.
    */
   lastPersistedContentSeq: number | undefined;
-  /**
-   * Whether the workspace top-level block should be (re)injected on this
-   * turn. Compaction's prepare phase strips the workspace / NOW.md / PKB
-   * blocks off the tail, so it is set after any successful compaction to
-   * force the workspace overview back in. On an ordinary turn the block is
-   * already present in history, so it defaults `false` to avoid burning
-   * tokens re-injecting it redundantly.
-   */
-  shouldInjectWorkspace: boolean;
-  /**
-   * Whether the reducer has compacted `ctx.messages`, gating the Slack
-   * chronological-transcript override on re-injection. The captured
-   * transcript is the full persisted history; blindly replaying it after
-   * compaction would overwrite the reduced messages and undo compaction, so
-   * once this is `true` the override falls back to the reduced
-   * `ctx.messages`.
-   */
-  reducerCompacted: boolean;
 }
 
 /** Immutable context shared across event handlers within a single agent loop run. */
 export interface EventHandlerDeps {
-  readonly ctx: AgentLoopConversationContext;
+  readonly ctx: Conversation;
   readonly onEvent: (msg: ServerMessage) => void;
   readonly reqId: string;
   readonly isFirstMessage: boolean;
@@ -392,8 +372,6 @@ export function createEventHandlerState(): EventHandlerState {
     pendingPartialFlushPromise: undefined,
     currentMessageContent: [],
     lastPersistedContentSeq: undefined,
-    shouldInjectWorkspace: false,
-    reducerCompacted: false,
   };
 }
 
@@ -655,9 +633,7 @@ function computeToolUseStatusText(
   return `Running ${friendlyToolName(name)}`;
 }
 
-function resolveAssistantReplyTimestampTimezone(
-  ctx: AgentLoopConversationContext,
-): string {
+function resolveAssistantReplyTimestampTimezone(ctx: Conversation): string {
   const config = getConfig();
   return resolveTurnTimezoneContext({
     configuredUserTimeZone: config.ui?.userTimezone ?? null,
@@ -1506,6 +1482,13 @@ function annotatePersistedAssistantMessage(
         display: surface.display,
         ...(surface.persistent ? { persistent: true } : {}),
         ...(surface.toolCallId ? { toolCallId: surface.toolCallId } : {}),
+        // Daemon-only commit-timing activation tag, persisted so
+        // restoreSurfaceStateFromHistory can rehydrate it after a reload. This
+        // block lives only in server-side conversation history, never in the
+        // client `ui_surface_show` message.
+        ...(surface.activationMoment
+          ? { activationMoment: surface.activationMoment }
+          : {}),
       } as unknown as ContentBlock);
     }
     modified = true;
@@ -1659,6 +1642,8 @@ export async function handleMessageComplete(
       deps.ctx.conversationId,
       state.pendingNotifiedInferenceProfile,
     );
+    deps.ctx.lastNotifiedInferenceProfile =
+      state.pendingNotifiedInferenceProfile;
     state.pendingNotifiedInferenceProfile = null;
   }
 
@@ -2302,17 +2287,14 @@ export async function dispatchAgentEvent(
         // so re-injection re-applies onto the stripped history even when the
         // pipeline ran but did not compact. When it did compact, commit the
         // durable result (DB-record fields, Slack provenance, SSE) — which
-        // overwrites `ctx.messages` with the compacted history — and flip the
-        // per-turn re-injection guards the orchestrator reads. This runs
+        // overwrites `ctx.messages` with the compacted history. This runs
         // before the loop's `reinject` hook (the loop awaits this dispatch),
-        // so the guards are set in time. A failed durable commit re-throws
-        // below to abort the turn rather than re-injecting against
-        // half-applied state.
+        // so the committed history is in place in time. A failed durable
+        // commit re-throws below to abort the turn rather than re-injecting
+        // against half-applied state.
         deps.ctx.messages = event.basis;
         if (event.result.compacted) {
           await deps.applyCompaction(event.result, event.basis);
-          state.reducerCompacted = true;
-          state.shouldInjectWorkspace = true;
         }
         break;
       case "history_stripped":