Merge branch 'main' into commands-list-clean

2026-05-06 18:21:37 +00:00 · 2026-01-09 11:04:23 -05:00
parent 750dea3edf c892fd174e
commit 98b875cd0f
359 changed files with 18384 additions and 4739 deletions
--- a/src/auto-reply/reply/agent-runner.ts
+++ b/src/auto-reply/reply/agent-runner.ts
@@ -50,7 +50,7 @@ import {
  shouldSuppressMessagingToolReplies,
 } from "./reply-payloads.js";
 import {
-  createReplyToModeFilter,
+  createReplyToModeFilterForChannel,
  resolveReplyToMode,
 } from "./reply-threading.js";
 import { incrementCompactionCount } from "./session-updates.js";
@@ -260,7 +260,10 @@ export async function runReplyAgent(params: {
    followupRun.run.config,
    replyToChannel,
  );
-  const applyReplyToMode = createReplyToModeFilter(replyToMode);
+  const applyReplyToMode = createReplyToModeFilterForChannel(
+    replyToMode,
+    replyToChannel,
+  );
  const cfg = followupRun.run.config;

  if (shouldSteer && isStreaming) {
@@ -716,7 +719,8 @@ export async function runReplyAgent(params: {

    const replyTaggedPayloads: ReplyPayload[] = applyReplyThreading({
      payloads: sanitizedPayloads,
-      applyReplyToMode,
+      replyToMode,
+      replyToChannel,
      currentMessageId: sessionCtx.MessageSid,
    })
      .map((payload) => {
--- a/src/auto-reply/reply/block-streaming.ts
+++ b/src/auto-reply/reply/block-streaming.ts
@@ -34,7 +34,7 @@ export function resolveBlockStreamingChunking(
 } {
  const providerKey = normalizeChunkProvider(provider);
  const textLimit = resolveTextChunkLimit(cfg, providerKey);
-  const chunkCfg = cfg?.agent?.blockStreamingChunk;
+  const chunkCfg = cfg?.agents?.defaults?.blockStreamingChunk;
  const maxRequested = Math.max(
    1,
    Math.floor(chunkCfg?.maxChars ?? DEFAULT_BLOCK_STREAM_MAX),
--- a/src/auto-reply/reply/commands.ts
+++ b/src/auto-reply/reply/commands.ts
@@ -1,3 +1,7 @@
+import {
+  resolveAgentDir,
+  resolveDefaultAgentId,
+} from "../../agents/agent-scope.js";
 import {
  ensureAuthProfileStore,
  resolveAuthProfileDisplayLabel,
@@ -16,6 +20,13 @@ import {
 } from "../../agents/pi-embedded.js";
 import type { ClawdbotConfig } from "../../config/config.js";
 import {
+  getConfigOverrides,
+  resetConfigOverrides,
+  setConfigOverride,
+  unsetConfigOverride,
+} from "../../config/runtime-overrides.js";
+import {
+  resolveAgentIdFromSessionKey,
  resolveSessionFilePath,
  type SessionEntry,
  type SessionScope,
@@ -61,6 +72,7 @@ import type {
 } from "../thinking.js";
 import type { ReplyPayload } from "../types.js";
 import { isAbortTrigger, setAbortMemory } from "./abort.js";
+import { parseDebugCommand } from "./debug-commands.js";
 import type { InlineDirectives } from "./directive-handling.js";
 import { stripMentions, stripStructuralPrefixes } from "./mentions.js";
 import { getFollowupQueueDepth, resolveQueueSettings } from "./queue.js";
@@ -135,6 +147,10 @@ export async function buildStatusReply(params: {
    );
    return undefined;
  }
+  const statusAgentId = sessionKey
+    ? resolveAgentIdFromSessionKey(sessionKey)
+    : resolveDefaultAgentId(cfg);
+  const statusAgentDir = resolveAgentDir(cfg, statusAgentId);
  let usageLine: string | null = null;
  try {
    const usageProvider = resolveUsageProviderId(provider);
@@ -142,8 +158,18 @@ export async function buildStatusReply(params: {
      const usageSummary = await loadProviderUsageSummary({
        timeoutMs: 3500,
        providers: [usageProvider],
+        agentDir: statusAgentDir,
      });
      usageLine = formatUsageSummaryLine(usageSummary, { now: Date.now() });
+      if (
+        !usageLine &&
+        (resolvedVerboseLevel === "on" || resolvedElevatedLevel === "on")
+      ) {
+        const entry = usageSummary.providers[0];
+        if (entry?.error) {
+          usageLine = `📊 Usage: ${entry.displayName} (${entry.error})`;
+        }
+      }
    }
  } catch {
    usageLine = null;
@@ -164,18 +190,19 @@ export async function buildStatusReply(params: {
    ? (normalizeGroupActivation(sessionEntry?.groupActivation) ??
      defaultGroupActivation())
    : undefined;
+  const agentDefaults = cfg.agents?.defaults ?? {};
  const statusText = buildStatusMessage({
    config: cfg,
    agent: {
-      ...cfg.agent,
+      ...agentDefaults,
      model: {
-        ...cfg.agent?.model,
+        ...agentDefaults.model,
        primary: `${provider}/${model}`,
      },
      contextTokens,
-      thinkingDefault: cfg.agent?.thinkingDefault,
-      verboseDefault: cfg.agent?.verboseDefault,
-      elevatedDefault: cfg.agent?.elevatedDefault,
+      thinkingDefault: agentDefaults.thinkingDefault,
+      verboseDefault: agentDefaults.verboseDefault,
+      elevatedDefault: agentDefaults.elevatedDefault,
    },
    sessionEntry,
    sessionKey,
@@ -185,7 +212,12 @@ export async function buildStatusReply(params: {
    resolvedVerbose: resolvedVerboseLevel,
    resolvedReasoning: resolvedReasoningLevel,
    resolvedElevated: resolvedElevatedLevel,
-    modelAuth: resolveModelAuthLabel(provider, cfg, sessionEntry),
+    modelAuth: resolveModelAuthLabel(
+      provider,
+      cfg,
+      sessionEntry,
+      statusAgentDir,
+    ),
    usageLine: usageLine ?? undefined,
    queue: {
      mode: queueSettings.mode,
@@ -213,12 +245,15 @@ function resolveModelAuthLabel(
  provider?: string,
  cfg?: ClawdbotConfig,
  sessionEntry?: SessionEntry,
+  agentDir?: string,
 ): string | undefined {
  const resolved = provider?.trim();
  if (!resolved) return undefined;

  const providerKey = normalizeProviderId(resolved);
-  const store = ensureAuthProfileStore();
+  const store = ensureAuthProfileStore(agentDir, {
+    allowKeychainPrompt: false,
+  });
  const profileOverride = sessionEntry?.authProfileOverride?.trim();
  const order = resolveAuthProfileOrder({
    cfg,
@@ -593,6 +628,88 @@ export async function handleCommands(params: {
    return { shouldContinue: false, reply };
  }

+  const debugCommand = allowTextCommands
+    ? parseDebugCommand(command.commandBodyNormalized)
+    : null;
+  if (debugCommand) {
+    if (!command.isAuthorizedSender) {
+      logVerbose(
+        `Ignoring /debug from unauthorized sender: ${command.senderE164 || "<unknown>"}`,
+      );
+      return { shouldContinue: false };
+    }
+    if (debugCommand.action === "error") {
+      return {
+        shouldContinue: false,
+        reply: { text: `⚠️ ${debugCommand.message}` },
+      };
+    }
+    if (debugCommand.action === "show") {
+      const overrides = getConfigOverrides();
+      const hasOverrides = Object.keys(overrides).length > 0;
+      if (!hasOverrides) {
+        return {
+          shouldContinue: false,
+          reply: { text: "⚙️ Debug overrides: (none)" },
+        };
+      }
+      const json = JSON.stringify(overrides, null, 2);
+      return {
+        shouldContinue: false,
+        reply: {
+          text: `⚙️ Debug overrides (memory-only):\n\`\`\`json\n${json}\n\`\`\``,
+        },
+      };
+    }
+    if (debugCommand.action === "reset") {
+      resetConfigOverrides();
+      return {
+        shouldContinue: false,
+        reply: { text: "⚙️ Debug overrides cleared; using config on disk." },
+      };
+    }
+    if (debugCommand.action === "unset") {
+      const result = unsetConfigOverride(debugCommand.path);
+      if (!result.ok) {
+        return {
+          shouldContinue: false,
+          reply: { text: `⚠️ ${result.error ?? "Invalid path."}` },
+        };
+      }
+      if (!result.removed) {
+        return {
+          shouldContinue: false,
+          reply: {
+            text: `⚙️ No debug override found for ${debugCommand.path}.`,
+          },
+        };
+      }
+      return {
+        shouldContinue: false,
+        reply: { text: `⚙️ Debug override removed for ${debugCommand.path}.` },
+      };
+    }
+    if (debugCommand.action === "set") {
+      const result = setConfigOverride(debugCommand.path, debugCommand.value);
+      if (!result.ok) {
+        return {
+          shouldContinue: false,
+          reply: { text: `⚠️ ${result.error ?? "Invalid override."}` },
+        };
+      }
+      const valueLabel =
+        typeof debugCommand.value === "string"
+          ? `"${debugCommand.value}"`
+          : JSON.stringify(debugCommand.value);
+      return {
+        shouldContinue: false,
+        reply: {
+          text: `⚙️ Debug override set: ${debugCommand.path}=${valueLabel ?? "null"}`,
+        },
+      };
+    }
+  }
+
  const stopRequested = command.commandBodyNormalized === "/stop";
  if (allowTextCommands && stopRequested) {
    if (!command.isAuthorizedSender) {
--- a/src/auto-reply/reply/debug-commands.test.ts
+++ b/src/auto-reply/reply/debug-commands.test.ts
@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+
+import { parseDebugCommand } from "./debug-commands.js";
+
+describe("parseDebugCommand", () => {
+  it("parses show/reset", () => {
+    expect(parseDebugCommand("/debug")).toEqual({ action: "show" });
+    expect(parseDebugCommand("/debug show")).toEqual({ action: "show" });
+    expect(parseDebugCommand("/debug reset")).toEqual({ action: "reset" });
+  });
+
+  it("parses set with JSON", () => {
+    const cmd = parseDebugCommand('/debug set foo={"a":1}');
+    expect(cmd).toEqual({ action: "set", path: "foo", value: { a: 1 } });
+  });
+
+  it("parses unset", () => {
+    const cmd = parseDebugCommand("/debug unset foo.bar");
+    expect(cmd).toEqual({ action: "unset", path: "foo.bar" });
+  });
+});
--- a/src/auto-reply/reply/debug-commands.ts
+++ b/src/auto-reply/reply/debug-commands.ts
@@ -0,0 +1,99 @@
+export type DebugCommand =
+  | { action: "show" }
+  | { action: "reset" }
+  | { action: "set"; path: string; value: unknown }
+  | { action: "unset"; path: string }
+  | { action: "error"; message: string };
+
+function parseDebugValue(raw: string): { value?: unknown; error?: string } {
+  const trimmed = raw.trim();
+  if (!trimmed) return { error: "Missing value." };
+
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      return { value: JSON.parse(trimmed) };
+    } catch (err) {
+      return { error: `Invalid JSON: ${String(err)}` };
+    }
+  }
+
+  if (trimmed === "true") return { value: true };
+  if (trimmed === "false") return { value: false };
+  if (trimmed === "null") return { value: null };
+
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+    const num = Number(trimmed);
+    if (Number.isFinite(num)) return { value: num };
+  }
+
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    try {
+      return { value: JSON.parse(trimmed) };
+    } catch {
+      const unquoted = trimmed.slice(1, -1);
+      return { value: unquoted };
+    }
+  }
+
+  return { value: trimmed };
+}
+
+export function parseDebugCommand(raw: string): DebugCommand | null {
+  const trimmed = raw.trim();
+  if (!trimmed.toLowerCase().startsWith("/debug")) return null;
+  const rest = trimmed.slice("/debug".length).trim();
+  if (!rest) return { action: "show" };
+
+  const match = rest.match(/^(\S+)(?:\s+([\s\S]+))?$/);
+  if (!match) return { action: "error", message: "Invalid /debug syntax." };
+  const action = match[1].toLowerCase();
+  const args = (match[2] ?? "").trim();
+
+  switch (action) {
+    case "show":
+      return { action: "show" };
+    case "reset":
+      return { action: "reset" };
+    case "unset": {
+      if (!args)
+        return { action: "error", message: "Usage: /debug unset path" };
+      return { action: "unset", path: args };
+    }
+    case "set": {
+      if (!args) {
+        return {
+          action: "error",
+          message: "Usage: /debug set path=value",
+        };
+      }
+      const eqIndex = args.indexOf("=");
+      if (eqIndex <= 0) {
+        return {
+          action: "error",
+          message: "Usage: /debug set path=value",
+        };
+      }
+      const path = args.slice(0, eqIndex).trim();
+      const rawValue = args.slice(eqIndex + 1);
+      if (!path) {
+        return {
+          action: "error",
+          message: "Usage: /debug set path=value",
+        };
+      }
+      const parsed = parseDebugValue(rawValue);
+      if (parsed.error) {
+        return { action: "error", message: parsed.error };
+      }
+      return { action: "set", path, value: parsed.value };
+    }
+    default:
+      return {
+        action: "error",
+        message: "Usage: /debug show|set|unset|reset",
+      };
+  }
+}
--- a/src/auto-reply/reply/directive-handling.ts
+++ b/src/auto-reply/reply/directive-handling.ts
@@ -1,6 +1,10 @@
-import { resolveClawdbotAgentDir } from "../../agents/agent-paths.js";
-import { resolveAgentConfig } from "../../agents/agent-scope.js";
 import {
+  resolveAgentConfig,
+  resolveAgentDir,
+  resolveDefaultAgentId,
+} from "../../agents/agent-scope.js";
+import {
+  isProfileInCooldown,
  resolveAuthProfileDisplayLabel,
  resolveAuthStorePathForDisplay,
 } from "../../agents/auth-profiles.js";
@@ -20,9 +24,11 @@ import {
  buildModelAliasIndex,
  type ModelAliasIndex,
  modelKey,
+  normalizeProviderId,
  resolveConfiguredModelRef,
  resolveModelRefFromString,
 } from "../../agents/model-selection.js";
+import { resolveSandboxConfigForAgent } from "../../agents/sandbox.js";
 import type { ClawdbotConfig } from "../../config/config.js";
 import {
  resolveAgentIdFromSessionKey,
@@ -72,18 +78,111 @@ const maskApiKey = (value: string): string => {
  return `${trimmed.slice(0, 8)}...${trimmed.slice(-8)}`;
 };

+type ModelAuthDetailMode = "compact" | "verbose";
+
 const resolveAuthLabel = async (
  provider: string,
  cfg: ClawdbotConfig,
  modelsPath: string,
+  agentDir?: string,
+  mode: ModelAuthDetailMode = "compact",
 ): Promise<{ label: string; source: string }> => {
  const formatPath = (value: string) => shortenHomePath(value);
-  const store = ensureAuthProfileStore();
+  const store = ensureAuthProfileStore(agentDir, {
+    allowKeychainPrompt: false,
+  });
  const order = resolveAuthProfileOrder({ cfg, store, provider });
+  const providerKey = normalizeProviderId(provider);
+  const lastGood = (() => {
+    const map = store.lastGood;
+    if (!map) return undefined;
+    for (const [key, value] of Object.entries(map)) {
+      if (normalizeProviderId(key) === providerKey) return value;
+    }
+    return undefined;
+  })();
+  const nextProfileId = order[0];
+  const now = Date.now();
+
+  const formatUntil = (timestampMs: number) => {
+    const remainingMs = Math.max(0, timestampMs - now);
+    const minutes = Math.round(remainingMs / 60_000);
+    if (minutes < 1) return "soon";
+    if (minutes < 60) return `${minutes}m`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 48) return `${hours}h`;
+    const days = Math.round(hours / 24);
+    return `${days}d`;
+  };
+
  if (order.length > 0) {
+    if (mode === "compact") {
+      const profileId = nextProfileId;
+      if (!profileId) return { label: "missing", source: "missing" };
+      const profile = store.profiles[profileId];
+      const configProfile = cfg.auth?.profiles?.[profileId];
+      const missing =
+        !profile ||
+        (configProfile?.provider &&
+          configProfile.provider !== profile.provider) ||
+        (configProfile?.mode &&
+          configProfile.mode !== profile.type &&
+          !(configProfile.mode === "oauth" && profile.type === "token"));
+
+      const more = order.length > 1 ? ` (+${order.length - 1})` : "";
+      if (missing) return { label: `${profileId} missing${more}`, source: "" };
+
+      if (profile.type === "api_key") {
+        return {
+          label: `${profileId} api-key ${maskApiKey(profile.key)}${more}`,
+          source: "",
+        };
+      }
+      if (profile.type === "token") {
+        const exp =
+          typeof profile.expires === "number" &&
+          Number.isFinite(profile.expires) &&
+          profile.expires > 0
+            ? profile.expires <= now
+              ? " expired"
+              : ` exp ${formatUntil(profile.expires)}`
+            : "";
+        return {
+          label: `${profileId} token ${maskApiKey(profile.token)}${exp}${more}`,
+          source: "",
+        };
+      }
+      const display = resolveAuthProfileDisplayLabel({ cfg, store, profileId });
+      const label = display === profileId ? profileId : display;
+      const exp =
+        typeof profile.expires === "number" &&
+        Number.isFinite(profile.expires) &&
+        profile.expires > 0
+          ? profile.expires <= now
+            ? " expired"
+            : ` exp ${formatUntil(profile.expires)}`
+          : "";
+      return { label: `${label} oauth${exp}${more}`, source: "" };
+    }
+
    const labels = order.map((profileId) => {
      const profile = store.profiles[profileId];
      const configProfile = cfg.auth?.profiles?.[profileId];
+      const flags: string[] = [];
+      if (profileId === nextProfileId) flags.push("next");
+      if (lastGood && profileId === lastGood) flags.push("lastGood");
+      if (isProfileInCooldown(store, profileId)) {
+        const until = store.usageStats?.[profileId]?.cooldownUntil;
+        if (
+          typeof until === "number" &&
+          Number.isFinite(until) &&
+          until > now
+        ) {
+          flags.push(`cooldown ${formatUntil(until)}`);
+        } else {
+          flags.push("cooldown");
+        }
+      }
      if (
        !profile ||
        (configProfile?.provider &&
@@ -92,13 +191,27 @@ const resolveAuthLabel = async (
          configProfile.mode !== profile.type &&
          !(configProfile.mode === "oauth" && profile.type === "token"))
      ) {
-        return `${profileId}=missing`;
+        const suffix = flags.length > 0 ? ` (${flags.join(", ")})` : "";
+        return `${profileId}=missing${suffix}`;
      }
      if (profile.type === "api_key") {
-        return `${profileId}=${maskApiKey(profile.key)}`;
+        const suffix = flags.length > 0 ? ` (${flags.join(", ")})` : "";
+        return `${profileId}=${maskApiKey(profile.key)}${suffix}`;
      }
      if (profile.type === "token") {
-        return `${profileId}=token:${maskApiKey(profile.token)}`;
+        if (
+          typeof profile.expires === "number" &&
+          Number.isFinite(profile.expires) &&
+          profile.expires > 0
+        ) {
+          flags.push(
+            profile.expires <= now
+              ? "expired"
+              : `exp ${formatUntil(profile.expires)}`,
+          );
+        }
+        const suffix = flags.length > 0 ? ` (${flags.join(", ")})` : "";
+        return `${profileId}=token:${maskApiKey(profile.token)}${suffix}`;
      }
      const display = resolveAuthProfileDisplayLabel({
        cfg,
@@ -111,13 +224,24 @@ const resolveAuthLabel = async (
          : display.startsWith(profileId)
            ? display.slice(profileId.length).trim()
            : `(${display})`;
-      return `${profileId}=OAuth${suffix ? ` ${suffix}` : ""}`;
+      if (
+        typeof profile.expires === "number" &&
+        Number.isFinite(profile.expires) &&
+        profile.expires > 0
+      ) {
+        flags.push(
+          profile.expires <= now
+            ? "expired"
+            : `exp ${formatUntil(profile.expires)}`,
+        );
+      }
+      const suffixLabel = suffix ? ` ${suffix}` : "";
+      const suffixFlags = flags.length > 0 ? ` (${flags.join(", ")})` : "";
+      return `${profileId}=OAuth${suffixLabel}${suffixFlags}`;
    });
    return {
      label: labels.join(", "),
-      source: `auth-profiles.json: ${formatPath(
-        resolveAuthStorePathForDisplay(),
-      )}`,
+      source: `auth-profiles.json: ${formatPath(resolveAuthStorePathForDisplay(agentDir))}`,
    };
  }

@@ -127,13 +251,14 @@ const resolveAuthLabel = async (
      envKey.source.includes("ANTHROPIC_OAUTH_TOKEN") ||
      envKey.source.toLowerCase().includes("oauth");
    const label = isOAuthEnv ? "OAuth (env)" : maskApiKey(envKey.apiKey);
-    return { label, source: envKey.source };
+    return { label, source: mode === "verbose" ? envKey.source : "" };
  }
  const customKey = getCustomProviderApiKey(cfg, provider);
  if (customKey) {
    return {
      label: maskApiKey(customKey),
-      source: `models.json: ${formatPath(modelsPath)}`,
+      source:
+        mode === "verbose" ? `models.json: ${formatPath(modelsPath)}` : "",
    };
  }
  return { label: "missing", source: "missing" };
@@ -150,10 +275,13 @@ const resolveProfileOverride = (params: {
  rawProfile?: string;
  provider: string;
  cfg: ClawdbotConfig;
+  agentDir?: string;
 }): { profileId?: string; error?: string } => {
  const raw = params.rawProfile?.trim();
  if (!raw) return {};
-  const store = ensureAuthProfileStore();
+  const store = ensureAuthProfileStore(params.agentDir, {
+    allowKeychainPrompt: false,
+  });
  const profile = store.profiles[raw];
  if (!profile) {
    return { error: `Auth profile "${raw}" not found.` };
@@ -362,17 +490,21 @@ export async function handleDirectiveOnly(params: {
    currentReasoningLevel,
    currentElevatedLevel,
  } = params;
+  const activeAgentId = params.sessionKey
+    ? resolveAgentIdFromSessionKey(params.sessionKey)
+    : resolveDefaultAgentId(params.cfg);
+  const agentDir = resolveAgentDir(params.cfg, activeAgentId);
  const runtimeIsSandboxed = (() => {
-    const sandboxMode = params.cfg.agent?.sandbox?.mode ?? "off";
-    if (sandboxMode === "off") return false;
    const sessionKey = params.sessionKey?.trim();
    if (!sessionKey) return false;
    const agentId = resolveAgentIdFromSessionKey(sessionKey);
+    const sandboxCfg = resolveSandboxConfigForAgent(params.cfg, agentId);
+    if (sandboxCfg.mode === "off") return false;
    const mainKey = resolveAgentMainSessionKey({
      cfg: params.cfg,
      agentId,
    });
-    if (sandboxMode === "all") return true;
+    if (sandboxCfg.mode === "all") return true;
    return sessionKey !== mainKey;
  })();
  const shouldHintDirectRuntime =
@@ -383,6 +515,10 @@ export async function handleDirectiveOnly(params: {
    const isModelListAlias =
      modelDirective === "status" || modelDirective === "list";
    if (!directives.rawModelDirective || isModelListAlias) {
+      const modelsPath = `${agentDir}/models.json`;
+      const formatPath = (value: string) => shortenHomePath(value);
+      const authMode: ModelAuthDetailMode =
+        modelDirective === "status" ? "verbose" : "compact";
      if (allowedModelCatalog.length === 0) {
        const resolvedDefault = resolveConfiguredModelRef({
          cfg: params.cfg,
@@ -394,7 +530,9 @@ export async function handleDirectiveOnly(params: {
          provider: string;
          id: string;
        }> = [];
-        for (const raw of Object.keys(params.cfg.agent?.models ?? {})) {
+        for (const raw of Object.keys(
+          params.cfg.agents?.defaults?.models ?? {},
+        )) {
          const resolved = resolveModelRefFromString({
            raw: String(raw),
            defaultProvider,
@@ -420,9 +558,6 @@ export async function handleDirectiveOnly(params: {
        if (fallbackCatalog.length === 0) {
          return { text: "No models available." };
        }
-        const agentDir = resolveClawdbotAgentDir();
-        const modelsPath = `${agentDir}/models.json`;
-        const formatPath = (value: string) => shortenHomePath(value);
        const authByProvider = new Map<string, string>();
        for (const entry of fallbackCatalog) {
          if (authByProvider.has(entry.provider)) continue;
@@ -430,6 +565,8 @@ export async function handleDirectiveOnly(params: {
            entry.provider,
            params.cfg,
            modelsPath,
+            agentDir,
+            authMode,
          );
          authByProvider.set(entry.provider, formatAuthLabel(auth));
        }
@@ -438,7 +575,8 @@ export async function handleDirectiveOnly(params: {
        const lines = [
          `Current: ${current}`,
          `Default: ${defaultLabel}`,
-          `Auth file: ${formatPath(resolveAuthStorePathForDisplay())}`,
+          `Agent: ${activeAgentId}`,
+          `Auth file: ${formatPath(resolveAuthStorePathForDisplay(agentDir))}`,
          `⚠️ Model catalog unavailable; showing configured models only.`,
        ];
        const byProvider = new Map<string, typeof fallbackCatalog>();
@@ -466,9 +604,6 @@ export async function handleDirectiveOnly(params: {
        }
        return { text: lines.join("\n") };
      }
-      const agentDir = resolveClawdbotAgentDir();
-      const modelsPath = `${agentDir}/models.json`;
-      const formatPath = (value: string) => shortenHomePath(value);
      const authByProvider = new Map<string, string>();
      for (const entry of allowedModelCatalog) {
        if (authByProvider.has(entry.provider)) continue;
@@ -476,6 +611,8 @@ export async function handleDirectiveOnly(params: {
          entry.provider,
          params.cfg,
          modelsPath,
+          agentDir,
+          authMode,
        );
        authByProvider.set(entry.provider, formatAuthLabel(auth));
      }
@@ -484,7 +621,8 @@ export async function handleDirectiveOnly(params: {
      const lines = [
        `Current: ${current}`,
        `Default: ${defaultLabel}`,
-        `Auth file: ${formatPath(resolveAuthStorePathForDisplay())}`,
+        `Agent: ${activeAgentId}`,
+        `Auth file: ${formatPath(resolveAuthStorePathForDisplay(agentDir))}`,
      ];
      if (resetModelOverride) {
        lines.push(`(previous selection reset to default)`);
@@ -686,6 +824,7 @@ export async function handleDirectiveOnly(params: {
          rawProfile: directives.rawModelProfile,
          provider: modelSelection.provider,
          cfg: params.cfg,
+          agentDir,
        });
        if (profileResolved.error) {
          return { text: profileResolved.error };
@@ -837,6 +976,7 @@ export async function persistInlineDirectives(params: {
  directives: InlineDirectives;
  effectiveModelDirective?: string;
  cfg: ClawdbotConfig;
+  agentDir?: string;
  sessionEntry?: SessionEntry;
  sessionStore?: Record<string, SessionEntry>;
  sessionKey?: string;
@@ -851,7 +991,7 @@ export async function persistInlineDirectives(params: {
  model: string;
  initialModelLabel: string;
  formatModelSwitchEvent: (label: string, alias?: string) => string;
-  agentCfg: ClawdbotConfig["agent"] | undefined;
+  agentCfg: NonNullable<ClawdbotConfig["agents"]>["defaults"] | undefined;
 }): Promise<{ provider: string; model: string; contextTokens: number }> {
  const {
    directives,
@@ -871,6 +1011,10 @@ export async function persistInlineDirectives(params: {
    agentCfg,
  } = params;
  let { provider, model } = params;
+  const activeAgentId = sessionKey
+    ? resolveAgentIdFromSessionKey(sessionKey)
+    : resolveDefaultAgentId(cfg);
+  const agentDir = resolveAgentDir(cfg, activeAgentId);

  if (sessionEntry && sessionStore && sessionKey) {
    let updated = false;
@@ -930,6 +1074,7 @@ export async function persistInlineDirectives(params: {
              rawProfile: directives.rawModelProfile,
              provider: resolved.ref.provider,
              cfg,
+              agentDir,
            });
            if (profileResolved.error) {
              throw new Error(profileResolved.error);
@@ -1007,13 +1152,16 @@ export function resolveDefaultModel(params: {
    agentModelOverride && agentModelOverride.length > 0
      ? {
          ...params.cfg,
-          agent: {
-            ...params.cfg.agent,
-            model: {
-              ...(typeof params.cfg.agent?.model === "object"
-                ? params.cfg.agent.model
-                : undefined),
-              primary: agentModelOverride,
+          agents: {
+            ...params.cfg.agents,
+            defaults: {
+              ...params.cfg.agents?.defaults,
+              model: {
+                ...(typeof params.cfg.agents?.defaults?.model === "object"
+                  ? params.cfg.agents.defaults.model
+                  : undefined),
+                primary: agentModelOverride,
+              },
            },
          },
        }
--- a/src/auto-reply/reply/dispatch-from-config.ts
+++ b/src/auto-reply/reply/dispatch-from-config.ts
@@ -53,6 +53,7 @@ export async function dispatchReplyFromConfig(params: {
      payload,
      channel: originatingChannel,
      to: originatingTo,
+      sessionKey: ctx.SessionKey,
      accountId: ctx.AccountId,
      threadId: ctx.MessageThreadId,
      cfg,
@@ -106,6 +107,7 @@ export async function dispatchReplyFromConfig(params: {
        payload: reply,
        channel: originatingChannel,
        to: originatingTo,
+        sessionKey: ctx.SessionKey,
        accountId: ctx.AccountId,
        threadId: ctx.MessageThreadId,
        cfg,
--- a/src/auto-reply/reply/followup-runner.ts
+++ b/src/auto-reply/reply/followup-runner.ts
@@ -19,10 +19,7 @@ import {
  filterMessagingToolDuplicates,
  shouldSuppressMessagingToolReplies,
 } from "./reply-payloads.js";
-import {
-  createReplyToModeFilter,
-  resolveReplyToMode,
-} from "./reply-threading.js";
+import { resolveReplyToMode } from "./reply-threading.js";
 import { isRoutableChannel, routeReply } from "./route-reply.js";
 import { incrementCompactionCount } from "./session-updates.js";
 import type { TypingController } from "./typing.js";
@@ -97,6 +94,7 @@ export function createFollowupRunner(params: {
          payload,
          channel: originatingChannel,
          to: originatingTo,
+          sessionKey: queued.run.sessionKey,
          accountId: queued.originatingAccountId,
          threadId: queued.originatingThreadId,
          cfg: queued.run.config,
@@ -194,13 +192,12 @@ export function createFollowupRunner(params: {
        (queued.run.messageProvider?.toLowerCase() as
          | OriginatingChannelType
          | undefined);
-      const applyReplyToMode = createReplyToModeFilter(
-        resolveReplyToMode(queued.run.config, replyToChannel),
-      );
+      const replyToMode = resolveReplyToMode(queued.run.config, replyToChannel);

      const replyTaggedPayloads: ReplyPayload[] = applyReplyThreading({
        payloads: sanitizedPayloads,
-        applyReplyToMode,
+        replyToMode,
+        replyToChannel,
      });

      const dedupedPayloads = filterMessagingToolDuplicates({
--- a/src/auto-reply/reply/mentions.test.ts
+++ b/src/auto-reply/reply/mentions.test.ts
@@ -9,7 +9,7 @@ import {
 describe("mention helpers", () => {
  it("builds regexes and skips invalid patterns", () => {
    const regexes = buildMentionRegexes({
-      routing: {
+      messages: {
        groupChat: { mentionPatterns: ["\\bclawd\\b", "(invalid"] },
      },
    });
@@ -23,7 +23,7 @@ describe("mention helpers", () => {

  it("matches patterns case-insensitively", () => {
    const regexes = buildMentionRegexes({
-      routing: { groupChat: { mentionPatterns: ["\\bclawd\\b"] } },
+      messages: { groupChat: { mentionPatterns: ["\\bclawd\\b"] } },
    });
    expect(matchesMentionPatterns("CLAWD: hi", regexes)).toBe(true);
  });
@@ -31,11 +31,16 @@ describe("mention helpers", () => {
  it("uses per-agent mention patterns when configured", () => {
    const regexes = buildMentionRegexes(
      {
-        routing: {
+        messages: {
          groupChat: { mentionPatterns: ["\\bglobal\\b"] },
-          agents: {
-            work: { mentionPatterns: ["\\bworkbot\\b"] },
-          },
+        },
+        agents: {
+          list: [
+            {
+              id: "work",
+              groupChat: { mentionPatterns: ["\\bworkbot\\b"] },
+            },
+          ],
        },
      },
      "work",
--- a/src/auto-reply/reply/mentions.ts
+++ b/src/auto-reply/reply/mentions.ts
@@ -1,23 +1,62 @@
+import { resolveAgentConfig } from "../../agents/agent-scope.js";
 import type { ClawdbotConfig } from "../../config/config.js";
 import type { MsgContext } from "../templating.js";

+function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function deriveMentionPatterns(identity?: { name?: string; emoji?: string }) {
+  const patterns: string[] = [];
+  const name = identity?.name?.trim();
+  if (name) {
+    const parts = name.split(/\s+/).filter(Boolean).map(escapeRegExp);
+    const re = parts.length ? parts.join(String.raw`\s+`) : escapeRegExp(name);
+    patterns.push(String.raw`\b@?${re}\b`);
+  }
+  const emoji = identity?.emoji?.trim();
+  if (emoji) {
+    patterns.push(escapeRegExp(emoji));
+  }
+  return patterns;
+}
+
+const BACKSPACE_CHAR = "\u0008";
+
+function normalizeMentionPattern(pattern: string): string {
+  if (!pattern.includes(BACKSPACE_CHAR)) return pattern;
+  return pattern.split(BACKSPACE_CHAR).join("\\b");
+}
+
+function normalizeMentionPatterns(patterns: string[]): string[] {
+  return patterns.map(normalizeMentionPattern);
+}
+
 function resolveMentionPatterns(
  cfg: ClawdbotConfig | undefined,
  agentId?: string,
 ): string[] {
  if (!cfg) return [];
-  const agentConfig = agentId ? cfg.routing?.agents?.[agentId] : undefined;
-  if (agentConfig && Object.hasOwn(agentConfig, "mentionPatterns")) {
-    return agentConfig.mentionPatterns ?? [];
+  const agentConfig = agentId ? resolveAgentConfig(cfg, agentId) : undefined;
+  const agentGroupChat = agentConfig?.groupChat;
+  if (agentGroupChat && Object.hasOwn(agentGroupChat, "mentionPatterns")) {
+    return agentGroupChat.mentionPatterns ?? [];
  }
-  return cfg.routing?.groupChat?.mentionPatterns ?? [];
+  const globalGroupChat = cfg.messages?.groupChat;
+  if (globalGroupChat && Object.hasOwn(globalGroupChat, "mentionPatterns")) {
+    return globalGroupChat.mentionPatterns ?? [];
+  }
+  const derived = deriveMentionPatterns(agentConfig?.identity);
+  return derived.length > 0 ? derived : [];
 }

 export function buildMentionRegexes(
  cfg: ClawdbotConfig | undefined,
  agentId?: string,
 ): RegExp[] {
-  const patterns = resolveMentionPatterns(cfg, agentId);
+  const patterns = normalizeMentionPatterns(
+    resolveMentionPatterns(cfg, agentId),
+  );
  return patterns
    .map((pattern) => {
      try {
@@ -66,7 +105,9 @@ export function stripMentions(
  agentId?: string,
 ): string {
  let result = text;
-  const patterns = resolveMentionPatterns(cfg, agentId);
+  const patterns = normalizeMentionPatterns(
+    resolveMentionPatterns(cfg, agentId),
+  );
  for (const p of patterns) {
    try {
      const re = new RegExp(p, "gi");
--- a/src/auto-reply/reply/model-selection.ts
+++ b/src/auto-reply/reply/model-selection.ts
@@ -33,7 +33,9 @@ type ModelSelectionState = {

 export async function createModelSelectionState(params: {
  cfg: ClawdbotConfig;
-  agentCfg: ClawdbotConfig["agent"] | undefined;
+  agentCfg:
+    | NonNullable<NonNullable<ClawdbotConfig["agents"]>["defaults"]>
+    | undefined;
  sessionEntry?: SessionEntry;
  sessionStore?: Record<string, SessionEntry>;
  sessionKey?: string;
@@ -201,7 +203,9 @@ export function resolveModelDirectiveSelection(params: {
 }

 export function resolveContextTokens(params: {
-  agentCfg: ClawdbotConfig["agent"] | undefined;
+  agentCfg:
+    | NonNullable<NonNullable<ClawdbotConfig["agents"]>["defaults"]>
+    | undefined;
  model: string;
 }): number {
  return (
--- a/src/auto-reply/reply/normalize-reply.ts
+++ b/src/auto-reply/reply/normalize-reply.ts
@@ -0,0 +1,49 @@
+import { stripHeartbeatToken } from "../heartbeat.js";
+import { HEARTBEAT_TOKEN, SILENT_REPLY_TOKEN } from "../tokens.js";
+import type { ReplyPayload } from "../types.js";
+
+export type NormalizeReplyOptions = {
+  responsePrefix?: string;
+  onHeartbeatStrip?: () => void;
+  stripHeartbeat?: boolean;
+  silentToken?: string;
+};
+
+export function normalizeReplyPayload(
+  payload: ReplyPayload,
+  opts: NormalizeReplyOptions = {},
+): ReplyPayload | null {
+  const hasMedia = Boolean(
+    payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0,
+  );
+  const trimmed = payload.text?.trim() ?? "";
+  if (!trimmed && !hasMedia) return null;
+
+  const silentToken = opts.silentToken ?? SILENT_REPLY_TOKEN;
+  if (trimmed === silentToken && !hasMedia) return null;
+
+  let text = payload.text ?? undefined;
+  if (text && !trimmed) {
+    // Keep empty text when media exists so media-only replies still send.
+    text = "";
+  }
+
+  const shouldStripHeartbeat = opts.stripHeartbeat ?? true;
+  if (shouldStripHeartbeat && text?.includes(HEARTBEAT_TOKEN)) {
+    const stripped = stripHeartbeatToken(text, { mode: "message" });
+    if (stripped.didStrip) opts.onHeartbeatStrip?.();
+    if (stripped.shouldSkip && !hasMedia) return null;
+    text = stripped.text;
+  }
+
+  if (
+    opts.responsePrefix &&
+    text &&
+    text.trim() !== HEARTBEAT_TOKEN &&
+    !text.startsWith(opts.responsePrefix)
+  ) {
+    text = `${opts.responsePrefix} ${text}`;
+  }
+
+  return { ...payload, text };
+}
--- a/src/auto-reply/reply/queue.ts
+++ b/src/auto-reply/reply/queue.ts
@@ -553,7 +553,7 @@ export function resolveQueueSettings(params: {
  inlineOptions?: Partial<QueueSettings>;
 }): QueueSettings {
  const providerKey = params.provider?.trim().toLowerCase();
-  const queueCfg = params.cfg.routing?.queue;
+  const queueCfg = params.cfg.messages?.queue;
  const providerModeRaw =
    providerKey && queueCfg?.byProvider
      ? (queueCfg.byProvider as Record<string, string | undefined>)[providerKey]
--- a/src/auto-reply/reply/reply-dispatcher.ts
+++ b/src/auto-reply/reply/reply-dispatcher.ts
@@ -1,6 +1,5 @@
-import { stripHeartbeatToken } from "../heartbeat.js";
-import { HEARTBEAT_TOKEN, SILENT_REPLY_TOKEN } from "../tokens.js";
 import type { GetReplyOptions, ReplyPayload } from "../types.js";
+import { normalizeReplyPayload } from "./normalize-reply.js";
 import type { TypingController } from "./typing.js";

 export type ReplyDispatchKind = "tool" | "block" | "final";
@@ -45,41 +44,14 @@ export type ReplyDispatcher = {
  getQueuedCounts: () => Record<ReplyDispatchKind, number>;
 };

-function normalizeReplyPayload(
+function normalizeReplyPayloadInternal(
  payload: ReplyPayload,
  opts: Pick<ReplyDispatcherOptions, "responsePrefix" | "onHeartbeatStrip">,
 ): ReplyPayload | null {
-  const hasMedia = Boolean(
-    payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0,
-  );
-  const trimmed = payload.text?.trim() ?? "";
-  if (!trimmed && !hasMedia) return null;
-
-  // Avoid sending the explicit silent token when no media is attached.
-  if (trimmed === SILENT_REPLY_TOKEN && !hasMedia) return null;
-
-  let text = payload.text ?? undefined;
-  if (text && !trimmed) {
-    // Keep empty text when media exists so media-only replies still send.
-    text = "";
-  }
-  if (text?.includes(HEARTBEAT_TOKEN)) {
-    const stripped = stripHeartbeatToken(text, { mode: "message" });
-    if (stripped.didStrip) opts.onHeartbeatStrip?.();
-    if (stripped.shouldSkip && !hasMedia) return null;
-    text = stripped.text;
-  }
-
-  if (
-    opts.responsePrefix &&
-    text &&
-    text.trim() !== HEARTBEAT_TOKEN &&
-    !text.startsWith(opts.responsePrefix)
-  ) {
-    text = `${opts.responsePrefix} ${text}`;
-  }
-
-  return { ...payload, text };
+  return normalizeReplyPayload(payload, {
+    responsePrefix: opts.responsePrefix,
+    onHeartbeatStrip: opts.onHeartbeatStrip,
+  });
 }

 export function createReplyDispatcher(
@@ -96,7 +68,7 @@ export function createReplyDispatcher(
  };

  const enqueue = (kind: ReplyDispatchKind, payload: ReplyPayload) => {
-    const normalized = normalizeReplyPayload(payload, options);
+    const normalized = normalizeReplyPayloadInternal(payload, options);
    if (!normalized) return false;
    queuedCounts[kind] += 1;
    pending += 1;
--- a/src/auto-reply/reply/reply-payloads.ts
+++ b/src/auto-reply/reply/reply-payloads.ts
@@ -1,16 +1,17 @@
 import { isMessagingToolDuplicate } from "../../agents/pi-embedded-helpers.js";
 import type { MessagingToolSend } from "../../agents/pi-embedded-runner.js";
+import type { ReplyToMode } from "../../config/types.js";
+import type { OriginatingChannelType } from "../templating.js";
 import type { ReplyPayload } from "../types.js";
 import { extractReplyToTag } from "./reply-tags.js";
-
-export type ReplyToModeFilter = (payload: ReplyPayload) => ReplyPayload;
+import { createReplyToModeFilterForChannel } from "./reply-threading.js";

 export function applyReplyTagsToPayload(
  payload: ReplyPayload,
  currentMessageId?: string,
 ): ReplyPayload {
  if (typeof payload.text !== "string") return payload;
-  const { cleaned, replyToId } = extractReplyToTag(
+  const { cleaned, replyToId, hasTag } = extractReplyToTag(
    payload.text,
    currentMessageId,
  );
@@ -18,6 +19,7 @@ export function applyReplyTagsToPayload(
    ...payload,
    text: cleaned ? cleaned : undefined,
    replyToId: replyToId ?? payload.replyToId,
+    replyToTag: hasTag || payload.replyToTag,
  };
 }

@@ -31,10 +33,15 @@ export function isRenderablePayload(payload: ReplyPayload): boolean {

 export function applyReplyThreading(params: {
  payloads: ReplyPayload[];
-  applyReplyToMode: ReplyToModeFilter;
+  replyToMode: ReplyToMode;
+  replyToChannel?: OriginatingChannelType;
  currentMessageId?: string;
 }): ReplyPayload[] {
-  const { payloads, applyReplyToMode, currentMessageId } = params;
+  const { payloads, replyToMode, replyToChannel, currentMessageId } = params;
+  const applyReplyToMode = createReplyToModeFilterForChannel(
+    replyToMode,
+    replyToChannel,
+  );
  return payloads
    .map((payload) => applyReplyTagsToPayload(payload, currentMessageId))
    .filter(isRenderablePayload)
--- a/src/auto-reply/reply/reply-threading.test.ts
+++ b/src/auto-reply/reply/reply-threading.test.ts
@@ -40,6 +40,13 @@ describe("createReplyToModeFilter", () => {
    expect(filter({ text: "hi", replyToId: "1" }).replyToId).toBeUndefined();
  });

+  it("keeps replyToId when mode is off and reply tags are allowed", () => {
+    const filter = createReplyToModeFilter("off", { allowTagsWhenOff: true });
+    expect(
+      filter({ text: "hi", replyToId: "1", replyToTag: true }).replyToId,
+    ).toBe("1");
+  });
+
  it("keeps replyToId when mode is all", () => {
    const filter = createReplyToModeFilter("all");
    expect(filter({ text: "hi", replyToId: "1" }).replyToId).toBe("1");
--- a/src/auto-reply/reply/reply-threading.ts
+++ b/src/auto-reply/reply/reply-threading.ts
@@ -19,11 +19,15 @@ export function resolveReplyToMode(
  }
 }

-export function createReplyToModeFilter(mode: ReplyToMode) {
+export function createReplyToModeFilter(
+  mode: ReplyToMode,
+  opts: { allowTagsWhenOff?: boolean } = {},
+) {
  let hasThreaded = false;
  return (payload: ReplyPayload): ReplyPayload => {
    if (!payload.replyToId) return payload;
    if (mode === "off") {
+      if (opts.allowTagsWhenOff && payload.replyToTag) return payload;
      return { ...payload, replyToId: undefined };
    }
    if (mode === "all") return payload;
@@ -34,3 +38,12 @@ export function createReplyToModeFilter(mode: ReplyToMode) {
    return payload;
  };
 }
+
+export function createReplyToModeFilterForChannel(
+  mode: ReplyToMode,
+  channel?: OriginatingChannelType,
+) {
+  return createReplyToModeFilter(mode, {
+    allowTagsWhenOff: channel === "slack",
+  });
+}
--- a/src/auto-reply/reply/route-reply.test.ts
+++ b/src/auto-reply/reply/route-reply.test.ts
@@ -1,8 +1,15 @@
 import { describe, expect, it, vi } from "vitest";

+import type { ClawdbotConfig } from "../../config/config.js";
+import { SILENT_REPLY_TOKEN } from "../tokens.js";
+
 const mocks = vi.hoisted(() => ({
  sendMessageDiscord: vi.fn(async () => ({ messageId: "m1", channelId: "c1" })),
  sendMessageIMessage: vi.fn(async () => ({ messageId: "ok" })),
+  sendMessageMSTeams: vi.fn(async () => ({
+    messageId: "m1",
+    conversationId: "c1",
+  })),
  sendMessageSignal: vi.fn(async () => ({ messageId: "t1" })),
  sendMessageSlack: vi.fn(async () => ({ messageId: "m1", channelId: "c1" })),
  sendMessageTelegram: vi.fn(async () => ({ messageId: "m1", chatId: "c1" })),
@@ -15,6 +22,9 @@ vi.mock("../../discord/send.js", () => ({
 vi.mock("../../imessage/send.js", () => ({
  sendMessageIMessage: mocks.sendMessageIMessage,
 }));
+vi.mock("../../msteams/send.js", () => ({
+  sendMessageMSTeams: mocks.sendMessageMSTeams,
+}));
 vi.mock("../../signal/send.js", () => ({
  sendMessageSignal: mocks.sendMessageSignal,
 }));
@@ -59,6 +69,63 @@ describe("routeReply", () => {
    expect(mocks.sendMessageSlack).not.toHaveBeenCalled();
  });

+  it("drops silent token payloads", async () => {
+    mocks.sendMessageSlack.mockClear();
+    const res = await routeReply({
+      payload: { text: SILENT_REPLY_TOKEN },
+      channel: "slack",
+      to: "channel:C123",
+      cfg: {} as never,
+    });
+    expect(res.ok).toBe(true);
+    expect(mocks.sendMessageSlack).not.toHaveBeenCalled();
+  });
+
+  it("applies responsePrefix when routing", async () => {
+    mocks.sendMessageSlack.mockClear();
+    const cfg = {
+      messages: { responsePrefix: "[clawdbot]" },
+    } as unknown as ClawdbotConfig;
+    await routeReply({
+      payload: { text: "hi" },
+      channel: "slack",
+      to: "channel:C123",
+      cfg,
+    });
+    expect(mocks.sendMessageSlack).toHaveBeenCalledWith(
+      "channel:C123",
+      "[clawdbot] hi",
+      expect.any(Object),
+    );
+  });
+
+  it("derives responsePrefix from agent identity when routing", async () => {
+    mocks.sendMessageSlack.mockClear();
+    const cfg = {
+      agents: {
+        list: [
+          {
+            id: "rich",
+            identity: { name: "Richbot", theme: "lion bot", emoji: "🦁" },
+          },
+        ],
+      },
+      messages: {},
+    } as unknown as ClawdbotConfig;
+    await routeReply({
+      payload: { text: "hi" },
+      channel: "slack",
+      to: "channel:C123",
+      sessionKey: "agent:rich:main",
+      cfg,
+    });
+    expect(mocks.sendMessageSlack).toHaveBeenCalledWith(
+      "channel:C123",
+      "[Richbot] hi",
+      expect.any(Object),
+    );
+  });
+
  it("passes thread id to Telegram sends", async () => {
    mocks.sendMessageTelegram.mockClear();
    await routeReply({
@@ -143,4 +210,25 @@ describe("routeReply", () => {
      expect.objectContaining({ accountId: "acc-1", verbose: false }),
    );
  });
+
+  it("routes MS Teams via proactive sender", async () => {
+    mocks.sendMessageMSTeams.mockClear();
+    const cfg = {
+      msteams: {
+        enabled: true,
+      },
+    } as unknown as ClawdbotConfig;
+    await routeReply({
+      payload: { text: "hi" },
+      channel: "msteams",
+      to: "conversation:19:abc@thread.tacv2",
+      cfg,
+    });
+    expect(mocks.sendMessageMSTeams).toHaveBeenCalledWith({
+      cfg,
+      to: "conversation:19:abc@thread.tacv2",
+      text: "hi",
+      mediaUrl: undefined,
+    });
+  });
 });
--- a/src/auto-reply/reply/route-reply.ts
+++ b/src/auto-reply/reply/route-reply.ts
@@ -7,15 +7,19 @@
 * across multiple providers.
 */

+import { resolveEffectiveMessagesConfig } from "../../agents/identity.js";
 import type { ClawdbotConfig } from "../../config/config.js";
 import { sendMessageDiscord } from "../../discord/send.js";
 import { sendMessageIMessage } from "../../imessage/send.js";
+import { sendMessageMSTeams } from "../../msteams/send.js";
+import { resolveAgentIdFromSessionKey } from "../../routing/session-key.js";
 import { sendMessageSignal } from "../../signal/send.js";
 import { sendMessageSlack } from "../../slack/send.js";
 import { sendMessageTelegram } from "../../telegram/send.js";
 import { sendMessageWhatsApp } from "../../web/outbound.js";
 import type { OriginatingChannelType } from "../templating.js";
 import type { ReplyPayload } from "../types.js";
+import { normalizeReplyPayload } from "./normalize-reply.js";

 export type RouteReplyParams = {
  /** The reply payload to send. */
@@ -24,6 +28,8 @@ export type RouteReplyParams = {
  channel: OriginatingChannelType;
  /** The destination chat/channel/user ID. */
  to: string;
+  /** Session key for deriving agent identity defaults (multi-agent). */
+  sessionKey?: string;
  /** Provider account id (multi-account). */
  accountId?: string;
  /** Telegram message thread id (forum topics). */
@@ -54,16 +60,28 @@ export type RouteReplyResult = {
 export async function routeReply(
  params: RouteReplyParams,
 ): Promise<RouteReplyResult> {
-  const { payload, channel, to, accountId, threadId, abortSignal } = params;
+  const { payload, channel, to, accountId, threadId, cfg, abortSignal } =
+    params;

  // Debug: `pnpm test src/auto-reply/reply/route-reply.test.ts`
-  const text = payload.text ?? "";
-  const mediaUrls = (payload.mediaUrls?.filter(Boolean) ?? []).length
-    ? (payload.mediaUrls?.filter(Boolean) as string[])
-    : payload.mediaUrl
-      ? [payload.mediaUrl]
+  const responsePrefix = params.sessionKey
+    ? resolveEffectiveMessagesConfig(
+        cfg,
+        resolveAgentIdFromSessionKey(params.sessionKey),
+      ).responsePrefix
+    : cfg.messages?.responsePrefix;
+  const normalized = normalizeReplyPayload(payload, {
+    responsePrefix,
+  });
+  if (!normalized) return { ok: true };
+
+  const text = normalized.text ?? "";
+  const mediaUrls = (normalized.mediaUrls?.filter(Boolean) ?? []).length
+    ? (normalized.mediaUrls?.filter(Boolean) as string[])
+    : normalized.mediaUrl
+      ? [normalized.mediaUrl]
      : [];
-  const replyToId = payload.replyToId;
+  const replyToId = normalized.replyToId;

  // Skip empty replies.
  if (!text.trim() && mediaUrls.length === 0) {
@@ -145,6 +163,16 @@ export async function routeReply(
        };
      }

+      case "msteams": {
+        const result = await sendMessageMSTeams({
+          cfg,
+          to,
+          text,
+          mediaUrl,
+        });
+        return { ok: true, messageId: result.messageId };
+      }
+
      default: {
        const _exhaustive: never = channel;
        return { ok: false, error: `Unknown channel: ${String(_exhaustive)}` };
@@ -195,7 +223,8 @@ export function isRoutableChannel(
  | "discord"
  | "signal"
  | "imessage"
-  | "whatsapp" {
+  | "whatsapp"
+  | "msteams" {
  if (!channel) return false;
  return [
    "telegram",
@@ -204,5 +233,6 @@ export function isRoutableChannel(
    "signal",
    "imessage",
    "whatsapp",
+    "msteams",
  ].includes(channel);
 }
--- a/src/auto-reply/reply/session-updates.ts
+++ b/src/auto-reply/reply/session-updates.ts
@@ -91,7 +91,7 @@ export async function ensureSkillSnapshot(params: {
      systemSent: true,
      skillsSnapshot: skillSnapshot,
    };
-    sessionStore[sessionKey] = nextEntry;
+    sessionStore[sessionKey] = { ...sessionStore[sessionKey], ...nextEntry };
    if (storePath) {
      await saveSessionStore(storePath, sessionStore);
    }
@@ -123,7 +123,7 @@ export async function ensureSkillSnapshot(params: {
      updatedAt: Date.now(),
      skillsSnapshot,
    };
-    sessionStore[sessionKey] = nextEntry;
+    sessionStore[sessionKey] = { ...sessionStore[sessionKey], ...nextEntry };
    if (storePath) {
      await saveSessionStore(storePath, sessionStore);
    }
--- a/src/auto-reply/reply/session.ts
+++ b/src/auto-reply/reply/session.ts
@@ -264,7 +264,7 @@ export async function initSessionState(params: {
      ctx.MessageThreadId,
    );
  }
-  sessionStore[sessionKey] = sessionEntry;
+  sessionStore[sessionKey] = { ...sessionStore[sessionKey], ...sessionEntry };
  await saveSessionStore(storePath, sessionStore);

  const sessionCtx: TemplateContext = {