@vellumai/assistant 0.9.0 → 0.10.0-staging.2

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

@@ -9,9 +9,9 @@ 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 { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
+import { isMemoryV3Live } from "../config/memory-v3-gate.js";
 import type { LLMCallSite, LLMConfig } from "../config/schemas/llm.js";
 import {
   NOW_SCRATCHPAD_STRIP_PREFIXES,
@@ -62,11 +62,11 @@ import type {
 import type { ContentBlock, Message } from "../providers/types.js";
 import {
   type ActorTrustContext,
-  isUntrustedTrustClass,
   resolveActorTrust,
   type TrustClass,
 } from "../runtime/actor-trust-resolver.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { resolveCapabilities } from "../runtime/capabilities.js";
 import { channelStatusToMemberStatus } from "../runtime/routes/inbound-stages/acl-enforcement.js";
 import { getSubagentManager } from "../subagent/index.js";
 import type { SubagentState } from "../subagent/types.js";
@@ -125,8 +125,8 @@ export interface InboundActorContext {
   actorSenderDisplayName?: string;
   /** Guardian-managed display name from the contact record. */
   actorMemberDisplayName?: string;
-  /** Trust classification: guardian, trusted_contact, or unknown. */
-  trustClass: "guardian" | "trusted_contact" | "unknown";
+  /** Trust classification: see TrustClass. */
+  trustClass: TrustClass;
   /** Guardian identity for this (assistant, channel) binding. */
   guardianIdentity?: string;
   /** Member status when the actor has a contact record. */
@@ -916,7 +916,7 @@ function filterSlackConversationRowsForActor(
   rows: MessageRow[],
   trustClass: TrustClass | undefined,
 ): MessageRow[] {
-  if (!isUntrustedTrustClass(trustClass)) return rows;
+  if (resolveCapabilities(trustClass).canAccessMemory) return rows;
   const nonSlackVisibleRows = filterMessagesForUntrustedActor(rows);
   const nonSlackVisibleIds = new Set(nonSlackVisibleRows.map((row) => row.id));
   return rows.filter((row) => {
@@ -1009,6 +1009,7 @@ function rowToRenderable(row: SlackTranscriptInputRow): RenderableSlackMessage {
       if (
         outer.provenanceTrustClass === "guardian" ||
         outer.provenanceTrustClass === "trusted_contact" ||
+        outer.provenanceTrustClass === "unverified_contact" ||
         outer.provenanceTrustClass === "unknown"
       ) {
         provenanceTrustClass = outer.provenanceTrustClass;
@@ -1322,9 +1323,9 @@ export function loadSlackChronologicalContext(
     options,
   );
   return assembleSlackChronologicalContext(rows, capabilities, {
-    contextSummary: isUntrustedTrustClass(options.trustClass)
-      ? null
-      : options.contextSummary,
+    contextSummary: resolveCapabilities(options.trustClass).canAccessMemory
+      ? options.contextSummary
+      : null,
   });
 }
 
@@ -1536,8 +1537,8 @@ export interface RuntimeInjectionBlocks {
    */
   memoryV3InjectedBlock?: string;
   /**
-   * True when memory-v3 superseded v2 as this turn's `<memory>` source — the
-   * `memory-v3-live` flag is on AND the v3 injector produced a block (possibly
+   * True when memory-v3 superseded v2 as this turn's `<memory>` source —
+   * `memory.v3.live` is on AND the v3 injector produced a block (possibly
    * empty-text on an all-repeat turn), i.e. exactly when assembly stripped
    * v2's fresh tail block. The user-prompt-submit hook keys v2's
    * `memoryInjectedBlock` metadata persist off this so a stripped v2 block is
@@ -2177,7 +2178,7 @@ export async function applyRuntimeInjections(
   // no-op, keeping the v2 path bit-for-bit identical.
   let runMessagesForAssembly = stripSpotlightInjections(runMessages);
 
-  // v2 suppression: when the `memory-v3-live` flag is on AND the v3 injector
+  // v2 suppression: when `memory.v3.live` is on AND the v3 injector
   // produced a block this turn (possibly empty-text on an all-repeat turn), v3
   // owns the `<memory>` layer. v2's `prepareMemory` already prepended its own
   // fresh `<memory>` block to the tail user message — strip the TAIL's v2
@@ -2196,10 +2197,7 @@ export async function applyRuntimeInjections(
   // (`produce()` → null) leaves v2's block intact — fallback rather than a
   // memory-less turn. Idempotent: re-injection sites that already stripped
   // see no change. Flag off → bit-for-bit identical to the v2 path.
-  const suppressV2MemoryForV3 = isAssistantFeatureFlagEnabled(
-    "memory-v3-live",
-    getConfig(),
-  );
+  const suppressV2MemoryForV3 = isMemoryV3Live(getConfig());
   const v3ProducedBlock = afterMemory.some((b) => b.id === MEMORY_V3_BLOCK_ID);
   const memoryV3Active = suppressV2MemoryForV3 && v3ProducedBlock;
   if (memoryV3Active) {

package/src/daemon/conversation-slash.ts

@@ -7,6 +7,7 @@ import {
   loadRawConfig,
   saveRawConfig,
 } from "../config/loader.js";
+import { orderProfileKeys } from "../config/profile-order.js";
 import { getConversationOverrideProfile } from "../memory/conversation-crud.js";
 import { getConfiguredProviders } from "../providers/provider-availability.js";
 import { getVisibleProviderCatalog } from "../providers/provider-catalog-visibility.js";
@@ -130,28 +131,6 @@ function parseModelCommand(trimmed: string): ModelCommandParse | null {
   return { kind: "switch", profileName: rest };
 }
 
-function orderedProfileNames(
-  profiles: Record<
-    string,
-    { label?: string; description?: string; status?: "active" | "disabled" }
-  >,
-  profileOrder: readonly string[] | undefined,
-): string[] {
-  const order = profileOrder ?? [];
-  const seen = new Set<string>();
-  const ordered: string[] = [];
-  for (const name of order) {
-    if (profiles[name] != null && !seen.has(name)) {
-      ordered.push(name);
-      seen.add(name);
-    }
-  }
-  const tail = Object.keys(profiles)
-    .filter((n) => !seen.has(n))
-    .sort();
-  return [...ordered, ...tail];
-}
-
 async function resolveModelCommand(
   parse: ModelCommandParse,
 ): Promise<SlashResolution> {
@@ -160,7 +139,7 @@ async function resolveModelCommand(
     string,
     { label?: string; description?: string; status?: "active" | "disabled" }
   >;
-  const profileNames = orderedProfileNames(profiles, config.llm.profileOrder);
+  const profileNames = orderProfileKeys(profiles, config.llm.profileOrder);
   const activeProfile = config.llm.activeProfile;
 
   if (parse.kind === "list") {

package/src/daemon/conversation-surfaces.ts

@@ -291,6 +291,32 @@ export function markSurfaceCompleted(
   }
 }
 
+/**
+ * Complete a `ui_surface` card and notify live clients, addressed only by
+ * conversation + surface id.
+ *
+ * Unlike {@link completeSurfaceFromAction}, this needs no live `Conversation`
+ * instance, so it can run from flows that don't own one — projecting a
+ * terminal guardian-request status onto its in-app approval card when the
+ * request was resolved on another surface (or by the expiry sweep). Persists
+ * the completion (reload-safe) and broadcasts `ui_surface_complete` so every
+ * connected client of this guardian converges. No-ops when the surface block
+ * isn't found in the conversation.
+ */
+export function completeSurfaceAndNotify(
+  conversationId: string,
+  surfaceId: string,
+  summary: string,
+): void {
+  markSurfaceCompleted({ conversationId }, surfaceId, summary);
+  broadcastMessage({
+    type: "ui_surface_complete",
+    conversationId,
+    surfaceId,
+    summary,
+  });
+}
+
 /**
  * Remove a `ui_surface` content block from history so a passively dismissed
  * surface does not survive a reload. The live client drops a dismissed surface

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

@@ -26,7 +26,10 @@ import {
   ACTIVITY_SKIP_SET,
   injectActivityField,
 } from "../tools/schema-transforms.js";
-import { resolveSkillExecuteInput } from "../tools/skills/execute.js";
+import {
+  augmentSkillExecuteError,
+  resolveSkillExecuteInput,
+} from "../tools/skills/execute.js";
 import { resolveToolInvocationAlias } from "../tools/tool-name-aliases.js";
 import {
   isDiskPressureCleanupToolName,
@@ -52,7 +55,7 @@ import {
 } from "./doordash-steps.js";
 import type { ServerMessage, UiSurfaceShow } from "./message-protocol.js";
 import { runPostExecutionSideEffects } from "./tool-side-effects.js";
-import { resolveTrustClass } from "./trust-context.js";
+import { FALLBACK_TURN_TRUST, resolveTrustClass } from "./trust-context.js";
 
 const log = getLogger("conversation-tool-setup");
 
@@ -178,28 +181,32 @@ export function createToolExecutor(
       markDoordashStepInProgress(ctx, executionInput);
     }
 
-    // Build the context object shared by both the skill_execute interception
-    // path and the regular executor path.
+    // Per-turn trust snapshot: prefer the snapshot captured at turn start so
+    // a concurrent owner meta command (/status, /clean) that mutates the live
+    // trustContext cannot elevate the in-flight turn to guardian.
+    const turnTrust =
+      ctx.currentTurnTrustContext ?? ctx.trustContext ?? FALLBACK_TURN_TRUST;
+
     const toolContext: ToolContext = {
       workingDir: ctx.workingDir,
       conversationId: ctx.conversationId,
       assistantId: ctx.assistantId,
       requestId: ctx.currentRequestId,
       taskRunId: ctx.taskRunId,
-      trustClass: resolveTrustClass(ctx.trustContext),
-      executionChannel: ctx.trustContext?.sourceChannel,
-      sourceActorPrincipalId: ctx.trustContext?.guardianPrincipalId,
+      trustClass: resolveTrustClass(turnTrust),
+      executionChannel: turnTrust.sourceChannel,
+      sourceActorPrincipalId: turnTrust.guardianPrincipalId,
       callSessionId: ctx.callSessionId,
       triggeredBySurfaceAction:
         ctx.surfaceActionRequestIds?.has(ctx.currentRequestId ?? "") ?? false,
       approvedViaPrompt: ctx.approvedViaPromptThisTurn || undefined,
       batchAuthorizedByTask: false,
-      requesterExternalUserId: ctx.trustContext?.requesterExternalUserId,
-      requesterChatId: ctx.trustContext?.requesterChatId,
-      requesterIdentifier: ctx.trustContext?.requesterIdentifier,
-      requesterDisplayName: ctx.trustContext?.requesterDisplayName,
+      requesterExternalUserId: turnTrust.requesterExternalUserId,
+      requesterChatId: turnTrust.requesterChatId,
+      requesterIdentifier: turnTrust.requesterIdentifier,
+      requesterDisplayName: turnTrust.requesterDisplayName,
       channelPermissionChannelId:
-        ctx.trustContext?.sourceChannel === "slack"
+        turnTrust.sourceChannel === "slack"
           ? getBindingByConversation(ctx.conversationId)?.externalChatId
           : undefined,
       onOutput,
@@ -211,6 +218,7 @@ export function createToolExecutor(
       isPlatformHosted: getIsPlatform(),
       transportInterface: ctx.transportInterface,
       overrideProfile: ctx.currentTurnOverrideProfile,
+      invokingCallSite: ctx.currentCallSite ?? "mainAgent",
       attribution: resolveConversationAttribution(ctx),
       onToolLifecycleEvent: handleToolLifecycleEvent,
       sendToClient: (msg) => {
@@ -320,7 +328,12 @@ export function createToolExecutor(
       const innerRejection = rejectNonAllowlistedTool(toolName);
       if (innerRejection) return innerRejection;
 
-      const result = await executor.execute(toolName, toolInput, toolContext);
+      const rawResult = await executor.execute(
+        toolName,
+        toolInput,
+        toolContext,
+      );
+      const result = augmentSkillExecuteError(toolName, toolInput, rawResult);
       if (toolContext.approvedViaPrompt) {
         ctx.approvedViaPromptThisTurn = true;
       }
@@ -371,7 +384,7 @@ export function createProxyApprovalCallback(
  * history or explicit preactivation. Without this, their tools are
  * unavailable in fresh conversations until `skill_load` is called.
  */
-const DEFAULT_PREACTIVATED_SKILL_IDS = ["tasks", "notifications", "subagent"];
+const DEFAULT_PREACTIVATED_SKILL_IDS = ["notifications", "subagent"];
 
 /**
  * Subset of Conversation state that the resolveTools callback reads at each

package/src/daemon/conversation.ts

@@ -80,12 +80,10 @@ import {
 } from "../prompts/system-prompt.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
-import {
-  isUntrustedTrustClass,
-  type TrustClass,
-} from "../runtime/actor-trust-resolver.js";
+import { type TrustClass } from "../runtime/actor-trust-resolver.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import type { AuthContext } from "../runtime/auth/types.js";
+import { resolveCapabilities } from "../runtime/capabilities.js";
 import type { InteractiveUiResult } from "../runtime/interactive-ui.js";
 import { publishSyncInvalidation } from "../runtime/sync/sync-publisher.js";
 import {
@@ -107,7 +105,7 @@ import {
   runAgentLoopImpl,
 } from "./conversation-agent-loop.js";
 import type { HistoryConversationContext } from "./conversation-history.js";
-import { undo as undoImpl } from "./conversation-history.js";
+import { isToolResultBlock, undo as undoImpl } from "./conversation-history.js";
 import {
   abortConversation,
   disposeConversation,
@@ -175,6 +173,36 @@ import { TraceEmitter } from "./trace-emitter.js";
 
 const log = getLogger("conversation");
 
+/**
+ * Whether a persisted message starts a new conversation turn. A turn is
+ * delimited by a "real" user message; a user message whose content is entirely
+ * tool_result blocks is a continuation within the current turn, and assistant
+ * messages never start one. Mirrors the turn-boundary definition used by
+ * `getAssistantMessageIdsInTurn`/`getTurnTimeBounds` and the agent loop's
+ * per-turn `turnCount++`, so counting these reconstructs `turnCount` on load.
+ */
+function startsNewTurn(role: string, content: string): boolean {
+  if (role !== "user") return false;
+  try {
+    const parsed = JSON.parse(content);
+    if (
+      Array.isArray(parsed) &&
+      parsed.length > 0 &&
+      parsed.every(
+        (block: unknown) =>
+          block != null &&
+          typeof block === "object" &&
+          isToolResultBlock(block as Record<string, unknown>),
+      )
+    ) {
+      return false;
+    }
+  } catch {
+    // Non-JSON content is a plain user message — a turn boundary.
+  }
+  return true;
+}
+
 export interface CleanResult {
   previousEstimatedInputTokens: number;
   estimatedInputTokens: number;
@@ -366,6 +394,13 @@ export class Conversation {
     workspaceDir: string,
   ) => Pick<WorkspaceGitService, "ensureInitialized">;
   /** @internal */ commitTurnChanges?: typeof commitTurnChanges;
+  /**
+   * Abort-watchdog timeout (ms) for the agent loop's bounded-unwind backstop.
+   * Overridable in tests to fire the watchdog quickly; defaults to the
+   * production constant in the agent loop when unset.
+   * @internal
+   */
+  abortWatchdogMs?: number;
   /**
    * The conversation's immutable creation type (`interactive`, `background`,
    * `scheduled`, …) as stored on the DB row. Cached on load (and set directly
@@ -824,10 +859,25 @@ export class Conversation {
 
   async loadFromDb(): Promise<void> {
     const trustClass = this.trustContext?.trustClass;
+    const canAccessMemory = resolveCapabilities(trustClass).canAccessMemory;
     const allDbMessages = getMessages(this.conversationId);
-    const dbMessages = isUntrustedTrustClass(trustClass)
-      ? filterMessagesForUntrustedActor(allDbMessages)
-      : allDbMessages;
+    const dbMessages = canAccessMemory
+      ? allDbMessages
+      : filterMessagesForUntrustedActor(allDbMessages);
+
+    // Rehydrate the in-memory turn counter from persisted history. `turnCount`
+    // is otherwise a fresh-zero field, so a reloaded conversation (eviction,
+    // restart, fork) would restart its turn numbering at 0 and the next turn
+    // would reuse `turnIndex` 0 — colliding with the conversation's first turn.
+    // The memory-v3 selector memoizes per (conversationId, turnIndex) for the
+    // life of the daemon process, so a collided turnIndex serves a stale
+    // selection and skips retrieval. One turn per real (turn-starting) user
+    // message, matching the agent loop's per-turn `turnCount++`. Counted from
+    // the full unsliced history so it survives compaction and is independent of
+    // the viewer's trust class.
+    this.turnCount = allDbMessages.filter((m) =>
+      startsNewTurn(m.role, m.content),
+    ).length;
 
     const conv = getConversation(this.conversationId);
     this.conversationType = conv?.conversationType ?? undefined;
@@ -855,12 +905,12 @@ export class Conversation {
     // than exist. Slack chronological context is a separate consumer that
     // applies its own trust filtering downstream, so it reads the raw
     // mirrored count rather than this in-context boundary.
-    const inContextCompactedCount = isUntrustedTrustClass(trustClass)
-      ? 0
-      : Math.min(this.contextCompactedMessageCount, dbMessages.length);
-    const contextSummaryForHistory = isUntrustedTrustClass(trustClass)
-      ? null
-      : this.contextSummary?.trim() || null;
+    const inContextCompactedCount = canAccessMemory
+      ? Math.min(this.contextCompactedMessageCount, dbMessages.length)
+      : 0;
+    const contextSummaryForHistory = canAccessMemory
+      ? this.contextSummary?.trim() || null
+      : null;
 
     // Every injection-strip event (`/clean` or compaction) updates
     // `historyStrippedAt`. Messages older than this should skip metadata
@@ -1847,6 +1897,8 @@ export class Conversation {
        * this value via {@link SubagentManager.spawn}.
        */
       overrideProfile?: string;
+      /** Float `overrideProfile` above call-site layers for this run. */
+      forceOverrideProfile?: boolean;
     },
   ): Promise<void> {
     const { onEvent, ...rest } = options ?? {};

package/src/daemon/disk-pressure-policy.ts

@@ -1,5 +1,6 @@
 import type { InterfaceId } from "../channels/types.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
+import { resolveCapabilities } from "../runtime/capabilities.js";
 import type { DiskPressureStatus } from "./disk-pressure-guard.js";
 import type { ConversationType } from "./message-types/shared.js";
 import type { TrustContext } from "./trust-context.js";
@@ -74,11 +75,11 @@ export function classifyDiskPressureTurnPolicy(
   }
 
   const trustClass = metadata.trustContext?.trustClass;
-  if (trustClass === "guardian") {
+  if (resolveCapabilities(trustClass).canActUnderDiskPressureCleanup) {
     return { action: "allow-cleanup-mode", reason: "guardian" };
   }
 
-  if (trustClass === "trusted_contact") {
+  if (trustClass === "trusted_contact" || trustClass === "unverified_contact") {
     return { action: "block", reason: "trusted-contact" };
   }
 
@@ -156,6 +157,7 @@ function isExplicitLocalOwnerCleanupTurn(
   }
   return (
     metadata.trustContext == null ||
-    metadata.trustContext.trustClass === "guardian"
+    resolveCapabilities(metadata.trustContext.trustClass)
+      .canActUnderDiskPressureCleanup
   );
 }

package/src/daemon/handlers/__tests__/config-a2a-complete.test.ts

@@ -121,7 +121,6 @@ describe("completeA2AInvite", () => {
     const invite = findById(created.inviteId!);
     const contact = getContact(invite!.contactId);
     expect(contact!.channels[0]!.address).toBe("upper-case-id-123");
-    expect(contact!.channels[0]!.externalUserId).toBe("UPPER-Case-ID-123");
   });
 
   test("assistantContactMetadata has correct assistantId and gatewayUrl", () => {

package/src/daemon/handlers/__tests__/config-a2a-redeem.test.ts

@@ -120,7 +120,6 @@ describe("redeemA2AInvite", () => {
 
     const contact = getContact(result.contactId!);
     expect(contact!.channels[0]!.address).toBe("upper-case-sender-id");
-    expect(contact!.channels[0]!.externalUserId).toBe("UPPER-Case-SENDER-ID");
   });
 
   test("does not make outbound fetch calls", () => {

package/src/daemon/handlers/config-a2a.ts

@@ -221,7 +221,6 @@ export function completeA2AInvite(params: {
       {
         type: "a2a",
         address: params.acceptor.assistantId.toLowerCase(),
-        externalUserId: params.acceptor.assistantId,
         status: "active",
         policy: "allow",
       },
@@ -289,7 +288,6 @@ export function redeemA2AInvite(params: {
       {
         type: "a2a",
         address: params.sender.assistantId.toLowerCase(),
-        externalUserId: params.sender.assistantId,
         status: "active",
         policy: "allow",
       },

package/src/daemon/handlers/config-channels.ts

@@ -204,7 +204,7 @@ export function revokeVerificationForChannel(
   // revocation becomes a no-op (wrong reason or skipped entirely).
   const contactResult = findContactChannel({
     channelType: resolvedChannel,
-    externalUserId: bindingBeforeRevoke.guardianExternalUserId,
+    address: bindingBeforeRevoke.guardianExternalUserId,
     externalChatId: bindingBeforeRevoke.guardianDeliveryChatId,
   });
 
@@ -331,7 +331,10 @@ export async function verifyTrustedContact(
       const sessionResult = createOutboundSession({
         channel: verificationChannel,
         expectedChatId: channel.externalChatId,
-        expectedExternalUserId: channel.externalUserId ?? undefined,
+        expectedExternalUserId:
+          channel.address !== channel.externalChatId
+            ? channel.address
+            : undefined,
         identityBindingStatus: "bound",
         destinationAddress: effectiveDestination,
         verificationPurpose: "trusted_contact",
@@ -404,22 +407,14 @@ export async function verifyTrustedContact(
 
   // --- Slack verification ---
   if (verificationChannel === "slack") {
-    const slackUserId = channel.externalUserId ?? destination;
-
-    const hasIdentityBinding = Boolean(
-      channel.externalUserId || channel.externalChatId,
-    );
-    if (!hasIdentityBinding) {
-      return {
-        success: false,
-        error:
-          "Slack verification requires an externalUserId or externalChatId for identity binding",
-      };
-    }
+    const slackUserId = channel.address;
 
     const sessionResult = createOutboundSession({
       channel: verificationChannel,
-      expectedExternalUserId: channel.externalUserId ?? undefined,
+      expectedExternalUserId:
+        channel.address !== channel.externalChatId
+          ? channel.address
+          : undefined,
       expectedChatId: channel.externalChatId ?? undefined,
       identityBindingStatus: "bound",
       destinationAddress: slackUserId,
@@ -560,7 +555,11 @@ export async function handleChannelVerificationSession(
           const { to, text, subject, assistantId: aid } = result._pendingEmail;
           deliverVerificationEmail(to, text, subject, aid);
         }
-        const { _pendingSlackDm: _, _pendingEmail: __, ...publicResult } = result;
+        const {
+          _pendingSlackDm: _,
+          _pendingEmail: __,
+          ...publicResult
+        } = result;
         broadcastMessage({
           type: "channel_verification_session_response",
           ...publicResult,

package/src/daemon/handlers/config-slack-channel.ts

@@ -28,6 +28,9 @@ import { log as _log } from "./shared.js";
 
 // -- Result type --
 
+export const SlackThreadMode = z.enum(["mention_only", "mention_then_thread"]);
+export type SlackThreadMode = z.infer<typeof SlackThreadMode>;
+
 export const SlackChannelConfigResultSchema = z.object({
   success: z.boolean(),
   hasBotToken: z.boolean(),
@@ -39,6 +42,7 @@ export const SlackChannelConfigResultSchema = z.object({
   teamUrl: z.string().optional(),
   botUserId: z.string().optional(),
   botUsername: z.string().optional(),
+  threadMode: SlackThreadMode,
   error: z.string().optional(),
   warning: z.string().optional(),
 });
@@ -129,6 +133,8 @@ export async function getSlackChannelConfig(): Promise<SlackChannelConfigResult>
     ensureUserTokenInjectionTemplates();
   }
 
+  const { threadMode } = getConfig().slack;
+
   return {
     success: true,
     hasBotToken,
@@ -140,6 +146,7 @@ export async function getSlackChannelConfig(): Promise<SlackChannelConfigResult>
     ...(teamUrl ? { teamUrl } : {}),
     ...(botUserId ? { botUserId } : {}),
     ...(botUsername ? { botUsername } : {}),
+    threadMode,
   };
 }
 
@@ -166,6 +173,7 @@ async function currentErrorSnapshot(
       !!(errConn && errConn.status === "active") &&
       errHasBotToken &&
       errHasAppToken,
+    threadMode: getConfig().slack.threadMode,
     error,
   };
 }
@@ -429,6 +437,7 @@ export async function setSlackChannelConfig(
     hasUserToken,
     connected: hasBotToken && hasAppToken,
     ...metadata,
+    threadMode: getConfig().slack.threadMode,
     ...(warning ? { warning } : {}),
   };
 }
@@ -440,9 +449,8 @@ export async function setSlackChannelConfig(
  * the bot_token, app_token, oauth_connection row, and Slack config metadata
  * untouched so the Socket Mode connection stays up. Returns a
  * `SlackChannelConfigResult` reflecting the remaining state. A `not-found`
- * delete outcome is reported as a failure to match the credential_store
- * delete semantics (callers and automation rely on missing-credential
- * detection).
+ * delete outcome is reported as a failure to match the credential delete
+ * semantics (callers and automation rely on missing-credential detection).
  */
 export async function clearSlackUserToken(): Promise<SlackChannelConfigResult> {
   const result = await deleteSecureKeyAsync(
@@ -467,6 +475,7 @@ export async function clearSlackUserToken(): Promise<SlackChannelConfigResult> {
       hasUserToken,
       connected:
         !!(conn && conn.status === "active") && hasBotToken && hasAppToken,
+      threadMode: getConfig().slack.threadMode,
       error:
         result === "not-found"
           ? "Slack user token not found in secure storage"
@@ -498,6 +507,7 @@ export async function clearSlackUserToken(): Promise<SlackChannelConfigResult> {
     ...(teamUrl ? { teamUrl } : {}),
     ...(botUserId ? { botUserId } : {}),
     ...(botUsername ? { botUsername } : {}),
+    threadMode: getConfig().slack.threadMode,
   };
 }
 
@@ -531,6 +541,7 @@ export async function clearSlackChannelConfig(): Promise<SlackChannelConfigResul
       hasUserToken,
       connected:
         !!(conn && conn.status === "active") && hasBotToken && hasAppToken,
+      threadMode: getConfig().slack.threadMode,
       error: "Failed to delete Slack channel credentials from secure storage",
     };
   }
@@ -557,5 +568,13 @@ export async function clearSlackChannelConfig(): Promise<SlackChannelConfigResul
     hasAppToken: false,
     hasUserToken: false,
     connected: false,
+    threadMode: "mention_only",
   };
 }
+
+export function patchSlackChannelConfig(threadMode: SlackThreadMode): void {
+  const raw = loadRawConfig();
+  setNestedValue(raw, "slack.threadMode", threadMode);
+  saveRawConfig(raw);
+  invalidateConfigCache();
+}