mixdog 0.9.22 → 0.9.23

package/src/standalone/channel-daemon.mjs

@@ -0,0 +1,139 @@
+// Machine-global channels daemon entry.
+//
+// One process per machine hosts the channels runtime (worker-main) and exposes
+// it to many TUIs over a local HTTP + SSE transport (see
+// channel-daemon-transport.mjs) instead of the old per-TUI fork + node-IPC.
+// Spawned (or attached-to) by createStandaloneChannelWorker; ownership is a
+// pid-verified singleton lock (singleton-owner.mjs) — NOT the try-once
+// active-instance lock that starved under 6 contending workers. A stale daemon
+// (dead owner pid) is reclaimed by the next claim; a live peer that wins the
+// race makes this process exit(0) so the spawner attaches to the winner.
+//
+// Boot order matters: MIXDOG_CHANNEL_DAEMON must be set BEFORE importing the
+// channels runtime so worker-main skips its parent-IPC loop (runWorkerIpc) and
+// lets this entry own start()/stop() + the transport.
+process.env.MIXDOG_CHANNEL_DAEMON = '1';
+process.env.MIXDOG_WORKER_MODE = process.env.MIXDOG_WORKER_MODE || '1';
+
+import os from 'node:os';
+import path from 'node:path';
+import { mkdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { performance } from 'node:perf_hooks';
+import { claimSingletonOwner, releaseSingletonOwner } from '../runtime/shared/singleton-owner.mjs';
+import { setChannelNotifySink } from '../runtime/channels/lib/parent-bridge.mjs';
+import { setOwnerContext } from '../runtime/channels/lib/runtime-paths.mjs';
+import { createChannelDaemonTransport } from './channel-daemon-transport.mjs';
+import { createStandaloneMemoryRuntime } from './memory-runtime-proxy.mjs';
+
+function runtimeRoot() {
+  return process.env.MIXDOG_RUNTIME_ROOT
+    ? path.resolve(process.env.MIXDOG_RUNTIME_ROOT)
+    : path.join(os.tmpdir(), 'mixdog');
+}
+
+const RUNTIME_ROOT = runtimeRoot();
+const DATA_DIR = process.env.MIXDOG_DATA_DIR ? path.resolve(process.env.MIXDOG_DATA_DIR) : RUNTIME_ROOT;
+const CWD = process.cwd();
+const DISCOVERY_PATH = path.join(RUNTIME_ROOT, 'channel-daemon.json');
+// Owner-election lock, separate from the channels seat/bridge state. Reused
+// pid-verified claim primitive with real claim-lock retry inside.
+const OWNER_PATH = path.join(DATA_DIR, 'channel-daemon-owner.json');
+// Memory runtime is folded into the daemon: the ONE machine-global process is
+// responsible for starting BOTH the channels runtime and the memory runtime.
+// The memory proxy is spawn-or-attach + singleton (memory-runtime-owner lock)
+// and advertises memory_port to active-instance.json exactly as before, so
+// external readers / memory-client.mjs discovery is UNCHANGED.
+const MEMORY_ENTRY = fileURLToPath(new URL('../runtime/memory/index.mjs', import.meta.url));
+
+function log(line) {
+  try { process.stderr.write(`[channel-daemon] ${line}\n`); } catch {}
+}
+
+let channels = null;
+let transport = null;
+let memoryRuntime = null;
+let shuttingDown = false;
+
+async function shutdown(reason, code = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  log(`shutting down (${reason})`);
+  try { setChannelNotifySink(null); } catch {}
+  try { await channels?.stop?.(); } catch (e) { log(`channels.stop failed: ${e?.message || e}`); }
+  // Detach the memory client (never hard-kills the shared memory daemon).
+  try { await memoryRuntime?.stop?.(); } catch (e) { log(`memory.stop failed: ${e?.message || e}`); }
+  try { await transport?.stop?.(); } catch (e) { log(`transport.stop failed: ${e?.message || e}`); }
+  try { releaseSingletonOwner(OWNER_PATH, process.pid); } catch {}
+  process.exit(code);
+}
+
+async function main() {
+  const startedAt = performance.now();
+  try { mkdirSync(RUNTIME_ROOT, { recursive: true }); } catch {}
+
+  // Pid-verified singleton claim (claimSingletonOwner reclaims a dead-pid owner
+  // file and refuses only a LIVE peer). Loser exits so the spawner attaches to
+  // the winner instead of running a second daemon.
+  const claim = claimSingletonOwner(OWNER_PATH, { kind: 'channel-runtime-daemon', pid: process.pid, meta: { cwd: CWD } });
+  if (!claim.owned) {
+    log(`live peer holds owner lock (pid=${claim.owner?.pid}) — exiting for attach`);
+    process.exit(0);
+  }
+  process.on('exit', () => { try { releaseSingletonOwner(OWNER_PATH, process.pid); } catch {} });
+
+  // Import the channels runtime AFTER the daemon env is set so worker-main
+  // skips runWorkerIpc; this triggers its boot side effects (config/backend).
+  channels = await import('../runtime/channels/index.mjs');
+
+  // Pointer-move tools re-point active-instance owner/cwd at the binding TUI
+  // (mirrors the transport's routing pointer) so external readers see the
+  // pointer TUI, not the daemon's spawner.
+  const POINTER_TOOLS = new Set(['activate_channel_bridge', 'rebind_current_transcript']);
+  transport = createChannelDaemonTransport({
+    handleCall: (name, args, ctx) => {
+      if (ctx && POINTER_TOOLS.has(name)) {
+        try { setOwnerContext({ leadPid: ctx.leadPid, cwd: ctx.cwd }); } catch {}
+      }
+      return channels.handleToolCallWithBridgeRetry(name, args || {});
+    },
+    discoveryPath: DISCOVERY_PATH,
+    log,
+    // Self-shutdown when the last attached TUI leaves (reuses the SSE/client
+    // registry as the liveness signal — mirrors the memory daemon grace).
+    onClientsEmpty: () => { void shutdown('no live clients'); },
+  });
+  setChannelNotifySink((method, params) => transport.notify(method, params));
+  const { port, token } = await transport.start();
+
+  // Boot the owned channels runtime (Discord connect, transcript bind). Failure
+  // is non-fatal — the daemon still serves tool calls and can reconnect later.
+  try { await channels.start(); } catch (e) { log(`channels.start failed (non-fatal): ${e?.message || e}`); }
+
+  // Fold memory startup in: eagerly ensure the memory runtime is up under the
+  // daemon's lifecycle (spawn-or-attach singleton). Fire-and-forget — memory
+  // boot is heavy (DB/embeddings) and must NOT delay the ready handshake below
+  // (the spawner's ready wait would time out); the proxy publishes memory_port
+  // to active-instance.json when ready and memory-client buffers until then.
+  try {
+    memoryRuntime = createStandaloneMemoryRuntime({ entry: MEMORY_ENTRY, dataDir: DATA_DIR, cwd: CWD });
+    void memoryRuntime.start().catch((e) => log(`memory.start failed (non-fatal): ${e?.message || e}`));
+  } catch (e) { log(`memory.start setup failed (non-fatal): ${e?.message || e}`); }
+
+  // Ready handshake for the spawner (mirrors the memory daemon's ready port).
+  if (process.send) {
+    try { process.send({ type: 'ready', port, token }); } catch {}
+  }
+  log(`ready port=${port} pid=${process.pid} in ${(performance.now() - startedAt).toFixed(0)}ms`);
+}
+
+process.on('SIGTERM', () => { void shutdown('SIGTERM'); });
+process.on('SIGINT', () => { void shutdown('SIGINT'); });
+process.on('message', (msg) => {
+  if (msg && msg.type === 'shutdown') void shutdown('IPC shutdown');
+});
+
+main().catch((err) => {
+  log(`fatal boot error: ${err?.stack || err?.message || err}`);
+  void shutdown('fatal boot error', 2);
+});

package/src/standalone/channel-worker.mjs

@@ -7,6 +7,9 @@ import { startChildGuardian } from '../runtime/shared/child-guardian.mjs';
 import { appendBuffered } from '../runtime/shared/buffered-appender.mjs';
 import { scrubLoaderVars } from '../runtime/agent/orchestrator/tools/env-scrub.mjs';
 import { rotateBoundedLog, PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '../lib/mixdog-debug.cjs';
+import { attachToDaemon, readDaemonDiscovery, probeDaemonHealth } from './channel-daemon-client.mjs';
+import { claimSingletonOwner, releaseSingletonOwner } from '../runtime/shared/singleton-owner.mjs';
+import { randomUUID } from 'node:crypto';
 
 const CHANNEL_TOOLS = new Set([
   'reply',
@@ -17,9 +20,17 @@ const CHANNEL_TOOLS = new Set([
   // Lead-only runtime plumbing (bridge-claim on start, config hot-reload).
   'activate_channel_bridge',
   'reload_config',
+  // Lead-pushed transcript repoint (auto-acquire / newSession / resume /
+  // clear). Not model-facing; internal Lead-only runtime plumbing.
+  'rebind_current_transcript',
 ]);
 
 const WORKER_PRELOAD = fileURLToPath(new URL('./channel-worker-preload.cjs', import.meta.url));
+// Machine-global channels daemon entry (spawn-or-attach target). Overridable
+// via env so the flip smoke can point at a stub daemon (no Discord token).
+const DAEMON_ENTRY = process.env.MIXDOG_CHANNEL_DAEMON_ENTRY
+  ? resolve(process.env.MIXDOG_CHANNEL_DAEMON_ENTRY)
+  : fileURLToPath(new URL('./channel-daemon.mjs', import.meta.url));
 
 // A global package update can briefly remove channel-worker-preload.cjs while
 // the worker is spawning (MODULE_NOT_FOUND boot crash). Retry once before
@@ -83,7 +94,20 @@ export function createStandaloneChannelWorker({
   let bootGeneration = 0;
   let inProcessMod = null;
   let inProcessStartPromise = null;
+  // Set when in-process mode (MIXDOG_CHANNEL_WORKER_PROCESS=0) holds the daemon
+  // singleton lock, so stop() releases it (never double-own beside a daemon).
+  let inProcessOwned = false;
+  // Machine-global channels daemon attach handle. Replaces the per-TUI fork +
+  // node-IPC call/notify plumbing; the daemon is SHARED and never killed on
+  // this TUI's exit (only detached-from). The fork machinery below is retained
+  // as an unreachable legacy path while useProcessWorker is true.
+  let daemonClient = null;
+  let attachPromise = null;
+  let daemonPid = null;
   let nextCallId = 1;
+  // Per-proxy unique prefix so a callId can never collide across TUIs sharing
+  // the same supervisor pid (which would cross-dedup two distinct calls).
+  const proxyId = randomUUID();
   let parentExitCleanup = null;
   const pending = new Map();
   const ownedChildPids = new Set();
@@ -159,10 +183,10 @@ export function createStandaloneChannelWorker({
       };
     }
     return {
-      running: Boolean(child && child.exitCode == null && !child.killed),
-      pid: child?.pid || null,
-      pending: pending.size,
-      mode: 'runtime',
+      running: Boolean(daemonClient),
+      pid: daemonPid,
+      pending: 0,
+      mode: 'daemon',
     };
   }
 
@@ -224,6 +248,9 @@ export function createStandaloneChannelWorker({
 
   function start() {
     if (!useProcessWorker) return startInProcess();
+    // Daemon mode (default): spawn-or-attach to the machine-global channels
+    // daemon. The fork code below is unreachable while useProcessWorker is true.
+    return ensureDaemonAttached().then(() => status());
     if (stopPromise) {
       return stopPromise.then(() => start());
     }
@@ -335,6 +362,155 @@ export function createStandaloneChannelWorker({
   }
 
   async function startInProcess() {
+    if (inProcessMod || inProcessStartPromise) return _startInProcess();
+    // Singleton guard: in-process mode must not run a SECOND live bridge owner
+    // beside the machine-global daemon (double Discord gateway). Claim the same
+    // owner lock the daemon uses; if a LIVE daemon holds it, fail loudly rather
+    // than silently double-own (unset MIXDOG_CHANNEL_WORKER_PROCESS=0 to attach).
+    const claim = claimSingletonOwner(daemonOwnerPath, { kind: 'channel-runtime-daemon', pid: process.pid, meta: { cwd, mode: 'in-process' } });
+    if (!claim.owned) {
+      throw new Error(`in-process channels runtime refused: a live channels daemon (pid=${claim.owner?.pid}) already owns the bridge — refusing to double-own. Unset MIXDOG_CHANNEL_WORKER_PROCESS=0 to attach, or stop the daemon.`);
+    }
+    inProcessOwned = true;
+    try {
+      return await _startInProcess();
+    } catch (err) {
+      // Boot failed: release the just-claimed lock so a retry (or the daemon)
+      // can own it instead of leaking a live lock held by a non-running runtime.
+      if (inProcessOwned && !inProcessMod) {
+        try { releaseSingletonOwner(daemonOwnerPath, process.pid); } catch {}
+        inProcessOwned = false;
+      }
+      throw err;
+    }
+  }
+
+  // ── Machine-global daemon: spawn-or-attach ────────────────────────────────
+  // Second+ TUI attaches to the live daemon instead of forking. Discovery is a
+  // pid-verified file (channel-daemon.json, 127.0.0.1 only). A stale daemon
+  // (dead pid) or unhealthy one is respawned; a spawn race loser exits(0) so we
+  // re-read discovery and attach to the winner (pid-verified singleton lock).
+  const daemonLeadPid = Number(process.env.MIXDOG_SUPERVISOR_PID) || process.pid;
+  const discoveryPath = join(runtimeRoot(), 'channel-daemon.json');
+  function daemonDelay(ms) { return new Promise((r) => setTimeout(r, ms)); }
+  // Same singleton owner file the daemon claims (dataDir-relative), so the
+  // in-process fallback can refuse to run beside a live daemon.
+  const daemonOwnerPath = join(dataDir, 'channel-daemon-owner.json');
+  // Drop the cached attach so the next ensureDaemonAttached() re-reads discovery,
+  // health-probes, and respawns a dead daemon — the recovery hinge for a daemon
+  // restart mid-session (no TUI process restart needed).
+  function invalidateDaemonClient(reason = 'invalidate', expected = null) {
+    // CAS: only tear down when the live handle is still the one that failed, so
+    // a concurrent call that already re-attached a fresh daemon isn't clobbered.
+    if (expected && daemonClient !== expected) return;
+    const client = daemonClient;
+    daemonClient = null;
+    attachPromise = null;
+    daemonPid = null;
+    if (client) { try { client.close(reason); } catch {} }
+  }
+  function daemonEnv() {
+    const env = { ...process.env };
+    scrubLoaderVars(env);
+    return {
+      ...env,
+      MIXDOG_ROOT: rootDir,
+      MIXDOG_DATA_DIR: dataDir,
+      MIXDOG_STANDALONE: '1',
+      MIXDOG_WORKER_MODE: '1',
+      MIXDOG_CHANNEL_DAEMON: '1',
+      MIXDOG_CLI_OWNED: '0',
+      MIXDOG_SUPERVISOR_PID: process.env.MIXDOG_SUPERVISOR_PID || String(process.pid),
+      MIXDOG_QUIET_SESSION_LOG: process.env.MIXDOG_QUIET_SESSION_LOG ?? '1',
+    };
+  }
+  // Fork one daemon candidate DETACHED (it outlives this TUI — machine-global)
+  // and NEVER track it for parent-exit kill. Resolves when the candidate reports
+  // ready OR exits (race loss/crash); the caller then re-checks discovery.
+  function spawnDaemonCandidate() {
+    return new Promise((resolveSpawn) => {
+      let settled = false;
+      const done = () => { if (settled) return; settled = true; resolveSpawn(); };
+      let daemon;
+      try {
+        daemon = fork(DAEMON_ENTRY, [], {
+          cwd,
+          execArgv: ['--require', WORKER_PRELOAD],
+          stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+          detached: true,
+          env: daemonEnv(),
+          windowsHide: true,
+        });
+      } catch (err) {
+        logLine(logPath, `daemon spawn failed: ${err?.message || err}`);
+        done();
+        return;
+      }
+      daemon.stderr?.on('data', (chunk) => {
+        const text = String(chunk || '').trimEnd();
+        if (text) logLine(logPath, text);
+      });
+      daemon.once('message', (msg) => {
+        if (msg && msg.type === 'ready') {
+          // Fully detach: the daemon must not be tied to this TUI's IPC/lifecycle.
+          try { daemon.disconnect?.(); } catch {}
+          try { daemon.unref?.(); } catch {}
+          try { daemon.stderr?.unref?.(); } catch {}
+          done();
+        }
+      });
+      daemon.once('exit', done); // race loss (exit 0) or crash → re-check discovery
+      daemon.once('error', (err) => { logLine(logPath, `daemon spawn error: ${err?.message || err}`); done(); });
+      const t = setTimeout(done, 20_000);
+      t.unref?.();
+    });
+  }
+  async function doAttach(discovery) {
+    const client = await attachToDaemon({
+      discovery,
+      leadPid: daemonLeadPid,
+      cwd,
+      onNotify: (msg) => { try { onNotify?.(msg); } catch {} },
+      // SSE gave up (daemon dead/restarted): drop this attach and proactively
+      // re-attach so notifies resume without waiting for the next call().
+      onFatal: () => { invalidateDaemonClient('sse fatal', client); void ensureDaemonAttached().catch(() => {}); },
+      log: (line) => logLine(logPath, line),
+    });
+    daemonClient = client;
+    daemonPid = discovery.pid;
+    return client;
+  }
+  async function ensureDaemonAttached() {
+    if (daemonClient) return daemonClient;
+    if (attachPromise) return attachPromise;
+    attachPromise = (async () => {
+      const deadline = Date.now() + 30_000;
+      for (let attempt = 0; ; attempt++) {
+        let discovery = readDaemonDiscovery(discoveryPath);
+        if (discovery) {
+          const health = await probeDaemonHealth({ port: discovery.port, token: discovery.token, timeoutMs: attempt === 0 ? 800 : 2000 });
+          if (health) return await doAttach(discovery);
+          discovery = null; // published but unhealthy → respawn
+        }
+        // No live daemon (absent / dead pid / unhealthy): spawn a candidate. A
+        // race loser exits(0); the winner publishes discovery we then attach to.
+        await spawnDaemonCandidate();
+        const after = readDaemonDiscovery(discoveryPath);
+        if (after) {
+          const health = await probeDaemonHealth({ port: after.port, token: after.token, timeoutMs: 3000 });
+          if (health) return await doAttach(after);
+        }
+        if (Date.now() > deadline) throw new Error('channels daemon did not become ready');
+        await daemonDelay(200);
+      }
+    })();
+    try {
+      return await attachPromise;
+    } finally {
+      attachPromise = null;
+    }
+  }
+  async function _startInProcess() {
     if (inProcessMod) return status();
     if (inProcessStartPromise) return inProcessStartPromise;
     inProcessStartPromise = (async () => {
@@ -370,6 +546,25 @@ export function createStandaloneChannelWorker({
         if (timer) clearTimeout(timer);
       }
     }
+    // Daemon path: dispatch over HTTP with bounded re-attach so a daemon
+    // death/restart is transparent — a transport failure drops the stale attach
+    // and ensureDaemonAttached re-reads discovery + respawns-if-dead.
+    let lastDaemonErr = null;
+    // One stable callId for this logical call, reused across retries so the
+    // daemon dedups a retried transport failure to a single side-effect.
+    const logicalCallId = `ch_${proxyId}_${nextCallId++}`;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      const daemon = await ensureDaemonAttached();
+      try {
+        return await daemon.call(name, args || {}, { timeoutMs, callId: logicalCallId });
+      } catch (err) {
+        if (!err?.daemonTransportError) throw err; // tool error → surface as-is
+        lastDaemonErr = err;
+        invalidateDaemonClient('transport failure', daemon);
+        await daemonDelay(200 * (attempt + 1));
+      }
+    }
+    throw lastDaemonErr || new Error('channels daemon call failed');
     if (!child || !child.send) throw new Error('channels worker is not running');
     const callId = `ch_${nextCallId++}`;
     return await new Promise((resolve, reject) => {
@@ -449,6 +644,9 @@ export function createStandaloneChannelWorker({
     if (stopPromise) return stopPromise;
     if (!useProcessWorker) {
       if (!inProcessMod && !inProcessStartPromise) {
+        // Nothing running, but a lock may still be held if a prior boot claimed
+        // then failed without clearing — release it so stop() never leaks it.
+        if (inProcessOwned) { try { releaseSingletonOwner(daemonOwnerPath, process.pid); } catch {} inProcessOwned = false; }
         return Promise.resolve(false);
       }
       stopPromise = Promise.resolve(inProcessStartPromise)
@@ -456,6 +654,7 @@ export function createStandaloneChannelWorker({
         .then(async () => {
           try { await inProcessMod?.stop?.(reason); } catch {}
           inProcessMod = null;
+          if (inProcessOwned) { try { releaseSingletonOwner(daemonOwnerPath, process.pid); } catch {} inProcessOwned = false; }
           return true;
         })
         .finally(() => {
@@ -463,6 +662,16 @@ export function createStandaloneChannelWorker({
         });
       return stopPromise;
     }
+    // Daemon path: detach this TUI's client only. The shared daemon reaps
+    // itself via client-grace once the last TUI leaves; never kill it here.
+    if (useProcessWorker) {
+      const client = daemonClient;
+      daemonClient = null;
+      attachPromise = null;
+      daemonPid = null;
+      if (!client) return Promise.resolve(false);
+      return client.close(reason).then(() => true).catch(() => true);
+    }
     if (!child) {
       return Promise.resolve(false);
     }

package/src/standalone/hook-bus.mjs

@@ -352,11 +352,79 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
     return saveRules(rules);
   }
 
+  // --- debounced hooks.json persist ------------------------------------------
+  // Rule state is flipped in the in-memory rulesCache synchronously so the
+  // picker reopen renders from memory (no disk re-read); the heavy file RMW
+  // (saveRules) is deferred so a burst of toggle key presses collapses into one
+  // write. Mirrors config-lifecycle's scheduleSkillsSave pattern.
+  const RULES_SAVE_DEBOUNCE_MS = 400;
+  // Pending flips are tracked as index→enabled patches (not a full snapshot) so
+  // that if hooks.json is edited externally during the debounce window the flush
+  // can reload the current disk rules and reapply only our enabled-flag changes
+  // instead of clobbering the external edit.
+  let pendingRulePatches = null;
+  let rulesBaseMtime = null;
+  let rulesSaveTimer = null;
+
+  function flushRules() {
+    if (rulesSaveTimer) {
+      clearTimeout(rulesSaveTimer);
+      rulesSaveTimer = null;
+    }
+    if (!pendingRulePatches || pendingRulePatches.size === 0) {
+      pendingRulePatches = null;
+      rulesBaseMtime = null;
+      return;
+    }
+    const patches = pendingRulePatches;
+    const base = rulesBaseMtime;
+    pendingRulePatches = null;
+    rulesBaseMtime = null;
+    try {
+      let rules;
+      const diskChanged = rulesPath && existsSync(rulesPath) && statSync(rulesPath).mtimeMs !== base;
+      if (diskChanged) {
+        // External edit during the debounce window: reload from disk and reapply
+        // only our flips so the external change survives.
+        const parsed = JSON.parse(readFileSync(rulesPath, 'utf8'));
+        rules = normalizeRules(parsed).filter((rule) => rule && typeof rule === 'object');
+      } else {
+        rules = [...(rulesCache.rules || [])];
+      }
+      for (const [index, enabled] of patches) {
+        if (index >= 0 && index < rules.length) rules[index] = { ...rules[index], enabled };
+      }
+      saveRules(rules);
+    } catch (error) {
+      emit('hook:error', { error: `debounced hooks save failed: ${error?.message || error}` });
+    }
+  }
+
+  function scheduleRulesSave() {
+    if (rulesSaveTimer) clearTimeout(rulesSaveTimer);
+    rulesSaveTimer = setTimeout(flushRules, RULES_SAVE_DEBOUNCE_MS);
+    rulesSaveTimer.unref?.();
+  }
+
   function setRuleEnabled(index, enabled) {
     const rules = [...loadRules()];
     if (!Number.isInteger(index) || index < 0 || index >= rules.length) throw new Error(`hook rule not found: ${index}`);
-    rules[index] = { ...rules[index], enabled: enabled !== false };
-    return saveRules(rules);
+    const nextEnabled = enabled !== false;
+    rules[index] = { ...rules[index], enabled: nextEnabled };
+    // Adopt in memory immediately: keep the last-known disk mtime so loadRules
+    // returns this flipped cache (disk is untouched until the debounce flushes),
+    // and drop the config cache so a re-read reflects the change.
+    rulesCache = { ...rulesCache, rules };
+    configCache.key = '';
+    if (!pendingRulePatches) {
+      pendingRulePatches = new Map();
+      // mtime the in-memory cache was loaded from; flush compares against it to
+      // detect an external edit made during the debounce window.
+      rulesBaseMtime = rulesCache.mtimeMs;
+    }
+    pendingRulePatches.set(index, nextEnabled);
+    scheduleRulesSave();
+    return listRules();
   }
 
   function deleteRule(index) {
@@ -496,5 +564,5 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
     return rewakeHandler;
   }
 
-  return { addRule, beforeTool, deleteRule, dispatch, emit, listRules, setRewakeHandler, setRuleEnabled, status };
+  return { addRule, beforeTool, deleteRule, dispatch, emit, flushRules, listRules, setRewakeHandler, setRuleEnabled, status };
 }