@vellumai/assistant 0.8.7 → 0.8.8

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/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,6 @@
 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,
@@ -42,6 +41,7 @@ import {
   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");

package/src/context/strip-injections.ts

@@ -0,0 +1,122 @@
+/**
+ * Runtime-injection stripping for compaction and overflow recovery.
+ *
+ * Runtime injections (turn context, memory, NOW.md, workspace, Slack
+ * chronological, etc.) persist in message history to keep the conversation
+ * prefix stable for Anthropic's prefix caching. They only need to be removed
+ * when compaction rewrites the message array, so the compactor summarizes the
+ * raw persistent messages rather than the ephemeral injected blocks.
+ *
+ * This module is the compaction-layer home for that strip so both the agent
+ * loop (which drives the compaction pipeline) and the compactor can call it
+ * without reaching up into the daemon orchestrator.
+ */
+import type { Message } from "../providers/types.js";
+
+/**
+ * A matcher for an injected text block. A plain string matches by prefix
+ * (`startsWith`). A `{ prefix, suffix }` wrapper requires BOTH the opening
+ * prefix and the closing suffix, so user-authored content that merely begins
+ * with an injection-like opening tag (e.g. a message discussing `<info>`
+ * markup) is not mistaken for an injected block and dropped. This mirrors
+ * `countMemoryPrefixBlocks`, which only treats `<memory>…</memory>` /
+ * `<info>…</info>` blocks as injected when the full wrapper is present.
+ */
+export type InjectionMatcher = string | { prefix: string; suffix: string };
+
+/**
+ * Remove text blocks from user messages that match any of the given matchers.
+ * If stripping removes all content blocks from a message, the message itself
+ * is dropped.
+ *
+ * This is the shared primitive behind the individual strip* functions and
+ * the `stripInjectionsForCompaction` pipeline.
+ */
+export function stripUserTextBlocksByPrefix(
+  messages: Message[],
+  matchers: InjectionMatcher[],
+): Message[] {
+  return messages
+    .map((message) => {
+      if (message.role !== "user") return message;
+      const nextContent = message.content.filter((block) => {
+        if (block.type !== "text") return true;
+        return !matchers.some((m) =>
+          typeof m === "string"
+            ? block.text.startsWith(m)
+            : block.text.startsWith(m.prefix) && block.text.endsWith(m.suffix),
+        );
+      });
+      if (nextContent.length === message.content.length) return message;
+      if (nextContent.length === 0) return null;
+      return { ...message, content: nextContent };
+    })
+    .filter(
+      (message): message is NonNullable<typeof message> => message != null,
+    );
+}
+
+/** Matchers stripped by the pipeline (order doesn't matter — single pass). */
+const RUNTIME_INJECTION_PREFIXES: InjectionMatcher[] = [
+  "<channel_capabilities>",
+  "<channel_command_context>",
+  "<disk_pressure_warning>",
+  "<channel_turn_context>", // backward-compat: strip legacy separate channel blocks
+  "<guardian_context>",
+  "<inbound_actor_context>", // backward-compat: strip legacy separate actor blocks
+  "<interface_turn_context>", // backward-compat: strip legacy separate interface blocks
+  // NOTE: <turn_context> is intentionally NOT stripped — unified turn context
+  // blocks persist in history so the assistant retains temporal/actor grounding.
+  "<background_turn>",
+  "<memory_context __injected>",
+  "<memory_context>", // backward-compat: strip legacy blocks from pre-__injected history
+  // The static `memory-v2-static` block (`<info>\n…</info>`) and the
+  // dynamic activation block (`<memory>\n…</memory>`, plus legacy
+  // `<memory __injected>…`) are both stripped so each compaction
+  // re-injects the freshest essentials/threads/recent/buffer view and
+  // re-runs the activation pipeline, matching the `<knowledge_base>`
+  // cadence. The activation pipeline dedupes via `everInjected`, and
+  // compaction handles aggregate growth, so accumulation does not cause
+  // unbounded context growth. Both wrappers may appear in persisted rows.
+  //
+  // These two use the full `{ prefix, suffix }` wrapper shape (not a bare
+  // prefix) so that user-authored text merely starting with `<memory>\n` or
+  // `<info>\n` is never silently dropped during compaction/`/clean`. This
+  // matches the full-wrapper requirement in `countMemoryPrefixBlocks`.
+  { prefix: "<memory>\n", suffix: "\n</memory>" },
+  { 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.
+  "<temporal_context>\nToday:", // backward-compat: strip legacy temporal blocks
+  "<active_subagents>",
+  "<active_workspace>",
+  "<active_dynamic_page>",
+  "<non_interactive_context>",
+  // Shared prefix catches both the current NOW.md tag and any pre-line-limit
+  // variant that may linger in in-flight histories during a rolling deploy.
+  "<NOW.md Always keep this up to date",
+  "<now_scratchpad>", // backward-compat: strip legacy blocks from pre-rename history
+  "<knowledge_base>",
+  "<pkb>", // backward-compat: strip legacy tag from pre-rename history
+  "<system_reminder>",
+  "<transport_hints>",
+  // The Slack active-thread focus block is non-persisted and injected on
+  // the FINAL user turn only. Strip it here so re-assembly during compaction
+  // and overflow recovery does not duplicate it across turns.
+  "<active_thread>",
+  "<system_notice>One or more tool calls returned an error.",
+];
+
+/**
+ * Strip all runtime-injected context from message history in a single pass.
+ *
+ * Used only during compaction and overflow recovery — not on normal turns.
+ * Runtime injections persist in history to keep the conversation prefix
+ * stable for Anthropic's prefix caching. Stripping is only needed when
+ * compaction rewrites the message array (cache miss is expected anyway).
+ */
+export function stripInjectionsForCompaction(messages: Message[]): Message[] {
+  return stripUserTextBlocksByPrefix(messages, RUNTIME_INJECTION_PREFIXES);
+}

package/src/context/token-estimator.ts

@@ -359,6 +359,29 @@ export function estimatePromptTokens(
   return correction === 1.0 ? raw : Math.ceil(raw * correction);
 }
 
+/**
+ * Calibrated prompt-token estimate including the tool-definition budget.
+ *
+ * Combines the per-tool budget ({@link estimateToolsTokens}) with the
+ * message/system estimate ({@link estimatePromptTokens}) under the EWMA
+ * calibration correction. This is the estimate the overflow gate consumes;
+ * the pre-send calibration capture in `agent/loop.ts` deliberately stays on
+ * `estimatePromptTokensRaw` so the calibrator trains against the uncorrected
+ * value rather than chasing its own output.
+ */
+export function estimatePromptTokensWithTools(
+  history: Message[],
+  systemPrompt: string | undefined,
+  tools: ToolDefinition[],
+  providerName: string,
+): number {
+  const toolTokenBudget = tools.length > 0 ? estimateToolsTokens(tools) : 0;
+  return estimatePromptTokens(history, systemPrompt, {
+    providerName,
+    toolTokenBudget,
+  });
+}
+
 function stableJson(value: unknown): string {
   try {
     return JSON.stringify(value);

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

@@ -5,29 +5,6 @@ import type {
   ToolResultContent,
 } from "../providers/types.js";
 
-/**
- * Maximum share of the context window that a single tool result may occupy.
- */
-const MAX_TOOL_RESULT_CONTEXT_SHARE = 0.3;
-
-/**
- * Absolute cap on tool-result characters (~100K tokens).
- */
-export const HARD_MAX_TOOL_RESULT_CHARS = 400_000;
-
-/**
- * Calculate the maximum allowed characters for a tool result based on the
- * context window size. Uses ~4 chars per token as a rough heuristic.
- */
-export function calculateMaxToolResultChars(
-  contextWindowTokens: number,
-): number {
-  return Math.min(
-    HARD_MAX_TOOL_RESULT_CHARS,
-    Math.floor(contextWindowTokens * MAX_TOOL_RESULT_CONTEXT_SHARE * 4),
-  );
-}
-
 /**
  * Aggressively truncate all tool-result text across an entire message history.
  *

package/src/context/window-manager.ts

@@ -90,7 +90,6 @@ export interface ShouldCompactResult {
 }
 
 export interface ContextWindowCompactOptions {
-  lastCompactedAt?: number;
   /** Skip the auto-threshold check (used for /compact and recovery). */
   force?: boolean;
   /**
@@ -104,14 +103,12 @@ export interface ContextWindowCompactOptions {
    */
   precomputedEstimate?: number;
   /**
-   * Legacy fields retained for backwards compatibility with existing
-   * callers. The new assistant-driven compactor does not consume them —
-   * the model decides where to cut and what to keep — but accepting them
+   * Legacy field retained for backwards compatibility with existing
+   * callers. The new assistant-driven compactor does not consume it —
+   * the model decides where to cut and what to keep — but accepting it
    * here lets callers keep their existing call sites unchanged.
    */
   minKeepRecentUserTurns?: number;
-  conversationOriginChannel?: string;
-  targetInputTokensOverride?: number;
   /**
    * Trust class of the actor whose turn triggered compaction. Forwarded to
    * the compactor so the image manifest excludes guardian-only attachments

package/src/credential-execution/executable-discovery.ts

@@ -17,6 +17,7 @@
  */
 
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 
 import { getIsContainerized } from "../config/env-registry.js";
@@ -160,6 +161,21 @@ export function discoverLocalCes():
     return { mode: "local-source", sourcePath: sourceEntry };
   }
 
+  // npm-layout fallback: resolve via node_modules when installed as a package
+  try {
+    const _require = createRequire(import.meta.url);
+    const pkgPath = _require.resolve(
+      "@vellumai/credential-executor/package.json",
+    );
+    const npmSourceEntry = join(dirname(pkgPath), "src", "main.ts");
+    if (existsSync(npmSourceEntry)) {
+      log.info({ path: npmSourceEntry }, "Found CES source via npm package");
+      return { mode: "local-source", sourcePath: npmSourceEntry };
+    }
+  } catch {
+    // Package not installed — fall through to unavailable
+  }
+
   const reason = `CES executable not found. Searched: ${searchPaths.join(", ")}; also checked source at ${sourceEntry}`;
   log.warn(reason);
   return { mode: "unavailable", reason };

package/src/daemon/__tests__/conversation-lifecycle-auto-analyze.test.ts

@@ -165,6 +165,12 @@ function makeDisposeContext(
   const ctx = {
     conversationId: overrides.conversationId ?? "conv-1",
     processing: false,
+    isProcessing(this: { processing: boolean }) {
+      return this.processing;
+    },
+    setProcessing(this: { processing: boolean }, value: boolean) {
+      this.processing = value;
+    },
     abortController,
     prompter,
     secretPrompter,

package/src/daemon/__tests__/inference-profile-notification.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Verifies that the inference-profile-change notification is persisted only
+ * once the model has actually received the turn context carrying the
+ * `model_profile` block — signalled by the first `message_complete` event from
+ * the agent loop — rather than inline before the provider call. A turn that
+ * fails or is cancelled before delivery never emits `message_complete`, so the
+ * notice is re-sent on the next turn instead of being silently suppressed.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+// ── Mock platform (must precede imports that read it) ────────────────────────
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({ memory: {} }),
+  loadConfig: () => ({}),
+}));
+
+const setLastNotifiedInferenceProfile = mock(
+  (_conversationId: string, _profileKey: string) => {},
+);
+
+mock.module("../../memory/conversation-crud.js", () => ({
+  deleteMessageById: () => {},
+  getConversation: () => null,
+  getMessageById: () => null,
+  messageMetadataSchema: { safeParse: () => ({ success: false }) },
+  provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  setConversationHistoryStrippedAt: () => {},
+  setLastNotifiedInferenceProfile,
+  updateMessageContent: () => {},
+}));
+
+mock.module("../../memory/llm-request-log-store.js", () => ({
+  backfillMessageIdOnLogs: () => {},
+  buildProviderErrorResponsePayload: () => ({}),
+  recordRequestLog: () => {},
+  setAgentLoopExitReasonOnLatestLog: () => {},
+}));
+
+mock.module("../../memory/memory-recall-log-store.js", () => ({
+  backfillMemoryRecallLogMessageId: () => {},
+}));
+
+mock.module("../../memory/memory-v2-activation-log-store.js", () => ({
+  backfillMemoryV2ActivationMessageId: () => {},
+}));
+
+// ── Imports (after mocks) ────────────────────────────────────────────────────
+import type { AgentEvent } from "../../agent/loop.js";
+import type { Message } from "../../providers/types.js";
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../conversation-agent-loop-handlers.js";
+import {
+  createEventHandlerState,
+  dispatchAgentEvent,
+} from "../conversation-agent-loop-handlers.js";
+
+const CONVERSATION_ID = "conv-profile-notify";
+const PROFILE_KEY = "quality-optimized";
+
+function makeDeps(): EventHandlerDeps {
+  return {
+    ctx: {
+      conversationId: CONVERSATION_ID,
+      provider: { name: "mock-provider" },
+      traceEmitter: { emit: () => {} },
+      currentTurnSurfaces: [],
+      trustContext: undefined,
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: () => {},
+    reqId: "req-profile-notify",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    } as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
+  } as EventHandlerDeps;
+}
+
+function messageCompleteEvent(): Extract<
+  AgentEvent,
+  { type: "message_complete" }
+> {
+  const message: Message = {
+    role: "assistant",
+    content: [{ type: "text", text: "response" }],
+  };
+  return { type: "message_complete", message };
+}
+
+// A reserved assistant row id is the precondition `handleMessageComplete`
+// asserts before finalizing; the row reservation itself is exercised elsewhere.
+function readyState(): EventHandlerState {
+  const state = createEventHandlerState();
+  state.lastAssistantMessageId = "assistant-row-1";
+  return state;
+}
+
+describe("inference-profile-change notification persistence", () => {
+  test("persists on the first message_complete and clears the pending slot", async () => {
+    setLastNotifiedInferenceProfile.mockClear();
+    const state = readyState();
+    state.pendingNotifiedInferenceProfile = PROFILE_KEY;
+
+    await dispatchAgentEvent(state, makeDeps(), messageCompleteEvent());
+
+    expect(setLastNotifiedInferenceProfile).toHaveBeenCalledTimes(1);
+    expect(setLastNotifiedInferenceProfile).toHaveBeenCalledWith(
+      CONVERSATION_ID,
+      PROFILE_KEY,
+    );
+    expect(state.pendingNotifiedInferenceProfile).toBeNull();
+  });
+
+  test("does not persist when the turn carries no profile-change notice", async () => {
+    setLastNotifiedInferenceProfile.mockClear();
+    const state = readyState();
+
+    await dispatchAgentEvent(state, makeDeps(), messageCompleteEvent());
+
+    expect(setLastNotifiedInferenceProfile).not.toHaveBeenCalled();
+  });
+
+  test("persists exactly once across a multi-call turn", async () => {
+    setLastNotifiedInferenceProfile.mockClear();
+    const state = readyState();
+    state.pendingNotifiedInferenceProfile = PROFILE_KEY;
+    const deps = makeDeps();
+
+    await dispatchAgentEvent(state, deps, messageCompleteEvent());
+    await dispatchAgentEvent(state, deps, messageCompleteEvent());
+
+    expect(setLastNotifiedInferenceProfile).toHaveBeenCalledTimes(1);
+  });
+});

package/src/daemon/__tests__/native-web-search-metadata.test.ts

@@ -51,6 +51,7 @@ mock.module("../../memory/llm-request-log-store.js", () => ({
 }));
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
+import { WEB_SEARCH_BACKEND_FAILURE_MESSAGE } from "../../tools/network/web-search-error.js";
 import type {
   EventHandlerDeps,
   EventHandlerState,
@@ -95,6 +96,7 @@ function createCollectorDeps(providerName = "anthropic"): {
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
     } as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
   } as EventHandlerDeps;
   return { deps, events };
 }
@@ -257,9 +259,7 @@ describe("native server_tool_complete metadata", () => {
     );
     expect(toolResults).toHaveLength(2);
 
-    const byId = new Map(
-      toolResults.map((r) => [r.toolUseId, r] as const),
-    );
+    const byId = new Map(toolResults.map((r) => [r.toolUseId, r] as const));
     expect(byId.get("tu_a")?.activityMetadata?.webSearch?.query).toBe("alpha");
     expect(byId.get("tu_b")?.activityMetadata?.webSearch?.query).toBe("beta");
 
@@ -270,7 +270,7 @@ describe("native server_tool_complete metadata", () => {
     expect(durB).toBeGreaterThanOrEqual(durA);
   });
 
-  test("forwards provider error codes instead of generic 'Search failed'", async () => {
+  test("maps recoverable error codes to friendly copy, not the raw code", async () => {
     const { deps, events } = createCollectorDeps();
     const toolUseId = "tu_err_code";
 
@@ -292,9 +292,11 @@ describe("native server_tool_complete metadata", () => {
     const toolResultEvent = events.find(
       (e): e is ToolResultEvent => e.type === "tool_result",
     );
-    expect(toolResultEvent?.activityMetadata?.webSearch?.errorMessage).toBe(
-      "max_uses_exceeded",
-    );
+    const errorMessage =
+      toolResultEvent?.activityMetadata?.webSearch?.errorMessage;
+    // The raw provider code is never user-visible.
+    expect(errorMessage).not.toBe("max_uses_exceeded");
+    expect(errorMessage).toContain("web-search limit");
   });
 
   test("does NOT emit activityMetadata for non-Anthropic providers", async () => {
@@ -350,7 +352,7 @@ describe("native server_tool_complete metadata", () => {
       (e): e is ToolResultEvent => e.type === "tool_result",
     );
     const meta = toolResultEvent?.activityMetadata?.webSearch;
-    expect(meta?.errorMessage).toBe("Search failed");
+    expect(meta?.errorMessage).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
     expect(meta?.resultCount).toBe(0);
     expect(meta?.results).toEqual([]);
     expect(toolResultEvent?.isError).toBe(true);

package/src/daemon/assistant-attachments.ts

@@ -8,7 +8,7 @@
 import { readFileSync, statSync } from "node:fs";
 import { basename } from "node:path";
 
-import { isPlaceholderSentinelText } from "../providers/anthropic/client.js";
+import { isPlaceholderSentinelText } from "../providers/placeholder-sentinels.js";
 import {
   hostPolicy,
   sandboxPolicy,

package/src/daemon/config-watcher.ts

@@ -178,8 +178,8 @@ export class ConfigWatcher {
    * Start all file watchers. `onConversationEvict` is called when watched
    * files change and conversations need to be evicted for reload.
    * `onIdentityChanged` is called when IDENTITY.md changes on disk.
-   * `onIdentityIntroChanged` is called when SOUL.md changes and cached
-   * identity intro greetings should be invalidated.
+   * `onIdentityIntroChanged` is called when SOUL.md changes and identity
+   * intro subscribers should refetch.
    * `onSkillsChanged` is called after skill directory changes evict
    * conversations.
    */

package/src/daemon/context-overflow-reducer.ts

@@ -173,7 +173,6 @@ async function applyForcedCompaction(
   const compactionOptions: ContextWindowCompactOptions = {
     force: true,
     minKeepRecentUserTurns: 0,
-    targetInputTokensOverride: config.targetTokens,
   };
 
   const result = await compactFn(messages, signal, compactionOptions);