@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

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

@@ -5,13 +5,21 @@
  * before it is sent to the provider.  They are pure (no side effects).
  */
 
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { statSync } from "node:fs";
+import { join } from "node:path";
 
 import { type ChannelId, parseInterfaceId } from "../channels/types.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
+import { stripUserTextBlocksByPrefix } from "../context/strip-injections.js";
 import { createContextSummaryMessage } from "../context/window-manager.js";
-import { getAppDirPath, listAppFiles } from "../memory/app-store.js";
+import { getDocumentsForConversation } from "../documents/document-store.js";
+import {
+  getApp,
+  getAppDirPath,
+  listAppFiles,
+  resolveAppDir,
+} from "../memory/app-store.js";
 import {
   getMessages as defaultGetMessages,
   type MessageRow,
@@ -21,8 +29,6 @@ import {
   extractMemoryPrefixBlocks,
   stripAllMemoryInjections,
 } from "../memory/graph/conversation-graph-memory.js";
-import type { QdrantSparseVector } from "../memory/qdrant-client.js";
-import { MEMORY_V3_BLOCK_ID } from "../memory/v3/types.js";
 import {
   readSlackMetadata,
   readSlackMetadataFromMessageMetadata,
@@ -35,9 +41,9 @@ import {
   type RenderedSlackTranscriptMessage,
   renderSlackTranscriptWithProvenance,
 } from "../messaging/providers/slack/render-transcript.js";
-import { getInjectors } from "../plugins/registry.js";
+import { getInjectorChain } from "../plugins/defaults/memory-retrieval/injector-chain.js";
+import { MEMORY_V3_BLOCK_ID } from "../plugins/defaults/memory-v3-shadow/types.js";
 import type {
-  DiskPressureInjectionContext,
   InjectionBlock,
   InjectionPlacement,
   TurnContext,
@@ -53,12 +59,19 @@ import { channelStatusToMemberStatus } from "../runtime/routes/inbound-stages/ac
 import type { SubagentState } from "../subagent/types.js";
 import { TERMINAL_STATUSES } from "../subagent/types.js";
 import { canonicalizeInboundIdentity } from "../util/canonicalize-identity.js";
-import { getWorkspaceDir, getWorkspacePromptPath } from "../util/platform.js";
-import { stripCommentLines } from "../util/strip-comment-lines.js";
+import { findConversationOrSubagent } from "./conversation-registry.js";
+import type {
+  DynamicPageSurfaceData,
+  SurfaceData,
+  SurfaceType,
+} from "./message-protocol.js";
 import { filterMessagesForUntrustedActor } from "./message-provenance.js";
-import { type PkbContextConversation } from "./pkb-context-tracker.js";
 import type { TrustContext } from "./trust-context.js";
 
+// The compaction strip lives in the compaction layer (`context/`) so the agent
+// loop can own it; re-exported here for this module's existing consumers.
+export { stripInjectionsForCompaction } from "../context/strip-injections.js";
+
 /**
  * Describes the capabilities of the channel through which the user is
  * interacting.  Used to gate UI-specific references and permission asks.
@@ -257,8 +270,8 @@ export function isGroupChatType(chatType?: string): boolean {
   }
 }
 
-/** Context about the active workspace surface, passed to applyRuntimeInjections. */
-export interface ActiveSurfaceContext {
+/** Context about the active workspace surface, rendered into the `<active_workspace>` block. */
+interface ActiveSurfaceContext {
   surfaceId: string;
   html: string;
   /** When set, the surface is backed by a persisted app. */
@@ -271,8 +284,72 @@ export interface ActiveSurfaceContext {
   appPages?: Record<string, string>;
   /** The page currently displayed in the WebView (e.g. "settings.html"). */
   currentPage?: string;
-  /** Pre-fetched list of files in the app directory. */
-  appFiles?: string[];
+}
+
+/**
+ * Resolve the conversation's active workspace surface into the context block
+ * consumed by {@link applyRuntimeInjections}, or `null` when no dynamic-page
+ * surface is active. App-backed surfaces are enriched with their persisted app
+ * metadata; the file tree is listed on demand by the injector.
+ */
+export function buildActiveSurfaceContext(params: {
+  currentActiveSurfaceId: string | undefined;
+  currentPage: string | undefined;
+  surfaceState: ReadonlyMap<
+    string,
+    { surfaceType: SurfaceType; data: SurfaceData }
+  >;
+}): ActiveSurfaceContext | null {
+  const { currentActiveSurfaceId, currentPage, surfaceState } = params;
+  if (!currentActiveSurfaceId) return null;
+
+  const stored = surfaceState.get(currentActiveSurfaceId);
+  if (!stored || stored.surfaceType !== "dynamic_page") return null;
+
+  const data = stored.data as DynamicPageSurfaceData;
+  const activeSurface: ActiveSurfaceContext = {
+    surfaceId: currentActiveSurfaceId,
+    html: data.html,
+    currentPage,
+  };
+
+  if (data.appId) {
+    const app = getApp(data.appId);
+    if (app) {
+      activeSurface.appId = app.id;
+      activeSurface.appName = app.name;
+      activeSurface.appDirName = resolveAppDir(app.id).dirName;
+      activeSurface.appSchemaJson = app.schemaJson;
+      if (app.pages && Object.keys(app.pages).length > 0) {
+        activeSurface.appPages = app.pages;
+      }
+    }
+  }
+
+  return activeSurface;
+}
+
+/**
+ * Lists the conversation's active documents as the lightweight summaries the
+ * `active-documents` injector surfaces to the assistant — letting it target
+ * existing documents with `document_update` instead of issuing duplicate
+ * `document_create` calls. Returns `null` when the conversation has none.
+ */
+export function buildActiveDocuments(conversationId: string): Array<{
+  surfaceId: string;
+  title: string;
+  wordCount: number;
+  updatedAt: number;
+}> | null {
+  const conversationDocs = getDocumentsForConversation(conversationId);
+  return conversationDocs.length > 0
+    ? conversationDocs.map((d) => ({
+        surfaceId: d.surfaceId,
+        title: d.title,
+        wordCount: d.wordCount,
+        updatedAt: d.updatedAt,
+      }))
+    : null;
 }
 
 const MAX_CONTEXT_LENGTH = 100_000;
@@ -315,7 +392,7 @@ function injectActiveSurfaceContext(
     );
 
     // File tree with sizes (capped at 50 files to bound prompt size)
-    const files = ctx.appFiles ?? listAppFiles(ctx.appId);
+    const files = listAppFiles(ctx.appId);
     const MAX_FILE_TREE_ENTRIES = 50;
     const displayFiles = files.slice(0, MAX_FILE_TREE_ENTRIES);
     lines.push("", "App files:");
@@ -490,7 +567,7 @@ export function buildSubagentStatusBlock(
 }
 
 // The `<active_subagents>` block is emitted by the `subagent-status` default
-// injector (`plugins/defaults/injectors/register.ts`) as an `append-user-tail`
+// injector (`plugins/defaults/memory-retrieval/injectors.ts`) as an `append-user-tail`
 // placement. Use {@link applyRuntimeInjections} with
 // `options.subagentStatusBlock` set, or drive the injector chain directly
 // via `collectInjectorBlocks`.
@@ -514,30 +591,7 @@ function injectVoiceCallControlContext(
 // NOW.md scratchpad injection
 // ---------------------------------------------------------------------------
 
-/**
- * Read the NOW.md scratchpad from the workspace prompt directory.
- *
- * Returns the trimmed content with `_`-prefixed comment lines stripped,
- * or `null` if the file is missing, empty, or unreadable.
- */
-export function readNowScratchpad(): string | null {
-  const nowPath = getWorkspacePromptPath("NOW.md");
-  if (!existsSync(nowPath)) return null;
-  try {
-    const stripped = stripCommentLines(readFileSync(nowPath, "utf-8")).trim();
-    return stripped.length > 0 ? stripped : null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * The `<NOW.md>` block is emitted by the `now-md` default injector
- * (`plugins/defaults/injectors/register.ts`) as an `after-memory-prefix` placement.
- * Use {@link applyRuntimeInjections} with `options.nowScratchpad` set.
- */
-
-/** Strip `<NOW.md>` blocks injected by `injectNowScratchpad`. */
+/** Strip `<NOW.md>` blocks injected by the `now-md` default injector. */
 export function stripNowScratchpad(messages: Message[]): Message[] {
   return stripUserTextBlocksByPrefix(messages, [
     // Shared prefix catches both the current tag and any pre-line-limit
@@ -547,102 +601,6 @@ export function stripNowScratchpad(messages: Message[]): Message[] {
   ]);
 }
 
-// ---------------------------------------------------------------------------
-// PKB (Personal Knowledge Base) injection
-// ---------------------------------------------------------------------------
-
-const PKB_DEFAULT_FILES = [
-  "INDEX.md",
-  "essentials.md",
-  "threads.md",
-  "buffer.md",
-];
-
-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;
-
-/**
- * Read `_autoinject.md` from the PKB directory and return the list of
- * filenames to inject.
- *
- * - Returns `null` when the file is missing or unreadable — callers
- *   should fall back to the hardcoded defaults.
- * - Returns `[]` when the file exists but has no entries (empty or
- *   comments only) — an explicit opt-out meaning "inject nothing."
- */
-export function readAutoinjectList(pkbDir: string): string[] | null {
-  const filePath = join(pkbDir, AUTOINJECT_FILENAME);
-  if (!existsSync(filePath)) return null;
-  try {
-    const raw = stripCommentLines(readFileSync(filePath, "utf-8"));
-    const files = raw
-      .split("\n")
-      .map((l) => l.trim())
-      .filter((l) => l.length > 0);
-    return files.length > 0 ? files : [];
-  } catch {
-    return 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.
- *
- * Which files are loaded is determined by `pkb/_autoinject.md` (one filename
- * per line). Falls back to the built-in defaults when that file is absent.
- *
- * Returns the concatenated content ready for injection, or `null` if all
- * files are missing or empty.
- */
-export function readPkbContext(): string | null {
-  const pkbDir = join(getWorkspaceDir(), "pkb");
-  if (!existsSync(pkbDir)) return null;
-
-  const filesToInject = getPkbAutoInjectList(pkbDir);
-
-  const parts: string[] = [];
-  for (const file of filesToInject) {
-    // Path traversal guard: reject entries that escape the pkb directory
-    const filePath = resolve(pkbDir, file);
-    if (!filePath.startsWith(pkbDir + "/")) continue;
-
-    if (!existsSync(filePath)) continue;
-    try {
-      let content = stripCommentLines(readFileSync(filePath, "utf-8")).trim();
-      if (file === "buffer.md" && content.length > 0) {
-        // Cap buffer entries to prevent unbounded growth when filing is disabled
-        const lines = content.split("\n");
-        if (lines.length > MAX_BUFFER_LINES) {
-          content = lines.slice(-MAX_BUFFER_LINES).join("\n");
-        }
-      }
-      if (content.length > 0) parts.push(content);
-    } catch {
-      // Skip unreadable files
-    }
-  }
-
-  return parts.length > 0 ? parts.join("\n\n") : null;
-}
-
 /**
  * Prepend channel capability context to the last user message so the
  * model knows what the current channel can and cannot do.
@@ -994,53 +952,6 @@ export function buildUnifiedTurnContextBlock(
   return lines.join("\n");
 }
 
-// ---------------------------------------------------------------------------
-// Prefix-based stripping primitive
-// ---------------------------------------------------------------------------
-
-/**
- * A matcher for an injected text block. A plain string matches by prefix
- * (`startsWith`). A `{ prefix, suffix }` wrapper requires BOTH the opening
- * prefix and the closing suffix, so user-authored content that merely begins
- * with an injection-like opening tag (e.g. a message discussing `<info>`
- * markup) is not mistaken for an injected block and dropped. This mirrors
- * `countMemoryPrefixBlocks`, which only treats `<memory>…</memory>` /
- * `<info>…</info>` blocks as injected when the full wrapper is present.
- */
-type InjectionMatcher = string | { prefix: string; suffix: string };
-
-/**
- * Remove text blocks from user messages that match any of the given matchers.
- * If stripping removes all content blocks from a message, the message itself
- * is dropped.
- *
- * This is the shared primitive behind the individual strip* functions and
- * the `stripInjectionsForCompaction` pipeline.
- */
-function stripUserTextBlocksByPrefix(
-  messages: Message[],
-  matchers: InjectionMatcher[],
-): Message[] {
-  return messages
-    .map((message) => {
-      if (message.role !== "user") return message;
-      const nextContent = message.content.filter((block) => {
-        if (block.type !== "text") return true;
-        return !matchers.some((m) =>
-          typeof m === "string"
-            ? block.text.startsWith(m)
-            : block.text.startsWith(m.prefix) && block.text.endsWith(m.suffix),
-        );
-      });
-      if (nextContent.length === message.content.length) return message;
-      if (nextContent.length === 0) return null;
-      return { ...message, content: nextContent };
-    })
-    .filter(
-      (message): message is NonNullable<typeof message> => message != null,
-    );
-}
-
 // ---------------------------------------------------------------------------
 // Individual strip functions (thin wrappers around the primitive)
 // ---------------------------------------------------------------------------
@@ -1726,98 +1637,6 @@ export function loadSlackActiveThreadFocusBlock(
   return assembleSlackActiveThreadFocusBlock(rows, capabilities);
 }
 
-/** Matchers stripped by the pipeline (order doesn't matter — single pass). */
-const RUNTIME_INJECTION_PREFIXES: InjectionMatcher[] = [
-  "<channel_capabilities>",
-  "<channel_command_context>",
-  "<disk_pressure_warning>",
-  "<channel_turn_context>", // backward-compat: strip legacy separate channel blocks
-  "<guardian_context>",
-  "<inbound_actor_context>", // backward-compat: strip legacy separate actor blocks
-  "<interface_turn_context>", // backward-compat: strip legacy separate interface blocks
-  // NOTE: <turn_context> is intentionally NOT stripped — unified turn context
-  // blocks persist in history so the assistant retains temporal/actor grounding.
-  "<background_turn>",
-  "<memory_context __injected>",
-  "<memory_context>", // backward-compat: strip legacy blocks from pre-__injected history
-  // The static `memory-v2-static` block (`<info>\n…</info>`) and the
-  // dynamic activation block (`<memory>\n…</memory>`, plus legacy
-  // `<memory __injected>…`) are both stripped so each compaction
-  // re-injects the freshest essentials/threads/recent/buffer view and
-  // re-runs the activation pipeline, matching the `<knowledge_base>`
-  // cadence. The activation pipeline dedupes via `everInjected`, and
-  // compaction handles aggregate growth, so accumulation does not cause
-  // unbounded context growth. Both wrappers may appear in persisted rows.
-  //
-  // These two use the full `{ prefix, suffix }` wrapper shape (not a bare
-  // prefix) so that user-authored text merely starting with `<memory>\n` or
-  // `<info>\n` is never silently dropped during compaction/`/clean`. This
-  // matches the full-wrapper requirement in `countMemoryPrefixBlocks`.
-  { prefix: "<memory>\n", suffix: "\n</memory>" },
-  { prefix: "<info>\n", suffix: "\n</info>" },
-  "<voice_call_control>",
-  "<workspace_top_level>", // backward-compat: strip legacy workspace blocks
-  // NOTE: <workspace> is intentionally NOT stripped — workspace context
-  // persists in history so the assistant retains workspace grounding.
-  "<temporal_context>\nToday:", // backward-compat: strip legacy temporal blocks
-  "<active_subagents>",
-  "<active_workspace>",
-  "<active_dynamic_page>",
-  "<non_interactive_context>",
-  // Shared prefix catches both the current NOW.md tag and any pre-line-limit
-  // variant that may linger in in-flight histories during a rolling deploy.
-  "<NOW.md Always keep this up to date",
-  "<now_scratchpad>", // backward-compat: strip legacy blocks from pre-rename history
-  "<knowledge_base>",
-  "<pkb>", // backward-compat: strip legacy tag from pre-rename history
-  "<system_reminder>",
-  "<transport_hints>",
-  // The Slack active-thread focus block is non-persisted and injected on
-  // the FINAL user turn only. Strip it here so re-assembly during compaction
-  // and overflow recovery does not duplicate it across turns.
-  "<active_thread>",
-  "<system_notice>One or more tool calls returned an error.",
-];
-
-/**
- * Strip all runtime-injected context from message history in a single pass.
- *
- * Used only during compaction and overflow recovery — not on normal turns.
- * Runtime injections persist in history to keep the conversation prefix
- * stable for Anthropic's prefix caching. Stripping is only needed when
- * compaction rewrites the message array (cache miss is expected anyway).
- */
-export function stripInjectionsForCompaction(messages: Message[]): Message[] {
-  return stripUserTextBlocksByPrefix(messages, RUNTIME_INJECTION_PREFIXES);
-}
-
-/**
- * Extract the most recently injected NOW.md content from the message history.
- * Returns null if no NOW.md injection is found.
- */
-export function findLastInjectedNowContent(messages: Message[]): string | null {
-  // 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(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;
-}
-
 /**
  * Controls which runtime injections are applied.
  *
@@ -1865,8 +1684,14 @@ export interface RuntimeInjectionResult {
 }
 
 /**
- * Run every registered {@link Injector}'s `produce()` in ascending `order`
- * and return every non-null block the chain produced.
+ * Run every {@link Injector} in the chain ({@link getInjectorChain}, already
+ * sorted by ascending `order`) and return every non-null block it produced.
+ *
+ * `runMessages` is the turn's working message array, forwarded to each
+ * injector so producers that need the current prompt contents read it from a
+ * parameter rather than the shared {@link TurnContext}. Omitted by text-only
+ * callers ({@link composeInjectorChain}) that drive the chain without a
+ * message array.
  *
  * Injectors returning `null` are omitted from the result. The returned array
  * preserves ascending-`order` sort so downstream callers (notably
@@ -1875,12 +1700,11 @@ export interface RuntimeInjectionResult {
  */
 async function collectInjectorBlocks(
   ctx: TurnContext,
+  runMessages?: Message[],
 ): Promise<InjectionBlock[]> {
-  const injectors = getInjectors();
-  if (injectors.length === 0) return [];
   const out: InjectionBlock[] = [];
-  for (const injector of injectors) {
-    const block = await injector.produce(ctx);
+  for (const injector of getInjectorChain()) {
+    const block = await injector.produce(ctx, runMessages);
     if (block) out.push(block);
   }
   return out;
@@ -1998,63 +1822,19 @@ function applyInjectionBlock(
  * 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.
+ * chain — `isNonInteractive` — because it is orchestrator-owned content that
+ * never made sense as a plugin-overridable default injector.
+ *
+ * The active workspace surface, the channel capabilities, the active document
+ * list, the channel command context, the voice call-control prompt, and the
+ * transport hints are not on this bag: `applyRuntimeInjections` resolves them
+ * from the live conversation itself (its surface state, `channelCapabilities`,
+ * the document store keyed by `conversationId`, its `commandIntent`, its
+ * `voiceCallControlPrompt`, and its `transportHints` respectively), so the
+ * orchestrator does not compute or thread them per turn.
  */
 export interface RuntimeInjectionOptions {
-  diskPressureContext?: DiskPressureInjectionContext | null;
-  /**
-   * 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;
-  /**
-   * Pre-rendered v2 static memory content (essentials/threads/recent/buffer
-   * concatenated, header-wrapped). When non-null on full-mode turns the
-   * `memory-v2-static` injector wraps it in `<info>` and splices it onto
-   * the user message; subsequent turns leave the prior block cached on its
-   * original user message.
-   */
-  memoryV2Static?: string | null;
-  nowScratchpad?: string | null;
   subagentStatusBlock?: string | null;
   isNonInteractive?: boolean;
   /**
@@ -2064,7 +1844,6 @@ export interface RuntimeInjectionOptions {
    * configured reminder.
    */
   isBackgroundConversation?: boolean;
-  transportHints?: string[] | null;
   /**
    * Pre-rendered Slack chronological transcript that replaces the
    * default `runMessages` history for any Slack conversation (channels
@@ -2099,22 +1878,7 @@ export interface RuntimeInjectionOptions {
    * `undefined` when the inbound is a top-level (non-thread) post.
    */
   slackActiveThreadFocusBlock?: string | null;
-  activeDocuments?: TurnInjectionInputs["activeDocuments"];
   mode?: InjectionMode;
-  /**
-   * memory-v3-live: when true AND the v3 injector produced a `<memory>` block
-   * this turn (placement `after-memory-prefix`, id `memory-v3`), the v2
-   * `<memory>` injection that `graphMemory.prepareMemory` prepended to the
-   * tail is stripped from EVERY user message before the v3 block is spliced —
-   * so v3 becomes the sole `<memory>` source and history stays byte-stable for
-   * prompt caching.
-   *
-   * The strip is keyed off whether v3 ACTUALLY produced a block, not off the
-   * flag alone: when v3 errors or selects nothing (its injector returns
-   * `null`), v2's block is left in place so the turn still ships memory rather
-   * than dropping it (fallback-to-v2). Default false — v2 untouched.
-   */
-  suppressV2MemoryForV3?: boolean;
   /**
    * Per-turn {@link TurnContext} forwarded to plugin-registered
    * {@link Injector}s via {@link collectInjectorBlocks}. When omitted,
@@ -2141,44 +1905,35 @@ export interface RuntimeInjectionOptions {
  */
 function buildTurnInjectionInputs(
   options: RuntimeInjectionOptions,
+  channelCapabilities: ChannelCapabilities | null,
+  activeDocuments: TurnInjectionInputs["activeDocuments"],
 ): TurnInjectionInputs {
   return {
     mode: options.mode,
-    diskPressureContext: options.diskPressureContext,
-    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,
-    memoryV2Static: options.memoryV2Static,
-    nowScratchpad: options.nowScratchpad,
     subagentStatusBlock: options.subagentStatusBlock,
-    channelCapabilities: options.channelCapabilities,
+    channelCapabilities,
     slackChronologicalMessages: options.slackChronologicalMessages,
     slackActiveThreadFocusBlock: options.slackActiveThreadFocusBlock,
-    activeSurface: options.activeSurface,
-    channelCommandContext: options.channelCommandContext,
-    voiceCallControlPrompt: options.voiceCallControlPrompt,
-    transportHints: options.transportHints,
     isNonInteractive: options.isNonInteractive,
     isBackgroundConversation: options.isBackgroundConversation,
-    activeDocuments: options.activeDocuments,
+    activeDocuments,
   };
 }
 
+/**
+ * Conversation id used for the synthetic fallback {@link TurnContext} and the
+ * live-conversation lookup when the caller omits a context (test call sites).
+ */
+const RUNTIME_ASSEMBLY_FALLBACK_CONVERSATION_ID = "runtime-assembly-fallback";
+
 /** Minimal synthetic TurnContext used when the caller omits one. */
 function synthesizeFallbackTurnContext(
   inputs: TurnInjectionInputs,
 ): TurnContext {
   return {
-    requestId: "runtime-assembly-fallback",
-    conversationId: "runtime-assembly-fallback",
+    requestId: RUNTIME_ASSEMBLY_FALLBACK_CONVERSATION_ID,
+    conversationId: RUNTIME_ASSEMBLY_FALLBACK_CONVERSATION_ID,
     turnIndex: 0,
     trust: {
       sourceChannel: inputs.channelCapabilities?.channel
@@ -2219,6 +1974,9 @@ function synthesizeFallbackTurnContext(
  *  6. Run the remaining hardcoded branches (`isNonInteractive`,
  *     `voiceCallControlPrompt`, `activeSurface`, `channelCapabilities`,
  *     `channelCommandContext`, `transportHints`) in their historical order.
+ *     `voiceCallControlPrompt`, `activeSurface`, `channelCapabilities`,
+ *     `channelCommandContext`, and `transportHints` are sourced from the live
+ *     conversation rather than `options`.
  *  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
@@ -2233,19 +1991,63 @@ export async function applyRuntimeInjections(
   options: RuntimeInjectionOptions,
 ): Promise<RuntimeInjectionResult> {
   const mode = options.mode ?? "full";
-  const slackConversation = options.channelCapabilities?.channel === "slack";
+
+  // Source the channel capabilities from the live conversation rather than a
+  // per-turn option computed by the orchestrator. The same value drives the
+  // Slack-conversation gate, the `<channel_capabilities>` branch, and the
+  // per-injector inputs the Slack injectors read.
+  const conversationId =
+    options.turnContext?.conversationId ??
+    RUNTIME_ASSEMBLY_FALLBACK_CONVERSATION_ID;
+  const channelCapabilities =
+    findConversationOrSubagent(conversationId)?.channelCapabilities ?? null;
+  const slackConversation = channelCapabilities?.channel === "slack";
+
+  // Source the active documents from the document store keyed by the same
+  // conversation id rather than a per-turn option computed by the
+  // orchestrator; the `active-documents` and `document-comments` injectors
+  // read the result off their per-injector inputs.
+  const activeDocuments = buildActiveDocuments(conversationId);
+
+  // Source the channel command intent (e.g. Telegram /start) from the live
+  // conversation rather than a per-turn option. It is set on the conversation
+  // at message-processing start and cleared at turn end, so the same value
+  // drives the `<channel_command_context>` branch on every assembly call
+  // within the turn.
+  const channelCommandContext =
+    findConversationOrSubagent(conversationId)?.commandIntent ?? null;
+
+  // Source the voice call-control prompt from the live conversation rather
+  // than a per-turn option. The voice-session bridge sets it on the
+  // conversation when a call attaches and clears it when the call ends, so
+  // the same value drives the `<voice_call_control>` branch on every assembly
+  // call within the turn.
+  const voiceCallControlPrompt =
+    findConversationOrSubagent(conversationId)?.voiceCallControlPrompt ?? null;
+
+  // Source the transport hints from the live conversation rather than a
+  // per-turn option. They are set on the conversation from the inbound
+  // message's transport when the message is processed, so the same value
+  // drives the `<transport_hints>` branch on every assembly call within the
+  // turn.
+  const transportHints =
+    findConversationOrSubagent(conversationId)?.transportHints ?? null;
 
   // 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 injectionInputs = buildTurnInjectionInputs(
+    options,
+    channelCapabilities,
+    activeDocuments,
+  );
   const turnCtx: TurnContext = options.turnContext
     ? { ...options.turnContext, injectionInputs }
     : synthesizeFallbackTurnContext(injectionInputs);
 
-  const chainBlocks = await collectInjectorBlocks(turnCtx);
+  const chainBlocks = await collectInjectorBlocks(turnCtx, runMessages);
 
   // Split the chain output by placement so the downstream assembly can
   // process each slot with the correct ordering rule.
@@ -2325,21 +2127,25 @@ export async function applyRuntimeInjections(
       : undefined;
 
   // ── Step 0: memory-v3-live v2 suppression ──
-  // When v3 live mode is on AND the v3 injector actually produced a block this
-  // turn, v3 is the sole `<memory>` source. v2's `prepareMemory` already
-  // prepended its own `<memory>` block to the tail user message (and historical
-  // turns may carry v2 blocks from earlier turns). Strip every user message's
-  // memory prefix here so:
+  // When the `memory-v3-live` flag is on AND the v3 injector actually produced
+  // a block this turn, v3 is the sole `<memory>` source. v2's `prepareMemory`
+  // already prepended its own `<memory>` block to the tail user message (and
+  // historical turns may carry v2 blocks from earlier turns). Strip every user
+  // message's memory prefix here so:
   //   1. The v3 `after-memory-prefix` block (Step 2) lands at the top of the
   //      tail with no v2 prefix ahead of it — exactly one `<memory>` block.
   //   2. History is byte-stable across turns for prompt caching.
   // Keyed off the v3 block being present (not the flag alone) so a v3 failure
   // (`produce()` → null) leaves v2's block intact — fallback rather than a
   // memory-less turn. Idempotent: re-injection sites that already stripped
-  // see no change.
+  // see no change. Flag off → bit-for-bit identical to the v2 path.
+  const suppressV2MemoryForV3 = isAssistantFeatureFlagEnabled(
+    "memory-v3-live",
+    getConfig(),
+  );
   const v3ProducedBlock = afterMemory.some((b) => b.id === MEMORY_V3_BLOCK_ID);
   let runMessagesForAssembly = runMessages;
-  if (options.suppressV2MemoryForV3 && v3ProducedBlock) {
+  if (suppressV2MemoryForV3 && v3ProducedBlock) {
     runMessagesForAssembly = stripAllMemoryInjections(runMessages);
   }
 
@@ -2410,42 +2216,56 @@ export async function applyRuntimeInjections(
     }
   }
 
-  if (options.voiceCallControlPrompt) {
+  if (voiceCallControlPrompt) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [
         ...result.slice(0, -1),
-        injectVoiceCallControlContext(userTail, options.voiceCallControlPrompt),
+        injectVoiceCallControlContext(userTail, voiceCallControlPrompt),
       ];
     }
   }
 
-  if (mode === "full" && options.activeSurface) {
-    const userTail = result[result.length - 1];
-    if (userTail && userTail.role === "user") {
-      result = [
-        ...result.slice(0, -1),
-        injectActiveSurfaceContext(userTail, options.activeSurface),
-      ];
+  if (mode === "full") {
+    // Source the active workspace surface from the live conversation's surface
+    // state rather than from a per-turn option computed by the orchestrator.
+    const surfaceConversation = findConversationOrSubagent(
+      turnCtx.conversationId,
+    );
+    const activeSurface = surfaceConversation
+      ? buildActiveSurfaceContext({
+          currentActiveSurfaceId: surfaceConversation.currentActiveSurfaceId,
+          currentPage: surfaceConversation.currentPage,
+          surfaceState: surfaceConversation.surfaceState,
+        })
+      : null;
+    if (activeSurface) {
+      const userTail = result[result.length - 1];
+      if (userTail && userTail.role === "user") {
+        result = [
+          ...result.slice(0, -1),
+          injectActiveSurfaceContext(userTail, activeSurface),
+        ];
+      }
     }
   }
 
-  if (options.channelCapabilities) {
+  if (channelCapabilities) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [
         ...result.slice(0, -1),
-        injectChannelCapabilityContext(userTail, options.channelCapabilities),
+        injectChannelCapabilityContext(userTail, channelCapabilities),
       ];
     }
   }
 
-  if (mode === "full" && options.channelCommandContext) {
+  if (mode === "full" && channelCommandContext) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [
         ...result.slice(0, -1),
-        injectChannelCommandContext(userTail, options.channelCommandContext),
+        injectChannelCommandContext(userTail, channelCommandContext),
       ];
     }
   }
@@ -2459,14 +2279,14 @@ export async function applyRuntimeInjections(
   if (
     mode === "full" &&
     !slackConversation &&
-    options.transportHints &&
-    options.transportHints.length > 0
+    transportHints &&
+    transportHints.length > 0
   ) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [
         ...result.slice(0, -1),
-        injectTransportHints(userTail, options.transportHints),
+        injectTransportHints(userTail, transportHints),
       ];
     }
   }