@vellumai/assistant 0.6.3 → 0.6.5

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -1,12 +1,31 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
+
+// PKB search is mocked so the reminder-hints tests can assert behavior
+// without standing up Qdrant. The mock returns whatever is staged in
+// `pkbSearchResults` / `pkbSearchThrows` for the enclosing test.
+let pkbSearchResults: Array<{
+  path: string;
+  denseScore: number;
+  hybridScore?: number;
+}> = [];
+let pkbSearchThrows: Error | null = null;
+mock.module("../memory/pkb/pkb-search.js", () => ({
+  searchPkbFiles: async () => {
+    if (pkbSearchThrows) throw pkbSearchThrows;
+    return pkbSearchResults;
+  },
+}));
 
 import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type {
   ChannelCapabilities,
+  SlackTranscriptInputRow,
   UnifiedTurnContextOptions,
 } from "../daemon/conversation-runtime-assembly.js";
 import {
   applyRuntimeInjections,
+  assembleSlackActiveThreadFocusBlock,
+  assembleSlackChronologicalMessages,
   buildSubagentStatusBlock,
   buildUnifiedTurnContextBlock,
   findLastInjectedNowContent,
@@ -15,11 +34,21 @@ import {
   injectNowScratchpad,
   injectSubagentStatus,
   isGroupChatType,
+  isSlackChannelConversation,
+  loadSlackActiveThreadFocusBlock,
+  loadSlackChronologicalMessages,
   resolveChannelCapabilities,
   stripChannelCapabilityContext,
   stripInjectionsForCompaction,
   stripNowScratchpad,
 } from "../daemon/conversation-runtime-assembly.js";
+import { buildPkbReminder } from "../daemon/pkb-reminder-builder.js";
+import type { MessageRow } from "../memory/conversation-crud.js";
+import {
+  type SlackMessageMetadata,
+  writeSlackMetadata,
+} from "../messaging/providers/slack/message-metadata.js";
+import { parentAlias } from "../messaging/providers/slack/render-transcript.js";
 import type { Message } from "../providers/types.js";
 import type { SubagentState } from "../subagent/types.js";
 
@@ -345,6 +374,56 @@ describe("isGroupChatType", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// isSlackChannelConversation
+// ---------------------------------------------------------------------------
+
+describe("isSlackChannelConversation", () => {
+  const base = {
+    dashboardCapable: false,
+    supportsDynamicUi: false,
+    supportsVoiceInput: false,
+  } as const;
+
+  test("returns true for Slack channels (chatType === channel)", () => {
+    expect(
+      isSlackChannelConversation({
+        channel: "slack",
+        chatType: "channel",
+        ...base,
+      }),
+    ).toBe(true);
+  });
+
+  test("returns false for Slack DMs regardless of chatType shape", () => {
+    // Gateway omits chatType entirely for DM message events, so
+    // `isSlackChannelConversation` must return false for both the
+    // `chatType === undefined` and `chatType === "im"` shapes.
+    expect(isSlackChannelConversation({ channel: "slack", ...base })).toBe(
+      false,
+    );
+    expect(
+      isSlackChannelConversation({
+        channel: "slack",
+        chatType: "im",
+        ...base,
+      }),
+    ).toBe(false);
+  });
+
+  test("returns false for non-Slack channels", () => {
+    expect(
+      isSlackChannelConversation({
+        channel: "telegram",
+        chatType: "channel",
+        ...base,
+      }),
+    ).toBe(false);
+    expect(isSlackChannelConversation(null)).toBe(false);
+    expect(isSlackChannelConversation()).toBe(false);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // stripChannelCapabilityContext
 // ---------------------------------------------------------------------------
@@ -422,7 +501,7 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
     },
   ];
 
-  test("injects channel capabilities when provided", () => {
+  test("injects channel capabilities when provided", async () => {
     const caps: ChannelCapabilities = {
       channel: "telegram",
       dashboardCapable: false,
@@ -430,7 +509,7 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
       supportsVoiceInput: false,
     };
 
-    const result = applyRuntimeInjections(baseMessages, {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       channelCapabilities: caps,
     });
 
@@ -442,8 +521,8 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
     );
   });
 
-  test("does not inject when channelCapabilities is null", () => {
-    const result = applyRuntimeInjections(baseMessages, {
+  test("does not inject when channelCapabilities is null", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       channelCapabilities: null,
     });
 
@@ -451,14 +530,14 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
     expect(result[0].content.length).toBe(1);
   });
 
-  test("does not inject when channelCapabilities is omitted", () => {
-    const result = applyRuntimeInjections(baseMessages, {});
+  test("does not inject when channelCapabilities is omitted", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
 
     expect(result.length).toBe(1);
     expect(result[0].content.length).toBe(1);
   });
 
-  test("combines with other injections", () => {
+  test("combines with other injections", async () => {
     const caps: ChannelCapabilities = {
       channel: "telegram",
       dashboardCapable: false,
@@ -466,7 +545,7 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
       supportsVoiceInput: false,
     };
 
-    const result = applyRuntimeInjections(baseMessages, {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       channelCapabilities: caps,
     });
 
@@ -612,8 +691,11 @@ describe("applyRuntimeInjections — injection mode", () => {
     isNonInteractive: true,
   };
 
-  test("full mode (default) includes all injections", () => {
-    const result = applyRuntimeInjections(baseMessages, fullOptions);
+  test("full mode (default) includes all injections", async () => {
+    const { messages: result } = await applyRuntimeInjections(
+      baseMessages,
+      fullOptions,
+    );
     const allText = result[0].content
       .filter((b): b is { type: "text"; text: string } => b.type === "text")
       .map((b) => b.text)
@@ -627,11 +709,11 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).toContain("<non_interactive_context>");
     expect(allText).toContain("<NOW.md");
     expect(allText).toContain("<system_reminder>");
-    expect(allText).toContain("<pkb>");
+    expect(allText).toContain("<knowledge_base>");
   });
 
-  test("explicit mode: 'full' behaves the same as default", () => {
-    const result = applyRuntimeInjections(baseMessages, {
+  test("explicit mode: 'full' behaves the same as default", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       ...fullOptions,
       mode: "full",
     });
@@ -646,8 +728,8 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).toContain("<NOW.md");
   });
 
-  test("minimal mode skips high-token optional blocks", () => {
-    const result = applyRuntimeInjections(baseMessages, {
+  test("minimal mode skips high-token optional blocks", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       ...fullOptions,
       mode: "minimal",
     });
@@ -662,11 +744,11 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).not.toContain("<active_workspace>");
     expect(allText).not.toContain("<NOW.md");
     expect(allText).not.toContain("<system_reminder>");
-    expect(allText).not.toContain("<pkb>");
+    expect(allText).not.toContain("<knowledge_base>");
   });
 
-  test("minimal mode preserves safety-critical blocks", () => {
-    const result = applyRuntimeInjections(baseMessages, {
+  test("minimal mode preserves safety-critical blocks", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       ...fullOptions,
       mode: "minimal",
     });
@@ -681,23 +763,29 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).toContain("<channel_capabilities>");
   });
 
-  test("minimal mode produces strictly fewer content blocks than full mode", () => {
-    const fullResult = applyRuntimeInjections(baseMessages, {
-      ...fullOptions,
-      mode: "full",
-    });
-    const minimalResult = applyRuntimeInjections(baseMessages, {
-      ...fullOptions,
-      mode: "minimal",
-    });
+  test("minimal mode produces strictly fewer content blocks than full mode", async () => {
+    const { messages: fullResult } = await applyRuntimeInjections(
+      baseMessages,
+      {
+        ...fullOptions,
+        mode: "full",
+      },
+    );
+    const { messages: minimalResult } = await applyRuntimeInjections(
+      baseMessages,
+      {
+        ...fullOptions,
+        mode: "minimal",
+      },
+    );
 
     expect(minimalResult[0].content.length).toBeLessThan(
       fullResult[0].content.length,
     );
   });
 
-  test("minimal mode still preserves the original user message text", () => {
-    const result = applyRuntimeInjections(baseMessages, {
+  test("minimal mode still preserves the original user message text", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       ...fullOptions,
       mode: "minimal",
     });
@@ -730,7 +818,7 @@ describe("injectNowScratchpad", () => {
     expect(injected.type).toBe("text");
     const text = (injected as { type: "text"; text: string }).text;
     expect(text).toBe(
-      "<NOW.md Always keep this up to date>\nCurrent focus: shipping PR 3\n</NOW.md>",
+      "<NOW.md Always keep this up to date; keep under 10 lines>\nCurrent focus: shipping PR 3\n</NOW.md>",
     );
     // Original content comes last
     expect((result.content[1] as { type: "text"; text: string }).text).toBe(
@@ -1015,8 +1103,8 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
     },
   ];
 
-  test("injects NOW.md block when provided", () => {
-    const result = applyRuntimeInjections(baseMessages, {
+  test("injects NOW.md block when provided", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       nowScratchpad: "Current focus: fix the bug",
     });
 
@@ -1028,8 +1116,8 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
     expect(text).toContain("Current focus: fix the bug");
   });
 
-  test("scratchpad appears before user's original text content", () => {
-    const result = applyRuntimeInjections(baseMessages, {
+  test("scratchpad appears before user's original text content", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       nowScratchpad: "scratchpad notes",
     });
 
@@ -1043,8 +1131,8 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
     );
   });
 
-  test("does not inject when nowScratchpad is null", () => {
-    const result = applyRuntimeInjections(baseMessages, {
+  test("does not inject when nowScratchpad is null", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       nowScratchpad: null,
     });
 
@@ -1052,15 +1140,15 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
     expect(result[0].content.length).toBe(1);
   });
 
-  test("does not inject when nowScratchpad is omitted", () => {
-    const result = applyRuntimeInjections(baseMessages, {});
+  test("does not inject when nowScratchpad is omitted", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
 
     expect(result.length).toBe(1);
     expect(result[0].content.length).toBe(1);
   });
 
-  test("skipped in minimal mode", () => {
-    const result = applyRuntimeInjections(baseMessages, {
+  test("skipped in minimal mode", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       nowScratchpad: "Current focus: fix the bug",
       mode: "minimal",
     });
@@ -1391,6 +1479,61 @@ describe("buildUnifiedTurnContextBlock", () => {
     expect(text).toContain("contact_notes: Prefers short replies");
     expect(text).toContain("contact_interaction_count: 42");
   });
+
+  test("time_since_last_message: emitted right after current_time when provided", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "macos",
+      timeSinceLastMessage: "2d ago",
+    };
+
+    const text = buildUnifiedTurnContextBlock(options);
+    const lines = text.split("\n");
+    expect(lines[0]).toBe("<turn_context>");
+    expect(lines[1]).toBe("current_time: 2026-04-02T12:00:00Z");
+    expect(lines[2]).toBe("time_since_last_message: 2d ago");
+    expect(lines[3]).toBe("interface: macos");
+    expect(lines[4]).toBe("</turn_context>");
+  });
+
+  test("time_since_last_message: omitted when null", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "macos",
+      timeSinceLastMessage: null,
+    };
+
+    const text = buildUnifiedTurnContextBlock(options);
+    expect(text).not.toContain("time_since_last_message");
+  });
+
+  test("time_since_last_message: omitted when field absent (backward-compat)", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "macos",
+    };
+
+    const text = buildUnifiedTurnContextBlock(options);
+    expect(text).not.toContain("time_since_last_message");
+  });
+
+  test("time_since_last_message: works on non-guardian path", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "telegram",
+      channelName: "telegram",
+      timeSinceLastMessage: "yesterday",
+      actorContext: {
+        sourceChannel: "telegram",
+        canonicalActorIdentity: "user-1",
+        trustClass: "trusted_contact",
+      },
+    };
+
+    const text = buildUnifiedTurnContextBlock(options);
+    expect(text).toContain("time_since_last_message: yesterday");
+    expect(text).toContain("canonical_actor_identity: user-1");
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -1408,8 +1551,8 @@ describe("applyRuntimeInjections with unifiedTurnContext", () => {
   const sampleBlock =
     "<turn_context>\ncurrent_time: 2026-04-02T12:00:00Z\ninterface: macos\n</turn_context>";
 
-  test("injects unifiedTurnContext when provided", () => {
-    const result = applyRuntimeInjections(baseMessages, {
+  test("injects unifiedTurnContext when provided", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       unifiedTurnContext: sampleBlock,
     });
 
@@ -1424,8 +1567,8 @@ describe("applyRuntimeInjections with unifiedTurnContext", () => {
     );
   });
 
-  test("does not inject when unifiedTurnContext is null", () => {
-    const result = applyRuntimeInjections(baseMessages, {
+  test("does not inject when unifiedTurnContext is null", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       unifiedTurnContext: null,
     });
 
@@ -1433,15 +1576,15 @@ describe("applyRuntimeInjections with unifiedTurnContext", () => {
     expect(result[0].content).toHaveLength(1);
   });
 
-  test("does not inject when unifiedTurnContext is omitted", () => {
-    const result = applyRuntimeInjections(baseMessages, {});
+  test("does not inject when unifiedTurnContext is omitted", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
 
     expect(result).toHaveLength(1);
     expect(result[0].content).toHaveLength(1);
   });
 
-  test("injected in full mode", () => {
-    const result = applyRuntimeInjections(baseMessages, {
+  test("injected in full mode", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       unifiedTurnContext: sampleBlock,
       mode: "full",
     });
@@ -1454,8 +1597,8 @@ describe("applyRuntimeInjections with unifiedTurnContext", () => {
     expect(allText).toContain("<turn_context>");
   });
 
-  test("injected in minimal mode (no mode guard)", () => {
-    const result = applyRuntimeInjections(baseMessages, {
+  test("injected in minimal mode (no mode guard)", async () => {
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
       unifiedTurnContext: sampleBlock,
       mode: "minimal",
     });
@@ -1469,6 +1612,55 @@ describe("applyRuntimeInjections with unifiedTurnContext", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// applyRuntimeInjections blocks.unifiedTurnContext
+// ---------------------------------------------------------------------------
+
+describe("applyRuntimeInjections blocks.unifiedTurnContext", () => {
+  const userTailMessages: Message[] = [
+    {
+      role: "user",
+      content: [{ type: "text", text: "Hello there" }],
+    },
+  ];
+
+  const sampleBlock =
+    "<turn_context>\ncurrent_time: 2026-04-02T12:00:00Z\ninterface: macos\n</turn_context>";
+
+  test("captures unifiedTurnContext when tail is a user message", async () => {
+    const result = await applyRuntimeInjections(userTailMessages, {
+      unifiedTurnContext: sampleBlock,
+    });
+
+    expect(result.blocks.unifiedTurnContext).toBe(sampleBlock);
+  });
+
+  test("does not capture when tail is not a user message", async () => {
+    const assistantTailMessages: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "Hello" }],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Hi back" }],
+      },
+    ];
+
+    const result = await applyRuntimeInjections(assistantTailMessages, {
+      unifiedTurnContext: sampleBlock,
+    });
+
+    expect(result.blocks.unifiedTurnContext).toBeUndefined();
+  });
+
+  test("does not capture when unifiedTurnContext option is absent", async () => {
+    const result = await applyRuntimeInjections(userTailMessages, {});
+
+    expect(result.blocks.unifiedTurnContext).toBeUndefined();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // findLastInjectedNowContent
 // ---------------------------------------------------------------------------
@@ -1668,8 +1860,8 @@ describe("applyRuntimeInjections — subagent status", () => {
     content: [{ type: "text", text: "user message" }],
   };
 
-  test("includes subagent status in full mode", () => {
-    const result = applyRuntimeInjections([userMsg], {
+  test("includes subagent status in full mode", async () => {
+    const { messages: result } = await applyRuntimeInjections([userMsg], {
       subagentStatusBlock:
         "<active_subagents>\n- [running] test\n</active_subagents>",
       mode: "full",
@@ -1681,8 +1873,8 @@ describe("applyRuntimeInjections — subagent status", () => {
     expect(texts.some((t) => t.includes("<active_subagents>"))).toBe(true);
   });
 
-  test("skips subagent status in minimal mode", () => {
-    const result = applyRuntimeInjections([userMsg], {
+  test("skips subagent status in minimal mode", async () => {
+    const { messages: result } = await applyRuntimeInjections([userMsg], {
       subagentStatusBlock:
         "<active_subagents>\n- [running] test\n</active_subagents>",
       mode: "minimal",
@@ -1717,3 +1909,2546 @@ describe("stripInjectionsForCompaction — subagent status", () => {
     expect(texts).toContain("hello");
   });
 });
+
+// ---------------------------------------------------------------------------
+// applyRuntimeInjections — PKB relevance hints
+// ---------------------------------------------------------------------------
+
+describe("applyRuntimeInjections — PKB relevance hints", () => {
+  const baseMessages: Message[] = [
+    {
+      role: "user",
+      content: [{ type: "text", text: "Tell me about project foo" }],
+    },
+  ];
+
+  const FLAT_REMINDER = buildPkbReminder([]);
+
+  // Use a platform-agnostic absolute workspace root so the tests work on
+  // macOS and Linux runners alike. `pkbRoot` sits under `pkbWorkingDir` to
+  // mirror production, where `pkbRoot = join(workingDir, "pkb")`.
+  const pkbWorkingDir = "/tmp/fake-workspace";
+  const pkbRoot = `${pkbWorkingDir}/pkb`;
+
+  function makePkbOptions(overrides: Record<string, unknown> = {}) {
+    return {
+      pkbActive: true,
+      pkbQueryVector: [0.1, 0.2, 0.3],
+      pkbScopeId: "scope-1",
+      pkbConversation: { messages: baseMessages },
+      pkbRoot,
+      pkbWorkingDir,
+      pkbAutoInjectList: [],
+      ...overrides,
+    };
+  }
+
+  function extractTexts(result: Message[]): string[] {
+    const tail = result[result.length - 1];
+    return tail.content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text);
+  }
+
+  test("three uninvolved hits → reminder contains all three bullets", async () => {
+    pkbSearchResults = [
+      { path: "topics/alpha.md", denseScore: 0.9 },
+      { path: "topics/beta.md", denseScore: 0.8 },
+      { path: "topics/gamma.md", denseScore: 0.7 },
+    ];
+    pkbSearchThrows = null;
+
+    const { messages: result } = await applyRuntimeInjections(
+      baseMessages,
+      makePkbOptions(),
+    );
+    const texts = extractTexts(result);
+    const reminder = texts.find((t) => t.startsWith("<system_reminder>"));
+    expect(reminder).toBeDefined();
+    expect(reminder).toContain("- topics/alpha.md");
+    expect(reminder).toContain("- topics/beta.md");
+    expect(reminder).toContain("- topics/gamma.md");
+    expect(reminder).toContain("these files look especially relevant");
+  });
+
+  test("default auto-injected files (from PKB_DEFAULT_FILES) are filtered out of hints", async () => {
+    // Regression test: when `_autoinject.md` is missing, `readPkbContext`
+    // falls back to PKB_DEFAULT_FILES — so those files ARE in the prompt.
+    // The tracker must know about them too, otherwise the reminder would
+    // redundantly recommend e.g. `essentials.md` even though its contents
+    // are already injected. The agent-loop passes the effective auto-inject
+    // list (via `getPkbAutoInjectList`) to `applyRuntimeInjections`.
+    pkbSearchResults = [
+      { path: "essentials.md", denseScore: 0.95 },
+      { path: "topics/alpha.md", denseScore: 0.9 },
+    ];
+    pkbSearchThrows = null;
+
+    const { messages: result } = await applyRuntimeInjections(
+      baseMessages,
+      makePkbOptions({
+        // Simulate the fallback the agent-loop now threads through:
+        // `_autoinject.md` is missing, so defaults are injected.
+        pkbAutoInjectList: [
+          "INDEX.md",
+          "essentials.md",
+          "threads.md",
+          "buffer.md",
+        ],
+      }),
+    );
+    const texts = extractTexts(result);
+    const reminder = texts.find((t) => t.startsWith("<system_reminder>"));
+    expect(reminder).toBeDefined();
+    // essentials.md is a default auto-inject file, so it's already in the
+    // prompt — the reminder must not recommend it again.
+    expect(reminder).not.toContain("- essentials.md");
+    // The other hit, which is not auto-injected, still appears.
+    expect(reminder).toContain("- topics/alpha.md");
+  });
+
+  test("<system_reminder> is injected immediately before the user's typed text (above, not below)", async () => {
+    pkbSearchResults = [];
+    pkbSearchThrows = null;
+
+    const { messages: result } = await applyRuntimeInjections(
+      baseMessages,
+      makePkbOptions(),
+    );
+    const texts = extractTexts(result);
+    const reminderIdx = texts.findIndex((t) =>
+      t.startsWith("<system_reminder>"),
+    );
+    const userTextIdx = texts.findIndex(
+      (t) => t === "Tell me about project foo",
+    );
+    expect(reminderIdx).toBeGreaterThanOrEqual(0);
+    expect(userTextIdx).toBeGreaterThanOrEqual(0);
+    expect(reminderIdx).toBeLessThan(userTextIdx);
+  });
+
+  test("in-context paths are filtered out of hints", async () => {
+    pkbSearchResults = [
+      { path: "topics/alpha.md", denseScore: 0.9 },
+      { path: "topics/beta.md", denseScore: 0.8 },
+      { path: "topics/gamma.md", denseScore: 0.7 },
+    ];
+    pkbSearchThrows = null;
+
+    // Build a conversation that has already read topics/beta.md via file_read.
+    const conversationWithRead: { messages: Message[] } = {
+      messages: [
+        ...baseMessages,
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool_use",
+              id: "tu_1",
+              name: "file_read",
+              input: { path: `${pkbRoot}/topics/beta.md` },
+            },
+          ],
+        },
+      ],
+    };
+
+    const { messages: result } = await applyRuntimeInjections(
+      baseMessages,
+      makePkbOptions({ pkbConversation: conversationWithRead }),
+    );
+    const texts = extractTexts(result);
+    const reminder = texts.find((t) => t.startsWith("<system_reminder>"));
+    expect(reminder).toBeDefined();
+    expect(reminder).toContain("- topics/alpha.md");
+    expect(reminder).not.toContain("- topics/beta.md");
+    expect(reminder).toContain("- topics/gamma.md");
+  });
+
+  test("empty search → reminder equals flat fallback text byte-for-byte", async () => {
+    pkbSearchResults = [];
+    pkbSearchThrows = null;
+
+    const { messages: result } = await applyRuntimeInjections(
+      baseMessages,
+      makePkbOptions(),
+    );
+    const texts = extractTexts(result);
+    const reminder = texts.find((t) => t.startsWith("<system_reminder>"));
+    expect(reminder).toBe(FLAT_REMINDER);
+  });
+
+  test("search throws → reminder equals flat fallback text byte-for-byte", async () => {
+    pkbSearchResults = [];
+    pkbSearchThrows = new Error("qdrant exploded");
+
+    const { messages: result } = await applyRuntimeInjections(
+      baseMessages,
+      makePkbOptions(),
+    );
+    const texts = extractTexts(result);
+    const reminder = texts.find((t) => t.startsWith("<system_reminder>"));
+    expect(reminder).toBe(FLAT_REMINDER);
+  });
+
+  test("missing query vector → flat fallback, search is not attempted", async () => {
+    pkbSearchThrows = new Error("should not be called");
+
+    const { messages: result } = await applyRuntimeInjections(
+      baseMessages,
+      makePkbOptions({ pkbQueryVector: undefined }),
+    );
+    const texts = extractTexts(result);
+    const reminder = texts.find((t) => t.startsWith("<system_reminder>"));
+    expect(reminder).toBe(FLAT_REMINDER);
+  });
+
+  test("gate uses denseScore — hybridScore alone cannot pass the threshold", async () => {
+    // Simulates the situation where sparse-only matches (which surface via
+    // hybrid's prefetch beyond the dense prefetch limit) pick up RRF hits
+    // but fail the absolute cosine quality bar.
+    pkbSearchResults = [
+      { path: "topics/alpha.md", denseScore: 0.9, hybridScore: 0.02 },
+      { path: "topics/noise.md", denseScore: 0.3, hybridScore: 0.03 },
+    ];
+    pkbSearchThrows = null;
+
+    const { messages: result } = await applyRuntimeInjections(
+      baseMessages,
+      makePkbOptions(),
+    );
+    const texts = extractTexts(result);
+    const reminder = texts.find((t) => t.startsWith("<system_reminder>"));
+    expect(reminder).toBeDefined();
+    expect(reminder).toContain("- topics/alpha.md");
+    // Below-threshold dense score is filtered even though its hybrid score
+    // is higher than alpha's.
+    expect(reminder).not.toContain("- topics/noise.md");
+  });
+
+  test("ranking follows hybridScore when present — lexical winner surfaces first", async () => {
+    // Sparse re-ranks alpha ahead of beta even though beta's dense cosine is
+    // higher. Both pass the dense threshold, so both survive filtering; the
+    // hybrid score drives ordering among survivors.
+    pkbSearchResults = [
+      { path: "topics/beta.md", denseScore: 0.9, hybridScore: 0.02 },
+      { path: "topics/alpha.md", denseScore: 0.75, hybridScore: 0.04 },
+    ];
+    pkbSearchThrows = null;
+
+    const { messages: result } = await applyRuntimeInjections(
+      baseMessages,
+      makePkbOptions(),
+    );
+    const texts = extractTexts(result);
+    const reminder = texts.find((t) => t.startsWith("<system_reminder>"));
+    expect(reminder).toBeDefined();
+    const alphaIdx = reminder!.indexOf("- topics/alpha.md");
+    const betaIdx = reminder!.indexOf("- topics/beta.md");
+    expect(alphaIdx).toBeGreaterThanOrEqual(0);
+    expect(betaIdx).toBeGreaterThanOrEqual(0);
+    expect(alphaIdx).toBeLessThan(betaIdx);
+  });
+
+  test("archive/ threshold is stricter (0.7) and applies to denseScore", async () => {
+    pkbSearchResults = [
+      { path: "topics/alpha.md", denseScore: 0.55 }, // passes 0.5
+      { path: "archive/old.md", denseScore: 0.55 }, // fails 0.7
+      { path: "archive/solid.md", denseScore: 0.75 }, // passes 0.7
+    ];
+    pkbSearchThrows = null;
+
+    const { messages: result } = await applyRuntimeInjections(
+      baseMessages,
+      makePkbOptions(),
+    );
+    const texts = extractTexts(result);
+    const reminder = texts.find((t) => t.startsWith("<system_reminder>"));
+    expect(reminder).toBeDefined();
+    expect(reminder).toContain("- topics/alpha.md");
+    expect(reminder).not.toContain("- archive/old.md");
+    expect(reminder).toContain("- archive/solid.md");
+  });
+
+  test("stripInjectionsForCompaction removes the PKB reminder (flat and hinted)", () => {
+    // Verifies the existing strip pipeline still catches the new reminder
+    // text — it still opens with `<system_reminder>`, which is already in
+    // RUNTIME_INJECTION_PREFIXES.
+    const flatMessage: Message = {
+      role: "user",
+      content: [
+        { type: "text", text: "hello" },
+        { type: "text", text: buildPkbReminder([]) },
+      ],
+    };
+    const hintedMessage: Message = {
+      role: "user",
+      content: [
+        { type: "text", text: "hello" },
+        {
+          type: "text",
+          text: buildPkbReminder(["topics/alpha.md", "topics/beta.md"]),
+        },
+      ],
+    };
+
+    for (const msg of [flatMessage, hintedMessage]) {
+      const stripped = stripInjectionsForCompaction([msg]);
+      const texts = stripped[0].content
+        .filter((b): b is { type: "text"; text: string } => b.type === "text")
+        .map((b) => b.text);
+      expect(texts.some((t) => t.startsWith("<system_reminder>"))).toBe(false);
+      expect(texts).toContain("hello");
+    }
+  });
+
+  test("after simulated compaction (strip + rebuild), fresh hints are emitted from post-compaction tool_use blocks", async () => {
+    pkbSearchResults = [
+      { path: "topics/alpha.md", denseScore: 0.9 },
+      { path: "topics/beta.md", denseScore: 0.8 },
+      { path: "topics/gamma.md", denseScore: 0.7 },
+    ];
+    pkbSearchThrows = null;
+
+    // Pre-compaction conversation: beta was already read.
+    const preCompactionConversation: { messages: Message[] } = {
+      messages: [
+        ...baseMessages,
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool_use",
+              id: "tu_pre",
+              name: "file_read",
+              input: { path: `${pkbRoot}/topics/beta.md` },
+            },
+          ],
+        },
+      ],
+    };
+
+    // 1. Initial injection sees the pre-compaction state — beta should be
+    // filtered out.
+    const { messages: initialResult } = await applyRuntimeInjections(
+      baseMessages,
+      {
+        pkbActive: true,
+        pkbQueryVector: [0.1, 0.2],
+        pkbScopeId: "scope-1",
+        pkbConversation: preCompactionConversation,
+        pkbRoot,
+        pkbWorkingDir,
+        pkbAutoInjectList: [],
+      },
+    );
+    // Unwrap the injected reminder from the last user message.
+    const initialTexts = extractTexts(initialResult);
+    const initialReminder = initialTexts.find(
+      (t) =>
+        t.startsWith("<system_reminder>") &&
+        t.includes("these files look especially relevant"),
+    );
+    expect(initialReminder).toBeDefined();
+    expect(initialReminder).not.toContain("- topics/beta.md");
+
+    // 2. Simulate compaction: strip all runtime injections, rebuild
+    // conversation to reflect the post-compaction state (tool_use blocks
+    // are serialized into summary text, so the only live file_read is the
+    // newly-read gamma).
+    const postCompactionConversation: { messages: Message[] } = {
+      messages: [
+        ...baseMessages,
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool_use",
+              id: "tu_post",
+              name: "file_read",
+              input: { path: `${pkbRoot}/topics/gamma.md` },
+            },
+          ],
+        },
+      ],
+    };
+    const postCompactionMessages = stripInjectionsForCompaction(initialResult);
+
+    // 3. Re-inject with the new conversation — gamma (now in context)
+    // should be filtered, and beta (no longer "in context") should appear.
+    const { messages: rebuiltResult } = await applyRuntimeInjections(
+      postCompactionMessages,
+      {
+        pkbActive: true,
+        pkbQueryVector: [0.1, 0.2],
+        pkbScopeId: "scope-1",
+        pkbConversation: postCompactionConversation,
+        pkbRoot,
+        pkbWorkingDir,
+        pkbAutoInjectList: [],
+      },
+    );
+    const rebuiltTexts = extractTexts(rebuiltResult);
+    const rebuiltReminder = rebuiltTexts.find(
+      (t) =>
+        t.startsWith("<system_reminder>") &&
+        t.includes("these files look especially relevant"),
+    );
+    expect(rebuiltReminder).toBeDefined();
+    expect(rebuiltReminder).toContain("- topics/alpha.md");
+    expect(rebuiltReminder).toContain("- topics/beta.md");
+    expect(rebuiltReminder).not.toContain("- topics/gamma.md");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Slack channel chronological rendering (multi-thread)
+// ---------------------------------------------------------------------------
+
+describe("Slack channel chronological rendering — multi-thread", () => {
+  // Slack ts values are seconds-since-epoch with microsecond precision.
+  // Pick a few stable anchors so thread aliases (sha-derived) stay
+  // predictable across the scenarios.
+  const T0 = "1700000000.000001"; // 2023-11-14 22:13:20 UTC — top-level message in thread A
+  const T0_REPLY1 = "1700000005.000001"; // reply in thread A
+  const T0_REPLY2 = "1700000020.000001"; // later reply in thread A
+  const T1 = "1700000010.000002"; // top-level message starting thread B
+  const T2 = "1700000030.000003"; // newer top-level message
+  const ALIAS_T0 = parentAlias(T0);
+  const ALIAS_T1 = parentAlias(T1);
+  const ALIAS_T2 = parentAlias(T2);
+
+  const SLACK_CHANNEL_ID = "C0123CHANNEL";
+
+  function buildSlackMeta(
+    overrides: Partial<SlackMessageMetadata>,
+  ): SlackMessageMetadata {
+    return {
+      source: "slack",
+      channelId: SLACK_CHANNEL_ID,
+      channelTs: overrides.channelTs ?? T0,
+      eventKind: "message",
+      ...overrides,
+    } as SlackMessageMetadata;
+  }
+
+  function userRow(opts: {
+    id: string;
+    createdAt: number;
+    text: string;
+    slackMeta?: SlackMessageMetadata;
+    extraOuterMetadata?: Record<string, unknown>;
+  }): MessageRow {
+    const outer: Record<string, unknown> = {
+      ...(opts.extraOuterMetadata ?? {}),
+    };
+    if (opts.slackMeta) outer.slackMeta = writeSlackMetadata(opts.slackMeta);
+    return {
+      id: opts.id,
+      conversationId: "conv-1",
+      role: "user",
+      content: JSON.stringify([{ type: "text", text: opts.text }]),
+      createdAt: opts.createdAt,
+      metadata: Object.keys(outer).length > 0 ? JSON.stringify(outer) : null,
+    };
+  }
+
+  function assistantRow(opts: {
+    id: string;
+    createdAt: number;
+    text: string;
+    slackMeta?: SlackMessageMetadata;
+  }): MessageRow {
+    const outer: Record<string, unknown> = {};
+    if (opts.slackMeta) outer.slackMeta = writeSlackMetadata(opts.slackMeta);
+    return {
+      id: opts.id,
+      conversationId: "conv-1",
+      role: "assistant",
+      content: JSON.stringify([{ type: "text", text: opts.text }]),
+      createdAt: opts.createdAt,
+      metadata: Object.keys(outer).length > 0 ? JSON.stringify(outer) : null,
+    };
+  }
+
+  // Helper: assemble a Slack-channel turn through the public assembly path
+  // so the tests exercise the same code the daemon uses.
+  async function runSlackChannelAssembly(
+    rows: MessageRow[],
+  ): Promise<Message[]> {
+    const slackChannelCaps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const slackChronologicalMessages = loadSlackChronologicalMessages(
+      "conv-1",
+      slackChannelCaps,
+      { loader: () => rows, trustClass: "guardian" },
+    );
+    const lastUserMessage: Message = {
+      role: "user",
+      content: [{ type: "text", text: "current turn" }],
+    };
+    const { messages } = await applyRuntimeInjections([lastUserMessage], {
+      channelCapabilities: slackChannelCaps,
+      slackChronologicalMessages,
+    });
+    return messages;
+  }
+
+  // Extract the rendered text content from a chronological transcript
+  // result. Each Message produced by the slack-channel render carries
+  // exactly one rendered text block, but the FINAL message also receives
+  // injection blocks (e.g. <channel_capabilities>) prepended by the rest
+  // of `applyRuntimeInjections`. The rendered transcript line is always
+  // the LAST text block of each Message.
+  function texts(messages: Message[]): string[] {
+    return messages.map((m) => {
+      for (let i = m.content.length - 1; i >= 0; i--) {
+        const block = m.content[i];
+        if (block.type === "text") return block.text;
+      }
+      return "";
+    });
+  }
+
+  // ── Scenario 1: reply in mid-thread ──────────────────────────────────
+  // Alice posts to thread A, Bob replies in thread B (cross-thread). Then
+  // Alice posts a follow-up reply in thread A. Cross-thread visibility:
+  // Bob's mid-thread reply must remain visible alongside thread A.
+  test("scenario 1 — mid-thread reply preserves cross-thread visibility", async () => {
+    const rows: MessageRow[] = [
+      userRow({
+        id: "m1",
+        createdAt: 1700000000_000,
+        text: "Top-level in thread A",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+      }),
+      userRow({
+        id: "m2",
+        createdAt: 1700000010_000,
+        text: "Top-level starting thread B",
+        slackMeta: buildSlackMeta({ channelTs: T1, displayName: "bob" }),
+      }),
+      userRow({
+        id: "m3",
+        createdAt: 1700000015_000,
+        text: "Reply in thread B (cross-thread relative to A)",
+        slackMeta: buildSlackMeta({
+          channelTs: "1700000015.000001",
+          threadTs: T1,
+          displayName: "bob",
+        }),
+      }),
+      userRow({
+        id: "m4",
+        createdAt: 1700000020_000,
+        text: "Reply in thread A from alice",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY2,
+          threadTs: T0,
+          displayName: "alice",
+        }),
+      }),
+    ];
+
+    const result = await runSlackChannelAssembly(rows);
+    const lines = texts(result);
+
+    expect(lines.length).toBe(4);
+    // Chronological order is preserved.
+    expect(lines[0]).toContain("Top-level in thread A");
+    expect(lines[1]).toContain("Top-level starting thread B");
+    expect(lines[2]).toContain("Reply in thread B");
+    expect(lines[3]).toContain("Reply in thread A");
+    // Cross-thread visibility: thread B's reply is in the rendered output
+    // alongside thread A's reply.
+    expect(lines[2]).toContain(`→ ${ALIAS_T1}`);
+    expect(lines[3]).toContain(`→ ${ALIAS_T0}`);
+    // Sender labels appear.
+    expect(lines[0]).toContain("alice");
+    expect(lines[1]).toContain("bob");
+  });
+
+  // ── Scenario 2: reply to a top-level (starts new thread) ─────────────
+  test("scenario 2 — reply to top-level renders thread tag pointing at parent", async () => {
+    const rows: MessageRow[] = [
+      userRow({
+        id: "m1",
+        createdAt: 1700000000_000,
+        text: "Top-level message",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+      }),
+      userRow({
+        id: "m2",
+        createdAt: 1700000005_000,
+        text: "Reply that starts a new thread",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY1,
+          threadTs: T0,
+          displayName: "bob",
+        }),
+      }),
+    ];
+
+    const result = await runSlackChannelAssembly(rows);
+    const lines = texts(result);
+
+    expect(lines.length).toBe(2);
+    // Top-level has no thread tag.
+    expect(lines[0]).not.toContain("→ M");
+    // Reply points at the parent's deterministic alias.
+    expect(lines[1]).toContain(`→ ${ALIAS_T0}`);
+    expect(lines[1]).toContain("Reply that starts a new thread");
+  });
+
+  // ── Scenario 3: reply to the most-recent top-level message ───────────
+  test("scenario 3 — reply to last top-level still renders thread tag", async () => {
+    const rows: MessageRow[] = [
+      userRow({
+        id: "m1",
+        createdAt: 1700000000_000,
+        text: "Older top-level",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+      }),
+      userRow({
+        id: "m2",
+        createdAt: 1700000010_000,
+        text: "Newer top-level",
+        slackMeta: buildSlackMeta({ channelTs: T1, displayName: "alice" }),
+      }),
+      userRow({
+        id: "m3",
+        createdAt: 1700000020_000,
+        text: "Reply to the newer top-level",
+        slackMeta: buildSlackMeta({
+          channelTs: "1700000020.000099",
+          threadTs: T1,
+          displayName: "bob",
+        }),
+      }),
+    ];
+
+    const result = await runSlackChannelAssembly(rows);
+    const lines = texts(result);
+
+    expect(lines.length).toBe(3);
+    // The reply targets the newer top-level alias, not the older one.
+    expect(lines[2]).toContain(`→ ${ALIAS_T1}`);
+    expect(lines[2]).not.toContain(`→ ${ALIAS_T0}`);
+  });
+
+  // ── Scenario 4: brand-new top-level message ──────────────────────────
+  test("scenario 4 — new top-level message has no thread tag", async () => {
+    const rows: MessageRow[] = [
+      userRow({
+        id: "m1",
+        createdAt: 1700000000_000,
+        text: "Existing top-level",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+      }),
+      userRow({
+        id: "m2",
+        createdAt: 1700000030_000,
+        text: "Brand-new top-level message",
+        slackMeta: buildSlackMeta({ channelTs: T2, displayName: "carol" }),
+      }),
+    ];
+
+    const result = await runSlackChannelAssembly(rows);
+    const lines = texts(result);
+
+    expect(lines.length).toBe(2);
+    // Both lines render without a thread tag — they are siblings, not
+    // members of the same thread.
+    expect(lines[0]).not.toContain("→ M");
+    expect(lines[1]).not.toContain("→ M");
+    expect(lines[1]).toContain("Brand-new top-level message");
+    // Sanity: each top-level message has a deterministic alias even if
+    // the rendered output doesn't surface it on a top-level line. This
+    // confirms the alias function is reachable for downstream consumers
+    // (focus block in PR 24).
+    expect(ALIAS_T2.length).toBe(7);
+  });
+
+  // ── Scenario 5: legacy mixed with post-upgrade rows ──────────────────
+  // Pre-upgrade rows have no `slackMeta` sub-key. Post-upgrade rows have
+  // it. Both kinds must appear in the rendered transcript with legacy
+  // rows rendered flat (no thread tag) and post-upgrade rows carrying
+  // their thread tags. The renderer's chronological sort must intermix
+  // them on the appropriate timeline.
+  test("scenario 5 — legacy rows mixed with post-upgrade rows render chronologically", async () => {
+    const rows: MessageRow[] = [
+      // Legacy user row with a displayName hint only — no slackMeta.
+      userRow({
+        id: "m1",
+        createdAt: 1699999000_000,
+        text: "Legacy user message",
+        extraOuterMetadata: { displayName: "legacy_alice" },
+      }),
+      // Legacy assistant row.
+      assistantRow({
+        id: "m2",
+        createdAt: 1699999500_000,
+        text: "Legacy assistant reply",
+      }),
+      // Post-upgrade row anchored to a thread parent that has no record
+      // in storage (legacy parent) — the renderer still emits the alias
+      // because the metadata is intact.
+      userRow({
+        id: "m3",
+        createdAt: 1700000000_000,
+        text: "Post-upgrade thread reply",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY1,
+          threadTs: T0,
+          displayName: "alice",
+        }),
+      }),
+    ];
+
+    const result = await runSlackChannelAssembly(rows);
+    const lines = texts(result);
+
+    // All three rows survive the rendering pipeline. Legacy rows are NOT
+    // dropped from context.
+    expect(lines.length).toBe(3);
+    // Chronological order preserved across legacy/post-upgrade rows.
+    expect(lines[0]).toContain("Legacy user message");
+    expect(lines[1]).toContain("Legacy assistant reply");
+    expect(lines[2]).toContain("Post-upgrade thread reply");
+    // Legacy rows render flat — no thread tag arrow.
+    expect(lines[0]).not.toContain("→ M");
+    expect(lines[1]).not.toContain("→ M");
+    // Post-upgrade row carries its thread tag.
+    expect(lines[2]).toContain(`→ ${ALIAS_T0}`);
+    // Sender labels: legacy rows carry no structured displayName, and the
+    // role slot already conveys user-vs-assistant identity, so the row
+    // mapper emits `null` senderLabel and the renderer omits the label
+    // entirely. Real Slack usernames are only rendered for post-upgrade
+    // user rows where `slackMeta.displayName` is populated.
+    expect(lines[0]).not.toContain("@user");
+    expect(lines[0]).not.toContain("@assistant");
+    expect(lines[1]).not.toContain("@assistant");
+    expect(lines[1]).not.toContain("@user");
+  });
+
+  // ── Branch isolation: non-Slack channels untouched ───────────────────
+  test("non-slack conversations bypass chronological rendering", async () => {
+    const lastUserMessage: Message = {
+      role: "user",
+      content: [{ type: "text", text: "vellum question" }],
+    };
+    const { messages: result } = await applyRuntimeInjections(
+      [lastUserMessage],
+      {
+        channelCapabilities: {
+          channel: "vellum",
+          dashboardCapable: true,
+          supportsDynamicUi: true,
+          supportsVoiceInput: true,
+        },
+        // Even if we accidentally pass a chronological transcript, the
+        // branch must be a no-op for non-slack channels.
+        slackChronologicalMessages: [
+          {
+            role: "user",
+            content: [{ type: "text", text: "should not appear" }],
+          },
+        ],
+      },
+    );
+    expect(result.length).toBe(1);
+    const allText = result[0].content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).toContain("vellum question");
+    expect(allText).not.toContain("should not appear");
+  });
+
+  // ── DMs (chatType === "im") use chronological rendering ────────────────
+  // The runtime-assembly hook overrides `runMessages` for any Slack
+  // conversation (channels and DMs alike). DMs render flat (no thread
+  // tags), but they DO swap in the pre-assembled chronological transcript
+  // so the model sees one consistent persisted view.
+  test("slack DMs (chatType im) use chronological rendering", async () => {
+    const lastUserMessage: Message = {
+      role: "user",
+      content: [{ type: "text", text: "DM question" }],
+    };
+    const { messages: result } = await applyRuntimeInjections(
+      [lastUserMessage],
+      {
+        channelCapabilities: {
+          channel: "slack",
+          dashboardCapable: false,
+          supportsDynamicUi: false,
+          supportsVoiceInput: false,
+          chatType: "im",
+        },
+        slackChronologicalMessages: [
+          {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: "[11/14/23 14:25 @alice]: earlier DM line",
+              },
+            ],
+          },
+          {
+            role: "assistant",
+            content: [{ type: "text", text: "[11/14/23 14:26]: prior reply" }],
+          },
+        ],
+      },
+    );
+    // The chronological transcript REPLACES the default runMessages, so
+    // the inbound `DM question` text does not appear — only the rendered
+    // transcript lines do (plus any non-Slack injections).
+    const allText = result
+      .flatMap((m) => m.content)
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).toContain("earlier DM line");
+    expect(allText).toContain("prior reply");
+    expect(allText).not.toContain("DM question");
+  });
+
+  // ── Memory-injection carry-through on slack replacement ──────────────
+  // `graphMemory.prepareMemory` prepends `<memory __injected>` (and
+  // optional memory-image groups) to the last user message BEFORE the
+  // runtime assembly runs. When the Slack branch replaces `runMessages`
+  // with the chronological transcript, the prepended blocks must be
+  // carried onto the new tail so the model still sees recalled memory.
+  // The final order inside the tail user message is:
+  //   channel_capabilities → [carried memory blocks] → slack transcript tail.
+  test("slack replacement preserves prepended memory block", async () => {
+    const slackCaps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "im",
+    };
+    const runMessagesWithMemory: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "<memory __injected>\nrecalled fact about the user\n</memory>",
+          },
+          { type: "text", text: "hello there" },
+        ],
+      },
+    ];
+    const { messages: result } = await applyRuntimeInjections(
+      runMessagesWithMemory,
+      {
+        channelCapabilities: slackCaps,
+        slackChronologicalMessages: [
+          {
+            role: "user",
+            content: [{ type: "text", text: "[19:55 alice]: hello there" }],
+          },
+        ],
+      },
+    );
+    const tail = result[result.length - 1];
+    expect(tail.role).toBe("user");
+    const allText = tail.content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).toContain("<memory __injected>");
+    expect(allText).toContain("recalled fact about the user");
+    expect(allText).toContain("[19:55 alice]: hello there");
+    // Memory block must appear before the Slack transcript tail so the
+    // model sees recalled context ahead of the conversation view.
+    const memoryIdx = allText.indexOf("<memory __injected>");
+    const transcriptIdx = allText.indexOf("[19:55 alice]: hello there");
+    expect(memoryIdx).toBeLessThan(transcriptIdx);
+    // The pre-replacement "hello there" text from the original runMessages
+    // must NOT leak through — only the Slack-rendered line appears.
+    expect(allText.match(/hello there/g)?.length).toBe(1);
+  });
+
+  test("slack replacement preserves memory-image groups + text block", async () => {
+    const slackCaps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "im",
+    };
+    const runMessagesWithMemory: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "<memory_image __injected>\nimage description",
+          },
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: "image/png",
+              data: "AAAA",
+            },
+          },
+          { type: "text", text: "</memory_image>" },
+          {
+            type: "text",
+            text: "<memory __injected>\nrecalled text\n</memory>",
+          },
+          { type: "text", text: "original turn text" },
+        ],
+      },
+    ];
+    const { messages: result } = await applyRuntimeInjections(
+      runMessagesWithMemory,
+      {
+        channelCapabilities: slackCaps,
+        slackChronologicalMessages: [
+          {
+            role: "user",
+            content: [{ type: "text", text: "[19:55 alice]: transcript line" }],
+          },
+        ],
+      },
+    );
+    const tail = result[result.length - 1];
+    expect(tail.role).toBe("user");
+    // The memory-image block is carried through as an `image` content
+    // block; the transcript-only replacement would have none.
+    const imageBlocks = tail.content.filter((b) => b.type === "image");
+    expect(imageBlocks.length).toBe(1);
+    const allText = tail.content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).toContain("<memory_image __injected>");
+    expect(allText).toContain("</memory_image>");
+    expect(allText).toContain("<memory __injected>");
+    expect(allText).toContain("[19:55 alice]: transcript line");
+    // The original turn text (before the Slack replacement) must NOT
+    // leak through — only the memory prefix + transcript tail are kept.
+    expect(allText).not.toContain("original turn text");
+  });
+
+  test("slack replacement is a no-op when the tail has no memory prefix", async () => {
+    const slackCaps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "im",
+    };
+    const { messages: result } = await applyRuntimeInjections(
+      [{ role: "user", content: [{ type: "text", text: "inbound" }] }],
+      {
+        channelCapabilities: slackCaps,
+        slackChronologicalMessages: [
+          {
+            role: "user",
+            content: [{ type: "text", text: "[19:55 alice]: only transcript" }],
+          },
+        ],
+      },
+    );
+    const tail = result[result.length - 1];
+    const allText = tail.content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).not.toContain("<memory __injected>");
+    expect(allText).toContain("[19:55 alice]: only transcript");
+  });
+
+  // ── transport_hints suppression for slack channels ────────────────────
+  test("slack channel conversations skip <transport_hints> injection", async () => {
+    const slackChannelCaps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const rows: MessageRow[] = [
+      userRow({
+        id: "m1",
+        createdAt: 1700000000_000,
+        text: "Original message",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+      }),
+    ];
+    const slackChronologicalMessages = loadSlackChronologicalMessages(
+      "conv-1",
+      slackChannelCaps,
+      { loader: () => rows, trustClass: "guardian" },
+    );
+
+    const { messages: result } = await applyRuntimeInjections(
+      [{ role: "user", content: [{ type: "text", text: "current turn" }] }],
+      {
+        channelCapabilities: slackChannelCaps,
+        slackChronologicalMessages,
+        transportHints: ["thread context: ..."],
+      },
+    );
+
+    const allText = result
+      .flatMap((m) => m.content)
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).not.toContain("<transport_hints>");
+  });
+
+  // ── transport_hints suppression for slack DMs ─────────────────────────
+  // Slack DMs assemble context from persisted message rows; defensively
+  // suppress transport hints on the daemon side too so any stale hint
+  // cannot leak into the LLM input.
+  test("slack DM conversations skip <transport_hints> injection", async () => {
+    const slackDmCaps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "im",
+    };
+
+    const { messages: result } = await applyRuntimeInjections(
+      [{ role: "user", content: [{ type: "text", text: "hi DM" }] }],
+      {
+        channelCapabilities: slackDmCaps,
+        transportHints: ["dm context: ..."],
+      },
+    );
+
+    const allText = result
+      .flatMap((m) => m.content)
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).not.toContain("<transport_hints>");
+    expect(allText).not.toContain("dm context");
+  });
+
+  // ── transport_hints kept for non-slack channels ───────────────────────
+  test("non-slack conversations still receive <transport_hints>", async () => {
+    const { messages: result } = await applyRuntimeInjections(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      {
+        channelCapabilities: {
+          channel: "telegram",
+          dashboardCapable: false,
+          supportsDynamicUi: false,
+          supportsVoiceInput: false,
+          chatType: "private",
+        },
+        transportHints: ["please answer concisely"],
+      },
+    );
+    const allText = result
+      .flatMap((m) => m.content)
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).toContain("<transport_hints>");
+    expect(allText).toContain("please answer concisely");
+  });
+
+  // ── trust-filter regression for loadSlackChronologicalMessages ───────
+  // For untrusted actors, guardian-scoped rows must be excluded
+  // from the chronological transcript the same way `loadFromDb` filters
+  // them out of the default history.
+  test("loadSlackChronologicalMessages filters guardian-scoped rows for untrusted actors", () => {
+    const caps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    // Row 1 has no provenance → guardian-scoped (filtered out).
+    // Row 2 has provenance.trustClass === "trusted_contact" (kept).
+    const rows: MessageRow[] = [
+      userRow({
+        id: "m1",
+        createdAt: 1700000000_000,
+        text: "guardian-only context",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+      }),
+      userRow({
+        id: "m2",
+        createdAt: 1700000010_000,
+        text: "from untrusted actor",
+        slackMeta: buildSlackMeta({ channelTs: T1, displayName: "bob" }),
+        extraOuterMetadata: {
+          provenanceTrustClass: "trusted_contact",
+        },
+      }),
+    ];
+    const result = loadSlackChronologicalMessages("conv-1", caps, {
+      loader: () => rows,
+      trustClass: "trusted_contact",
+    });
+    expect(result).not.toBeNull();
+    const allText = result!
+      .flatMap((m) => m.content)
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).not.toContain("guardian-only context");
+    expect(allText).toContain("from untrusted actor");
+  });
+
+  // ── loadSlackChronologicalMessages returns null for non-slack channels ─
+  test("loadSlackChronologicalMessages returns null for non-slack channels", () => {
+    const result = loadSlackChronologicalMessages(
+      "conv-1",
+      {
+        channel: "telegram",
+        dashboardCapable: false,
+        supportsDynamicUi: false,
+        supportsVoiceInput: false,
+        chatType: "private",
+      },
+      { loader: () => [] },
+    );
+    expect(result).toBeNull();
+  });
+
+  // ───────────────────────────────────────────────────────────────────────
+  // Active-thread focus block (PR 24)
+  // ───────────────────────────────────────────────────────────────────────
+  //
+  // The focus block is appended (tail) to the FINAL user turn ONLY when
+  // the inbound message lives inside a Slack thread. It surfaces parent +
+  // replies (and reactions targeting them) so the model can orient even
+  // when the channel-wide chronological transcript is long and
+  // interleaved. The block is non-persisted: replays / re-injections strip
+  // any prior `<active_thread>` blocks via `RUNTIME_INJECTION_PREFIXES`.
+
+  // Re-run a Slack-channel turn through the public assembly path with the
+  // active-thread focus block plumbed in (mirrors production wiring in
+  // conversation-agent-loop.ts).
+  async function runSlackChannelAssemblyWithFocus(rows: MessageRow[]): Promise<{
+    messages: Message[];
+    focusBlock: string | null;
+  }> {
+    const slackChannelCaps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const slackChronologicalMessages = loadSlackChronologicalMessages(
+      "conv-1",
+      slackChannelCaps,
+      { loader: () => rows, trustClass: "guardian" },
+    );
+    const focusBlock = loadSlackActiveThreadFocusBlock(
+      "conv-1",
+      slackChannelCaps,
+      { loader: () => rows, trustClass: "guardian" },
+    );
+    const lastUserMessage: Message = {
+      role: "user",
+      content: [{ type: "text", text: "current turn" }],
+    };
+    const { messages } = await applyRuntimeInjections([lastUserMessage], {
+      channelCapabilities: slackChannelCaps,
+      slackChronologicalMessages,
+      slackActiveThreadFocusBlock: focusBlock,
+    });
+    return { messages, focusBlock };
+  }
+
+  test("appends <active_thread> focus block when inbound is a thread reply", async () => {
+    // Channel transcript with two interleaved threads. The latest user row
+    // is a reply in thread A — the focus block must list thread A's parent
+    // and replies, including the new reply, but exclude thread B entirely.
+    const rows: MessageRow[] = [
+      userRow({
+        id: "m1",
+        createdAt: 1700000000_000,
+        text: "Top-level in thread A",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+      }),
+      userRow({
+        id: "m2",
+        createdAt: 1700000010_000,
+        text: "Top-level in thread B",
+        slackMeta: buildSlackMeta({ channelTs: T1, displayName: "bob" }),
+      }),
+      userRow({
+        id: "m3",
+        createdAt: 1700000015_000,
+        text: "Cross-thread reply in B",
+        slackMeta: buildSlackMeta({
+          channelTs: "1700000015.000001",
+          threadTs: T1,
+          displayName: "bob",
+        }),
+      }),
+      // Inbound (latest user row): reply in thread A.
+      userRow({
+        id: "m4",
+        createdAt: 1700000020_000,
+        text: "New reply in thread A",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY2,
+          threadTs: T0,
+          displayName: "alice",
+        }),
+      }),
+    ];
+
+    const { messages, focusBlock } =
+      await runSlackChannelAssemblyWithFocus(rows);
+
+    // Block was built and is non-empty.
+    expect(focusBlock).not.toBeNull();
+    expect(focusBlock!).toContain("<active_thread>");
+    expect(focusBlock!).toContain("</active_thread>");
+    // Parent (T0) is included, both by content and via the parent alias.
+    expect(focusBlock!).toContain("Top-level in thread A");
+    // The new reply is included.
+    expect(focusBlock!).toContain("New reply in thread A");
+    expect(focusBlock!).toContain(`→ ${ALIAS_T0}`);
+    // Thread B's content is NOT in the focus block.
+    expect(focusBlock!).not.toContain("Top-level in thread B");
+    expect(focusBlock!).not.toContain("Cross-thread reply in B");
+    expect(focusBlock!).not.toContain(`→ ${ALIAS_T1}`);
+
+    // The focus block is appended to the FINAL user message as a tail
+    // text block — not to any earlier message.
+    const lastMsg = messages[messages.length - 1];
+    expect(lastMsg.role).toBe("user");
+    const lastTexts = lastMsg.content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text);
+    expect(lastTexts.some((t) => t.startsWith("<active_thread>"))).toBe(true);
+
+    // Earlier rendered messages do NOT carry the focus block.
+    for (let i = 0; i < messages.length - 1; i++) {
+      const earlierTexts = messages[i].content
+        .filter((b): b is { type: "text"; text: string } => b.type === "text")
+        .map((b) => b.text);
+      for (const t of earlierTexts) {
+        expect(t).not.toContain("<active_thread>");
+      }
+    }
+  });
+
+  test("includes reactions on thread messages in the focus block", async () => {
+    // Thread A has a parent + reply; reactions hang off both. The focus
+    // block must list the reactions (rendered by `renderSlackTranscript`'s
+    // existing reaction-line format) so the model sees the engagement.
+    const rows: MessageRow[] = [
+      userRow({
+        id: "m1",
+        createdAt: 1700000000_000,
+        text: "Thread A parent",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+      }),
+      // Reaction on the parent.
+      userRow({
+        id: "m2",
+        createdAt: 1700000003_000,
+        text: "[reaction]",
+        slackMeta: buildSlackMeta({
+          channelTs: "1700000003.111111",
+          // Reactions live on the channel timeline, not inside a
+          // particular thread; targetChannelTs is the load-bearing field.
+          eventKind: "reaction",
+          displayName: "carol",
+          reaction: {
+            emoji: "thumbsup",
+            targetChannelTs: T0,
+            op: "added",
+          },
+        }),
+      }),
+      // Reply in thread A (this is the inbound — most recent user row).
+      userRow({
+        id: "m3",
+        createdAt: 1700000010_000,
+        text: "Thread A reply",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY1,
+          threadTs: T0,
+          displayName: "bob",
+        }),
+      }),
+      // Reaction on the reply (added AFTER the reply, before the assembly).
+      userRow({
+        id: "m4",
+        createdAt: 1700000012_000,
+        text: "[reaction]",
+        slackMeta: buildSlackMeta({
+          channelTs: "1700000012.222222",
+          eventKind: "reaction",
+          displayName: "dave",
+          reaction: {
+            emoji: "eyes",
+            targetChannelTs: T0_REPLY1,
+            op: "added",
+          },
+        }),
+      }),
+      // The actual inbound user row that triggers the focus — a fresh
+      // reply in the same thread (so detectActiveThreadTs picks T0).
+      userRow({
+        id: "m5",
+        createdAt: 1700000020_000,
+        text: "Another reply in thread A",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY2,
+          threadTs: T0,
+          displayName: "alice",
+        }),
+      }),
+    ];
+
+    const { focusBlock } = await runSlackChannelAssemblyWithFocus(rows);
+    expect(focusBlock).not.toBeNull();
+    // Both reactions surface in the block (parent + reply targets).
+    expect(focusBlock!).toContain("reacted");
+    expect(focusBlock!).toContain("thumbsup");
+    expect(focusBlock!).toContain("eyes");
+    // Reactions reference the parent alias for visual grounding.
+    expect(focusBlock!).toContain(ALIAS_T0);
+  });
+
+  test("no focus block when inbound is a top-level message", async () => {
+    // Latest user row is top-level (no threadTs) — focus block must be
+    // null and applyRuntimeInjections must NOT append `<active_thread>`.
+    const rows: MessageRow[] = [
+      userRow({
+        id: "m1",
+        createdAt: 1700000000_000,
+        text: "Earlier top-level",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+      }),
+      userRow({
+        id: "m2",
+        createdAt: 1700000030_000,
+        text: "Brand-new top-level (the inbound)",
+        slackMeta: buildSlackMeta({ channelTs: T2, displayName: "carol" }),
+      }),
+    ];
+
+    const { messages, focusBlock } =
+      await runSlackChannelAssemblyWithFocus(rows);
+    expect(focusBlock).toBeNull();
+    const allText = messages
+      .flatMap((m) => m.content)
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).not.toContain("<active_thread>");
+  });
+
+  test("focus blocks are stripped from prior turns on rebuild (no accumulation)", async () => {
+    // Simulate a multi-turn exchange: turn 1 yields a user message that
+    // already carries an `<active_thread>` block (because the previous
+    // turn's assembly appended it). The compaction-stripping pipeline must
+    // remove the focus block so it does not persist into the next turn's
+    // history.
+    const userMessageWithStaleFocus: Message = {
+      role: "user",
+      content: [
+        { type: "text", text: "actual user content from prior turn" },
+        {
+          type: "text",
+          text: "<active_thread>\n[11/14/23 14:25 @alice]: old focus\n</active_thread>",
+        },
+      ],
+    };
+    const stripped = stripInjectionsForCompaction([userMessageWithStaleFocus]);
+    expect(stripped.length).toBe(1);
+    const remainingTexts = stripped[0].content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text);
+    expect(remainingTexts).toContain("actual user content from prior turn");
+    for (const t of remainingTexts) {
+      expect(t).not.toContain("<active_thread>");
+    }
+  });
+
+  test("focus block is dropped when injection is replayed (rebuilds re-derive it)", async () => {
+    // Defensive: the `<active_thread>` block is a per-turn injection. When
+    // overflow recovery / compaction re-runs `applyRuntimeInjections` on
+    // already-injected messages, prior `<active_thread>` blocks must be
+    // stripped so the rebuild's freshly-derived block is the only one
+    // present. We simulate by building a Slack channel turn, then
+    // running the strip pipeline + applying injections again with a
+    // different focus block to confirm no duplication occurs.
+    const rows: MessageRow[] = [
+      userRow({
+        id: "m1",
+        createdAt: 1700000000_000,
+        text: "Thread A parent",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+      }),
+      userRow({
+        id: "m2",
+        createdAt: 1700000020_000,
+        text: "Reply in thread A",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY2,
+          threadTs: T0,
+          displayName: "alice",
+        }),
+      }),
+    ];
+
+    const { messages: firstPassMessages } =
+      await runSlackChannelAssemblyWithFocus(rows);
+
+    // Strip injected blocks (this is what the overflow / compaction path
+    // does between rebuilds).
+    const stripped = stripInjectionsForCompaction(firstPassMessages);
+    const strippedTexts = stripped
+      .flatMap((m) => m.content)
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(strippedTexts).not.toContain("<active_thread>");
+
+    // Re-run injection with a fresh focus block — only ONE
+    // `<active_thread>` block must end up in the result.
+    const slackChannelCaps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const newFocus = "<active_thread>\nnewly built\n</active_thread>";
+    const { messages: reInjected } = await applyRuntimeInjections(stripped, {
+      channelCapabilities: slackChannelCaps,
+      slackActiveThreadFocusBlock: newFocus,
+    });
+    const reInjectedTexts = reInjected
+      .flatMap((m) => m.content)
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text);
+    const blockCount = reInjectedTexts.filter((t) =>
+      t.startsWith("<active_thread>"),
+    ).length;
+    expect(blockCount).toBe(1);
+    expect(
+      reInjectedTexts.find((t) => t.startsWith("<active_thread>")),
+    ).toContain("newly built");
+  });
+
+  test("non-slack conversations ignore slackActiveThreadFocusBlock", async () => {
+    // Defensive: the focus injection is gated on `slackChannel` (i.e.
+    // `isSlackChannelConversation`). Even if a caller mistakenly forwards
+    // a focus block on a non-Slack channel, it must NOT be appended.
+    const { messages: result } = await applyRuntimeInjections(
+      [{ role: "user", content: [{ type: "text", text: "vellum question" }] }],
+      {
+        channelCapabilities: {
+          channel: "vellum",
+          dashboardCapable: true,
+          supportsDynamicUi: true,
+          supportsVoiceInput: true,
+        },
+        slackActiveThreadFocusBlock: "<active_thread>\nbogus\n</active_thread>",
+      },
+    );
+    const allText = result
+      .flatMap((m) => m.content)
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).not.toContain("<active_thread>");
+    expect(allText).toContain("vellum question");
+  });
+
+  test("slack DMs ignore slackActiveThreadFocusBlock", async () => {
+    // Same as above but for Slack DMs (chatType === "im"). The focus
+    // injection is keyed on `isSlackChannelConversation` which excludes
+    // DMs, so the block must not appear.
+    const { messages: result } = await applyRuntimeInjections(
+      [{ role: "user", content: [{ type: "text", text: "DM question" }] }],
+      {
+        channelCapabilities: {
+          channel: "slack",
+          dashboardCapable: false,
+          supportsDynamicUi: false,
+          supportsVoiceInput: false,
+          chatType: "im",
+        },
+        slackActiveThreadFocusBlock: "<active_thread>\nbogus\n</active_thread>",
+      },
+    );
+    const allText = result
+      .flatMap((m) => m.content)
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).not.toContain("<active_thread>");
+    expect(allText).toContain("DM question");
+  });
+
+  test("loadSlackActiveThreadFocusBlock returns null for non-slack channels", () => {
+    const result = loadSlackActiveThreadFocusBlock(
+      "conv-1",
+      {
+        channel: "telegram",
+        dashboardCapable: false,
+        supportsDynamicUi: false,
+        supportsVoiceInput: false,
+        chatType: "private",
+      },
+      { loader: () => [] },
+    );
+    expect(result).toBeNull();
+  });
+
+  test("loadSlackActiveThreadFocusBlock returns null for Slack DMs (no threads)", () => {
+    // DMs do not have threads, so the focus block is always a no-op.
+    // The loader short-circuits before invoking the row loader so the
+    // DB read is skipped entirely. Covers both the gateway-omitted
+    // `chatType === undefined` case and the explicit `chatType === "im"`
+    // shape some fixtures still emit.
+    let loaderCalls = 0;
+    const dmCapsWithImType: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "im",
+    };
+    expect(
+      loadSlackActiveThreadFocusBlock("conv-1", dmCapsWithImType, {
+        loader: () => {
+          loaderCalls += 1;
+          return [];
+        },
+      }),
+    ).toBeNull();
+    const dmCapsNoChatType: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    };
+    expect(
+      loadSlackActiveThreadFocusBlock("conv-1", dmCapsNoChatType, {
+        loader: () => {
+          loaderCalls += 1;
+          return [];
+        },
+      }),
+    ).toBeNull();
+    expect(loaderCalls).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// assembleSlackActiveThreadFocusBlock — pure assembly entrypoint
+// ---------------------------------------------------------------------------
+
+describe("assembleSlackActiveThreadFocusBlock", () => {
+  const SLACK_CHANNEL_ID = "C0FOCUS";
+  const PARENT_TS = "1700000000.000001";
+  const REPLY_TS = "1700000010.000002";
+
+  const SLACK_CAPS: ChannelCapabilities = {
+    channel: "slack",
+    dashboardCapable: false,
+    supportsDynamicUi: false,
+    supportsVoiceInput: false,
+    chatType: "channel",
+  };
+
+  function buildMeta(
+    overrides: Partial<SlackMessageMetadata>,
+  ): SlackMessageMetadata {
+    return {
+      source: "slack",
+      channelId: SLACK_CHANNEL_ID,
+      channelTs: overrides.channelTs ?? PARENT_TS,
+      eventKind: "message",
+      ...overrides,
+    } as SlackMessageMetadata;
+  }
+
+  function envelope(meta: SlackMessageMetadata | null): string {
+    const outer: Record<string, unknown> = {};
+    if (meta) outer.slackMeta = writeSlackMetadata(meta);
+    return JSON.stringify(outer);
+  }
+
+  function buildRow(
+    role: "user" | "assistant",
+    text: string,
+    createdAt: number,
+    meta: SlackMessageMetadata | null,
+  ): SlackTranscriptInputRow {
+    return {
+      role,
+      content: JSON.stringify([{ type: "text", text }]),
+      createdAt,
+      metadata: meta ? envelope(meta) : null,
+    };
+  }
+
+  test("returns null when channel is not Slack", () => {
+    const result = assembleSlackActiveThreadFocusBlock([], {
+      channel: "telegram",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "private",
+    });
+    expect(result).toBeNull();
+  });
+
+  test("returns null for Slack DMs (chatType im) regardless of rows", () => {
+    // DMs do not have threads. Even if a caller mistakenly passes thread-
+    // looking metadata, the assembler short-circuits before scanning rows.
+    const dmCaps: ChannelCapabilities = { ...SLACK_CAPS, chatType: "im" };
+    const rows: SlackTranscriptInputRow[] = [
+      buildRow(
+        "user",
+        "thread-shaped row in a DM",
+        1_000,
+        buildMeta({
+          channelTs: REPLY_TS,
+          threadTs: PARENT_TS,
+          displayName: "@alice",
+        }),
+      ),
+    ];
+    expect(assembleSlackActiveThreadFocusBlock(rows, dmCaps)).toBeNull();
+  });
+
+  test("returns null when no rows have slackMeta", () => {
+    const result = assembleSlackActiveThreadFocusBlock(
+      [buildRow("user", "legacy", 1_000, null)],
+      SLACK_CAPS,
+    );
+    expect(result).toBeNull();
+  });
+
+  test("returns null when latest user row is top-level (no threadTs)", () => {
+    // Active thread detection scans newest-to-oldest user rows and stops
+    // at the first one with slackMeta — if it's top-level, no focus
+    // block is built.
+    const rows: SlackTranscriptInputRow[] = [
+      buildRow(
+        "user",
+        "older thread reply",
+        1_000,
+        buildMeta({
+          channelTs: REPLY_TS,
+          threadTs: PARENT_TS,
+          displayName: "@alice",
+        }),
+      ),
+      buildRow(
+        "user",
+        "fresh top-level",
+        2_000,
+        buildMeta({ channelTs: "1700000099.000001", displayName: "@bob" }),
+      ),
+    ];
+    const result = assembleSlackActiveThreadFocusBlock(rows, SLACK_CAPS);
+    expect(result).toBeNull();
+  });
+
+  test("collects parent + replies + reactions on the active thread", () => {
+    const rows: SlackTranscriptInputRow[] = [
+      // Parent of the active thread.
+      buildRow(
+        "user",
+        "Parent",
+        1_000,
+        buildMeta({ channelTs: PARENT_TS, displayName: "@alice" }),
+      ),
+      // Top-level message in a SIBLING thread (must NOT appear in the block).
+      buildRow(
+        "user",
+        "Sibling top-level",
+        1_500,
+        buildMeta({
+          channelTs: "1700000005.999999",
+          displayName: "@bob",
+        }),
+      ),
+      // Reaction on parent (must appear).
+      buildRow(
+        "user",
+        "[reaction]",
+        1_800,
+        buildMeta({
+          channelTs: "1700000008.111111",
+          eventKind: "reaction",
+          displayName: "@carol",
+          reaction: {
+            emoji: "tada",
+            targetChannelTs: PARENT_TS,
+            op: "added",
+          },
+        }),
+      ),
+      // Inbound: reply in active thread (latest user row).
+      buildRow(
+        "user",
+        "Reply",
+        2_000,
+        buildMeta({
+          channelTs: REPLY_TS,
+          threadTs: PARENT_TS,
+          displayName: "@alice",
+        }),
+      ),
+    ];
+    const result = assembleSlackActiveThreadFocusBlock(rows, SLACK_CAPS);
+    expect(result).not.toBeNull();
+    expect(result!).toContain("<active_thread>");
+    expect(result!).toContain("</active_thread>");
+    expect(result!).toContain("Parent");
+    expect(result!).toContain("Reply");
+    expect(result!).toContain("tada");
+    // Sibling content is NOT pulled in.
+    expect(result!).not.toContain("Sibling top-level");
+  });
+
+  test("preserves speaker attribution when flattening to plain text", () => {
+    // The `<active_thread>` block is rendered as newline-joined plain text,
+    // discarding `Message.role`. Assistant rows and unnamed user rows must
+    // therefore carry an explicit `@assistant` / `@user` label so the model
+    // can still tell turns apart inside the flattened block.
+    const rows: SlackTranscriptInputRow[] = [
+      buildRow(
+        "user",
+        "Parent from alice",
+        1_000,
+        buildMeta({ channelTs: PARENT_TS, displayName: "@alice" }),
+      ),
+      buildRow(
+        "assistant",
+        "Assistant reply",
+        2_000,
+        buildMeta({
+          channelTs: "1700000005.000001",
+          threadTs: PARENT_TS,
+        }),
+      ),
+      buildRow(
+        "user",
+        "Unnamed follow-up",
+        3_000,
+        buildMeta({ channelTs: REPLY_TS, threadTs: PARENT_TS }),
+      ),
+    ];
+    const result = assembleSlackActiveThreadFocusBlock(rows, SLACK_CAPS);
+    expect(result).not.toBeNull();
+    expect(result!).toContain("@alice");
+    expect(result!).toContain("@assistant");
+    expect(result!).toContain("@user");
+  });
+
+  test("emits a block even when the parent has not been backfilled yet", () => {
+    // The inbound reply detects an `activeThreadTs` from its own
+    // `threadTs`, but the parent (`channelTs === activeThreadTs`) has not
+    // landed in storage yet (backfill pending). The block must still emit
+    // — the reply itself is a member (its own threadTs matches) so the
+    // renderer has at least one line to write.
+    const rows: SlackTranscriptInputRow[] = [
+      buildRow(
+        "user",
+        "Lone reply",
+        1_000,
+        buildMeta({
+          channelTs: REPLY_TS,
+          threadTs: PARENT_TS,
+          displayName: "@alice",
+        }),
+      ),
+    ];
+    const result = assembleSlackActiveThreadFocusBlock(rows, SLACK_CAPS);
+    expect(result).not.toBeNull();
+    expect(result!).toContain("Lone reply");
+    expect(result!).toContain("<active_thread>");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// assembleSlackChronologicalMessages — DM chronological rendering
+// ---------------------------------------------------------------------------
+
+describe("assembleSlackChronologicalMessages", () => {
+  // Anchor times mirror the renderer's HH:MM (UTC) output.
+  // 14:25:00 UTC on 2023-11-14 = epoch second 1699971900.
+  const TS_14_25 = "1699971900.000100"; // 14:25 UTC
+  const TS_14_28 = "1699972080.000300"; // 14:28 UTC
+  const MS_14_25 = 1699971900_000;
+  const MS_14_26 = 1699971960_000;
+  const MS_14_28 = 1699972080_000;
+  const MS_14_30 = 1699972200_000;
+
+  const DM_CHANNEL_ID = "D0DM0001";
+  const DM_CAPS: ChannelCapabilities = {
+    channel: "slack",
+    dashboardCapable: false,
+    supportsDynamicUi: false,
+    supportsVoiceInput: false,
+    chatType: "im",
+  };
+
+  /**
+   * Build the persisted-row metadata JSON envelope. `slackMeta` is stored as
+   * a JSON string sub-key inside the outer metadata object, mirroring the
+   * production write path in `conversation-messaging.ts`.
+   */
+  function metadataEnvelope(slackMeta: SlackMessageMetadata | null): string {
+    const envelope: Record<string, unknown> = {
+      userMessageChannel: "slack",
+      assistantMessageChannel: "slack",
+    };
+    if (slackMeta) {
+      envelope.slackMeta = writeSlackMetadata(slackMeta);
+    }
+    return JSON.stringify(envelope);
+  }
+
+  /** Build a row that mirrors how `addMessage` persists user/assistant content. */
+  function row(
+    role: "user" | "assistant",
+    text: string,
+    createdAt: number,
+    metadata: string | null,
+  ): SlackTranscriptInputRow {
+    return {
+      role,
+      content: JSON.stringify([{ type: "text", text }]),
+      createdAt,
+      metadata,
+    };
+  }
+
+  test("returns null when channel is not Slack", () => {
+    const caps: ChannelCapabilities = {
+      channel: "telegram",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "private",
+    };
+    const result = assembleSlackChronologicalMessages([], caps);
+    expect(result).toBeNull();
+  });
+
+  test("renders for Slack channels (chatType !== 'im')", () => {
+    // The channel branch and the DM branch share this assembler.
+    // `applyRuntimeInjections` swaps in the chronological transcript for
+    // any Slack conversation (channels and DMs alike); the assembler
+    // itself returns rendered messages for any Slack channel.
+    const channelCaps: ChannelCapabilities = {
+      ...DM_CAPS,
+      chatType: "channel",
+    };
+    const result = assembleSlackChronologicalMessages([], channelCaps);
+    expect(result).toEqual([]);
+  });
+
+  test("renders when chatType is missing entirely", () => {
+    // The assembler treats a missing chatType as a non-DM Slack channel
+    // (it does not infer DM from absence). Callers that need to
+    // distinguish DMs from channels (e.g. to skip thread-only injections)
+    // can still gate via `isSlackChannelConversation`.
+    const looseCaps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    };
+    const result = assembleSlackChronologicalMessages([], looseCaps);
+    expect(result).toEqual([]);
+  });
+
+  test("DM-only fixture: pure chronological render with no thread tags", () => {
+    // Two-turn DM: user → assistant → user. All rows carry slackMeta but
+    // none have threadTs (DMs never have threadTs). Output must be a flat
+    // chronological transcript with no `→ Mxxxxxx` parent-alias arrows.
+    const userMeta1: SlackMessageMetadata = {
+      source: "slack",
+      channelId: DM_CHANNEL_ID,
+      channelTs: TS_14_25,
+      eventKind: "message",
+      displayName: "@alice",
+    };
+    const userMeta2: SlackMessageMetadata = {
+      source: "slack",
+      channelId: DM_CHANNEL_ID,
+      channelTs: TS_14_28,
+      eventKind: "message",
+      displayName: "@alice",
+    };
+    // Outbound assistant rows in DMs may go through the legacy fallback
+    // when no slackMeta envelope is present at all (e.g. a row written
+    // before the post-send reconciliation lands, or pre-upgrade history).
+    // This fixture pins down the legacy interleave behaviour and matches
+    // how `assembleSlackChronologicalMessages` falls back to chronological
+    // ordering by createdAt for null-slackMeta rows.
+    const rows: SlackTranscriptInputRow[] = [
+      row("user", "hi assistant", MS_14_25, metadataEnvelope(userMeta1)),
+      row("assistant", "hi back!", MS_14_26, metadataEnvelope(null)),
+      row("user", "another one", MS_14_28, metadataEnvelope(userMeta2)),
+    ];
+
+    const result = assembleSlackChronologicalMessages(rows, DM_CAPS);
+    expect(result).not.toBeNull();
+    expect(result).toEqual([
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "[11/14/23 14:25 @alice]: hi assistant" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "[11/14/23 14:26]: hi back!" }],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "[11/14/23 14:28 @alice]: another one" },
+        ],
+      },
+    ]);
+    // Sanity: no thread-tag arrow ever appears in DM output.
+    for (const msg of result!) {
+      const text = (msg.content[0] as { type: "text"; text: string }).text;
+      expect(text).not.toMatch(/→ M[0-9a-f]{6}/);
+    }
+  });
+
+  test("legacy-DM fixture: pre-upgrade rows (no slackMeta) interleave with post-upgrade rows", () => {
+    // Mix:
+    //  - Two pre-upgrade rows (created before PR 16 wired slackMeta into
+    //    DM persistence). Their metadata column has no slackMeta sub-key —
+    //    the renderer's flat fallback orders them by createdAt.
+    //  - One post-upgrade user row with slackMeta.
+    //  - One assistant row that lacks slackMeta entirely (no metadata
+    //    column at all — also goes through the legacy fallback).
+    //
+    // All four rows must appear in the output, sorted chronologically.
+    const postUpgradeUserMeta: SlackMessageMetadata = {
+      source: "slack",
+      channelId: DM_CHANNEL_ID,
+      channelTs: TS_14_28,
+      eventKind: "message",
+      displayName: "@alice",
+    };
+
+    const rows: SlackTranscriptInputRow[] = [
+      // Pre-upgrade user row from before slackMeta was persisted on DMs.
+      row("user", "old hi", MS_14_25, metadataEnvelope(null)),
+      // Pre-upgrade assistant row.
+      row("assistant", "old reply", MS_14_26, metadataEnvelope(null)),
+      // Post-upgrade user row with slackMeta.
+      row("user", "fresh hi", MS_14_28, metadataEnvelope(postUpgradeUserMeta)),
+      // Assistant row with no metadata column at all (defensive: null
+      // metadata must still survive the assembly path).
+      row("assistant", "fresh reply", MS_14_30, null),
+    ];
+
+    const result = assembleSlackChronologicalMessages(rows, DM_CAPS);
+    expect(result).not.toBeNull();
+    expect(result!.map((m) => (m.content[0] as { text: string }).text)).toEqual(
+      [
+        "[11/14/23 14:25]: old hi",
+        "[11/14/23 14:26]: old reply",
+        "[11/14/23 14:28 @alice]: fresh hi",
+        "[11/14/23 14:30]: fresh reply",
+      ],
+    );
+    expect(result!.map((m) => m.role)).toEqual([
+      "user",
+      "assistant",
+      "user",
+      "assistant",
+    ]);
+  });
+
+  test("malformed slackMeta sub-key falls back to legacy flat render", () => {
+    // Defensive: if the slackMeta sub-key is present but isn't a valid
+    // serialized SlackMessageMetadata, the row is treated as legacy rather
+    // than dropped from context.
+    const badEnvelope = JSON.stringify({
+      userMessageChannel: "slack",
+      slackMeta: "not valid json {{{",
+    });
+    const rows: SlackTranscriptInputRow[] = [
+      row("user", "hello", MS_14_25, badEnvelope),
+    ];
+
+    const result = assembleSlackChronologicalMessages(rows, DM_CAPS);
+    expect(result).toEqual([
+      {
+        role: "user",
+        content: [{ type: "text", text: "[11/14/23 14:25]: hello" }],
+      },
+    ]);
+  });
+
+  test("empty rows yields an empty array (Slack DM with no history)", () => {
+    const result = assembleSlackChronologicalMessages([], DM_CAPS);
+    expect(result).toEqual([]);
+  });
+
+  test("attachment-only user rows emit a placeholder tag line so sender/timestamp attribution is preserved", () => {
+    // Before the placeholder, a row whose content is only an image or file
+    // would render without any tag line at all — the model would see the
+    // attachment block but lose all sender/timestamp attribution. Emit a
+    // synthetic tag line with an `[image]` / `[file]` placeholder so the
+    // attribution survives while the image/file block itself is still
+    // preserved alongside it.
+    const userMeta1: SlackMessageMetadata = {
+      source: "slack",
+      channelId: DM_CHANNEL_ID,
+      channelTs: TS_14_25,
+      eventKind: "message",
+      displayName: "@alice",
+    };
+    const userMeta2: SlackMessageMetadata = {
+      source: "slack",
+      channelId: DM_CHANNEL_ID,
+      channelTs: TS_14_28,
+      eventKind: "message",
+      displayName: "@alice",
+    };
+    const imageOnlyContent = JSON.stringify([
+      {
+        type: "image",
+        source: { type: "base64", media_type: "image/png", data: "aGVsbG8=" },
+      },
+    ]);
+    const mixedImageAndFileContent = JSON.stringify([
+      {
+        type: "image",
+        source: { type: "base64", media_type: "image/png", data: "aGVsbG8=" },
+      },
+      { type: "file", source: { type: "file_id", file_id: "file_1" } },
+    ]);
+    const rows: SlackTranscriptInputRow[] = [
+      {
+        role: "user",
+        content: imageOnlyContent,
+        createdAt: MS_14_25,
+        metadata: metadataEnvelope(userMeta1),
+      },
+      {
+        role: "user",
+        content: mixedImageAndFileContent,
+        createdAt: MS_14_28,
+        metadata: metadataEnvelope(userMeta2),
+      },
+    ];
+    const result = assembleSlackChronologicalMessages(rows, DM_CAPS);
+    expect(result).not.toBeNull();
+    expect(result!.length).toBe(2);
+    const firstTag = (result![0]!.content[0] as { type: "text"; text: string })
+      .text;
+    const secondTag = (result![1]!.content[0] as { type: "text"; text: string })
+      .text;
+    expect(firstTag).toBe("[11/14/23 14:25 @alice]: [image]");
+    expect(secondTag).toBe("[11/14/23 14:28 @alice]: [image] [file]");
+    // The attachment blocks themselves must still be preserved alongside.
+    expect(result![0]!.content.some((b) => b.type === "image")).toBe(true);
+    expect(
+      result![1]!.content.some((b) => b.type === "image") &&
+        result![1]!.content.some((b) => b.type === "file"),
+    ).toBe(true);
+    // No empty-body render like `[... @alice]: ` should ever appear.
+    for (const msg of result!) {
+      const head = (msg.content[0] as { type: "text"; text: string }).text;
+      expect(head).not.toMatch(/]:\s*$/);
+    }
+  });
+
+  test("row content with interleaved text + tool_use preserves tool_use alongside tag line", () => {
+    // Replayable content blocks (tool_use, tool_result, thinking, etc.) are
+    // preserved alongside the tag line. A row persisted with
+    // `[text, tool_use]` renders as `[{type:text, tag-line}, {type:tool_use}]`.
+    //
+    // The assistant tool_use is paired with a follow-up user tool_result so
+    // the orphan-pair filter leaves both blocks intact.
+    const userMeta: SlackMessageMetadata = {
+      source: "slack",
+      channelId: DM_CHANNEL_ID,
+      channelTs: TS_14_25,
+      eventKind: "message",
+      displayName: "@alice",
+    };
+    const assistantRowContent = JSON.stringify([
+      { type: "text", text: "looking it up" },
+      {
+        type: "tool_use",
+        id: "tu_1",
+        name: "search",
+        input: { q: "weather" },
+      },
+    ]);
+    const toolResultRowContent = JSON.stringify([
+      { type: "tool_result", tool_use_id: "tu_1", content: "72F sunny" },
+    ]);
+    const rows: SlackTranscriptInputRow[] = [
+      row("user", "what's the weather?", MS_14_25, metadataEnvelope(userMeta)),
+      {
+        role: "assistant",
+        content: assistantRowContent,
+        createdAt: MS_14_26,
+        metadata: metadataEnvelope(null),
+      },
+      {
+        role: "user",
+        content: toolResultRowContent,
+        createdAt: MS_14_28,
+        metadata: metadataEnvelope(null),
+      },
+    ];
+    const result = assembleSlackChronologicalMessages(rows, DM_CAPS);
+    expect(result).not.toBeNull();
+    const rendered = result!;
+    // Pin the assistant row shape — that is what this test is about.
+    expect(rendered.length).toBeGreaterThanOrEqual(2);
+    expect(rendered[1]!).toEqual({
+      role: "assistant",
+      content: [
+        { type: "text", text: "[11/14/23 14:26]: looking it up" },
+        {
+          type: "tool_use",
+          id: "tu_1",
+          name: "search",
+          input: { q: "weather" },
+        },
+      ],
+    });
+  });
+
+  test("post-reconciliation: assistant rows with channelTs participate in thread tagging", () => {
+    // Once `deliverReplyViaCallback` reconciles `channelTs` from the
+    // gateway's response, assistant rows carry a fully-formed slackMeta
+    // envelope. They must then render through the Slack chronological
+    // path (not the legacy fallback) so reply rows pointing at the
+    // assistant's prior message get a `→ Mxxxxxx` parent-alias arrow.
+    //
+    // This is the cross-thread visibility that the slack-thread-aware-
+    // context plan promises: a follow-up user reply to the assistant's
+    // earlier post should render with a parent-alias arrow that the model
+    // can use to reason about which prior assistant message it threads off.
+    const SLACK_CHANNEL_ID_2 = "C0THREAD";
+    const ASSISTANT_TS = "1700001000.000111";
+    const REPLY_TS = "1700001020.000222";
+    const SLACK_CAPS_CHANNEL: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+
+    const assistantMeta: SlackMessageMetadata = {
+      source: "slack",
+      channelId: SLACK_CHANNEL_ID_2,
+      channelTs: ASSISTANT_TS,
+      eventKind: "message",
+    };
+    const userReplyMeta: SlackMessageMetadata = {
+      source: "slack",
+      channelId: SLACK_CHANNEL_ID_2,
+      channelTs: REPLY_TS,
+      threadTs: ASSISTANT_TS, // Reply to the assistant's earlier message.
+      displayName: "@alice",
+      eventKind: "message",
+    };
+
+    // 1700001000 UTC = 2023-11-14 22:30:00 UTC
+    const MS_ASSISTANT = 1700001000_000;
+    const MS_REPLY = 1700001020_000;
+
+    const rows: SlackTranscriptInputRow[] = [
+      row(
+        "assistant",
+        "Earlier reply",
+        MS_ASSISTANT,
+        metadataEnvelope(assistantMeta),
+      ),
+      row("user", "Following up", MS_REPLY, metadataEnvelope(userReplyMeta)),
+    ];
+
+    const result = assembleSlackChronologicalMessages(rows, SLACK_CAPS_CHANNEL);
+    expect(result).not.toBeNull();
+    expect(result!.length).toBe(2);
+
+    // The user follow-up MUST carry a `→ Mxxxxxx` parent-alias arrow that
+    // points at the assistant's prior message. Before reconciliation, the
+    // assistant row was treated as legacy/null-metadata and excluded from
+    // alias issuance — the user reply rendered without the arrow.
+    const replyText = (result![1].content[0] as { text: string }).text;
+    expect(replyText).toMatch(/→ M[0-9a-f]{6}/);
+    expect(replyText).toContain(parentAlias(ASSISTANT_TS));
+  });
+
+  test("post-reconciliation: assistant row appears in active-thread focus block", () => {
+    // The active-thread focus block at
+    // `conversation-runtime-assembly.ts:1387` filters out rows with null
+    // metadata. Before reconciliation, outbound assistant rows were null-
+    // metadata at the renderable layer and silently dropped from the focus
+    // block — even when they were part of the active thread the user just
+    // replied to. Once channelTs is filled in, the assistant row's
+    // `threadTs` matches the active thread and the row is included.
+    const SLACK_CHANNEL_ID_3 = "C0FOCUS2";
+    const PARENT_TS = "1700002000.000001";
+    const ASSISTANT_REPLY_TS = "1700002005.000111";
+    const USER_REPLY_TS = "1700002010.000222";
+    const SLACK_CAPS_CHANNEL: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+
+    const parentMeta: SlackMessageMetadata = {
+      source: "slack",
+      channelId: SLACK_CHANNEL_ID_3,
+      channelTs: PARENT_TS,
+      eventKind: "message",
+      displayName: "@alice",
+    };
+    const assistantInThreadMeta: SlackMessageMetadata = {
+      source: "slack",
+      channelId: SLACK_CHANNEL_ID_3,
+      channelTs: ASSISTANT_REPLY_TS,
+      threadTs: PARENT_TS, // Assistant's reply lives inside the active thread.
+      eventKind: "message",
+    };
+    const userInThreadMeta: SlackMessageMetadata = {
+      source: "slack",
+      channelId: SLACK_CHANNEL_ID_3,
+      channelTs: USER_REPLY_TS,
+      threadTs: PARENT_TS, // Latest user row — drives active-thread detection.
+      displayName: "@alice",
+      eventKind: "message",
+    };
+
+    const rows: SlackTranscriptInputRow[] = [
+      {
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Parent message" }]),
+        createdAt: 1700002000_000,
+        metadata: metadataEnvelope(parentMeta),
+      },
+      {
+        role: "assistant",
+        content: JSON.stringify([
+          { type: "text", text: "Assistant earlier reply" },
+        ]),
+        createdAt: 1700002005_000,
+        metadata: metadataEnvelope(assistantInThreadMeta),
+      },
+      {
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Follow-up" }]),
+        createdAt: 1700002010_000,
+        metadata: metadataEnvelope(userInThreadMeta),
+      },
+    ];
+
+    const focusBlock = assembleSlackActiveThreadFocusBlock(
+      rows,
+      SLACK_CAPS_CHANNEL,
+    );
+    expect(focusBlock).not.toBeNull();
+    expect(focusBlock!).toContain("<active_thread>");
+    expect(focusBlock!).toContain("Parent message");
+    // The assistant's earlier reply must appear in the focus block now —
+    // before reconciliation it was excluded because its slackMeta failed
+    // `readSlackMetadata` validation (no channelTs).
+    expect(focusBlock!).toContain("Assistant earlier reply");
+    expect(focusBlock!).toContain("Follow-up");
+  });
+
+  test("multi-step tool turn: preserves tool_use/tool_result pairs across assembled transcript", () => {
+    // Simulates seven rows of a realistic multi-step tool-using turn:
+    //   user("hi")
+    //   assistant([text, tool_use(abc)])
+    //   user([tool_result(abc)])
+    //   assistant([text, tool_use(def)])
+    //   user([tool_result(def)])
+    //   assistant([text])
+    //   user("follow-up")
+    //
+    // Rows 3 and 5 are synthetic "tool-turn" rows generated by the agent
+    // loop and are NOT sent to Slack (no slackMeta.channelTs). They still
+    // persist structurally because Anthropic requires tool_use/tool_result
+    // pairing in message history. The chronological renderer must:
+    //   - preserve all four tool blocks in order
+    //   - emit pure-tool-only messages (no tag line) for the synthetic rows
+    //   - keep the Slack-visible rows' tag lines intact
+    const CHANNEL = "C0ROUNDTRIP";
+    const TS_TOP_USER = "1700003000.000100"; // 23:03:20 UTC
+    const TS_ASSIST_1 = "1700003005.000200"; // 23:03:25 UTC
+    const TS_ASSIST_2 = "1700003015.000300"; // 23:03:35 UTC
+    const TS_ASSIST_3 = "1700003025.000400"; // 23:03:45 UTC
+    const TS_FOLLOWUP = "1700003030.000500"; // 23:03:50 UTC
+
+    const userMeta = (ts: string): SlackMessageMetadata => ({
+      source: "slack",
+      channelId: CHANNEL,
+      channelTs: ts,
+      eventKind: "message",
+      displayName: "@alice",
+    });
+    const assistMeta = (ts: string): SlackMessageMetadata => ({
+      source: "slack",
+      channelId: CHANNEL,
+      channelTs: ts,
+      eventKind: "message",
+    });
+
+    const rows: SlackTranscriptInputRow[] = [
+      // 1. User "hi" — Slack-visible, carries channelTs.
+      {
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "hi" }]),
+        createdAt: 1700003000_000,
+        metadata: metadataEnvelope(userMeta(TS_TOP_USER)),
+      },
+      // 2. Assistant: text + tool_use(abc) — Slack-visible.
+      {
+        role: "assistant",
+        content: JSON.stringify([
+          { type: "text", text: "checking..." },
+          {
+            type: "tool_use",
+            id: "tu_abc",
+            name: "search",
+            input: { q: "first" },
+          },
+        ]),
+        createdAt: 1700003005_000,
+        metadata: metadataEnvelope(assistMeta(TS_ASSIST_1)),
+      },
+      // 3. User: tool_result(abc) — synthetic, no slackMeta envelope.
+      {
+        role: "user",
+        content: JSON.stringify([
+          { type: "tool_result", tool_use_id: "tu_abc", content: "result 1" },
+        ]),
+        createdAt: 1700003006_000,
+        metadata: metadataEnvelope(null),
+      },
+      // 4. Assistant: text + tool_use(def) — Slack-visible.
+      {
+        role: "assistant",
+        content: JSON.stringify([
+          { type: "text", text: "one more lookup..." },
+          {
+            type: "tool_use",
+            id: "tu_def",
+            name: "search",
+            input: { q: "second" },
+          },
+        ]),
+        createdAt: 1700003015_000,
+        metadata: metadataEnvelope(assistMeta(TS_ASSIST_2)),
+      },
+      // 5. User: tool_result(def) — synthetic, no slackMeta envelope.
+      {
+        role: "user",
+        content: JSON.stringify([
+          { type: "tool_result", tool_use_id: "tu_def", content: "result 2" },
+        ]),
+        createdAt: 1700003016_000,
+        metadata: metadataEnvelope(null),
+      },
+      // 6. Assistant: text-only final answer — Slack-visible.
+      {
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "all done" }]),
+        createdAt: 1700003025_000,
+        metadata: metadataEnvelope(assistMeta(TS_ASSIST_3)),
+      },
+      // 7. User: follow-up text — Slack-visible.
+      {
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "follow-up" }]),
+        createdAt: 1700003030_000,
+        metadata: metadataEnvelope(userMeta(TS_FOLLOWUP)),
+      },
+    ];
+
+    const SLACK_CAPS_CHANNEL: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+
+    const result = assembleSlackChronologicalMessages(rows, SLACK_CAPS_CHANNEL);
+    expect(result).not.toBeNull();
+
+    // All four tool blocks must appear in the rendered transcript.
+    const allBlocks = result!.flatMap((m) => m.content);
+    const toolUses = allBlocks.filter((b) => b.type === "tool_use");
+    const toolResults = allBlocks.filter((b) => b.type === "tool_result");
+    expect(toolUses.map((b) => (b as { id: string }).id)).toEqual([
+      "tu_abc",
+      "tu_def",
+    ]);
+    expect(
+      toolResults.map((b) => (b as { tool_use_id: string }).tool_use_id),
+    ).toEqual(["tu_abc", "tu_def"]);
+
+    // tool_use(abc) must come before tool_result(abc), and likewise for def.
+    // Since they sit on adjacent rows, enforcing this via the flat index of
+    // each block is sufficient.
+    const findIdx = (pred: (b: (typeof allBlocks)[number]) => boolean) =>
+      allBlocks.findIndex(pred);
+    const idxTuAbc = findIdx(
+      (b) => b.type === "tool_use" && (b as { id: string }).id === "tu_abc",
+    );
+    const idxTrAbc = findIdx(
+      (b) =>
+        b.type === "tool_result" &&
+        (b as { tool_use_id: string }).tool_use_id === "tu_abc",
+    );
+    const idxTuDef = findIdx(
+      (b) => b.type === "tool_use" && (b as { id: string }).id === "tu_def",
+    );
+    const idxTrDef = findIdx(
+      (b) =>
+        b.type === "tool_result" &&
+        (b as { tool_use_id: string }).tool_use_id === "tu_def",
+    );
+    expect(idxTuAbc).toBeLessThan(idxTrAbc);
+    expect(idxTrAbc).toBeLessThan(idxTuDef);
+    expect(idxTuDef).toBeLessThan(idxTrDef);
+
+    // Slack-visible rows render a tag line; synthetic tool-turn rows do not.
+    // Per-row assertion: we expect 7 messages (one per persisted row).
+    expect(result!.length).toBe(7);
+
+    // Row 1: user tag line only.
+    expect(result![0]).toEqual({
+      role: "user",
+      content: [{ type: "text", text: "[11/14/23 23:03 @alice]: hi" }],
+    });
+    // Row 2: assistant tag line + tool_use(abc).
+    expect(result![1]).toEqual({
+      role: "assistant",
+      content: [
+        { type: "text", text: "[11/14/23 23:03]: checking..." },
+        {
+          type: "tool_use",
+          id: "tu_abc",
+          name: "search",
+          input: { q: "first" },
+        },
+      ],
+    });
+    // Row 3: synthetic tool_result(abc) — no tag line.
+    expect(result![2]).toEqual({
+      role: "user",
+      content: [
+        { type: "tool_result", tool_use_id: "tu_abc", content: "result 1" },
+      ],
+    });
+    // Row 4: assistant tag line + tool_use(def).
+    expect(result![3]).toEqual({
+      role: "assistant",
+      content: [
+        { type: "text", text: "[11/14/23 23:03]: one more lookup..." },
+        {
+          type: "tool_use",
+          id: "tu_def",
+          name: "search",
+          input: { q: "second" },
+        },
+      ],
+    });
+    // Row 5: synthetic tool_result(def) — no tag line.
+    expect(result![4]).toEqual({
+      role: "user",
+      content: [
+        { type: "tool_result", tool_use_id: "tu_def", content: "result 2" },
+      ],
+    });
+    // Row 6: assistant final text-only answer, rendered as tag line only.
+    expect(result![5]).toEqual({
+      role: "assistant",
+      content: [{ type: "text", text: "[11/14/23 23:03]: all done" }],
+    });
+    // Row 7: user follow-up tag line.
+    expect(result![6]).toEqual({
+      role: "user",
+      content: [{ type: "text", text: "[11/14/23 23:03 @alice]: follow-up" }],
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// applyRuntimeInjections blocks.pkbSystemReminder
+// ---------------------------------------------------------------------------
+
+describe("applyRuntimeInjections blocks.pkbSystemReminder", () => {
+  const baseMessages: Message[] = [
+    {
+      role: "user",
+      content: [{ type: "text", text: "Hello" }],
+    },
+  ];
+
+  test("captures exact reminder bytes when full mode and PKB active", async () => {
+    pkbSearchResults = [];
+    pkbSearchThrows = null;
+    const { blocks } = await applyRuntimeInjections(baseMessages, {
+      pkbActive: true,
+      mode: "full",
+    });
+
+    const expected = buildPkbReminder([]);
+    expect(blocks.pkbSystemReminder).toBe(expected);
+  });
+
+  test("not captured in minimal mode", async () => {
+    const { blocks } = await applyRuntimeInjections(baseMessages, {
+      pkbActive: true,
+      mode: "minimal",
+    });
+
+    expect(blocks.pkbSystemReminder).toBeUndefined();
+  });
+
+  test("not captured when PKB inactive", async () => {
+    const { blocks } = await applyRuntimeInjections(baseMessages, {
+      pkbActive: false,
+      mode: "full",
+    });
+
+    expect(blocks.pkbSystemReminder).toBeUndefined();
+  });
+});