@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/runtime/routes/inbound-stages/reaction-intercept.test.ts

@@ -72,6 +72,7 @@ mock.module("../../../contacts/contact-store.js", () => ({
 let recordInboundCalls: Array<{ conversationId?: string }> = [];
 let recordedEvent: { eventId: string; conversationId: string } | null = null;
 let outboundTargetConversationId: string | null = null;
+let outboundLookupChannels: string[] = [];
 let storedTarget: { messageId: string; conversationId: string } | null = null;
 mock.module("../../../persistence/delivery-crud.js", () => ({
   recordInbound: (
@@ -89,7 +90,10 @@ mock.module("../../../persistence/delivery-crud.js", () => ({
     };
   },
   findMessageBySourceId: () => storedTarget,
-  findSlackConversationByMessageTs: () => outboundTargetConversationId,
+  findConversationByProviderMessageId: (sourceChannel: string) => {
+    outboundLookupChannels.push(sourceChannel);
+    return outboundTargetConversationId;
+  },
   findInboundEvent: () => recordedEvent,
   clearPayload: () => {},
   linkMessage: () => {},
@@ -134,7 +138,7 @@ mock.module("./guardian-reply-intercept.js", () => ({
   },
 }));
 
-import { handleSlackReactionIntercept } from "./reaction-intercept.js";
+import { handleReactionIntercept } from "./reaction-intercept.js";
 
 // ---------------------------------------------------------------------------
 // Fixtures
@@ -178,7 +182,11 @@ function buildParams(overrides: {
 }) {
   msgCounter++;
   return {
-    callbackData: "reaction:white_check_mark",
+    reaction: {
+      op: "added" as const,
+      emoji: "white_check_mark",
+      targetMessageId: "1700000000.1",
+    },
     sourceChannel: "slack" as const,
     sourceInterface: "slack" as const,
     conversationExternalId: SLACK_CHANNEL_ID,
@@ -217,6 +225,7 @@ describe("reaction intercept consumes the stamped verdict directly", () => {
     recordInboundCalls = [];
     recordedEvent = null;
     outboundTargetConversationId = null;
+    outboundLookupChannels = [];
     addMessageCalls = 0;
     guardianReplyCalls = [];
     guardianReplyResponse = undefined;
@@ -226,7 +235,7 @@ describe("reaction intercept consumes the stamped verdict directly", () => {
   test("guardian verdict routes the reaction into the approval decision pipeline", async () => {
     guardianReplyResponse = { accepted: true, canonicalRouter: "applied" };
 
-    const result = await handleSlackReactionIntercept(
+    const result = await handleReactionIntercept(
       buildParams({
         rawSenderId: GUARDIAN_USER_ID,
         trustVerdict: GUARDIAN_VERDICT,
@@ -242,7 +251,7 @@ describe("reaction intercept consumes the stamped verdict directly", () => {
   });
 
   test("contact verdict records the reaction; the decision pipeline self-gate ignores it", async () => {
-    const result = await handleSlackReactionIntercept(
+    const result = await handleReactionIntercept(
       buildParams({
         rawSenderId: MEMBER_USER_ID,
         trustVerdict: MEMBER_VERDICT,
@@ -261,12 +270,12 @@ describe("reaction intercept consumes the stamped verdict directly", () => {
     expect(recordInboundCalls).toEqual([{ conversationId: "conv-target" }]);
   });
 
-  test("a reaction on the assistant's own post resolves through slackMeta", async () => {
-    // Outbound posts open no inbound event, so the ts is only on the row.
+  test("a reaction on the assistant's own post resolves through its stored envelope", async () => {
+    // Outbound posts open no inbound event, so the id is only on the row.
     storedTarget = null;
     outboundTargetConversationId = "conv-assistant-post";
 
-    const result = await handleSlackReactionIntercept(
+    const result = await handleReactionIntercept(
       buildParams({
         rawSenderId: MEMBER_USER_ID,
         trustVerdict: MEMBER_VERDICT,
@@ -278,12 +287,36 @@ describe("reaction intercept consumes the stamped verdict directly", () => {
     ]);
     expect(addMessageCalls).toBe(1);
     expect(result).toMatchObject({ accepted: true, duplicate: false });
+    // The outbound-row lookup is scoped to the reaction's own channel: a
+    // Slack reaction never scans another channel's conversations.
+    expect(outboundLookupChannels).toEqual(["slack"]);
+  });
+
+  test("a non-Slack reaction resolves the assistant's post on its own channel", async () => {
+    storedTarget = null;
+    outboundTargetConversationId = "conv-discord-post";
+
+    const params = {
+      ...buildParams({
+        rawSenderId: MEMBER_USER_ID,
+        trustVerdict: MEMBER_VERDICT,
+      }),
+      sourceChannel: "discord" as const,
+      sourceInterface: undefined,
+    };
+    const result = await handleReactionIntercept(params);
+
+    expect(outboundLookupChannels).toEqual(["discord"]);
+    expect(recordInboundCalls).toEqual([
+      { conversationId: "conv-discord-post" },
+    ]);
+    expect(result).toMatchObject({ accepted: true, duplicate: false });
   });
 
   test("a reaction on a message that is not stored is dropped without minting", async () => {
     storedTarget = null;
 
-    const result = await handleSlackReactionIntercept(
+    const result = await handleReactionIntercept(
       buildParams({
         rawSenderId: MEMBER_USER_ID,
         trustVerdict: MEMBER_VERDICT,
@@ -298,7 +331,7 @@ describe("reaction intercept consumes the stamped verdict directly", () => {
   test("a redelivered reaction never reaches the guardian rail twice", async () => {
     recordedEvent = { eventId: "evt-1", conversationId: "conv-target" };
 
-    const result = await handleSlackReactionIntercept(
+    const result = await handleReactionIntercept(
       buildParams({
         rawSenderId: GUARDIAN_USER_ID,
         trustVerdict: GUARDIAN_VERDICT,
@@ -319,7 +352,7 @@ describe("reaction intercept consumes the stamped verdict directly", () => {
     storedTarget = null;
     guardianReplyResponse = { accepted: true, canonicalRouter: "applied" };
 
-    const result = await handleSlackReactionIntercept(
+    const result = await handleReactionIntercept(
       buildParams({
         rawSenderId: GUARDIAN_USER_ID,
         trustVerdict: GUARDIAN_VERDICT,
@@ -331,21 +364,21 @@ describe("reaction intercept consumes the stamped verdict directly", () => {
   });
 
   test("unknown verdict is dropped before any write", async () => {
-    const result = await handleSlackReactionIntercept(
+    const result = await handleReactionIntercept(
       buildParams({ rawSenderId: "U_STRANGER", trustVerdict: UNKNOWN_VERDICT }),
     );
     expectDropped(result);
   });
 
   test("missing verdict is dropped fail-closed", async () => {
-    const result = await handleSlackReactionIntercept(
+    const result = await handleReactionIntercept(
       buildParams({ rawSenderId: MEMBER_USER_ID }),
     );
     expectDropped(result);
   });
 
   test("resolutionFailed verdict is dropped fail-closed even with a guardian shape", async () => {
-    const result = await handleSlackReactionIntercept(
+    const result = await handleReactionIntercept(
       buildParams({
         rawSenderId: GUARDIAN_USER_ID,
         trustVerdict: { ...GUARDIAN_VERDICT, resolutionFailed: true },
@@ -355,7 +388,7 @@ describe("reaction intercept consumes the stamped verdict directly", () => {
   });
 
   test("memberless guardian verdict is contradictory and dropped fail-closed", async () => {
-    const result = await handleSlackReactionIntercept(
+    const result = await handleReactionIntercept(
       buildParams({
         rawSenderId: GUARDIAN_USER_ID,
         trustVerdict: {
@@ -370,13 +403,13 @@ describe("reaction intercept consumes the stamped verdict directly", () => {
 
   test("classification is verdict-only: no IPC, cache, or local-store reads", async () => {
     guardianReplyResponse = { accepted: true, canonicalRouter: "applied" };
-    await handleSlackReactionIntercept(
+    await handleReactionIntercept(
       buildParams({
         rawSenderId: GUARDIAN_USER_ID,
         trustVerdict: GUARDIAN_VERDICT,
       }),
     );
-    await handleSlackReactionIntercept(
+    await handleReactionIntercept(
       buildParams({
         rawSenderId: MEMBER_USER_ID,
         trustVerdict: MEMBER_VERDICT,

package/src/runtime/routes/inbound-stages/reaction-intercept.ts

@@ -20,25 +20,35 @@
  * `unknown` (drop). Reactions never drive an agent turn.
  */
 import type { SourceMetadata } from "@vellumai/gateway-client";
-import { resolveInboundEventKind } from "@vellumai/gateway-client";
+import {
+  type InboundReactionPayload,
+  resolveInboundEventKind,
+} from "@vellumai/gateway-client";
 
 import type { ChannelId, InterfaceId } from "../../../channels/types.js";
+import { findConversation } from "../../../daemon/conversation-registry.js";
 import { getDiskPressureStatus } from "../../../daemon/disk-pressure-guard.js";
 import { classifyDiskPressureTurnPolicy } from "../../../daemon/disk-pressure-policy.js";
+import type { TrustContext } from "../../../daemon/trust-context-types.js";
+import { writeSlackMetadata } from "../../../messaging/providers/slack/message-metadata.js";
+import {
+  buildNeutralReactionMeta,
+  buildSlackReactionMeta,
+} from "../../../messaging/reaction-envelopes.js";
 import {
-  type SlackMessageMetadata,
-  writeSlackMetadata,
-} from "../../../messaging/providers/slack/message-metadata.js";
-import { addMessage } from "../../../persistence/conversation-crud.js";
+  addMessage,
+  provenanceFromTrustContext,
+} from "../../../persistence/conversation-crud.js";
 import {
+  findConversationByProviderMessageId,
   findInboundEvent,
   findMessageBySourceId,
-  findSlackConversationByMessageTs,
   linkMessage,
   recordInbound,
 } from "../../../persistence/delivery-crud.js";
 import { markProcessed } from "../../../persistence/delivery-status.js";
 import { getLogger } from "../../../util/logger.js";
+import { toTrustContext } from "../../actor-trust-resolver.js";
 import type { ApprovalConversationGenerator } from "../../http-types.js";
 import {
   actorTrustContextFromVerdict,
@@ -49,56 +59,24 @@ import { handleGuardianReplyIntercept } from "./guardian-reply-intercept.js";
 const log = getLogger("runtime-http");
 
 /**
- * Detect a Slack reaction event by inspecting the inbound payload's
- * `callbackData` prefix. The gateway encodes reactions as a unified
- * `SlackInboundEvent` with `callbackData` of the form `reaction:<emoji>`
- * (added) or `reaction_removed:<emoji>` (removed) — see
- * `gateway/src/slack/normalize.ts`. This helper centralizes that convention
- * so the daemon can route reactions to this dedicated stage instead of the
- * agent-response pipeline.
+ * Whether the inbound payload belongs to the reaction event family, on any
+ * channel. Family membership is the kind alone; whether the payload can be
+ * acted on is `resolveInboundReactionPayload`'s answer, and the dispatch
+ * drops a family member whose payload does not resolve rather than letting
+ * it be reinterpreted as a message.
  */
-export function isSlackReactionEvent(body: {
-  sourceChannel?: string;
+export function isReactionEvent(body: {
   eventKind?: string;
+  isEdit?: boolean;
   callbackData?: string;
+  callbackQueryId?: string;
 }): boolean {
-  // The Slack gate is deliberate, not residue: Slack is the only channel
-  // whose reactions are ingested today, and widening this is a per-channel
-  // decision made with that channel's reaction wire shape, not a fallthrough.
-  return (
-    body.sourceChannel === "slack" &&
-    resolveInboundEventKind(body) === "reaction"
-  );
-}
-
-/**
- * Parse a reaction `callbackData` string into its op (added/removed) and
- * emoji name. Returns `null` when the input is not a reaction prefix or
- * when the emoji portion is empty.
- */
-export function parseSlackReactionCallbackData(
-  callbackData: string,
-): { op: "added" | "removed"; emoji: string } | null {
-  let op: "added" | "removed";
-  let emoji: string;
-  if (callbackData.startsWith("reaction_removed:")) {
-    op = "removed";
-    emoji = callbackData.slice("reaction_removed:".length);
-  } else if (callbackData.startsWith("reaction:")) {
-    op = "added";
-    emoji = callbackData.slice("reaction:".length);
-  } else {
-    return null;
-  }
-  if (emoji.length === 0) {
-    return null;
-  }
-  return { op, emoji };
+  return resolveInboundEventKind(body) === "reaction";
 }
 
 export interface ReactionInterceptParams {
-  /** The reaction callbackData (`reaction:<emoji>` / `reaction_removed:<emoji>`). */
-  callbackData: string;
+  /** The resolved structured payload: op, emoji, and target message id. */
+  reaction: InboundReactionPayload;
   sourceChannel: ChannelId;
   sourceInterface: InterfaceId | undefined;
   conversationExternalId: string;
@@ -113,15 +91,15 @@ export interface ReactionInterceptParams {
 }
 
 /**
- * Handle a Slack reaction event end to end. Always consumes the event (the
- * caller dispatches here only for `isSlackReactionEvent`), returning the
+ * Handle a reaction event end to end, on any channel. Always consumes the event (the
+ * caller dispatches here only for `isReactionEvent`), returning the
  * response the top-level handler should short-circuit with.
  */
-export async function handleSlackReactionIntercept(
+export async function handleReactionIntercept(
   params: ReactionInterceptParams,
 ): Promise<Record<string, unknown>> {
   const {
-    callbackData,
+    reaction,
     sourceChannel,
     sourceInterface,
     conversationExternalId,
@@ -162,10 +140,7 @@ export async function handleSlackReactionIntercept(
     return { accepted: true, reaction: "dropped_unknown_actor" };
   }
 
-  const reactedMessageTs =
-    typeof sourceMetadata?.messageId === "string"
-      ? sourceMetadata.messageId
-      : undefined;
+  const reactedMessageTs = reaction.targetMessageId;
   // Respect disk-pressure cleanup so reactions don't bypass storage
   // protection. Guardians resolve to `allow-cleanup-mode` (not `block`), so a
   // guardian's approval-by-reaction still flows. Blocked silently and before
@@ -210,12 +185,13 @@ export async function handleSlackReactionIntercept(
   // `reaction_removed:` never does. `handleGuardianReplyIntercept` self-gates
   // on `trustClass === "guardian"`, so a contact's reaction returns no
   // response and falls through to persistence.
-  if (callbackData.startsWith("reaction:") && replyCallbackUrl) {
+  if (reaction.op === "added" && replyCallbackUrl) {
     const reactionIntercept = await handleGuardianReplyIntercept({
       isDuplicate: false,
       trimmedContent: "",
       hasCallbackData: true,
-      callbackData,
+      callbackData: undefined,
+      reaction,
       reactedMessageTs,
       rawSenderId,
       canonicalSenderId,
@@ -239,14 +215,16 @@ export async function handleSlackReactionIntercept(
   // reaction is dropped rather than given a conversation of its own.
   // Inbound messages carry their provider id on the event that delivered
   // them. The assistant's own posts open no inbound event, so a reaction on
-  // one is resolved through the `slackMeta` those rows carry.
+  // one is resolved through the envelope those rows carry (`slackMeta` on
+  // Slack, the neutral `providerMeta` everywhere else).
   const targetConversationId = reactedMessageTs
     ? (findMessageBySourceId(
         sourceChannel,
         conversationExternalId,
         reactedMessageTs,
       )?.conversationId ??
-      findSlackConversationByMessageTs(
+      findConversationByProviderMessageId(
+        sourceChannel,
         conversationExternalId,
         reactedMessageTs,
       ))
@@ -272,15 +250,24 @@ export async function handleSlackReactionIntercept(
 
   // Record the reaction as an inline transcript signal.
   try {
-    await persistSlackReactionAsMessage({
+    await persistReactionAsMessage({
       conversationId: result.conversationId,
       conversationExternalId,
       eventId: result.eventId,
-      callbackData,
+      sourceChannel,
+      reaction,
       actorDisplayName,
+      actorExternalId: canonicalSenderId ?? rawSenderId ?? undefined,
       reactedMessageTs,
       duplicate: result.duplicate,
+      trustCtx: toTrustContext(trustCtx, conversationExternalId),
     });
+    if (!result.duplicate) {
+      // Reactions never drive a turn, so a resident conversation would
+      // otherwise carry the new row only after eviction. Marking it stale
+      // makes the next turn's history reload pick the reaction up.
+      findConversation(result.conversationId)?.markHistoryStale();
+    }
   } catch (err) {
     log.error(
       { err, conversationId: result.conversationId, eventId: result.eventId },
@@ -305,53 +292,66 @@ export async function handleSlackReactionIntercept(
  * deduplication and conversation resolution have happened. Duplicate inbound
  * events are skipped here to keep persistence idempotent.
  */
-async function persistSlackReactionAsMessage(params: {
+async function persistReactionAsMessage(params: {
   conversationId: string;
   conversationExternalId: string;
   eventId: string;
-  callbackData: string;
+  sourceChannel: ChannelId;
+  reaction: InboundReactionPayload;
   actorDisplayName?: string;
+  /**
+   * The reactor's stable channel identity, canonical when resolution
+   * succeeded. Persisted as the envelope's actor id: a display name is
+   * sender-controlled labeling, and the rendered history line attributes
+   * its fenced content by this id (`origin`), never by the label.
+   */
+  actorExternalId?: string;
   reactedMessageTs: string;
   duplicate: boolean;
+  /**
+   * The reactor's trust context. Persisted as row provenance so actor-scoped
+   * history loads keep the row: `filterMessagesForUntrustedActor` drops any
+   * row with no `provenanceTrustClass`, which would hide every reaction from
+   * non-guardian turns.
+   */
+  trustCtx: TrustContext;
 }): Promise<void> {
   if (params.duplicate) {
     return;
   }
+  const facts = {
+    channel: params.sourceChannel,
+    chatId: params.conversationExternalId,
+    targetMessageId: params.reactedMessageTs,
+    emoji: params.reaction.emoji,
+    op: params.reaction.op,
+    ...(params.actorExternalId
+      ? { actorExternalId: params.actorExternalId }
+      : {}),
+    ...(params.actorDisplayName
+      ? { actorDisplayName: params.actorDisplayName }
+      : {}),
+  };
 
-  const parsed = parseSlackReactionCallbackData(params.callbackData);
-  if (!parsed) {
-    log.debug(
+  if (params.sourceChannel !== "slack") {
+    const persisted = await addMessage(
+      params.conversationId,
+      "user",
+      "[reaction]",
       {
-        conversationId: params.conversationId,
-        callbackData: params.callbackData,
+        metadata: {
+          ...provenanceFromTrustContext(params.trustCtx),
+          providerMeta: JSON.stringify(buildNeutralReactionMeta(facts)),
+        },
+        skipIndexing: true,
       },
-      "Skipping reaction persistence: unparseable callbackData",
     );
+    linkMessage(params.eventId, persisted.id);
+    markProcessed(params.eventId);
     return;
   }
 
-  const slackMeta: SlackMessageMetadata = {
-    source: "slack",
-    channelId: params.conversationExternalId,
-    channelTs: params.reactedMessageTs,
-    eventKind: "reaction",
-    // No `threadTs`: Slack sends none on a reaction, so the gateway's thread
-    // id here is the reacted message's own ts. It equals `channelTs`, which
-    // every reader treats as "not in a thread" anyway, and storing it makes
-    // the row false evidence that a thread belongs to this conversation
-    // (`legacySlackConversationHasThreadEvidence`).
-    ...(params.actorDisplayName
-      ? { displayName: params.actorDisplayName }
-      : {}),
-    reaction: {
-      emoji: parsed.emoji,
-      targetChannelTs: params.reactedMessageTs,
-      op: parsed.op,
-      ...(params.actorDisplayName
-        ? { actorDisplayName: params.actorDisplayName }
-        : {}),
-    },
-  };
+  const slackMeta = buildSlackReactionMeta(facts);
 
   // Sentinel content — Slack transcript renderers read `slackMeta` to format
   // the reaction line; the literal text is never displayed to the model.
@@ -360,7 +360,10 @@ async function persistSlackReactionAsMessage(params: {
     "user",
     "[reaction]",
     {
-      metadata: { slackMeta: writeSlackMetadata(slackMeta) },
+      metadata: {
+        ...provenanceFromTrustContext(params.trustCtx),
+        slackMeta: writeSlackMetadata(slackMeta),
+      },
       skipIndexing: true,
     },
   );

package/src/runtime/routes/index.ts

@@ -74,6 +74,7 @@ import { ROUTES as GATEWAY_STATUS_ROUTES } from "./gateway-status-routes.js";
 import { ROUTES as GLOBAL_SEARCH_ROUTES } from "./global-search-routes.js";
 import { ROUTES as GROUP_ROUTES } from "./group-routes.js";
 import { ROUTES as GUARDIAN_ACTION_ROUTES } from "./guardian-action-routes.js";
+import { GUARDIAN_FORM_ROUTES } from "./guardian-form-routes.js";
 import { ROUTES as HEARTBEAT_ROUTES } from "./heartbeat-routes.js";
 import { ROUTES as HOME_FEED_ROUTES } from "./home-feed-routes.js";
 import { ROUTES as HOME_STATE_ROUTES } from "./home-state-routes.js";
@@ -193,6 +194,7 @@ export const ROUTES: RouteDefinition[] = [
   ...CLIENT_ROUTES,
   ...CONTENT_SOURCE_ROUTES,
   ...CONTACT_PROMPT_ROUTES,
+  ...GUARDIAN_FORM_ROUTES,
   ...CONTACT_ROUTES,
   ...CONVERSATION_ATTENTION_ROUTES,
   ...CONVERSATION_CLI_ROUTES,

package/src/runtime/routes/integrations/slack/channel.ts

@@ -19,8 +19,39 @@ import {
 } from "../../../../daemon/handlers/config-slack-channel.js";
 import { ACTOR_PRINCIPALS } from "../../../auth/route-policy.js";
 import { BadRequestError } from "../../errors.js";
+import { parseBody } from "../../parse-body.js";
 import type { RouteDefinition, RouteHandlerArgs } from "../../types.js";
 
+// ---------------------------------------------------------------------------
+// Body schemas
+//
+// Each is named once and used twice: as the route's `requestBody`, a codegen
+// signal only, and by `parseBody` in the handler, which is what rejects a
+// malformed request. One declaration keeps the wire contract and the runtime
+// check in agreement.
+// ---------------------------------------------------------------------------
+
+/**
+ * Every field is optional because `setSlackChannelConfig` accepts any subset:
+ * a user token alone is a valid update that leaves the bot and app tokens in
+ * place. The wizard requires both bot and app tokens, and enforces that in
+ * `use-save-slack-config.ts` where that requirement belongs.
+ */
+const SetSlackChannelConfigBody = z.object({
+  botToken: z.string().optional().describe("Slack bot token"),
+  appToken: z.string().optional().describe("Slack app-level token"),
+  userToken: z
+    .string()
+    .optional()
+    .describe("Slack user token, for reading channels the bot is not in"),
+});
+
+const PatchSlackChannelConfigBody = z.object({
+  threadMode: SlackThreadMode.describe(
+    "Controls whether the bot follows threads after an initial @mention",
+  ).optional(),
+});
+
 // ---------------------------------------------------------------------------
 // Handlers
 // ---------------------------------------------------------------------------
@@ -32,22 +63,19 @@ async function handleGetSlackChannelConfig() {
 export async function handleSetSlackChannelConfig({
   body = {},
 }: RouteHandlerArgs) {
-  const { botToken, appToken, userToken } = body as {
-    botToken?: string;
-    appToken?: string;
-    userToken?: string;
-  };
+  const { botToken, appToken, userToken } = parseBody(
+    SetSlackChannelConfigBody,
+    body,
+  );
   const result = await setSlackChannelConfig(botToken, appToken, userToken);
   if (!result.success) {
-    throw new BadRequestError(
-      (result as { error?: string }).error ?? "Failed to set Slack config",
-    );
+    throw new BadRequestError(result.error ?? "Failed to set Slack config");
   }
   return result;
 }
 
 async function handlePatchSlackChannelConfig({ body = {} }: RouteHandlerArgs) {
-  const { threadMode } = body as { threadMode?: string };
+  const { threadMode } = parseBody(PatchSlackChannelConfigBody, body);
   if (threadMode !== undefined) {
     const parsed = SlackThreadMode.safeParse(threadMode);
     if (!parsed.success) {
@@ -95,10 +123,7 @@ export const ROUTES: RouteDefinition[] = [
     description: "Validate and store Slack channel credentials.",
     tags: ["integrations"],
     handler: handleSetSlackChannelConfig,
-    requestBody: z.object({
-      botToken: z.string().describe("Slack bot token"),
-      appToken: z.string().describe("Slack app-level token"),
-    }),
+    requestBody: SetSlackChannelConfigBody,
     responseBody: SlackChannelConfigResultSchema,
   },
   {
@@ -113,11 +138,7 @@ export const ROUTES: RouteDefinition[] = [
     description: "Update Slack channel behavior settings (e.g. thread mode).",
     tags: ["integrations"],
     handler: handlePatchSlackChannelConfig,
-    requestBody: z.object({
-      threadMode: SlackThreadMode.describe(
-        "Controls whether the bot follows threads after an initial @mention",
-      ).optional(),
-    }),
+    requestBody: PatchSlackChannelConfigBody,
     responseBody: SlackChannelConfigResultSchema,
   },
   {

package/src/runtime/routes/migration-routes.ts

@@ -44,7 +44,6 @@ import {
 } from "../../security/secure-keys.js";
 import {
   getCredentialMetadata,
-  persistCredentialMetadata,
   upsertCredentialMetadata,
 } from "../../tools/credentials/metadata-store.js";
 import { getLogger } from "../../util/logger.js";
@@ -157,8 +156,7 @@ export async function reconcileVellumMetadataFromCes(warningSink: {
       if (getCredentialMetadata("vellum", field)) {
         continue;
       }
-      const metadata = upsertCredentialMetadata("vellum", field, {});
-      await persistCredentialMetadata(metadata);
+      upsertCredentialMetadata("vellum", field, {});
       log.info(
         { field },
         "Reconciled vellum:* metadata entry from CES after import",

package/src/runtime/routes/monitoring-routes.ts

@@ -139,10 +139,7 @@ const statusResponseSchema = z.object({
 async function handleMonitoringStart() {
   let result: { pid: number; alreadyRunning: boolean };
   try {
-    // `detached: false` parents the monitor to the daemon so it appears in
-    // `assistant ps` and is torn down on shutdown.
     result = await spawnMonitoringWorkerProcess({
-      detached: false,
       terminateOnTimeout: true,
     });
   } catch (err) {