feat: thread-bound subagents on Discord (#21805)

* docs: thread-bound subagents plan

* docs: add exact thread-bound subagent implementation touchpoints

* Docs: prioritize auto thread-bound subagent flow

* Docs: add ACP harness thread-binding extensions

* Discord: add thread-bound session routing and auto-bind spawn flow

* Subagents: add focus commands and ACP/session binding lifecycle hooks

* Tests: cover thread bindings, focus commands, and ACP unbind hooks

* Docs: add plugin-hook appendix for thread-bound subagents

* Plugins: add subagent lifecycle hook events

* Core: emit subagent lifecycle hooks and decouple Discord bindings

* Discord: handle subagent bind lifecycle via plugin hooks

* Subagents: unify completion finalizer and split registry modules

* Add subagent lifecycle events module

* Hooks: fix subagent ended context key

* Discord: share thread bindings across ESM and Jiti

* Subagents: add persistent sessions_spawn mode for thread-bound sessions

* Subagents: clarify thread intro and persistent completion copy

* test(subagents): stabilize sessions_spawn lifecycle cleanup assertions

* Discord: add thread-bound session TTL with auto-unfocus

* Subagents: fail session spawns when thread bind fails

* Subagents: cover thread session failure cleanup paths

* Session: add thread binding TTL config and /session ttl controls

* Tests: align discord reaction expectations

* Agent: persist sessionFile for keyed subagent sessions

* Discord: normalize imports after conflict resolution

* Sessions: centralize sessionFile resolve/persist helper

* Discord: harden thread-bound subagent session routing

* Rebase: resolve upstream/main conflicts

* Subagents: move thread binding into hooks and split bindings modules

* Docs: add channel-agnostic subagent routing hook plan

* Agents: decouple subagent routing from Discord

* Discord: refactor thread-bound subagent flows

* Subagents: prevent duplicate end hooks and orphaned failed sessions

* Refactor: split subagent command and provider phases

* Subagents: honor hook delivery target overrides

* Discord: add thread binding kill switches and refresh plan doc

* Discord: fix thread bind channel resolution

* Routing: centralize account id normalization

* Discord: clean up thread bindings on startup failures

* Discord: add startup cleanup regression tests

* Docs: add long-term thread-bound subagent architecture

* Docs: split session binding plan and dedupe thread-bound doc

* Subagents: add channel-agnostic session binding routing

* Subagents: stabilize announce completion routing tests

* Subagents: cover multi-bound completion routing

* Subagents: suppress lifecycle hooks on failed thread bind

* tests: fix discord provider mock typing regressions

* docs/protocol: sync slash command aliases and delete param models

* fix: add changelog entry for Discord thread-bound subagents (#21805) (thanks @onutc)

---------

Co-authored-by: Shadow <hi@shadowing.dev>

src/discord/monitor/thread-bindings.messages.ts

@@ -0,0 +1,72 @@
+import { DEFAULT_FAREWELL_TEXT, type ThreadBindingRecord } from "./thread-bindings.types.js";
+
+function normalizeThreadBindingMessageTtlMs(raw: unknown): number {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) {
+    return 0;
+  }
+  const ttlMs = Math.floor(raw);
+  if (ttlMs < 0) {
+    return 0;
+  }
+  return ttlMs;
+}
+
+export function formatThreadBindingTtlLabel(ttlMs: number): string {
+  if (ttlMs <= 0) {
+    return "disabled";
+  }
+  if (ttlMs < 60_000) {
+    return "<1m";
+  }
+  const totalMinutes = Math.floor(ttlMs / 60_000);
+  if (totalMinutes % 60 === 0) {
+    return `${Math.floor(totalMinutes / 60)}h`;
+  }
+  return `${totalMinutes}m`;
+}
+
+export function resolveThreadBindingThreadName(params: {
+  agentId?: string;
+  label?: string;
+}): string {
+  const label = params.label?.trim();
+  const base = label || params.agentId?.trim() || "agent";
+  const raw = `🤖 ${base}`.replace(/\s+/g, " ").trim();
+  return raw.slice(0, 100);
+}
+
+export function resolveThreadBindingIntroText(params: {
+  agentId?: string;
+  label?: string;
+  sessionTtlMs?: number;
+}): string {
+  const label = params.label?.trim();
+  const base = label || params.agentId?.trim() || "agent";
+  const normalized = base.replace(/\s+/g, " ").trim().slice(0, 100) || "agent";
+  const ttlMs = normalizeThreadBindingMessageTtlMs(params.sessionTtlMs);
+  if (ttlMs > 0) {
+    return `🤖 ${normalized} session active (auto-unfocus in ${formatThreadBindingTtlLabel(ttlMs)}). Messages here go directly to this session.`;
+  }
+  return `🤖 ${normalized} session active. Messages here go directly to this session.`;
+}
+
+export function resolveThreadBindingFarewellText(params: {
+  reason?: string;
+  farewellText?: string;
+  sessionTtlMs: number;
+}): string {
+  const custom = params.farewellText?.trim();
+  if (custom) {
+    return custom;
+  }
+  if (params.reason === "ttl-expired") {
+    return `Session ended automatically after ${formatThreadBindingTtlLabel(params.sessionTtlMs)}. Messages here will no longer be routed.`;
+  }
+  return DEFAULT_FAREWELL_TEXT;
+}
+
+export function summarizeBindingPersona(record: ThreadBindingRecord): string {
+  const label = record.label?.trim();
+  const base = label || record.agentId;
+  return (`🤖 ${base}`.trim() || "🤖 agent").slice(0, 80);
+}