mixdog 0.9.95 → 0.9.97

package/src/standalone/agent-dispatch-broker.mjs

@@ -0,0 +1,198 @@
+import { createFairCallScheduler } from './fair-call-scheduler.mjs';
+
+const MEMORY_AGENTS = Object.freeze([
+  'cycle1-agent',
+  'cycle2-agent',
+  'cycle3-agent',
+]);
+const MEMORY_AGENT_SET = new Set(MEMORY_AGENTS);
+
+function abortError(signal) {
+  return signal?.reason instanceof Error
+    ? signal.reason
+    : new Error(String(signal?.reason || 'agent dispatch canceled'));
+}
+
+function awaitSharedPreparation(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.reject(abortError(signal));
+  let listener = null;
+  const aborted = new Promise((_, reject) => {
+    listener = () => reject(abortError(signal));
+    signal.addEventListener('abort', listener, { once: true });
+  });
+  return Promise.race([promise, aborted]).finally(() => {
+    if (listener) {
+      try { signal.removeEventListener('abort', listener); } catch {}
+    }
+  });
+}
+
+/**
+ * Process-singleton memory LLM broker.
+ *
+ * The daemon owns one provider/session/memory graph. Memory
+ * process keeps PG, embeddings, and recall, and forwards only cycle LLM calls
+ * here. A singleton is NOT a serial lane: every call gets its own dispatch
+ * session + AbortController and the fair scheduler starts calls in parallel
+ * unless an operator explicitly configures a finite active limit.
+ */
+export function createAgentDispatchBroker({
+  loadConfig,
+  initProviders,
+  makeAgentDispatch,
+  log = () => {},
+  activeMax = Infinity,
+  queueMax = 256,
+  onActivityChanged = null,
+} = {}) {
+  if (typeof loadConfig !== 'function') throw new TypeError('loadConfig is required');
+  if (typeof initProviders !== 'function') throw new TypeError('initProviders is required');
+  if (typeof makeAgentDispatch !== 'function') throw new TypeError('makeAgentDispatch is required');
+
+  const scheduler = createFairCallScheduler({
+    name: 'memory agent dispatch',
+    activeMax,
+    queueMax,
+    minOwnerQueue: Math.max(8, Math.floor(queueMax / 16)),
+  });
+  const inFlight = new Map();
+  const dispatchers = new Map(MEMORY_AGENTS.map((agent) => [
+    agent,
+    makeAgentDispatch({
+      agent,
+      taskType: 'maintenance',
+      sourceType: 'memory-cycle',
+      brief: false,
+    }),
+  ]));
+  let nextCallId = 0;
+  let closed = false;
+  let preparedProviderSignature = null;
+  let providerPreparePromise = null;
+
+  async function prepareProviders(signal = null) {
+    const config = loadConfig();
+    const providers = config?.providers || {};
+    let signature = null;
+    try { signature = JSON.stringify(providers); } catch {}
+    if (signature !== null && preparedProviderSignature === signature) return;
+    if (providerPreparePromise) {
+      await awaitSharedPreparation(providerPreparePromise, signal);
+      if (signature !== null && preparedProviderSignature === signature) return;
+      return prepareProviders(signal);
+    }
+    const pending = Promise.resolve()
+      // Process-global preparation is shared by every request. One caller's
+      // cancellation may stop waiting but must never abort initialization
+      // underneath independent calls.
+      .then(() => initProviders(providers))
+      .then(() => {
+        preparedProviderSignature = signature;
+      });
+    const tracked = pending.finally(() => {
+      if (providerPreparePromise === tracked) providerPreparePromise = null;
+    });
+    providerPreparePromise = tracked;
+    await awaitSharedPreparation(tracked, signal);
+  }
+
+  async function warmup() {
+    if (closed) throw new Error('memory agent dispatch broker is closed');
+    await prepareProviders();
+    return true;
+  }
+
+  function dispatch(params = {}, { callId = null, signal = null } = {}) {
+    if (closed) return Promise.reject(new Error('memory agent dispatch broker is closed'));
+    const agent = String(params.agent || '').trim();
+    if (!MEMORY_AGENT_SET.has(agent)) {
+      return Promise.reject(new Error(`memory agent dispatch denied for "${agent || 'unknown'}"`));
+    }
+    const prompt = String(params.prompt ?? '');
+    if (!prompt) return Promise.reject(new Error(`agent dispatch prompt required for "${agent}"`));
+
+    const id = String(callId || `broker-${process.pid}-${++nextCallId}`);
+    const existing = inFlight.get(id);
+    if (existing) return existing.promise;
+
+    const controller = new AbortController();
+    const abortFromCaller = () => {
+      if (controller.signal.aborted) return;
+      try { controller.abort(signal?.reason); } catch { try { controller.abort(); } catch {} }
+    };
+    if (signal?.aborted) abortFromCaller();
+    else signal?.addEventListener?.('abort', abortFromCaller, { once: true });
+
+    const run = async () => {
+      if (controller.signal.aborted) throw abortError(controller.signal);
+      await prepareProviders(controller.signal);
+      if (controller.signal.aborted) throw abortError(controller.signal);
+      const timeout = Number(params.timeout);
+      return dispatchers.get(agent)({
+        prompt,
+        preset: params.preset || undefined,
+        cwd: typeof params.cwd === 'string' && params.cwd ? params.cwd : undefined,
+        parentSignal: controller.signal,
+        ...(Number.isFinite(timeout) && timeout > 0 ? { idleTimeoutMs: timeout } : {}),
+      });
+    };
+    const promise = scheduler.enqueue(`memory:${agent}`, run, {
+      signal: controller.signal,
+    });
+    let record = null;
+    const tracked = promise.finally(() => {
+      signal?.removeEventListener?.('abort', abortFromCaller);
+      if (inFlight.get(id) === record) inFlight.delete(id);
+      try { onActivityChanged?.(snapshot()); } catch {}
+    });
+    record = { controller, promise: tracked };
+    inFlight.set(id, record);
+    try { onActivityChanged?.(snapshot()); } catch {}
+    return tracked;
+  }
+
+  function cancel(callId, reason = 'memory agent dispatch canceled') {
+    const id = String(callId || '');
+    const record = inFlight.get(id);
+    if (!record) return false;
+    try { record.controller.abort(new Error(reason)); } catch { try { record.controller.abort(); } catch {} }
+    return true;
+  }
+
+  async function cancelAndWait(callId, reason = 'memory agent dispatch canceled') {
+    const id = String(callId || '');
+    const record = inFlight.get(id);
+    if (!record) return false;
+    cancel(id, reason);
+    try { await record.promise; } catch {}
+    return true;
+  }
+
+  function snapshot() {
+    return {
+      ...scheduler.snapshot(),
+      inFlight: inFlight.size,
+      dispatchers: dispatchers.size,
+    };
+  }
+
+  function close(reason = 'memory agent dispatch broker is closed') {
+    if (closed) return;
+    closed = true;
+    for (const record of inFlight.values()) {
+      try { record.controller.abort(new Error(reason)); } catch {}
+    }
+    scheduler.close(reason);
+    log(`agent dispatch broker closed (${reason})`);
+  }
+
+  return {
+    warmup,
+    dispatch,
+    cancel,
+    cancelAndWait,
+    snapshot,
+    close,
+  };
+}

package/src/standalone/agent-tool/helpers.mjs

@@ -151,8 +151,8 @@ export function synthesizePreset(config, key) {
   };
 }
 
-export function normalizeAgentRoute(routeLike, fallbackProvider = '') {
-  const provider = clean(routeLike?.provider) || clean(fallbackProvider);
+export function normalizeAgentRoute(routeLike) {
+  const provider = clean(routeLike?.provider);
   const model = clean(routeLike?.model);
   if (!provider || !model) return null;
   return {

package/src/standalone/agent-tool/spawn-flow.mjs

@@ -76,6 +76,8 @@ export function createSpawnFlow({
         const lease = await resourceAdmission.acquire('agent', {
           signal: admissionController.signal,
           label: jobMeta?.tag || type,
+          ownerKey: notifyContext?.callerSessionId || notifyContext?.sessionId
+            || clientHostPid || null,
         });
         try {
           // Yield one macrotask before doing agent work. startBackgroundTask uses

package/src/standalone/agent-tool/spawn-preset.mjs

@@ -1,8 +1,4 @@
-import { isKnownProvider } from '../provider-admin.mjs';
-import {
-  DEFAULT_AGENT_PRESETS,
-  DEFAULT_PROVIDER,
-} from './tool-def.mjs';
+import { configuredAgentRouteCandidates } from '../../runtime/shared/agent-route-config.mjs';
 import {
   agentPresetName,
   clean,
@@ -30,19 +26,10 @@ export function resolveAgentSpawnPreset(config, args = {}) {
   }
 
   const agentName = normalizeAgentName(args.agent);
-  const configuredDefault = clean(config?.defaultProvider);
-  const fallbackProvider = configuredDefault && isKnownProvider(configuredDefault)
-    ? configuredDefault
-    : DEFAULT_PROVIDER;
-  const workflowSlot = agentName === 'explore' ? 'explorer'
-    : (agentName === 'maintainer' ? 'memory' : '');
-  const maintenanceSlot = agentName === 'explore' ? 'explore'
-    : (agentName === 'maintainer' ? 'memory' : '');
   const agentRoute = !clean(args.preset)
-    ? (normalizeAgentRoute(config?.agents?.[agentName], fallbackProvider)
-      || (agentName === 'maintainer' ? normalizeAgentRoute(config?.agents?.maintenance, fallbackProvider) : null)
-      || normalizeAgentRoute(config?.workflowRoutes?.[workflowSlot], fallbackProvider)
-      || normalizeAgentRoute(config?.maintenance?.[maintenanceSlot], fallbackProvider))
+    ? configuredAgentRouteCandidates(config, agentName)
+      .map((candidate) => normalizeAgentRoute(candidate))
+      .find(Boolean) || null
     : null;
   if (agentRoute) {
     return {
@@ -60,14 +47,17 @@ export function resolveAgentSpawnPreset(config, args = {}) {
     };
   }
 
-  const mainPreset = !clean(args.preset) && (agentName === 'explore' || agentName === 'maintainer')
+  const mainPreset = !clean(args.preset)
     ? findPreset(config, config?.default)
     : null;
-  if (mainPreset) return { presetName: mainPreset.id || mainPreset.name, preset: mainPreset };
+  if (normalizeAgentRoute(mainPreset)) {
+    return { presetName: mainPreset.id || mainPreset.name, preset: mainPreset };
+  }
 
-  const presetName = clean(args.preset) || DEFAULT_AGENT_PRESETS[agentName];
-  if (!presetName) throw new Error(`agent: agent "${agentName}" has no model assignment`);
+  const presetName = clean(args.preset);
+  if (!presetName) throw new Error(`agent: agent "${agentName}" has no Main model assignment`);
   const preset = findPreset(config, presetName) || synthesizePreset(config, presetName);
   if (!preset) throw new Error(`agent: preset "${presetName}" not found`);
+  if (!normalizeAgentRoute(preset)) throw new Error(`agent: preset "${presetName}" has no complete route`);
   return { presetName, preset };
 }

package/src/standalone/agent-tool/tool-def.mjs

@@ -6,20 +6,6 @@ export const PRESET_ALIASES = new Map([
   ['opus-xhigh', { base: 'opus-high', effort: 'xhigh', id: 'opus-xhigh', name: 'OPUS XHIGH' }],
 ]);
 
-export const DEFAULT_AGENT_PRESETS = Object.freeze({
-  explore: 'sonnet-high',
-  maintainer: 'haiku',
-  worker: 'sonnet-high',
-  'heavy-worker': 'sonnet-high',
-  reviewer: 'opus-xhigh',
-  debugger: 'opus-xhigh',
-});
-
-// Mirrors DEFAULT_PROVIDER in mixdog-session-runtime.mjs. Used only as the
-// last-resort fallback when a stored agent route omits its provider and the
-// config carries no defaultProvider.
-export const DEFAULT_PROVIDER = 'anthropic-oauth';
-
 export const WORKER_INDEX_FILE = 'agent-workers.json';
 
 export const ACTIVE_STAGES = new Set(['connecting', 'requesting', 'streaming', 'tool_running', 'running', 'cancelling']);

package/src/standalone/channel-admin.mjs

@@ -11,6 +11,7 @@ import {
 import { basename, dirname, join } from 'node:path';
 import {
   SECRET_ACCOUNTS,
+  canonicalizeStoredChannelsConfig,
   deleteSecret,
   diagnoseDiscordTokenValue,
   getDiscordToken,
@@ -43,10 +44,10 @@ import { readHookPublicBase } from '../runtime/channels/lib/webhook/relay-tunnel
 
 const NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 const DEFAULT_CHANNELS = Object.freeze({
-  backend: 'discord',
+  provider: 'discord',
   discord: {},
   access: { dmPolicy: 'allowlist', allowFrom: [], channels: {} },
-  channel: { channelId: '', discordChannelId: '', telegramChatId: '' },
+  channel: { discordChannelId: '', telegramChatId: '' },
   webhook: { enabled: true, port: 3333 },
 });
 
@@ -91,36 +92,28 @@ function assertScheduleName(name) {
 }
 
 function normalizeChannelsConfig(raw = {}) {
+  const stored = canonicalizeStoredChannelsConfig(raw);
   return {
     ...DEFAULT_CHANNELS,
-    ...(raw && typeof raw === 'object' ? raw : {}),
-    discord: { ...DEFAULT_CHANNELS.discord, ...(raw?.discord || {}) },
-    access: { ...DEFAULT_CHANNELS.access, ...(raw?.access || {}) },
-    channel: { ...DEFAULT_CHANNELS.channel, ...(raw?.channel || {}) },
-    webhook: { ...DEFAULT_CHANNELS.webhook, ...(raw?.webhook || {}) },
+    ...stored,
+    discord: { ...DEFAULT_CHANNELS.discord, ...(stored.discord || {}) },
+    access: { ...DEFAULT_CHANNELS.access, ...(stored.access || {}) },
+    channel: { ...DEFAULT_CHANNELS.channel, ...(stored.channel || {}) },
+    webhook: { ...DEFAULT_CHANNELS.webhook, ...(stored.webhook || {}) },
   };
 }
 
-function channelIdForBackend(entry = {}, backend = 'discord') {
-  if (backend === 'telegram') {
-    return String(entry?.telegramChatId || (entry?.discordChannelId ? '' : entry?.channelId) || '');
+function channelIdForProvider(entry = {}, provider = 'discord') {
+  if (provider === 'telegram') {
+    return String(entry?.telegramChatId || '');
   }
-  return String(entry?.discordChannelId || (entry?.telegramChatId ? '' : entry?.channelId) || '');
-}
-
-function seedBackendChannelIds(entry = {}, backend = 'discord') {
-  const next = { ...(entry || {}) };
-  if (next.channelId) {
-    if (backend === 'telegram' && !next.telegramChatId && !next.discordChannelId) next.telegramChatId = next.channelId;
-    if (backend !== 'telegram' && !next.discordChannelId && !next.telegramChatId) next.discordChannelId = next.channelId;
-  }
-  return next;
+  return String(entry?.discordChannelId || '');
 }
 
 // Resolve the single-channel entry from the config's `channel` object.
 function resolveChannelEntry(cfg = {}) {
   if (cfg.channel && typeof cfg.channel === 'object'
-    && (cfg.channel.channelId || cfg.channel.discordChannelId || cfg.channel.telegramChatId)) {
+    && (cfg.channel.discordChannelId || cfg.channel.telegramChatId)) {
     return cfg.channel;
   }
   return cfg.channel && typeof cfg.channel === 'object' ? cfg.channel : {};
@@ -138,7 +131,7 @@ function updateChannelsSection(build) {
 }
 
 // Async twin of updateChannelsSection: identical normalize/strip logic, but the
-// channels-section RMW runs through updateSectionAsync so a debounced backend
+// channels-section RMW runs through updateSectionAsync so a debounced provider
 // flush does not block the event loop. Same config lock file → linearizable
 // with the sync writers.
 async function updateChannelsSectionAsync(build) {
@@ -166,10 +159,10 @@ function listEntryDirs(dir) {
 // settings/TUI layer consumes.
 function getChannel(config = {}) {
   const cfg = normalizeChannelsConfig(config);
-  const backend = cfg.backend === 'telegram' ? 'telegram' : 'discord';
+  const provider = cfg.provider === 'telegram' ? 'telegram' : 'discord';
   const entry = resolveChannelEntry(cfg);
   return {
-    channelId: channelIdForBackend(entry, backend),
+    channelId: channelIdForProvider(entry, provider),
     discordChannelId: String(entry?.discordChannelId || ''),
     telegramChatId: String(entry?.telegramChatId || ''),
   };
@@ -199,39 +192,38 @@ export function forgetTelegramToken() {
   return { ok: true };
 }
 
-// Single-channel write: persists `cfg.channel`, keeping the per-backend id
-// fields (discordChannelId/telegramChatId) so a backend switch retains both
-// ids. `backend` selects which per-backend field the id updates; when omitted
-// the id lands on the active backend's field.
-export function setChannel({ channelId, backend = null } = {}) {
+// Single-channel write: persists `cfg.channel`, keeping the per-provider id
+// fields (discordChannelId/telegramChatId) so a provider switch retains both
+// ids. `provider` selects which per-provider field the id updates; when omitted
+// the id lands on the active provider's field.
+export function setChannel({ channelId, provider = null } = {}) {
   const id = String(channelId || '').trim();
   if (!id) throw new Error('channelId is required');
-  const targetBackend = backend === 'telegram' || backend === 'discord' ? backend : null;
+  const targetProvider = provider === 'telegram' || provider === 'discord' ? provider : null;
   return updateChannelsSection((cfg) => {
-    const activeBackend = cfg.backend === 'telegram' ? 'telegram' : 'discord';
-    const writeBackend = targetBackend || activeBackend;
-    const current = seedBackendChannelIds(resolveChannelEntry(cfg), activeBackend);
+    const activeProvider = cfg.provider === 'telegram' ? 'telegram' : 'discord';
+    const writeProvider = targetProvider || activeProvider;
+    const current = resolveChannelEntry(cfg);
     const nextEntry = { ...current };
-    if (writeBackend === 'telegram') nextEntry.telegramChatId = id;
+    if (writeProvider === 'telegram') nextEntry.telegramChatId = id;
     else nextEntry.discordChannelId = id;
-    // `channelId` mirrors the active backend's id for legacy readers.
-    nextEntry.channelId = channelIdForBackend(nextEntry, activeBackend);
+    delete nextEntry.channelId;
     return { ...cfg, channel: nextEntry };
   });
 }
 
-export async function setChannelAsync({ channelId, backend = null } = {}) {
+export async function setChannelAsync({ channelId, provider = null } = {}) {
   const id = String(channelId || '').trim();
   if (!id) throw new Error('channelId is required');
-  const targetBackend = backend === 'telegram' || backend === 'discord' ? backend : null;
+  const targetProvider = provider === 'telegram' || provider === 'discord' ? provider : null;
   return updateChannelsSectionAsync((cfg) => {
-    const activeBackend = cfg.backend === 'telegram' ? 'telegram' : 'discord';
-    const writeBackend = targetBackend || activeBackend;
-    const current = seedBackendChannelIds(resolveChannelEntry(cfg), activeBackend);
+    const activeProvider = cfg.provider === 'telegram' ? 'telegram' : 'discord';
+    const writeProvider = targetProvider || activeProvider;
+    const current = resolveChannelEntry(cfg);
     const nextEntry = { ...current };
-    if (writeBackend === 'telegram') nextEntry.telegramChatId = id;
+    if (writeProvider === 'telegram') nextEntry.telegramChatId = id;
     else nextEntry.discordChannelId = id;
-    nextEntry.channelId = channelIdForBackend(nextEntry, activeBackend);
+    delete nextEntry.channelId;
     return { ...cfg, channel: nextEntry };
   });
 }
@@ -260,33 +252,30 @@ export async function setWebhookConfigAsync(patch = {}) {
   }));
 }
 
-function validateBackend(name) {
+function validateProvider(name) {
   const value = String(name || '').trim();
   if (value !== 'discord' && value !== 'telegram') {
-    throw new Error('backend must be discord or telegram');
+    throw new Error('provider must be discord or telegram');
   }
   return value;
 }
-function backendBuilder(value) {
+function providerBuilder(value) {
   return (cfg) => {
-    const activeBackend = cfg.backend === 'telegram' ? 'telegram' : 'discord';
-    const seeded = seedBackendChannelIds(resolveChannelEntry(cfg), activeBackend);
-    // `channelId` now mirrors the newly-selected backend's id; both per-backend
-    // id fields are retained so switching back keeps the other id.
-    const channel = { ...seeded, channelId: channelIdForBackend(seeded, value) };
-    return { ...cfg, channel, backend: value };
+    const channel = { ...resolveChannelEntry(cfg) };
+    delete channel.channelId;
+    return { ...cfg, channel, provider: value };
   };
 }
-export function setBackend(name) {
-  const value = validateBackend(name);
-  updateChannelsSection(backendBuilder(value));
-  return { ok: true, backend: value };
+export function setChannelProvider(name) {
+  const value = validateProvider(name);
+  updateChannelsSection(providerBuilder(value));
+  return { ok: true, provider: value };
 }
-// Async twin used by the debounced backend-save flush timer.
-export async function setBackendAsync(name) {
-  const value = validateBackend(name);
-  await updateChannelsSectionAsync(backendBuilder(value));
-  return { ok: true, backend: value };
+// Async twin used by the debounced provider-save flush timer.
+export async function setChannelProviderAsync(name) {
+  const value = validateProvider(name);
+  await updateChannelsSectionAsync(providerBuilder(value));
+  return { ok: true, provider: value };
 }
 
 function normalizeCron(time) {
@@ -578,16 +567,16 @@ export async function channelSetup(config = null) {
   const discordProblem = diagnoseDiscordTokenValue(discordToken, cfg);
   const telegramToken = getTelegramToken();
   return {
-    backend: cfg.backend || 'discord',
+    provider: cfg.provider || 'discord',
     discord: {
-      backend: 'discord',
+      provider: 'discord',
       authenticated: Boolean(discordToken && !discordProblem),
       stored: hasStoredSecret(SECRET_ACCOUNTS.discordToken),
       status: discordToken ? (discordProblem ? 'Invalid' : 'Set') : 'Off',
       problem: discordProblem || null,
     },
     telegram: {
-      backend: 'telegram',
+      provider: 'telegram',
       authenticated: Boolean(telegramToken),
       stored: hasStoredSecret(SECRET_ACCOUNTS.telegramToken),
       status: telegramToken ? 'Set' : 'Off',

package/src/standalone/{channel-daemon-client.mjs → channel-client.mjs}

@@ -1,7 +1,7 @@
-// Machine-global channels daemon — attach client (TUI side).
+// Machine-global channel service — attach client (TUI side).
 //
 // Mirrors the memory proxy's attach pattern (POST /client/register + /health,
-// 127.0.0.1 only). A TUI uses this to talk to the ONE shared channels daemon
+// 127.0.0.1 only). A TUI uses this to talk to the shared channel front door
 // instead of forking its own worker: tool calls go over POST /call and the
 // worker->parent notify path arrives on a persistent SSE stream (GET /events),
 // replacing the old node-IPC `{type:'notify'}` messages.
@@ -28,18 +28,22 @@ function isPidAlive(pid) {
 
 // Read + validate the discovery file. Returns null when missing/corrupt or when
 // the recorded pid is dead (stale daemon) so the caller reclaims + respawns.
-export function readDaemonDiscovery(discoveryPath) {
+export function readChannelDiscovery(discoveryPath) {
   let raw;
   try { raw = JSON.parse(readFileSync(discoveryPath, 'utf8')); }
   catch { return null; }
-  const port = parsePort(raw?.port);
+  const endpoint = raw?.endpoints?.channel;
+  const port = parsePort(endpoint?.port);
   const pid = parsePid(raw?.pid);
-  if (!port || !pid || !raw?.token) return null;
+  if (!port || !pid || !endpoint?.token) return null;
   if (!isPidAlive(pid)) return null; // dead daemon → treat as absent
-  return { port, pid, token: String(raw.token) };
+  return { port, pid, token: String(endpoint.token) };
 }
 
-function request({ port, method = 'GET', path = '/', token, body = null, timeoutMs = 10_000 }) {
+function request({
+  port, method = 'GET', path = '/', token, body = null, timeoutMs = 10_000,
+  agent = undefined,
+}) {
   return new Promise((resolve, reject) => {
     const payload = body == null ? null : JSON.stringify(body);
     let req = null;
@@ -69,6 +73,7 @@ function request({ port, method = 'GET', path = '/', token, body = null, timeout
       port,
       path,
       method,
+      agent,
       headers: {
         ...(token ? { 'X-Mixdog-Daemon-Token': token } : {}),
         ...(payload
@@ -107,7 +112,7 @@ function request({ port, method = 'GET', path = '/', token, body = null, timeout
   });
 }
 
-export async function probeDaemonHealth({ port, token, timeoutMs = 800 } = {}) {
+export async function probeChannelHealth({ port, token, timeoutMs = 800 } = {}) {
   try {
     const health = await request({ port, token, path: '/health', timeoutMs });
     return health?.status === 'ok' ? health : null;
@@ -119,7 +124,7 @@ export async function probeDaemonHealth({ port, token, timeoutMs = 800 } = {}) {
 // dispatches channel tools over HTTP. onNotify receives the SAME
 // `{type:'notify', method, params}` shape the old IPC path delivered, so the
 // TUI-side onNotify handler stays unchanged (thin glue).
-export async function attachToDaemon({
+export async function attachChannel({
   discovery,
   leadPid = process.pid,
   cwd = process.cwd(),
@@ -130,6 +135,12 @@ export async function attachToDaemon({
   const expectedPid = parsePid(discovery?.pid);
   if (!discovery?.port || !discovery?.token || !expectedPid) throw new Error('daemon discovery {port, pid, token} required');
   const { port, token: serverToken } = discovery;
+  const callAgent = new http.Agent({
+    keepAlive: true, keepAliveMsecs: 5_000, maxSockets: 16, maxFreeSockets: 4,
+  });
+  const controlAgent = new http.Agent({
+    keepAlive: true, keepAliveMsecs: 5_000, maxSockets: 4, maxFreeSockets: 2,
+  });
   const staleDiscoveryError = (reason) => {
     const err = new Error(reason);
     err.daemonDiscoveryStale = true;
@@ -137,7 +148,7 @@ export async function attachToDaemon({
   };
   const isExpectedDaemon = (health) => Number(health?.pid) === expectedPid;
 
-  const initialHealth = await probeDaemonHealth({ port, token: serverToken, timeoutMs: 800 });
+  const initialHealth = await probeChannelHealth({ port, token: serverToken, timeoutMs: 800 });
   if (!isExpectedDaemon(initialHealth)) throw staleDiscoveryError('daemon discovery pid does not match health');
 
   let reg;
@@ -147,12 +158,11 @@ export async function attachToDaemon({
       token: serverToken,
       method: 'POST',
       path: '/client/register',
-      // Initial attachment is transport-only. Mark it with the legacy
-      // non-stealing registration intent as well as relying on the current
-      // daemon contract, so a newly updated desktop cannot supersede a
-      // terminal still served by an older machine-global daemon.
-      body: { leadPid, cwd, reattach: true },
+      // Channel attachment observes the current owner and never claims the
+      // manual routing seat merely by opening the transport.
+      body: { leadPid, cwd, passive: true },
       timeoutMs: 3000,
+      agent: controlAgent,
     });
   } catch (err) {
     if (err?.statusCode === 401 || err?.statusCode === 403) {
@@ -193,6 +203,7 @@ export async function attachToDaemon({
           ...(registrationId ? { registrationId, replaceToken, leadPid, cwd } : {}),
         },
         timeoutMs: 1500,
+        agent: controlAgent,
       });
     } catch { /* best-effort; daemon sweep reaps us */ }
   }
@@ -219,7 +230,7 @@ export async function attachToDaemon({
   function handleStreamLoss(reason) {
     if (closed || fatal || reconnectTimer || reconnectProbe) return;
     reconnectProbe = true;
-    void probeDaemonHealth({ port, token: serverToken, timeoutMs: 800 }).then((health) => {
+    void probeChannelHealth({ port, token: serverToken, timeoutMs: 800 }).then((health) => {
       reconnectProbe = false;
       if (closed || fatal) return;
       if (!isExpectedDaemon(health)) {
@@ -310,17 +321,17 @@ export async function attachToDaemon({
       // Re-register (the daemon may have pruned us) then reopen the stream.
       // Re-register mints a fresh client token (the old one was pruned); adopt
       // it so the reopened stream and subsequent calls target the live entry.
-      // reattach:true — a reconnect is NOT a new terminal, so it must NOT steal
-      // the ownership seat (last-wins is reserved for genuine fresh registers).
+      // A reconnect is passive and must not claim the ownership seat.
       const generation = lifecycle;
       const registrationId = reconnectRegistrationId ||= randomUUID();
       const replaceToken = reconnectReplaceToken ||= clientToken;
       const registration = request({
         port, token: serverToken, method: 'POST', path: '/client/register',
         body: {
-          leadPid, cwd, reattach: true, replaceToken,
+          leadPid, cwd, passive: true, replaceToken,
           registrationId,
         }, timeoutMs: 3000,
+        agent: controlAgent,
       }).then(async (r) => {
         const freshToken = r?.token;
         if (!freshToken) return false;
@@ -356,6 +367,7 @@ export async function attachToDaemon({
         // a retried transport failure to a single side-effect.
         body: { token: clientToken, name, args: args || {}, ...(callId ? { callId } : {}) },
         timeoutMs,
+        agent: callAgent,
       });
     } catch (err) {
       // Transport failure (daemon dead/restarted/unreachable) — tag so the
@@ -383,6 +395,8 @@ export async function attachToDaemon({
     closePromise = (async () => {
       if (pendingRegistration) await pendingRegistration;
       await deregister(clientToken, { registrationId, replaceToken });
+      callAgent.destroy();
+      controlAgent.destroy();
       log(`detached (${reason})`);
     })();
     return closePromise;