@vellumai/assistant 0.8.7 → 0.8.8

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,7 +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,
@@ -35,7 +42,7 @@ 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 type {
   DiskPressureInjectionContext,
   InjectionBlock,
@@ -53,12 +60,18 @@ 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 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.
@@ -271,8 +284,90 @@ 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;
+}
+
+/**
+ * Resolves the `<workspace>` top-level block for the runtime injector, or
+ * `null` when the turn isn't injecting it. The refresh runs every turn so a
+ * workspace-mutating tool's `markWorkspaceTopLevelDirty` is picked up on the
+ * following turn; it is dirty-guarded, so it only rescans when the cache is
+ * stale.
+ */
+export function buildWorkspaceTopLevelContext(
+  ctx: {
+    refreshWorkspaceTopLevelContextIfNeeded(): void;
+    workspaceTopLevelContext: string | null;
+  },
+  shouldInject: boolean,
+): string | null {
+  ctx.refreshWorkspaceTopLevelContextIfNeeded();
+  return shouldInject ? ctx.workspaceTopLevelContext : null;
 }
 
 const MAX_CONTEXT_LENGTH = 100_000;
@@ -315,7 +410,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:");
@@ -514,30 +609,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 +619,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 +970,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 +1655,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 +1702,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 +1718,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;
@@ -2017,44 +1859,6 @@ export interface RuntimeInjectionOptions {
   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;
   /**
@@ -2101,20 +1905,6 @@ export interface RuntimeInjectionOptions {
   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,
@@ -2147,17 +1937,6 @@ function buildTurnInjectionInputs(
     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,
     slackChronologicalMessages: options.slackChronologicalMessages,
@@ -2245,7 +2024,7 @@ export async function applyRuntimeInjections(
     ? { ...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 +2104,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);
   }
 

package/src/daemon/conversation-slash.ts

@@ -14,43 +14,24 @@ import { getVisibleProviderCatalog } from "../providers/provider-catalog-visibil
 export type SlashResolution =
   | { kind: "passthrough"; content: string }
   | { kind: "unknown"; message: string }
-  | { kind: "compact"; targetInputTokensOverride?: number }
+  | { kind: "compact" }
   | { kind: "clean" };
 
-const COMPACT_USAGE_HINT =
-  "Usage: `/compact [<tokens>]` (e.g. `/compact 30000`, `/compact 30k`, `/compact 1m`).";
+type CompactParse = { kind: "compact" } | { kind: "unknown"; message: string };
 
-type CompactParse =
-  | { kind: "compact"; targetInputTokensOverride?: number }
-  | { kind: "unknown"; message: string };
-
-const TOKEN_COUNT_PATTERN = /^(\d+(?:\.\d+)?)([km])?$/i;
 const COMPACT_COMMAND_PATTERN = /^\/compact(?:\s+(.+?))?\s*$/i;
 
-function parseTokenCount(input: string): number | null {
-  const match = input.match(TOKEN_COUNT_PATTERN);
-  if (!match) return null;
-  const value = Number.parseFloat(match[1]);
-  if (!Number.isFinite(value) || value <= 0) return null;
-  const suffix = match[2]?.toLowerCase();
-  const multiplier = suffix === "m" ? 1_000_000 : suffix === "k" ? 1_000 : 1;
-  const tokens = Math.floor(value * multiplier);
-  return tokens > 0 ? tokens : null;
-}
-
 function parseCompactCommand(trimmed: string): CompactParse | null {
   const match = trimmed.match(COMPACT_COMMAND_PATTERN);
   if (!match) return null;
   const rest = match[1]?.trim();
-  if (!rest) return { kind: "compact" };
-  const tokens = parseTokenCount(rest);
-  if (tokens == null) {
+  if (rest) {
     return {
       kind: "unknown",
-      message: `Unrecognized argument to \`/compact\`: \`${rest}\`. ${COMPACT_USAGE_HINT}`,
+      message: `\`/compact\` does not take arguments. Usage: \`/compact\`.`,
     };
   }
-  return { kind: "compact", targetInputTokensOverride: tokens };
+  return { kind: "compact" };
 }
 
 type CleanParse = { kind: "clean" } | { kind: "unknown"; message: string };
@@ -448,7 +429,7 @@ export async function resolveSlash(
     return await resolveModelList();
   }
 
-  // Handle /compact command (with optional `<tokens>` override).
+  // Handle /compact command (summarize history; takes no arguments).
   const compactParse = parseCompactCommand(trimmed);
   if (compactParse) return compactParse;