mixdog 0.9.147 → 0.9.149

package/src/standalone/channel-transport.mjs

@@ -17,6 +17,7 @@ import { randomUUID } from 'node:crypto';
 import { readFileSync, rmSync } from 'node:fs';
 import { basename } from 'node:path';
 import { writeJsonAtomicSync } from '../runtime/shared/atomic-file.mjs';
+import { isPidAlive, parsePid } from '../runtime/shared/pid-liveness.mjs';
 import { readBody, sendJson, sendError } from '../runtime/memory/lib/http-wire.mjs';
 import { createFairCallScheduler } from './fair-call-scheduler.mjs';
 
@@ -26,17 +27,6 @@ function readChannelBody(req) {
   return readBody(req, { maxBytes: CHANNEL_HTTP_BODY_MAX_BYTES });
 }
 
-function parsePid(value) {
-  const n = Number(value);
-  return Number.isInteger(n) && n > 0 ? n : null;
-}
-
-function isPidAlive(pid) {
-  const n = parsePid(pid);
-  if (!n) return false;
-  try { process.kill(n, 0); return true; }
-  catch (error) { return error?.code === 'EPERM'; }
-}
 
 const ACTIVATE_TOOL = 'activate_channel_bridge';
 const REBIND_TOOL = 'rebind_current_transcript';
@@ -103,6 +93,16 @@ export function createChannelTransport({
     queueMax: Math.max(16, Math.min(64, CALL_QUEUE_MAX)),
     minOwnerQueue: 4,
   });
+  // Binding calls (manual ON/OFF, rebind) mutate GLOBAL pointer/pin state after
+  // reading it. The control lane is unbounded, so two sessions toggling at once
+  // would interleave read and write and clobber each other's binding. Every
+  // binding call therefore runs alone on this chain.
+  let bindingChain = Promise.resolve();
+  function runExclusiveBinding(run) {
+    const result = bindingChain.then(run, run);
+    bindingChain = result.then(() => {}, () => {});
+    return result;
+  }
   // Reconnect register replay: a server may commit replacement just before its
   // HTTP response is lost. The retry supplies this stable id and receives the
   // already-created fresh token instead of creating an orphan replacement.
@@ -813,6 +813,17 @@ export function createChannelTransport({
             const previousRemoteSessionId = c.remoteSessionId || null;
             const previousRemoteAcquired = remoteAcquired;
             const previousStickyRemoteFrame = stickyRemoteFrame;
+            // A failed manual ON must leave ownership exactly as it was.
+            const rollbackActivation = () => {
+              if (!activating || pointerToken !== clientToken
+                  || c.remoteSessionId !== bindingSessionId) return;
+              pointerToken = previousPointerToken && clients.has(previousPointerToken)
+                ? previousPointerToken
+                : null;
+              c.remoteSessionId = previousRemoteSessionId;
+              remoteAcquired = previousRemoteAcquired;
+              stickyRemoteFrame = previousStickyRemoteFrame;
+            };
             if (activating) {
               c.remoteSessionId = bindingSessionId;
               movePointer(clientToken, 'manual remote ON', { notifyDisplaced: false });
@@ -823,6 +834,16 @@ export function createChannelTransport({
                 leadPid: c?.leadPid ?? null,
                 cwd: c?.cwd ?? null,
               });
+              // A soft `{isError:true}` envelope is a FAILED call, not a
+              // result: taking the success path here moved control ownership
+              // on a failed ON and cleared the durable pin on a failed OFF
+              // while the runtime was still bound.
+              if (result?.isError === true) {
+                rollbackActivation();
+                log(`${name} failed (soft error); binding state unchanged for session=${bindingSessionId || '?'}`);
+                publishRemoteState();
+                return result;
+              }
               if (activating && previousPointerToken && previousPointerToken !== clientToken) {
                 const displaced = clients.get(previousPointerToken);
                 if (displaced && isPidAlive(displaced.leadPid)
@@ -837,7 +858,7 @@ export function createChannelTransport({
                 remoteAcquired = false;
                 stickyRemoteFrame = null;
               }
-              if (activating && result?.isError !== true
+              if (activating
                   && pointerToken === clientToken
                   && c.remoteSessionId === bindingSessionId) {
                 remoteAcquired = true;
@@ -846,21 +867,14 @@ export function createChannelTransport({
               publishRemoteState();
               return result;
             } catch (err) {
-              if (activating && pointerToken === clientToken
-                  && c.remoteSessionId === bindingSessionId) {
-                pointerToken = previousPointerToken && clients.has(previousPointerToken)
-                  ? previousPointerToken
-                  : null;
-                c.remoteSessionId = previousRemoteSessionId;
-                remoteAcquired = previousRemoteAcquired;
-                stickyRemoteFrame = previousStickyRemoteFrame;
-                publishRemoteState();
-              }
+              rollbackActivation();
+              publishRemoteState();
               throw err;
             }
           };
-          const scheduler = BINDING_TOOLS.has(name) ? channelControlCalls : channelCalls;
-          dispatch = scheduler.enqueue(ownerKey, run);
+          const bindingCall = BINDING_TOOLS.has(name);
+          const scheduler = bindingCall ? channelControlCalls : channelCalls;
+          dispatch = scheduler.enqueue(ownerKey, bindingCall ? () => runExclusiveBinding(run) : run);
           if (cacheKey) {
             const record = { promise: dispatch, at: nowMs() };
             callCache.set(cacheKey, record);
@@ -880,7 +894,12 @@ export function createChannelTransport({
           const result = await dispatch;
           sendJson(res, { result });
         } catch (err) {
-          sendJson(res, { error: err?.message || String(err) }, 200);
+          // Keep the machine-readable code beside the message: callers branch
+          // on it instead of pattern-matching free text.
+          sendJson(res, {
+            error: err?.message || String(err),
+            ...(err?.code ? { code: String(err.code) } : {}),
+          }, 200);
         }
         return;
       }

package/src/standalone/daemon.mjs

@@ -40,6 +40,7 @@ import { writeJsonAtomicSync } from '../runtime/shared/atomic-file.mjs';
 import { ensurePrivateRuntimeRoot, resolveRuntimeRoot } from '../runtime/shared/runtime-root.mjs';
 import { ensureProcessListenerHeadroom } from '../runtime/shared/process-listener-headroom.mjs';
 import { claimSingletonOwner, releaseSingletonOwner } from '../runtime/shared/singleton-owner.mjs';
+import { remoteIntentPath } from '../runtime/shared/remote-intent.mjs';
 import { PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '../lib/mixdog-debug.cjs';
 import { setChannelNotifySink } from '../runtime/channels/lib/parent-bridge.mjs';
 import { setOwnerContext } from '../runtime/channels/lib/runtime-paths.mjs';
@@ -484,6 +485,19 @@ async function main() {
     handleCall,
     agentBroker: agentDispatchBroker,
     log,
+    // The durable channel link lives in this file. Without it a restart loses
+    // the pinned session (nothing to restore) and every catalog reports Remote
+    // disabled because no state ever reaches getRemoteSessionState().
+    remoteIntentPath: remoteIntentPath(RUNTIME_ROOT),
+    onRemoteStateChange: (state) => {
+      remoteSessionState = {
+        enabled: state?.enabled === true,
+        sessionId: state?.sessionId ?? null,
+        cwd: state?.cwd ?? null,
+        daemonPid: state?.daemonPid ?? process.pid,
+        updatedAt: state?.updatedAt ?? Date.now(),
+      };
+    },
     // Self-shutdown when the last attached TUI leaves (reuses the SSE/client
     // registry as the liveness signal).
     onClientsEmpty: () => { maybeSelfShutdown('no live channel clients'); },
@@ -566,7 +580,11 @@ async function main() {
   };
   let sessionRuntimePrewarmStarted = false;
   let sessionRuntimePrewarmPromise = null;
-  sessionRuntimeHost = createSessionRuntimeHost({ cwd: CWD, log });
+  sessionRuntimeHost = createSessionRuntimeHost({
+    cwd: CWD,
+    log,
+    canRecycle: () => (sessionService?.busyCount ?? 1) === 0,
+  });
   function prewarmSessionRuntime() {
     if (sessionRuntimePrewarmPromise) return sessionRuntimePrewarmPromise;
     sessionRuntimePrewarmStarted = true;
@@ -575,7 +593,7 @@ async function main() {
       .catch((error) => log(`image pipeline prewarm failed (non-fatal): ${error?.message || error}`));
     sessionRuntimePrewarmPromise = sessionRuntimeHost.prewarm()
       .then(() => {
-        log('session runtime worker/agent-loop/keychain/provider prewarm ready');
+        log('session runtime worker/agent-loop/keychain/memory prewarm ready');
         return true;
       })
       .catch((error) => {
@@ -712,6 +730,17 @@ async function main() {
   // client — see the transport's onClientRegistered hook.
   if (process.env.MIXDOG_DAEMON_SPAWNED_FOR !== 'session') startChannels();
 
+  // A pinned channel session outlives the daemon that pinned it. Reactivate the
+  // durable intent AFTER the ready handshake (activation itself brings the
+  // messaging bridge up); with no intent on disk this is a no-op and the
+  // channels graph stays dormant.
+  if (transport.remoteIntentSessionId) {
+    void transport.restoreRemoteIntent()
+      .then((restored) => {
+        if (!restored) log('remote intent restore declined (session unavailable)');
+      })
+      .catch((error) => log(`remote intent restore failed: ${error?.message || error}`));
+  }
 }
 
 process.on('SIGTERM', () => { void shutdown('SIGTERM'); });

package/src/standalone/hook-bus/config.mjs

@@ -116,16 +116,32 @@ export function hookConfigEntries(dataDir, cwd) {
   ]);
 }
 
-export function isStandardConfig(parsed) {
-  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return false;
+/** Classify a hooks file and name the malformed events inside it.
+ *
+ *  One bad value under `hooks` used to demote the WHOLE file to legacy, which
+ *  silently disabled every standard policy handler in it. A file with at least
+ *  one well-formed event stays standard; the malformed keys are reported so the
+ *  caller can surface them instead of dropping them in silence. */
+export function standardConfigReport(parsed) {
+  const empty = { standard: false, validEvents: [], invalidEvents: [] };
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return empty;
   const hooks = parsed.hooks;
-  if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks)) return false;
-  const values = Object.values(hooks);
-  if (values.length === 0) return false;
-  return values.every((groups) => (
-    Array.isArray(groups)
-    && groups.every((g) => g && typeof g === 'object' && Array.isArray(g.hooks))
-  ));
+  if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks)) return empty;
+  const entries = Object.entries(hooks);
+  if (entries.length === 0) return empty;
+  const validEvents = [];
+  const invalidEvents = [];
+  for (const [eventName, groups] of entries) {
+    const wellFormed = Array.isArray(groups)
+      && groups.every((g) => g && typeof g === 'object' && Array.isArray(g.hooks));
+    if (wellFormed) validEvents.push(eventName);
+    else invalidEvents.push(eventName);
+  }
+  return { standard: validEvents.length > 0, validEvents, invalidEvents };
+}
+
+export function isStandardConfig(parsed) {
+  return standardConfigReport(parsed).standard;
 }
 
 const SIMPLE_MATCHER_RE = /^[A-Za-z0-9_ ,|]*$/;

package/src/standalone/hook-bus/handlers.mjs

@@ -158,7 +158,7 @@ function hookEnv(projectDir, pluginData, payload, pluginRoot = null) {
   return env;
 }
 
-export function runCommandHandler(handler, payload, eventName, pluginData, onSpawnError = null, onRewake = null) {
+export function runCommandHandler(handler, payload, eventName, pluginData, onSpawnError = null) {
   const projectDir = payload.cwd || process.cwd();
   const effectivePluginData = handler._pluginData || pluginData || null;
   const stdin = JSON.stringify(payload);
@@ -171,55 +171,6 @@ export function runCommandHandler(handler, payload, eventName, pluginData, onSpa
     stdio: ['pipe', 'pipe', 'pipe'],
   };
 
-  if (handler.asyncRewake === true) {
-    try {
-      const child = spawn(spec.command, spec.args, withProcessGroup(baseOpts));
-      let bgStdout = '';
-      let bgStderr = '';
-      let bgStdoutBytes = 0;
-      let bgStderrBytes = 0;
-      let killed = false;
-      child.stdout?.on('data', (chunk) => {
-        bgStdoutBytes += chunk.length;
-        if (bgStdoutBytes <= MAX_BUFFER_BYTES) bgStdout += chunk.toString('utf8');
-      });
-      child.stderr?.on('data', (chunk) => {
-        bgStderrBytes += chunk.length;
-        if (bgStderrBytes <= MAX_BUFFER_BYTES) bgStderr += chunk.toString('utf8');
-      });
-      const killTimer = setTimeout(() => {
-        killed = true;
-        try { child.stdout?.removeAllListeners('data'); } catch {}
-        try { child.stderr?.removeAllListeners('data'); } catch {}
-        terminateTree(child);
-      }, timeoutMs);
-      killTimer.unref?.();
-      child.on('error', (error) => {
-        clearTimeout(killTimer);
-        if (typeof onSpawnError === 'function') onSpawnError(error);
-      });
-      child.on('close', (code) => {
-        clearTimeout(killTimer);
-        try {
-          if (!killed && code === 2 && typeof onRewake === 'function') {
-            const text = (bgStderr || '').trim() || (bgStdout || '').trim();
-            onRewake({ eventName, payload, text });
-          }
-        } catch {}
-      });
-      child.stdin?.end(stdin);
-      return Promise.resolve({ exitCode: 0, stdout: '', stderr: '', async: true });
-    } catch (error) {
-      return Promise.resolve({
-        exitCode: -1,
-        stdout: '',
-        stderr: error?.message || String(error),
-        timedOut: false,
-        spawnError: error,
-      });
-    }
-  }
-
   if (handler.async === true) {
     try {
       const child = spawn(spec.command, spec.args, withProcessGroup({
@@ -448,12 +399,25 @@ export async function runMcpToolHandler(handler, payload, eventName, mcpToolRunn
     return { exitCode: -1, stdout: '', stderr: 'mcp_tool handler missing tool name', timedOut: false, spawnError: null };
   }
   let timer = null;
+  // Losing the race is not cancellation: without this signal the tool call kept
+  // running (and holding its MCP slot) long after the hook gave up on it.
+  const controller = new AbortController();
   try {
-    const runPromise = Promise.resolve(mcpToolRunner({ name, args: payload }));
+    const runPromise = Promise.resolve(mcpToolRunner({
+      name,
+      args: payload,
+      signal: controller.signal,
+      timeoutMs,
+    }));
+    // The abandoned call still settles somewhere; keep its rejection handled.
+    runPromise.catch(() => {});
     const text = await Promise.race([
       runPromise,
       new Promise((_r, reject) => {
-        timer = setTimeout(() => reject(new Error(`mcp_tool hook timed out: ${name}`)), timeoutMs);
+        timer = setTimeout(() => {
+          try { controller.abort(new Error(`mcp_tool hook timed out: ${name}`)); } catch {}
+          reject(new Error(`mcp_tool hook timed out: ${name}`));
+        }, timeoutMs);
         // No unref: this timer must keep the event loop alive so the race can
         // settle even when the runner promise never resolves. Cleared in finally.
       }),

package/src/standalone/hook-bus.mjs

@@ -6,28 +6,25 @@ import {
   SUPPORTED_HANDLER_TYPES,
   EXIT2_BLOCK_EVENTS,
   TOP_LEVEL_DECISION_EVENTS,
-  limitText,
 } from './hook-bus/constants.mjs';
 import {
   buildEventPayload,
   hookConfigEntries,
   hookRulesPath,
-  isStandardConfig,
   matchFieldFor,
   matcherFires,
   mergeEvents,
   normalizeRules,
   parseStandardConfig,
+  standardConfigReport,
 } from './hook-bus/config.mjs';
 import {
-  handlerTimeoutS,
   ifConditionPasses,
   parseHandlerOutput,
   runCommandHandler,
   runHttpHandler,
   runMcpToolHandler,
   runPromptHandler,
-  defaultShellKind,
 } from './hook-bus/handlers.mjs';
 import {
   compactValue,
@@ -57,6 +54,7 @@ export {
   mergeEvents,
   normalizeRules,
   parseStandardConfig,
+  standardConfigReport,
 } from './hook-bus/config.mjs';
 export {
   handlerTimeoutS,
@@ -84,7 +82,6 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
   const counts = new Map(DEFAULT_EVENTS.map((name) => [name, 0]));
   const rulesPath = hookRulesPath(dataDir);
   const pluginData = dataDir || null;
-  let rewakeHandler = null;
   let rulesCache = { mtimeMs: -1, rules: [] };
   let configCache = {
     key: '',
@@ -163,10 +160,27 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
         disabled = parsed.disableAllHooks === true;
         disableSeen = true;
       }
-      if (isStandardConfig(parsed)) {
+      const report = standardConfigReport(parsed);
+      if (report.standard) {
+        // A malformed event no longer demotes the whole file to legacy (which
+        // silently disabled every standard handler in it): keep the valid
+        // events and report the broken ones.
+        if (report.invalidEvents.length > 0) {
+          errors.push({
+            file: filePath,
+            error: `ignored malformed hook event(s): ${report.invalidEvents.join(', ')}`,
+          });
+        }
         mergeEvents(events, parseStandardConfig(parsed, filePath, entry));
       } else {
-        legacyRules.push(...normalizeRules(parsed).filter((rule) => rule && typeof rule === 'object'));
+        const fileRules = normalizeRules(parsed).filter((rule) => rule && typeof rule === 'object');
+        if (fileRules.length === 0 && report.invalidEvents.length > 0) {
+          errors.push({
+            file: filePath,
+            error: `no usable hooks: malformed event(s) under "hooks": ${report.invalidEvents.join(', ')}`,
+          });
+        }
+        legacyRules.push(...fileRules);
       }
     }
     configCache = {
@@ -230,16 +244,7 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
           error: `hook spawn failed: ${error?.message || error}`,
         });
       };
-      const reportRewake = ({ eventName: en, payload: pl, text }) => {
-        try {
-          if (typeof rewakeHandler === 'function') {
-            rewakeHandler({ eventName: en, payload: pl, text });
-          } else {
-            emit('hook:rewake', { name: pl?.tool_name || en, text: text || null });
-          }
-        } catch {}
-      };
-      return await runCommandHandler(handler, payload, eventName, pluginData, reportSpawnError, reportRewake);
+      return await runCommandHandler(handler, payload, eventName, pluginData, reportSpawnError);
     }
     if (type === 'http') {
       if (!handler.url) return null;
@@ -334,6 +339,8 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
   }
 
   function addRule(rule = {}) {
+    // Same index-safety rule as deleteRule: settle debounced toggles first.
+    flushRules();
     const action = String(rule.action || rule.decision || '').trim().toLowerCase();
     if (!action || !['allow', 'deny', 'block', 'modify', 'rewrite', 'ask'].includes(action)) {
       throw new Error('hook rule action must be allow, deny, block, modify, rewrite, or ask');
@@ -428,6 +435,10 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
   }
 
   function deleteRule(index) {
+    // Pending enabled-state patches are addressed by INDEX. Flushing them
+    // before the splice keeps a debounced toggle from landing on whatever rule
+    // shifted into that slot after the delete.
+    flushRules();
     const rules = [...loadRules()];
     if (!Number.isInteger(index) || index < 0 || index >= rules.length) throw new Error(`hook rule not found: ${index}`);
     rules.splice(index, 1);
@@ -564,10 +575,5 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
     };
   }
 
-  function setRewakeHandler(fn) {
-    rewakeHandler = typeof fn === 'function' ? fn : null;
-    return rewakeHandler;
-  }
-
-  return { addRule, beforeTool, deleteRule, dispatch, emit, flushRules, listRules, setRewakeHandler, setRuleEnabled, status };
+  return { addRule, beforeTool, deleteRule, dispatch, emit, flushRules, listRules, setRuleEnabled, status };
 }

package/src/standalone/memory-runtime-proxy.mjs

@@ -6,6 +6,7 @@ import { dirname, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { claimSingletonOwner, handoffSingletonOwner, readSingletonOwner, releaseSingletonOwner } from '../runtime/shared/singleton-owner.mjs';
 import { readLiveServiceAdvert } from '../runtime/shared/service-discovery.mjs';
+import { isPidAlive, parsePid } from '../runtime/shared/pid-liveness.mjs';
 import { resolveRuntimeRoot } from '../runtime/shared/runtime-root.mjs';
 import { sleep as delay } from '../runtime/shared/sleep.mjs';
 import { scrubLoaderVars } from '../runtime/agent/orchestrator/tools/env-scrub.mjs';
@@ -40,22 +41,6 @@ function parsePort(value) {
   return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;
 }
 
-function parsePid(value) {
-  const pid = Number(value);
-  return Number.isInteger(pid) && pid > 0 ? pid : null;
-}
-
-function isPidAlive(pid) {
-  const n = parsePid(pid);
-  if (!n) return false;
-  try {
-    process.kill(n, 0);
-    return true;
-  } catch (error) {
-    return error?.code === 'EPERM';
-  }
-}
-
 const TRANSIENT_MEMORY_RPC_BACKOFF_MS = 400;
 // A child that dies during startup with one of these signatures is a hard,
 // deterministic failure (bad entry path, syntax/require error) — never a