@vellumai/assistant 0.6.4 → 0.6.6

package/src/daemon/conversation-runtime-assembly.ts

@@ -10,14 +10,43 @@ import { join, resolve } from "node:path";
 
 import { type ChannelId, parseInterfaceId } from "../channels/types.js";
 import { getAppDirPath, listAppFiles } from "../memory/app-store.js";
+import {
+  getMessages as defaultGetMessages,
+  type MessageRow,
+} from "../memory/conversation-crud.js";
+import {
+  countMemoryPrefixBlocks,
+  extractMemoryPrefixBlocks,
+} from "../memory/graph/conversation-graph-memory.js";
+import type { QdrantSparseVector } from "../memory/qdrant-client.js";
+import { readSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
+import {
+  extractTagLineTexts,
+  isReactionTagLine,
+  type RenderableSlackMessage,
+  renderSlackTranscript,
+} from "../messaging/providers/slack/render-transcript.js";
 import { isPermissionControlsV2Enabled } from "../permissions/v2-consent-policy.js";
-import type { Message } from "../providers/types.js";
-import type { ActorTrustContext } from "../runtime/actor-trust-resolver.js";
+import { getInjectors } from "../plugins/registry.js";
+import type {
+  InjectionBlock,
+  InjectionPlacement,
+  TurnContext,
+  TurnInjectionInputs,
+} from "../plugins/types.js";
+import type { ContentBlock, Message } from "../providers/types.js";
+import {
+  type ActorTrustContext,
+  isUntrustedTrustClass,
+  type TrustClass,
+} from "../runtime/actor-trust-resolver.js";
 import { channelStatusToMemberStatus } from "../runtime/routes/inbound-stages/acl-enforcement.js";
 import type { SubagentState } from "../subagent/types.js";
 import { TERMINAL_STATUSES } from "../subagent/types.js";
 import { getWorkspaceDir, getWorkspacePromptPath } from "../util/platform.js";
 import { stripCommentLines } from "../util/strip-comment-lines.js";
+import { filterMessagesForUntrustedActor } from "./conversation-lifecycle.js";
+import { type PkbContextConversation } from "./pkb-context-tracker.js";
 
 /**
  * Describes the capabilities of the channel through which the user is
@@ -493,16 +522,11 @@ export function buildSubagentStatusBlock(
   return lines.join("\n");
 }
 
-/** Append a subagent status block to the last user message. */
-export function injectSubagentStatus(
-  message: Message,
-  statusBlock: string,
-): Message {
-  return {
-    ...message,
-    content: [...message.content, { type: "text" as const, text: statusBlock }],
-  };
-}
+// The `<active_subagents>` block is emitted by the `subagent-status` default
+// injector (`plugins/defaults/injectors.ts`) as an `append-user-tail`
+// placement. Use {@link applyRuntimeInjections} with
+// `options.subagentStatusBlock` set, or drive the injector chain directly
+// via `collectInjectorBlocks`.
 
 /**
  * Append voice call-control protocol instructions to the last user
@@ -546,47 +570,17 @@ export function readNowScratchpad(): string | null {
 }
 
 /**
- * Insert NOW.md scratchpad content into the user message, after any
- * injected context blocks (e.g. memory_context) but before the user's
- * original content.  This keeps the user's actual message as the last
- * thing the model reads.
+ * The `<NOW.md>` block is emitted by the `now-md` default injector
+ * (`plugins/defaults/injectors.ts`) as an `after-memory-prefix` placement.
+ * Use {@link applyRuntimeInjections} with `options.nowScratchpad` set.
  */
-export function injectNowScratchpad(
-  message: Message,
-  content: string,
-): Message {
-  const scratchpadBlock = {
-    type: "text" as const,
-    text: `<NOW.md Always keep this up to date>\n${content}\n</NOW.md>`,
-  };
-
-  // Find insertion point: skip any leading injected-context text blocks
-  // (e.g. memory_context) so the scratchpad lands between injected context
-  // and the user's original content.
-  let insertIdx = 0;
-  for (let i = 0; i < message.content.length; i++) {
-    const block = message.content[i];
-    if (block.type === "text" && block.text.startsWith("<memory_context")) {
-      insertIdx = i + 1;
-    } else {
-      break;
-    }
-  }
-
-  return {
-    ...message,
-    content: [
-      ...message.content.slice(0, insertIdx),
-      scratchpadBlock,
-      ...message.content.slice(insertIdx),
-    ],
-  };
-}
 
 /** Strip `<NOW.md>` blocks injected by `injectNowScratchpad`. */
 export function stripNowScratchpad(messages: Message[]): Message[] {
   return stripUserTextBlocksByPrefix(messages, [
-    "<NOW.md Always keep this up to date>",
+    // Shared prefix catches both the current tag and any pre-line-limit
+    // variant that may linger in in-flight histories during a rolling deploy.
+    "<NOW.md Always keep this up to date",
     "<now_scratchpad>", // backward-compat: strip legacy blocks from pre-rename history
   ]);
 }
@@ -607,14 +601,6 @@ const AUTOINJECT_FILENAME = "_autoinject.md";
 /** Max buffer.md lines injected into prompts — keeps context bounded even when filing is off. */
 const MAX_BUFFER_LINES = 50;
 
-const PKB_SYSTEM_REMINDER =
-  "<system_reminder>" +
-  "\n**CRITICAL:** you MUST read any PKB files that might be relevant to this conversation — " +
-  "INDEX.md is your table of contents. Don't wait to be asked. " +
-  "Use `remember` OFTEN for EVERY new fact you learn IMMEDIATELY, don't wait for the next turn. " +
-  "Corrections to things you had wrong are the highest-priority remembers — never skip them." +
-  "\n</system_reminder>";
-
 /**
  * Read `_autoinject.md` from the PKB directory and return the list of
  * filenames to inject.
@@ -639,6 +625,21 @@ export function readAutoinjectList(pkbDir: string): string[] | null {
   }
 }
 
+/**
+ * Resolve the effective list of auto-inject filenames for a PKB directory.
+ *
+ * This is the single source of truth used both by `readPkbContext` (which
+ * actually injects the files) and by the PKB reminder-hint tracker in
+ * `conversation-agent-loop.ts` (which needs to know what's already in
+ * context so it doesn't redundantly recommend those files).
+ *
+ * Returns `PKB_DEFAULT_FILES` when `_autoinject.md` is missing/unreadable,
+ * or the parsed list (possibly empty) when it is present.
+ */
+export function getPkbAutoInjectList(pkbRoot: string): string[] {
+  return readAutoinjectList(pkbRoot) ?? PKB_DEFAULT_FILES;
+}
+
 /**
  * Read the always-loaded PKB files and append a nudge encouraging the
  * assistant to proactively read topic files and use `remember` aggressively.
@@ -653,7 +654,7 @@ export function readPkbContext(): string | null {
   const pkbDir = join(getWorkspaceDir(), "pkb");
   if (!existsSync(pkbDir)) return null;
 
-  const filesToInject = readAutoinjectList(pkbDir) ?? PKB_DEFAULT_FILES;
+  const filesToInject = getPkbAutoInjectList(pkbDir);
 
   const parts: string[] = [];
   for (const file of filesToInject) {
@@ -680,50 +681,17 @@ export function readPkbContext(): string | null {
   return parts.length > 0 ? parts.join("\n\n") : null;
 }
 
-/**
- * Insert PKB context into the user message, after any injected memory
- * blocks but before NOW.md and the user's original content.
- */
-export function injectPkbContext(message: Message, content: string): Message {
-  // Escape closing tags that could break out of the XML wrapper
-  const escaped = content.replace(/<\/pkb\s*>/gi, "&lt;/pkb&gt;");
-  const pkbBlock = {
-    type: "text" as const,
-    text: `<pkb>\n${escaped}\n</pkb>`,
-  };
+// The `<knowledge_base>` block is emitted by the `pkb-context` default
+// injector (`plugins/defaults/injectors.ts`) as an `after-memory-prefix`
+// placement, splicing immediately after any leading memory-prefix blocks.
+// Use {@link applyRuntimeInjections} with `options.pkbContext` set.
 
-  // Find insertion point: skip any leading memory/image blocks
-  let insertIdx = 0;
-  for (let i = 0; i < message.content.length; i++) {
-    const block = message.content[i];
-    if (
-      block.type === "text" &&
-      (block.text.startsWith("<memory") ||
-        block.text.startsWith("</memory_image>") ||
-        block.text.startsWith("<memory_context"))
-    ) {
-      insertIdx = i + 1;
-    } else if (block.type === "image") {
-      // Memory images precede the memory text block
-      insertIdx = i + 1;
-    } else {
-      break;
-    }
-  }
-
-  return {
-    ...message,
-    content: [
-      ...message.content.slice(0, insertIdx),
-      pkbBlock,
-      ...message.content.slice(insertIdx),
-    ],
-  };
-}
-
-/** Strip `<pkb>` blocks injected by `injectPkbContext`. */
+/** Strip `<knowledge_base>` blocks injected by `injectPkbContext`. */
 export function stripPkbContext(messages: Message[]): Message[] {
-  return stripUserTextBlocksByPrefix(messages, ["<pkb>"]);
+  return stripUserTextBlocksByPrefix(messages, [
+    "<knowledge_base>",
+    "<pkb>", // backward-compat: strip legacy blocks from pre-rename history
+  ]);
 }
 
 /**
@@ -909,6 +877,10 @@ export function buildUnifiedTurnContextBlock(
       .replace(/[\r\n\u0085\u2028\u2029]+/g, " ")
       // Replace remaining ASCII C0/C1 control characters and DEL.
       .replace(/[\x00-\x1F\x7F-\x9F]/g, " ")
+      // Escape XML special characters to prevent turn_context breakout.
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
       .trim();
     return singleLine.length > 0 ? singleLine : "unknown";
   };
@@ -1088,18 +1060,10 @@ export function stripChannelCapabilityContext(messages: Message[]): Message[] {
   return stripUserTextBlocksByPrefix(messages, ["<channel_capabilities>"]);
 }
 
-/**
- * Prepend workspace top-level directory context to a user message.
- */
-export function injectWorkspaceTopLevelContext(
-  message: Message,
-  contextText: string,
-): Message {
-  return {
-    ...message,
-    content: [{ type: "text", text: contextText }, ...message.content],
-  };
-}
+// The workspace top-level context block is emitted by the
+// `workspace-context` default injector (`plugins/defaults/injectors.ts`)
+// as a `prepend-user-tail` placement. Use {@link applyRuntimeInjections}
+// with `options.workspaceTopLevelContext` set.
 
 /**
  * Strip `<active_workspace>` (and legacy `<active_dynamic_page>`) blocks
@@ -1138,6 +1102,445 @@ export function stripTransportHints(messages: Message[]): Message[] {
   return stripUserTextBlocksByPrefix(messages, ["<transport_hints>"]);
 }
 
+// ---------------------------------------------------------------------------
+// Slack chronological transcript assembly
+// ---------------------------------------------------------------------------
+
+/**
+ * True when the channel capabilities describe a Slack non-DM conversation
+ * (group/channel/mpim). Used to gate thread-only behavior such as the
+ * `<active_thread>` focus block. DMs are excluded because they have no
+ * threads.
+ *
+ * The gateway normalizer sets `chatType: "channel"` for every non-DM Slack
+ * conversation (public, private, and mpim alike — see
+ * `gateway/src/slack/normalize.ts`) and omits the field entirely for DMs.
+ * We therefore accept only `chatType === "channel"` — when the gateway
+ * omits `chatType` (as it does for DMs), the check correctly returns
+ * `false`.
+ *
+ * The chronological-transcript override applies to ALL Slack
+ * conversations (channels and DMs) — gate that on
+ * `channelCapabilities.channel === "slack"` rather than this helper.
+ */
+export function isSlackChannelConversation(
+  channelCapabilities?: ChannelCapabilities | null,
+): boolean {
+  return (
+    channelCapabilities?.channel === "slack" &&
+    channelCapabilities.chatType === "channel"
+  );
+}
+
+/**
+ * Minimal structural shape of a persisted message row used by the Slack
+ * chronological-transcript assembly path. Decouples the assembly logic from
+ * the DB-row type so it can be unit-tested with plain literals.
+ */
+export interface SlackTranscriptInputRow {
+  role: "user" | "assistant";
+  /** Raw persisted content column. JSON-encoded `ContentBlock[]` in production. */
+  content: string;
+  /** Epoch ms when the row was created. */
+  createdAt: number;
+  /** Raw `metadata` column value (JSON string with optional `slackMeta` sub-key). */
+  metadata: string | null;
+}
+
+/**
+ * Extract the user-facing plain text from an already-parsed `ContentBlock[]`.
+ * Only `text` blocks contribute to the rendered transcript line. Tool-use /
+ * tool-result / thinking blocks are intentionally elided — they would clutter
+ * the Slack-style transcript and the model can already recall them from the
+ * surrounding turn structure.
+ *
+ * Rows with no text blocks (e.g. images, file uploads, pure tool turns) would
+ * otherwise render as an empty transcript line like `[14:25 @alice]: `;
+ * surface the attachment/tool context instead so the model can tell something
+ * was actually said on that turn.
+ */
+function extractPlainTextFromBlocks(blocks: ContentBlock[]): string {
+  const parts: string[] = [];
+  const placeholderLabels: string[] = [];
+  for (const block of blocks) {
+    if (!block || typeof block !== "object") continue;
+    if (block.type === "text") {
+      parts.push(block.text);
+      continue;
+    }
+    const label = placeholderForBlockType(block.type);
+    if (label && !placeholderLabels.includes(label)) {
+      placeholderLabels.push(label);
+    }
+  }
+  if (parts.length > 0) {
+    return parts.join("\n");
+  }
+  return placeholderLabels.join(" ");
+}
+
+function placeholderForBlockType(type: ContentBlock["type"]): string | null {
+  switch (type) {
+    case "image":
+      return "[image]";
+    case "file":
+      return "[file]";
+    case "tool_use":
+    case "server_tool_use":
+      return "[tool call]";
+    case "tool_result":
+    case "web_search_tool_result":
+      return "[tool result]";
+    case "thinking":
+    case "redacted_thinking":
+    case "text":
+      return null;
+  }
+}
+
+/**
+ * Convert a persisted row into the {@link RenderableSlackMessage} shape
+ * consumed by `renderSlackTranscript`.
+ *
+ * Legacy pre-upgrade rows (no `slackMeta` sub-key, malformed metadata, etc.)
+ * yield `metadata: null`; the renderer then takes its flat-render fallback
+ * path and the row stays in chronological order via `createdAt`.
+ *
+ * Sender labels are emitted only when they add information beyond the role
+ * slot:
+ * - Reaction rows: always labeled — `@assistant` for the assistant, the real
+ *   `slackMeta.displayName` for a known user, or `@user` as a last-resort
+ *   subject so the rendered `[time X reacted ...]` line still parses.
+ * - Assistant message rows: `null` — the role slot already says "assistant".
+ * - User message rows: real `slackMeta.displayName` when available (to
+ *   disambiguate speakers in multi-party channels); `null` otherwise so the
+ *   renderer drops the redundant `@user` placeholder.
+ */
+function rowToRenderable(row: SlackTranscriptInputRow): RenderableSlackMessage {
+  let slackMeta: ReturnType<typeof readSlackMetadata> = null;
+  if (row.metadata) {
+    try {
+      const outer = JSON.parse(row.metadata) as { slackMeta?: unknown };
+      if (typeof outer.slackMeta === "string") {
+        slackMeta = readSlackMetadata(outer.slackMeta);
+      }
+    } catch {
+      // Malformed metadata — fall through to legacy/null treatment.
+    }
+  }
+
+  const isReaction = slackMeta?.eventKind === "reaction";
+  let senderLabel: string | null;
+  if (isReaction) {
+    senderLabel =
+      row.role === "assistant"
+        ? "@assistant"
+        : (slackMeta?.displayName ?? "@user");
+  } else if (row.role === "assistant") {
+    senderLabel = null;
+  } else {
+    senderLabel = slackMeta?.displayName ?? null;
+  }
+
+  // Parse `row.content` once and derive both the structured `contentBlocks`
+  // view (for downstream tool-block preservation) and the flattened
+  // `plainText` view (used for tag-line rendering) from the same parsed
+  // result. Large Slack histories with many tool payloads would otherwise
+  // pay a double JSON-parse cost per row.
+  let contentBlocks: ContentBlock[] = [];
+  let plainText: string;
+  try {
+    const parsed = JSON.parse(row.content);
+    if (Array.isArray(parsed)) {
+      contentBlocks = parsed as ContentBlock[];
+      plainText = extractPlainTextFromBlocks(contentBlocks);
+    } else if (typeof parsed === "string") {
+      plainText = parsed;
+    } else {
+      plainText = row.content;
+    }
+  } catch {
+    // Plain string row (legacy) — no structured blocks to preserve.
+    plainText = row.content;
+  }
+
+  // Attachment-only rows (images, files) carry no text block, so the
+  // transcript renderer would normally emit them *without* a tag line —
+  // the model sees the image but loses sender/timestamp attribution.
+  // Synthesize a leading text block carrying the placeholder so the
+  // renderer emits `[14:25 @alice]: [image]` and then the image itself.
+  // Pure tool-only rows (tool_use / tool_result) are intentionally
+  // excluded — those are synthetic turn continuations that should stay
+  // tag-line-free, matching the documented behaviour in
+  // `buildMessageContentBlocks`.
+  const hasTextBlock = contentBlocks.some((b) => b?.type === "text");
+  const hasAttachmentBlock = contentBlocks.some(
+    (b) => b?.type === "image" || b?.type === "file",
+  );
+  if (!hasTextBlock && hasAttachmentBlock && plainText !== "") {
+    contentBlocks = [{ type: "text", text: plainText }, ...contentBlocks];
+  }
+
+  return {
+    role: row.role,
+    content: plainText,
+    metadata: slackMeta,
+    senderLabel,
+    createdAt: row.createdAt,
+    contentBlocks,
+  };
+}
+
+/**
+ * Build a chronological Slack transcript for Slack conversations (both DMs
+ * and group/channel/mpim) and project it onto the LLM-facing `Message[]`
+ * shape.
+ *
+ * Returns `null` when the channel is not Slack (caller should fall through
+ * to the default message history). Legacy pre-upgrade rows without
+ * `slackMeta` are tolerated: the renderer's flat fallback orders them by
+ * `createdAt` alongside post-upgrade rows.
+ *
+ * For ALL Slack conversations (channels and DMs), `<transport_hints>`
+ * injection is suppressed by `applyRuntimeInjections` so the model sees
+ * one consistent persisted view instead of a duplicated gateway hint.
+ */
+export function assembleSlackChronologicalMessages(
+  rows: SlackTranscriptInputRow[],
+  capabilities: ChannelCapabilities,
+): Message[] | null {
+  if (capabilities.channel !== "slack") {
+    return null;
+  }
+  const renderable = rows.map(rowToRenderable);
+  return renderSlackTranscript(renderable);
+}
+
+/**
+ * Load DB rows for a Slack conversation and project them onto the
+ * chronological transcript shape.
+ *
+ * Convenience wrapper over `getMessages` + `assembleSlackChronologicalMessages`.
+ * The loader is exposed as a parameter so tests can substitute a stub. In
+ * production it defaults to `getMessages` from `conversation-crud.ts`.
+ *
+ * When `trustClass` identifies an untrusted actor (guardian-scoped rows
+ * must not leak into the model context), rows are passed through
+ * `filterMessagesForUntrustedActor` before assembly — mirroring the
+ * filtering applied in `loadFromDb` so the chronological transcript
+ * respects the same per-actor scoping as the default history path.
+ *
+ * Returns `null` when the channel is not Slack — callers should fall
+ * through to the default in-memory message history.
+ */
+export function loadSlackChronologicalMessages(
+  conversationId: string,
+  capabilities: ChannelCapabilities,
+  options: {
+    loader?: (id: string) => MessageRow[];
+    trustClass?: TrustClass;
+  } = {},
+): Message[] | null {
+  if (capabilities.channel !== "slack") {
+    return null;
+  }
+  const loader = options.loader ?? defaultGetMessages;
+  const allRows = loader(conversationId);
+  const scopedRows = isUntrustedTrustClass(options.trustClass)
+    ? filterMessagesForUntrustedActor(allRows)
+    : allRows;
+  // Coerce MessageRow.role (string) to the structural row's stricter union.
+  const rows: SlackTranscriptInputRow[] = scopedRows.map((row) => ({
+    role: row.role === "assistant" ? "assistant" : "user",
+    content: row.content,
+    createdAt: row.createdAt,
+    metadata: row.metadata,
+  }));
+  return assembleSlackChronologicalMessages(rows, capabilities);
+}
+
+// ---------------------------------------------------------------------------
+// Active-thread focus block (non-persisted; appended to current user turn)
+// ---------------------------------------------------------------------------
+
+/**
+ * Detect the "active" Slack thread ts for the current turn.
+ *
+ * The active thread is the thread the current inbound user message belongs
+ * to: scan from newest to oldest and return the `slackMeta.threadTs` of the
+ * most recent user row that carries one. Returns `null` when no recent user
+ * row sits inside a thread (e.g. the inbound was a top-level channel post,
+ * or the conversation has no Slack-tagged user rows yet).
+ *
+ * Pure: takes pre-mapped renderable rows and returns the ts string only.
+ */
+function detectActiveThreadTs(rows: RenderableSlackMessage[]): string | null {
+  for (let i = rows.length - 1; i >= 0; i--) {
+    const row = rows[i];
+    if (row.role !== "user") continue;
+    const meta = row.metadata;
+    if (!meta) continue;
+    if (meta.eventKind !== "message") continue;
+    if (typeof meta.threadTs === "string" && meta.threadTs.length > 0) {
+      return meta.threadTs;
+    }
+    // First non-thread user row wins: the inbound is top-level, no active
+    // thread to focus on.
+    return null;
+  }
+  return null;
+}
+
+/**
+ * Build a focus block listing every message belonging to the active thread:
+ * the parent (whose `channelTs` equals `activeThreadTs`) plus every reply
+ * (whose `threadTs` equals `activeThreadTs`). Reactions targeting any of
+ * those messages are also pulled in via their `targetChannelTs`. Edits and
+ * deletions surface through the existing renderer markers.
+ *
+ * Returns `null` when no rows match (e.g. parent backfill hasn't run yet
+ * AND the thread has no replies in storage either) so the caller can skip
+ * the empty block. Otherwise returns the rendered XML block ready to append
+ * to the user's tail message.
+ *
+ * Pure: takes pre-mapped renderable rows + a thread ts, returns text only.
+ */
+function buildActiveThreadBlockFromRenderable(
+  rows: RenderableSlackMessage[],
+  activeThreadTs: string,
+): string | null {
+  const members: RenderableSlackMessage[] = [];
+  for (const row of rows) {
+    const meta = row.metadata;
+    if (!meta) continue;
+    if (meta.eventKind === "message") {
+      if (
+        meta.channelTs === activeThreadTs ||
+        meta.threadTs === activeThreadTs
+      ) {
+        members.push(row);
+      }
+      continue;
+    }
+    if (
+      meta.eventKind === "reaction" &&
+      meta.reaction &&
+      meta.reaction.targetChannelTs === activeThreadTs
+    ) {
+      members.push(row);
+      continue;
+    }
+    // Reactions targeting a reply within the thread also belong in the
+    // focus block — collect them by checking the reaction target against
+    // any thread reply's channelTs we've already accepted. We do this in a
+    // second pass below to avoid an O(n^2) inner scan here.
+  }
+
+  // Second pass: pull in reactions whose target is one of the already-
+  // collected reply messages. Using a Set keeps this O(n).
+  const memberChannelTs = new Set(
+    members
+      .map((m) => m.metadata?.channelTs)
+      .filter((v): v is string => typeof v === "string"),
+  );
+  for (const row of rows) {
+    const meta = row.metadata;
+    if (!meta || meta.eventKind !== "reaction" || !meta.reaction) continue;
+    if (meta.reaction.targetChannelTs === activeThreadTs) continue; // already added
+    if (memberChannelTs.has(meta.reaction.targetChannelTs)) {
+      members.push(row);
+    }
+  }
+
+  if (members.length === 0) return null;
+
+  // The active-thread block is flattened to plain text below, which discards
+  // `Message.role`. Assistant rows are relabeled in the post-render step:
+  // `renderSlackTranscript` emits assistant content with no tag-line wrapper
+  // (to prevent the model mimicking `[MM/DD/YY HH:MM]:` prefixes in outbound
+  // replies), so we prepend an explicit `@assistant:` label to the flattened
+  // line. Unnamed user rows (no real Slack displayName) get a `@user`
+  // senderLabel here so their tag line carries attribution through the
+  // renderer. Labeled user rows and assistant rows pass through unchanged.
+  const labeledMembers = members.map((m) => {
+    if (m.role === "assistant") return m;
+    if (m.senderLabel !== null) return m;
+    return { ...m, senderLabel: "@user" };
+  });
+
+  const rendered = renderSlackTranscript(labeledMembers);
+  if (rendered.length === 0) return null;
+  // Reaction / overflow-trailer lines already embed `@assistant` inline, so
+  // `isReactionTagLine` is used to skip those and avoid double-attribution
+  // (`@assistant: [... @assistant reacted ...]`). Regular content and the
+  // `[deleted]` sentinel get the prefix so attribution survives flattening.
+  const lines = rendered
+    .map((msg) => {
+      const text = extractTagLineTexts([msg])[0] ?? "";
+      return msg.role === "assistant" && !isReactionTagLine(text)
+        ? `@assistant: ${text}`
+        : text;
+    })
+    .join("\n");
+  return `<active_thread>\n${lines}\n</active_thread>`;
+}
+
+/**
+ * Build the Slack active-thread focus block from raw rows.
+ *
+ * Pure assembly entrypoint mirroring `assembleSlackChronologicalMessages`.
+ * Returns the rendered `<active_thread>` block as a string, or `null` when:
+ *   - the channel is not Slack, OR
+ *   - the channel is a Slack DM (DMs do not have threads), OR
+ *   - the latest user row is top-level (not in a thread), OR
+ *   - no rows belong to the active thread.
+ */
+export function assembleSlackActiveThreadFocusBlock(
+  rows: SlackTranscriptInputRow[],
+  capabilities: ChannelCapabilities,
+): string | null {
+  if (capabilities.channel !== "slack") return null;
+  // DMs do not have threads, so the focus block is always a no-op.
+  // The gateway sets `chatType: "channel"` for every non-DM Slack
+  // conversation and omits the field for DMs, so gate the focus block
+  // on the positive `"channel"` match.
+  if (capabilities.chatType !== "channel") return null;
+  const renderable = rows.map(rowToRenderable);
+  const activeThreadTs = detectActiveThreadTs(renderable);
+  if (!activeThreadTs) return null;
+  return buildActiveThreadBlockFromRenderable(renderable, activeThreadTs);
+}
+
+/**
+ * Loader convenience over `assembleSlackActiveThreadFocusBlock` mirroring
+ * `loadSlackChronologicalMessages`. Returns `null` when the channel is not
+ * Slack, or when it is a Slack DM (DMs have no threads), so callers can
+ * skip the injection entirely without paying for a DB read.
+ */
+export function loadSlackActiveThreadFocusBlock(
+  conversationId: string,
+  capabilities: ChannelCapabilities,
+  options: {
+    loader?: (id: string) => MessageRow[];
+    trustClass?: TrustClass;
+  } = {},
+): string | null {
+  if (capabilities.channel !== "slack") return null;
+  if (capabilities.chatType !== "channel") return null;
+  const loader = options.loader ?? defaultGetMessages;
+  const allRows = loader(conversationId);
+  const scopedRows = isUntrustedTrustClass(options.trustClass)
+    ? filterMessagesForUntrustedActor(allRows)
+    : allRows;
+  const rows: SlackTranscriptInputRow[] = scopedRows.map((row) => ({
+    role: row.role === "assistant" ? "assistant" : "user",
+    content: row.content,
+    createdAt: row.createdAt,
+    metadata: row.metadata,
+  }));
+  return assembleSlackActiveThreadFocusBlock(rows, capabilities);
+}
+
 /** Prefixes stripped by the pipeline (order doesn't matter — single pass). */
 const RUNTIME_INJECTION_PREFIXES = [
   "<channel_capabilities>",
@@ -1164,11 +1567,18 @@ const RUNTIME_INJECTION_PREFIXES = [
   "<active_workspace>",
   "<active_dynamic_page>",
   "<non_interactive_context>",
-  "<NOW.md Always keep this up to date>",
+  // Shared prefix catches both the current NOW.md tag and any pre-line-limit
+  // variant that may linger in in-flight histories during a rolling deploy.
+  "<NOW.md Always keep this up to date",
   "<now_scratchpad>", // backward-compat: strip legacy blocks from pre-rename history
-  "<pkb>",
+  "<knowledge_base>",
+  "<pkb>", // backward-compat: strip legacy tag from pre-rename history
   "<system_reminder>",
   "<transport_hints>",
+  // The Slack active-thread focus block is non-persisted and injected on
+  // the FINAL user turn only. Strip it here so re-assembly during compaction
+  // and overflow recovery does not duplicate it across turns.
+  "<active_thread>",
   "<system_notice>One or more tool calls returned an error.",
 ];
 
@@ -1189,16 +1599,23 @@ export function stripInjectionsForCompaction(messages: Message[]): Message[] {
  * Returns null if no NOW.md injection is found.
  */
 export function findLastInjectedNowContent(messages: Message[]): string | null {
-  const prefix = "<NOW.md Always keep this up to date>\n";
+  // Matches every NOW.md opening tag we emit (the tag text may evolve over
+  // time, e.g. adding a line-limit hint), so in-flight histories with older
+  // tag variants remain discoverable during a rolling deploy.
+  const openTagPrefix = "<NOW.md Always keep this up to date";
   const suffix = "\n</NOW.md>";
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
     if (msg.role !== "user") continue;
     for (const block of msg.content) {
-      if (block.type === "text" && block.text.startsWith(prefix)) {
-        const end = block.text.lastIndexOf(suffix);
-        if (end > prefix.length) return block.text.slice(prefix.length, end);
+      if (block.type !== "text" || !block.text.startsWith(openTagPrefix)) {
+        continue;
       }
+      const tagEnd = block.text.indexOf(">\n");
+      if (tagEnd < 0) continue;
+      const contentStart = tagEnd + ">\n".length;
+      const end = block.text.lastIndexOf(suffix);
+      if (end > contentStart) return block.text.slice(contentStart, end);
     }
   }
   return null;
@@ -1216,76 +1633,519 @@ export function findLastInjectedNowContent(messages: Message[]): string | null {
 export type InjectionMode = "full" | "minimal";
 
 /**
- * Apply a chain of user-message injections to `runMessages`.
+ * Per-turn injection bytes captured so `loadFromDb` can rehydrate historical
+ * user messages byte-for-byte after a daemon restart or conversation
+ * eviction. Persisting the exact injected text onto message metadata keeps
+ * Anthropic's prefix cache anchored to msg[0] instead of invalidating every
+ * turn on reload. Any field left `undefined` means that block was not
+ * injected on this turn.
+ */
+export interface RuntimeInjectionBlocks {
+  unifiedTurnContext?: string;
+  pkbSystemReminder?: string;
+  workspaceBlock?: string;
+  nowScratchpadBlock?: string;
+  pkbContextBlock?: string;
+  /**
+   * Composed output of every plugin-registered {@link Injector}, concatenated
+   * in ascending `order`. Empty string when every injector opted out (returned
+   * `null`). Today the default injectors (`default-injectors` plugin)
+   * placeholder-return `null`, so this is only non-empty when a third-party
+   * plugin registers an injector that emits content.
+   *
+   * Populated by {@link composeInjectorChain} during
+   * {@link applyRuntimeInjections}. Distinct from the other `blocks` fields
+   * because those track specific hardcoded injections today; this field is
+   * the extensibility seam for {@link Injector} plugins.
+   */
+  injectorChainBlock?: string;
+}
+
+export interface RuntimeInjectionResult {
+  messages: Message[];
+  blocks: RuntimeInjectionBlocks;
+}
+
+/**
+ * Run every registered {@link Injector}'s `produce()` in ascending `order`
+ * and return every non-null block the chain produced.
+ *
+ * Injectors returning `null` are omitted from the result. The returned array
+ * preserves ascending-`order` sort so downstream callers (notably
+ * {@link applyRuntimeInjections}) can group blocks by `placement` and apply
+ * them declaratively without losing per-injector ordering within each slot.
+ */
+export async function collectInjectorBlocks(
+  ctx: TurnContext,
+): Promise<InjectionBlock[]> {
+  const injectors = getInjectors();
+  if (injectors.length === 0) return [];
+  const out: InjectionBlock[] = [];
+  for (const injector of injectors) {
+    const block = await injector.produce(ctx);
+    if (block) out.push(block);
+  }
+  return out;
+}
+
+/**
+ * Run every registered {@link Injector}'s `produce()` in ascending
+ * `order`, concatenate the non-null results into a single block of text,
+ * and return it.
+ *
+ * Separator: blank line between blocks. Injectors returning `null` are
+ * skipped entirely (no leading/trailing blank lines). When no injector
+ * contributes, the function returns an empty string.
  *
- * Each injection is optional — pass `null`/`undefined` to skip it.
- * Returns the final message array ready for the provider.
+ * Used by tests that assert the concatenation contract and by callers that
+ * want a single informational string view of the chain. The canonical
+ * integration point is {@link applyRuntimeInjections}, which uses
+ * {@link collectInjectorBlocks} + placement-aware application to splice
+ * each block into the per-turn message array.
  */
-export function applyRuntimeInjections(
+export async function composeInjectorChain(ctx: TurnContext): Promise<string> {
+  const blocks = await collectInjectorBlocks(ctx);
+  const pieces: string[] = [];
+  for (const block of blocks) {
+    if (block.text.length > 0) pieces.push(block.text);
+  }
+  return pieces.join("\n\n");
+}
+
+/**
+ * Default block placement. Kept in sync with {@link InjectionBlock} so
+ * blocks produced without an explicit `placement` (e.g. third-party
+ * injectors written against the pre-G2.1 API) behave predictably.
+ */
+const DEFAULT_PLACEMENT: InjectionPlacement = "append-user-tail";
+
+/**
+ * Count leading memory-prefix blocks on a user message's `content`.
+ *
+ * Delegates to {@link countMemoryPrefixBlocks} from
+ * `memory/graph/conversation-graph-memory.js` — the same state-machine the
+ * pre-migration PKB-reminder branch used to find its splice point. The
+ * pre-migration `injectPkbContext` and `injectNowScratchpad` helpers used
+ * slightly simpler rules inline; reusing the canonical counter here
+ * collapses the three near-identical splice rules into one source of truth
+ * so the ordering of PKB-context / PKB-reminder / NOW blocks relative to
+ * any memory prefix is stable and testable. For the common case (just
+ * `<memory __injected>` text, no images), the output is byte-identical to
+ * the pre-migration helpers.
+ */
+function countMemoryPrefixBlocksOnContent(content: ContentBlock[]): number {
+  return countMemoryPrefixBlocks(content);
+}
+
+/**
+ * Apply one injector block to a `runMessages` array according to its
+ * declared {@link InjectionPlacement}.
+ *
+ * Preserves the byte-for-byte positional semantics of the pre-migration
+ * `inject*` helpers:
+ *  - `"prepend-user-tail"` — prepend to the tail user message's content.
+ *  - `"append-user-tail"`  — append to the tail user message's content.
+ *  - `"after-memory-prefix"` — splice immediately after any leading memory
+ *    prefix blocks (mirrors `injectPkbContext` / `injectNowScratchpad`).
+ *  - `"replace-run-messages"` — replace `runMessages` wholesale with
+ *    `block.messagesOverride`.
+ *
+ * Blocks with empty `text` on non-replace placements are no-ops (the
+ * pre-migration branches also short-circuited on empty strings).
+ */
+function applyInjectionBlock(
   runMessages: Message[],
-  options: {
-    activeSurface?: ActiveSurfaceContext | null;
-    workspaceTopLevelContext?: string | null;
-    channelCapabilities?: ChannelCapabilities | null;
-    channelCommandContext?: ChannelCommandContext | null;
-    unifiedTurnContext?: string | null;
-    voiceCallControlPrompt?: string | null;
-    pkbContext?: string | null;
-    pkbActive?: boolean;
-    nowScratchpad?: string | null;
-    subagentStatusBlock?: string | null;
-    isNonInteractive?: boolean;
-    transportHints?: string[] | null;
-    mode?: InjectionMode;
-  },
+  block: InjectionBlock,
 ): Message[] {
-  const mode = options.mode ?? "full";
-  let result = runMessages;
+  const placement = block.placement ?? DEFAULT_PLACEMENT;
 
-  // For non-interactive conversations (scheduled jobs, work items), instruct the
-  // model to never ask for clarification — there is no human present to answer.
-  if (options.isNonInteractive) {
-    const userTail = result[result.length - 1];
-    if (userTail && userTail.role === "user") {
-      result = [
-        ...result.slice(0, -1),
+  if (placement === "replace-run-messages") {
+    if (!block.messagesOverride) return runMessages;
+    return block.messagesOverride;
+  }
+
+  if (block.text.length === 0) return runMessages;
+
+  const userTail = runMessages[runMessages.length - 1];
+  if (!userTail || userTail.role !== "user") return runMessages;
+
+  const textBlock = { type: "text" as const, text: block.text };
+
+  switch (placement) {
+    case "prepend-user-tail":
+      return [
+        ...runMessages.slice(0, -1),
+        { ...userTail, content: [textBlock, ...userTail.content] },
+      ];
+    case "append-user-tail":
+      return [
+        ...runMessages.slice(0, -1),
+        { ...userTail, content: [...userTail.content, textBlock] },
+      ];
+    case "after-memory-prefix": {
+      const memoryPrefixCount = countMemoryPrefixBlocksOnContent(
+        userTail.content,
+      );
+      return [
+        ...runMessages.slice(0, -1),
         {
           ...userTail,
           content: [
-            ...userTail.content,
-            {
-              type: "text" as const,
-              text: "<non_interactive_context>\nNon-interactive scheduled task — do not ask for clarification or confirmation. Follow the instructions exactly using your best judgment. If recalled memory contains conflicting notes, prefer the explicit instruction in this message.\n</non_interactive_context>",
-            },
+            ...userTail.content.slice(0, memoryPrefixCount),
+            textBlock,
+            ...userTail.content.slice(memoryPrefixCount),
           ],
         },
       ];
     }
   }
+}
 
-  if (options.voiceCallControlPrompt) {
-    const userTail = result[result.length - 1];
-    if (userTail && userTail.role === "user") {
-      result = [
-        ...result.slice(0, -1),
-        injectVoiceCallControlContext(userTail, options.voiceCallControlPrompt),
-      ];
+/**
+ * Per-turn options accepted by {@link applyRuntimeInjections}.
+ *
+ * Most fields flow through to the per-injector {@link TurnInjectionInputs}
+ * bag attached to the {@link TurnContext} the caller provides (or to an
+ * ephemeral {@link TurnContext} synthesized for test call sites). A small
+ * number of fields drive hardcoded branches that live outside the injector
+ * chain — `activeSurface`, `channelCapabilities`, `channelCommandContext`,
+ * `voiceCallControlPrompt`, `transportHints`, and `isNonInteractive` —
+ * because they are orchestrator-owned content that never made sense as
+ * plugin-overridable default injectors.
+ */
+export interface RuntimeInjectionOptions {
+  /**
+   * Active dashboard-surface context (read from `<active_workspace>`). Kept
+   * on the options bag rather than an injector because it is a
+   * channel-capability concern that has never been gated as a default
+   * injector.
+   */
+  activeSurface?: ActiveSurfaceContext | null;
+  workspaceTopLevelContext?: string | null;
+  channelCapabilities?: ChannelCapabilities | null;
+  channelCommandContext?: ChannelCommandContext | null;
+  unifiedTurnContext?: string | null;
+  voiceCallControlPrompt?: string | null;
+  pkbContext?: string | null;
+  pkbActive?: boolean;
+  /**
+   * Dense query vector surfaced from the graph memory retriever.
+   * When present together with `pkbActive`, used to run `searchPkbFiles`
+   * to surface relevance hints in the PKB system reminder. When missing,
+   * the reminder falls back to the flat static text.
+   */
+  pkbQueryVector?: number[];
+  /** Optional sparse vector accompanying `pkbQueryVector`. */
+  pkbSparseVector?: QdrantSparseVector;
+  /** Memory scope id used to filter PKB search results. */
+  pkbScopeId?: string;
+  /**
+   * The live conversation (or a minimal shape containing `messages`) used
+   * to compute which PKB paths are already "in context" and therefore
+   * suppressed from hint suggestions.
+   */
+  pkbConversation?: PkbContextConversation;
+  /** Auto-injected PKB filenames (resolved relative to `pkbRoot`). */
+  pkbAutoInjectList?: string[];
+  /** Absolute path to the PKB directory (e.g. `<workspace>/pkb`). */
+  pkbRoot?: string;
+  /**
+   * Working directory against which relative `file_read` tool paths
+   * resolve, used to detect workspace-relative reads like
+   * `pkb/threads.md`. Falls back to `pkbRoot` when omitted.
+   */
+  pkbWorkingDir?: string;
+  nowScratchpad?: string | null;
+  subagentStatusBlock?: string | null;
+  isNonInteractive?: boolean;
+  transportHints?: string[] | null;
+  /**
+   * Pre-rendered Slack chronological transcript that replaces the
+   * default `runMessages` history for any Slack conversation (channels
+   * and DMs alike).
+   *
+   * When `channelCapabilities` describes a Slack conversation and this
+   * array is non-empty, the `slack-messages` default injector emits a
+   * `replace-run-messages` block that swaps `runMessages` with this
+   * transcript. Channel renders include sibling-thread tags; DM renders
+   * are flat (DMs have no threads). The `transportHints` pipeline is
+   * skipped for any Slack conversation so the persisted view isn't
+   * duplicated by gateway-side hints.
+   *
+   * Callers build this via `loadSlackChronologicalMessages` (or the
+   * underlying `assembleSlackChronologicalMessages`) before invoking
+   * this function so the assembly path stays free of direct DB calls
+   * and remains easy to test.
+   */
+  slackChronologicalMessages?: Message[] | null;
+  /**
+   * Pre-rendered `<active_thread>` focus block listing the messages of
+   * the thread the current inbound user message belongs to.
+   *
+   * Appended to the FINAL user message ONLY when `channelCapabilities`
+   * describes a Slack non-DM channel. The block is non-persisted: history
+   * rebuilds re-derive it from storage on each turn, and
+   * `RUNTIME_INJECTION_PREFIXES` strips any `<active_thread>` blocks from
+   * prior turns so they do not accumulate.
+   *
+   * Callers build this via `loadSlackActiveThreadFocusBlock` (or the
+   * underlying `assembleSlackActiveThreadFocusBlock`). Pass `null` /
+   * `undefined` when the inbound is a top-level (non-thread) post.
+   */
+  slackActiveThreadFocusBlock?: string | null;
+  mode?: InjectionMode;
+  /**
+   * Per-turn {@link TurnContext} forwarded to plugin-registered
+   * {@link Injector}s via {@link collectInjectorBlocks}. When omitted,
+   * `applyRuntimeInjections` synthesizes an ephemeral context (with a
+   * fallback `trust` classification) so the default-injector chain still
+   * runs — call sites that build the options bag without holding a full
+   * `TurnContext` get the same chain output.
+   *
+   * When provided, the caller's `trust`, `conversationId`, `turnIndex`,
+   * etc. are preserved; the function layers its per-turn
+   * {@link TurnInjectionInputs} onto a shallow clone so the caller's
+   * `TurnContext` is not mutated.
+   */
+  turnContext?: TurnContext;
+}
+
+/**
+ * Build the {@link TurnInjectionInputs} bag from the options bag.
+ *
+ * Exposed so callers that already hold a {@link TurnContext} can layer the
+ * same per-turn inputs onto it before handing control to
+ * {@link collectInjectorBlocks} directly — useful for tests and for the
+ * overflow-reducer reinject path.
+ */
+export function buildTurnInjectionInputs(
+  options: RuntimeInjectionOptions,
+): TurnInjectionInputs {
+  return {
+    mode: options.mode,
+    workspaceTopLevelContext: options.workspaceTopLevelContext,
+    unifiedTurnContext: options.unifiedTurnContext,
+    pkbContext: options.pkbContext,
+    pkbActive: options.pkbActive,
+    pkbQueryVector: options.pkbQueryVector,
+    pkbSparseVector: options.pkbSparseVector,
+    pkbScopeId: options.pkbScopeId,
+    pkbConversation: options.pkbConversation,
+    pkbAutoInjectList: options.pkbAutoInjectList,
+    pkbRoot: options.pkbRoot,
+    pkbWorkingDir: options.pkbWorkingDir,
+    nowScratchpad: options.nowScratchpad,
+    subagentStatusBlock: options.subagentStatusBlock,
+    channelCapabilities: options.channelCapabilities,
+    slackChronologicalMessages: options.slackChronologicalMessages,
+    slackActiveThreadFocusBlock: options.slackActiveThreadFocusBlock,
+    activeSurface: options.activeSurface,
+    channelCommandContext: options.channelCommandContext,
+    voiceCallControlPrompt: options.voiceCallControlPrompt,
+    transportHints: options.transportHints,
+    isNonInteractive: options.isNonInteractive,
+  };
+}
+
+/** Minimal synthetic TurnContext used when the caller omits one. */
+function synthesizeFallbackTurnContext(
+  inputs: TurnInjectionInputs,
+): TurnContext {
+  return {
+    requestId: "runtime-assembly-fallback",
+    conversationId: "runtime-assembly-fallback",
+    turnIndex: 0,
+    trust: {
+      sourceChannel: inputs.channelCapabilities?.channel
+        ? (inputs.channelCapabilities.channel as TrustContext["sourceChannel"])
+        : "vellum",
+      trustClass: "unknown",
+    },
+    injectionInputs: inputs,
+  };
+}
+
+/**
+ * Apply the runtime-injection chain to `runMessages`.
+ *
+ * The canonical per-turn assembly pipeline for every provider call:
+ *
+ *  1. Build the per-turn {@link TurnInjectionInputs} bag from `options`.
+ *  2. Layer it onto a {@link TurnContext} — either the one the caller
+ *     supplies via `options.turnContext` (preserving its `requestId`,
+ *     trust, and other fields) or an ephemeral fallback synthesized here.
+ *  3. Drive the default + third-party {@link Injector} chain via
+ *     {@link collectInjectorBlocks}.
+ *  4. Apply the chain's `"replace-run-messages"` block (Slack chronological
+ *     transcript) first so subsequent branches operate on the replaced
+ *     tail. When replacement fires, re-prepend any memory-prefix blocks
+ *     that `graphMemory.prepareMemory` had attached to the original tail —
+ *     the Slack transcript is rendered fresh from persisted rows and
+ *     carries no memory prefix of its own.
+ *  5. Apply the chain's `"after-memory-prefix"` blocks in ascending
+ *     `order`. This runs BEFORE step 6's hardcoded prepends so the
+ *     memory-prefix counter sees only the memory blocks on the tail —
+ *     any `<channel_capabilities>` / `<channel_command_context>` /
+ *     `<transport_hints>` prepended first would push the count to zero
+ *     and force PKB / NOW to splice at the top of the tail. Within the
+ *     after-memory block, each successive splice lands at the memory
+ *     boundary, pushing earlier splices further from memory — so
+ *     higher-`order` blocks end up closer to the memory prefix.
+ *  6. Run the remaining hardcoded branches (`isNonInteractive`,
+ *     `voiceCallControlPrompt`, `activeSurface`, `channelCapabilities`,
+ *     `channelCommandContext`, `transportHints`) in their historical order.
+ *  7. Finally, apply the chain's remaining blocks by placement:
+ *     `"append-user-tail"` in ascending `order`, then `"prepend-user-tail"`
+ *     in descending `order` so the lowest-`order` prepend lands topmost in
+ *     the user tail content.
+ *
+ * Returns the final message array plus a `blocks` object holding the exact
+ * injected text for each captured block — callers persist those bytes to
+ * message metadata for later byte-exact rehydration.
+ */
+export async function applyRuntimeInjections(
+  runMessages: Message[],
+  options: RuntimeInjectionOptions,
+): Promise<RuntimeInjectionResult> {
+  const mode = options.mode ?? "full";
+  const slackConversation = options.channelCapabilities?.channel === "slack";
+
+  // Build the per-injector inputs and attach them to the caller's
+  // TurnContext (without mutating it). When the caller didn't supply one,
+  // synthesize a minimal fallback so the chain still runs — test call sites
+  // that drive injection via `options` without constructing a full context
+  // continue to work.
+  const injectionInputs = buildTurnInjectionInputs(options);
+  const turnCtx: TurnContext = options.turnContext
+    ? { ...options.turnContext, injectionInputs }
+    : synthesizeFallbackTurnContext(injectionInputs);
+
+  const chainBlocks = await collectInjectorBlocks(turnCtx);
+
+  // Split the chain output by placement so the downstream assembly can
+  // process each slot with the correct ordering rule.
+  const prepends: InjectionBlock[] = [];
+  const appends: InjectionBlock[] = [];
+  const afterMemory: InjectionBlock[] = [];
+  let replaceBlock: InjectionBlock | null = null;
+  for (const block of chainBlocks) {
+    switch (block.placement ?? "append-user-tail") {
+      case "replace-run-messages":
+        // Later replace-run-messages blocks would overwrite earlier ones;
+        // the default chain only registers one (the Slack transcript).
+        replaceBlock = block;
+        break;
+      case "after-memory-prefix":
+        afterMemory.push(block);
+        break;
+      case "prepend-user-tail":
+        prepends.push(block);
+        break;
+      case "append-user-tail":
+        appends.push(block);
+        break;
     }
   }
 
-  if (mode === "full" && options.pkbContext) {
-    const userTail = result[result.length - 1];
-    if (userTail && userTail.role === "user") {
-      result = [
-        ...result.slice(0, -1),
-        injectPkbContext(userTail, options.pkbContext),
-      ];
+  // Track captured text for metadata persistence. Each field corresponds
+  // to a specific default-injector block id so the loop below can pick up
+  // the right capture without re-rendering.
+  //
+  // The capture is gated on the tail actually being a user message — if it
+  // isn't, `applyInjectionBlock` no-ops the block and no content is actually
+  // injected, so the persisted metadata must be undefined (matches
+  // pre-migration behaviour where the `inject*` helpers short-circuited the
+  // same way).
+  let turnContextCaptured: string | undefined;
+  let workspaceCaptured: string | undefined;
+  let nowScratchpadCaptured: string | undefined;
+  let pkbContextCaptured: string | undefined;
+  let pkbSystemReminderCaptured: string | undefined;
+  const initialTail = runMessages[runMessages.length - 1];
+  const initialTailIsUser = !!initialTail && initialTail.role === "user";
+  if (initialTailIsUser) {
+    for (const block of chainBlocks) {
+      switch (block.id) {
+        case "unified-turn-context":
+          turnContextCaptured = block.text;
+          break;
+        case "workspace-context":
+          workspaceCaptured = block.text;
+          break;
+        case "now-md":
+          nowScratchpadCaptured = block.text;
+          break;
+        case "pkb-context":
+          pkbContextCaptured = block.text;
+          break;
+        case "pkb-reminder":
+          pkbSystemReminderCaptured = block.text;
+          break;
+      }
+    }
+  }
+
+  // Compose the block text into a single informational string for
+  // `injectorChainBlock`. Matches the pre-migration behaviour where the
+  // field captured the composed view of every third-party injector on
+  // the turn. We include default injectors here too so downstream
+  // observers see the full set.
+  const injectorChainPieces: string[] = [];
+  for (const block of chainBlocks) {
+    if (block.text.length > 0) injectorChainPieces.push(block.text);
+  }
+  const injectorChainBlock =
+    injectorChainPieces.length > 0
+      ? injectorChainPieces.join("\n\n")
+      : undefined;
+
+  let result = runMessages;
+
+  // ── Step 1: Slack chronological replacement (chain "replace" block) ──
+  if (replaceBlock && replaceBlock.messagesOverride) {
+    // `graphMemory.prepareMemory` prepends a `<memory __injected>` block
+    // (and any memory-image groups) to the last user message before
+    // runtime assembly runs. The Slack transcript is freshly rendered
+    // from persisted rows and has no such prefix, so swap it in and then
+    // re-prepend the captured prefix onto the new tail user message.
+    const carriedMemoryBlocks = extractMemoryPrefixBlocks(runMessages);
+    result = replaceBlock.messagesOverride;
+    if (carriedMemoryBlocks.length > 0) {
+      const slackTail = result[result.length - 1];
+      if (slackTail && slackTail.role === "user") {
+        result = [
+          ...result.slice(0, -1),
+          {
+            ...slackTail,
+            content: [...carriedMemoryBlocks, ...slackTail.content],
+          },
+        ];
+      }
     }
   }
 
-  // PKB behavioral nudge — injected on every turn when PKB is active so
-  // the model keeps reading topic files and calling `remember`.
-  if (mode === "full" && options.pkbActive) {
+  // ── Step 2: after-memory-prefix chain blocks ──
+  // These splice relative to the memory-prefix count on the tail content,
+  // so they must run BEFORE the hardcoded prepends in step 3. Otherwise
+  // any prepended `<channel_capabilities>` / `<channel_command_context>` /
+  // `<transport_hints>` (none of which are memory-prefix blocks) would
+  // drop the count to 0 and PKB / NOW would splice at the very top of
+  // the tail instead of immediately after memory.
+  //
+  // Ascending `order`: each splice lands at the memory-prefix boundary,
+  // pushing any previously-spliced block one slot further from memory.
+  // So higher-`order` blocks end up closer to the memory prefix.
+  for (const block of afterMemory) {
+    result = applyInjectionBlock(result, block);
+  }
+
+  // ── Step 3: hardcoded branches that stayed outside the injector chain ──
+  // These run in the same historical order as before G2.1 so their
+  // interleaving with any prior tail content stays stable.
+
+  // For non-interactive conversations (scheduled jobs, work items), instruct the
+  // model to never ask for clarification — there is no human present to answer.
+  if (options.isNonInteractive) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [
@@ -1294,19 +2154,22 @@ export function applyRuntimeInjections(
           ...userTail,
           content: [
             ...userTail.content,
-            { type: "text" as const, text: PKB_SYSTEM_REMINDER },
+            {
+              type: "text" as const,
+              text: "<non_interactive_context>\nNon-interactive scheduled task — do not ask for clarification or confirmation. Follow the instructions exactly using your best judgment. If recalled memory contains conflicting notes, prefer the explicit instruction in this message.\n</non_interactive_context>",
+            },
           ],
         },
       ];
     }
   }
 
-  if (mode === "full" && options.nowScratchpad) {
+  if (options.voiceCallControlPrompt) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [
         ...result.slice(0, -1),
-        injectNowScratchpad(userTail, options.nowScratchpad),
+        injectVoiceCallControlContext(userTail, options.voiceCallControlPrompt),
       ];
     }
   }
@@ -1341,34 +2204,15 @@ export function applyRuntimeInjections(
     }
   }
 
-  if (mode === "full" && options.subagentStatusBlock) {
-    const userTail = result[result.length - 1];
-    if (userTail && userTail.role === "user") {
-      result = [
-        ...result.slice(0, -1),
-        injectSubagentStatus(userTail, options.subagentStatusBlock),
-      ];
-    }
-  }
-
-  if (options.unifiedTurnContext) {
-    const userTail = result[result.length - 1];
-    if (userTail && userTail.role === "user") {
-      result = [
-        ...result.slice(0, -1),
-        {
-          ...userTail,
-          content: [
-            { type: "text" as const, text: options.unifiedTurnContext },
-            ...userTail.content,
-          ],
-        },
-      ];
-    }
-  }
-
+  // Slack conversations (both channels and DMs) build their own
+  // chronological transcript from persisted messages and intentionally do
+  // not receive the per-turn `<transport_hints>` block — the rendered
+  // history already covers the active thread / DM, so duplicating it
+  // would confuse the model. Other channels (telegram, email, etc.) keep
+  // the existing injection.
   if (
     mode === "full" &&
+    !slackConversation &&
     options.transportHints &&
     options.transportHints.length > 0
   ) {
@@ -1381,21 +2225,29 @@ export function applyRuntimeInjections(
     }
   }
 
-  // Workspace top-level context is injected last so it appears first
-  // (prepended) in the user message content, keeping cache breakpoints
-  // anchored to the trailing blocks.
-  if (mode === "full" && options.workspaceTopLevelContext) {
-    const userTail = result[result.length - 1];
-    if (userTail && userTail.role === "user") {
-      result = [
-        ...result.slice(0, -1),
-        injectWorkspaceTopLevelContext(
-          userTail,
-          options.workspaceTopLevelContext,
-        ),
-      ];
-    }
+  // ── Step 4: apply remaining chain blocks by placement ──
+  // append-user-tail: ascending `order` so lower-order blocks come first
+  // in the append sequence.
+  for (const block of appends) {
+    result = applyInjectionBlock(result, block);
+  }
+
+  // prepend-user-tail: descending `order` so the lowest-order block lands
+  // topmost in the tail content (each successive prepend pushes the
+  // previous one further down).
+  for (let i = prepends.length - 1; i >= 0; i--) {
+    result = applyInjectionBlock(result, prepends[i]);
   }
 
-  return result;
+  return {
+    messages: result,
+    blocks: {
+      unifiedTurnContext: turnContextCaptured,
+      pkbSystemReminder: pkbSystemReminderCaptured,
+      workspaceBlock: workspaceCaptured,
+      nowScratchpadBlock: nowScratchpadCaptured,
+      pkbContextBlock: pkbContextCaptured,
+      injectorChainBlock,
+    },
+  };
 }