mixdog 0.9.3 → 0.9.4

package/src/runtime/channels/index.mjs

@@ -1,4 +1,3 @@
-import { spawn } from "child_process";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
@@ -7,17 +6,15 @@ 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, transcribe, stopVoiceWhisperServer } from "./lib/whisper-server.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 { managedLaunchId, enqueueLauncherCommand } from "../shared/launcher-control.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 { invalidatePrefetchCache } from "../agent/orchestrator/session/cache/prefetch-cache.mjs";
 import { WebhookServer } from "./lib/webhook.mjs";
 import { EventPipeline } from "./lib/event-pipeline.mjs";
 import { startCliWorker } from "./lib/cli-worker-host.mjs";
@@ -63,7 +60,12 @@ import {
   BENIGN_CRASH_STREAK_WINDOW_MS,
 } from "./lib/crash-log.mjs";
 import { dropTrace, preview, _dtIdxFlush } from "./lib/index-drop-trace.mjs";
-import { normalizeWhisperLanguage, detectDeviceLanguage } from "./lib/whisper-language.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,
@@ -201,66 +203,11 @@ const INSTRUCTIONS = "";
 // 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.
-function normalizeChannelNotifyParams(method, params) {
-  if (method === 'notifications/claude/channel' && params && params.meta) {
-    const m = {};
-    for (const [k, v] of Object.entries(params.meta)) {
-      if (v === undefined || v === null) continue;
-      m[k] = k === 'silent_to_agent' ? (v === true || v === 'true') : String(v);
-    }
-    return { ...params, meta: m };
-  }
-  return params;
-}
-
-function sendNotifyToParent(method, params) {
-  // CC channel schema requires meta: Record<string,string> (channelNotification.ts).
-  // Coerce every meta value to string so a non-string (e.g. a Discord
-  // interaction.type number) can't fail zod and silently drop the notify.
-  // silent_to_agent stays boolean — an internal routing flag the daemon
-  // router / agentNotify consume (=== true) before the CC zod boundary.
-  const outParams = normalizeChannelNotifyParams(method, params);
-  if (!process.send) {
-    try { process.stderr.write(`mixdog channels: notify dropped (no IPC channel): ${method}\n`); } catch {}
-    return;
-  }
-  try {
-    process.send({ type: 'notify', method, params: outParams });
-  } catch (err) {
-    try { process.stderr.write(`mixdog channels: notify IPC send failed: ${err && err.message || err}\n`); } catch {}
-  }
-}
-
-// ── Memory worker bridge (worker → parent → memory) ─────────────────
-// The channels worker does not own the memory worker handle. To trigger
-// memory tool actions (e.g. cycle1) we send `memory_call_request` to the
-// parent, which routes through callWorker('memory', ...) and ships the
-// result back as `memory_call_response`. The response listener is
-// integrated into the main IPC handler below (not a second listener).
-const _memoryCallPending = new Map();
-let _memoryCallSeq = 0;
-
-function callMemoryAction(action, args, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    if (!process.send) return reject(new Error('not a worker process'));
-    const callId = `mc_${INSTANCE_ID}_${++_memoryCallSeq}_${Math.random().toString(36).slice(2, 8)}`;
-    const timer = setTimeout(() => {
-      _memoryCallPending.delete(callId);
-      reject(new Error(`memory_call ${action} timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-    _memoryCallPending.set(callId, {
-      resolve: (v) => { clearTimeout(timer); resolve(v); },
-      reject: (e) => { clearTimeout(timer); reject(e); },
-    });
-    try {
-      process.send({ type: 'memory_call_request', callId, action, args: args || {} });
-    } catch (e) {
-      _memoryCallPending.delete(callId);
-      clearTimeout(timer);
-      reject(e);
-    }
-  });
-}
+const {
+  sendNotifyToParent,
+  callMemoryAction,
+  handleMemoryCallResponse,
+} = createParentBridge({ getInstanceId: () => INSTANCE_ID });
 function resolveChannelLabel(channelsConfig, label) {
   if (!label || !channelsConfig) return label;
   const entry = channelsConfig[label];
@@ -362,15 +309,20 @@ forwarder.setOnIdle(() => {
 // (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.
-forwarder.setOwnerGetter(() => bridgeRuntimeConnected);
+// 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 });
   const boundTranscriptPath = forwarder.transcriptPath || transcriptPath;
   forwarder.startWatch();
   void memoryIngestTranscript(boundTranscriptPath, { cwd: options.cwd });
-  refreshActiveInstance(INSTANCE_ID, { channelId, transcriptPath: boundTranscriptPath });
+  // 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) => {
       state.channelId = channelId;
@@ -597,13 +549,7 @@ let bridgeRuntimeStarting = false;
 let _ownedRuntimeStopRequested = false;
 let bridgeOwnershipRefreshInFlight = null;
 let bridgeOwnershipTimer = null;
-let lastOwnershipNote = "";
 const ACTIVE_OWNER_STALE_MS = 1e4;
-// Owner heartbeat: keep active-instance.json fresh so other sessions cannot
-// steal the seat after 10 s of channel-action silence. unref'd interval —
-// never blocks process exit. Single JSON atomic write, no measurable load.
-const OWNER_HEARTBEAT_INTERVAL_MS = 5e3;
-let ownerHeartbeatTimer = null;
 // 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
@@ -613,31 +559,21 @@ let bindingReadyStatus = "pending";
 let _bindingReadyResolve;
 const bindingReady = new Promise((r) => { _bindingReadyResolve = r; });
 dropTrace("bindingReady.create", { status: bindingReadyStatus });
-function logOwnership(note) {
-  if (lastOwnershipNote === note) return;
-  lastOwnershipNote = note;
-  process.stderr.write(`[ownership] ${note}
-`);
-}
-function currentOwnerState() {
-  const active = readActiveInstance();
-  return {
-    active,
-    // Strict last-wins: this process owns the bridge ONLY when active-instance
-    // names exactly this INSTANCE_ID. A newer remote session that claims the
-    // seat overwrites instanceId, so the old owner immediately reads owned=false
-    // and disconnects on its next refresh tick. No PID/terminal fallback —
-    // that used to let a co-terminal worker wrongly self-claim.
-    owned: active?.instanceId === INSTANCE_ID
-  };
-}
-function getBridgeOwnershipSnapshot() {
-  return currentOwnerState();
-}
-function claimBridgeOwnership(reason) {
-  refreshActiveInstance(INSTANCE_ID);
-  logOwnership(`claimed owner (${reason})`);
-}
+// ── 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).
@@ -787,7 +723,20 @@ async function startOwnedRuntime(options = {}) {
   // Advertise active-instance.json BEFORE backend connect so a newer remote
   // session's last-wins claim is visible immediately. backendReady=false
   // marks the partial state until backend.connect() succeeds.
-  refreshActiveInstance(INSTANCE_ID, { backendReady: false });
+  // onlyIfOwned: startOwnedRuntime is only entered on the owned path, but a
+  // newer session can claim the seat between that check and this write; CAS
+  // aborts instead of re-stealing. The write result is checked below so a
+  // CAS abort stops the start path immediately (heartbeat/backend/scheduler
+  // never start) instead of relying on the 3s ownership timer to notice.
+  const casResult = refreshActiveInstance(INSTANCE_ID, { backendReady: false }, { onlyIfOwned: true });
+  // 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 the start path here rather than
+  // relying on the 3s ownership timer to notice later.
+  if (casResult?.instanceId !== INSTANCE_ID) {
+    bridgeRuntimeStarting = false;
+    return;
+  }
   startOwnerHeartbeat();
   // Re-check after each post-connect await so a stopOwnedRuntime() landing
   // mid-start cannot be overridden by the resuming start (scheduler/snapshot/
@@ -825,7 +774,11 @@ async function startOwnedRuntime(options = {}) {
       return;
     }
     bridgeRuntimeConnected = true;
-    refreshActiveInstance(INSTANCE_ID, { backendReady: true });
+    // onlyIfOwned: backend.connect() above can take seconds — a newer owner
+    // claiming the seat during that await must not be overwritten here. On
+    // CAS abort the next refreshBridgeOwnership tick observes owned=false
+    // and stops this runtime; backendReady stays unset for the lost seat.
+    refreshActiveInstance(INSTANCE_ID, { backendReady: true }, { onlyIfOwned: true });
     // 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
@@ -916,26 +869,14 @@ async function stopOwnedRuntime(reason) {
 function refreshBridgeOwnershipSafe(options = {}) {
   refreshBridgeOwnership(options).catch(err => process.stderr.write(`[channels] refreshBridgeOwnership rejected: ${err?.message || err}\n`));
 }
-function startOwnerHeartbeat() {
-  if (ownerHeartbeatTimer) return;
-  ownerHeartbeatTimer = setInterval(() => {
-    try {
-      // Last-wins guard: only refresh the seat if we STILL own it. If a newer
-      // remote session claimed active-instance.json since our last tick, do
-      // NOT overwrite it back — that would re-steal ownership and cause
-      // ping-pong / double backend connections. The bridgeOwnershipTimer's
-      // refreshBridgeOwnership() will observe owned=false and disconnect us.
-      if (currentOwnerState().owned) refreshActiveInstance(INSTANCE_ID);
-    } catch (e) {
-      process.stderr.write(`[ownership] heartbeat refresh failed: ${e instanceof Error ? e.message : String(e)}\n`);
-    }
-  }, OWNER_HEARTBEAT_INTERVAL_MS);
-  ownerHeartbeatTimer.unref?.();
-}
-function stopOwnerHeartbeat() {
-  if (!ownerHeartbeatTimer) return;
-  clearInterval(ownerHeartbeatTimer);
-  ownerHeartbeatTimer = null;
+// 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 {}
 }
 async function refreshBridgeOwnership(options = {}) {
   // Coalesce concurrent callers onto the in-flight refresh so backend tool
@@ -955,14 +896,18 @@ async function refreshBridgeOwnership(options = {}) {
     }
     const { active, owned } = currentOwnerState();
     if (owned) {
-      refreshActiveInstance(INSTANCE_ID);
+      // onlyIfOwned: ownership was checked outside the file lock; CAS mode
+      // prevents this periodic tick from overwriting a newer owner that
+      // claimed the seat in between (re-steal / ping-pong guard).
+      refreshActiveInstance(INSTANCE_ID, undefined, { onlyIfOwned: true });
       await startOwnedRuntime(options);
       return;
     }
     // Not the owner. Two sub-cases:
     //   (a) A live remote session holds the seat (active-instance names a
     //       different, non-stale instance) → last-wins: we lost, go quiet
-    //       (disconnect if we were connected).
+    //       (disconnect if we were connected) and tell the parent session to
+    //       drop remote mode entirely (single-holder, no handover).
     //   (b) There is NO live owner (active is null/stale — e.g. our own entry
     //       was cleared after a backend-connect failure or a bridge
     //       deactivate/reactivate) → this remote session claims the empty seat
@@ -971,6 +916,7 @@ async function refreshBridgeOwnership(options = {}) {
     if (active && active.instanceId && active.instanceId !== INSTANCE_ID) {
       if (bridgeRuntimeConnected) {
         await stopOwnedRuntime("ownership lost (newer remote session)");
+        notifyRemoteSuperseded();
       }
       return;
     }
@@ -1200,8 +1146,10 @@ function wireEventQueueHandlers(eventQueue) {
   // 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.
-  eventQueue.setOwnerGetter(() => bridgeRuntimeConnected);
-  forwarder.setOwnerGetter(() => bridgeRuntimeConnected);
+  // 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
@@ -1430,496 +1378,75 @@ backend.onInteraction = (interaction) => {
     }
   });
 };
-function isVoiceAttachment(contentType) {
-  if (typeof contentType !== 'string') return false;
-  const ct = contentType.toLowerCase();
-  return ct.startsWith("audio/") || ct.startsWith("application/ogg");
-}
-function runCmd(cmd, args, capture = false) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(cmd, args, {
-      stdio: capture ? ["ignore", "pipe", "ignore"] : "ignore",
-      windowsHide: true
-    });
-    let out = "";
-    if (capture && proc.stdout) proc.stdout.on("data", (d) => {
-      out += d;
-    });
-    proc.on("close", (code) => code === 0 ? resolve(out) : reject(new Error(`${cmd} exit ${code}`)));
-    proc.on("error", reject);
-  });
-}
-// ── voice.transcription concurrency queue (max=1 by default, config-driven) ──
-const _voiceTranscriptionQueue = (() => {
-  let running = 0;
-  const pending = [];
-  function drain() {
-    const limit = config.voice?.transcription?.maxConcurrency ?? 1;
-    while (running < limit && pending.length > 0) {
-      const { fn, resolve, reject } = pending.shift();
-      running++;
-      fn().then(resolve, reject).finally(() => { running--; drain(); });
-    }
-  }
-  return function enqueue(fn) {
-    return new Promise((resolve, reject) => { pending.push({ fn, resolve, reject }); drain(); });
-  };
-})();
-
-// ── wav + transcript cache keyed by attachment id ──
-const _voiceWavCache = new Map();        // attachmentId → wavPath
-const _voiceTranscriptCache = new Map(); // attachmentId → transcript string
-const _voiceInflight = new Map();        // attachmentId → Promise<string|null>
-const _voiceFfmpegInflight = new Map();  // attachmentId|wavPath → Promise<void> single-flight ffmpeg
-
-async function _probeAudioDurationSec(filePath) {
-  try {
-    const ffprobePath = (() => { try { return _require('ffprobe-static').path; } catch { return 'ffprobe'; } })();
-    return await new Promise((resolve, reject) => {
-      const args = ['-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', filePath];
-      let out = '';
-      const proc = spawn(ffprobePath, args, { windowsHide: true });
-      proc.stdout.on('data', (d) => { out += d; });
-      proc.on('close', (code) => { code === 0 ? resolve(parseFloat(out.trim()) || null) : reject(new Error(`ffprobe exit ${code}`)); });
-      proc.on('error', reject);
-    });
-  } catch {
-    return null;
-  }
-}
-
-async function transcribeVoice(audioPath, { attachmentId } = {}) {
-  // ── size gate (config: voice.transcription.maxFileSizeMB) ──
-  const maxSizeBytes = (config.voice?.transcription?.maxFileSizeMB ?? 0) * 1024 * 1024;
-  if (maxSizeBytes > 0) {
-    try {
-      const stat = await fs.promises.stat(audioPath);
-      if (stat.size > maxSizeBytes) {
-        process.stderr.write(`mixdog: voice.transcription skipped — file too large (${(stat.size / 1024 / 1024).toFixed(1)} MB > ${config.voice.transcription.maxFileSizeMB} MB): ${audioPath}\n`);
-        return null;
-      }
-    } catch { /* stat failure: proceed */ }
-  }
-  // ── duration gate (config: voice.transcription.maxDurationSec) ──
-  const maxDurationSec = config.voice?.transcription?.maxDurationSec ?? 0;
-  if (maxDurationSec > 0) {
-    const dur = await _probeAudioDurationSec(audioPath);
-    if (dur !== null && dur > maxDurationSec) {
-      process.stderr.write(`mixdog: voice.transcription skipped — audio too long (${Math.floor(dur)}s > ${maxDurationSec}s): ${audioPath}\n`);
-      return null;
-    }
-  }
-  // ── transcript cache hit ──
-  if (attachmentId && _voiceTranscriptCache.has(attachmentId)) {
-    process.stderr.write(`mixdog: voice.transcription cache hit (${attachmentId})\n`);
-    return _voiceTranscriptCache.get(attachmentId);
-  }
-  if (attachmentId && _voiceInflight.has(attachmentId)) {
-    return _voiceInflight.get(attachmentId);
-  }
-  const p = _voiceTranscriptionQueue(() => _doTranscribeVoice(audioPath, attachmentId));
-  if (attachmentId) {
-    _voiceInflight.set(attachmentId, p);
-    p.catch((err) => {
-      try { process.stderr.write(`mixdog: voice.transcription inflight rejection: ${err?.stack || err}\n`); } catch {}
-    }).finally(() => _voiceInflight.delete(attachmentId));
-  }
-  return p;
-}
-
-async function _doTranscribeVoice(audioPath, attachmentId) {
-  try {
-    const runtime = resolveVoiceRuntime(DATA_DIR);
-    if (!runtime?.installed) {
-      const missing = [runtime?.binary ? null : 'binary', runtime?.model ? null : 'model', runtime?.ffmpeg ? null : 'ffmpeg'].filter(Boolean).join(' + ');
-      throw new Error(`voice runtime not installed (missing: ${missing}) — open the setup wizard and click "Install voice"`);
-    }
-    const whisperCmd = runtime.whisperCmd;
-    const modelPath = runtime.modelPath;
-    const ffmpegPath = runtime.ffmpegPath;
-    const lang = normalizeWhisperLanguage(config.voice?.language) ?? detectDeviceLanguage();
-    const _cpuCount = (() => { try { return os.cpus().length; } catch { return 2; } })();
-    const threadCount = config.voice?.transcription?.threadCount ?? Math.max(1, Math.ceil(_cpuCount / 4));
-    // ── wav cache keyed by attachment id ──
-    let wavPath;
-    if (attachmentId && _voiceWavCache.has(attachmentId)) {
-      wavPath = _voiceWavCache.get(attachmentId);
-      if (!fs.existsSync(wavPath)) {
-        _voiceWavCache.delete(attachmentId);
-        wavPath = undefined;
-      } else {
-        process.stderr.write(`mixdog: voice.transcription wav cache hit (${attachmentId})\n`);
-      }
-    }
-    if (!wavPath) {
-      wavPath = audioPath.replace(/\.[^.]+$/, ".wav");
-      const sampleRate = config.voice?.transcription?.sampleRate ?? 16000;
-      const channels = config.voice?.transcription?.channels ?? 1;
-      // Single-flight: parallel callers for the same key share one ffmpeg spawn.
-      const _ffmpegKey = attachmentId || wavPath;
-      if (_voiceFfmpegInflight.has(_ffmpegKey)) {
-        await _voiceFfmpegInflight.get(_ffmpegKey);
-      } else {
-        const _ffmpegPromise = runCmd(ffmpegPath, ["-i", audioPath, "-ar", String(sampleRate), "-ac", String(channels), "-threads", String(threadCount), "-y", wavPath]);
-        _voiceFfmpegInflight.set(_ffmpegKey, _ffmpegPromise);
-        try {
-          await _ffmpegPromise;
-          if (attachmentId) _voiceWavCache.set(attachmentId, wavPath);
-        } finally {
-          _voiceFfmpegInflight.delete(_ffmpegKey);
-        }
-      }
-    }
-    process.stderr.write(`mixdog: voice.transcription start runtime=${runtime.kind} cmd=${path.basename(whisperCmd)}\n`);
-    await ensureReady({ serverCmd: runtime.serverCmd, modelPath, threadCount, host: '127.0.0.1' });
-    const text = await transcribe(wavPath, { language: lang });
-    const result = text.trim() || null;
-    if (attachmentId && result) _voiceTranscriptCache.set(attachmentId, result);
-    return result;
-  } catch (err) {
-    if (err?.message?.startsWith('voice runtime not installed')) throw err; // propagate setup errors; caller posts user-visible failure
-    process.stderr.write(`mixdog: voice.transcription failed: ${err}\n`);
-    return null;
-  }
-}
+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", "react", "edit_message", "download_attachment", "trigger_schedule"]);
+const BACKEND_TOOLS = /* @__PURE__ */ new Set(["reply", "fetch"]);
+// ── Inbound routing / dedup / ownership helpers ─────────────────────────────
+// Extracted → lib/inbound-routing.mjs. Bound to live config/identity getters.
+// Created here (ahead of backend-dispatch) so labelForChannelId is initialised
+// before it is passed into createBackendDispatch below.
+const {
+  writeChannelOwner,
+  shouldDropDuplicateInbound,
+  resolveInboundRoute,
+  labelForChannelId,
+} = 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). The MCP-result formatting (text shape, cache
-// invalidation, isError flag) is kept here so results stay consistent.
-// schedule_status / schedule_control share their result-formatting between
-// the local (owner) MCP case handlers and the owner-side HTTP routes that
-// serve proxied standby sessions. Keeping the body here makes both paths
-// byte-identical and reads the LIVE scheduler.
-function scheduleStatusResult() {
-  const statuses = scheduler.getStatus();
-  if (statuses.length === 0) {
-    return { content: [{ type: "text", text: "no schedules configured" }] };
-  }
-  const lines = statuses.map((s) => {
-    const state = s.running ? " [RUNNING]" : "";
-    const last = s.lastFired ? ` (last: ${s.lastFired})` : "";
-    return `  ${s.name}  ${s.time} ${s.days} (${s.type})${state}${last}`;
-  });
-  return { content: [{ type: "text", text: lines.join("\n") }] };
-}
-function scheduleControlResult(args) {
-  const scName = args.name;
-  const action = args.action;
-  // Validate that the named schedule actually exists.
-  const _scAll = [...(scheduler.nonInteractive || []), ...(scheduler.interactive || [])];
-  const _scKnown = _scAll.some(s => s.name === scName);
-  if (!_scKnown) {
-    return { content: [{ type: "text", text: `schedule_control: unknown schedule "${scName}" — use schedule_status to list valid names` }], isError: true };
-  }
-  if (action === "defer") {
-    const minutes = args.minutes ?? 30;
-    if (typeof minutes !== "number" || !Number.isFinite(minutes) || minutes <= 0) {
-      return { content: [{ type: "text", text: `schedule_control: minutes must be a positive number, got ${JSON.stringify(minutes)}` }], isError: true };
-    }
-    scheduler.defer(scName, minutes);
-    return { content: [{ type: "text", text: `deferred "${scName}" for ${minutes} minutes` }] };
-  } else if (action === "skip_today") {
-    scheduler.skipToday(scName);
-    return { content: [{ type: "text", text: `skipped "${scName}" for today` }] };
-  }
-  return { content: [{ type: "text", text: `unknown action: ${action}` }], isError: true };
-}
-async function dispatchReply(args) {
-  const sendOpts = {
-    replyTo: args.reply_to,
-    files: args.files ?? [],
-    embeds: args.embeds ?? [],
-    components: args.components ?? []
-  };
-  let ids;
-  // Pre-send activity bump keeps idle gating consistent during the await.
-  scheduler.noteActivity();
-  const sendResult = await backend.sendMessage(args.chat_id, args.text, sendOpts);
-  scheduler.noteActivity();
-  ids = sendResult.sentIds;
-  const text = ids.length === 1 ? `sent (id: ${ids[0]})` : `sent ${ids.length} parts (ids: ${ids.join(", ")})`;
-  return { content: [{ type: "text", text }] };
-}
-async function dispatchFetch(args) {
-  const channelId = resolveChannelLabel(config.channelsConfig, args.channel);
-  const limit = args.limit ?? 20;
-  let msgs;
-  msgs = await backend.fetchMessages(channelId, limit);
-  recordFetchedMessages(channelId, args.channel !== channelId ? args.channel : labelForChannelId(channelId), msgs);
-  const text = msgs.length === 0 ? "(no messages)" : msgs.map((m) => {
-    const atts = m.attachmentCount > 0 ? ` +${m.attachmentCount}att` : "";
-    return `[${m.ts}] ${m.user}: ${m.text}  (id: ${m.id}${atts})`;
-  }).join("\n");
-  return { content: [{ type: "text", text }] };
-}
-async function dispatchReact(args) {
-  await backend.react(args.chat_id, args.message_id, args.emoji);
-  return { content: [{ type: "text", text: "reacted" }] };
-}
-async function dispatchEditMessage(args) {
-  const opts = { embeds: args.embeds ?? [], components: args.components ?? [] };
-  let id;
-  id = await backend.editMessage(args.chat_id, args.message_id, args.text, opts);
-  return { content: [{ type: "text", text: `edited (id: ${id})` }] };
-}
-async function dispatchDownloadAttachment(args) {
-  let files;
-  files = await backend.downloadAttachment(args.chat_id, args.message_id);
-  if (files.length === 0) {
-    return { content: [{ type: "text", text: "message has no attachments" }] };
-  }
-  const lines = files.map(
-    (f) => `  ${f.path}  (${f.name}, ${f.contentType}, ${(f.size / 1024).toFixed(0)}KB)`
-  );
-  // Each downloaded file lands on the local FS; if any of them
-  // had a stale prefetch entry from a prior session, drop it so
-  // the next prefetch sees the fresh contents.
-  for (const f of files) {
-    if (f && typeof f.path === "string" && f.path) {
-      invalidatePrefetchCache(f.path);
-    }
-  }
-  return { content: [{ type: "text", text: `downloaded ${files.length} attachment(s):
-${lines.join("\n")}` }] };
-}
-async function handleToolCall(name, args, _signal) {
-  if (isChannelsDegraded()) {
-    return { content: [{ type: 'text', text: `[channels degraded] ${name} unavailable — restart MCP to recover` }], isError: true }
-  }
-  let result;
-  try {
-    switch (name) {
-      case "reply":
-        result = await dispatchReply(args);
-        break;
-      case "fetch":
-        result = await dispatchFetch(args);
-        break;
-      case "react":
-        result = await dispatchReact(args);
-        break;
-      case "edit_message":
-        result = await dispatchEditMessage(args);
-        break;
-      case "download_attachment":
-        result = await dispatchDownloadAttachment(args);
-        break;
-      case "schedule_status": {
-          result = scheduleStatusResult();
-          break;
-        }
-      case "trigger_schedule": {
-          const triggerResult = await scheduler.triggerManual(args.name);
-          result = { content: [{ type: "text", text: triggerResult }] };
-          break;
-        }
-      case "schedule_control": {
-          result = scheduleControlResult(args);
-          break;
-        }
-      case "activate_channel_bridge": {
-          const active = args.active === true;
-          const wasActive = channelBridgeActive;
-          channelBridgeActive = active;
-          writeBridgeState(active);
-          if (active && !wasActive) {
-            refreshBridgeOwnershipSafe({ restoreBinding: true });
-          }
-          if (!active && wasActive) {
-            stopServerTyping();
-            // Tear down the owner-side runtime so Discord/scheduler/webhook/
-            // event-pipeline don't keep running on a deactivated bridge.
-            try { await stopOwnedRuntime("bridge deactivated"); } catch (e) {
-              process.stderr.write(`mixdog: stopOwnedRuntime on deactivate failed: ${e?.message || e}\n`);
-            }
-          }
-          result = { content: [{ type: "text", text: `channel bridge ${active ? "activated" : "deactivated"}` }] };
-          break;
-        }
-      case "reload_config": {
-          await reloadRuntimeConfig();
-          // Extend reload to the agent module so providers/presets/maintenance
-          // hot-reload on the same call (dynamic import: agent/index.mjs does not
-          // import channels, so this stays acyclic and tolerant of load order).
-          let agentReloadMsg = "";
-          if (process.env.MIXDOG_STANDALONE !== '1') {
-            try {
-              const { reloadAgentConfig } = await import("../agent/index.mjs");
-              await reloadAgentConfig("reload_config tool");
-              agentReloadMsg = ", agent providers/presets/maintenance";
-            } catch (err) {
-              process.stderr.write(`[reload_config] agent reload failed: ${err?.message || String(err)}\n`);
-            }
-          }
-          result = { content: [{ type: "text", text: `config reloaded — schedules, webhooks, events${agentReloadMsg} re-registered` }] };
-          break;
-        }
-      case "inject_command": {
-          const cmd = String(args?.command || "").trim();
-          const ALLOW = new Set(["clear"]);
-          if (!ALLOW.has(cmd)) {
-            result = { content: [{ type: "text", text: `inject_command: '${cmd}' not in allow-list (${[...ALLOW].join(", ")})` }], isError: true };
-            break;
-          }
-          // Unified managed-launcher control path (cross-platform). The
-          // command is delivered to the `mixdog`-launched child's stdin by the
-          // launcher that owns it — no OS/terminal keystroke injection, no new
-          // window. Only sessions with an engaged native managed-launch bridge
-          // are addressable; anything else gets a clear not-managed error
-          // rather than a silent no-op.
-          try {
-            const launchId = managedLaunchId();
-            if (!launchId) {
-              result = { content: [{ type: "text", text: "inject_command: this session is not a managed `mixdog` launch (MIXDOG_LAUNCH_ID unset). Managed input delivery requires the native mixdog-launch PTY/ConPTY bridge." }], isError: true };
-              break;
-            }
-            enqueueLauncherCommand(launchId, `/${cmd}`);
-            result = { content: [{ type: "text", text: `queued /${cmd} for managed launcher (launchId=${launchId})` }] };
-          } catch (err) {
-            result = { content: [{ type: "text", text: `inject_command error: ${err?.message || err}` }], isError: true };
-          }
-          break;
-        }
-      // memory — handled by memory-service.mjs MCP
-      default:
-          result = {
-            content: [{ type: "text", text: `unknown tool: ${name}` }],
-            isError: true
-          };
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    result = {
-      content: [{ type: "text", text: `${name} failed: ${msg}` }],
-      isError: true
-    };
-  }
-  return result;
-}
-// Bridge auto-connect retry + forwarder-aware tool dispatch wrapper. Used by
-// both the HTTP MCP path (createHttpMcpServer's CallTool handler can call this)
-// and the worker IPC handler at the bottom of this file. The pre-v0.6.7 code
-// registered this on the orphan worker-level `Server`, which never had a
-// transport, so the wrapper never actually fired. Centralised here for reuse.
-// Last timestamp a forwardNewText() call was dispatched (debounce for item 4).
-let _lastForwardMs = 0;
-
-async function handleToolCallWithBridgeRetry(toolName, args, signal) {
-  // Debounce: only forward when ≥250 ms have elapsed since the last forward,
-  // to avoid one HTTP roundtrip per tool call on rapid-fire sequences.
-  const now = Date.now();
-  if (now - _lastForwardMs >= 250) {
-    _lastForwardMs = now;
-    await forwarder.forwardNewText();
-  }
-  if (BACKEND_TOOLS.has(toolName) && !bridgeRuntimeConnected) {
-    // Remote-owner startup: ensure this owner's backend is connected.
-    for (let i = 0; i < 2 && !bridgeRuntimeConnected; i++) {
-      try {
-        await refreshBridgeOwnership();
-      } catch {
-      }
-      if (!bridgeRuntimeConnected) await new Promise((r) => setTimeout(r, 300));
-    }
-    if (!bridgeRuntimeConnected) {
-      return {
-        content: [{ type: "text", text: `Discord auto-connect failed after retries. Check token and network.` }],
-        isError: true
-      };
-    }
-  }
-  const result = await handleToolCall(toolName, args, signal);
-  const toolLine = OutputForwarder.buildToolLine(toolName, args);
-  if (toolLine) {
-    // Distinct from the dispatch-log ok line (server-main.mjs): this forwards
-    // a human-readable tool summary to Discord for the user, not operator stdout.
-    void forwarder.forwardToolLog(toolLine, toolName, args);
-  }
-  return result;
-}
-const INBOUND_DEDUP_TTL = 5 * 6e4;
-const inboundSeen = /* @__PURE__ */ new Map();
-const INBOUND_DEDUP_DIR = path.join(os.tmpdir(), "mixdog-inbound");
-ensureDir(INBOUND_DEDUP_DIR);
-function writeChannelOwner(channelId) {
-  const ownerPath = getChannelOwnerPath(channelId);
-  try {
-    fs.writeFileSync(ownerPath, JSON.stringify({ instanceId: INSTANCE_ID, pid: process.pid, updatedAt: Date.now() }));
-    return true;
-  } catch {
-    return false;
-  }
-}
-function shouldDropDuplicateInbound(msg) {
-  const key = `${msg.chatId}:${msg.messageId}`;
-  const now = Date.now();
-  if (inboundSeen.has(key) && now - inboundSeen.get(key) < INBOUND_DEDUP_TTL) return true;
-  inboundSeen.set(key, now);
-  const marker = path.join(INBOUND_DEDUP_DIR, key.replace(/:/g, "_"));
-  try {
-    fs.writeFileSync(marker, String(now), { flag: "wx" });
-  } catch (e) {
-    if (e.code === "EEXIST") {
-      try {
-        const stat = fs.statSync(marker);
-        if (now - stat.mtimeMs < INBOUND_DEDUP_TTL) return true;
-      } catch {}
-    }
-  }
-  if (Math.random() < 0.1) {
-    try {
-      for (const f of fs.readdirSync(INBOUND_DEDUP_DIR)) {
-        const fp = path.join(INBOUND_DEDUP_DIR, f);
-        try {
-          if (now - fs.statSync(fp).mtimeMs > INBOUND_DEDUP_TTL) removeFileIfExists(fp);
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  for (const [k, t] of inboundSeen) {
-    if (now - t > INBOUND_DEDUP_TTL) inboundSeen.delete(k);
-  }
-  return false;
-}
-function resolveInboundRoute(chatId, parentChatId) {
-  const main = config.channelsConfig?.main;
-  const findEntry = (id) => {
-    if (!id || !config.channelsConfig) return null;
-    if (typeof main === "object" && main !== null && main.channelId === id) {
-      return { label: "main", entry: main };
-    }
-    for (const [label, entry] of Object.entries(config.channelsConfig)) {
-      if (typeof entry === "object" && entry !== null && entry.channelId === id) {
-        return { label, entry };
-      }
-    }
-    return null;
-  };
-  // Prefer a direct channelsConfig match on the thread/channel id; fall back
-  // to the parent channel id so thread messages inherit the parent's label
-  // and mode (e.g. monitor) instead of being routed as untagged interactive.
-  const direct = findEntry(chatId);
-  if (direct) {
-    const mode = direct.entry.mode === "monitor" ? "monitor" : (direct.entry.mode || "interactive");
-    return { targetChatId: chatId, sourceChatId: chatId, sourceLabel: direct.label, sourceMode: mode };
-  }
-  if (parentChatId) {
-    const viaParent = findEntry(parentChatId);
-    if (viaParent) {
-      const mode = viaParent.entry.mode === "monitor" ? "monitor" : (viaParent.entry.mode || "interactive");
-      return { targetChatId: chatId, sourceChatId: parentChatId, sourceLabel: viaParent.label, sourceMode: mode };
-    }
-  }
-  return { targetChatId: chatId, sourceChatId: chatId, sourceLabel: undefined, sourceMode: "interactive" };
-}
+// 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,
+  resolveChannelLabel,
+  labelForChannelId,
+});
+// ── 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,
+    setChannelBridgeActive: (v) => { channelBridgeActive = v; },
+    writeBridgeState,
+    stopServerTyping,
+    claimBridgeOwnership,
+    refreshBridgeOwnership,
+    bindPersistedTranscriptIfAny,
+    stopOwnedRuntime,
+    reloadRuntimeConfig,
+  },
+});
 const inboundQueue = (() => {
   let tail = Promise.resolve();
   let _iqDepth = 0;
@@ -1935,14 +1462,6 @@ const inboundQueue = (() => {
     }).finally(() => { _iqDepth--; });
   };
 })();
-// ── Reverse-lookup channelId → human label from channelsConfig ──────────────
-function labelForChannelId(channelId) {
-  if (!channelId || !config.channelsConfig) return channelId;
-  for (const [label, entry] of Object.entries(config.channelsConfig)) {
-    if (entry?.channelId === channelId) return label;
-  }
-  return channelId;
-}
 
 backend.onMessage = (msg) => {
   const receivedAtMs = Number.isFinite(msg.receivedAtMs) ? msg.receivedAtMs : Date.now();
@@ -1970,6 +1489,7 @@ backend.onMessage = (msg) => {
   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)
@@ -2003,6 +1523,12 @@ backend.onMessage = (msg) => {
         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();
@@ -2020,16 +1546,98 @@ backend.onMessage = (msg) => {
       }
     }
   }
-  if (transcriptPath) {
-    applyTranscriptBinding(route.targetChatId, transcriptPath, { cwd: boundTranscript?.sessionCwd });
-  } else {
-    refreshActiveInstance(INSTANCE_ID, { channelId: route.targetChatId });
+  // 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;
@@ -2040,39 +1648,7 @@ backend.onMessage = (msg) => {
       else delete state.transcriptPath;
       state.sessionCwd = boundTranscript?.sessionCwd ?? null;
     });
-    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
-      });
-    }
   })();
-  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`);
-  }
-  inboundQueue(() => handleInbound(msg, route, {
-    sessionId: boundTranscript?.sessionId ?? sessionIdFromTranscriptPath(transcriptPath),
-    receivedAtMs,
-    queuedAtMs
-  }).catch((err) => {
-    process.stderr.write(`mixdog: handleInbound error: ${err}
-`);
-  }).finally(() => {
-    stopServerTyping();
-  }));
 };
 async function handleInbound(msg, route, options = {}) {
   const handleStartMs = Date.now();
@@ -2343,17 +1919,7 @@ if (_isWorkerMode && process.send) {
       }
       return;
     }
-    if (msg && msg.type === 'memory_call_response' && msg.callId) {
-      // Response side of the worker → parent → memory bridge. Routed into
-      // this existing listener (instead of a second process.on('message'))
-      // to keep IPC dispatch in one place.
-      const pending = _memoryCallPending.get(msg.callId);
-      if (!pending) return;
-      _memoryCallPending.delete(msg.callId);
-      if (msg.ok) pending.resolve(msg.result);
-      else pending.reject(new Error(msg.error || 'memory_call failed'));
-      return;
-    }
+    if (handleMemoryCallResponse(msg)) return;
     if (msg.type === 'cancel' && msg.callId) {
       const entry = _inFlightChannelCalls.get(msg.callId)
       if (entry) {