mixdog 0.9.22 → 0.9.23

package/src/runtime/channels/lib/owner-heartbeat.mjs

@@ -1,16 +1,14 @@
-// Bridge ownership snapshot + owner heartbeat cluster. Extracted verbatim from
-// channels/index.mjs (behavior-preserving). Self-contained: owns its own
-// heartbeat timer + last-note dedup state, and depends only on the
-// active-instance read/refresh primitives + identity, threaded as injected
-// deps so the module reads live file-level references at call time.
+// Bridge ownership snapshot + ownership logging. Ownership TRUTH now comes from
+// the OS-enforced seat lock (lib/seat-lock.mjs): this process owns the bridge
+// iff it holds the named-pipe/unix-socket listener. The old 5s file heartbeat +
+// last-wins active-instance CAS is retired — a holder crash auto-releases the
+// pipe and takeover is an explicit release message, so no periodic refresh or
+// staleness eviction is needed. active-instance.json is now a pure metadata
+// advert written elsewhere; it is no longer read to decide ownership.
 function createOwnerHeartbeat({
-  getInstanceId,
-  readActiveInstance,
-  refreshActiveInstance,
-  OWNER_HEARTBEAT_INTERVAL_MS = 5e3,
+  isSeatHeld,
 }) {
   let lastOwnershipNote = "";
-  let ownerHeartbeatTimer = null;
 
   function logOwnership(note) {
     if (lastOwnershipNote === note) return;
@@ -19,65 +17,18 @@ function createOwnerHeartbeat({
 `);
   }
   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 === getInstanceId()
-    };
+    // Ownership is exactly "do we hold the seat lock". No file read, no PID
+    // heuristic, no staleness window.
+    return { owned: isSeatHeld() === true };
   }
   function getBridgeOwnershipSnapshot() {
     return currentOwnerState();
   }
-  function claimBridgeOwnership(reason, options = {}) {
-    // Returns true only when THIS instance actually holds the seat after the
-    // write. With options.timeoutMs:0 (try-once) a contended lock throws
-    // ELOCKCONTENDED — the caller catches it and treats the seat as busy.
-    const refreshOpts = Number.isFinite(options.timeoutMs) ? { timeoutMs: options.timeoutMs } : undefined;
-    const res = refreshActiveInstance(getInstanceId(), undefined, refreshOpts);
-    const claimed = res?.instanceId === getInstanceId();
-    if (claimed) logOwnership(`claimed owner (${reason})`);
-    return claimed;
-  }
-  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.
-        // onlyIfOwned: re-checks ownership INSIDE the file lock so a newer
-        // owner claiming the seat between currentOwnerState() and the locked
-        // write is never overwritten (see refreshActiveInstance CAS guard).
-        // Try-once (timeoutMs:0): the heartbeat must never block on the
-        // active-instance lock. On contention refreshActiveInstance throws and
-        // we simply skip this tick — the next tick catches up.
-        if (currentOwnerState().owned) refreshActiveInstance(getInstanceId(), undefined, { onlyIfOwned: true, timeoutMs: 0 });
-      } 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;
-  }
 
   return {
     logOwnership,
     currentOwnerState,
     getBridgeOwnershipSnapshot,
-    claimBridgeOwnership,
-    startOwnerHeartbeat,
-    stopOwnerHeartbeat,
   };
 }
 

package/src/runtime/channels/lib/parent-bridge.mjs

@@ -14,6 +14,16 @@ function normalizeChannelNotifyParams(method, params) {
   return params;
 }
 
+// Pluggable notify sink. Under the per-TUI fork model notifies flow over
+// node-IPC to the parent (process.send). Under the machine-global daemon there
+// is no IPC parent: the daemon entry installs a sink that routes each notify to
+// the CORRECT attached TUI over the transport's SSE fan-out (targeted, never
+// broadcast). When a sink is installed it fully replaces the process.send path.
+let _notifySink = null;
+function setChannelNotifySink(fn) {
+  _notifySink = typeof fn === 'function' ? fn : null;
+}
+
 function createParentBridge({ getInstanceId }) {
   function sendNotifyToParent(method, params) {
     // CC channel schema requires meta: Record<string,string> (channelNotification.ts).
@@ -22,6 +32,11 @@ function createParentBridge({ getInstanceId }) {
     // 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 (_notifySink) {
+      try { _notifySink(method, outParams); }
+      catch (err) { try { process.stderr.write(`mixdog channels: notify sink failed: ${err && err.message || err}\n`); } catch {} }
+      return;
+    }
     if (!process.send) {
       try { process.stderr.write(`mixdog channels: notify dropped (no IPC channel): ${method}\n`); } catch {}
       return;
@@ -85,4 +100,4 @@ function createParentBridge({ getInstanceId }) {
   };
 }
 
-export { createParentBridge, normalizeChannelNotifyParams };
+export { createParentBridge, normalizeChannelNotifyParams, setChannelNotifySink };

package/src/runtime/channels/lib/runtime-paths.mjs

@@ -38,6 +38,24 @@ function parsePositivePid(value) {
 function getTerminalLeadPid() {
   return parsePositivePid(process.env.MIXDOG_SUPERVISOR_PID) ?? process.pid;
 }
+// Daemon pointer-owner override. The machine-global daemon is spawned once, so
+// its intrinsic terminalLeadPid pins to the FIRST spawner. When the routing
+// pointer moves (a TUI claims the bridge / rebinds its transcript) the daemon
+// calls setOwnerContext({leadPid,cwd}) so active-instance.json owner fields
+// track the CURRENT bound TUI — statusline/webhook/memory resolve the pointer
+// TUI (and its session-cwd), not the spawner.
+let _ownerContextOverride = null;
+function setOwnerContext(ctx) {
+  const leadPid = parsePositivePid(ctx?.leadPid);
+  const next = leadPid ? { leadPid, cwd: ctx?.cwd ?? null } : null;
+  const changed = JSON.stringify(next) !== JSON.stringify(_ownerContextOverride);
+  _ownerContextOverride = next;
+  // Synchronously re-advertise so external readers (statusline/webhook/memory)
+  // see the new owner/cwd immediately, not on the next incidental refresh.
+  if (changed) {
+    try { refreshActiveInstance(makeInstanceId(), {}); } catch {}
+  }
+}
 function getServerPid() {
   return parsePositivePid(process.env.MIXDOG_SERVER_PID) ?? (process.env.MIXDOG_WORKER_MODE === "1" ? null : process.pid);
 }
@@ -57,7 +75,6 @@ function isPidAlive(pid) {
     return e?.code === "EPERM";
   }
 }
-const UI_HEARTBEAT_STALE_MS = 5 * 60 * 1e3;
 function activeInstanceStaleReason(state) {
   const ownerPid = getActiveOwnerPid(state);
   if (!isPidAlive(ownerPid)) return `owner PID ${ownerPid ?? "unknown"} is dead`;
@@ -67,39 +84,16 @@ function activeInstanceStaleReason(state) {
   if (workerPid && !isPidAlive(workerPid)) return `worker PID ${workerPid} is dead`;
   const serverPid = parsePositivePid(state?.server_pid);
   if (serverPid && !isPidAlive(serverPid)) return `server PID ${serverPid} is dead`;
-  // Zombie-Lead repro (2026-07-02): a Lead's owner/channels/worker/server
-  // PIDs can all still be alive (process not killed) while the TUI's render
-  // loop is dead in the water — no signal ever fires, so pid-only staleness
-  // never trips. If the TUI is heartbeating (field present), treat a stale
-  // heartbeat as stale ownership too. Backward-compat: state written by an
-  // older/non-TUI process (or before the first heartbeat tick) simply omits
-  // ui_heartbeat_at, so this branch is a no-op and pid-only judgment stands.
-  const uiHeartbeatAt = Number(state?.ui_heartbeat_at);
-  if (Number.isFinite(uiHeartbeatAt) && uiHeartbeatAt > 0) {
-    const age = Date.now() - uiHeartbeatAt;
-    if (age > UI_HEARTBEAT_STALE_MS) {
-      return `ui heartbeat stale (${Math.round(age / 1000)}s since last tick)`;
-    }
-  }
+  // NOTE: ownership is no longer decided here — the OS seat lock
+  // (lib/seat-lock.mjs) is the authority. This PID-death check only marks a
+  // metadata advert whose owning process is gone so refreshActiveInstance can
+  // avoid preserving its owner fields. The former ui_heartbeat_at staleness
+  // branch was removed: its false-stale eviction was the Discord-flapping root
+  // cause, and a crashed holder now auto-releases the seat instead.
   return null;
 }
-// Called from src/tui on a 30s timer while the render loop is alive. Only
-// touches ui_heartbeat_at (and updatedAt) so it never races/clobbers the
-// channels worker's own refreshActiveInstance() writes.
-function touchUiHeartbeat(instanceId) {
-  ensureRuntimeDirs();
-  try {
-    updateJsonAtomicSync(ACTIVE_INSTANCE_FILE, (curRaw) => {
-      if (!curRaw) return undefined;
-      if (instanceId && curRaw.instanceId !== instanceId) return undefined;
-      return { ...curRaw, ui_heartbeat_at: Date.now(), updatedAt: Date.now() };
-    }, { compact: true, fsync: false, fsyncDir: false, renameFallback: 'truncate', timeoutMs: 0 });
-  } catch { /* best-effort try-once (timeoutMs:0): on lock contention we skip
-               this tick without ever blocking the render loop on Atomics.wait;
-               the next 30s tick catches up. */ }
-}
 function buildRuntimeIdentity() {
-  const terminalLeadPid = getTerminalLeadPid();
+  const terminalLeadPid = _ownerContextOverride?.leadPid ?? getTerminalLeadPid();
   const serverPid = getServerPid();
   return {
     ownerLeadPid: terminalLeadPid,
@@ -108,6 +102,7 @@ function buildRuntimeIdentity() {
     server_pid: serverPid,
     worker_pid: process.pid,
     ...process.env.MIXDOG_WORKER_MODE === "1" ? { channels_pid: process.pid } : {},
+    ...(_ownerContextOverride?.cwd ? { sessionCwd: _ownerContextOverride.cwd } : {}),
   };
 }
 function getTurnEndPath(instanceId) {
@@ -140,71 +135,11 @@ function readActiveInstance() {
     state = readJsonFile(ACTIVE_INSTANCE_FILE, null);
     if (!state) return null;
   }
-  const staleReason = activeInstanceStaleReason(state);
-  if (staleReason) {
-    // Owner is dead — but the file may carry process-independent runtime
-    // state (memory_port, pg_*) that next callers want to preserve. Wiping
-    // the whole file forced the next refresh to rebuild from {} and drop
-    // memory_port, which broke the scheduler and MCP memory lookup
-    // until the memory worker re-advertised. Instead, clear only the
-    // owner-identity fields and keep the rest as a stale-but-useful prev
-    // for the next refresh. refreshActiveInstance still treats the
-    // returned state as "no live owner" via getActiveOwnerPid downstream.
-    const {
-      pinned: _stalePinned,
-      instanceId: _staleId,
-      ownerLeadPid: _staleOwner,
-      terminalLeadPid: _staleTerm,
-      supervisor_pid: _staleSup,
-      server_pid: _staleServer,
-      worker_pid: _staleWorker,
-      channels_pid: _staleChannels,
-      supervisor_started_at: _staleStart,
-      server_started_at: _staleServerStart,
-      httpPort: _staleHttpPort,
-      backendReady: _staleBackendReady,
-      turnEndFile: _staleTurnEnd,
-      statusFile: _staleStatus,
-    } = state ?? {};
-    const ownerFieldsAlreadyEmpty = _staleId === undefined
-      && _staleOwner === undefined
-      && _staleTerm === undefined
-      && _staleSup === undefined;
-    if (!ownerFieldsAlreadyEmpty) {
-      process.stderr.write(`mixdog: stale active-instance.json (${staleReason}), clearing owner fields\n`);
-      try {
-        updateJsonAtomicSync(ACTIVE_INSTANCE_FILE, (curRaw) => {
-          if (!curRaw) return undefined;
-          const liveReason = activeInstanceStaleReason(curRaw);
-          if (!liveReason) return undefined;
-          const {
-            pinned: _stalePinned2,
-            instanceId: _staleId2,
-            ownerLeadPid: _staleOwner2,
-            terminalLeadPid: _staleTerm2,
-            supervisor_pid: _staleSup2,
-            server_pid: _staleServer2,
-            worker_pid: _staleWorker2,
-            channels_pid: _staleChannels2,
-            supervisor_started_at: _staleStart2,
-            server_started_at: _staleServerStart2,
-            httpPort: _staleHttpPort2,
-            backendReady: _staleBackendReady2,
-            turnEndFile: _staleTurnEnd2,
-            statusFile: _staleStatus2,
-            ...stableRestLocked
-          } = curRaw ?? {};
-          const ownerEmpty = _staleId2 === undefined
-            && _staleOwner2 === undefined
-            && _staleTerm2 === undefined
-            && _staleSup2 === undefined;
-          if (ownerEmpty) return undefined;
-          return { ...stableRestLocked, updatedAt: Date.now() };
-        }, { compact: true, fsync: false, fsyncDir: false, renameFallback: 'truncate' });
-      } catch {}
-    }
-    return null;
-  }
+  // Pure metadata-advert read: ownership is the OS seat lock now, so this no
+  // longer evicts a "stale" owner (the false-stale ui_heartbeat eviction was
+  // the Discord-flapping root cause). A crashed holder auto-releases the seat;
+  // its leftover advert is harmless and refreshActiveInstance's own
+  // preservation logic decides which fields to carry forward.
   return state;
 }
 function writeActiveInstance(state) {
@@ -401,22 +336,6 @@ function refreshActiveInstance(instanceId, meta, options) {
         }
       }
     }
-    // Headless worker-owned seat: THIS process is the channels worker AND no
-    // distinct terminal lead owns the seat (ownerLeadPid resolves to our own
-    // pid). A worker never runs the TUI render loop, so it owns no heartbeat —
-    // it must NOT keep refreshing a ui_heartbeat_at it does not own. An
-    // inherited value (written by a prior TUI session, carried forward in
-    // prevRest) would otherwise be perpetually renewed here and falsely mask a
-    // dead render loop, so DROP it and let pid-only judgment stand.
-    // When a distinct terminal lead owns the seat (ownerLeadPid !== our pid),
-    // this branch is a no-op: the TUI's own heartbeat is carried forward
-    // untouched, so a stale (zombie) render loop still evicts the seat even
-    // while the worker pid is alive.
-    const workerOwnsSeat = process.env.MIXDOG_WORKER_MODE === "1"
-      && identity.ownerLeadPid === process.pid;
-    if (workerOwnsSeat) {
-      delete next.ui_heartbeat_at;
-    }
     return { ...preservedExtra, ...next };
   }, writeOpts);
 }
@@ -572,6 +491,6 @@ export {
   probeActiveOwner,
   refreshActiveInstance,
   releaseOwnedChannelLocks,
-  touchUiHeartbeat,
+  setOwnerContext,
   writeServerPid
 };

package/src/runtime/channels/lib/seat-lock.mjs

@@ -0,0 +1,196 @@
+import net from "net";
+import { createHash } from "crypto";
+import { existsSync, unlinkSync } from "fs";
+import { join } from "path";
+
+// OS-enforced bridge-seat singleton. The seat is a named-pipe (win32) / unix
+// domain socket (posix) server: acquiring the seat == successfully listen()ing
+// on the address. Because the OS binds exactly one listener per address, at
+// most one process can hold the seat at a time — no file heartbeat / staleness
+// heuristics, and a holder crash auto-releases (win32 removes the pipe; posix
+// leaves a stale socket file that a connect-probe detects and unlinks).
+//
+// Takeover is an EXPLICIT release message, not a last-wins file overwrite: a
+// contender that finds the seat occupied connects to the holder and sends
+// {"op":"takeover",...}; the holder runs its teardown (onTakeover -> the
+// worker's stopOwnedRuntime) then closes the server, letting the contender's
+// retried listen() succeed within a bounded backoff window.
+function hashRoot(runtimeRoot) {
+  return createHash("sha1").update(String(runtimeRoot)).digest("hex").slice(0, 16);
+}
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+export function createSeatLock({ runtimeRoot, instanceId }) {
+  const isWin = process.platform === "win32";
+  const address = isWin
+    ? `\\\\.\\pipe\\mixdog-seat-${hashRoot(runtimeRoot)}`
+    : join(runtimeRoot, "seat.sock");
+  let server = null;
+  let held = false;
+  let takeoverHandler = null;
+  let releasing = null;
+
+  function isSeatHeld() {
+    // Daemon model: the machine-global channels daemon is the permanent
+    // singleton bridge owner (pid-verified channel-daemon-owner lock). Ownership
+    // is unconditional — the OS seat lease/heartbeat/steal is retired.
+    return true;
+  }
+  function seatAddress() {
+    return address;
+  }
+  // Register the teardown to run when a takeover message arrives (or on an
+  // explicit releaseSeat). Runs BEFORE the server closes so the contender only
+  // wins the seat once we've released the backend.
+  function onTakeover(cb) {
+    takeoverHandler = cb;
+  }
+  function closeServer() {
+    // Capture holder status BEFORE nulling: only the process that actually held
+    // the listener may unlink the posix socket file. A non-holder close must
+    // never unlink — otherwise it races away a NEW holder's freshly-bound
+    // socket, re-opening the seat as falsely vacant (double-owner).
+    const wasListener = server !== null;
+    return new Promise((resolve) => {
+      const s = server;
+      server = null;
+      held = false;
+      if (!s) return resolve();
+      try {
+        s.close(() => resolve());
+      } catch {
+        resolve();
+      }
+    }).then(() => {
+      // posix: remove OUR socket file so the next listen() is clean — but only
+      // when we were the confirmed listener (see wasListener above).
+      if (!isWin && wasListener) {
+        try { if (existsSync(address)) unlinkSync(address); } catch {}
+      }
+    });
+  }
+  async function runTeardownThenClose(reason) {
+    // Coalesce concurrent release paths (takeover message + explicit stop).
+    if (releasing) return releasing;
+    releasing = (async () => {
+      try { await takeoverHandler?.(reason); } catch {}
+      await closeServer();
+    })();
+    try { await releasing; } finally { releasing = null; }
+  }
+  function handleLine(line, sock) {
+    let msg = null;
+    try { msg = JSON.parse(line); } catch { return; }
+    if (msg?.op === "takeover") {
+      // Ack first so the contender knows we received the takeover and is not
+      // left waiting the full timeout, then release.
+      try { sock.write(JSON.stringify({ op: "ack", instanceId }) + "\n"); } catch {}
+      void runTeardownThenClose({ reason: "takeover", byInstanceId: msg.instanceId });
+    }
+  }
+  function attachServer(s) {
+    s.on("connection", (sock) => {
+      let buf = "";
+      sock.on("data", (chunk) => {
+        buf += chunk.toString("utf8");
+        let idx;
+        while ((idx = buf.indexOf("\n")) >= 0) {
+          const line = buf.slice(0, idx);
+          buf = buf.slice(idx + 1);
+          if (line) handleLine(line, sock);
+        }
+      });
+      sock.on("error", () => {});
+    });
+    // A server-level error after listen (e.g. pipe invalidated) must not crash
+    // the worker; drop the dead handle so the next acquire re-listens.
+    s.on("error", () => {});
+  }
+  function tryListen() {
+    return new Promise((resolve, reject) => {
+      const s = net.createServer();
+      const onError = (err) => { s.removeListener("listening", onListening); reject(err); };
+      const onListening = () => {
+        s.removeListener("error", onError);
+        server = s;
+        held = true;
+        attachServer(s);
+        s.unref?.();
+        resolve(true);
+      };
+      s.once("error", onError);
+      s.once("listening", onListening);
+      s.listen(address);
+    });
+  }
+  // Connect to the current holder. When takeover=true, send the takeover
+  // message. Resolves:
+  //   'alive' — a live holder answered (or we connected)         -> back off
+  //   'stale' — connect refused/ENOENT (posix crashed holder)    -> unlink+retry
+  function connectHolder({ takeover }) {
+    return new Promise((resolve) => {
+      const sock = net.createConnection(address);
+      let settled = false;
+      const done = (r) => {
+        if (settled) return;
+        settled = true;
+        try { sock.destroy(); } catch {}
+        resolve(r);
+      };
+      sock.on("connect", () => {
+        if (takeover) {
+          try { sock.write(JSON.stringify({ op: "takeover", instanceId }) + "\n"); } catch { done("alive"); }
+        } else {
+          done("alive");
+        }
+      });
+      sock.on("data", () => done("alive")); // ack
+      sock.on("error", (err) => {
+        const code = err?.code;
+        done(code === "ECONNREFUSED" || code === "ENOENT" ? "stale" : "alive");
+      });
+      sock.on("close", () => done("alive"));
+      const t = setTimeout(() => done("alive"), 1500);
+      t.unref?.();
+    });
+  }
+  // Acquire the seat. force=true (default) takes over a live holder via the
+  // takeover message; force=false (claim-if-vacant) backs off when a live
+  // holder is present but still reclaims a stale (crashed) posix socket.
+  // Returns true on success, false on timeout / vacant-only backoff.
+  // Deletion of the seat lease/steal protocol. Under the daemon model there is
+  // exactly one channels runtime per machine (enforced upstream by the
+  // singleton daemon-owner lock), so acquiring the bridge seat is unconditional
+  // and never contends — no listen()/EADDRINUSE probe, no explicit takeover
+  // message, no claim-if-vacant backoff, no false-stale steal. The former
+  // named-pipe / unix-socket server machinery (tryListen/connectHolder/
+  // handleLine/attachServer) is now unreachable and kept only until the file is
+  // pruned in a follow-up cleanup.
+  async function acquireSeat(_opts = {}) {
+    held = true;
+    return true;
+  }
+  // Graceful release: run teardown (if any) then close the server. Idempotent.
+  async function releaseSeat(reason = { reason: "release" }) {
+    if (!server && !held) {
+      // Not the holder: nothing to close and — critically — do NOT unlink; the
+      // socket file may belong to a NEW holder that bound after we released.
+      return;
+    }
+    await runTeardownThenClose(reason);
+  }
+  // Close the server WITHOUT running the teardown callback. Used by the worker's
+  // stopOwnedRuntime itself so the teardown (which calls this) does not recurse.
+  async function closeSeatServer() {
+    await closeServer();
+  }
+  return {
+    acquireSeat,
+    releaseSeat,
+    closeSeatServer,
+    onTakeover,
+    isSeatHeld,
+    seatAddress,
+  };
+}

package/src/runtime/channels/lib/session-discovery.mjs

@@ -44,10 +44,11 @@ function getParentPid(pid) {
       // which fires per transcript watchDebounce tick, so without these flags users
       // see a powershell.exe console window pop in/out repeatedly during
       // any chat activity — including while the config UI is loading.
+      // NO `-WindowStyle Hidden` CLI switch: windowsHide already covers it,
+      // and the token triggers Defender's PowhidSubExec false positive.
       const out2 = execFileSync("powershell.exe", [
         "-NoProfile",
         "-NonInteractive",
-        "-WindowStyle", "Hidden",
         "-Command",
         `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").ParentProcessId`
       ], {

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

@@ -23,10 +23,10 @@ function createToolDispatch({
     setChannelBridgeActive,
     writeBridgeState,
     stopServerTyping,
-    claimBridgeOwnership,
     notifyRemoteAcquired,
     refreshBridgeOwnership,
     bindPersistedTranscriptIfAny,
+    rebindCurrentTranscript,
     stopOwnedRuntime,
     reloadRuntimeConfig,
   } = lifecycle;
@@ -59,14 +59,15 @@ function createToolDispatch({
               // double reconnect). refreshBridgeOwnership below still re-pins
               // the forwarder binding onto THIS session either way.
               if (getOwned?.() !== true) {
-                claimBridgeOwnership(wasActive ? "re-activate takeover" : "bridge activated");
-                // Genuine acquire transition (we were NOT the owner) — tell the
-                // parent to flip remote ON. Not fired when we already own the
-                // seat, so an idempotent re-activate never re-notifies.
+                // Genuine acquire transition (we do NOT hold the seat) — tell the
+                // parent to flip remote ON. The seat itself is acquired inside
+                // refreshBridgeOwnership({ claim: true }) below (explicit
+                // takeover). An idempotent re-activate (already own the seat)
+                // skips both the notify and the takeover.
                 notifyRemoteAcquired?.();
               }
               try {
-                await refreshBridgeOwnership({ restoreBinding: true });
+                await refreshBridgeOwnership({ restoreBinding: true, claim: true });
                 // An already-connected owner returns early from
                 // startOwnedRuntime(), so rebind explicitly to follow the
                 // current (parent-chain) session transcript.
@@ -104,6 +105,16 @@ function createToolDispatch({
             result = { content: [{ type: "text", text: `config reloaded — schedules, webhooks, events${agentReloadMsg} re-registered` }] };
             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)"}` }] };
+            break;
+        }
         // memory — handled by memory-service.mjs MCP
         default:
             result = {
@@ -132,7 +143,10 @@ function createToolDispatch({
     // 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) {
+    // 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();
     }
@@ -140,7 +154,9 @@ function createToolDispatch({
       // Remote-owner startup: ensure this owner's backend is connected.
       for (let i = 0; i < 2 && !getBridgeRuntimeConnected(); i++) {
         try {
-          await refreshBridgeOwnership();
+          // Auto-connect a remote owner. claimIfVacant: acquire the seat only
+          // when vacant/stale — never steal a live holder from this retry path.
+          await refreshBridgeOwnership({ claim: true, claimIfVacant: true });
         } catch {
         }
         if (!getBridgeRuntimeConnected()) await new Promise((r) => setTimeout(r, 300));