mixdog 0.9.19 → 0.9.21

package/src/runtime/channels/index.mjs

@@ -1,2192 +1,15 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { performance } from "perf_hooks";
-import { createRequire } from "module";
-const _require = createRequire(import.meta.url);
-import { loadConfig, createBackend, loadProfileConfig, DATA_DIR } from "./lib/config.mjs";
-import { resolveVoiceRuntime } from "./lib/voice-runtime-fetcher.mjs";
-import { ensureReady, stopVoiceWhisperServer } from "./lib/whisper-server.mjs";
-import { loadConfig as loadAgentConfig } from "../agent/orchestrator/config.mjs";
-import { captureOriginalUserCwd, readLastSessionCwd } from "../shared/user-cwd.mjs";
-import { initProviders } from "../agent/orchestrator/providers/registry.mjs";
-import { Scheduler } from "./lib/scheduler.mjs";
-import { startSnapshotWriter, stopSnapshotWriter, recordFetchedMessages } from "./lib/status-snapshot.mjs";
-import { hasPending as dispatchHasPending } from "../agent/orchestrator/dispatch-persist.mjs";
-import { setListener as setActivityBusListener } from "../agent/orchestrator/activity-bus.mjs";
-import { stripSoftWarns } from "../agent/orchestrator/tool-loop-guard.mjs";
-import { WebhookServer } from "./lib/webhook.mjs";
-import { EventPipeline } from "./lib/event-pipeline.mjs";
-import { startCliWorker } from "./lib/cli-worker-host.mjs";
-import {
-  OutputForwarder,
-  discoverSessionBoundTranscript,
-  findLatestTranscriptByMtime,
-  sameResolvedPath
-} from "./lib/output-forwarder.mjs";
-import { controlClaudeSession } from "./lib/session-control.mjs";
-import { JsonStateFile, ensureDir, removeFileIfExists, writeTextFile } from "./lib/state-file.mjs";
-import {
-  buildModalRequestSpec,
-  PendingInteractionStore
-} from "./lib/interaction-workflows.mjs";
-import {
-  ensureRuntimeDirs,
-  makeInstanceId,
-  getTurnEndPath,
-  getStatusPath,
-  getPermissionResultPath,
-  getChannelOwnerPath,
-  getActiveOwnerPid,
-  getTerminalLeadPid,
-  readActiveInstance,
-  refreshActiveInstance,
-  cleanupStaleRuntimeFiles,
-  probeActiveOwner,
-  cleanupInstanceRuntimeFiles,
-  releaseOwnedChannelLocks,
-  clearActiveInstance,
-  notePreviousServerIfAny,
-  writeServerPid,
-  clearServerPid,
-  RUNTIME_ROOT
-} from "./lib/runtime-paths.mjs";
-import { getDiscordToken } from "./lib/config.mjs";
-import { bootProfile, localTimestamp } from "./lib/boot-profile.mjs";
-import {
-  isChannelsDegraded,
-  logCrash,
-  _isBenignCrash,
-  BENIGN_CRASH_FATAL_THRESHOLD,
-  BENIGN_CRASH_STREAK_WINDOW_MS,
-} from "./lib/crash-log.mjs";
-import { dropTrace, preview, _dtIdxFlush } from "./lib/index-drop-trace.mjs";
-import { createVoiceTranscription } from "./lib/voice-transcription.mjs";
-import { createBackendDispatch } from "./lib/backend-dispatch.mjs";
-import { createParentBridge } from "./lib/parent-bridge.mjs";
-import { createInboundRouting } from "./lib/inbound-routing.mjs";
-import { createToolDispatch } from "./lib/tool-dispatch.mjs";
-import { createOwnerHeartbeat } from "./lib/owner-heartbeat.mjs";
-const memoryClientModulePath = new URL("./lib/memory-client.mjs", import.meta.url).href;
-const {
-  appendEntry: memoryAppendEntry,
-  ingestTranscript: memoryIngestTranscript,
-  drainBuffer: memoryDrainBuffer,
-} = await import(memoryClientModulePath);
-// Zombie-Lead repro (2026-07-02): logCrash-then-survive left a worker alive
-// after an unhandled rejection whose async state was already corrupted
-// (observed: EPERM on active-instance.json rename retry), so it spun
-// forever doing nothing useful — a zombie Lead. Fatal-exit on repeat.
-let _benignCrashStreak = 0;
-let _lastBenignCrashAt = 0;
-function _fatalCrash(label, err) {
-  logCrash(label, err);
-  const benign = _isBenignCrash(err);
-  if (benign) {
-    const now = Date.now();
-    _benignCrashStreak = (now - _lastBenignCrashAt) <= BENIGN_CRASH_STREAK_WINDOW_MS
-      ? _benignCrashStreak + 1
-      : 1;
-    _lastBenignCrashAt = now;
-    if (_benignCrashStreak < BENIGN_CRASH_FATAL_THRESHOLD) return;
-  } else {
-    _benignCrashStreak = 0;
-  }
-  Promise.resolve()
-    .then(() => (typeof stop === "function" ? stop(`fatal:${label}`) : null))
-    .catch(() => {})
-    .finally(() => {
-      try { process.exitCode = 1; } catch {}
-      process.exit(1);
-    });
-  // Best-effort stop() may itself hang (e.g. IPC to a dead child) — a bare
-  // .finally() would then never fire and we're back to a zombie. Force the
-  // exit unconditionally after a short grace window regardless of outcome.
-  setTimeout(() => { try { process.exit(1); } catch {} }, 3000).unref?.();
-}
-process.on("unhandledRejection", (err) => _fatalCrash("unhandled rejection", err));
-process.on("uncaughtException", (err) => _fatalCrash("uncaught exception", err));
-if (process.env.MIXDOG_CHANNELS_NO_CONNECT) {
-  process.exit(0);
-}
-const _isWorkerMode = process.env.MIXDOG_WORKER_MODE === '1'
-const _bootLogEarly = path.join(
-  DATA_DIR || path.join(os.tmpdir(), "mixdog"),
-  "boot.log"
-);
-const {
-  isMixdogDebugEnabled: isMixdogDebug,
-  pruneStalePluginDataLogSiblings,
-  appendSessionStartCriticalLog,
-  DEFAULT_STALE_LOG_SIBLING_MAX,
-} = _require("../../lib/mixdog-debug.cjs");
-// One-shot log rotation at worker boot (10 MB threshold, .1 suffix overwrite).
-if (isMixdogDebug()) {
-  try { if (fs.statSync(_bootLogEarly).size > 10 * 1024 * 1024) fs.renameSync(_bootLogEarly, _bootLogEarly + '.1') } catch {}
-  fs.appendFileSync(_bootLogEarly, `[${localTimestamp()}] bootstrap start pid=${process.pid}
-`);
-}
-const _bootLog = path.join(DATA_DIR, "boot.log");
-let config = loadConfig();
-let backend = createBackend(config);
-const INSTANCE_ID = makeInstanceId();
-const TERMINAL_LEAD_PID = getTerminalLeadPid();
-// Rotate additional worker logs (10 MB threshold).
-for (const _rotLog of ["channels-worker.log", "schedule.log", "event.log", "memory-worker.log", "mcp-debug.log", "webhook.log", "pg.log", "session-start.log"]) {
-  const _rotPath = path.join(DATA_DIR, _rotLog);
-  try { if (fs.statSync(_rotPath).size > 10 * 1024 * 1024) fs.renameSync(_rotPath, _rotPath + ".1") } catch {}
-}
-// GC per-worker scoped sibling logs (`<name>-worker.<leadPid>.<workerPid>.log`).
-// Master logs above rotate live; scoped siblings are opened once per worker
-// process and never reopened, so age-based removal is the only reliable
-// cleanup signal. 7-day TTL keeps recent crash forensics while bounding leak.
-const _STALE_WORKER_LOG_TTL_MS = 7 * 24 * 60 * 60 * 1000;
-try {
-  const _now = Date.now();
-  for (const _f of fs.readdirSync(DATA_DIR)) {
-    if (!/^(channels|memory)-worker\.\d+\.\d+\.log$/.test(_f)
-      && !/^mcp-debug\.\d+\.\d+\.log$/.test(_f)
-      && !/^supervisor\.\d+\.log$/.test(_f)) continue;
-    const _p = path.join(DATA_DIR, _f);
-    try { if (_now - fs.statSync(_p).mtimeMs > _STALE_WORKER_LOG_TTL_MS) fs.unlinkSync(_p); } catch {}
-  }
-} catch {}
-// GC stale ephemeral session files. closeSession plants a closed=true
-// tombstone, but bench / smoke / probe drivers historically created sessions
-// without ever calling closeSession, leaving 175-byte placeholders behind.
-// 7-day TTL is safe because live agent sessions touch their JSON file on
-// every ask iteration, so any file older than 7 days is provably abandoned.
-const _SESSIONS_DIR = path.join(DATA_DIR, 'sessions');
-const _STALE_SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1000;
-try {
-  const _now = Date.now();
-  for (const _f of fs.readdirSync(_SESSIONS_DIR)) {
-    if (!_f.endsWith('.json')) continue;
-    const _p = path.join(_SESSIONS_DIR, _f);
-    try { if (_now - fs.statSync(_p).mtimeMs > _STALE_SESSION_TTL_MS) fs.unlinkSync(_p); } catch {}
-  }
-} catch {}
-// Count-based cap: drop oldest *.log siblings when plugin-data accumulates
-// hundreds of per-process files (doctor warns above 300).
-try {
-  pruneStalePluginDataLogSiblings(DATA_DIR, DEFAULT_STALE_LOG_SIBLING_MAX);
-} catch {}
-// SIGTERM: flush the drop-trace buffer, but do NOT exit here. In worker
-// mode the graceful `_channelsShutdownHandler` below owns shutdown
-// (stop() → cleanup → process.exit). In non-worker mode no SIGTERM
-// handler was previously installed beyond this one; defer to default
-// termination so process.on('exit') hooks still run.
-process.on("SIGTERM", () => {
-  void _dtIdxFlush();
-  if (!_isWorkerMode) process.exit(0);
-});
-// ────────────────────────────────────────────────────────────────────────────
-ensureRuntimeDirs();
-cleanupStaleRuntimeFiles();
-if (!_isWorkerMode) {
-  notePreviousServerIfAny();
-  writeServerPid();
-  // Publish owner identity immediately so the SessionStart shim's
-  // owner_lead_alive() sees a live owner and uses the full connect budget
-  // instead of the 5s no-owner grace (fixes missing recap/core on restart).
-  // backendReady intentionally omitted — readiness stays gated until connect.
-  try {
-    refreshActiveInstance(INSTANCE_ID);
-  } catch (e) {
-    const code = e?.code;
-    const transient =
-      code === "EPERM" || code === "EBUSY" || code === "EACCES" || code === "ENOENT";
-    if (!transient) throw e;
-    try {
-      process.stderr.write(
-        `mixdog channels: refreshActiveInstance at startup failed (non-fatal, ${code}): ${e instanceof Error ? e.message : String(e)}\n`,
-      );
-    } catch {}
-  }
-  startCliWorker();
-}
-const INSTRUCTIONS = "";
-
-// ── Parent notification helper ───────────────────────────────────────
-// This worker has no MCP transport of its own. All notifications flow
-// through IPC to the parent (server.mjs), which owns the single connected
-// MCP `Server` instance. The parent's IPC message handler translates
-// `{type:'notify', method, params}` into `server.notification({method, params})`.
-//
-// Before v0.6.7 the worker had its own orphan `Server` instance that was
-// never `connect()`ed to any transport, so `.notification()` silently
-// threw 'Not connected' inside the SDK and every call was dropped by an
-// outer `.catch(() => {})`. That regression is what this path replaces.
-const {
-  sendNotifyToParent,
-  callMemoryAction,
-  handleMemoryCallResponse,
-} = createParentBridge({ getInstanceId: () => INSTANCE_ID });
-let channelBridgeActive = false;
-function writeBridgeState(active) {
-  try {
-    const stateFile = path.join(os.tmpdir(), "mixdog", "bridge-state.json");
-    fs.mkdirSync(path.dirname(stateFile), { recursive: true });
-    fs.writeFileSync(stateFile, JSON.stringify({ active, ts: Date.now() }));
-  } catch {
-  }
-}
-function isChannelBridgeActive() {
-  return channelBridgeActive;
-}
-let typingChannelId = null;
-const pendingSetup = new PendingInteractionStore();
-function startServerTyping(channelId) {
-  if (typingChannelId && typingChannelId !== channelId) {
-    backend.stopTyping(typingChannelId);
-  }
-  typingChannelId = channelId;
-  backend.startTyping(channelId);
-}
-function stopServerTyping() {
-  if (typingChannelId) {
-    backend.stopTyping(typingChannelId);
-    typingChannelId = null;
-  }
-}
-const TURN_END_FILE = getTurnEndPath(INSTANCE_ID);
-const TURN_END_BASENAME = path.basename(TURN_END_FILE);
-const TURN_END_DIR = path.dirname(TURN_END_FILE);
-let turnEndWatcher = null;
-// Config hot-reload watcher (installed by start(); torn down by stop()).
-let _configWatcher = null;
-let _reloadDebounce = null;
-if (!_isWorkerMode) {
-  removeFileIfExists(TURN_END_FILE);
-  turnEndWatcher = fs.watch(TURN_END_DIR, async (_event, filename) => {
-    if (filename !== TURN_END_BASENAME) return;
-    try {
-      const stat = fs.statSync(TURN_END_FILE);
-      if (stat.size > 0) {
-        stopServerTyping();
-        await forwarder.forwardFinalText();
-        removeFileIfExists(TURN_END_FILE);
-      }
-    } catch {
-    }
-  });
-}
-const STATUS_FILE = getStatusPath(INSTANCE_ID);
-const statusState = new JsonStateFile(STATUS_FILE, {});
-statusState.ensure();
-function sessionIdFromTranscriptPath(transcriptPath) {
-  const base = path.basename(transcriptPath);
-  return base.endsWith(".jsonl") ? base.slice(0, -6) : "";
-}
-function getPersistedTranscriptPath() {
-  const state = statusState.read();
-  if (typeof state.transcriptPath === "string" && state.transcriptPath) return state.transcriptPath;
-  return readActiveInstance()?.transcriptPath ?? "";
-}
-function pickUsableTranscriptPath(bound, previousPath) {
-  if (bound?.exists) return bound.transcriptPath;
-  if (!previousPath) return "";
-  if (!bound?.sessionId) return previousPath;
-  return sessionIdFromTranscriptPath(previousPath) === bound.sessionId ? previousPath : "";
-}
-const forwarder = new OutputForwarder({
-  send: async (ch, text, opts) => {
-    if (!channelBridgeActive) {
-      throw new Error("send() called while channel bridge is inactive");
-    }
-    await backend.sendMessage(ch, text, opts);
-  },
-  formatOutgoing: (text) => backend.formatOutgoing ? backend.formatOutgoing(text) : text,
-  recordAssistantTurn: async () => {
-  },
-  react: (ch, mid, emoji) => {
-    if (!channelBridgeActive) return Promise.resolve();
-    return backend.react(ch, mid, emoji);
-  },
-  removeReaction: (ch, mid, emoji) => {
-    if (!channelBridgeActive) return Promise.resolve();
-    return backend.removeReaction(ch, mid, emoji);
-  },
-  // Watchdog backstop: force the backend to tear down + rebuild a wedged
-  // client so an over-budget send fails fast and the queue releases.
-  resetBackend: async () => {
-    if (typeof backend?._resetClient === "function") await backend._resetClient();
-  }
-}, statusState);
-forwarder.setOnIdle(() => {
-  stopServerTyping();
-  void forwarder.forwardFinalText();
-});
-// Wire the forwarder ownership probe unconditionally. wireEventQueueHandlers()
-// also sets this, but that path only runs when the event pipeline starts
-// (webhook enabled or event rules present). Without an event pipeline the
-// forwarder's ownerGetter stayed null and _isOwner() failed open, letting a
-// non-owner process forward transcript output (duplicate Discord sends).
-// The closure reads bridgeRuntimeConnected at call time as a fast-path AND;
-// bridgeRuntimeConnected alone can go stale (e.g. this process lost the seat
-// but has not yet observed it), so currentOwnerState().owned is re-read at
-// probe time as the source of truth for ownership.
-forwarder.setOwnerGetter(() => bridgeRuntimeConnected && currentOwnerState().owned);
-function applyTranscriptBinding(channelId, transcriptPath, options = {}) {
-  if (!transcriptPath) return;
-  forwarder.setContext(channelId, transcriptPath, {
-    replayFromStart: options.replayFromStart,
-    catchUpFromPersisted: options.catchUpFromPersisted,
-    recoverUnsyncedTail: options.recoverUnsyncedTail,
-  });
-  const boundTranscriptPath = forwarder.transcriptPath || transcriptPath;
-  forwarder.startWatch();
-  void memoryIngestTranscript(boundTranscriptPath, { cwd: options.cwd });
-  // Opportunistic drain: an ingest that had to buffer (memory port not yet
-  // published) leaves entry-/ingest- files behind; kick the drainer so they
-  // replay as soon as the port appears, without waiting for the periodic tick.
-  void memoryDrainBuffer().catch(() => {});
-  // onlyIfOwned: binds happen on the owned path, but discovery/poll loops
-  // above can outlast an ownership handoff — never overwrite a newer owner.
-  refreshActiveInstance(INSTANCE_ID, { channelId, transcriptPath: boundTranscriptPath }, { onlyIfOwned: true });
-  if (options.persistStatus !== false) {
-    statusState.update((state) => {
-      const wasSameTranscript = typeof state.transcriptPath === "string"
-        && state.transcriptPath
-        && sameResolvedPath(state.transcriptPath, boundTranscriptPath);
-      const prevSentCount = Number(state.sentCount ?? 0);
-      const nextSentCount = Number(forwarder.sentCount ?? 0);
-      state.channelId = channelId;
-      state.transcriptPath = boundTranscriptPath;
-      state.lastFileSize = forwarder.lastFileSize;
-      if (wasSameTranscript) {
-        state.sentCount = Math.max(
-          Number.isFinite(prevSentCount) ? prevSentCount : 0,
-          Number.isFinite(nextSentCount) ? nextSentCount : 0,
-        );
-        if (forwarder.lastHash) state.lastSentHash = forwarder.lastHash;
-        else if (typeof state.lastSentHash !== "string") state.lastSentHash = "";
-        if (!Number.isFinite(Number(state.lastSentTime))) state.lastSentTime = 0;
-        if (typeof state.sessionIdle !== "boolean") state.sessionIdle = false;
-      } else {
-        state.sentCount = forwarder.sentCount;
-        state.lastSentHash = forwarder.lastHash;
-        state.lastSentTime = 0;
-        state.sessionIdle = false;
-      }
-      if (options.cwd !== undefined) state.sessionCwd = options.cwd ?? null;
-      else if (!wasSameTranscript) state.sessionCwd = null;
-    });
-  }
-}
-// ── Pending-transcript re-arm ────────────────────────────────────────
-// fs.watch cannot watch a file that does not exist yet, so when we bind a
-// session's known-but-not-yet-written transcript path, OutputForwarder.
-// startWatch() silently fails (watch.start.catch) and the file's later
-// creation is never observed. This bounded poll bridges that gap: once the
-// transcript-writer creates the file, we install the watch and forward the
-// backlog. It self-cancels on success, on timeout, and whenever a fresh
-// (re)bind supersedes it — so no timers leak and no double-forward occurs.
-let _pendingRearmTimer = null;
-const PENDING_REARM_INTERVAL_MS = 250;
-const PENDING_REARM_MAX_MS = 60_000;
-function cancelPendingTranscriptRearm() {
-  if (_pendingRearmTimer) {
-    clearTimeout(_pendingRearmTimer);
-    _pendingRearmTimer = null;
-    dropTrace("rebind.rearm.cancel");
-  }
-}
-function schedulePendingTranscriptRearm(channelId, boundPath) {
-  cancelPendingTranscriptRearm();
-  if (!boundPath) return;
-  const deadline = Date.now() + PENDING_REARM_MAX_MS;
-  dropTrace("rebind.rearm.schedule", { channelId, path: boundPath });
-  const tick = () => {
-    _pendingRearmTimer = null;
-    // A different transcript got bound in the meantime — abandon this poll.
-    if (forwarder.transcriptPath !== boundPath) {
-      dropTrace("rebind.rearm.superseded", { path: boundPath, now: forwarder.transcriptPath || "(none)" });
-      return;
-    }
-    // Ownership may have been lost (bridge deactivated / superseded owner)
-    // while this poll was pending. Do not reinstall the fs.watch handle after
-    // teardown; startWatch() is not owner-gated so guard it here.
-    if (!bridgeRuntimeConnected) {
-      dropTrace("rebind.rearm.not-owner", { path: boundPath });
-      return;
-    }
-    if (fs.existsSync(boundPath)) {
-      dropTrace("rebind.rearm.fire", { channelId, path: boundPath });
-      forwarder.startWatch();
-      void forwarder.forwardNewText().catch((err) => {
-        try { process.stderr.write(`mixdog: rearm forwardNewText rejection: ${err?.stack || err}\n`); } catch {}
-      });
-      return;
-    }
-    if (Date.now() >= deadline) {
-      dropTrace("rebind.rearm.timeout", { channelId, path: boundPath });
-      return;
-    }
-    _pendingRearmTimer = setTimeout(tick, PENDING_REARM_INTERVAL_MS);
-    _pendingRearmTimer?.unref?.();
-  };
-  _pendingRearmTimer = setTimeout(tick, PENDING_REARM_INTERVAL_MS);
-  _pendingRearmTimer?.unref?.();
-}
-async function rebindTranscriptContext(channelId, options = {}) {
-  const previousPath = options.previousPath ?? "";
-  const mode = options.mode ?? "same";
-  // A new (re)bind supersedes any pending re-arm poll left over from a prior
-  // bind of a not-yet-existing transcript, so we never leak timers or
-  // double-forward once the fresh bind takes over.
-  cancelPendingTranscriptRearm();
-  const explicitTranscriptPath = typeof options.transcriptPath === "string" ? options.transcriptPath.trim() : "";
-  if (explicitTranscriptPath) {
-    let explicitExists = false;
-    try {
-      explicitExists = fs.statSync(explicitTranscriptPath).isFile();
-    } catch {
-      explicitExists = false;
-    }
-    if (explicitExists) {
-      applyTranscriptBinding(channelId, explicitTranscriptPath, {
-        replayFromStart: Boolean(options.catchUp),
-        catchUpFromPersisted: options.catchUpFromPersisted,
-        persistStatus: options.persistStatus,
-        recoverUnsyncedTail: options.recoverUnsyncedTail,
-      });
-      if (options.catchUp || options.catchUpFromPersisted) {
-        await forwarder.forwardNewText();
-      }
-      return explicitTranscriptPath;
-    }
-  }
-  let sawPendingTranscript = false;
-  let pendingSessionId = "";
-  // Distinct from sawPendingTranscript/pendingSessionId (which only track the
-  // sessionId): remember the FULL not-yet-on-disk candidate — its concrete
-  // transcriptPath (from the session record) + cwd — so we can bind it after
-  // the loop even though the `.jsonl` does not exist yet. This breaks the
-  // chicken-and-egg deadlock where the first assistant reply is only written
-  // seconds after inbound time.
-  let pendingTranscriptPath = "";
-  let pendingTranscriptCwd = null;
-  const maxAttempts = Number.isFinite(options.maxAttempts) ? Math.max(1, Math.floor(options.maxAttempts)) : 30;
-  const pollMs = Number.isFinite(options.pollMs) ? Math.max(25, Math.floor(options.pollMs)) : 150;
-  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-    const bound = discoverSessionBoundTranscript();
-    if (bound?.exists) {
-      const acceptable = mode === "same" || !previousPath || bound.transcriptPath !== previousPath;
-      if (acceptable) {
-        const replayFromStart = Boolean(
-          options.catchUp && !previousPath && sawPendingTranscript && pendingSessionId === bound.sessionId
-        );
-        applyTranscriptBinding(channelId, bound.transcriptPath, {
-          replayFromStart,
-          catchUpFromPersisted: options.catchUpFromPersisted,
-          recoverUnsyncedTail: options.recoverUnsyncedTail,
-          persistStatus: options.persistStatus,
-          cwd: bound.sessionCwd,
-        });
-        if (replayFromStart || options.catchUpFromPersisted) {
-          await forwarder.forwardNewText();
-        }
-        return bound.transcriptPath;
-      }
-    } else if (bound?.sessionId) {
-      sawPendingTranscript = true;
-      pendingSessionId = bound.sessionId;
-      if (bound.transcriptPath) {
-        pendingTranscriptPath = bound.transcriptPath;
-        pendingTranscriptCwd = bound.sessionCwd ?? null;
-      }
-    }
-    await new Promise((resolve) => setTimeout(resolve, pollMs));
-  }
-  // No existing transcript surfaced during the loop, but the session record
-  // named a concrete transcript path that simply is not on disk yet. Bind it
-  // now: applyTranscriptBinding persists state.transcriptPath (so the
-  // getPersistedTranscriptPath() fallback works for future rebinds) and calls
-  // forwarder.startWatch(). Because fs.watch cannot watch a missing file, we
-  // also schedule a bounded re-arm poll that installs the watch + catches up
-  // once the transcript-writer creates the file.
-  if (pendingTranscriptPath) {
-    // Same wrong-session guard as the exists:true path: refuse to bind a
-    // candidate that conflicts with an explicit previousPath when this is a
-    // switch (mode!=="same").
-    const acceptable = mode === "same" || !previousPath || pendingTranscriptPath !== previousPath;
-    if (acceptable) {
-      dropTrace("rebind.pending.bind", { channelId, path: pendingTranscriptPath, sessionId: pendingSessionId });
-      // If the persisted cursor belongs to THIS transcript, resume from it;
-      // otherwise this is a freshly-discovered session transcript that was
-      // never bound before (the chicken-and-egg case), so forward from the
-      // start of file. Binding with catchUpFromPersisted against a
-      // non-matching persisted path would set the read cursor to EOF and
-      // silently skip the first reply (output-forwarder setContext).
-      // Resume from the persisted cursor only when it belongs to THIS
-      // transcript; otherwise forward from the start of file (see comment
-      // above). sameResolvedPath handles Windows case-insensitive paths.
-      const samePersisted = sameResolvedPath(getPersistedTranscriptPath(), pendingTranscriptPath);
-      applyTranscriptBinding(channelId, pendingTranscriptPath, {
-        replayFromStart: !samePersisted,
-        catchUpFromPersisted: samePersisted,
-        recoverUnsyncedTail: options.recoverUnsyncedTail,
-        cwd: pendingTranscriptCwd,
-        persistStatus: options.persistStatus,
-      });
-      const boundPath = forwarder.transcriptPath || pendingTranscriptPath;
-      if (fs.existsSync(boundPath)) {
-        // Raced: file appeared between discovery and bind — forward immediately.
-        await forwarder.forwardNewText();
-      } else {
-        schedulePendingTranscriptRearm(channelId, boundPath);
-      }
-      process.stderr.write(`mixdog: rebind pending: bound not-yet-existing transcript ${boundPath}\n`);
-      return pendingTranscriptPath;
-    }
-  }
-  if (previousPath && options.fallbackPrevious !== false) {
-    applyTranscriptBinding(channelId, previousPath, {
-      catchUpFromPersisted: true,
-      recoverUnsyncedTail: options.recoverUnsyncedTail,
-      cwd: statusState.read().sessionCwd
-    });
-    if (fs.existsSync(previousPath)) {
-      await forwarder.forwardNewText();
-    } else {
-      // Same not-yet-on-disk situation as the pending branch: arm a poll so
-      // forwarding starts when the file is created.
-      schedulePendingTranscriptRearm(channelId, forwarder.transcriptPath || previousPath);
-    }
-    process.stderr.write(`mixdog: rebind fallback: bound previous transcript ${previousPath}\n`);
-    return previousPath;
-  }
-  process.stderr.write(`mixdog: rebind failed: no transcript found and no previous path to fall back to\n`);
-  return "";
-}
-const scheduler = new Scheduler(
-  config.nonInteractive ?? [],
-  config.interactive ?? [],
-  // Single resolved main-channel id used for the schedule `channel` flag.
-  config.channelId
-);
-// Register the pending-dispatch probe so the scheduler treats an in-flight
-// bridge dispatch as "active" regardless of user-inbound silence.
-scheduler.setPendingCheck(() => {
-  try {
-    return dispatchHasPending(DATA_DIR);
-  } catch {
-    return false;
-  }
-});
-// Bridge the orchestrator-side activity notifier into the scheduler so
-// events like `addPending` can bump lastActivity without importing the
-// scheduler instance directly (avoids module cycles).
-setActivityBusListener(() => scheduler.noteActivity());
-let webhookServer = null;
-let eventPipeline = null;
-let bridgeRuntimeConnected = false;
-let bridgeRuntimeStarting = false;
-// Stop-requested signal: set by stopOwnedRuntime() when it runs during the
-// startOwnedRuntime() in-flight window (bridgeRuntimeStarting=true). Checked
-// by startOwnedRuntime() right after backend.connect() resolves so the
-// in-flight start does not revive owner state after the stop already tore
-// the partial-start state down.
-let _ownedRuntimeStopRequested = false;
-let bridgeOwnershipRefreshInFlight = null;
-let bridgeOwnershipTimer = null;
-const ACTIVE_OWNER_STALE_MS = 1e4;
-// Owner gating here is multi-process runtime coordination: only the active
-// bindingReady gates all send paths until the boot-time refreshBridgeOwnership
-// ({ restoreBinding: true }) call completes. Without this, scheduler/webhook
-// emissions fired within the first ~few hundred ms after restart drop because
-// the Discord backend binding has not yet been established.
-let bindingReadyStatus = "pending";
-let _bindingReadyResolve;
-const bindingReady = new Promise((r) => { _bindingReadyResolve = r; });
-let _memoryDrainTimer = null;
-dropTrace("bindingReady.create", { status: bindingReadyStatus });
-// ── Bridge ownership snapshot + owner heartbeat ─────────────────────────────
-// Extracted → lib/owner-heartbeat.mjs. Owns its own heartbeat timer + last-note
-// dedup; bound to live identity + active-instance primitives.
-const {
-  logOwnership,
-  currentOwnerState,
-  getBridgeOwnershipSnapshot,
-  claimBridgeOwnership,
-  startOwnerHeartbeat,
-  stopOwnerHeartbeat,
-} = createOwnerHeartbeat({
-  getInstanceId: () => INSTANCE_ID,
-  readActiveInstance,
-  refreshActiveInstance,
-});
-async function bindPersistedTranscriptIfAny() {
-  // Main-channel fallback requires channelBridgeActive (set in start() before
-  // refreshBridgeOwnership → startOwnedRuntime, including pre-connect binds).
-  // Resolve channelId first from persisted status; fall back to the most
-  // recent status-*.json snapshot, then to the configured main channel when
-  // the bridge is active. No exists-gate here — once we have a channelId,
-  // hand off to rebindTranscriptContext(), which owns the 30-attempt retry
-  // for transcripts that are not yet on disk at boot/activate time.
-  let currentStatus = statusState.read();
-  if (!currentStatus.channelId) {
-    try {
-      const files = fs.readdirSync(RUNTIME_ROOT).filter((f) => f.startsWith("status-") && f.endsWith(".json")).map((f) => {
-        const full = path.join(RUNTIME_ROOT, f);
-        return { path: full, mtime: fs.statSync(full).mtimeMs };
-      }).sort((a, b) => b.mtime - a.mtime);
-      for (const { path: fp } of files) {
-        try {
-          const data = JSON.parse(fs.readFileSync(fp, "utf8"));
-          if (data.channelId) {
-            statusState.update((state) => {
-              Object.assign(state, data);
-            });
-            currentStatus = statusState.read();
-            process.stderr.write(`mixdog: restored status from ${fp}
-`);
-            break;
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  if (!currentStatus.channelId && channelBridgeActive) {
-    const mainId = config.channelId;
-    if (mainId) {
-      statusState.update((state) => {
-        state.channelId = mainId;
-      });
-      currentStatus = statusState.read();
-      process.stderr.write(`mixdog: auto-bound to main channel ${mainId}
-`);
-    }
-  }
-  if (!currentStatus.channelId) return;
-  const bound = await rebindTranscriptContext(currentStatus.channelId, {
-    previousPath: getPersistedTranscriptPath(),
-    persistStatus: true,
-    catchUpFromPersisted: true,
-    recoverUnsyncedTail: true,
-  });
-  if (bound) {
-    process.stderr.write(`mixdog: initial transcript bind: ${bound}
-`);
-  }
-}
-function shouldStartEventPipelineRuntime() {
-  return config.webhook?.enabled === true || (Array.isArray(config.events?.rules) && config.events.rules.length > 0);
-}
-function ensureEventPipelineRuntime() {
-  if (!eventPipeline) {
-    eventPipeline = new EventPipeline(config.events, config.channelId);
-    wireEventQueueHandlers(eventPipeline.getQueue());
-  }
-  return eventPipeline;
-}
-function ensureWebhookServerRuntime() {
-  if (!webhookServer) {
-    webhookServer = new WebhookServer(config.webhook);
-  }
-  wireWebhookHandlers();
-  return webhookServer;
-}
-async function stopWebhookAndEventRuntime() {
-  if (webhookServer) {
-    await webhookServer.stop();
-    webhookServer = null;
-  }
-  if (eventPipeline) {
-    eventPipeline.stop();
-    eventPipeline = null;
-  }
-}
-function syncOwnedWebhookAndEventRuntime({ reload = false } = {}) {
-  if (shouldStartEventPipelineRuntime()) {
-    const pipeline = ensureEventPipelineRuntime();
-    if (reload) {
-      pipeline.reloadConfig(config.events, config.channelId);
-      wireEventQueueHandlers(pipeline.getQueue());
-    }
-    pipeline.start();
-  } else if (eventPipeline) {
-    eventPipeline.stop();
-    eventPipeline = null;
-  }
-
-  if (config.webhook?.enabled === true) {
-    const server = ensureWebhookServerRuntime();
-    if (reload) {
-      // server.reloadConfig is async (it awaits the current server's
-      // close() before re-listening). Chain start() onto its resolution
-      // so we don't race the bound port — calling start() synchronously
-      // here would re-listen before close() finishes and surface
-      // EADDRINUSE on the same port.
-      server.reloadConfig(config.webhook, {
-        autoStart: false
-      }).then(() => {
-        // A stopWebhookAndEventRuntime() / deactivate landing during the async
-        // close()+reload window nulls out webhookServer (and webhook.enabled may
-        // have flipped off). Without this guard the resolved continuation would
-        // re-listen and resurrect an orphan listener that no teardown tracks.
-        if (webhookServer !== server || config.webhook?.enabled !== true) {
-          try { server.stop(); } catch {}
-          return;
-        }
-        wireWebhookHandlers();
-        server.start();
-      }).catch((err) => {
-        process.stderr.write(`mixdog channels: webhook reload failed: ${err instanceof Error ? err.message : String(err)}\n`);
-      });
-    } else {
-      server.start();
-    }
-  } else if (webhookServer) {
-    webhookServer.stop();
-    webhookServer = null;
-  }
-}
-let _ownedRuntimeSelfHealing = false;
-// Explicit restore path for an already-connected owner. The 3s ownership tick
-// must not run this implicitly: re-binding status on every tick can move the
-// transcript cursor to EOF, and probing the gateway during Discord's own
-// reconnect window can reset a healthy reconnect loop. Keep this for explicit
-// activation/reload recovery only.
-async function selfHealOwnedRuntime(options = {}) {
-  const shouldRestoreBinding = options.restoreBinding === true;
-  const shouldResetBackend = options.resetBackend === true;
-  if (!shouldRestoreBinding && !shouldResetBackend) return;
-  if (_ownedRuntimeSelfHealing) return;
-  _ownedRuntimeSelfHealing = true;
-  try {
-    if (shouldRestoreBinding) {
-      await bindPersistedTranscriptIfAny().catch((e) => {
-        process.stderr.write(`mixdog: self-heal bindPersistedTranscriptIfAny failed (non-fatal): ${e instanceof Error ? e.message : String(e)}\n`);
-      });
-    }
-    if (shouldResetBackend && typeof backend?._resetClient === "function") {
-      await backend._resetClient().catch((e) => {
-        process.stderr.write(`mixdog: self-heal backend reset failed (non-fatal): ${e instanceof Error ? e.message : String(e)}\n`);
-      });
-    }
-    // Nudge the forwarder to drain anything the rebind/reconnect surfaced.
-    void forwarder.forwardNewText().catch(() => {});
-  } finally {
-    _ownedRuntimeSelfHealing = false;
-  }
-}
-async function startOwnedRuntime(options = {}) {
-  if (bridgeRuntimeConnected) {
-    if (!bridgeRuntimeStarting) await selfHealOwnedRuntime(options);
-    return;
-  }
-  if (bridgeRuntimeStarting) return;
-  if (!channelBridgeActive) return;
-  bridgeRuntimeStarting = true;
-  _ownedRuntimeStopRequested = false;
-  // Capture the backend instance that THIS start operation will connect. A
-  // reloadRuntimeConfig() hot-swap can replace the global `backend` while this
-  // start is still awaiting connect(); using the captured instance for both
-  // connect() and the bail-path disconnect() guarantees we tear down the
-  // backend WE started (not the freshly-swapped one), closing the
-  // both-backends-live window.
-  const startingBackend = backend;
-  const claimAfterReady = options.claimAfterReady === true;
-  // Single-holder correctness: the seat is claimed BEFORE backend.connect(),
-  // never after. The old make-before-break (claim-after-ready) boot left two
-  // gateways connected and contending during the multi-second connect window;
-  // claiming first makes the previous owner observe owned=false on its next
-  // tick and drain+disconnect, so at most one gateway ever serves.
-  //   - boot (claimAfterReady): last-wins acquire — this new remote session
-  //     takes the seat outright.
-  //   - refresh/owned-path: CAS onlyIfOwned — abort fast if the seat moved.
-  // backendReady=false marks the partial state until backend.connect() succeeds.
-  // Wrapped so ANY throw in the pre-connect claim (lock contention/error)
-  // resets bridgeRuntimeStarting — otherwise a transient lock error would
-  // leave it stuck true and permanently block every future ownership attempt.
-  try {
-    if (claimAfterReady) {
-      refreshActiveInstance(INSTANCE_ID, { backendReady: false });
-      logOwnership("boot claim (pre-connect, last-wins)");
-    } else {
-      // Try-once (timeoutMs:0): a refresh-path re-acquire must never block on
-      // the active-instance lock. Contention throws → caught below and treated
-      // as "seat busy, abort this attempt"; the next 3s tick retries.
-      const casResult = refreshActiveInstance(INSTANCE_ID, { backendReady: false }, { onlyIfOwned: true, timeoutMs: 0 });
-      // A successful CAS write always sets instanceId to ours; any other result
-      // (aborted write returning the stale/foreign/missing prior state) means the
-      // seat was not ours to claim — abort here rather than relying on the timer.
-      if (casResult?.instanceId !== INSTANCE_ID) {
-        bridgeRuntimeStarting = false;
-        return;
-      }
-    }
-    // A newer session can claim between our write and this read. If we no longer
-    // own the seat, abort fast WITHOUT starting heartbeat/backend/scheduler/
-    // webhook/ngrok — ancillary runtime starts only past a confirmed-owned claim.
-    if (!currentOwnerState().owned) {
-      bridgeRuntimeStarting = false;
-      return;
-    }
-  } catch (e) {
-    bridgeRuntimeStarting = false;
-    process.stderr.write(`mixdog: pre-connect seat claim aborted (${e instanceof Error ? e.message : String(e)})\n`);
-    return;
-  }
-  // Arm ownership-loss detection BEFORE backend.connect() so a session that is
-  // superseded during the (multi-second) connect window is torn down: the 3s
-  // tick observes a newer owner and flips _ownedRuntimeStopRequested, and
-  // bailIfStopRequested below disconnects the backend WE connected.
-  armBridgeOwnershipTimer();
-  // Heartbeat is ownership-gated; safe to arm now that we hold the seat.
-  startOwnerHeartbeat();
-  // Periodic buffer drain: replays memory-buffer/entry-*/ingest-*.json once the
-  // memory service publishes its port. Idempotent + reentrancy-guarded inside
-  // drainBuffer(); unref'd so it never holds the worker open.
-  if (!_memoryDrainTimer) {
-    _memoryDrainTimer = setInterval(() => { void memoryDrainBuffer().catch(() => {}); }, 5e3);
-    _memoryDrainTimer.unref?.();
-  }
-  // Re-check after each post-connect await so a stopOwnedRuntime() landing
-  // mid-start cannot be overridden by the resuming start (scheduler/snapshot/
-  // webhook/binding launches below would revive owner state after stop).
-  // Idempotent: stop's sync teardown already ran; re-running disconnect +
-  // teardown is safe and covers both the pre-connected window (stop could
-  // not disconnect an in-flight backend) and the post-connected window
-  // (stop did disconnect; redo to be defensive).
-  const bailIfStopRequested = async () => {
-    if (!_ownedRuntimeStopRequested) return false;
-    try { await startingBackend.disconnect(); } catch {}
-    try { stopOwnerHeartbeat(); } catch {}
-    try { releaseOwnedChannelLocks(INSTANCE_ID); } catch {}
-    try { clearActiveInstance(INSTANCE_ID); } catch {}
-    bridgeRuntimeConnected = false;
-    _ownedRuntimeStopRequested = false;
-    return true;
-  };
-  const restoreBinding = options.restoreBinding !== false;
-  const bindPersistedTranscriptTask = restoreBinding
-    ? bindPersistedTranscriptIfAny().catch((e) => {
-      process.stderr.write(`mixdog: bindPersistedTranscriptIfAny failed (non-fatal): ${e instanceof Error ? e.message : String(e)}\n`);
-    })
-    : null;
-  // Await backend.connect() so callers (and bindingReady) only resolve after
-  // the Discord binding is real. Previously this was fire-and-forget and
-  // refreshBridgeOwnership returned immediately, letting bindingReady fire
-  // before backend listeners were attached.
-  try {
-    await startingBackend.connect();
-    if (await bailIfStopRequested()) {
-      cancelPendingTranscriptRearm();
-      try { forwarder.stopWatch(); } catch {}
-      if (bindPersistedTranscriptTask) await bindPersistedTranscriptTask;
-      return;
-    }
-    // Post-connect ownership confirm (CAS). The seat was claimed BEFORE
-    // connect; a newer session may have superseded us during the connect
-    // window (the 3s tick would already be tearing us down). onlyIfOwned:
-    // never re-steal here. If the CAS aborts we LOST the seat — disconnect the
-    // backend WE connected and mark the bridge runtime not connected (do NOT
-    // clear active-instance; the newer owner holds it).
-    let ownConfirm;
-    try {
-      ownConfirm = refreshActiveInstance(INSTANCE_ID, { backendReady: true }, { onlyIfOwned: true });
-    } catch { ownConfirm = null; }
-    if (ownConfirm?.instanceId !== INSTANCE_ID) {
-      try { await startingBackend.disconnect(); } catch {}
-      try { stopOwnerHeartbeat(); } catch {}
-      try { releaseOwnedChannelLocks(INSTANCE_ID); } catch {}
-      if (_memoryDrainTimer) { clearInterval(_memoryDrainTimer); _memoryDrainTimer = null; }
-      bridgeRuntimeConnected = false;
-      cancelPendingTranscriptRearm();
-      try { forwarder.stopWatch(); } catch {}
-      if (bindPersistedTranscriptTask) await bindPersistedTranscriptTask;
-      notifyRemoteSuperseded();
-      return;
-    }
-    bridgeRuntimeConnected = true;
-    if (claimAfterReady) {
-      // First confirmed ownership at boot — tell the parent it holds the seat
-      // exactly once (heartbeat/refresh re-pin ownership but never re-enter).
-      notifyRemoteAcquired();
-    }
-    // initProviders must complete before scheduler.start() — otherwise the
-    // scheduler's first fire can land before the registry is populated and
-    // return `Provider "<name>" not found or not enabled`. The previous
-    // fire-and-forget call let scheduler.start() race ahead of init.
-    try {
-      const agentCfg = loadAgentConfig();
-      await initProviders(agentCfg.providers || {});
-    } catch (e) {
-      process.stderr.write(`mixdog: initProviders failed (non-fatal): ${e instanceof Error ? e.message : String(e)}\n`);
-    }
-    if (await bailIfStopRequested()) {
-      cancelPendingTranscriptRearm();
-      try { forwarder.stopWatch(); } catch {}
-      if (bindPersistedTranscriptTask) await bindPersistedTranscriptTask;
-      return;
-    }
-    scheduler.start();
-    startSnapshotWriter(scheduler);
-    syncOwnedWebhookAndEventRuntime();
-    if (restoreBinding) {
-      if (bindPersistedTranscriptTask) await bindPersistedTranscriptTask;
-      const pendingTranscriptPath = forwarder.transcriptPath;
-      if (pendingTranscriptPath && !fs.existsSync(pendingTranscriptPath)) {
-        // Pre-connect bind may have armed rearm while !bridgeRuntimeConnected;
-        // the first tick then exits without rescheduling. Re-arm now that we own.
-        schedulePendingTranscriptRearm(statusState.read().channelId, pendingTranscriptPath);
-      } else {
-        void forwarder.forwardNewText().catch((err) => {
-          process.stderr.write(`mixdog: post-connect forwardNewText failed (non-fatal): ${err instanceof Error ? err.message : String(err)}\n`);
-        });
-      }
-    }
-    process.stderr.write(`mixdog: running with ${backend.name} backend\n`);
-    logOwnership(`active owner lead=${TERMINAL_LEAD_PID} pid=${process.pid}`);
-  } catch (e) {
-    process.stderr.write(`mixdog: backend connect failed (non-fatal, cycle1/MCP still up): ${e instanceof Error ? e.message : String(e)}\n`);
-    cancelPendingTranscriptRearm();
-    try { forwarder.stopWatch(); } catch {}
-    if (bindPersistedTranscriptTask) await bindPersistedTranscriptTask;
-    // Roll back partial owner-side state advertised before connect() ran:
-    // heartbeat and active-instance entry.
-    try { stopOwnerHeartbeat(); } catch {}
-    try { releaseOwnedChannelLocks(INSTANCE_ID); } catch {}
-    try { clearActiveInstance(INSTANCE_ID); } catch {}
-    if (_memoryDrainTimer) { clearInterval(_memoryDrainTimer); _memoryDrainTimer = null; }
-  } finally {
-    bridgeRuntimeStarting = false;
-  }
-}
-async function stopOwnedRuntime(reason) {
-  // Cancel any pending transcript re-arm poll BEFORE the connected/starting
-  // early-return below. Otherwise a poll armed against a not-yet-existing
-  // transcript could fire after teardown and reinstall the fs.watch handle
-  // (startWatch is not owner-gated), leaking a live watcher past shutdown.
-  cancelPendingTranscriptRearm();
-  // startOwnedRuntime() advertises owner HTTP/heartbeat/active-instance and
-  // claims channel locks BEFORE awaiting backend.connect(). If shutdown lands
-  // during that window (bridgeRuntimeStarting=true, bridgeRuntimeConnected
-  // still false) we still need to tear that partial state down — otherwise
-  // the port stays bound and active-instance.json stays stale.
-  if (!bridgeRuntimeConnected && !bridgeRuntimeStarting) return;
-  // If a start is in flight (bridgeRuntimeStarting=true), signal the in-flight
-  // startOwnedRuntime() to abort right after its backend.connect() resolves.
-  // Without this the in-flight start re-marks connected and re-launches
-  // scheduler/webhook/heartbeat after we tear them down here.
-  if (bridgeRuntimeStarting) _ownedRuntimeStopRequested = true;
-  const wasConnected = bridgeRuntimeConnected;
-  stopServerTyping();
-  // Release the transcript fs.watch handle plus the forwarder's debounce/retry
-  // timers on standby. Without this the watcher keeps firing scheduleWatchFlush
-  // and the drain/retry timers stay live after ownership is dropped, leaking a
-  // file handle + timers for the rest of the process lifetime.
-  try { forwarder.stopWatch(); } catch {}
-  stopOwnerHeartbeat();
-  if (_memoryDrainTimer) { clearInterval(_memoryDrainTimer); _memoryDrainTimer = null; }
-  scheduler.stop();
-  stopSnapshotWriter();
-  await stopWebhookAndEventRuntime();
-  releaseOwnedChannelLocks(INSTANCE_ID);
-  clearActiveInstance(INSTANCE_ID);
-  try {
-    // Only disconnect the backend when connect() actually completed; calling
-    // disconnect() mid-connect races the connect promise.
-    if (wasConnected) {
-      // Drain in-flight outbound sends before disconnecting so a handoff
-      // (owned=false observed → ownership lost) never cuts off a reply
-      // mid-delivery. Bounded inside drainPendingSends so a wedged send can
-      // not stall teardown — we still disconnect promptly.
-      try { await backend.drainPendingSends?.(); } catch {}
-      await backend.disconnect();
-    }
-  } finally {
-    bridgeRuntimeConnected = false;
-    logOwnership(`standby: ${reason}`);
-  }
-}
-function refreshBridgeOwnershipSafe(options = {}) {
-  refreshBridgeOwnership(options).catch(err => process.stderr.write(`[channels] refreshBridgeOwnership rejected: ${err?.message || err}\n`));
-}
-// Ownership-loss / re-acquire detection timer. Armed BEFORE backend.connect()
-// (from startOwnedRuntime) so a session superseded during the connect window is
-// torn down promptly, and re-armed idempotently on every start path.
-function armBridgeOwnershipTimer() {
-  if (bridgeOwnershipTimer) return;
-  bridgeOwnershipTimer = setInterval(() => {
-    refreshBridgeOwnershipSafe();
-  }, 3e3);
-  bridgeOwnershipTimer.unref?.();
-}
-// Tell the parent session that this worker LOST the bridge seat to a newer
-// remote session (last-wins). The parent flips its remote mode OFF entirely —
-// exactly one session holds remote; losers fully release, no handover.
-function notifyRemoteSuperseded() {
-  if (!process.send) return;
-  try {
-    process.send({ type: 'notify', method: 'notifications/mixdog/remote', params: { state: 'superseded' } });
-  } catch {}
-}
-// Symmetric to notifyRemoteSuperseded: tell the parent session this worker
-// ACQUIRED the bridge seat so it flips remote mode ON (badge/transcript writer).
-// Guarded by process.send so a manually-forked worker with no IPC parent is a
-// no-op instead of crashing. Callers fire this only on a genuine claim
-// transition (boot make-before-break, activate when not already owned) — never
-// on a heartbeat refresh — so the parent's idempotent handler sees it once.
-function notifyRemoteAcquired() {
-  if (!process.send) return;
-  try {
-    process.send({ type: 'notify', method: 'notifications/mixdog/remote', params: { state: 'acquired' } });
-  } catch {}
-}
-async function refreshBridgeOwnership(options = {}) {
-  // Coalesce concurrent callers onto the in-flight refresh so backend tool
-  // calls landing during normal login wait for the same connect attempt
-  // instead of returning early and observing spurious auto-connect failure.
-  if (bridgeOwnershipRefreshInFlight) return bridgeOwnershipRefreshInFlight;
-  bridgeOwnershipRefreshInFlight = (async () => {
-    // Opt-in remote, single-owner, last-wins. Only a remote session with an
-    // active bridge participates. If this instance is the active owner (its
-    // INSTANCE_ID is the one advertised in active-instance.json) it ensures
-    // the owned runtime is up. If a newer remote session has since claimed
-    // ownership (last-wins overwrite), this instance is no longer owner and
-    // quietly tears its backend down on the next tick. No proxy, no steal.
-    if (!channelBridgeActive) {
-      if (bridgeRuntimeConnected) await stopOwnedRuntime("bridge inactive");
-      return;
-    }
-    // Non-blocking ownership probe (read-only, no lock): distinguishes a live
-    // owner from a genuinely empty/stale seat from an INDETERMINATE read (a
-    // concurrent atomic rename yields partial content). "Locked/unreadable =
-    // busy/unknown owner, never claimable" — skip the tick on 'unknown' so we
-    // never claim a seat we merely failed to read (double-owner guard).
-    const probe = probeActiveOwner();
-    if (probe.status === 'unknown') return;
-    const owned = probe.status === 'live' && probe.state?.instanceId === INSTANCE_ID;
-    if (owned) {
-      // Try-once CAS refresh (timeoutMs:0): on lock contention treat as busy
-      // and skip the metadata touch — never block the tick. We still own, so
-      // ensure/keep the owned runtime up.
-      try { refreshActiveInstance(INSTANCE_ID, undefined, { onlyIfOwned: true, timeoutMs: 0 }); } catch {}
-      await startOwnedRuntime(options);
-      return;
-    }
-    if (probe.status === 'live' && probe.state.instanceId && probe.state.instanceId !== INSTANCE_ID) {
-      // A different live remote session holds the seat (last-wins: we lost).
-      // Go quiet (disconnect if connected) and tell the parent to drop remote
-      // mode entirely (single-holder, no handover). Notify UNCONDITIONALLY —
-      // a loser whose backend never connected must still drop its Remote
-      // indicator; the parent handler is idempotent.
-      // Also cover the STARTING phase: a worker stuck in backend.connect() must
-      // get _ownedRuntimeStopRequested set (stopOwnedRuntime does this while
-      // bridgeRuntimeStarting) so bailIfStopRequested tears it down promptly
-      // once connect() resolves — otherwise the superseded connect lingers.
-      if (bridgeRuntimeConnected || bridgeRuntimeStarting) {
-        await stopOwnedRuntime("ownership lost (newer remote session)");
-      }
-      notifyRemoteSuperseded();
-      return;
-    }
-    // Empty (absent) or stale (dead owner) seat — claim it. Try-once
-    // (timeoutMs:0): a contended lock means a concurrent claimant is mid-write,
-    // so treat as busy and skip this tick rather than block.
-    let claimed = false;
-    try { claimed = claimBridgeOwnership("no active owner", { timeoutMs: 0 }); } catch { claimed = false; }
-    if (claimed) {
-      await startOwnedRuntime(options);
-    }
-  })();
-  try {
-    return await bridgeOwnershipRefreshInFlight;
-  } finally {
-    bridgeOwnershipRefreshInFlight = null;
-  }
-}
-
-async function reloadRuntimeConfig() {
-  const previousBackend = backend;
-  const previousBackendName = previousBackend?.name || "";
-  config = loadConfig();
-  scheduler.reloadConfig(
-    config.nonInteractive ?? [],
-    config.interactive ?? [],
-    // Single resolved main-channel id used for the schedule `channel` flag.
-    config.channelId,
-    { restart: bridgeRuntimeConnected }
-  );
-  const nextBackend = createBackend(config);
-  const backendChanged = (nextBackend?.name || "") !== previousBackendName;
-  if (backendChanged) {
-    const shouldRestart = bridgeRuntimeConnected || bridgeRuntimeStarting;
-    if (shouldRestart) await stopOwnedRuntime("backend config changed");
-    backend = nextBackend;
-    // The persisted routing channelId belongs to the OLD backend (e.g. a
-    // Discord snowflake) and is meaningless for the new one — sending to it
-    // would 400 "chat not found". There is no id mapping between platforms, so
-    // CLEAR the stale binding: drop the forwarder's context + watcher and wipe
-    // status.channelId/transcriptPath. The next inbound from the new backend
-    // rebinds the correct chat via applyTranscriptBinding(). Only done on
-    // backendChanged — same-backend reloads keep their binding untouched.
-    // (active-instance is cleared by stopOwnedRuntime on the restart path; we
-    // don't re-advertise here to avoid resurrecting a just-cleared entry.)
-    try { forwarder.stopWatch(); } catch {}
-    forwarder.channelId = "";
-    forwarder.transcriptPath = "";
-    try {
-      statusState.update((state) => {
-        state.channelId = "";
-        state.transcriptPath = "";
-      });
-    } catch {}
-    if (shouldRestart) refreshBridgeOwnershipSafe({ restoreBinding: false });
-  } else if (nextBackend !== previousBackend) {
-    try { await nextBackend.disconnect?.(); } catch {}
-  }
-  if (bridgeRuntimeConnected) {
-    syncOwnedWebhookAndEventRuntime({ reload: true });
-  } else {
-    await stopWebhookAndEventRuntime();
-  }
-}
-function injectAndRecord(channelId, name, content, options) {
-  // Strip soft-warn marker blocks (Tool-loop / Repeated-input / legacy
-  // Repeated-tool / Mixed-tool / Tool-budget / Same-file multi-chunk /
-  // Bash file-lookup / Iteration / 0-match advisory) from anywhere in the
-  // outbound body. Markers are
-  // intentionally prepended onto tool RESULTS upstream (tool-loop-guard.mjs
-  // build*Warn) so the model
-  // self-corrects, but agent roles commonly echo them and we don't want them
-  // surfacing in Discord / Lead channel push.
-  if (typeof content === 'string') content = stripSoftWarns(content);
-  // Skip-protocol guard: agents (webhook-handler / scheduler-task)
-  // prefix `[meta:silent]` on the first line to opt out
-  // of Lead inject for genuine no-op results (label-only events, dedup,
-  // "nothing to report"). The body still goes to Discord for audit; only
-  // the Lead-context inject is suppressed. See rules/agent/20-skip-protocol.md.
-  if (typeof content === 'string') {
-    const m = content.match(/^\s*\[meta:silent\][^\n]*\n?([\s\S]*)$/);
-    if (m) {
-      content = m[1];
-      options = { ...(options || {}), silent_to_agent: true };
-    }
-  }
-  const ts = new Date().toISOString();
-  const now = new Date();
-  const timeLabel = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")} `;
-  const sourceLabel = options?.type ? `${timeLabel}: ${options.type}` : timeLabel;
-  const meta = { chat_id: channelId, user: sourceLabel, user_id: "system", ts };
-  if (options?.instruction) meta.instruction = options.instruction;
-  if (options?.type) meta.type = options.type;
-  // `silent_to_agent` — lifecycle status pings (worker/iter/started echoes)
-  // surface on Discord but should NOT land in Lead's context window. When
-  // set, skip the parent-notify hop but keep the Discord-forward + event-log
-  // record. The meta flag is also propagated downstream so consumers that
-  // still see the notification (e.g. Lead itself if emission changes later)
-  // can recognise and drop it. Default is false → legacy behaviour preserved.
-  if (options?.silent_to_agent) meta.silent_to_agent = true;
-  const silent = options?.silent_to_agent === true;
-  if (!silent) {
-    sendNotifyToParent("notifications/claude/channel", { content, meta });
-  } else {
-    forwardLifecycleToDiscord(channelId, content);
-  }
-}
-
-// Best-effort direct Discord emission for silent-to-agent lifecycle pings.
-// Only used when the parent-notify hop is skipped, so the user still sees
-// the status on Discord even though Lead will never echo it through the
-// transcript-tail forwarder. Falls back to a no-op when no channel is
-// resolvable — lifecycle pings are non-critical.
-function forwardLifecycleToDiscord(channelId, content) {
-  try {
-    // Skip rather than guess: lifecycle callers pass the channelId they own;
-    // falling back to statusState.channelId can route to a stale/unrelated
-    // channel when the caller did not supply one intentionally.
-    const target = channelId || null;
-    dropTrace("send.lifecycle.entry", { channelId: target || "(none)", bindingReadyStatus, backendPresent: !!backend?.sendMessage, preview: preview(content) });
-    if (!target || !backend?.sendMessage) return;
-    void bindingReady.then(() =>
-      backend.sendMessage(target, content)
-        .then(() => dropTrace("send.lifecycle.ok", { channelId: target }))
-        .catch((err) => dropTrace("send.lifecycle.err", { channelId: target, err: String(err) }))
-    ).catch(() => {});
-  } catch { /* best-effort */ }
-}
-scheduler.setInjectHandler((channelId, name, content, options) => {
-  injectAndRecord(channelId, name, content, options);
-});
-scheduler.setSendHandler(async (channelId, text) => {
-  // Skip protocol: a scheduler-task emitting `[meta:silent]` has nothing to
-  // report — suppress the channel send entirely (no noise). Mirrors the
-  // webhook delegate drop and injectAndRecord's silent handling.
-  if (typeof text === "string" && /^\s*\[meta:silent\]/.test(text)) {
-    dropTrace("send.scheduler.silent", { channelId });
-    return;
-  }
-  dropTrace("send.scheduler.entry", { channelId, preview: preview(text) });
-  await bindingReady;
-  dropTrace("send.scheduler.ready", { channelId });
-  try {
-    await backend.sendMessage(channelId, text);
-    dropTrace("send.scheduler.ok", { channelId });
-  } catch (err) {
-    dropTrace("send.scheduler.err", { channelId, err: String(err) });
-    throw err;
-  }
-});
-function wireWebhookHandlers() {
-  if (!webhookServer) return;
-  webhookServer.setEventPipeline(eventPipeline);
-  webhookServer.setBridgeDispatch(async ({ role, preset, prompt, cwd, context }) => {
-    // Delegate-mode webhook → bridge orchestrator. Each bridge progress /
-    // final event is forwarded to the Lead via the same channel-notify
-    // path used by schedule & event-queue (injectAndRecord). Silent
-    // lifecycle pings keep routing only to Discord.
-    const agentMod = await import("../agent/index.mjs");
-    const channelId = resolveWebhookChannelId(context?.channel);
-    const endpoint = context?.endpoint || "unknown";
-    const event = context?.event || null;
-    const deliveryId = context?.deliveryId || null;
-    const label = `webhook:${endpoint}`;
-    const instruction = `Webhook review from role=${role} on endpoint "${endpoint}"`
-      + (event ? ` (event=${event})` : "")
-      + (deliveryId ? ` (delivery=${deliveryId})` : "")
-      + ". Relay the finding to the user naturally — summarize clearly, call out any issues, and note what needs a decision.";
-    const notifyFn = (text, meta = {}) => {
-      if (!text) return;
-      // Webhook skip protocol: when the agent worker emits a `[meta:silent]`
-      // marker (optionally behind model/role tag prefixes), the event is a
-      // no-op (label-only, dedup, "nothing to report"). Drop the message
-      // entirely — neither Lead inject nor Discord forward — instead of the
-      // partial `silent_to_agent` semantics that still audit to Discord.
-      const raw = String(text);
-      if (/^\s*(?:\[[^\]\n]+\]\s*)*\[meta:silent\]/.test(raw)) return;
-      // Deterministic findings-count drop. Code-review handlers emit a
-      // structured `[[findings:N]]` token (N = number of issues). The RELAY —
-      // not the worker's prose — decides: N==0 => clean review, drop entirely
-      // (no Lead inject, no Discord forward). Token absent => fail-safe forward
-      // so a real finding is never silently dropped if the worker omits it.
-      const fc = raw.match(/\[\[findings:(\d+)\]\]/i);
-      if (fc && Number(fc[1]) === 0) return;
-      // Lifecycle pings (started / iter echoes, marked silent_to_agent) are
-      // channel noise for an automated webhook review — drop them entirely so
-      // a skip stays fully silent and only the final answer reaches the
-      // channel. The final [meta:silent] skip result is already dropped above.
-      if (meta?.silent_to_agent === true) return;
-      // Strip the verdict token before surfacing (findings present, N>0).
-      const surfaced = raw.replace(/\[\[findings:\d+\]\]/gi, "").replace(/[^\S\n]{2,}/g, " ").trim();
-      injectAndRecord(channelId, label, surfaced || raw, {
-        type: "webhook",
-        instruction,
-      });
-    };
-    // Per-terminal cwd under the daemon's single channels worker. A webhook
-    // result is injected to ownerConn() — the connection whose session.leadPid
-    // equals active-instance ownerLeadPid — so the worker must run in THAT
-    // owner terminal's cwd. Read the sentinel keyed by ownerLeadPid; cwd-tool
-    // writes session-cwd-<leadPid>.txt per connection, so write and read meet
-    // on the same leadPid key no matter which terminal holds the owner seat.
-    // Falls back to the session entry position; never the plugin CACHE root.
-    const ownerPid = getActiveOwnerPid(readActiveInstance());
-    const ownerCwd = (ownerPid && readLastSessionCwd(ownerPid)) || captureOriginalUserCwd();
-    return agentMod.handleToolCall(
-      "bridge",
-      { role, preset, prompt, cwd: cwd || ownerCwd },
-      { notifyFn },
-    );
-  });
-}
-function resolveWebhookChannelId(channelFlag) {
-  // Single main channel: the endpoint's `channel` frontmatter is a boolean-ish
-  // flag (any non-empty value except "false" → post to the main channel). A raw
-  // channel id is still honored verbatim for owner-authored overrides.
-  const main = config?.channelId || "";
-  if (channelFlag == null) return main;
-  const v = String(channelFlag).trim();
-  if (v === "" || v.toLowerCase() === "false") return "";
-  // A pure-digit / snowflake-looking value is treated as an explicit id;
-  // anything else (legacy labels like "main") maps to the main channel.
-  return /^-?\d+$/.test(v) ? v : main;
-}
-function wireEventQueueHandlers(eventQueue) {
-  if (!eventQueue) return;
-  eventQueue.setInjectHandler((channelId, name, content, options) => {
-    injectAndRecord(channelId, name, content, options);
-  });
-  // Defensive ownership probe: the queue tick should only run in the active
-  // owner process. Non-owner instances see bridgeRuntimeConnected=false and
-  // will skip the tick even if an errant start() slipped through.
-  // bridgeRuntimeConnected is a fast-path AND; currentOwnerState().owned is
-  // re-read at probe time so a stale-connected flag cannot mask a lost seat.
-  eventQueue.setOwnerGetter(() => bridgeRuntimeConnected && currentOwnerState().owned);
-  forwarder.setOwnerGetter(() => bridgeRuntimeConnected && currentOwnerState().owned);
-}
-function editDiscordMessage(channelId, messageId, label) {
-  // Behavior-preserving: route through the backend abstraction (which uses
-  // discord.js under the hood) instead of issuing a raw REST PATCH. Errors
-  // are swallowed to stderr to match the prior fire-and-forget shape — the
-  // call site never awaited the HTTPS request either.
-  if (!getDiscordToken()) return;
-  const text = `\u{1F510} **Permission Request** \u2014 ${label}`;
-  void backend.editMessage(channelId, messageId, text, { components: [] }).catch((err) => {
-    process.stderr.write(`mixdog: editDiscordMessage failed: ${err}
-`);
-  });
-}
-backend.onModalRequest = async (rawInteraction) => {
-  if (!bridgeRuntimeConnected || !getBridgeOwnershipSnapshot().owned) {
-    refreshBridgeOwnershipSafe();
-    return;
-  }
-  const { ModalBuilder, TextInputBuilder, TextInputStyle, ActionRowBuilder } = await import("discord.js");
-  const customId = rawInteraction.customId;
-  const channelId = rawInteraction.channelId ?? "";
-  pendingSetup.rememberMessage(rawInteraction.user.id, channelId, rawInteraction.message?.id);
-  const modalSpec = buildModalRequestSpec(
-    customId,
-    pendingSetup.get(rawInteraction.user.id, channelId),
-    loadProfileConfig()
-  );
-  if (!modalSpec) return;
-  const modal = new ModalBuilder().setCustomId(modalSpec.customId).setTitle(modalSpec.title);
-  const rows = modalSpec.fields.map(
-    (field) => new ActionRowBuilder().addComponents((() => {
-      const input = new TextInputBuilder().setCustomId(field.id).setLabel(field.label).setStyle(TextInputStyle.Short).setRequired(field.required);
-      if (field.value) input.setValue(field.value);
-      return input;
-    })())
-  );
-  modal.addComponents(...rows);
-  await rawInteraction.showModal(modal);
-};
-const pendingPermRequests = new Map();
-const TOOL_EXEC_CONSUMER_MARKER = path.join(RUNTIME_ROOT, '.tool-exec-consumer');
-function refreshToolExecConsumerMarker() {
-  try {
-    if (pendingPermRequests.size > 0) {
-      fs.writeFileSync(TOOL_EXEC_CONSUMER_MARKER, String(Date.now()));
-    } else {
-      try { fs.unlinkSync(TOOL_EXEC_CONSUMER_MARKER); } catch {}
-    }
-  } catch {}
-}
-// Watch for terminal-approved tool executions. The PostToolUse hook writes a
-// signal file per tool call; when we see one, find the oldest pending perm
-// request with a matching tool name and mark its Discord message as
-// "Allowed (terminal)" so users don't see stale active buttons.
-try {
-  try { if (!fs.existsSync(RUNTIME_ROOT)) fs.mkdirSync(RUNTIME_ROOT, { recursive: true }); } catch {}
-  const SIGNAL_RE = /^tool-exec-\d+-[0-9a-f]+\.signal$/;
-  fs.watch(RUNTIME_ROOT, { persistent: false }, (eventType, filename) => {
-    if (!filename || !SIGNAL_RE.test(filename)) return;
-    setTimeout(() => {
-      try {
-        const signalPath = path.join(RUNTIME_ROOT, filename);
-        let raw;
-        try { raw = fs.readFileSync(signalPath, 'utf8'); } catch { return; }
-        let payload;
-        try { payload = JSON.parse(raw); } catch { return; }
-        const toolName = payload?.toolName;
-        if (!toolName) return;
-        const sigFilePath = payload?.filePath || '';
-        let oldestKey = null;
-        let oldestEntry = null;
-        for (const [k, v] of pendingPermRequests) {
-          if (v.toolName !== toolName) continue;
-          // Bind on filePath too. If both sides are empty (non-file tools
-          // like Bash), toolName alone is the match. Otherwise both must
-          // equal — prevents two concurrent Edit/Write requests from
-          // cross-approving each other.
-          const vFilePath = v.filePath || '';
-          if (vFilePath || sigFilePath) {
-            if (vFilePath !== sigFilePath) continue;
-          }
-          if (!oldestEntry || v.createdAt < oldestEntry.createdAt) {
-            oldestKey = k;
-            oldestEntry = v;
-          }
-        }
-        // No matching pending request — leave the signal on disk so a
-        // agent role hook (or other consumer) gets a chance to claim it.
-        if (!oldestKey || !oldestEntry) return;
-        if (oldestEntry.channelId && oldestEntry.messageId) {
-          try {
-            editDiscordMessage(oldestEntry.channelId, oldestEntry.messageId, 'Allowed (terminal)');
-          } catch (err) {
-            try { process.stderr.write(`mixdog channels: tool-exec signal edit failed: ${err && err.message || err}\n`); } catch {}
-          }
-        }
-        pendingPermRequests.delete(oldestKey);
-        refreshToolExecConsumerMarker();
-        // Only unlink once we've confirmed the match and handled it.
-        try { fs.unlinkSync(signalPath); } catch {}
-      } catch (err) {
-        try { process.stderr.write(`mixdog channels: tool-exec signal handler error: ${err && err.message || err}\n`); } catch {}
-      }
-    }, 50);
-  });
-  // Stale-signal sweeper: any signal file older than 60s is removed so
-  // unclaimed files don't accumulate on disk. Runs every 30s.
-  setInterval(() => {
-    try {
-      const now = Date.now();
-      const entries = fs.readdirSync(RUNTIME_ROOT);
-      for (const name of entries) {
-        if (!SIGNAL_RE.test(name)) continue;
-        const p = path.join(RUNTIME_ROOT, name);
-        try {
-          const st = fs.statSync(p);
-          if (now - st.mtimeMs > 60_000) {
-            try { fs.unlinkSync(p); } catch {}
-          }
-        } catch {}
-      }
-    } catch {}
-  }, 30_000)?.unref?.();
-} catch (err) {
-  try { process.stderr.write(`mixdog channels: tool-exec signal watcher setup failed: ${err && err.message || err}\n`); } catch {}
-}
-
-backend.onInteraction = (interaction) => {
-  // Channel-route permission reply. Custom_id format: perm-ch-{request_id}-{allow|session|deny}.
-  // request_id is the 5-letter short ID CC generates via shortRequestId().
-  // Emit notifications/claude/channel/permission back to the MCP host; the race
-  // logic in interactiveHandler.ts resolves the pending request and dismisses
-  // every other racer (local dialog, bridge, hook, classifier).
-  if (interaction.customId?.startsWith("perm-ch-")) {
-    const match = interaction.customId.match(/^perm-ch-([a-km-z]{5})-(allow|session|deny)$/);
-    if (!match) return;
-    const [, requestId, action] = match;
-    const access = config.access;
-    if (access?.allowFrom?.length > 0 && !access.allowFrom.includes(interaction.userId)) {
-      process.stderr.write(`mixdog: perm-ch button rejected — user ${interaction.userId} not in allowFrom\n`);
-      return;
-    }
-    const pending = pendingPermRequests.get(requestId);
-    pendingPermRequests.delete(requestId);
-    refreshToolExecConsumerMarker();
-    const params = { request_id: requestId };
-    if (action === 'deny') {
-      params.behavior = 'deny';
-    } else if (action === 'session') {
-      params.behavior = 'allow';
-      const toolName = pending?.toolName;
-      if (toolName) {
-        params.updatedPermissions = [{ type: 'addRules', rules: [{ toolName }], behavior: 'allow', destination: 'session' }];
-      }
-    } else {
-      params.behavior = 'allow';
-    }
-    sendNotifyToParent('notifications/claude/channel/permission', params);
-    const labels = { allow: 'Approved', session: 'Session Approved', deny: 'Denied' };
-    if (interaction.message?.id && interaction.channelId) {
-      editDiscordMessage(interaction.channelId, interaction.message.id, labels[action] || action);
-    }
-    return;
-  }
-  if (interaction.customId?.startsWith("perm-")) {
-    const match = interaction.customId.match(/^perm-([0-9a-f]{32})-(allow|session|deny)$/);
-    if (!match) return;
-    const [, uuid, action] = match;
-    const access = config.access;
-    if (!access) {
-      const _permDropLine = `[${localTimestamp()}] perm interaction dropped: no access config\n`;
-      if (isMixdogDebug()) {
-        fs.appendFileSync(_bootLog, _permDropLine);
-      } else {
-        appendSessionStartCriticalLog(DATA_DIR, `[channels] ${_permDropLine}`);
-      }
-      return;
-    }
-    if (access.allowFrom?.length > 0 && !access.allowFrom.includes(interaction.userId)) {
-      process.stderr.write(`mixdog: perm button rejected \u2014 user ${interaction.userId} not in allowFrom
-`);
-      return;
-    }
-    const resultPaths = [getPermissionResultPath(INSTANCE_ID, uuid)];
-    const leadInstanceId = String(TERMINAL_LEAD_PID);
-    if (leadInstanceId && leadInstanceId !== INSTANCE_ID) {
-      resultPaths.push(getPermissionResultPath(leadInstanceId, uuid));
-    }
-    for (const resultPath of resultPaths) {
-      try {
-        fs.writeFileSync(resultPath, action, { flag: "wx" });
-      } catch (e) {
-        if (e.code !== "EEXIST") {
-          process.stderr.write(`mixdog: writePermissionResult failed: ${e.message}\n`);
-        }
-      }
-    }
-    const labels = { allow: "Approved", session: "Session Approved", deny: "Denied" };
-    if (interaction.message?.id && interaction.channelId) {
-      editDiscordMessage(interaction.channelId, interaction.message.id, labels[action] || action);
-    }
-    return;
-  }
-  if (!bridgeRuntimeConnected || !getBridgeOwnershipSnapshot().owned) {
-    refreshBridgeOwnershipSafe();
-    return;
-  }
-  scheduler.noteActivity();
-  if (interaction.customId === "stop_task") {
-    controlClaudeSession(INSTANCE_ID, { type: "interrupt" })
-      .catch(err => process.stderr.write(`[channels] controlClaudeSession rejected: ${err?.message || err}\n`));
-    writeTextFile(TURN_END_FILE, String(Date.now()));
-    return;
-  }
-  sendNotifyToParent("notifications/claude/channel", {
-    content: `[interaction] ${interaction.type}: ${interaction.customId}${interaction.values ? " values=" + interaction.values.join(",") : ""}`,
-    meta: {
-      chat_id: interaction.channelId,
-      user: `interaction:${interaction.type}`,
-      user_id: interaction.userId,
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      interaction_type: interaction.type,
-      custom_id: interaction.customId,
-      ...interaction.values ? { values: interaction.values.join(",") } : {},
-      ...interaction.message ? { message_id: interaction.message.id } : {}
-    }
-  });
-};
-const { isVoiceAttachment, transcribeVoice } = createVoiceTranscription({
-  getConfig: () => config,
-  dataDir: DATA_DIR,
-});
-import { TOOL_DEFS } from './tool-defs.mjs';
-// Tool dispatch in worker mode goes through the IPC `call` handler at the
-// bottom of this file (parent's `callWorker` → `handleToolCall`). There is no
-// orphan worker-level MCP Server: the parent (server.mjs) owns the single
-// connected transport and routes CallTool through the IPC `call` path.
-const BACKEND_TOOLS = /* @__PURE__ */ new Set(["reply", "fetch"]);
-// ── Inbound routing / dedup / ownership helpers ─────────────────────────────
-// Extracted → lib/inbound-routing.mjs. Bound to live config/identity getters.
-const {
-  writeChannelOwner,
-  shouldDropDuplicateInbound,
-  resolveInboundRoute,
-} = createInboundRouting({
-  getConfig: () => config,
-  getInstanceId: () => INSTANCE_ID,
-  getChannelOwnerPath,
-});
-// ── Backend-tool dispatch helpers ───────────────────────────────────────────
-// Each helper dispatches through the local backend (this process is always the
-// owner in opt-in remote mode). Extracted → lib/backend-dispatch.mjs. Bound to
-// live config/backend getters so runtime reloads keep the original file-level
-// reference semantics.
-const {
-  dispatchReply,
-  dispatchFetch,
-} = createBackendDispatch({
-  getConfig: () => config,
-  getBackend: () => backend,
-  scheduler,
-});
-// ── Worker/HTTP tool-call dispatch ──────────────────────────────────────────
-// handleToolCall switch + bridge auto-connect retry wrapper. Extracted →
-// lib/tool-dispatch.mjs. The switch is entangled with ~8 runtime-lifecycle
-// functions plus mutable owner state (channelBridgeActive/bridgeRuntimeConnected)
-// and the forwarder; those are threaded as a lifecycle bag of lazy getters so
-// the module reads live file-level references at call time (original closure
-// semantics preserved). Used by the HTTP MCP CallTool path and the worker IPC
-// `call` handler at the bottom of this file.
-const {
-  handleToolCall,
-  handleToolCallWithBridgeRetry,
-} = createToolDispatch({
-  getForwarder: () => forwarder,
-  BACKEND_TOOLS,
-  isChannelsDegraded,
-  dispatchReply,
-  dispatchFetch,
-  lifecycle: {
-    getBridgeRuntimeConnected: () => bridgeRuntimeConnected,
-    getChannelBridgeActive: () => channelBridgeActive,
-    getOwned: () => getBridgeOwnershipSnapshot().owned,
-    setChannelBridgeActive: (v) => { channelBridgeActive = v; },
-    writeBridgeState,
-    stopServerTyping,
-    claimBridgeOwnership,
-    notifyRemoteAcquired,
-    refreshBridgeOwnership,
-    bindPersistedTranscriptIfAny,
-    stopOwnedRuntime,
-    reloadRuntimeConfig,
-  },
-});
-const inboundQueue = (() => {
-  let tail = Promise.resolve();
-  let _iqDepth = 0;
-  const _IQ_MAX_DEPTH = 1000;
-  return (fn) => {
-    if (_iqDepth >= _IQ_MAX_DEPTH) {
-      try { process.stderr.write(`mixdog: inboundQueue overflow (depth=${_iqDepth}), dropping message\n`); } catch {}
-      return;
-    }
-    _iqDepth++;
-    tail = Promise.resolve(tail).then(fn).catch((err) => {
-      try { process.stderr.write(`mixdog: inboundQueue error: ${err && err.message || err}\n`); } catch {}
-    }).finally(() => { _iqDepth--; });
-  };
-})();
-
-backend.onMessage = (msg) => {
-  const receivedAtMs = Number.isFinite(msg.receivedAtMs) ? msg.receivedAtMs : Date.now();
-  const onMessageAtMs = Date.now();
-  if (!bridgeRuntimeConnected || !getBridgeOwnershipSnapshot().owned) {
-    refreshBridgeOwnershipSafe();
-    return;
-  }
-  if (!channelBridgeActive) return;
-  if (shouldDropDuplicateInbound(msg)) return;
-  // No label concept anymore: the channel id IS the identifier.
-  recordFetchedMessages(msg.chatId, msg.chatId, [{ id: msg.messageId }], { markRead: true });
-  if (!writeChannelOwner(msg.chatId)) return;
-  const route = resolveInboundRoute(msg.chatId, msg.parentChatId);
-  scheduler.noteActivity();
-  startServerTyping(route.targetChatId);
-  backend.resetSendCount();
-  // Pin the prior turn's bound channel before this fire-and-forget flush so the
-  // imminent rebind below (which mutates forwarder.channelId synchronously)
-  // cannot redirect the previous turn's final output to the new channel.
-  const priorForwardChannelId = forwarder.channelId || null;
-  void forwarder.forwardFinalText(0, priorForwardChannelId).catch((err) => {
-    try { process.stderr.write(`mixdog: forwardFinalText rejection: ${err?.stack || err}\n`); } catch {}
-  }).finally(() => forwarder.reset());
-  const previousPath = getPersistedTranscriptPath();
-  let boundTranscript = null;
-  let stoleSelfTranscript = false;
-  let transcriptPath = forwarder.hasBinding() ? forwarder.transcriptPath : "";
-  let needsStealPoll = false;
-  // Reuse the current binding only while it still points at THIS owner's own
-  // session. discoverSessionBoundTranscript() now ranks the live parent-chain
-  // session (the one that forked this worker and receives injected input)
-  // above a more-recently-touched neighbour, so when a co-located session
-  // owns the stale binding we steal it back here instead of tailing the wrong
-  // transcript for the rest of the process lifetime. Steal whenever the live
-  // parent-chain (self) candidate resolves to a different path — even when its
-  // transcript is not on disk yet: we keep selfBound.exists=false so the
-  // downstream `!boundTranscript?.exists` branch routes through
-  // rebindTranscriptContext()'s pending-bind + re-arm poll, which forwards the
-  // first assistant reply once the self transcript is created. Marking the
-  // stale neighbour path as exists=true here would suppress that rearm and
-  // keep tailing the wrong session for the whole turn.
-  if (transcriptPath) {
-    const selfBound = discoverSessionBoundTranscript();
-    const shouldStealBoundTranscript = Boolean(
-      selfBound?.transcriptPath &&
-      !sameResolvedPath(selfBound.transcriptPath, transcriptPath) &&
-      selfBound.active === true &&
-      (selfBound.parentChain === true || selfBound.cwdMatches === true)
-    );
-    if (shouldStealBoundTranscript) {
-      process.stderr.write(`mixdog: inbound rebind: stealing transcript ${transcriptPath} -> ${selfBound.transcriptPath} (source=${selfBound.source || "unknown"}, exists=${selfBound.exists})\n`);
-      transcriptPath = selfBound.transcriptPath;
-      boundTranscript = selfBound;
-      stoleSelfTranscript = true;
-    } else {
-      boundTranscript = {
-        sessionId: sessionIdFromTranscriptPath(transcriptPath),
-        sessionCwd: statusState.read().sessionCwd ?? null,
-        transcriptPath,
-        exists: true
-      };
-      // Fast path skips the poll below (zero added latency) unless we lack a
-      // confident, currently-active self-bound candidate — that's the
-      // ~ms race window right after activate, before the parent-chain
-      // session record is published, where the steal gate above fails on
-      // the very first inbound even though a real self session exists.
-      if (!selfBound || selfBound.active !== true) needsStealPoll = true;
-    }
-  } else {
-    boundTranscript = discoverSessionBoundTranscript();
-    transcriptPath = pickUsableTranscriptPath(boundTranscript, previousPath);
-    // Only fall back to latest-by-mtime when discovery did NOT produce a
-    // confident, existing current-session transcript. detectCurrentSessionTranscript()
-    // already weighs mtime (with a 30s decisive threshold) against active-pid /
-    // cwd affinity, so overriding a real detected binding with the raw newest
-    // file would clobber the current session with an unrelated, more-recently
-    // touched transcript (wrong-session forward).
-    if (!boundTranscript?.exists) {
-      const latestByMtime = findLatestTranscriptByMtime(boundTranscript?.sessionCwd);
-      if (latestByMtime && latestByMtime !== transcriptPath) {
-        transcriptPath = latestByMtime;
-      }
-    }
-  }
-  // Binding-settled signal: resolves once the queued binding task below
-  // (poll-if-needed + apply-bind + rebind) has run, so the react/status
-  // IIFE can read the FINAL transcriptPath/boundTranscript instead of the
-  // pre-poll snapshot. onMessage itself stays synchronous — nothing here
-  // blocks message ordering or delays the enqueue calls.
-  let bindingDoneResolve;
-  const bindingDone = new Promise((resolve) => { bindingDoneResolve = resolve; });
-  const queuedAtMs = Date.now();
-  const preQueueMs = queuedAtMs - onMessageAtMs;
-  const gatewayToQueueMs = queuedAtMs - receivedAtMs;
-  if (preQueueMs > 250 || gatewayToQueueMs > 500) {
-    process.stderr.write(`mixdog: inbound latency prequeue=${preQueueMs}ms gateway_to_queue=${gatewayToQueueMs}ms channel=${route.targetChatId}\n`);
-  }
-  // ONE queued task per message: binding (poll-if-needed + bind + rebind)
-  // first, then handleInbound. Keeping both phases in a single task preserves
-  // the queue's per-message depth accounting — the overflow guard drops a
-  // whole message, never just its handleInbound half — and guarantees
-  // bindingDone/stopServerTyping always settle even when the binding phase
-  // throws. FIFO is preserved: inboundQueue chains tasks in call order, so
-  // this message's poll delay (if any) defers only its own delivery.
-  inboundQueue(async () => {
-    try {
-      if (needsStealPoll) {
-        const POLL_INTERVAL_MS = 50;
-        const POLL_TIMEOUT_MS = 500;
-        const pollStart = Date.now();
-        while (Date.now() - pollStart < POLL_TIMEOUT_MS) {
-          await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-          // fresh: bypass the negative parent-pid cache inside the walk —
-          // a transient parent-lookup miss cached just before this poll
-          // would otherwise pin every retry to null until its TTL expires,
-          // defeating the whole first-inbound recovery window.
-          const retryBound = discoverSessionBoundTranscript({ fresh: true });
-          const retryShouldSteal = Boolean(
-            retryBound?.transcriptPath &&
-            !sameResolvedPath(retryBound.transcriptPath, transcriptPath) &&
-            retryBound.active === true &&
-            (retryBound.parentChain === true || retryBound.cwdMatches === true)
-          );
-          if (retryShouldSteal) {
-            process.stderr.write(`mixdog: inbound rebind (poll +${Date.now() - pollStart}ms): stealing transcript ${transcriptPath} -> ${retryBound.transcriptPath} (source=${retryBound.source || "unknown"}, exists=${retryBound.exists})\n`);
-            transcriptPath = retryBound.transcriptPath;
-            boundTranscript = retryBound;
-            stoleSelfTranscript = true;
-            break;
-          }
-        }
-      }
-      if (transcriptPath) {
-        applyTranscriptBinding(route.targetChatId, transcriptPath, { cwd: boundTranscript?.sessionCwd });
-      } else {
-        refreshActiveInstance(INSTANCE_ID, { channelId: route.targetChatId }, { onlyIfOwned: true });
-      }
-      if (!boundTranscript?.exists) {
-        await rebindTranscriptContext(route.targetChatId, {
-          // For a stolen self transcript (not yet on disk) the sync bind above
-          // persisted lastFileSize=0 for this path, so catchUpFromPersisted makes
-          // setContext resume from offset 0 once the file appears — forwarding
-          // the first assistant reply. Relying on replayFromStart instead would
-          // race: the discovery loop only sets replayFromStart when it first saw
-          // the transcript as PENDING, so a file that already exists on the first
-          // loop iteration would bind at EOF and skip the reply. Non-steal keeps
-          // the original catch-up-from-cursor behaviour.
-          previousPath: transcriptPath,
-          catchUp: true,
-          catchUpFromPersisted: stoleSelfTranscript ? true : undefined,
-          persistStatus: true
-        });
-      }
-    } catch (err) {
-      try { process.stderr.write(`mixdog: inbound binding error: ${err}\n`); } catch {}
-    } finally {
-      bindingDoneResolve();
-    }
-    try {
-      await handleInbound(msg, route, {
-        sessionId: boundTranscript?.sessionId ?? sessionIdFromTranscriptPath(transcriptPath),
-        receivedAtMs,
-        queuedAtMs
-      });
-    } catch (err) {
-      process.stderr.write(`mixdog: handleInbound error: ${err}\n`);
-    } finally {
-      stopServerTyping();
-    }
-  });
-  void (async () => {
-    try {
-      await backend.react(msg.chatId, msg.messageId, "\u{1F914}");
-    } catch {
-    }
-    await bindingDone;
-    statusState.update((state) => {
-      state.channelId = route.targetChatId;
-      state.userMessageId = msg.messageId;
-      state.emoji = "\u{1F914}";
-      state.sentCount = 0;
-      state.sessionIdle = false;
-      if (transcriptPath) state.transcriptPath = transcriptPath;
-      else delete state.transcriptPath;
-      state.sessionCwd = boundTranscript?.sessionCwd ?? null;
-    });
-  })();
-};
-const NETWORK_ERR_RE = /fetch failed|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket hang up|network|timeout|aborted|TimeoutError/i;
-function isNetworkError(err) {
-  const s = `${err?.code ?? ""} ${err?.name ?? ""} ${err?.message ?? err ?? ""}`;
-  return NETWORK_ERR_RE.test(s);
-}
-async function retryOnNetwork(fn, { attempts = 3, baseDelayMs = 300, label = "op" } = {}) {
-  let lastErr;
-  for (let i = 0; i < attempts; i++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastErr = err;
-      if (i === attempts - 1 || !isNetworkError(err)) throw err;
-      const delay = baseDelayMs * (i + 1);
-      process.stderr.write(`mixdog: ${label} network failure (attempt ${i + 1}/${attempts}), retrying in ${delay}ms: ${err?.message || err}\n`);
-      await new Promise((r) => setTimeout(r, delay));
-    }
-  }
-  throw lastErr;
-}
-async function handleInbound(msg, route, options = {}) {
-  const handleStartMs = Date.now();
-  let text = msg.text;
-  const voiceAtts = msg.attachments.filter((a) => isVoiceAttachment(a.contentType));
-  if (voiceAtts.length > 0) {
-    if (config.voice?.enabled === false) {
-      process.stderr.write(`mixdog: voice.transcription skipped — voice.enabled=false\n`);
-      text = text || "[voice message]";
-    } else {
-      try {
-        const files = await retryOnNetwork(
-          // Short per-attempt timeout (vs the 180s default) bounds worst-case
-          // blockage of the serial inboundQueue on a bad voice message.
-          () => backend.downloadAttachment(msg.chatId, msg.messageId, { timeoutMs: 20_000 }),
-          { label: "voice.download" }
-        );
-        // concurrency handled inside transcribeVoice queue; loop is sequential so last att wins
-        for (const f of voiceAtts.map(a => files.find(df => df.id === a.id) ?? null).filter(Boolean)) {
-          const _t0 = Date.now();
-          const transcript = await retryOnNetwork(
-            () => transcribeVoice(f.path, { attachmentId: f.id }),
-            { label: "voice.transcription" }
-          );
-          const _elapsed = Date.now() - _t0;
-          if (transcript) {
-            text = transcript;
-            process.stderr.write(`mixdog: voice.transcription ok (${f.name}, ${_elapsed}ms): ${transcript.slice(0, 50)}\n`);
-          } else {
-            process.stderr.write(`mixdog: voice.transcription empty (${f.name})\n`);
-            text = text || "[voice message \u2014 transcription failed]";
-          }
-        }
-      } catch (err) {
-        const netFail = isNetworkError(err);
-        process.stderr.write(`mixdog: voice.transcription error${netFail ? " (network, retries exhausted)" : ""}: ${err}\n`);
-        const marker = netFail
-          ? "[attachment: voice transcription failed (network)]"
-          : `[voice message \u2014 transcription error: ${err?.message || err}]`;
-        text = text ? `${text} ${marker}` : marker;
-      }
-    }
-  }
-  const hasVoiceAtt = voiceAtts.length > 0;
-  const attMeta = msg.attachments.length > 0 && !hasVoiceAtt ? {
-    attachment_count: String(msg.attachments.length),
-    attachments: msg.attachments.map((a) => `${a.name} (${a.contentType}, ${(a.size / 1024).toFixed(0)}KB)`).join("; ")
-  } : {};
-  const messageBody = route.sourceMode === "monitor" && route.sourceLabel ? `[monitor:${route.sourceLabel}] ${text}` : text;
-  const notificationMeta = {
-    chat_id: route.targetChatId,
-    message_id: msg.messageId,
-    user: msg.user,
-    user_id: msg.userId,
-    ts: msg.ts,
-    ...route.sourceMode === "monitor" ? {
-      source_chat_id: route.sourceChatId,
-      source_mode: route.sourceMode,
-      ...route.sourceLabel ? { source_label: route.sourceLabel } : {}
-    } : {},
-    ...attMeta,
-    ...msg.imagePath ? { image_path: msg.imagePath } : {}
-  };
-  const notificationContent = messageBody;
-  sendNotifyToParent("notifications/claude/channel", {
-    content: notificationContent,
-    meta: notificationMeta
-  });
-  const notifiedAtMs = Date.now();
-  const receivedAtMs = Number.isFinite(options.receivedAtMs) ? options.receivedAtMs : handleStartMs;
-  const queuedAtMs = Number.isFinite(options.queuedAtMs) ? options.queuedAtMs : handleStartMs;
-  const queueMs = handleStartMs - queuedAtMs;
-  const handleMs = notifiedAtMs - handleStartMs;
-  const totalMs = notifiedAtMs - receivedAtMs;
-  if (queueMs > 250 || handleMs > 250 || totalMs > 500) {
-    process.stderr.write(`mixdog: inbound latency delivered total=${totalMs}ms queue=${queueMs}ms handle=${handleMs}ms channel=${route.targetChatId} attachments=${msg.attachments.length}\n`);
-  }
-  void memoryAppendEntry({
-    ts: msg.ts,
-    role: "user",
-    content: messageBody,
-    sourceRef: `discord:${route.targetChatId}#${msg.messageId}`,
-    sessionId: `discord:${route.targetChatId}`,
-    cwd: statusState.read().sessionCwd,
-  });
-}
-async function init(_sharedMcp) {
-  // _sharedMcp is no longer used. Notifications now flow via IPC to the parent
-  // (sendNotifyToParent above). The parameter is retained for backward
-  // compatibility with any caller that still passes a Server reference.
-  scheduler.setInjectHandler((channelId, name, content, options) => {
-    injectAndRecord(channelId, name, content, options);
-  });
-}
-async function start() {
-  channelBridgeActive = true;
-  writeBridgeState(true);
-  // Opt-in remote, single-owner, last-wins, MAKE-BEFORE-BREAK. Do NOT claim the
-  // seat up front: connect our own gateway first and claim only after it reports
-  // READY (inside startOwnedRuntime, claimAfterReady). Until then the previous
-  // owner keeps serving, so a boot causes no send/receive gap. This is also the
-  // SINGLE boot claim — the old "remote start" pre-claim + "re-activate
-  // takeover" second claim (double reconnect) is gone.
-  const _bindingReadyStart = Date.now();
-  try {
-    await startOwnedRuntime({ restoreBinding: true, claimAfterReady: true });
-    bindingReadyStatus = "resolved";
-    dropTrace("bindingReady.resolve", { elapsedMs: Date.now() - _bindingReadyStart, status: bindingReadyStatus });
-    _bindingReadyResolve(true);
-  } catch (e) {
-    bindingReadyStatus = "rejected";
-    dropTrace("bindingReady.reject", { elapsedMs: Date.now() - _bindingReadyStart, status: bindingReadyStatus, err: String(e) });
-    _bindingReadyResolve(e);
-  }
-  // Ownership timer: keep checking whether a newer remote session has taken
-  // over (last-wins) so a superseded owner disconnects promptly. Normally
-  // already armed by startOwnedRuntime before connect(); this is the fallback
-  // for a start path that aborted pre-connect (idempotent).
-  armBridgeOwnershipTimer();
-  // Hot-reload config on file change (schedules/webhooks/events).
-  if (!_configWatcher) {
-    try {
-      _configWatcher = fs.watch(path.join(DATA_DIR, "mixdog-config.json"), () => {
-        if (_reloadDebounce) clearTimeout(_reloadDebounce);
-        _reloadDebounce = setTimeout(() => { reloadRuntimeConfig().catch(() => {}); }, 500);
-      });
-    } catch {}
-  }
-  // Pre-warm the whisper-server manager once at owner startup so the first
-  // voice transcription does not pay cold-start cost. Non-blocking: failures
-  // (e.g. runtime not installed) are swallowed; per-request ensureReady retries.
-  void (async () => {
-    try {
-      if (config.voice?.enabled === false) return;
-      const runtime = resolveVoiceRuntime(DATA_DIR);
-      if (!runtime?.installed) return;
-      const _cpuCount = (() => { try { return os.cpus().length; } catch { return 2; } })();
-      const threadCount = config.voice?.transcription?.threadCount ?? Math.max(1, Math.ceil(_cpuCount / 4));
-      await ensureReady({ serverCmd: runtime.serverCmd, modelPath: runtime.modelPath, threadCount, host: '127.0.0.1' });
-    } catch (err) {
-      try { process.stderr.write(`mixdog: voice.transcription pre-warm skipped: ${err}\n`); } catch {}
-    }
-  })();
-}
-async function stop() {
-  try { await stopVoiceWhisperServer(); } catch {}
-  await stopOwnedRuntime("unified server stop");
-  cleanupInstanceRuntimeFiles(INSTANCE_ID);
-  if (bridgeOwnershipTimer) {
-    clearInterval(bridgeOwnershipTimer);
-    bridgeOwnershipTimer = null;
-  }
-  if (_reloadDebounce) { clearTimeout(_reloadDebounce); _reloadDebounce = null; }
-  if (_configWatcher) { try { _configWatcher.close(); } catch {} _configWatcher = null; }
-  if (turnEndWatcher) {
-    try { turnEndWatcher.close(); } catch {}
-    turnEndWatcher = null;
-  }
-}
-// ── IPC worker mode ──────────────────────────────────────────────
-if (_isWorkerMode && process.send) {
-  // SIGTERM/SIGINT/IPC shutdown handler — mirrors src/memory/index.mjs pattern.
-  // Cleans up in-progress webhook/scheduler state, removes runtime files, then exits.
-  let _channelsStopInFlight = false
-  let _channelsForceExitTimer = null
-  const _channelsShutdownHandler = async (sig) => {
-    if (_channelsStopInFlight) {
-      process.stderr.write(`[channels-worker] ${sig} — shutdown already in flight, ignoring\n`)
-      return
-    }
-    _channelsStopInFlight = true
-    process.stderr.write(`[channels-worker] received ${sig} — shutting down cleanly\n`)
-    _channelsForceExitTimer = setTimeout(() => {
-      process.stderr.write(`[channels-worker] stop() timed out after 6000ms — forcing exit(2)\n`)
-      process.exit(2)
-    }, 6000)
-    try { await stopVoiceWhisperServer() } catch (e) {
-      process.stderr.write(`[channels-worker] stopVoiceWhisperServer() error on ${sig}: ${e && (e.message || e)}\n`)
-    }
-    try { await stop() } catch (e) {
-      process.stderr.write(`[channels-worker] stop() error on ${sig}: ${e && (e.message || e)}\n`)
-    }
-    if (_channelsForceExitTimer) clearTimeout(_channelsForceExitTimer)
-    try { cleanupInstanceRuntimeFiles(INSTANCE_ID) } catch {}
-    try { clearServerPid() } catch {}
-    process.exit(0)
-  }
-  process.on('SIGTERM', () => _channelsShutdownHandler('SIGTERM'))
-  process.on('SIGINT',  () => _channelsShutdownHandler('SIGINT'))
-
-  // Map of callId → AbortController for in-flight IPC calls.
-  const _inFlightChannelCalls = new Map()
-
-  process.on('message', async (msg) => {
-    // Parent-initiated graceful shutdown — mirrors memory worker IPC pattern.
-    if (msg && msg.type === 'shutdown') {
-      process.stderr.write('[channels-worker] received IPC shutdown — calling stop()\n')
-      _channelsShutdownHandler('IPC:shutdown')
-      return
-    }
-    // Silent-to-agent lifecycle forward — parent (server.mjs) asks the
-    // channels worker to post status pings to the active bridge Discord
-    // channel without the Lead-notify hop. Best-effort: unknown channel or
-    // backend failure is swallowed; lifecycle pings are non-critical.
-    if (msg && msg.type === 'forward_to_discord') {
-      try {
-        const target = msg.channelId
-          || (statusState?.read?.().channelId)
-          || null;
-        if (target && backend?.sendMessage && typeof msg.content === 'string' && msg.content) {
-          await backend.sendMessage(target, msg.content).catch(() => {});
-        }
-      } catch { /* best-effort */ }
-      return;
-    }
-    // Host permission request → Discord Allow/Deny prompt.
-    // Parent (server.mjs) receives notifications/claude/channel/permission_request
-    // from the MCP host and forwards the params here. We post a buttoned message;
-    // button clicks are handled in backend.onInteraction and sent back to CC as
-    // notifications/claude/channel/permission via sendNotifyToParent.
-    if (msg && msg.type === 'permission_request_inbound') {
-      try {
-        const { request_id, tool_name, description, input_preview } = msg.params || {};
-        // tool_input arrives via the passthrough() schema in server.mjs when
-        // The host includes it in the permission_request notification.
-        // Used to bind the pendingPermRequest to a specific file so two
-        // concurrent Edit/Write requests cannot cross-approve via the
-        // terminal signal.
-        const toolInputParam = (msg.params && (msg.params.tool_input || msg.params.toolInput)) || {};
-        const filePathParam = toolInputParam.file_path || '';
-        if (!request_id || !tool_name) return;
-        if (pendingPermRequests.size > 100) {
-          const cutoff = Date.now() - 30 * 60 * 1000;
-          for (const [k, v] of pendingPermRequests) {
-            if (v.createdAt < cutoff) pendingPermRequests.delete(k);
-          }
-          refreshToolExecConsumerMarker();
-        }
-        const target = (statusState?.read?.().channelId)
-          || config?.channelId
-          || null;
-        if (!target || !backend?.sendMessage) {
-          process.stderr.write(`mixdog channels: permission_request dropped, no target channel (request_id=${request_id})\n`);
-          return;
-        }
-        const lines = [`🔐 **Permission Request**`, `Tool: \`${tool_name}\``];
-        if (description) lines.push(description);
-        if (input_preview) lines.push('```\n' + String(input_preview).slice(0, 800) + '\n```');
-        const content = lines.join('\n');
-        const components = [{
-          type: 1,
-          components: [
-            { type: 2, style: 3, label: 'Allow', custom_id: `perm-ch-${request_id}-allow` },
-            { type: 2, style: 1, label: 'Session Allow', custom_id: `perm-ch-${request_id}-session` },
-            { type: 2, style: 4, label: 'Deny', custom_id: `perm-ch-${request_id}-deny` },
-          ],
-        }];
-        let sentIds = null;
-        try {
-          const sendResult = await backend.sendMessage(target, content, { components });
-          sentIds = sendResult?.sentIds;
-        } catch (err) {
-          process.stderr.write(`mixdog channels: permission_request Discord send failed: ${err && err.message || err}\n`);
-          return;
-        }
-        const messageId = Array.isArray(sentIds) && sentIds.length > 0 ? sentIds[0] : null;
-        pendingPermRequests.set(request_id, {
-          toolName: tool_name,
-          filePath: filePathParam,
-          createdAt: Date.now(),
-          channelId: target,
-          messageId,
-        });
-        refreshToolExecConsumerMarker();
-      } catch (err) {
-        try { process.stderr.write(`mixdog channels: permission_request handler error: ${err && err.message || err}\n`); } catch {}
-      }
-      return;
-    }
-    if (handleMemoryCallResponse(msg)) return;
-    if (msg.type === 'cancel' && msg.callId) {
-      const entry = _inFlightChannelCalls.get(msg.callId)
-      if (entry) {
-        entry.abort()
-        _inFlightChannelCalls.delete(msg.callId)
-      }
-      process.send({ type: 'result', callId: msg.callId, error: 'cancelled' })
-      return
-    }
-    if (msg.type !== 'call' || !msg.callId) return
-    try {
-      const ac = new AbortController()
-      _inFlightChannelCalls.set(msg.callId, ac)
-      let result
-      try {
-        result = await handleToolCallWithBridgeRetry(msg.name, msg.args || {}, ac.signal)
-      } finally {
-        _inFlightChannelCalls.delete(msg.callId)
-      }
-      process.send({ type: 'result', callId: msg.callId, result })
-    } catch (e) {
-      process.send({ type: 'result', callId: msg.callId, error: e.message })
-    }
-  })
-  void (async () => {
-    const startedAt = performance.now()
-    const MAX_START_ATTEMPTS = 3
-    const BASE_BACKOFF_MS = 250
-    const isTransientStartErr = (err) =>
-      err?.code === 'ELOCKTIMEOUT' || /atomic lock timeout/i.test(err?.message || '')
-    let lastErr
-    for (let attempt = 1; attempt <= MAX_START_ATTEMPTS; attempt++) {
-      if (_channelsStopInFlight) return
-      try {
-        await start()
-        bootProfile("worker:ready", { ms: (performance.now() - startedAt).toFixed(1), attempt })
-        process.send({ type: 'ready' })
-        return
-      } catch (e) {
-        lastErr = e
-        const transient = isTransientStartErr(e)
-        bootProfile("worker:start-failed", { attempt, transient, error: e?.message || String(e) })
-        process.stderr.write(`[channels-worker] start() failed (attempt ${attempt}/${MAX_START_ATTEMPTS}, transient=${transient}): ${e && (e.message || e)}\n`)
-        if (!transient || attempt >= MAX_START_ATTEMPTS) break
-        const backoff = BASE_BACKOFF_MS * attempt + Math.floor(Math.random() * BASE_BACKOFF_MS)
-        await new Promise((r) => setTimeout(r, backoff))
-        if (_channelsStopInFlight) return
-      }
-    }
-    // A stop landed while we were failing — let clean shutdown proceed, never exit over it.
-    if (_channelsStopInFlight) return
-    // Terminal failure: do NOT mask as a (degraded) ready. Exit non-zero so the
-    // parent's exit-before-ready path respawns or rejects startRemote instead of
-    // silently losing remote output forwarding.
-    bootProfile("worker:failed", { ms: (performance.now() - startedAt).toFixed(1), error: lastErr?.message || String(lastErr) })
-    process.stderr.write(`[channels-worker] start() giving up after ${MAX_START_ATTEMPTS} attempts: ${lastErr && (lastErr.message || lastErr)}\n`)
-    // Exit 2 = terminal (non-transient) start failure: parent must reject, not respawn.
-    // Exit 1 = exhausted transient retries: parent may respawn.
-    process.exit(isTransientStartErr(lastErr) ? 1 : 2)
-  })()
-}
-
+// Thin facade for the channels worker runtime. The implementation was split
+// out into ./lib/worker-main.mjs plus focused lib/ modules; this file preserves
+// the exact public API and boot side-effects by re-exporting from worker-main.
+// Kept as the worker fork entrypoint (mixdog-session-runtime CHANNEL_WORKER_ENTRY).
 export {
   TOOL_DEFS,
   handleToolCall,
   handleToolCallWithBridgeRetry,
   init,
-  INSTRUCTIONS as instructions,
+  instructions,
   isChannelBridgeActive,
   isChannelsDegraded,
   start,
   stop
-};
+} from "./lib/worker-main.mjs";