@vellumai/assistant 0.8.3 → 0.8.4

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

@@ -9,6 +9,7 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
 
 import { type ChannelId, parseInterfaceId } from "../channels/types.js";
+import { getConfig } from "../config/loader.js";
 import { createContextSummaryMessage } from "../context/window-manager.js";
 import { getAppDirPath, listAppFiles } from "../memory/app-store.js";
 import {
@@ -20,15 +21,16 @@ import {
   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 {
+  readSlackMetadata,
+  readSlackMetadataFromMessageMetadata,
+} from "../messaging/providers/slack/message-metadata.js";
 import {
   compareSlackTs,
   extractTagLineTexts,
-  isReactionTagLine,
   isSlackTsAfter,
   type RenderableSlackMessage,
   type RenderedSlackTranscriptMessage,
-  renderSlackTranscript,
   renderSlackTranscriptWithProvenance,
 } from "../messaging/providers/slack/render-transcript.js";
 import { getInjectors } from "../plugins/registry.js";
@@ -48,6 +50,7 @@ import {
 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 { canonicalizeInboundIdentity } from "../util/canonicalize-identity.js";
 import { getWorkspaceDir, getWorkspacePromptPath } from "../util/platform.js";
 import { stripCommentLines } from "../util/strip-comment-lines.js";
 import { filterMessagesForUntrustedActor } from "./conversation-lifecycle.js";
@@ -680,18 +683,19 @@ export function injectChannelCapabilityContext(
       "- Do NOT reference the dashboard UI, settings panels, or visual preference pickers.",
     );
     if (!caps.supportsDynamicUi) {
-      lines.push(
-        "- Do NOT use ui_show, ui_update, or app_create — this channel cannot render them.",
-      );
+      if (caps.channel === "slack") {
+        lines.push(
+          '- Do NOT use app_create. Only use ui_show/ui_update for card surfaces with template: "task_progress"; present all other information as text.',
+        );
+      } else {
+        lines.push(
+          "- Do NOT use ui_show, ui_update, or app_create — this channel cannot render them.",
+        );
+      }
       lines.push(
         "- Present information as well-formatted text instead of dynamic UI.",
       );
     }
-    lines.push(
-      "- Defer dashboard-specific actions (e.g. accent color selection) by telling the user",
-    );
-    lines.push("  they can complete those steps later from the desktop app.");
-
     if (caps.channel === "whatsapp") {
       lines.push(
         "- Do NOT use markdown tables — use bullet lists instead. No markdown headers — use **bold** or CAPS for emphasis.",
@@ -699,10 +703,6 @@ export function injectChannelCapabilityContext(
     }
   }
 
-  if (!caps.supportsVoiceInput) {
-    lines.push("- Do NOT ask the user to use voice or microphone input.");
-  }
-
   // Inject group chat etiquette only when the chat type indicates a multi-party
   // conversation, avoiding misconditioned "stay silent" guidance in 1:1 DMs.
   if (isGroupChatType(caps.chatType)) {
@@ -798,6 +798,13 @@ export interface UnifiedTurnContextOptions {
    * the model can acknowledge long absences; otherwise omitted.
    */
   timeSinceLastMessage?: string | null;
+  /**
+   * Human-readable model profile description. Only populated when the active
+   * inference profile changed since the last turn (or on the first turn of a
+   * conversation) so the model knows which profile/model it is using without
+   * paying per-turn token cost.
+   */
+  modelProfile?: string | null;
 }
 
 /**
@@ -856,6 +863,9 @@ export function buildUnifiedTurnContextBlock(
   if (options.timeSinceLastMessage) {
     lines.push(`time_since_last_message: ${options.timeSinceLastMessage}`);
   }
+  if (options.modelProfile) {
+    lines.push(`model_profile: ${options.modelProfile}`);
+  }
   if (options.interfaceName) {
     lines.push(`interface: ${options.interfaceName}`);
   }
@@ -973,6 +983,9 @@ export function buildUnifiedTurnContextBlock(
     lines.push(
       `response_discretion: Not every message in a channel thread requires your response. If a message is clearly not directed at you (e.g. people talking among themselves, acknowledgements, reactions), output exactly <no_response/> as your entire reply to stay silent.`,
     );
+    if (options.channelName === "slack") {
+      lines.push("if you are going to do work, use task_progress");
+    }
   }
 
   lines.push("</turn_context>");
@@ -1032,17 +1045,6 @@ function injectTransportHints(message: Message, hints: string[]): Message {
   };
 }
 
-function injectSlackRuntimeContextNotice(
-  message: Message,
-  notice: string,
-): Message {
-  const block = `<slack_context_notice>\n${notice}\n</slack_context_notice>`;
-  return {
-    ...message,
-    content: [{ type: "text", text: block }, ...message.content],
-  };
-}
-
 // ---------------------------------------------------------------------------
 // Slack chronological transcript assembly
 // ---------------------------------------------------------------------------
@@ -1111,6 +1113,27 @@ function messageRowsToSlackTranscriptRows(
   }));
 }
 
+function hasSlackMetadata(row: MessageRow): boolean {
+  return (
+    readSlackMetadataFromMessageMetadata(row.metadata, {
+      allowFlatLegacy: true,
+    }) !== null
+  );
+}
+
+function filterSlackConversationRowsForActor(
+  rows: MessageRow[],
+  trustClass: TrustClass | undefined,
+): MessageRow[] {
+  if (!isUntrustedTrustClass(trustClass)) return rows;
+  const nonSlackVisibleRows = filterMessagesForUntrustedActor(rows);
+  const nonSlackVisibleIds = new Set(nonSlackVisibleRows.map((row) => row.id));
+  return rows.filter((row) => {
+    if (hasSlackMetadata(row)) return true;
+    return nonSlackVisibleIds.has(row.id);
+  });
+}
+
 /**
  * Extract the user-facing plain text from an already-parsed `ContentBlock[]`.
  * Only `text` blocks contribute to the rendered transcript line. Tool-use /
@@ -1268,6 +1291,60 @@ function rowToRenderable(row: SlackTranscriptInputRow): RenderableSlackMessage {
   };
 }
 
+const SLACK_ASSISTANT_THREAD_PLACEHOLDER_TEXT = "New Assistant Thread";
+
+function isSlackAssistantThreadPlaceholder(
+  message: RenderableSlackMessage,
+  canonicalConfiguredBotUserId: string | null,
+): boolean {
+  if (!canonicalConfiguredBotUserId) return false;
+  const metadata = message.metadata;
+  if (!metadata || metadata.eventKind !== "message") return false;
+  const actorExternalUserId = metadata.actorExternalUserId?.trim();
+  if (!actorExternalUserId) return false;
+
+  const canonicalActor =
+    canonicalizeInboundIdentity("slack", actorExternalUserId) ??
+    actorExternalUserId;
+  const isThreadRoot =
+    metadata.threadTs === undefined || metadata.threadTs === metadata.channelTs;
+  const hasSlackFiles =
+    Array.isArray(metadata.slackFiles) && metadata.slackFiles.length > 0;
+
+  return (
+    message.role === "user" &&
+    canonicalActor === canonicalConfiguredBotUserId &&
+    isThreadRoot &&
+    !hasSlackFiles &&
+    message.content.replace(/\s+/g, " ").trim() ===
+      SLACK_ASSISTANT_THREAD_PLACEHOLDER_TEXT
+  );
+}
+
+function getCanonicalConfiguredSlackBotUserId(): string | null {
+  const configuredBotUserId = getConfig().slack.botUserId.trim();
+  if (!configuredBotUserId) return null;
+  return (
+    canonicalizeInboundIdentity("slack", configuredBotUserId) ??
+    configuredBotUserId
+  );
+}
+
+function rowsToRenderableSlackMessages(
+  rows: SlackTranscriptInputRow[],
+): RenderableSlackMessage[] {
+  const canonicalConfiguredBotUserId = getCanonicalConfiguredSlackBotUserId();
+  return rows
+    .map(rowToRenderable)
+    .filter(
+      (message) =>
+        !isSlackAssistantThreadPlaceholder(
+          message,
+          canonicalConfiguredBotUserId,
+        ),
+    );
+}
+
 /**
  * Compatibility projection for callers that still need the legacy
  * `Message[] | null` shape. New runtime callers should use
@@ -1363,7 +1440,7 @@ function assembleSlackChronologicalContext(
   if (capabilities.channel !== "slack") {
     return null;
   }
-  const renderable = rows.map(rowToRenderable);
+  const renderable = rowsToRenderableSlackMessages(rows);
   const rendered = renderSlackTranscriptWithProvenance(renderable);
   const contextSummary = options.contextSummary?.trim();
   const renderedMessages = rendered.renderedMessages;
@@ -1372,6 +1449,7 @@ function assembleSlackChronologicalContext(
       {
         message: createContextSummaryMessage(contextSummary),
         sourceChannelTs: null,
+        tagLineProvenance: "none",
       },
       ...renderedMessages,
     ];
@@ -1392,11 +1470,10 @@ function assembleSlackChronologicalContext(
  * Compatibility wrapper over `loadSlackChronologicalContext` for callers that
  * still need only the legacy `Message[] | null` projection.
  *
- * 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.
+ * When `trustClass` identifies an untrusted actor, non-Slack/private rows
+ * are passed through the default trust filter. Slack-tagged rows stay visible
+ * because the transcript is scoped to the external Slack chat/thread, which
+ * the inbound actor can already read in Slack.
  *
  * Returns `null` when the channel is not Slack — callers should fall
  * through to the default in-memory message history.
@@ -1445,9 +1522,10 @@ export function loadSlackChronologicalContext(
   }
   const loader = options.loader ?? defaultGetMessages;
   const allRows = loader(conversationId);
-  const scopedRows = isUntrustedTrustClass(options.trustClass)
-    ? filterMessagesForUntrustedActor(allRows)
-    : allRows;
+  const scopedRows = filterSlackConversationRowsForActor(
+    allRows,
+    options.trustClass,
+  );
   const rows = filterRowsAfterSlackCompactionBoundary(
     messageRowsToSlackTranscriptRows(scopedRows),
     options,
@@ -1555,29 +1633,29 @@ function buildActiveThreadBlockFromRenderable(
   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.
+  // `Message.role`. Assistant rows that render content-only are relabeled in
+  // the post-render step. Timezone-aware assistant rows are already
+  // bracket-tagged by the renderer and must not receive another prefix.
+  // 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)
+  const rendered = renderSlackTranscriptWithProvenance(labeledMembers);
+  if (rendered.renderedMessages.length === 0) return null;
+  // Reaction / overflow-trailer lines are renderer-owned Slack event lines,
+  // and timezone-aware assistant rows already carry metadata-backed compact
+  // attribution. Regular assistant content and the `[deleted]` sentinel get
+  // the prefix so attribution survives flattening.
+  const lines = rendered.renderedMessages
+    .map((entry) => {
+      const text = extractTagLineTexts([entry.message])[0] ?? "";
+      return entry.message.role === "assistant" &&
+        entry.tagLineProvenance === "none"
         ? `@assistant: ${text}`
         : text;
     })
@@ -1605,7 +1683,7 @@ export function assembleSlackActiveThreadFocusBlock(
   // 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 renderable = rowsToRenderableSlackMessages(rows);
   const activeThreadTs = detectActiveThreadTs(renderable);
   if (!activeThreadTs) return null;
   return buildActiveThreadBlockFromRenderable(renderable, activeThreadTs);
@@ -1631,9 +1709,10 @@ export function loadSlackActiveThreadFocusBlock(
   if (capabilities.chatType !== "channel") return null;
   const loader = options.loader ?? defaultGetMessages;
   const allRows = loader(conversationId);
-  const scopedRows = isUntrustedTrustClass(options.trustClass)
-    ? filterMessagesForUntrustedActor(allRows)
-    : allRows;
+  const scopedRows = filterSlackConversationRowsForActor(
+    allRows,
+    options.trustClass,
+  );
   const rows = filterRowsAfterSlackCompactionBoundary(
     messageRowsToSlackTranscriptRows(scopedRows),
     options,
@@ -1681,7 +1760,6 @@ const RUNTIME_INJECTION_PREFIXES = [
   "<pkb>", // backward-compat: strip legacy tag from pre-rename history
   "<system_reminder>",
   "<transport_hints>",
-  "<slack_context_notice>",
   // 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.
@@ -1975,7 +2053,6 @@ export interface RuntimeInjectionOptions {
    */
   isBackgroundConversation?: boolean;
   transportHints?: string[] | null;
-  slackRuntimeContextNotice?: string | null;
   /**
    * Pre-rendered Slack chronological transcript that replaces the
    * default `runMessages` history for any Slack conversation (channels
@@ -2316,23 +2393,6 @@ export async function applyRuntimeInjections(
     }
   }
 
-  if (
-    mode === "full" &&
-    slackConversation &&
-    options.slackRuntimeContextNotice
-  ) {
-    const userTail = result[result.length - 1];
-    if (userTail && userTail.role === "user") {
-      result = [
-        ...result.slice(0, -1),
-        injectSlackRuntimeContextNotice(
-          userTail,
-          options.slackRuntimeContextNotice,
-        ),
-      ];
-    }
-  }
-
   if (mode === "full" && options.channelCommandContext) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {

package/src/daemon/conversation-slash.ts

@@ -14,7 +14,8 @@ import { getVisibleProviderCatalog } from "../providers/provider-catalog-visibil
 export type SlashResolution =
   | { kind: "passthrough"; content: string }
   | { kind: "unknown"; message: string }
-  | { kind: "compact"; targetInputTokensOverride?: number };
+  | { kind: "compact"; targetInputTokensOverride?: number }
+  | { kind: "clean" };
 
 const COMPACT_USAGE_HINT =
   "Usage: `/compact [<tokens>]` (e.g. `/compact 30000`, `/compact 30k`, `/compact 1m`).";
@@ -52,6 +53,23 @@ function parseCompactCommand(trimmed: string): CompactParse | null {
   return { kind: "compact", targetInputTokensOverride: tokens };
 }
 
+type CleanParse = { kind: "clean" } | { kind: "unknown"; message: string };
+
+const CLEAN_COMMAND_PATTERN = /^\/clean(?:\s+(.+?))?\s*$/i;
+
+function parseCleanCommand(trimmed: string): CleanParse | null {
+  const match = trimmed.match(CLEAN_COMMAND_PATTERN);
+  if (!match) return null;
+  const rest = match[1]?.trim();
+  if (rest) {
+    return {
+      kind: "unknown",
+      message: `\`/clean\` does not take arguments. Usage: \`/clean\`.`,
+    };
+  }
+  return { kind: "clean" };
+}
+
 // ── /context and /status commands ────────────────────────────────────
 
 export interface SlashContext {
@@ -302,10 +320,14 @@ function resolveStatusCommand(context: SlashContext): SlashResolution {
   return { kind: "unknown", message: lines.join("\n") };
 }
 
+const CLEAN_HELP_LINE =
+  "/clean — Strip injected runtime context and reset memory injection state (no summarization)";
+
 function resolveCommandsList(context?: SlashContext): string[] {
   const fallbackLines = [
     "/commands — List all available commands",
     "/compact — Force context compaction immediately",
+    CLEAN_HELP_LINE,
   ];
   if (context) {
     fallbackLines.push("/context — Show conversation context usage");
@@ -322,6 +344,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
     return [
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      CLEAN_HELP_LINE,
       "/context — Show conversation context usage",
       "/model — List or switch inference profile",
       "/models — List all available models",
@@ -335,6 +358,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
     return [
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      CLEAN_HELP_LINE,
       "/context — Show conversation context usage",
       "/model — List or switch inference profile",
       "/models — List all available models",
@@ -347,6 +371,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
   return [
     "/commands — List all available commands",
     "/compact — Force context compaction immediately",
+    CLEAN_HELP_LINE,
     "/context — Show conversation context usage",
     "/model — List or switch inference profile",
     "/models — List all available models",
@@ -366,7 +391,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
  */
 export function classifySlash(
   content: string,
-): "passthrough" | "compact" | "unknown" {
+): "passthrough" | "compact" | "clean" | "unknown" {
   const trimmed = content.trim();
   if (parseModelCommand(trimmed) != null) {
     return "unknown";
@@ -381,6 +406,8 @@ export function classifySlash(
   if (trimmed === "/models") return "unknown";
   const compactParse = parseCompactCommand(trimmed);
   if (compactParse) return compactParse.kind;
+  const cleanParse = parseCleanCommand(trimmed);
+  if (cleanParse) return cleanParse.kind;
   if (trimmed === "/context") return "unknown";
   if (trimmed === "/status") return "unknown";
   if (trimmed === "/commands") return "unknown";
@@ -388,9 +415,10 @@ export function classifySlash(
 }
 
 /**
- * Resolve built-in slash commands (/models, /context, /status, /commands, /compact).
- * Returns `unknown` with a deterministic message, `compact` for forced compaction,
- * or the (possibly rewritten) content as `passthrough`.
+ * Resolve built-in slash commands (/models, /context, /status, /commands,
+ * /compact, /clean). Returns `unknown` with a deterministic message,
+ * `compact` for forced compaction, `clean` for injection stripping, or the
+ * (possibly rewritten) content as `passthrough`.
  */
 export async function resolveSlash(
   content: string,
@@ -424,6 +452,10 @@ export async function resolveSlash(
   const compactParse = parseCompactCommand(trimmed);
   if (compactParse) return compactParse;
 
+  // Handle /clean command (strip injections, no summarization).
+  const cleanParse = parseCleanCommand(trimmed);
+  if (cleanParse) return cleanParse;
+
   // Handle /context and legacy /status commands
   if (trimmed === "/context" || trimmed === "/status") {
     if (!context) {

package/src/daemon/conversation-surfaces.ts

@@ -390,6 +390,40 @@ function normalizeTaskProgressCardPatch(
   return normalizedPatch;
 }
 
+function isTaskProgressCardData(data: SurfaceData | Record<string, unknown>) {
+  return (data as Record<string, unknown>).template === "task_progress";
+}
+
+function isSlackTaskProgressUiException(
+  ctx: SurfaceConversationContext,
+  toolName: string,
+  input: Record<string, unknown>,
+): boolean {
+  if (ctx.channelCapabilities?.channel !== "slack") return false;
+  if (toolName === "ui_show") {
+    const surfaceType = input.surface_type as SurfaceType;
+    if (surfaceType !== "card") return false;
+    const rawData = isPlainObject(input.data) ? input.data : {};
+    const data = normalizeCardShowData(input, rawData);
+    return isTaskProgressCardData(data);
+  }
+  if (toolName === "ui_update") {
+    const surfaceId = input.surface_id;
+    if (typeof surfaceId !== "string") return false;
+    const stored = ctx.surfaceState.get(surfaceId);
+    if (!stored || stored.surfaceType !== "card") return false;
+    if (!isTaskProgressCardData(stored.data)) return false;
+    const rawPatch = isPlainObject(input.data) ? input.data : {};
+    const patch = normalizeTaskProgressCardPatch(
+      stored.data as CardSurfaceData,
+      rawPatch,
+    );
+    const mergedData = { ...stored.data, ...patch } as SurfaceData;
+    return isTaskProgressCardData(mergedData);
+  }
+  return false;
+}
+
 /**
  * Subset of Conversation state that surface helpers need access to.
  * The Conversation class implements this interface so its instances can be
@@ -1638,7 +1672,12 @@ export async function handleSurfaceAction(
   // One-shot interactive surfaces — auto-complete now that the message has
   // been accepted. Deferred until after rejection check so the surface stays
   // active and retryable if the queue was full.
-  const ONE_SHOT_SURFACE_TYPES = ["form", "confirmation", "file_upload"];
+  const ONE_SHOT_SURFACE_TYPES = [
+    "form",
+    "confirmation",
+    "file_upload",
+    "task_preferences",
+  ];
   if (ONE_SHOT_SURFACE_TYPES.includes(pending.surfaceType)) {
     broadcastMessage({
       type: "ui_surface_complete",
@@ -2135,7 +2174,11 @@ export async function surfaceProxyResolver(
 
   if (toolName === "ui_show" || toolName === "ui_update") {
     const caps = ctx.channelCapabilities;
-    if (caps && !caps.supportsDynamicUi) {
+    if (
+      caps &&
+      !caps.supportsDynamicUi &&
+      !isSlackTaskProgressUiException(ctx, toolName, input)
+    ) {
       log.info(
         { toolName, channel: caps.channel, conversationId: ctx.conversationId },
         "Blocked UI surface tool on channel without dynamic UI support",

package/src/daemon/conversation-tool-setup.ts

@@ -331,6 +331,7 @@ export interface SkillProjectionContext {
 // ── Conditional tool sets ────────────────────────────────────────────
 
 const UI_SURFACE_TOOL_NAMES = new Set(["ui_show", "ui_update", "ui_dismiss"]);
+const SLACK_TASK_PROGRESS_UI_TOOL_NAMES = new Set(["ui_show", "ui_update"]);
 /**
  * Single source of truth for which tools are host tools and the capability
  * each one requires from the connected client interface. Adding a tool here
@@ -437,6 +438,12 @@ export function isToolActiveForContext(
     return false;
   }
   if (UI_SURFACE_TOOL_NAMES.has(name)) {
+    if (
+      ctx.channelCapabilities?.channel === "slack" &&
+      SLACK_TASK_PROGRESS_UI_TOOL_NAMES.has(name)
+    ) {
+      return !ctx.hasNoClient;
+    }
     return ctx.channelCapabilities?.supportsDynamicUi ?? !ctx.hasNoClient;
   }
   if (HOST_TOOL_NAMES.has(name)) {

package/src/daemon/conversation.ts

@@ -53,6 +53,7 @@ import {
   getConversation,
   getConversationOriginChannel,
   getConversationOverrideProfileFromRow,
+  setConversationCleanedAt,
 } from "../memory/conversation-crud.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import { shouldExposePersonalMemory } from "../memory/v2/static-context.js";
@@ -104,6 +105,7 @@ import {
   type ChannelCapabilities,
   getSlackCompactionWatermarkForPrefix,
   loadSlackChronologicalContext,
+  stripInjectionsForCompaction,
 } from "./conversation-runtime-assembly.js";
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
 import {
@@ -142,6 +144,13 @@ import { TraceEmitter } from "./trace-emitter.js";
 
 const log = getLogger("conversation");
 
+export interface CleanResult {
+  previousEstimatedInputTokens: number;
+  estimatedInputTokens: number;
+  maxInputTokens: number;
+  preservedMessages: number;
+}
+
 export { findLastUndoableUserMessageIndex } from "./conversation-history.js";
 export type {
   QueueDrainReason,
@@ -240,7 +249,6 @@ export class Conversation {
   /** @internal */ loadedHistoryPersonalMemoryAllowed?: boolean;
   /** @internal */ voiceCallControlPrompt?: string;
   /** @internal */ transportHints?: string[];
-  /** @internal */ slackRuntimeContextNotice?: string;
   /** @internal */ assistantId?: string;
   /** @internal */ commandIntent?: {
     type: string;
@@ -249,6 +257,13 @@ export class Conversation {
   };
   /** @internal */ surfaceActionRequestIds = new Set<string>();
   /** @internal */ approvedViaPromptThisTurn = false;
+  /**
+   * Set by `steerToMessage` to signal the drain path that it should inject
+   * synthetic tool_result messages for any pending tool_use blocks abandoned
+   * by the aborted generation. Cleared after repair.
+   * @internal
+   */
+  pendingSteerRepair = false;
   /**
    * When true, side-effect tools must prompt even if a trust/allow rule
    * would auto-allow. Set by non-interactive callers (e.g. non-guardian
@@ -1126,6 +1141,32 @@ export class Conversation {
     return result;
   }
 
+  /**
+   * Strip stale runtime injections from the message history and reset the
+   * memory-injection ledger without summarizing any history. Mirrors the
+   * non-LLM side effects of `forceCompact`: the next turn re-injects fresh
+   * NOW.md / knowledge-base / memory-v2 static blocks, and per-turn memory
+   * activations are no longer deduped against the prior session.
+   */
+  async forceClean(): Promise<CleanResult> {
+    const previousEstimatedInputTokens =
+      this.contextWindowManager.estimateInputTokens(this.messages);
+    const stripped = stripInjectionsForCompaction(this.messages);
+    this.messages = stripped;
+    await this.graphMemory.onCompacted(0);
+    this.pendingPostCompactReinject = true;
+    setConversationCleanedAt(this.conversationId, Date.now());
+    const estimatedInputTokens = this.contextWindowManager.estimateInputTokens(
+      this.messages,
+    );
+    return {
+      previousEstimatedInputTokens,
+      estimatedInputTokens,
+      maxInputTokens: this.contextWindowManager.maxInputTokens,
+      preservedMessages: this.messages.length,
+    };
+  }
+
   setChannelCapabilities(caps: ChannelCapabilities | null): void {
     this.channelCapabilities = caps ?? undefined;
     this.secretPrompter.setChannelContext(
@@ -1158,10 +1199,6 @@ export class Conversation {
     this.transportHints = hints;
   }
 
-  setSlackRuntimeContextNotice(notice: string | undefined): void {
-    this.slackRuntimeContextNotice = notice;
-  }
-
   /**
    * Apply client-reported host environment (home dir, username) from
    * transport metadata onto the conversation. Only interfaces whose