@vellumai/assistant 0.6.5 → 0.6.6

package/src/context/window-manager.ts

@@ -30,6 +30,118 @@ const COMPACTION_TOOL_RESULT_MAX_CHARS = 6_000;
 const MIN_COMPACTABLE_PERSISTED_MESSAGES = 2;
 const INTERNAL_CONTEXT_SUMMARY_MESSAGES = new WeakSet<Message>();
 
+/**
+ * When the existing summary is this fraction or more of the per-summary
+ * token budget, inject a "compress older content aggressively" instruction
+ * so incremental-update passes don't let the summary grow unboundedly.
+ */
+const SUMMARY_COMPRESSION_PRESSURE_RATIO = 0.6;
+
+/**
+ * Text-block prefixes that persist in live history (for prefix-caching
+ * stability and model grounding) but pollute the summarizer's view of the
+ * actual conversation. These blocks are system-metadata attached to user
+ * turns — memory injections, turn context, workspace hints, etc. They are
+ * stripped ONLY from the messages fed to the summarization LLM call. Live
+ * history is never mutated, so prefix caching is preserved.
+ *
+ * This list intentionally overlaps with `RUNTIME_INJECTION_PREFIXES` in
+ * `conversation-runtime-assembly.ts`. That list governs in-flight turn
+ * assembly via pure prefix matching; this one governs compaction input.
+ * Keep the two lists in sync when a new injection type is added.
+ *
+ * Compaction strip coverage is two-tier: this prefix list catches
+ * internal-vocabulary tags and any tag carrying the `__injected`
+ * attribute, while `COMPACTION_ONLY_WRAPPED_STRIP_TAGS` below matches
+ * ambiguous bare-tag blocks that are shaped like a runtime-emitted
+ * open/close wrap. A new ambiguous tag added upstream needs to be
+ * evaluated against both tiers — internal-vocabulary names go here,
+ * and names whose bare form collides with ordinary English
+ * (`<memory>`, `<workspace>`, `<knowledge_base>`, `<pkb>`,
+ * `<system_reminder>`) go in the wrapped-strip list so user prose
+ * mentioning the tag is preserved.
+ */
+const COMPACTION_ONLY_STRIP_PREFIXES = [
+  "<memory __injected>",
+  "<memory_image __injected>",
+  "</memory_image>",
+  "<memory_context __injected>",
+  "<turn_context>",
+  "<channel_turn_context>",
+  "<guardian_context>",
+  "<inbound_actor_context>",
+  "<interface_turn_context>",
+  "<workspace_top_level>",
+  "<now_scratchpad>",
+  "<NOW.md Always keep this up to date",
+  "<active_thread>",
+  "<active_subagents>",
+  "<active_workspace>",
+  "<active_dynamic_page>",
+  "<channel_capabilities>",
+  "<channel_command_context>",
+  "<voice_call_control>",
+  "<transport_hints>",
+  "<system_notice>",
+  "<non_interactive_context>",
+  "<temporal_context>",
+];
+
+/**
+ * Tags whose bare form (`<tag>`) is common English vocabulary or markup a
+ * user might legitimately type in prose. For these we only strip a text
+ * block if it is shaped exactly like a runtime injection: starts with
+ * `<tag>\n` and ends with `</tag>`. This bare-tag wrapped shape
+ * (e.g. `<memory>\n...\n</memory>`) appears in persisted history
+ * alongside the `__injected`-attributed variants, which the prefix list
+ * above already catches via `<memory __injected>`. A user who mentions
+ * `<memory>` in a sentence or inlines `<workspace>...</workspace>` within
+ * other prose will not match this shape.
+ */
+const COMPACTION_ONLY_WRAPPED_STRIP_TAGS = [
+  "memory",
+  "memory_context",
+  "workspace",
+  "knowledge_base",
+  "pkb",
+  "system_reminder",
+];
+
+function isCompactionInjectedBlock(text: string): boolean {
+  if (COMPACTION_ONLY_STRIP_PREFIXES.some((p) => text.startsWith(p))) {
+    return true;
+  }
+  return COMPACTION_ONLY_WRAPPED_STRIP_TAGS.some(
+    (tag) => text.startsWith(`<${tag}>\n`) && text.endsWith(`</${tag}>`),
+  );
+}
+
+/**
+ * Remove text blocks that look like runtime injections from user messages.
+ * Non-text blocks (images, tool_use, tool_result, etc.) are untouched.
+ * Empty messages (every block filtered out) are dropped from the output.
+ *
+ * Used only on the `compactableMessages` slice right before it is
+ * serialized for the summarization LLM — the caller's original message
+ * array is never mutated.
+ */
+export function stripCompactionOnlyInjections(messages: Message[]): Message[] {
+  return messages
+    .map((message) => {
+      if (message.role !== "user") return message;
+      const nextContent = message.content.filter((block) => {
+        if (block.type !== "text") return true;
+        return !isCompactionInjectedBlock(block.text);
+      });
+      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,
+    );
+}
+
 /**
  * Load the compaction summary system prompt from the bundled markdown asset.
  *
@@ -57,18 +169,27 @@ export function loadCompactPrompt(): string {
  * rather than failing module import at startup.
  */
 const SUMMARY_PROMPT_FALLBACK = [
-  "You compress long assistant conversations into durable working memory.",
-  "Focus on actionable state, not prose.",
-  "Preserve concrete facts: goals, constraints, decisions, pending questions, file paths, commands, errors, and TODOs.",
-  "Remove repetition and stale details that were superseded.",
-  'Thread anchors: when a "Retained Thread References" section is present, each listed reply cites its parent via `→ Mxxxxxx`. If that parent appears in the Transcript, preserve its text verbatim (reactions may be aggregated as "N users reacted"). Omit when the section is absent.',
-  "Return concise markdown using these section headers exactly:",
-  "## Goals",
-  "## Constraints",
-  "## Decisions",
-  "## Open Conversations",
-  "## Key Artifacts",
-  "## Recent Progress",
+  "You are summarizing a long conversation so that the assistant can keep working with it after older messages are dropped. Your summary will REPLACE those messages — the assistant's only access to what was said earlier will be what you write here.",
+  "",
+  "Be thorough. Capture what happened, why it mattered, what's unresolved, and what was felt. Do not compress away emotional tone, relationship context, or nuance. Keep specific details (names, numbers, file paths, commands, URLs, exact phrasings) when they might matter later.",
+  "",
+  "Target length: aim for 1500–4000 tokens. Use the upper end when the conversation is rich in decisions, relationships, emotional content, or threads that are still open. Use the lower end for short or simple task execution.",
+  "",
+  "Open with a 1–2 paragraph narrative describing what the conversation is about and where it currently stands. Then use `## ` section headers. Use these when they apply; skip sections that have nothing to say; add your own headers when something doesn't fit:",
+  "- `## What We're Working On`",
+  "- `## Decisions & Commitments`",
+  "- `## Facts Worth Remembering`",
+  "- `## Open Threads`",
+  "- `## Emotional Arc / Relationship Notes` (include when relevant)",
+  "- `## Artifacts & References`",
+  "",
+  "If an existing summary is provided, update it: merge new information in, prefer the most recent and explicit detail on conflicts, and preserve anything still unresolved or still true. Do not restart from scratch.",
+  "",
+  "Never include in the summary: content inside `<memory __injected>`, `<memory>`, `<turn_context>`, `<workspace>`, `<knowledge_base>`, `<system_reminder>`, `<now_scratchpad>`, `<NOW.md …>`, `<active_thread>`, `<channel_capabilities>`, `<transport_hints>`, `<system_notice>`, or any other angle-bracket-tagged system blocks. Tool-call boilerplate (retries, failed attempts the assistant recovered from, routine status updates) — summarize the outcome instead. Repetitive chit-chat that adds nothing.",
+  "",
+  'Thread anchors (Slack only): if the input includes a "Retained Thread References" section, each listed reply cites its parent via `→ Mxxxxxx`. If that parent appears in the Transcript, preserve its text verbatim. Omit when absent.',
+  "",
+  "Return only the summary itself in markdown — no preamble, no meta-commentary.",
 ].join("\n");
 
 /**
@@ -535,8 +656,14 @@ export class ContextWindowManager {
     const retainedThreadRefs = collectRetainedThreadReferences(
       messages.slice(keepPlan.keepFromIndex),
     );
+    // Strip runtime injections (memory, turn context, workspace hints, etc.)
+    // from the messages fed to the summarizer. These blocks are system
+    // metadata; leaving them in causes the summary to echo rotating memory
+    // content instead of the actual conversation. The caller's live message
+    // array is untouched so prefix caching stays intact.
+    const transcriptSource = stripCompactionOnlyInjections(compactableMessages);
     const transcriptBlocks = this.capTranscriptBlocksToTokenBudget(
-      serializeMessagesToContentBlocks(compactableMessages),
+      serializeMessagesToContentBlocks(transcriptSource),
       existingSummary ?? "No previous summary.",
       retainedThreadRefs,
     );
@@ -882,10 +1009,18 @@ export class ContextWindowManager {
      */
     failed: boolean;
   }> {
+    // When the existing summary is already consuming most of its budget,
+    // nudge the model to compress older durable content aggressively so
+    // incremental-update passes don't let the summary grow unboundedly.
+    const existingSummaryTokens = estimateTextTokens(currentSummary);
+    const compressionPressure =
+      existingSummaryTokens >=
+      this.summaryMaxTokens * SUMMARY_COMPRESSION_PRESSURE_RATIO;
     const contentBlocks = buildSummaryContentBlocks(
       currentSummary,
       transcriptBlocks,
       retainedThreadRefs,
+      { compressionPressure },
     );
     const summaryMessage: Message = { role: "user", content: contentBlocks };
     let failed = false;
@@ -895,7 +1030,10 @@ export class ContextWindowManager {
         undefined,
         SUMMARY_SYSTEM_PROMPT,
         {
-          config: { max_tokens: this.summaryMaxTokens },
+          config: {
+            callSite: "conversationSummarization" as const,
+            max_tokens: this.summaryMaxTokens,
+          },
           signal,
         },
       );
@@ -942,10 +1080,38 @@ export class ContextWindowManager {
     // Budget in tokens → approximate char limit (4 chars ≈ 1 token).
     const maxChars = this.summaryMaxTokens * 4;
     if (summary.length <= maxChars) return summary;
-    return `${safeStringSlice(summary, 0, maxChars)}...`;
+    return clampSummaryAtSectionBoundary(summary, maxChars);
   }
 }
 
+/**
+ * Truncate a markdown summary that exceeds `maxChars`, preferring a
+ * section boundary (`\n## `) so we never cut a heading mid-text. Falls
+ * back to a hard character slice when no boundary exists in the safe
+ * region (first half of the budget).
+ */
+export function clampSummaryAtSectionBoundary(
+  summary: string,
+  maxChars: number,
+): string {
+  if (summary.length <= maxChars) return summary;
+  const ELLIPSIS = "...";
+  // Hard limit we must stay under, leaving room for the ellipsis suffix.
+  const cutoff = maxChars - ELLIPSIS.length;
+  if (cutoff <= 0) return ELLIPSIS;
+  const head = safeStringSlice(summary, 0, cutoff);
+  // Find the last `## ` heading at a line start. Require it to be past the
+  // midpoint of the allowed region so we don't drop most of the summary
+  // just to hit a boundary — better to cut mid-section late than to keep
+  // almost nothing.
+  const halfway = Math.floor(cutoff / 2);
+  const boundary = head.lastIndexOf("\n## ");
+  if (boundary >= halfway) {
+    return `${head.slice(0, boundary).trimEnd()}\n${ELLIPSIS}`;
+  }
+  return `${head}${ELLIPSIS}`;
+}
+
 function collectUserTurnStartIndexes(messages: Message[]): number[] {
   const starts: number[] = [];
   for (let i = 0; i < messages.length; i++) {
@@ -1092,17 +1258,25 @@ function buildSummaryContentBlocks(
   currentSummary: string,
   transcriptBlocks: ContentBlock[],
   retainedThreadRefs: string[],
+  options: { compressionPressure: boolean } = { compressionPressure: false },
 ): ContentBlock[] {
   const lines = [
     "Update the summary with new transcript data.",
     "If new information conflicts with older notes, keep the most recent and explicit detail.",
     "Keep all unresolved asks and next steps.",
     "For any images included below, describe their visual content in the summary so the information is preserved after compaction.",
+  ];
+  if (options.compressionPressure) {
+    lines.push(
+      "The existing summary is approaching its token budget. Compress older durable content aggressively (drop detail that is no longer load-bearing, merge bullets, tighten prose) while preserving the most recent turns' nuance.",
+    );
+  }
+  lines.push(
     "",
     "### Existing Summary",
     currentSummary.trim().length > 0 ? currentSummary.trim() : "None.",
     "",
-  ];
+  );
   if (retainedThreadRefs.length > 0) {
     lines.push(
       "### Retained Thread References",

package/src/credential-health/credential-health-service.ts

@@ -16,6 +16,7 @@ import {
   oauthConnectionAccessTokenPath,
 } from "@vellumai/credential-storage";
 
+import { manualTokenAccessCredentialKey } from "../oauth/manual-token-connection.js";
 import {
   getProvider,
   listActiveConnectionsByProvider,
@@ -100,7 +101,9 @@ async function pingProvider(
 
   const body =
     method !== "GET" && pingBody
-      ? (typeof pingBody === "string" ? pingBody : JSON.stringify(pingBody))
+      ? typeof pingBody === "string"
+        ? pingBody
+        : JSON.stringify(pingBody)
       : undefined;
 
   try {
@@ -155,12 +158,22 @@ async function checkConnection(
     pingBody,
   } = opts;
 
-  const base = { connectionId, provider, accountInfo, missingScopes: [] as string[] };
+  const base = {
+    connectionId,
+    provider,
+    accountInfo,
+    missingScopes: [] as string[],
+  };
 
-  // 1. Check token presence
-  const token = await getSecureKeyAsync(
-    oauthConnectionAccessTokenPath(connectionId),
-  );
+  // 1. Check token presence. Manual-token providers (e.g. slack_channel,
+  // telegram) store their primary token under credential/<provider>/<field>
+  // rather than oauth_connection/<id>/access_token, so resolve the correct
+  // path before looking up the token — otherwise the lookup always returns
+  // null and marks these providers as "missing_token".
+  const tokenPath =
+    manualTokenAccessCredentialKey(provider) ??
+    oauthConnectionAccessTokenPath(connectionId);
+  const token = await getSecureKeyAsync(tokenPath);
   if (!token) {
     return {
       ...base,

package/src/daemon/__tests__/conversation-feed-event.test.ts

@@ -0,0 +1,317 @@
+/**
+ * Tests for the background conversation feed event emission logic in
+ * conversation-agent-loop.ts.
+ *
+ * Rather than running the full agent loop, these tests exercise the
+ * extraction logic in isolation by simulating the conditions under which
+ * emitFeedEvent is called: conversation type, message content, and title.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module-level mocks — must be in place before importing the module under test
+// ---------------------------------------------------------------------------
+
+const emitFeedEventSpy = mock<
+  (params: {
+    source: string;
+    title: string;
+    summary: string;
+    dedupKey?: string;
+  }) => Promise<unknown>
+>(async () => ({}));
+
+mock.module("../../home/emit-feed-event.js", () => ({
+  emitFeedEvent: emitFeedEventSpy,
+}));
+
+const getConversationSpy = mock<
+  (id: string) => {
+    conversationType: string;
+    title: string | null;
+  } | null
+>(() => null);
+
+const getMessageByIdSpy = mock<
+  (
+    messageId: string,
+    conversationId?: string,
+  ) => { id: string; content: string } | null
+>(() => null);
+
+// We need to stub enough of conversation-crud to avoid DB initialization.
+// The actual agent loop imports getConversation and getMessageById from
+// conversation-crud — we intercept those here for test assertions.
+mock.module("../../memory/conversation-crud.js", () => ({
+  getConversation: getConversationSpy,
+  getMessageById: getMessageByIdSpy,
+  // Stubs for other exports that may be transitively referenced:
+  addMessage: () => {},
+  clearStrippedInjectionMetadataForConversation: () => {},
+  deleteMessageById: () => {},
+  getConversationOriginChannel: () => null,
+  getConversationOriginInterface: () => null,
+  getLastUserTimestampBefore: () => null,
+  provenanceFromTrustContext: () => ({}),
+  updateConversationContextWindow: () => {},
+  updateConversationTitle: () => {},
+  updateMessageMetadata: () => {},
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Simulates the feed-event emission logic from conversation-agent-loop.ts.
+ *
+ * This mirrors the block inserted after `message_complete` so we can test it
+ * in isolation without spinning up the full agent loop infrastructure.
+ */
+/**
+ * Tracks the last warning logged by simulateFeedEventEmission, so tests can
+ * assert that malformed content is swallowed gracefully.
+ */
+let lastFeedEventWarning: unknown = undefined;
+
+function simulateFeedEventEmission(
+  conversationId: string,
+  lastAssistantMessageId: string | undefined,
+): void {
+  lastFeedEventWarning = undefined;
+  try {
+    const conv = getConversationSpy(conversationId);
+    if (
+      conv &&
+      (conv.conversationType === "background" ||
+        conv.conversationType === "scheduled")
+    ) {
+      const lastMsg = lastAssistantMessageId
+        ? getMessageByIdSpy(lastAssistantMessageId, conversationId)
+        : undefined;
+      let summary: string;
+      if (lastMsg) {
+        const parsed: unknown = JSON.parse(lastMsg.content);
+        if (typeof parsed === "string") {
+          summary = parsed.slice(0, 200);
+        } else if (Array.isArray(parsed)) {
+          const textBlock = (
+            parsed as Array<{ type?: string; text?: string }>
+          ).find((b) => b.type === "text");
+          summary =
+            typeof textBlock?.text === "string"
+              ? textBlock.text.slice(0, 200)
+              : (conv.title ?? "Background task completed.");
+        } else {
+          summary = conv.title ?? "Background task completed.";
+        }
+      } else {
+        summary = conv.title ?? "Background task completed.";
+      }
+      void emitFeedEventSpy({
+        source: "assistant",
+        title: conv.title ?? "Background Task",
+        summary,
+        dedupKey: `bg-conv:${conversationId}`,
+      });
+    }
+  } catch (feedErr) {
+    lastFeedEventWarning = feedErr;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("background conversation feed event", () => {
+  beforeEach(() => {
+    emitFeedEventSpy.mockClear();
+    getConversationSpy.mockClear();
+    getMessageByIdSpy.mockClear();
+  });
+
+  afterEach(() => {
+    emitFeedEventSpy.mockReset();
+    getConversationSpy.mockReset();
+    getMessageByIdSpy.mockReset();
+  });
+
+  test("emits feed event for background conversation with text content", () => {
+    const convId = "conv-bg-123";
+    const msgId = "msg-456";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Nightly Cleanup",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: JSON.stringify([
+        { type: "text", text: "Cleaned up 42 files successfully." },
+      ]),
+    });
+
+    simulateFeedEventEmission(convId, msgId);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    expect(emitFeedEventSpy).toHaveBeenCalledWith({
+      source: "assistant",
+      title: "Nightly Cleanup",
+      summary: "Cleaned up 42 files successfully.",
+      dedupKey: `bg-conv:${convId}`,
+    });
+  });
+
+  test("emits feed event for scheduled conversation", () => {
+    const convId = "conv-sched-789";
+    const msgId = "msg-101";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "scheduled",
+      title: "Weekly Report",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: JSON.stringify([{ type: "text", text: "Report generated." }]),
+    });
+
+    simulateFeedEventEmission(convId, msgId);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    expect(emitFeedEventSpy).toHaveBeenCalledWith({
+      source: "assistant",
+      title: "Weekly Report",
+      summary: "Report generated.",
+      dedupKey: `bg-conv:${convId}`,
+    });
+  });
+
+  test("truncates summary to 200 characters", () => {
+    const convId = "conv-bg-long";
+    const msgId = "msg-long";
+    const longText = "A".repeat(300);
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Long Task",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: JSON.stringify([{ type: "text", text: longText }]),
+    });
+
+    simulateFeedEventEmission(convId, msgId);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    const call = emitFeedEventSpy.mock.calls[0]![0];
+    expect(call.summary).toHaveLength(200);
+    expect(call.summary).toBe(longText.slice(0, 200));
+  });
+
+  test("falls back to conversation title when no text block in content", () => {
+    const convId = "conv-bg-notext";
+    const msgId = "msg-notext";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Image Task",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: JSON.stringify([{ type: "image", source: { data: "..." } }]),
+    });
+
+    simulateFeedEventEmission(convId, msgId);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    expect(emitFeedEventSpy.mock.calls[0]![0].summary).toBe("Image Task");
+  });
+
+  test("falls back to default summary when no message and no title", () => {
+    const convId = "conv-bg-notitle";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: null,
+    });
+
+    simulateFeedEventEmission(convId, undefined);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    const call = emitFeedEventSpy.mock.calls[0]![0];
+    expect(call.title).toBe("Background Task");
+    expect(call.summary).toBe("Background task completed.");
+  });
+
+  test("does NOT emit feed event for standard (foreground) conversations", () => {
+    const convId = "conv-standard-1";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "standard",
+      title: "Regular Chat",
+    });
+
+    simulateFeedEventEmission(convId, undefined);
+
+    expect(emitFeedEventSpy).not.toHaveBeenCalled();
+  });
+
+  test("does NOT emit feed event for private conversations", () => {
+    const convId = "conv-private-1";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "private",
+      title: "Secret Chat",
+    });
+
+    simulateFeedEventEmission(convId, undefined);
+
+    expect(emitFeedEventSpy).not.toHaveBeenCalled();
+  });
+
+  test("uses dedupKey per conversation for in-place updates", () => {
+    const convId = "conv-bg-dedup";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Recurring Job",
+    });
+
+    // First run
+    simulateFeedEventEmission(convId, undefined);
+    // Second run (re-run of same conversation)
+    simulateFeedEventEmission(convId, undefined);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(2);
+    // Both calls use the same dedupKey
+    expect(emitFeedEventSpy.mock.calls[0]![0].dedupKey).toBe(
+      `bg-conv:${convId}`,
+    );
+    expect(emitFeedEventSpy.mock.calls[1]![0].dedupKey).toBe(
+      `bg-conv:${convId}`,
+    );
+  });
+
+  test("swallows malformed JSON content without throwing", () => {
+    const convId = "conv-bg-badjson";
+    const msgId = "msg-badjson";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Bad JSON Task",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: "this is not valid JSON {{{",
+    });
+
+    // Should not throw
+    expect(() => simulateFeedEventEmission(convId, msgId)).not.toThrow();
+    // The error was caught and logged as a warning
+    expect(lastFeedEventWarning).toBeInstanceOf(SyntaxError);
+    // emitFeedEvent should NOT have been called
+    expect(emitFeedEventSpy).not.toHaveBeenCalled();
+  });
+});

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

@@ -7,9 +7,9 @@
  * `auto-analyze` feature flag and source-type guard).
  *
  * We stub the downstream enqueue helpers and the side-effecting lifecycle
- * deps (hook manager, notifier/skill cleanup, browser-screencast) so the test
- * can invoke `disposeConversation` with a minimal `DisposeContext` and assert
- * on the enqueue bookkeeping alone.
+ * deps (notifier/skill cleanup, browser-screencast) so the test can invoke
+ * `disposeConversation` with a minimal `DisposeContext` and assert on the
+ * enqueue bookkeeping alone.
  *
  * Two recursion guards apply when the source conversation is itself an
  * auto-analysis conversation:
@@ -83,19 +83,12 @@ mock.module("../../memory/auto-analysis-enqueue.js", () => ({
 
 // Stub all side-effecting cleanup helpers that disposeConversation chains
 // into after the enqueue block. We assert on enqueue behavior only.
-mock.module("../../hooks/manager.js", () => ({
-  getHookManager: () => ({
-    trigger: () => undefined,
-  }),
-}));
-
 mock.module("../../tools/browser/browser-screencast.js", () => ({
   unregisterConversationSender: () => {},
 }));
 
 mock.module("../conversation-notifiers.js", () => ({
   unregisterCallNotifiers: () => {},
-  unregisterWatchNotifiers: () => {},
 }));
 
 mock.module("../conversation-skill-tools.js", () => ({
@@ -105,8 +98,7 @@ mock.module("../conversation-skill-tools.js", () => ({
 // Dynamic import after mock.module calls so stubs take effect.
 const { disposeConversation } = await import("../conversation-lifecycle.js");
 type DisposeContext = import("../conversation-lifecycle.js").DisposeContext;
-type TrustClass =
-  import("../../runtime/actor-trust-resolver.js").TrustClass;
+type TrustClass = import("../../runtime/actor-trust-resolver.js").TrustClass;
 
 // ---------------------------------------------------------------------------
 // Fixture builder — minimal DisposeContext satisfying the interface shape.