@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

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

@@ -2,17 +2,30 @@ import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { eq } from "drizzle-orm";
+
 // This test exercises v1 PKB injection. `config.memory.v2.enabled` (default
 // `true`) makes the PKB injector go silent — force it off here so the v1
 // injection chain assertions stay meaningful.
 const realLoaderForAssemblyTest = await import("../config/loader.js");
 const realGetConfigForAssemblyTest = realLoaderForAssemblyTest.getConfig;
+// Per-test overrides for `ui.userTimezone` / `ui.detectedTimezone` so the
+// config self-resolution inside `applyRuntimeInjections` can be exercised.
+let assemblyConfiguredUserTimezone: string | null | undefined;
+let assemblyDetectedTimezone: string | null | undefined;
 mock.module("../config/loader.js", () => ({
   ...realLoaderForAssemblyTest,
   getConfig: () => {
     const real = realGetConfigForAssemblyTest();
     return {
       ...real,
+      ui: {
+        ...real.ui,
+        userTimezone:
+          assemblyConfiguredUserTimezone ?? real.ui?.userTimezone ?? null,
+        detectedTimezone:
+          assemblyDetectedTimezone ?? real.ui?.detectedTimezone ?? null,
+      },
       memory: { ...real.memory, v2: { ...real.memory.v2, enabled: false } },
       slack: { ...real.slack, botUserId: "U_BOT" },
     };
@@ -35,17 +48,36 @@ mock.module("../memory/pkb/pkb-search.js", () => ({
   },
 }));
 
+// `applyRuntimeInjections` computes the `<turn_context>` `current_time` live via
+// `formatTurnTimestamp`; pin it so the rendered block matches the deterministic
+// `buildUnifiedTurnContextBlock` expectations below. The rest of the module
+// (timezone canonicalization/resolution) keeps its real behavior.
+const FIXED_TURN_TIMESTAMP = "2026-04-02T12:00:00Z";
+// Conversation id the runtime-injection tests register their live conversation
+// under; passed explicitly now that `applyRuntimeInjections` requires the
+// caller to name the conversation it resolves through.
+const FALLBACK_CONVERSATION_ID = "runtime-assembly-fallback";
+const realDateContextForAssemblyTest =
+  await import("../daemon/date-context.js");
+mock.module("../daemon/date-context.js", () => ({
+  ...realDateContextForAssemblyTest,
+  formatTurnTimestamp: () => FIXED_TURN_TIMESTAMP,
+}));
+
+import { LLMSchema } from "../config/schemas/llm.js";
+import {
+  clearConversations,
+  setConversation,
+} from "../daemon/conversation-registry.js";
 import type {
   ChannelCapabilities,
   SlackTranscriptInputRow,
-  UnifiedTurnContextOptions,
 } from "../daemon/conversation-runtime-assembly.js";
 import {
   applyRuntimeInjections,
   assembleSlackActiveThreadFocusBlock,
   assembleSlackChronologicalMessages,
   buildSubagentStatusBlock,
-  buildUnifiedTurnContextBlock,
   getSlackCompactionWatermarkForPrefix,
   injectChannelCapabilityContext,
   injectChannelCommandContext,
@@ -55,24 +87,42 @@ import {
   loadSlackChronologicalContext,
   loadSlackChronologicalMessages,
   resolveChannelCapabilities,
+  resolveTurnInboundActorContext,
+  resolveTurnModelProfileLabel,
   stripChannelCapabilityContext,
   stripInjectionsForCompaction,
   stripNowScratchpad,
 } from "../daemon/conversation-runtime-assembly.js";
+import type { SurfaceData, SurfaceType } from "../daemon/message-protocol.js";
 import { buildPkbReminder } from "../daemon/pkb-reminder-builder.js";
+import type { TrustContext } from "../daemon/trust-context.js";
 import type { MessageRow } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import { getPkbRoot } from "../memory/pkb/types.js";
+import { conversations, messages } from "../memory/schema.js";
 import {
   type SlackMessageMetadata,
   writeSlackMetadata,
 } from "../messaging/providers/slack/message-metadata.js";
 import { parentAlias } from "../messaging/providers/slack/render-transcript.js";
+import postCompact from "../plugins/defaults/memory-retrieval/hooks/post-compact.js";
+import {
+  buildUnifiedTurnContextBlock,
+  type UnifiedTurnContextOptions,
+} from "../plugins/defaults/memory-retrieval/unified-turn-context.js";
 import type { Message } from "../providers/types.js";
 import { wrapUntrustedContent } from "../security/untrusted-content.js";
+import { getSubagentManager } from "../subagent/index.js";
 import type { SubagentState } from "../subagent/types.js";
 import { getWorkspacePromptPath } from "../util/platform.js";
 
+// `applyRuntimeInjections` self-resolves the Slack active-thread focus block by
+// reading the live conversation's persisted message rows, so the schema must
+// exist before any Slack-channel assembly test runs.
+initializeDb();
+
 // The pkb-reminder injector derives PKB-active state from the workspace itself
 // — `readPkbContext()` returning content behind the personal-memory trust gate
 // — rather than from a threaded flag. Tests that need the reminder to fire seed
@@ -103,6 +153,66 @@ function clearNowScratchpad(): void {
   rmSync(getWorkspacePromptPath("NOW.md"), { force: true });
 }
 
+// The workspace-context injector sources its block off the live `Conversation`
+// looked up by `conversationId`. Register a fake instance carrying both a
+// non-dirty workspace context (non-null content, not dirty) so
+// `resolveWorkspaceTopLevelContext` returns it verbatim without rescanning the
+// filesystem, and an active dynamic-page surface, so `applyRuntimeInjections`
+// resolves the `<workspace>` and `<active_workspace>` blocks from it;
+// `clearConversations()` between tests keeps suites that assert the blocks are
+// absent unaffected.
+function seedActiveSurfaceConversation(
+  conversationId: string,
+  workspaceText: string,
+  surfaceId: string,
+  data: SurfaceData,
+  channelCapabilities?: ChannelCapabilities,
+  commandIntent?: { type: string; payload?: string; languageCode?: string },
+  currentTurnTemporalSnapshot?: {
+    clientTimezone: string | null;
+  },
+): void {
+  setConversation(conversationId, {
+    conversationId,
+    workingDir: "/sandbox",
+    workspaceTopLevelContext: workspaceText,
+    workspaceTopLevelDirty: false,
+    currentActiveSurfaceId: surfaceId,
+    surfaceState: new Map<
+      string,
+      { surfaceType: SurfaceType; data: SurfaceData }
+    >([[surfaceId, { surfaceType: "dynamic_page", data }]]),
+    channelCapabilities: channelCapabilities ?? undefined,
+    commandIntent,
+    currentTurnTemporalSnapshot,
+  } as never);
+}
+
+function clearWorkspaceContext(): void {
+  clearConversations();
+}
+
+// The `<channel_capabilities>` branch and the Slack gates source the channel
+// capabilities off the live `Conversation` looked up by `conversationId`.
+// Register a fake fallback instance carrying the given capabilities (and a
+// non-dirty empty workspace + empty surface so the other live-sourced branches
+// stay inert) so `applyRuntimeInjections` resolves them; `clearConversations()`
+// between tests keeps suites asserting absence unaffected.
+function seedChannelCapabilitiesConversation(
+  caps: ChannelCapabilities | null,
+  transportHints?: string[],
+): void {
+  setConversation("runtime-assembly-fallback", {
+    conversationId: "runtime-assembly-fallback",
+    workingDir: "/sandbox",
+    workspaceTopLevelContext: "",
+    workspaceTopLevelDirty: false,
+    surfaceState: new Map(),
+    channelCapabilities: caps ?? undefined,
+    transportHints,
+  } as never);
+}
+
 // ---------------------------------------------------------------------------
 // resolveChannelCapabilities
 // ---------------------------------------------------------------------------
@@ -575,6 +685,8 @@ describe("stripChannelCapabilityContext", () => {
 // ---------------------------------------------------------------------------
 
 describe("applyRuntimeInjections with channelCapabilities", () => {
+  afterEach(clearConversations);
+
   const baseMessages: Message[] = [
     {
       role: "user",
@@ -590,8 +702,9 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
       supportsVoiceInput: false,
     };
 
+    seedChannelCapabilitiesConversation(caps);
     const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      channelCapabilities: caps,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
 
     expect(result.length).toBe(1);
@@ -603,8 +716,9 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
   });
 
   test("does not inject when channelCapabilities is null", async () => {
+    seedChannelCapabilitiesConversation(null);
     const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      channelCapabilities: null,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
 
     expect(result.length).toBe(1);
@@ -612,7 +726,9 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
   });
 
   test("does not inject when channelCapabilities is omitted", async () => {
-    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
+    });
 
     expect(result.length).toBe(1);
     expect(result[0].content.length).toBe(1);
@@ -626,8 +742,9 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
       supportsVoiceInput: false,
     };
 
+    seedChannelCapabilitiesConversation(caps);
     const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      channelCapabilities: caps,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
 
     expect(result.length).toBe(1);
@@ -755,30 +872,25 @@ describe("applyRuntimeInjections — injection mode", () => {
     },
   ];
 
+  const channelCapabilities: ChannelCapabilities = {
+    channel: "telegram",
+    dashboardCapable: false,
+    supportsDynamicUi: false,
+    supportsVoiceInput: false,
+  };
+
   const fullOptions = {
-    workspaceTopLevelContext: "<workspace>\nRoot: /sandbox\n</workspace>",
-    channelCommandContext: { type: "start" } as const,
-    activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
-    channelCapabilities: {
-      channel: "telegram",
-      dashboardCapable: false,
-      supportsDynamicUi: false,
-      supportsVoiceInput: false,
-    } as ChannelCapabilities,
-    unifiedTurnContext:
-      "<turn_context>\ncurrent_time: 2026-03-04 (Tuesday) 12:00:00 +00:00 (UTC)\ninterface: telegram\n</turn_context>",
+    // Non-interactive turn so the `<non_interactive_context>` branch fires.
     isNonInteractive: true,
+    requestId: "injection-mode-req",
+    conversationId: "injection-mode-conv",
+    turnIndex: 0,
     // Guardian trust so the personal-memory gate admits the actor regardless
     // of the telegram channel capabilities under test, letting the reminder
     // gate hinge purely on PKB content presence.
-    turnContext: {
-      requestId: "injection-mode-req",
-      conversationId: "injection-mode-conv",
-      turnIndex: 0,
-      trust: {
-        sourceChannel: "vellum" as const,
-        trustClass: "guardian" as const,
-      },
+    trust: {
+      sourceChannel: "vellum" as const,
+      trustClass: "guardian" as const,
     },
   };
 
@@ -788,10 +900,22 @@ describe("applyRuntimeInjections — injection mode", () => {
   beforeEach(() => {
     seedPkbContent();
     seedNowScratchpad("Current focus: shipping PR 3");
+    seedActiveSurfaceConversation(
+      "injection-mode-conv",
+      "<workspace>\nRoot: /sandbox\n</workspace>",
+      "sf_1",
+      { html: "<div>test</div>" },
+      channelCapabilities,
+      { type: "start" },
+      {
+        clientTimezone: null,
+      },
+    );
   });
   afterEach(() => {
     clearPkbContent();
     clearNowScratchpad();
+    clearWorkspaceContext();
   });
 
   test("full mode (default) includes all injections", async () => {
@@ -898,6 +1022,34 @@ describe("applyRuntimeInjections — injection mode", () => {
 
     expect(texts).toContain("Hello");
   });
+
+  test("post-compaction re-injection resolves the live conversation from the conversation id", async () => {
+    // GIVEN the seeded live conversation `injection-mode-conv` whose
+    // conversation-scoped blocks (`<active_workspace>`, `<channel_capabilities>`)
+    // only resolve when `applyRuntimeInjections` finds it by conversation id
+    // AND the agent loop hands the post-compaction hook the turn-identity fields
+    // flat (`requestId`, `conversationId`, `trust`)
+    const { messages: result } = await postCompact({
+      history: baseMessages,
+      requestId: "reinject-req",
+      conversationId: "injection-mode-conv",
+      trust: { sourceChannel: "vellum", trustClass: "guardian" },
+      isNonInteractive: false,
+      mode: "full",
+      modelProfile: null,
+      actorContext: null,
+    });
+    const allText = result[0].content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+
+    // THEN the hook forwards `conversationId` onto the flat injection options,
+    // so the re-injection resolves the same live conversation as the turn's
+    // initial assembly rather than the synthetic fallback.
+    expect(allText).toContain("<active_workspace>");
+    expect(allText).toContain("<channel_capabilities>");
+  });
 });
 
 // The now-md default injector emits the `<NOW.md>` block as an
@@ -1051,7 +1203,7 @@ describe("stripInjectionsForCompaction preserves persistent blocks", () => {
     ).toContain("<turn_context>");
   });
 
-  test("<workspace> blocks are NOT stripped", () => {
+  test("<workspace> blocks ARE stripped so the injector re-sources them post-compaction", () => {
     const messages: Message[] = [
       {
         role: "user",
@@ -1067,10 +1219,10 @@ describe("stripInjectionsForCompaction preserves persistent blocks", () => {
 
     const result = stripInjectionsForCompaction(messages);
     expect(result.length).toBe(1);
-    expect(result[0].content.length).toBe(2);
-    expect(
-      (result[0].content[0] as { type: "text"; text: string }).text,
-    ).toContain("<workspace>");
+    expect(result[0].content.length).toBe(1);
+    expect((result[0].content[0] as { type: "text"; text: string }).text).toBe(
+      "Hello",
+    );
   });
 
   test("legacy <workspace_top_level> blocks ARE stripped for backward compat", () => {
@@ -1237,7 +1389,9 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
 
   test("injects NOW.md block when the file has content", async () => {
     seedNowScratchpad("Current focus: fix the bug");
-    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
+    });
 
     expect(result.length).toBe(1);
     expect(result[0].content.length).toBe(2);
@@ -1249,7 +1403,9 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
 
   test("scratchpad appears before user's original text content", async () => {
     seedNowScratchpad("scratchpad notes");
-    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
+    });
 
     // Scratchpad comes first (before user content)
     expect(
@@ -1262,7 +1418,9 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
   });
 
   test("does not inject when the NOW.md file is absent", async () => {
-    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
+    });
 
     expect(result.length).toBe(1);
     expect(result[0].content.length).toBe(1);
@@ -1271,6 +1429,7 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
   test("skipped in minimal mode", async () => {
     seedNowScratchpad("Current focus: fix the bug");
     const { messages: result } = await applyRuntimeInjections(baseMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
       mode: "minimal",
     });
 
@@ -1283,6 +1442,138 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// resolveTurnInboundActorContext
+// ---------------------------------------------------------------------------
+
+describe("resolveTurnInboundActorContext", () => {
+  /**
+   * No trust context means there is no inbound actor to ground the turn on, so
+   * the actor section is suppressed.
+   */
+  test("returns null when there is no trust context", () => {
+    // GIVEN a turn with no trust context
+    // WHEN the inbound actor context is resolved
+    const actorContext = resolveTurnInboundActorContext(undefined, "asst-1");
+
+    // THEN there is no actor context to inject
+    expect(actorContext).toBeNull();
+  });
+
+  /**
+   * Guardian (owner) turns suppress the actor section — the unified turn context
+   * only renders actor fields for non-guardian actors.
+   */
+  test("returns null on guardian turns", () => {
+    // GIVEN a guardian trust context (no requester chat id, so the direct
+    // projection branch is taken)
+    const trustContext: TrustContext = {
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+      requesterDisplayName: "Alice",
+    };
+
+    // WHEN the inbound actor context is resolved
+    const actorContext = resolveTurnInboundActorContext(trustContext, "asst-1");
+
+    // THEN the actor section is suppressed for the owner
+    expect(actorContext).toBeNull();
+  });
+
+  /**
+   * A non-guardian trust context without the identity fields needed for the
+   * unified actor-trust lookup is projected directly into the actor context.
+   */
+  test("projects a non-guardian trust context directly", () => {
+    // GIVEN a trusted-contact trust context lacking requester chat/user ids
+    const trustContext: TrustContext = {
+      sourceChannel: "telegram",
+      trustClass: "trusted_contact",
+      requesterIdentifier: "@bob_handle",
+      requesterDisplayName: "Bob",
+      requesterSenderDisplayName: "Bobby",
+    };
+
+    // WHEN the inbound actor context is resolved
+    const actorContext = resolveTurnInboundActorContext(trustContext, "asst-1");
+
+    // THEN the trust context is projected into the model-facing actor context
+    expect(actorContext).toEqual({
+      sourceChannel: "telegram",
+      canonicalActorIdentity: null,
+      actorIdentifier: "@bob_handle",
+      actorDisplayName: "Bob",
+      actorSenderDisplayName: "Bobby",
+      actorMemberDisplayName: undefined,
+      trustClass: "trusted_contact",
+      guardianIdentity: undefined,
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveTurnModelProfileLabel
+// ---------------------------------------------------------------------------
+
+describe("resolveTurnModelProfileLabel", () => {
+  /**
+   * A null key means the active profile is unchanged since the last notified
+   * one, so there is no `model_profile` line to render this turn.
+   */
+  test("returns null when the profile key is null", () => {
+    // GIVEN a turn whose profile is unchanged since the last notification
+    const llm = LLMSchema.parse({
+      default: { provider: "anthropic", model: "claude-sonnet-4-7" },
+    });
+
+    // WHEN the label is resolved for a null key
+    const label = resolveTurnModelProfileLabel(null, "mainAgent", llm);
+
+    // THEN there is no profile line to inject
+    expect(label).toBeNull();
+  });
+
+  /**
+   * A known profile renders its configured display label paired with the model
+   * the call site resolves to.
+   */
+  test("renders the profile's label with the resolved model", () => {
+    // GIVEN a workspace with a labelled "fast" profile
+    const llm = LLMSchema.parse({
+      default: { provider: "anthropic", model: "claude-sonnet-4-7" },
+      profiles: {
+        fast: { label: "Fast", provider: "anthropic", model: "claude-haiku-4" },
+      },
+    });
+
+    // WHEN the label is resolved for that profile at the main-agent call site
+    const label = resolveTurnModelProfileLabel("fast", "mainAgent", llm);
+
+    // THEN the rendered line pairs the display label with the resolved model
+    expect(label).toBe("Fast (claude-haiku-4)");
+  });
+
+  /**
+   * A profile with no configured label falls back to its raw key so the model
+   * still gets a stable identifier.
+   */
+  test("falls back to the raw key when the profile has no label", () => {
+    // GIVEN a profile that sets a model but no display label
+    const llm = LLMSchema.parse({
+      default: { provider: "anthropic", model: "claude-sonnet-4-7" },
+      profiles: {
+        deep: { provider: "anthropic", model: "claude-opus-4" },
+      },
+    });
+
+    // WHEN the label is resolved for that profile
+    const label = resolveTurnModelProfileLabel("deep", "mainAgent", llm);
+
+    // THEN the raw key stands in for the missing label
+    expect(label).toBe("deep (claude-opus-4)");
+  });
+});
+
 // ---------------------------------------------------------------------------
 // buildUnifiedTurnContextBlock
 // ---------------------------------------------------------------------------
@@ -1694,6 +1985,8 @@ describe("buildUnifiedTurnContextBlock", () => {
 // ---------------------------------------------------------------------------
 
 describe("applyRuntimeInjections with unifiedTurnContext", () => {
+  afterEach(clearConversations);
+
   const baseMessages: Message[] = [
     {
       role: "user",
@@ -1701,12 +1994,42 @@ describe("applyRuntimeInjections with unifiedTurnContext", () => {
     },
   ];
 
-  const sampleBlock =
-    "<turn_context>\ncurrent_time: 2026-04-02T12:00:00Z\ninterface: macos\n</turn_context>";
+  const sampleOptions = {
+    interfaceName: "macos",
+  };
+  // The block reflects the options-bag interface and the `current_time` the
+  // injector computes live (pinned to `FIXED_TURN_TIMESTAMP` for this suite).
+  const sampleBlock = buildUnifiedTurnContextBlock({
+    timestamp: FIXED_TURN_TIMESTAMP,
+    ...sampleOptions,
+  });
+
+  // Seed the live fallback conversation with the per-turn temporal snapshot
+  // (its presence gates the `<turn_context>` block) and the turn interface
+  // context (so the injector sources the interface label to match
+  // `sampleOptions.interfaceName`).
+  function seedTemporalSnapshot(): void {
+    setConversation("runtime-assembly-fallback", {
+      conversationId: "runtime-assembly-fallback",
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: "",
+      workspaceTopLevelDirty: false,
+      surfaceState: new Map(),
+      currentTurnTemporalSnapshot: {
+        clientTimezone: null,
+      },
+      currentTurnInterfaceContext: {
+        userMessageInterface: "macos",
+        assistantMessageInterface: "macos",
+      },
+    } as never);
+  }
+
+  test("injects the turn-context block when the inputs are provided", async () => {
+    seedTemporalSnapshot();
 
-  test("injects unifiedTurnContext when provided", async () => {
     const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      unifiedTurnContext: sampleBlock,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
 
     expect(result).toHaveLength(1);
@@ -1720,25 +2043,21 @@ describe("applyRuntimeInjections with unifiedTurnContext", () => {
     );
   });
 
-  test("does not inject when unifiedTurnContext is null", async () => {
+  test("does not inject when the timestamp snapshot is absent", async () => {
     const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      unifiedTurnContext: null,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
 
     expect(result).toHaveLength(1);
     expect(result[0].content).toHaveLength(1);
   });
 
-  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", async () => {
+    seedTemporalSnapshot();
+
     const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      unifiedTurnContext: sampleBlock,
+      conversationId: FALLBACK_CONVERSATION_ID,
+      ...sampleOptions,
       mode: "full",
     });
 
@@ -1751,8 +2070,11 @@ describe("applyRuntimeInjections with unifiedTurnContext", () => {
   });
 
   test("injected in minimal mode (no mode guard)", async () => {
+    seedTemporalSnapshot();
+
     const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      unifiedTurnContext: sampleBlock,
+      conversationId: FALLBACK_CONVERSATION_ID,
+      ...sampleOptions,
       mode: "minimal",
     });
 
@@ -1765,11 +2087,168 @@ describe("applyRuntimeInjections with unifiedTurnContext", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// applyRuntimeInjections self-resolves the config timezones
+// ---------------------------------------------------------------------------
+
+describe("applyRuntimeInjections timezone resolution", () => {
+  afterEach(() => {
+    assemblyConfiguredUserTimezone = undefined;
+    assemblyDetectedTimezone = undefined;
+    clearConversations();
+  });
+
+  const baseMessages: Message[] = [
+    { role: "user", content: [{ type: "text", text: "Hello there" }] },
+  ];
+
+  // Seed the live fallback conversation with the per-turn temporal snapshot the
+  // loop freezes after memory retrieval. `applyRuntimeInjections` sources the
+  // client timezone and the long-absence gap from it, so the turn-context block
+  // only emits when this snapshot is present.
+  function seedTemporalSnapshot(
+    clientTimezone: string | null,
+    timeSinceLastMessage: string | null = null,
+  ): void {
+    setConversation("runtime-assembly-fallback", {
+      conversationId: "runtime-assembly-fallback",
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: "",
+      workspaceTopLevelDirty: false,
+      surfaceState: new Map(),
+      currentTurnTemporalSnapshot: {
+        clientTimezone,
+        timeSinceLastMessage,
+      },
+    } as never);
+  }
+
+  function injectedText(result: { messages: Message[] }): string {
+    return result.messages[0].content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+  }
+
+  test("sources the configured and detected timezones from config, not the options bag", async () => {
+    /**
+     * Verifies the re-homed configured user timezone and detected-timezone
+     * fallback are read from `config.ui` inside `applyRuntimeInjections`
+     * rather than threaded through the options bag. The detected timezone is
+     * the device-timezone fallback used when the client reports none.
+     */
+    // GIVEN the guardian has configured a user timezone in config
+    assemblyConfiguredUserTimezone = "America/New_York";
+
+    // AND a different server-detected timezone is configured
+    assemblyDetectedTimezone = "America/Los_Angeles";
+
+    // AND the turn's frozen snapshot carries no client timezone (so the
+    // detected timezone is the device-timezone fallback)
+    seedTemporalSnapshot(null);
+
+    // WHEN a turn is assembled
+    const result = await applyRuntimeInjections(baseMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
+    });
+
+    // THEN the injector surfaces the mismatch using the config-sourced values
+    const injected = injectedText(result);
+    expect(injected).toContain("configured_user_timezone: America/New_York");
+    expect(injected).toContain("client_device_timezone: America/Los_Angeles");
+  });
+
+  test("sources clientTimezone from the conversation's frozen turn snapshot", async () => {
+    /**
+     * Verifies the per-turn client timezone is taken from the conversation's
+     * frozen `currentTurnTemporalSnapshot` and takes precedence over the
+     * config-sourced detected-timezone fallback.
+     */
+    // GIVEN the configured user timezone and a detected fallback in config
+    assemblyConfiguredUserTimezone = "America/New_York";
+    assemblyDetectedTimezone = "America/Denver";
+
+    // AND the turn's frozen snapshot carries a client timezone
+    seedTemporalSnapshot("America/Los_Angeles");
+
+    // WHEN a turn is assembled
+    const result = await applyRuntimeInjections(baseMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
+    });
+
+    // THEN the injector surfaces the mismatch using the snapshot's client value
+    const injected = injectedText(result);
+    expect(injected).toContain("configured_user_timezone: America/New_York");
+    expect(injected).toContain("client_device_timezone: America/Los_Angeles");
+  });
+
+  test("omits the mismatch lines when config and client timezone agree", async () => {
+    /**
+     * Verifies no mismatch affordance is emitted when the config-sourced
+     * configured user timezone matches the snapshot's client timezone.
+     */
+    // GIVEN the configured user timezone matches the client timezone
+    assemblyConfiguredUserTimezone = "America/New_York";
+
+    // AND the turn's frozen snapshot carries the matching client timezone
+    seedTemporalSnapshot("America/New_York");
+
+    // WHEN a turn is assembled
+    const result = await applyRuntimeInjections(baseMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
+    });
+
+    // THEN no timezone-mismatch lines are injected
+    const injected = injectedText(result);
+    expect(injected).not.toContain("configured_user_timezone:");
+    expect(injected).not.toContain("client_device_timezone:");
+  });
+
+  test("sources time_since_last_message from the conversation's frozen turn snapshot", async () => {
+    /**
+     * Verifies the long-absence gap is taken from the conversation's frozen
+     * `currentTurnTemporalSnapshot` rather than threaded through the options
+     * bag, so every post-compaction re-injection reuses the turn-start value.
+     */
+    // GIVEN the turn's frozen snapshot carries a long-absence gap
+    seedTemporalSnapshot(null, "2d ago");
+
+    // WHEN a turn is assembled without the gap in the options bag
+    const result = await applyRuntimeInjections(baseMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
+    });
+
+    // THEN the injector surfaces the gap from the snapshot
+    const injected = injectedText(result);
+    expect(injected).toContain("time_since_last_message: 2d ago");
+  });
+
+  test("omits time_since_last_message when the snapshot carries no gap", async () => {
+    /**
+     * Verifies no `time_since_last_message` line is emitted when the frozen
+     * snapshot's gap is null (the normal back-and-forth case).
+     */
+    // GIVEN the turn's frozen snapshot carries no long-absence gap
+    seedTemporalSnapshot(null, null);
+
+    // WHEN a turn is assembled
+    const result = await applyRuntimeInjections(baseMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
+    });
+
+    // THEN no gap line is injected
+    const injected = injectedText(result);
+    expect(injected).not.toContain("time_since_last_message");
+  });
+});
+
 // ---------------------------------------------------------------------------
 // applyRuntimeInjections blocks.unifiedTurnContext
 // ---------------------------------------------------------------------------
 
 describe("applyRuntimeInjections blocks.unifiedTurnContext", () => {
+  afterEach(clearConversations);
+
   const userTailMessages: Message[] = [
     {
       role: "user",
@@ -1777,18 +2256,50 @@ describe("applyRuntimeInjections blocks.unifiedTurnContext", () => {
     },
   ];
 
-  const sampleBlock =
-    "<turn_context>\ncurrent_time: 2026-04-02T12:00:00Z\ninterface: macos\n</turn_context>";
+  const sampleOptions = {
+    interfaceName: "macos",
+  };
+  // The block reflects the options-bag interface and the `current_time` the
+  // injector computes live (pinned to `FIXED_TURN_TIMESTAMP` for this suite).
+  const sampleBlock = buildUnifiedTurnContextBlock({
+    timestamp: FIXED_TURN_TIMESTAMP,
+    ...sampleOptions,
+  });
+
+  // Seed the live fallback conversation with the per-turn temporal snapshot
+  // (its presence gates the `<turn_context>` block) and the turn interface
+  // context (so the injector sources the interface label to match
+  // `sampleOptions.interfaceName`).
+  function seedTemporalSnapshot(): void {
+    setConversation("runtime-assembly-fallback", {
+      conversationId: "runtime-assembly-fallback",
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: "",
+      workspaceTopLevelDirty: false,
+      surfaceState: new Map(),
+      currentTurnTemporalSnapshot: {
+        clientTimezone: null,
+      },
+      currentTurnInterfaceContext: {
+        userMessageInterface: "macos",
+        assistantMessageInterface: "macos",
+      },
+    } as never);
+  }
 
   test("captures unifiedTurnContext when tail is a user message", async () => {
+    seedTemporalSnapshot();
+
     const result = await applyRuntimeInjections(userTailMessages, {
-      unifiedTurnContext: sampleBlock,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
 
     expect(result.blocks.unifiedTurnContext).toBe(sampleBlock);
   });
 
   test("does not capture when tail is not a user message", async () => {
+    seedTemporalSnapshot();
+
     const assistantTailMessages: Message[] = [
       {
         role: "user",
@@ -1801,14 +2312,16 @@ describe("applyRuntimeInjections blocks.unifiedTurnContext", () => {
     ];
 
     const result = await applyRuntimeInjections(assistantTailMessages, {
-      unifiedTurnContext: sampleBlock,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
 
     expect(result.blocks.unifiedTurnContext).toBeUndefined();
   });
 
   test("does not capture when unifiedTurnContext option is absent", async () => {
-    const result = await applyRuntimeInjections(userTailMessages, {});
+    const result = await applyRuntimeInjections(userTailMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
+    });
 
     expect(result.blocks.unifiedTurnContext).toBeUndefined();
   });
@@ -1844,6 +2357,35 @@ function makeSubagentState(
   };
 }
 
+// `applyRuntimeInjections` self-resolves the `<active_subagents>` block from the
+// global subagent manager keyed by the conversation, so tests seed children
+// directly into the manager's private maps (mirroring the production source)
+// rather than threading a pre-built block through options.
+interface SubagentManagerTestInternals {
+  subagents: Map<string, { state: SubagentState }>;
+  parentToChildren: Map<string, Set<string>>;
+}
+
+function seedSubagentChild(
+  parentConversationId: string,
+  state: SubagentState,
+): void {
+  const internals =
+    getSubagentManager() as unknown as SubagentManagerTestInternals;
+  internals.subagents.set(state.config.id, { state });
+  const ids =
+    internals.parentToChildren.get(parentConversationId) ?? new Set<string>();
+  ids.add(state.config.id);
+  internals.parentToChildren.set(parentConversationId, ids);
+}
+
+function clearSeededSubagents(): void {
+  const internals =
+    getSubagentManager() as unknown as SubagentManagerTestInternals;
+  internals.subagents.clear();
+  internals.parentToChildren.clear();
+}
+
 describe("buildSubagentStatusBlock", () => {
   test("returns null for empty children array", () => {
     expect(buildSubagentStatusBlock([])).toBeNull();
@@ -1921,25 +2463,78 @@ describe("applyRuntimeInjections — subagent status", () => {
     content: [{ type: "text", text: "user message" }],
   };
 
-  test("includes subagent status in full mode", async () => {
+  afterEach(() => {
+    clearSeededSubagents();
+    clearConversations();
+  });
+
+  test("includes self-resolved subagent status in full mode", async () => {
+    // GIVEN the (fallback) parent conversation has one running child subagent
+    seedSubagentChild(
+      "runtime-assembly-fallback",
+      makeSubagentState({ id: "child-1", label: "worker", status: "running" }),
+    );
+
+    // WHEN runtime injections run in full mode
     const { messages: result } = await applyRuntimeInjections([userMsg], {
-      subagentStatusBlock:
-        "<active_subagents>\n- [running] test\n</active_subagents>",
+      conversationId: FALLBACK_CONVERSATION_ID,
       mode: "full",
     });
+
+    // THEN the tail user message carries the `<active_subagents>` block the
+    // injector self-resolved from the subagent manager
     const tail = result[result.length - 1];
     const texts = tail.content
       .filter((b): b is { type: "text"; text: string } => b.type === "text")
       .map((b) => b.text);
     expect(texts.some((t) => t.includes("<active_subagents>"))).toBe(true);
+    expect(texts.some((t) => t.includes('"worker"'))).toBe(true);
   });
 
   test("skips subagent status in minimal mode", async () => {
+    // GIVEN the (fallback) parent conversation has one running child subagent
+    seedSubagentChild(
+      "runtime-assembly-fallback",
+      makeSubagentState({ id: "child-1", label: "worker", status: "running" }),
+    );
+
+    // WHEN runtime injections run in minimal mode
     const { messages: result } = await applyRuntimeInjections([userMsg], {
-      subagentStatusBlock:
-        "<active_subagents>\n- [running] test\n</active_subagents>",
+      conversationId: FALLBACK_CONVERSATION_ID,
       mode: "minimal",
     });
+
+    // THEN the subagent status block is gated out
+    const tail = result[result.length - 1];
+    const texts = tail.content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text);
+    expect(texts.some((t) => t.includes("<active_subagents>"))).toBe(false);
+  });
+
+  test("skips subagent status when the conversation is itself a subagent", async () => {
+    // GIVEN the live conversation is itself a subagent (no nesting)
+    setConversation("runtime-assembly-fallback", {
+      conversationId: "runtime-assembly-fallback",
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: "",
+      workspaceTopLevelDirty: false,
+      surfaceState: new Map(),
+      isSubagent: true,
+    } as never);
+    // AND a child is registered under its id
+    seedSubagentChild(
+      "runtime-assembly-fallback",
+      makeSubagentState({ id: "child-1", label: "worker", status: "running" }),
+    );
+
+    // WHEN runtime injections run in full mode
+    const { messages: result } = await applyRuntimeInjections([userMsg], {
+      conversationId: FALLBACK_CONVERSATION_ID,
+      mode: "full",
+    });
+
+    // THEN no `<active_subagents>` block is emitted
     const tail = result[result.length - 1];
     const texts = tail.content
       .filter((b): b is { type: "text"; text: string } => b.type === "text")
@@ -2012,6 +2607,7 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
 
   function makePkbOptions(overrides: Record<string, unknown> = {}) {
     return {
+      conversationId: FALLBACK_CONVERSATION_ID,
       ...overrides,
     };
   }
@@ -2298,7 +2894,7 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
     // filtered out.
     const { messages: initialResult } = await applyRuntimeInjections(
       preCompactionMessages,
-      {},
+      { conversationId: FALLBACK_CONVERSATION_ID },
     );
     // Unwrap the injected reminder from the last user message.
     const initialTexts = extractTexts(initialResult);
@@ -2332,7 +2928,7 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
     // should be filtered, and beta (no longer "in context") should appear.
     const { messages: rebuiltResult } = await applyRuntimeInjections(
       postCompactionMessages,
-      {},
+      { conversationId: FALLBACK_CONVERSATION_ID },
     );
     const rebuiltTexts = extractTexts(rebuiltResult);
     const rebuiltReminder = rebuiltTexts.find(
@@ -2352,6 +2948,19 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
 // ---------------------------------------------------------------------------
 
 describe("Slack channel chronological rendering — multi-thread", () => {
+  afterEach(() => {
+    clearConversations();
+    // The focus-block tests persist rows under the runtime-assembly fallback
+    // conversation; clear them so later tests resolve against an empty DB.
+    const db = getDb();
+    db.delete(messages)
+      .where(eq(messages.conversationId, "runtime-assembly-fallback"))
+      .run();
+    db.delete(conversations)
+      .where(eq(conversations.id, "runtime-assembly-fallback"))
+      .run();
+  });
+
   // 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.
@@ -2395,6 +3004,7 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       content: JSON.stringify([{ type: "text", text: opts.text }]),
       createdAt: opts.createdAt,
       metadata: Object.keys(outer).length > 0 ? JSON.stringify(outer) : null,
+      clientMessageId: null,
     };
   }
 
@@ -2413,6 +3023,7 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       content: JSON.stringify([{ type: "text", text: opts.text }]),
       createdAt: opts.createdAt,
       metadata: Object.keys(outer).length > 0 ? JSON.stringify(outer) : null,
+      clientMessageId: null,
     };
   }
 
@@ -2428,18 +3039,16 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       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" }],
     };
+    // Persist the rows + live conversation so `applyRuntimeInjections`
+    // self-resolves the chronological transcript from conversation state,
+    // exactly as production does.
+    seedSlackChannelConversationWithRows(slackChannelCaps, rows);
     const { messages } = await applyRuntimeInjections([lastUserMessage], {
-      channelCapabilities: slackChannelCaps,
-      slackChronologicalMessages,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
     return messages;
   }
@@ -2726,24 +3335,15 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       role: "user",
       content: [{ type: "text", text: "vellum question" }],
     };
+    seedChannelCapabilitiesConversation({
+      channel: "vellum",
+      dashboardCapable: true,
+      supportsDynamicUi: true,
+      supportsVoiceInput: true,
+    });
     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" }],
-          },
-        ],
-      },
+      { conversationId: FALLBACK_CONVERSATION_ID },
     );
     expect(result.length).toBe(1);
     const allText = result[0].content
@@ -2751,7 +3351,6 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       .map((b) => b.text)
       .join("\n");
     expect(allText).toContain("vellum question");
-    expect(allText).not.toContain("should not appear");
   });
 
   // ── DMs (chatType === "im") use chronological rendering ────────────────
@@ -2764,36 +3363,38 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       role: "user",
       content: [{ type: "text", text: "DM question" }],
     };
-    const { messages: result } = await applyRuntimeInjections(
-      [lastUserMessage],
+    const rows: MessageRow[] = [
+      userRow({
+        id: "dm-1",
+        createdAt: 1700000000_000,
+        text: "earlier DM line",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+        extraOuterMetadata: { provenanceTrustClass: "guardian" },
+      }),
+      assistantRow({
+        id: "dm-2",
+        createdAt: 1700000005_000,
+        text: "prior reply",
+        slackMeta: buildSlackMeta({ channelTs: T0_REPLY1 }),
+      }),
+    ];
+    seedSlackChannelConversationWithRows(
       {
-        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: "prior reply" }],
-          },
-        ],
+        channel: "slack",
+        dashboardCapable: false,
+        supportsDynamicUi: false,
+        supportsVoiceInput: false,
+        chatType: "im",
       },
+      rows,
     );
-    // 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 { messages: result } = await applyRuntimeInjections(
+      [lastUserMessage],
+      { conversationId: FALLBACK_CONVERSATION_ID },
+    );
+    // The self-resolved 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")
@@ -2804,6 +3405,62 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     expect(allText).not.toContain("DM question");
   });
 
+  // ── Compaction boundary scopes the self-resolved transcript ──────────
+  // The transcript self-resolves from persisted rows scoped by the
+  // conversation's Slack compaction boundary. Rows at or before the
+  // persisted watermark were folded into the summary, so a fresh load
+  // excludes them and surfaces only the post-watermark tail — returning
+  // the compacted view rather than resurrecting folded history.
+  test("self-resolved transcript respects the Slack compaction watermark", async () => {
+    const slackCaps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const rows: MessageRow[] = [
+      userRow({
+        id: "folded",
+        createdAt: 1700000000_000,
+        text: "folded pre-compaction line",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+        extraOuterMetadata: { provenanceTrustClass: "guardian" },
+      }),
+      userRow({
+        id: "fresh",
+        createdAt: 1700000030_000,
+        text: "fresh post-compaction line",
+        slackMeta: buildSlackMeta({ channelTs: T2, displayName: "bob" }),
+        extraOuterMetadata: { provenanceTrustClass: "guardian" },
+      }),
+    ];
+    // A persisted watermark at T0 folds the first row into the summary.
+    seedSlackChannelConversationWithRows(slackCaps, rows, {
+      slackContextCompactionWatermarkTs: T0,
+      contextCompactedMessageCount: 1,
+    });
+    const { messages: result } = await applyRuntimeInjections(
+      [
+        {
+          role: "user",
+          content: [{ type: "text", text: "post-compaction question" }],
+        },
+      ],
+      { conversationId: FALLBACK_CONVERSATION_ID },
+    );
+    const allText = result
+      .flatMap((m) => m.content)
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    // The folded row stays in the summary; only the post-watermark tail is
+    // surfaced, and it replaces the default runMessages.
+    expect(allText).toContain("fresh post-compaction line");
+    expect(allText).not.toContain("folded pre-compaction line");
+    expect(allText).not.toContain("post-compaction 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
@@ -2828,21 +3485,23 @@ describe("Slack channel chronological rendering — multi-thread", () => {
             type: "text",
             text: "<memory __injected>\nrecalled fact about the user\n</memory>",
           },
-          { type: "text", text: "hello there" },
+          { type: "text", text: "original turn text" },
         ],
       },
     ];
+    const rows: MessageRow[] = [
+      userRow({
+        id: "mem-1",
+        createdAt: 1700000000_000,
+        text: "recalled conversation line",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+        extraOuterMetadata: { provenanceTrustClass: "guardian" },
+      }),
+    ];
+    seedSlackChannelConversationWithRows(slackCaps, rows);
     const { messages: result } = await applyRuntimeInjections(
       runMessagesWithMemory,
-      {
-        channelCapabilities: slackCaps,
-        slackChronologicalMessages: [
-          {
-            role: "user",
-            content: [{ type: "text", text: "[19:55 alice]: hello there" }],
-          },
-        ],
-      },
+      { conversationId: FALLBACK_CONVERSATION_ID },
     );
     const tail = result[result.length - 1];
     expect(tail.role).toBe("user");
@@ -2852,15 +3511,15 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       .join("\n");
     expect(allText).toContain("<memory __injected>");
     expect(allText).toContain("recalled fact about the user");
-    expect(allText).toContain("[19:55 alice]: hello there");
+    expect(allText).toContain("recalled conversation line");
     // 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");
+    const transcriptIdx = allText.indexOf("recalled conversation line");
     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);
+    // The pre-replacement inbound turn text must NOT leak through — only the
+    // carried memory prefix + the self-resolved transcript tail remain.
+    expect(allText).not.toContain("original turn text");
   });
 
   test("slack replacement preserves memory-image groups + text block", async () => {
@@ -2896,17 +3555,19 @@ describe("Slack channel chronological rendering — multi-thread", () => {
         ],
       },
     ];
+    const rows: MessageRow[] = [
+      userRow({
+        id: "mem-img-1",
+        createdAt: 1700000000_000,
+        text: "recalled conversation line",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+        extraOuterMetadata: { provenanceTrustClass: "guardian" },
+      }),
+    ];
+    seedSlackChannelConversationWithRows(slackCaps, rows);
     const { messages: result } = await applyRuntimeInjections(
       runMessagesWithMemory,
-      {
-        channelCapabilities: slackCaps,
-        slackChronologicalMessages: [
-          {
-            role: "user",
-            content: [{ type: "text", text: "[19:55 alice]: transcript line" }],
-          },
-        ],
-      },
+      { conversationId: FALLBACK_CONVERSATION_ID },
     );
     const tail = result[result.length - 1];
     expect(tail.role).toBe("user");
@@ -2921,7 +3582,7 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     expect(allText).toContain("<memory_image __injected>");
     expect(allText).toContain("</memory_image>");
     expect(allText).toContain("<memory __injected>");
-    expect(allText).toContain("[19:55 alice]: transcript line");
+    expect(allText).toContain("recalled conversation 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");
@@ -2935,17 +3596,19 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       supportsVoiceInput: false,
       chatType: "im",
     };
+    const rows: MessageRow[] = [
+      userRow({
+        id: "no-prefix-1",
+        createdAt: 1700000000_000,
+        text: "only transcript line",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+        extraOuterMetadata: { provenanceTrustClass: "guardian" },
+      }),
+    ];
+    seedSlackChannelConversationWithRows(slackCaps, rows);
     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" }],
-          },
-        ],
-      },
+      { conversationId: FALLBACK_CONVERSATION_ID },
     );
     const tail = result[result.length - 1];
     const allText = tail.content
@@ -2953,7 +3616,7 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       .map((b) => b.text)
       .join("\n");
     expect(allText).not.toContain("<memory __injected>");
-    expect(allText).toContain("[19:55 alice]: only transcript");
+    expect(allText).toContain("only transcript line");
   });
 
   // ── transport_hints suppression for slack channels ────────────────────
@@ -2965,27 +3628,12 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       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" },
-    );
-
+    seedChannelCapabilitiesConversation(slackChannelCaps, [
+      "thread context: ...",
+    ]);
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "current turn" }] }],
-      {
-        channelCapabilities: slackChannelCaps,
-        slackChronologicalMessages,
-        transportHints: ["thread context: ..."],
-      },
+      { conversationId: FALLBACK_CONVERSATION_ID },
     );
 
     const allText = result
@@ -3009,12 +3657,10 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       chatType: "im",
     };
 
+    seedChannelCapabilitiesConversation(slackDmCaps, ["dm context: ..."]);
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "hi DM" }] }],
-      {
-        channelCapabilities: slackDmCaps,
-        transportHints: ["dm context: ..."],
-      },
+      { conversationId: FALLBACK_CONVERSATION_ID },
     );
 
     const allText = result
@@ -3028,18 +3674,19 @@ describe("Slack channel chronological rendering — multi-thread", () => {
 
   // ── 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" }] }],
+    seedChannelCapabilitiesConversation(
       {
-        channelCapabilities: {
-          channel: "telegram",
-          dashboardCapable: false,
-          supportsDynamicUi: false,
-          supportsVoiceInput: false,
-          chatType: "private",
-        },
-        transportHints: ["please answer concisely"],
+        channel: "telegram",
+        dashboardCapable: false,
+        supportsDynamicUi: false,
+        supportsVoiceInput: false,
+        chatType: "private",
       },
+      ["please answer concisely"],
+    );
+    const { messages: result } = await applyRuntimeInjections(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      { conversationId: FALLBACK_CONVERSATION_ID },
     );
     const allText = result
       .flatMap((m) => m.content)
@@ -3336,10 +3983,72 @@ describe("Slack channel chronological rendering — multi-thread", () => {
   // 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<{
+  interface SeededCompactionState {
+    slackContextCompactionWatermarkTs?: string | null;
+    contextCompactedMessageCount?: number;
+  }
+
+  // Persist the Slack rows under the runtime-assembly fallback conversation and
+  // mirror the channel capabilities + trust class + compaction state onto its
+  // live registry entry, so `applyRuntimeInjections` self-resolves the
+  // `<active_thread>` focus block from the conversation's stored rows — the same
+  // way it does in production, where the injector reads the live conversation
+  // rather than receiving a pre-built block.
+  function seedSlackChannelConversationWithRows(
+    caps: ChannelCapabilities,
+    rows: MessageRow[],
+    compaction: SeededCompactionState = {},
+  ): void {
+    const db = getDb();
+    const now = Date.now();
+    db.delete(messages)
+      .where(eq(messages.conversationId, "runtime-assembly-fallback"))
+      .run();
+    db.insert(conversations)
+      .values({
+        id: "runtime-assembly-fallback",
+        createdAt: now,
+        updatedAt: now,
+      })
+      .run();
+    if (rows.length > 0) {
+      db.insert(messages)
+        .values(
+          rows.map((r) => ({
+            id: r.id,
+            conversationId: "runtime-assembly-fallback",
+            role: r.role,
+            content: r.content,
+            createdAt: r.createdAt,
+            metadata: r.metadata,
+          })),
+        )
+        .run();
+    }
+    setConversation("runtime-assembly-fallback", {
+      conversationId: "runtime-assembly-fallback",
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: "",
+      workspaceTopLevelDirty: false,
+      surfaceState: new Map(),
+      channelCapabilities: caps,
+      trustContext: { trustClass: "guardian" },
+      slackContextCompactionWatermarkTs:
+        compaction.slackContextCompactionWatermarkTs ?? null,
+      contextCompactedMessageCount:
+        compaction.contextCompactedMessageCount ?? 0,
+    } as never);
+  }
+
+  // Re-run a Slack-channel turn through the public assembly path. The
+  // active-thread focus block self-resolves inside `applyRuntimeInjections`
+  // from the seeded live conversation; `focusBlock` resolves it the same way
+  // (default DB loader, guardian trust + the seeded compaction state) for the
+  // expected-content assertions.
+  async function runSlackChannelAssemblyWithFocus(
+    rows: MessageRow[],
+    compaction: SeededCompactionState = {},
+  ): Promise<{
     messages: Message[];
     focusBlock: string | null;
   }> {
@@ -3350,24 +4059,23 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       supportsVoiceInput: false,
       chatType: "channel",
     };
-    const slackChronologicalMessages = loadSlackChronologicalMessages(
-      "conv-1",
-      slackChannelCaps,
-      { loader: () => rows, trustClass: "guardian" },
-    );
+    seedSlackChannelConversationWithRows(slackChannelCaps, rows, compaction);
     const focusBlock = loadSlackActiveThreadFocusBlock(
-      "conv-1",
+      "runtime-assembly-fallback",
       slackChannelCaps,
-      { loader: () => rows, trustClass: "guardian" },
+      {
+        trustClass: "guardian",
+        contextCompactedMessageCount: compaction.contextCompactedMessageCount,
+        slackContextCompactionWatermarkTs:
+          compaction.slackContextCompactionWatermarkTs,
+      },
     );
     const lastUserMessage: Message = {
       role: "user",
       content: [{ type: "text", text: "current turn" }],
     };
     const { messages } = await applyRuntimeInjections([lastUserMessage], {
-      channelCapabilities: slackChannelCaps,
-      slackChronologicalMessages,
-      slackActiveThreadFocusBlock: focusBlock,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
     return { messages, focusBlock };
   }
@@ -3584,14 +4292,143 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     }
   });
 
+  test("focus block self-resolves the live conversation's compaction watermark", async () => {
+    /**
+     * The watermark + compacted count live on the live `Conversation`, not in
+     * the injection options, so `applyRuntimeInjections` must read them off the
+     * live conversation to bound the self-resolved `<active_thread>` block.
+     */
+    // GIVEN a thread whose earliest rows were folded into a prior compaction
+    const rows: MessageRow[] = [
+      userRow({
+        id: "thread-root",
+        createdAt: 1700000000_000,
+        text: "compacted root",
+        slackMeta: buildSlackMeta({
+          channelTs: T0,
+          threadTs: T0,
+          displayName: "alice",
+        }),
+      }),
+      userRow({
+        id: "reply-before",
+        createdAt: 1700000005_000,
+        text: "compacted reply",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY1,
+          threadTs: T0,
+          displayName: "bob",
+        }),
+      }),
+      userRow({
+        id: "reply-after",
+        createdAt: 1700000020_000,
+        text: "live reply",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY2,
+          threadTs: T0,
+          displayName: "carol",
+        }),
+      }),
+    ];
+
+    // WHEN the live conversation carries a Slack compaction watermark at T1
+    const { messages, focusBlock } = await runSlackChannelAssemblyWithFocus(
+      rows,
+      {
+        slackContextCompactionWatermarkTs: T1,
+        contextCompactedMessageCount: 2,
+      },
+    );
+
+    // THEN the self-resolved focus block keeps only the post-watermark reply
+    expect(focusBlock).not.toBeNull();
+    expect(focusBlock!).toContain("live reply");
+    expect(focusBlock!).not.toContain("compacted root");
+    expect(focusBlock!).not.toContain("compacted reply");
+    // AND `applyRuntimeInjections` injected exactly that self-resolved block,
+    // proving it read the watermark + count off the live conversation.
+    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).toContain("<active_thread>");
+    expect(allText).toContain(focusBlock!);
+  });
+
+  test("focus block bounds by the compacted count when there is no watermark", async () => {
+    /**
+     * Conversations compacted before the Slack watermark migration have no
+     * watermark, so the raw `contextCompactedMessageCount` is the sole boundary
+     * the self-resolved focus block uses to drop already-compacted rows.
+     */
+    // GIVEN a thread whose first two rows were folded into a prior compaction
+    const rows: MessageRow[] = [
+      userRow({
+        id: "thread-root",
+        createdAt: 1700000000_000,
+        text: "compacted root",
+        slackMeta: buildSlackMeta({
+          channelTs: T0,
+          threadTs: T0,
+          displayName: "alice",
+        }),
+      }),
+      userRow({
+        id: "reply-before",
+        createdAt: 1700000005_000,
+        text: "compacted reply",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY1,
+          threadTs: T0,
+          displayName: "bob",
+        }),
+      }),
+      userRow({
+        id: "reply-after",
+        createdAt: 1700000020_000,
+        text: "live reply",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY2,
+          threadTs: T0,
+          displayName: "carol",
+        }),
+      }),
+    ];
+
+    // WHEN the live conversation has a compacted count of 2 and no watermark
+    const { messages, focusBlock } = await runSlackChannelAssemblyWithFocus(
+      rows,
+      {
+        slackContextCompactionWatermarkTs: null,
+        contextCompactedMessageCount: 2,
+      },
+    );
+
+    // THEN the self-resolved focus block drops the two compacted rows and keeps
+    // only the live reply
+    expect(focusBlock).not.toBeNull();
+    expect(focusBlock!).toContain("live reply");
+    expect(focusBlock!).not.toContain("compacted root");
+    expect(focusBlock!).not.toContain("compacted reply");
+    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).toContain("<active_thread>");
+    expect(allText).toContain(focusBlock!);
+  });
+
   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.
+    // running the strip pipeline + applying injections again to confirm the
+    // rebuild re-derives the block and no duplication occurs.
     const rows: MessageRow[] = [
       userRow({
         id: "m1",
@@ -3624,19 +4461,11 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       .join("\n");
     expect(strippedTexts).not.toContain("<active_thread>");
 
-    // Re-run injection with a fresh focus block — only ONE
+    // Re-run injection on the stripped messages — the conversation is still
+    // seeded, so the rebuild re-derives the 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,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
     const reInjectedTexts = reInjected
       .flatMap((m) => m.content)
@@ -3648,24 +4477,22 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     expect(blockCount).toBe(1);
     expect(
       reInjectedTexts.find((t) => t.startsWith("<active_thread>")),
-    ).toContain("newly built");
+    ).toContain("Reply in thread A");
   });
 
-  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.
+  test("non-slack conversations never get an active-thread focus block", async () => {
+    // The focus block is gated on a Slack *channel* conversation
+    // (`isSlackChannelConversation`). A non-Slack conversation must never
+    // self-resolve an `<active_thread>` block.
+    seedChannelCapabilitiesConversation({
+      channel: "vellum",
+      dashboardCapable: true,
+      supportsDynamicUi: true,
+      supportsVoiceInput: true,
+    });
     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>",
-      },
+      { conversationId: FALLBACK_CONVERSATION_ID },
     );
     const allText = result
       .flatMap((m) => m.content)
@@ -3676,22 +4503,20 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     expect(allText).toContain("vellum question");
   });
 
-  test("slack DMs ignore slackActiveThreadFocusBlock", async () => {
+  test("slack DMs never get an active-thread focus block", 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.
+    seedChannelCapabilitiesConversation({
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "im",
+    });
     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>",
-      },
+      { conversationId: FALLBACK_CONVERSATION_ID },
     );
     const allText = result
       .flatMap((m) => m.content)
@@ -5047,6 +5872,7 @@ describe("applyRuntimeInjections blocks.pkbSystemReminder", () => {
     pkbSearchResults = [];
     pkbSearchThrows = null;
     const { blocks } = await applyRuntimeInjections(baseMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
       mode: "full",
     });
 
@@ -5057,6 +5883,7 @@ describe("applyRuntimeInjections blocks.pkbSystemReminder", () => {
   test("not captured in minimal mode", async () => {
     seedPkbContent();
     const { blocks } = await applyRuntimeInjections(baseMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
       mode: "minimal",
     });
 
@@ -5065,6 +5892,7 @@ describe("applyRuntimeInjections blocks.pkbSystemReminder", () => {
 
   test("not captured when PKB inactive", async () => {
     const { blocks } = await applyRuntimeInjections(baseMessages, {
+      conversationId: FALLBACK_CONVERSATION_ID,
       mode: "full",
     });