@vellumai/assistant 0.8.11 → 0.8.12-staging.1

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

@@ -63,6 +63,86 @@ export const MemoryV3HotSetSchema = z
   })
   .describe("Memory v3 hot-set lane (decayed selection frequency) tuning.");
 
+/**
+ * Fresh-set lane tuning: the top-K pages by most-recent on-disk modification
+ * folded into the candidate pool as a stable-prefix lane. Recency covers the
+ * window before the other lanes can reach a just-written page (no selection
+ * history for the hot set; nothing lexical for the finders on summary-shaped
+ * messages).
+ */
+export const MemoryV3FreshSetSchema = z
+  .object({
+    k: z
+      .number({ error: "memory.v3.freshSet.k must be a number" })
+      .int("memory.v3.freshSet.k must be an integer")
+      .nonnegative("memory.v3.freshSet.k must be a non-negative integer")
+      .default(100)
+      .describe(
+        "Number of most-recently-modified pages included in the fresh-set lane (0 disables the lane). Sized to cover roughly the last day or two of page writes — the recency window conversations reference most.",
+      ),
+  })
+  .describe("Memory v3 fresh-set lane (page-modification recency) tuning.");
+
+/**
+ * Learned-edge lane tuning: a co-selection NPMI association graph over the
+ * selection log, expanded alongside the static link graph. Behavioral edges
+ * reach association-relevant pages no lexical, semantic, or authored-link
+ * lane can surface.
+ */
+export const MemoryV3LearnedEdgesSchema = z
+  .object({
+    halfLifeDays: z
+      .number({ error: "memory.v3.learnedEdges.halfLifeDays must be a number" })
+      .positive("memory.v3.learnedEdges.halfLifeDays must be a positive number")
+      .default(30)
+      .describe(
+        "Co-selection decay half-life in days: a selector call this old contributes half the weight of one made now.",
+      ),
+    minCount: z
+      .number({ error: "memory.v3.learnedEdges.minCount must be a number" })
+      .positive("memory.v3.learnedEdges.minCount must be a positive number")
+      .default(3)
+      .describe(
+        "Minimum decayed co-occurrence mass for a pair to form an edge (the rare-pair noise floor).",
+      ),
+    npmiFloor: z
+      .number({ error: "memory.v3.learnedEdges.npmiFloor must be a number" })
+      .nonnegative(
+        "memory.v3.learnedEdges.npmiFloor must be a non-negative number",
+      )
+      .default(0.2)
+      .describe("Minimum NPMI for a pair to form an edge."),
+    maxPerPage: z
+      .number({ error: "memory.v3.learnedEdges.maxPerPage must be a number" })
+      .int("memory.v3.learnedEdges.maxPerPage must be an integer")
+      .nonnegative(
+        "memory.v3.learnedEdges.maxPerPage must be a non-negative integer",
+      )
+      .default(6)
+      .describe(
+        "Maximum learned out-edges kept per page, strongest NPMI first (0 disables the lane).",
+      ),
+    perSeed: z
+      .number({ error: "memory.v3.learnedEdges.perSeed must be a number" })
+      .int("memory.v3.learnedEdges.perSeed must be an integer")
+      .positive("memory.v3.learnedEdges.perSeed must be a positive integer")
+      .default(3)
+      .describe(
+        "Maximum learned neighbours surfaced per expanded seed each turn.",
+      ),
+    cap: z
+      .number({ error: "memory.v3.learnedEdges.cap must be a number" })
+      .int("memory.v3.learnedEdges.cap must be an integer")
+      .nonnegative("memory.v3.learnedEdges.cap must be a non-negative integer")
+      .default(20)
+      .describe(
+        "Hard cap on total learned-lane surfaced articles per turn (0 disables the pass).",
+      ),
+  })
+  .describe(
+    "Memory v3 learned-edge lane (co-selection NPMI association graph) tuning.",
+  );
+
 /**
  * Ephemeral section-spotlight tuning: how many of the current turn's selected
  * finder hits render their matched section into the `<memory_spotlight>`
@@ -142,6 +222,10 @@ export const MemoryV3ConfigSchema = z
   .object({
     prune: MemoryV3PruneSchema.default(MemoryV3PruneSchema.parse({})),
     hotSet: MemoryV3HotSetSchema.default(MemoryV3HotSetSchema.parse({})),
+    freshSet: MemoryV3FreshSetSchema.default(MemoryV3FreshSetSchema.parse({})),
+    learnedEdges: MemoryV3LearnedEdgesSchema.default(
+      MemoryV3LearnedEdgesSchema.parse({}),
+    ),
     spotlight: MemoryV3SpotlightSchema.default(
       MemoryV3SpotlightSchema.parse({}),
     ),
@@ -161,6 +245,14 @@ export const MemoryV3ConfigSchema = z
       .describe(
         "Number of dense-lane articles folded into the candidate pool each turn.",
       ),
+    replyQueryK: z
+      .number({ error: "memory.v3.replyQueryK must be a number" })
+      .int("memory.v3.replyQueryK must be an integer")
+      .nonnegative("memory.v3.replyQueryK must be a non-negative integer")
+      .default(12)
+      .describe(
+        "Per-lane article budget for the reply-query finder pass: needle and dense each re-run over the assistant's previous message as separate queries (never concatenated with the user's message). 0 disables the pass. Deliberately small next to needleK/denseK — the pass adds the assistant-side retrieval signal, not a second full sweep.",
+      ),
     edge: MemoryV3EdgeSchema.default(MemoryV3EdgeSchema.parse({})),
   })
   .describe("Memory v3 — section-grain lane retrieval");

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

@@ -50,6 +50,27 @@ function buildToolNameById(messages: Message[]): Map<string, string> {
   return byId;
 }
 
+/**
+ * Shared eligibility rules for replacing an oversized tool result with the
+ * on-disk stub: string content over the size threshold, not an error result,
+ * not from an exempt tool (durable instructions like skill bodies), and not
+ * already truncated (idempotency marker). Used by both the post-turn pass and
+ * the result-time spool pass so the two converge on the same results.
+ */
+export function isTruncationEligible(
+  tr: ToolResultContent,
+  toolName: string | undefined,
+): boolean {
+  if (typeof tr.content !== "string") return false;
+  if (tr.content.length <= THRESHOLD_CHARS) return false;
+  if (tr.is_error) return false;
+  if (toolName !== undefined && TRUNCATION_EXEMPT_TOOLS.has(toolName)) {
+    return false;
+  }
+  if (tr.content.includes(TRUNCATION_MARKER)) return false;
+  return true;
+}
+
 /**
  * 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.
@@ -58,7 +79,10 @@ export function getToolResultFilePath(
   conversationDir: string,
   toolUseId: string,
 ): string {
-  const hash = createHash("sha256").update(toolUseId).digest("hex").slice(0, 12);
+  const hash = createHash("sha256")
+    .update(toolUseId)
+    .digest("hex")
+    .slice(0, 12);
   return join(conversationDir, TOOL_RESULT_DIR, `${hash}.txt`);
 }
 
@@ -73,7 +97,11 @@ export function buildTruncatedContent(
 ): string {
   const half = Math.floor(TARGET_CHARS / 2);
   const prefix = safeStringSlice(original, 0, half);
-  const suffix = safeStringSlice(original, original.length - half, original.length);
+  const suffix = safeStringSlice(
+    original,
+    original.length - half,
+    original.length,
+  );
   const omittedChars = original.length - TARGET_CHARS;
   const estimatedTokens = Math.round(omittedChars / 4);
   return `${prefix}\n\n...(${estimatedTokens} tokens omitted ${TRUNCATION_MARKER} ${filePath})\n\n${suffix}`;
@@ -86,9 +114,7 @@ export function buildTruncatedContent(
  * - The full content is persisted to a deterministic file path on disk.
  * - The in-context content is replaced with a prefix/suffix stub.
  *
- * Results are skipped if they are below threshold, are error results,
- * have already been truncated (contain `TRUNCATION_MARKER`), or were produced
- * by a tool in `TRUNCATION_EXEMPT_TOOLS` (durable instructions like skill bodies).
+ * Results are skipped unless {@link isTruncationEligible} allows them.
  *
  * Returns a shallow-copied messages array (only modified messages are cloned)
  * and the count of results that were truncated.
@@ -107,22 +133,10 @@ export function postTurnTruncateToolResults(
       if (block.type !== "tool_result") return block;
       const tr = block as ToolResultContent;
 
-      // Skip short results.
-      if (tr.content.length <= THRESHOLD_CHARS) return block;
-
-      // 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)) {
+      if (!isTruncationEligible(tr, toolNameById.get(tr.tool_use_id))) {
         return block;
       }
 
-      // Skip already-truncated results (idempotency).
-      if (tr.content.includes(TRUNCATION_MARKER)) return block;
-
       const filePath = getToolResultFilePath(
         options.conversationDir,
         tr.tool_use_id,

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

@@ -0,0 +1,104 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { ContentBlock, ToolResultContent } from "../providers/types.js";
+import {
+  buildTruncatedContent,
+  getToolResultFilePath,
+  isTruncationEligible,
+  TOOL_RESULT_DIR,
+} from "./post-turn-tool-result-truncation.js";
+
+/**
+ * AX-tree snapshots have their own dedicated history compactor
+ * (`compactAxTreeHistory`) with placeholder semantics tuned for computer-use
+ * sessions, and the model needs the freshest tree inline to act on it, so the
+ * result-time pass leaves them alone.
+ */
+const AX_TREE_TAG = "<ax-tree>";
+
+/**
+ * Tools whose results keep their full content at result time even when
+ * oversized. `file_read` is the model's only way to page spooled content back
+ * into context: stubbing a read of a `.tool-results/` file would spool a
+ * fresh copy and hand back another stub, so oversized content could never be
+ * read at all. Explicit reads are therefore honored in full; the post-turn
+ * pass still truncates them at turn end, after the model has consumed the
+ * content.
+ */
+const RESULT_TIME_STUB_EXEMPT_TOOLS = new Set<string>(["file_read"]);
+
+/**
+ * Whether a tool result is eligible for the result-time spool/stub pass:
+ * the post-turn pass's shared rules plus the AX-tree and `file_read`
+ * exemptions above.
+ */
+function isSpoolEligible(
+  tr: ToolResultContent,
+  toolName: string | undefined,
+): boolean {
+  if (!isTruncationEligible(tr, toolName)) return false;
+  if (toolName !== undefined && RESULT_TIME_STUB_EXEMPT_TOOLS.has(toolName)) {
+    return false;
+  }
+  if (tr.content.includes(AX_TREE_TAG)) return false;
+  return true;
+}
+
+/**
+ * Spool every oversized tool result in `blocks` to its deterministic
+ * `.tool-results/` file and replace the inline content with the post-turn
+ * pass's prefix/suffix stub — at result time, before the blocks join history.
+ *
+ * Because the swap happens before the content is ever sent, the
+ * provider-bound history stays strictly append-only across the turn's model
+ * calls, which is what keeps the provider's prompt-cache prefix valid:
+ * rewriting an earlier message between calls would invalidate the cache from
+ * that point on every iteration. The model still gets the head/tail preview
+ * plus the on-disk path, so it can page the full content back in with
+ * `file_read` (whose results are exempt from this pass) when it actually
+ * needs it.
+ *
+ * Uses the same file paths, stub bytes, and eligibility rules as
+ * `postTurnTruncateToolResults`, whose `TRUNCATION_MARKER` guard then skips
+ * these results at turn end. Eligible elements of `blocks` are replaced in
+ * place (the block objects themselves are not mutated). A result is only
+ * stubbed after its file is written, so a stub never points at a missing
+ * file; on filesystem errors the remaining blocks keep their full content and
+ * the post-turn pass covers them.
+ *
+ * Returns the number of results spooled and stubbed.
+ */
+export function spoolAndStubOversizedToolResults(
+  blocks: ContentBlock[],
+  options: {
+    conversationDir: string;
+    toolNameById: (toolUseId: string) => string | undefined;
+  },
+): number {
+  let stubbedCount = 0;
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    if (block.type !== "tool_result") continue;
+    if (!isSpoolEligible(block, options.toolNameById(block.tool_use_id))) {
+      continue;
+    }
+
+    if (stubbedCount === 0) {
+      mkdirSync(join(options.conversationDir, TOOL_RESULT_DIR), {
+        recursive: true,
+      });
+    }
+    const filePath = getToolResultFilePath(
+      options.conversationDir,
+      block.tool_use_id,
+    );
+    writeFileSync(filePath, block.content, "utf-8");
+    blocks[i] = {
+      ...block,
+      content: buildTruncatedContent(block.content, filePath),
+    };
+    stubbedCount++;
+  }
+  return stubbedCount;
+}

package/src/credential-execution/feature-gates.ts

@@ -59,4 +59,3 @@ export function isCesSecureInstallEnabled(config: AssistantConfig): boolean {
 export function isCesGrantAuditEnabled(config: AssistantConfig): boolean {
   return isAssistantFeatureFlagEnabled(CES_GRANT_AUDIT_FLAG_KEY, config);
 }
-

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

@@ -16,11 +16,12 @@ import type {
 } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
 import { recordEstimate } from "../context/estimator-calibration.js";
+import { stripInjectionsForCompaction } from "../context/strip-injections.js";
 import { getCalibrationProviderKey } from "../context/token-estimator.js";
 import {
   recordCompactionEndBestEffort,
   recordCompactionStartBestEffort,
-} from "../memory/compaction-log-writer-clickhouse.js";
+} from "../memory/compaction-log-store-clickhouse.js";
 import { projectAssistantMessage } from "../memory/conversation-attention-store.js";
 import {
   deleteMessageById,
@@ -286,6 +287,14 @@ export interface EventHandlerState {
    * never claims content a flush has not yet written.
    */
   lastPersistedContentSeq: number | undefined;
+  /**
+   * Pre-compaction history buffered from `context_compacting` start events,
+   * keyed by `compactionId`. The paired `compaction_completed` event no
+   * longer carries the pre-compaction history, so the dispatcher re-derives
+   * the stripped durable base from the buffered start messages. Entries are
+   * consumed (deleted) when the end event dispatches.
+   */
+  readonly compactionStartMessages: Map<string, Message[]>;
 }
 
 /** Immutable context shared across event handlers within a single agent loop run. */
@@ -301,8 +310,8 @@ export interface EventHandlerDeps {
   readonly turnInterfaceContext: TurnInterfaceContext;
   /**
    * Commit a successful inline compaction to durable state. Invoked from the
-   * `compaction_completed` dispatch case (when `result.compacted`) with the
-   * loop's compaction result and the stripped pre-compaction `messages`. Supplied
+   * `compaction_completed` dispatch case (when `compacted`) with the
+   * loop's compaction result and the stripped pre-compaction history. Supplied
    * by the orchestrator because the body writes Conversation DB-record fields,
    * projects Slack provenance, and emits transport the loop is intentionally
    * blind to.
@@ -361,6 +370,7 @@ export function createEventHandlerState(): EventHandlerState {
     currentMessageContent: [],
     currentThinkingTimestamps: [],
     lastPersistedContentSeq: undefined,
+    compactionStartMessages: new Map(),
   };
 }
 
@@ -2316,6 +2326,9 @@ export async function dispatchAgentEvent(
       }
       case "context_compacting":
         recordCompactionStartBestEffort(deps.ctx.conversationId, event);
+        // Buffer the pre-compaction history so the paired end event can
+        // re-derive the stripped durable base.
+        state.compactionStartMessages.set(event.compactionId, event.messages);
         deps.ctx.emitActivityState("thinking", "context_compacting", {
           requestId: deps.reqId,
           statusText: "Compacting context",
@@ -2329,22 +2342,34 @@ export async function dispatchAgentEvent(
         // banner.
         deps.onEvent(event);
         break;
-      case "compaction_completed":
-        // Always commit the loop-stripped `messages` as the durable message base
-        // 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. This runs
-        // before the loop's `reinject` hook (the loop awaits this dispatch),
-        // 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.
+      case "compaction_completed": {
+        // Always commit the stripped pre-compaction history as the durable
+        // message base so re-injection re-applies onto the stripped history
+        // even when the pipeline ran but did not compact. The base is
+        // re-derived from the buffered start event's messages (the end event
+        // carries only the pipeline's output). When the pipeline did compact,
+        // commit the durable result (DB-record fields, Slack provenance,
+        // SSE) — which overwrites `ctx.messages` with the compacted history.
+        // This runs before the loop's `reinject` hook (the loop awaits this
+        // dispatch), 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.
         recordCompactionEndBestEffort(deps.ctx.conversationId, event);
-        deps.ctx.messages = event.messages;
-        if (event.result.compacted) {
-          await deps.applyCompaction(event.result, event.messages);
+        const startMessages = state.compactionStartMessages.get(
+          event.compactionId,
+        );
+        state.compactionStartMessages.delete(event.compactionId);
+        // Fall back to the pipeline's output when the start event was never
+        // buffered — on the no-compaction path it is the stripped input.
+        const strippedBase = startMessages
+          ? stripInjectionsForCompaction(startMessages)
+          : event.messages;
+        deps.ctx.messages = strippedBase;
+        if (event.compacted) {
+          await deps.applyCompaction(event, strippedBase);
         }
         break;
+      }
       case "history_stripped":
         // Record the history-stripped DB marker right after the loop strips
         // injections (before the pipeline). Best-effort: a transient marker

package/src/daemon/conversation-error.ts

@@ -255,7 +255,7 @@ export function classifyConversationError(
     return {
       code: "PROVIDER_NOT_CONFIGURED",
       userMessage:
-        "No compatible provider connection found for this profile. Check your provider connections in Settings.",
+        "No compatible provider connection found for this profile. Check your provider connections in Settings → Models & Services.",
       retryable: true,
       debugDetails,
       errorCategory: "provider_not_configured",
@@ -334,15 +334,6 @@ function classifyCore(
       }
       return invalidApiKeyClassification(attribution);
     }
-    if (error.statusCode === 401) {
-      return {
-        code: "PROVIDER_INVALID_KEY",
-        userMessage:
-          "Your API key is invalid or expired. Update it in Settings or switch to managed mode.",
-        retryable: false,
-        errorCategory: "provider_invalid_key",
-      };
-    }
     if (error.statusCode === 402) {
       if (isManagedBalanceError(error)) {
         return managedBalanceClassification();
@@ -543,7 +534,7 @@ function providerBillingClassification(): Omit<
   return {
     code: "PROVIDER_BILLING",
     userMessage:
-      "Your API provider account or key needs credits. Add funds with the provider or update the key in Settings.",
+      "Your API provider account or key needs credits. Add funds with the provider or update the key in Settings → Models & Services.",
     retryable: false,
     errorCategory: "provider_billing",
   };
@@ -583,8 +574,8 @@ function invalidApiKeyClassification(
   return {
     code: "PROVIDER_INVALID_KEY",
     userMessage: target
-      ? `The API key${target} was rejected by the provider. Update it in Settings.`
-      : "Your API key was rejected by the provider. Update it in Settings.",
+      ? `The API key${target} was rejected by the provider. Update it in Settings → Models & Services.`
+      : "Your API key was rejected by the provider. Update it in Settings → Models & Services.",
     retryable: false,
     errorCategory: "provider_invalid_key",
     ...(attribution?.connectionName
@@ -610,8 +601,8 @@ function providerNotConfiguredClassification(
   return {
     code: "PROVIDER_NOT_CONFIGURED",
     userMessage: target
-      ? `No API key configured${target}. Add one in Settings to start chatting.`
-      : "No API key configured for inference. Add one in Settings to start chatting.",
+      ? `No API key configured${target}. Add one in Settings → Models & Services to start chatting.`
+      : "No API key configured for inference. Add one in Settings → Models & Services to start chatting.",
     retryable: true,
     errorCategory: "provider_not_configured",
     ...(attribution?.connectionName

package/src/daemon/conversation.ts

@@ -51,6 +51,7 @@ import {
   resolveOverrideProfile,
   setConversationHistoryStrippedAt,
 } from "../memory/conversation-crud.js";
+import { getResolvedConversationDirPath } from "../memory/conversation-directories.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import { unwrapMemoryBlock, wrapMemoryBlock } from "../memory/memory-marker.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
@@ -638,6 +639,14 @@ export class Conversation {
       toolExecutor: toolDefs.length > 0 ? toolExecutor : undefined,
       resolveTools,
       resolveSystemPrompt: resolveSystemPromptCallback,
+      resolveConversationDir: () => {
+        const conv = getConversation(this.conversationId);
+        if (!conv) return null;
+        return getResolvedConversationDirPath(
+          this.conversationId,
+          conv.createdAt,
+        );
+      },
     });
     createContextWindowManager({
       provider,

package/src/daemon/disk-pressure-policy.ts

@@ -54,7 +54,6 @@ const BACKGROUND_SOURCES = new Set([
   "reminder",
   "schedule",
   "task",
-  "update-bulletin",
 ]);
 const LOCAL_OWNER_INTERFACES = new Set(["macos", "web", "vellum", "cli"]);
 

package/src/daemon/lifecycle.ts

@@ -35,7 +35,6 @@ import {
 } from "../credential-execution/startup-timeout.js";
 import { FilingService } from "../filing/filing-service.js";
 import { HeartbeatService } from "../heartbeat/heartbeat-service.js";
-import { startHomeContentRefresh } from "../home/home-content-refresh.js";
 import { backfillRelationshipStateIfMissing } from "../home/relationship-state-writer.js";
 import { closeSentry, initSentry, setSentryDeviceId } from "../instrument.js";
 import {
@@ -98,8 +97,8 @@ import {
   listWorkItems,
   updateWorkItem,
 } from "../work-items/work-item-store.js";
+import { repairAdaptiveThinkingOnManagedProfiles } from "../workspace/adaptive-thinking-repair.js";
 import { WorkspaceHeartbeatService } from "../workspace/heartbeat-service.js";
-import { repairAdaptiveThinkingOnManagedProfiles } from "../workspace/migrations/097-enable-adaptive-thinking-managed-profiles.js";
 import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
 import { runWorkspaceMigrations } from "../workspace/migrations/runner.js";
 import {
@@ -480,10 +479,6 @@ export async function runDaemon(): Promise<void> {
         );
       });
 
-      // Pre-warm LLM-generated home page content (greeting + suggestion
-      // prompts) so the GET handler never triggers LLM calls.
-      startHomeContentRefresh();
-
       // Backfill injection templates on Slack bot token credentials so the
       // credential proxy can inject Authorization headers. Safe on every startup.
       try {
@@ -780,20 +775,6 @@ export async function runDaemon(): Promise<void> {
     startDiskPressureGuardForLifecycle();
     startOrphanReaper();
 
-    // Kick off the update bulletin background job AFTER `server.start()`
-    // resolves. The conversation store must be initialized before wake
-    // calls can resolve targets.
-    //
-    // Kept fire-and-forget (`void import(...).then(...).catch(...)`) so the
-    // daemon never blocks startup on it.
-    if (dbReady) {
-      void import("../prompts/update-bulletin-job.js")
-        .then((m) => m.runUpdateBulletinJobIfNeeded())
-        .catch((err) =>
-          log.warn({ err }, "Update bulletin job failed — continuing startup"),
-        );
-    }
-
     // Mutable refs for Qdrant and memory worker so background
     // init can assign them and the shutdown handler always sees the latest value.
     const bgRefs: {

package/src/daemon/message-types/conversations.ts

@@ -7,6 +7,7 @@ import type { ConversationListInvalidatedEvent } from "../../api/events/conversa
 import type { ConversationTitleUpdatedEvent } from "../../api/events/conversation-title-updated.js";
 import type { GenerationCancelledEvent } from "../../api/events/generation-cancelled.js";
 import type { GenerationHandoffEvent } from "../../api/events/generation-handoff.js";
+import type { UsageProgressEvent } from "../../api/events/usage-progress.js";
 import type { UsageUpdateEvent } from "../../api/events/usage-update.js";
 import type {
   ChannelId,
@@ -425,20 +426,6 @@ export interface UndoComplete {
   conversationId?: string;
 }
 
-/**
- * Emitted after each LLM call with per-call token deltas and estimated cost.
- * Clients accumulate these additively for live-updating usage metrics.
- * This is a UI-only hint — it does not persist to DB or affect billing.
- */
-export interface UsageProgress {
-  type: "usage_progress";
-  conversationId: string;
-  inputTokens: number;
-  outputTokens: number;
-  estimatedCost: number;
-  model: string;
-}
-
 export interface UsageResponse {
   type: "usage_response";
   totalInputTokens: number;
@@ -550,7 +537,7 @@ export type _ConversationsServerMessages =
   | HistoryResponse
   | UndoComplete
   | UsageUpdateEvent
-  | UsageProgress
+  | UsageProgressEvent
   | UsageResponse
   | ContextCompacted
   | CompactionCircuitOpenEvent

package/src/daemon/trust-context.ts

@@ -42,7 +42,7 @@ export interface TrustContext {
 
 /**
  * Trust context used by internal background jobs (memory consolidation,
- * update bulletin, scheduled tasks) when invoking the agent loop without
+ * scheduled tasks) when invoking the agent loop without
  * an inbound actor identity. The assistant is the guardian over its own
  * internal state, so self-maintenance flows clear the side-effect
  * approval gate. Inbound message conversations resolve trust per-actor

package/src/heartbeat/__tests__/heartbeat-service.test.ts

@@ -114,7 +114,7 @@ mock.module("../../config/loader.js", () => ({
   getNestedValue: () => undefined,
   setNestedValue: () => {},
   API_KEY_PROVIDERS: [],
-  _appendQuarantineBulletin: () => {},
+  _writeQuarantineNotice: () => {},
 }));
 
 // Stub prompt helpers.