mixdog 0.9.135 → 0.9.136

package/src/runtime/channels/lib/tool-dispatch.mjs

@@ -1,29 +1,19 @@
-import { OutputForwarder } from "./output-forwarder.mjs";
-
-// Worker/HTTP tool-call dispatch + bridge auto-connect retry wrapper.
-// Extracted verbatim from channels/index.mjs (behavior-preserving). The
-// `handleToolCall` switch is entangled with ~8 runtime-lifecycle functions
-// (claim/refresh ownership, stop owned runtime, transcript rebind, config
-// reload) plus mutable owner state (channelBridgeActive, bridgeRuntimeConnected)
-// and the forwarder. Those are threaded in as a `lifecycle` bag of lazy
-// getters/functions so the module reads the live file-level references at
-// call time — matching the original in-file closure semantics.
+// Worker/HTTP runtime-lifecycle dispatch (activate_channel_bridge /
+// reload_config). Channel messaging — forwarder, transcript binding, typing —
+// is deleted with Discord/Telegram; only the automation lifecycle remains.
+// Lifecycle functions are threaded in as a bag of lazy getters so the module
+// reads the live file-level references at call time.
 function createToolDispatch({
-  getForwarder,
   isChannelsDegraded,
   lifecycle,
 }) {
   const {
-    getBridgeRuntimeConnected,
     getChannelBridgeActive,
     getOwned,
     setChannelBridgeActive,
     writeBridgeState,
-    stopServerTyping,
     notifyRemoteAcquired,
     refreshBridgeOwnership,
-    bindPersistedTranscriptIfAny,
-    rebindCurrentTranscript,
     startChannelBridge,
     stopOwnedRuntime,
     reloadRuntimeConfig,
@@ -46,8 +36,6 @@ function createToolDispatch({
               // (getOwned() is always true), so activate never needs to claim a
               // seat or pre-notify — the not-connected -> connected transition
               // inside startOwnedRuntime fires notifyRemoteAcquired exactly once.
-              // refreshBridgeOwnership still re-pins the forwarder binding onto
-              // THIS session.
               if (getOwned?.() !== true) {
                 notifyRemoteAcquired?.();
               }
@@ -57,17 +45,12 @@ function createToolDispatch({
                 } else {
                   await refreshBridgeOwnership({ restoreBinding: true });
                 }
-                // An already-connected owner returns early from
-                // startOwnedRuntime(), so rebind explicitly to follow the
-                // current (parent-chain) session transcript.
-                if (getBridgeRuntimeConnected()) await bindPersistedTranscriptIfAny();
               } catch (e) {
                 process.stderr.write(`mixdog: bridge activate refresh failed (non-fatal): ${e?.message || e}\n`);
               }
             }
             if (!active && wasActive) {
-              stopServerTyping();
-              // Tear down the owner-side runtime so Discord/scheduler/webhook/
+              // Tear down the owner-side runtime so 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`);
@@ -99,13 +82,9 @@ function createToolDispatch({
             break;
           }
         case "rebind_current_transcript": {
-            // Lead-pushed repoint to the transcript it just created/rebound.
-            // Best-effort + idempotent: absent channelId or path => no-op; a
-            // bind failure is swallowed by the outer try so lead paths never
-            // throw. Same binding path as the inbound steal.
-            const transcriptPath = typeof args.transcriptPath === "string" ? args.transcriptPath.trim() : "";
-            if (transcriptPath) await rebindCurrentTranscript(transcriptPath);
-            result = { content: [{ type: "text", text: `transcript rebind ${transcriptPath ? "pushed" : "skipped (no path)"}` }] };
+            // Transcript forwarding is retired with channel messaging: accept
+            // and no-op so legacy lead-side pushes never surface an error.
+            result = { content: [{ type: "text", text: "transcript rebind retired" }] };
             break;
         }
         // memory — handled by memory-service.mjs MCP
@@ -125,32 +104,10 @@ function createToolDispatch({
     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 index.mjs.
-  // Last timestamp a forwardNewText() call was dispatched (debounce for item 4).
-  let _lastForwardMs = 0;
-
+  // IPC/HTTP wrapper: with channel messaging retired there is no transcript
+  // pre-flush or tool-log relay — plain dispatch.
   async function handleToolCallWithBridgeRetry(toolName, args, signal) {
-    const forwarder = getForwarder();
-    // 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();
-    // The transcript rebind op must repoint the forwarder BEFORE any flush;
-    // running the pre-flush first would send stale-transcript text ahead of the
-    // rebind. Skip the pre-flush for it so rebinding always precedes forwarding.
-    if (toolName !== 'rebind_current_transcript' && now - _lastForwardMs >= 250) {
-      _lastForwardMs = now;
-      await forwarder.forwardNewText();
-    }
-    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;
+    return handleToolCall(toolName, args, signal);
   }
 
   return { handleToolCall, handleToolCallWithBridgeRetry };

package/src/runtime/channels/lib/worker-ipc.mjs

@@ -67,21 +67,6 @@ export function runWorkerIpc({
       _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
-    // getProvider() 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 && getProvider()?.sendMessage && typeof msg.content === 'string' && msg.content) {
-          await getProvider().sendMessage(target, msg.content).catch(() => {});
-        }
-      } catch { /* best-effort */ }
-      return;
-    }
     if (handleMemoryCallResponse(msg)) return;
     if (msg.type === 'cancel' && msg.callId) {
       const entry = _inFlightChannelCalls.get(msg.callId)
@@ -137,7 +122,7 @@ export function runWorkerIpc({
     // 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
+    // parent's exit-before-ready path respawns or rejects the start 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`)

package/src/runtime/channels/lib/worker-main.mjs

@@ -12,29 +12,17 @@ import { captureOriginalUserCwd, readLastSessionCwd } from "../../shared/user-cw
 import { ensurePrivateRuntimeRoot, resolveRuntimeRoot } from "../../shared/runtime-root.mjs";
 import { initProviders } from "../../agent/orchestrator/providers/registry.mjs";
 import { Scheduler } from "./scheduler.mjs";
-import { startSnapshotWriter, stopSnapshotWriter, recordFetchedMessages } from "./status-snapshot.mjs";
+import { startSnapshotWriter, stopSnapshotWriter } from "./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 "./webhook.mjs";
 import { EventPipeline } from "./event-pipeline.mjs";
 import { startCliWorker } from "./cli-worker-host.mjs";
-import {
-  OutputForwarder,
-  discoverSessionBoundTranscript,
-  findLatestTranscriptByMtime,
-  sameResolvedPath
-} from "./output-forwarder.mjs";
-import { controlClaudeSession } from "./session-control.mjs";
 import { JsonStateFile, ensureDir, removeFileIfExists, writeTextFile } from "./state-file.mjs";
-import {
-  buildModalRequestSpec,
-  PendingInteractionStore
-} from "./interaction-workflows.mjs";
 import {
   ensureRuntimeDirs,
   makeInstanceId,
-  getTurnEndPath,
   getStatusPath,
   getChannelOwnerPath,
   getActiveOwnerPid,
@@ -61,24 +49,13 @@ import {
   BENIGN_CRASH_STREAK_WINDOW_MS,
 } from "./crash-log.mjs";
 import { dropTrace, preview, _dtIdxFlush } from "./index-drop-trace.mjs";
-import { createVoiceTranscription } from "./voice-transcription.mjs";
 import { createParentBridge } from "./parent-bridge.mjs";
-import { createInboundRouting } from "./inbound-routing.mjs";
 import { createToolDispatch } from "./tool-dispatch.mjs";
 import { createOwnerHeartbeat } from "./owner-heartbeat.mjs";
-import { createTranscriptBinding } from "./transcript-binding.mjs";
 import { isNetworkError, retryOnNetwork } from "./network-retry.mjs";
 import { runWorkerIpc } from "./worker-ipc.mjs";
-import { createInteractionHandlers } from "./interaction-handlers.mjs";
-import { createInboundHandler } from "./inbound-handler.mjs";
 import { createOwnedRuntime } from "./owned-runtime.mjs";
 import { runWorkerBootstrap } from "./worker-bootstrap.mjs";
-const memoryClientModulePath = new URL("./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
@@ -170,113 +147,12 @@ function writeBridgeState(active) {
 function isChannelBridgeActive() {
   return channelBridgeActive;
 }
-let typingChannelId = null;
-const pendingSetup = new PendingInteractionStore();
-function startServerTyping(channelId) {
-  if (typingChannelId && typingChannelId !== channelId) {
-    provider.stopTyping(typingChannelId);
-  }
-  typingChannelId = channelId;
-  provider.startTyping(channelId);
-}
-function stopServerTyping() {
-  if (typingChannelId) {
-    provider.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();
-const forwarder = new OutputForwarder({
-  send: async (ch, text, opts) => {
-    if (!channelBridgeActive) {
-      throw new Error("send() called while channel bridge is inactive");
-    }
-    await provider.sendMessage(ch, text, opts);
-  },
-  formatOutgoing: (text) => provider.formatOutgoing ? provider.formatOutgoing(text) : text,
-  recordAssistantTurn: async () => {
-  },
-  react: (ch, mid, emoji) => {
-    if (!channelBridgeActive) return Promise.resolve();
-    return provider.react(ch, mid, emoji);
-  },
-  removeReaction: (ch, mid, emoji) => {
-    if (!channelBridgeActive) return Promise.resolve();
-    return provider.removeReaction(ch, mid, emoji);
-  },
-  // Watchdog backstop: force the provider to tear down + rebuild a wedged
-  // client so an over-budget send fails fast and the queue releases.
-  resetProvider: async () => {
-    if (typeof provider?._resetClient === "function") await provider._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);
-// ── Transcript binding cluster ──────────────────────────────────────────────
-// Extracted → lib/transcript-binding.mjs. Bound to live config/identity/owner
-// getters so file-level reference semantics (runtime reloads, ownership flips)
-// are preserved.
-const {
-  sessionIdFromTranscriptPath,
-  getPersistedTranscriptPath,
-  pickUsableTranscriptPath,
-  applyTranscriptBinding,
-  cancelPendingTranscriptRearm,
-  schedulePendingTranscriptRearm,
-  rebindTranscriptContext,
-  bindPersistedTranscriptIfAny,
-} = createTranscriptBinding({
-  forwarder,
-  statusState,
-  readActiveInstance,
-  refreshActiveInstance,
-  instanceId: INSTANCE_ID,
-  memoryIngestTranscript,
-  memoryDrainBuffer,
-  dropTrace,
-  discoverSessionBoundTranscript,
-  sameResolvedPath,
-  getConfig: () => config,
-  getChannelBridgeActive: () => channelBridgeActive,
-  getBridgeRuntimeConnected: () => bridgeRuntimeConnected,
-  RUNTIME_ROOT,
-});
 const scheduler = new Scheduler(
   config.nonInteractive ?? [],
   config.interactive ?? [],
@@ -305,15 +181,6 @@ let bridgeRuntimeConnected = false;
 // in-flight start does not revive owner state after the stop already tore
 // the partial-start state down.
 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 provider binding has not yet been established.
-let bindingReadyStatus = "pending";
-let _bindingReadyResolve;
-const bindingReady = new Promise((r) => { _bindingReadyResolve = r; });
-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.
@@ -350,19 +217,13 @@ const {
   getChannelBridgeActive: () => channelBridgeActive,
   instanceId: INSTANCE_ID,
   TERMINAL_LEAD_PID,
-  forwarder,
   sendNotifyToParent,
   scheduler,
   statusState,
   logOwnership,
   currentOwnerState,
-  bindPersistedTranscriptIfAny,
-  cancelPendingTranscriptRearm,
-  schedulePendingTranscriptRearm,
-  stopServerTyping,
   wireWebhookHandlers,
   wireEventQueueHandlers,
-  memoryDrainBuffer,
 });
 function injectAndRecord(channelId, name, content, options) {
   // Strip soft-warn marker blocks (Tool-loop / Repeated-input / legacy
@@ -372,7 +233,7 @@ function injectAndRecord(channelId, name, content, options) {
   // 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.
+  // surfacing in the Lead channel push.
   if (typeof content === 'string') content = stripSoftWarns(content);
   const ts = new Date().toISOString();
   const now = new Date();
@@ -382,39 +243,10 @@ function injectAndRecord(channelId, name, content, options) {
   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, providerPresent: !!provider?.sendMessage, preview: preview(content) });
-    if (!target || !provider?.sendMessage) return;
-    void bindingReady.then(() =>
-      provider.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 */ }
+  // must NOT land in Lead's context window. The channel relay that used to
+  // surface them is retired, so silent pings are dropped entirely.
+  if (options?.silent_to_agent === true) return;
+  sendNotifyToParent("notifications/claude/channel", { content, meta });
 }
 scheduler.setInjectHandler((channelId, name, content, options) => {
   injectAndRecord(channelId, name, content, options);
@@ -423,24 +255,15 @@ scheduler.setInjectHandler((channelId, name, content, options) => {
 // actually holds the live bridge seat; otherwise the scheduler falls back to
 // the visible-session run so the fire is never lost.
 scheduler.setInjectReadyCheck(() => bridgeRuntimeConnected && currentOwnerState().owned);
-scheduler.setSendHandler(async (channelId, text) => {
-  dropTrace("send.scheduler.entry", { channelId, preview: preview(text) });
-  await bindingReady;
-  dropTrace("send.scheduler.ready", { channelId });
-  try {
-    await provider.sendMessage(channelId, text);
-    dropTrace("send.scheduler.ok", { channelId });
-  } catch (err) {
-    dropTrace("send.scheduler.err", { channelId, err: String(err) });
-    throw err;
-  }
+scheduler.setSendHandler(async () => {
+  // Channel delivery is retired: schedule results surface in the app session
+  // (parent notify / Automations row) only.
 });
 function wireWebhookHandlers() {
   if (!webhookServer) return;
   webhookServer.setEventPipeline(eventPipeline);
-  // Webhook fires run as sessions (schedules parity). Delivery mode:
-  // 'app' (default) → the Automations session row IS the surface;
-  // 'channel'/'both' → the run result also relays to the main channel.
+  // Webhook fires run as sessions (schedules parity); the Automations
+  // session row is the only surface (channel relay retired).
   webhookServer.setBridgeDispatch(async ({ prompt, model, cwd, workflow, attachments, delivery, context }) => {
     const { runWebhookSession } = await import("../../shared/webhook-session-run.mjs");
     const run = await runWebhookSession({
@@ -452,14 +275,6 @@ function wireWebhookHandlers() {
       delivery: delivery || null,
       prompt,
     });
-    const mode = String(delivery || "app");
-    if ((mode === "channel" || mode === "both") && run?.result && provider?.sendMessage) {
-      const target = scheduler.resolveChannel("");
-      if (target) {
-        void bindingReady.then(() => provider.sendMessage(target, run.result))
-          .catch((err) => dropTrace("send.webhook.err", { channelId: target, err: String(err) }));
-      }
-    }
     return run;
   });
 }
@@ -474,127 +289,37 @@ function wireEventQueueHandlers(eventQueue) {
   // 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);
 }
-createInteractionHandlers({
-  getProvider: () => provider,
-  getBridgeRuntimeConnected: () => bridgeRuntimeConnected,
-  instanceId: INSTANCE_ID,
-  getBridgeOwnershipSnapshot,
-  refreshBridgeOwnershipSafe,
-  pendingSetup,
-  buildModalRequestSpec,
-  loadProfileConfig,
-  sendNotifyToParent,
-  scheduler,
-  controlClaudeSession,
-  writeTextFile,
-  TURN_END_FILE,
-});
-const { isVoiceAttachment, transcribeVoice } = createVoiceTranscription({
-  getConfig: () => config,
-  dataDir: DATA_DIR,
-});
+// Inbound messaging, provider interaction handlers, and channel voice-message
+// transcription are DELETED with Discord/Telegram (user decision: PWA replaces
+// channels). The headless provider emits no events, so nothing wires here.
 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.
-// ── 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,
-});
 // ── 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.
+// Runtime lifecycle dispatch only (activate_channel_bridge / reload_config):
+// threaded as a lifecycle bag of lazy getters so the module reads live
+// file-level references at call time. 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,
   isChannelsDegraded,
   lifecycle: {
-    getBridgeRuntimeConnected: () => bridgeRuntimeConnected,
     getChannelBridgeActive: () => channelBridgeActive,
     getOwned: () => getBridgeOwnershipSnapshot().owned,
     setChannelBridgeActive: (v) => { channelBridgeActive = v; },
     writeBridgeState,
-    stopServerTyping,
     notifyRemoteAcquired,
     refreshBridgeOwnership,
-    bindPersistedTranscriptIfAny,
-    // Lead-pushed repoint: bind the exact transcript the lead just created
-    // (auto-acquire / newSession / resume / clear) instead of waiting for the
-    // next inbound parent-chain steal. Idempotent + best-effort: same binding
-    // path as the inbound steal (rebindTranscriptContext -> applyTranscriptBinding).
-    rebindCurrentTranscript: async (transcriptPath) => {
-      const cleanPath = typeof transcriptPath === "string" ? transcriptPath.trim() : "";
-      if (!cleanPath) return;
-      const channelId = statusState.read().channelId || config.channelId;
-      if (!channelId) return;
-      // Fail-closed: a malformed / not-yet-on-disk path must NEVER fall through
-      // to rebindTranscriptContext's discovery loop (which would mutate the
-      // binding onto a different session). Only an existing regular file binds;
-      // otherwise log + return so the current binding is left untouched.
-      let exists = false;
-      try { exists = fs.statSync(cleanPath).isFile(); } catch { exists = false; }
-      if (!exists) {
-        process.stderr.write(`mixdog: rebind_current_transcript: ignoring non-existent path ${cleanPath}\n`);
-        return;
-      }
-      // Idempotent: already bound to this exact transcript => no-op. In
-      // particular do NOT re-run recoverUnsyncedTail, which is only meaningful
-      // when the binding actually changes.
-      if (forwarder.hasBinding() && sameResolvedPath(forwarder.transcriptPath, cleanPath)) return;
-      // Binding changed: same path as the inbound steal's applyTranscriptBinding.
-      applyTranscriptBinding(channelId, cleanPath, {
-        persistStatus: true,
-        recoverUnsyncedTail: true,
-      });
-    },
     startChannelBridge: () => start({ messaging: true }),
     stopOwnedRuntime,
     reloadRuntimeConfig,
   },
 });
-createInboundHandler({
-  getProvider: () => provider,
-  getConfig: () => config,
-  getBridgeRuntimeConnected: () => bridgeRuntimeConnected,
-  getChannelBridgeActive: () => channelBridgeActive,
-  instanceId: INSTANCE_ID,
-  forwarder,
-  scheduler,
-  statusState,
-  getBridgeOwnershipSnapshot,
-  refreshBridgeOwnershipSafe,
-  writeChannelOwner,
-  shouldDropDuplicateInbound,
-  resolveInboundRoute,
-  isVoiceAttachment,
-  transcribeVoice,
-  getPersistedTranscriptPath,
-  sessionIdFromTranscriptPath,
-  pickUsableTranscriptPath,
-  applyTranscriptBinding,
-  rebindTranscriptContext,
-  sendNotifyToParent,
-  memoryAppendEntry,
-  startServerTyping,
-  stopServerTyping,
-});
 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
@@ -626,17 +351,11 @@ async function start(options = {}) {
   // Daemon model: this runtime is the machine-global singleton bridge owner
   // (enforced by the standalone daemon's singleton-owner lock), so there is no
   // seat to claim and no contender to make-before-break against. Just connect
-  // the owned runtime and bind the persisted transcript.
-  const _bindingReadyStart = Date.now();
+  // the owned runtime.
   try {
-    await startOwnedRuntime({ restoreBinding: 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);
+    await startOwnedRuntime();
+  } catch {
+    // Non-fatal: owned-runtime start errors degrade to automation-only mode.
   }
   // No-op under the daemon model (kept for call-site stability): there is no
   // ownership timer — the singleton daemon guarantees exactly one owner.
@@ -668,10 +387,6 @@ async function stop() {
   clearBridgeOwnershipTimer();
   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 ──────────────────────────────────────────────
 // Skipped under the machine-global host (MIXDOG_DAEMON_HOST=1): the daemon