mixdog 0.9.151 → 0.9.152

package/src/standalone/session-runtime-inline-host.mjs

@@ -0,0 +1,351 @@
+/**
+ * In-process session runtime host.
+ *
+ * Sessions remain independent async actors, but share the daemon's V8 isolate
+ * and ESM module cache. Native helpers and explicitly bounded worker pools keep
+ * CPU-heavy parsing/search work off the daemon loop.
+ */
+export function createInlineSessionRuntimeHost({
+  cwd = process.cwd(),
+  log = () => {},
+  loadLocalModule = () => import('../tui/session-local.mjs'),
+} = {}) {
+  const records = new Map();
+  const recordsBySessionId = new Map();
+  const agentSessionListeners = new Set();
+  const agentSessionSnapshots = new Map();
+  const activeAgentSessionProjections = new Set();
+  const pendingAgentSessionProjections = new Map();
+  const agentDispatchers = new Map();
+  const agentDispatchRuns = new Map();
+  let nextRuntimeId = 0;
+  let closed = false;
+  let localModulePromise = null;
+  let prewarmPromise = null;
+  let agentGraphPromise = null;
+  let preparedProviderSignature = null;
+  let providerPreparePromise = null;
+  let unsubscribeAgentSessionPublisher = null;
+  let agentSessionPublisherPromise = null;
+
+  function localModule() {
+    localModulePromise ??= Promise.resolve().then(loadLocalModule).catch((error) => {
+      localModulePromise = null;
+      throw error;
+    });
+    return localModulePromise;
+  }
+
+  function agentGraph() {
+    agentGraphPromise ??= Promise.all([
+      import('../runtime/agent/orchestrator/config.mjs'),
+      import('../runtime/agent/orchestrator/providers/registry.mjs'),
+      import('../runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs'),
+    ]).then(
+      ([config, registry, dispatch]) => ({ config, registry, dispatch }),
+      (error) => {
+        agentGraphPromise = null;
+        throw error;
+      },
+    );
+    return agentGraphPromise;
+  }
+
+  async function prepareAgentProviders() {
+    const { config, registry } = await agentGraph();
+    const providers = config.loadConfig()?.providers || {};
+    let signature = null;
+    try { signature = JSON.stringify(providers); } catch { /* re-prepare each call */ }
+    if (signature !== null && preparedProviderSignature === signature) return;
+    if (providerPreparePromise) {
+      await providerPreparePromise;
+      if (signature !== null && preparedProviderSignature === signature) return;
+      return prepareAgentProviders();
+    }
+    const pending = Promise.resolve()
+      .then(() => registry.initProviders(providers))
+      .then(() => { preparedProviderSignature = signature; });
+    const tracked = pending.finally(() => {
+      if (providerPreparePromise === tracked) providerPreparePromise = null;
+    });
+    providerPreparePromise = tracked;
+    await tracked;
+  }
+
+  function agentOwnedSession(session) {
+    const owner = String(session?.owner || '').trim().toLowerCase();
+    const agent = String(session?.agent || '').trim().toLowerCase();
+    return Boolean(session?.id)
+      && (owner === 'agent' || (agent && agent !== 'lead'));
+  }
+
+  async function projectAgentSession(session) {
+    const [
+      { restoreTranscriptItems },
+      { getSessionProgressSnapshot },
+    ] = await Promise.all([
+      import('../tui/session/session-api-ext.mjs'),
+      import('../runtime/agent/orchestrator/session/manager.mjs'),
+    ]);
+    const sessionId = String(session.id || '');
+    const status = String(session.status || '').trim().toLowerCase();
+    const progress = getSessionProgressSnapshot?.(sessionId) || null;
+    const stage = String(progress?.stage || '').trim().toLowerCase();
+    const busy = status === 'running' || status === 'queued'
+      || (stage && stage !== 'idle' && stage !== 'done' && stage !== 'closed');
+    return {
+      sessionId,
+      items: restoreTranscriptItems(
+        Array.isArray(session.messages) ? session.messages : [],
+        { sessionId, itemLimit: 512 },
+      ),
+      queued: [],
+      busy,
+      commandBusy: false,
+      provider: session.provider || '',
+      model: session.model || '',
+      effort: session.effort || '',
+      fast: session.fast === true,
+      modelParameters: session.modelParameters || {},
+      cwd: session.cwd || '',
+      desktopSession: session.desktopSession || null,
+      workflow: session.workflow || null,
+      ownerClientHostPid: Number(session.clientHostPid) || process.pid,
+    };
+  }
+
+  function publishAgentSessionState(sessionId, snapshot) {
+    agentSessionSnapshots.delete(sessionId);
+    agentSessionSnapshots.set(sessionId, snapshot);
+    while (agentSessionSnapshots.size > 256) {
+      const oldest = agentSessionSnapshots.keys().next().value;
+      if (oldest === undefined) break;
+      agentSessionSnapshots.delete(oldest);
+    }
+    for (const listener of [...agentSessionListeners]) {
+      try { listener({ sessionId, snapshot }); } catch {}
+    }
+  }
+
+  function scheduleAgentSessionProjection(session) {
+    if (!agentOwnedSession(session) || closed) return;
+    const sessionId = String(session.id);
+    pendingAgentSessionProjections.set(sessionId, session);
+    if (activeAgentSessionProjections.has(sessionId)) return;
+    activeAgentSessionProjections.add(sessionId);
+    queueMicrotask(() => {
+      void (async () => {
+        while (!closed) {
+          const latest = pendingAgentSessionProjections.get(sessionId);
+          if (!latest) break;
+          pendingAgentSessionProjections.delete(sessionId);
+          const snapshot = await projectAgentSession(latest);
+          if (!closed) publishAgentSessionState(sessionId, snapshot);
+        }
+      })().catch((error) => {
+        log(`agent session projection failed session=${sessionId}: ${error?.message || error}`);
+      }).finally(() => {
+        activeAgentSessionProjections.delete(sessionId);
+        if (pendingAgentSessionProjections.has(sessionId) && !closed) {
+          scheduleAgentSessionProjection(pendingAgentSessionProjections.get(sessionId));
+        }
+      });
+    });
+  }
+
+  async function ensureAgentSessionPublisher() {
+    if (unsubscribeAgentSessionPublisher) return;
+    agentSessionPublisherPromise ??= import(
+      '../runtime/agent/orchestrator/session/store.mjs'
+    ).then((store) => {
+      unsubscribeAgentSessionPublisher = store.subscribeLiveSessions(
+        scheduleAgentSessionProjection,
+      );
+    }).finally(() => {
+      agentSessionPublisherPromise = null;
+    });
+    await agentSessionPublisherPromise;
+  }
+
+  function forget(record) {
+    if (!record || !records.delete(record.id)) return;
+    for (const [sessionId, owner] of recordsBySessionId) {
+      if (owner === record) recordsBySessionId.delete(sessionId);
+    }
+  }
+
+  function ownerRuntime(sessionId) {
+    const id = String(sessionId || '').trim();
+    const known = recordsBySessionId.get(id);
+    if (known) return known.runtime;
+    for (const record of records.values()) {
+      const current = String(record.runtime.getState?.()?.sessionId || record.runtime.id || '');
+      if (!current || current !== id) continue;
+      recordsBySessionId.set(id, record);
+      return record.runtime;
+    }
+    return null;
+  }
+
+  async function create(options = {}) {
+    if (closed) throw new Error('session runtime host is closed');
+    const module = await localModule();
+    const runtime = await module.createLocalSessionRuntime({
+      ...options,
+      ...(options.cwd ? {} : { cwd }),
+    });
+    const record = {
+      id: `inline-${process.pid}-${++nextRuntimeId}`,
+      runtime,
+    };
+    records.set(record.id, record);
+    const hintedSessionId = String(options.sessionId || '').trim();
+    if (hintedSessionId) recordsBySessionId.set(hintedSessionId, record);
+
+    const originalDispose = typeof runtime.dispose === 'function'
+      ? runtime.dispose.bind(runtime)
+      : null;
+    runtime.dispose = async (...args) => {
+      try {
+        return await originalDispose?.(...args);
+      } finally {
+        forget(record);
+      }
+    };
+    return runtime;
+  }
+
+  function prewarm() {
+    if (closed) return Promise.reject(new Error('session runtime host is closed'));
+    prewarmPromise ??= localModule().then((module) => Promise.allSettled([
+      module.preloadSessionRuntimeModule?.(),
+      module.preloadAgentLoopRuntime?.(),
+      module.preloadKeychainSecrets?.(),
+    ])).then(() => ({ ready: true }));
+    return prewarmPromise;
+  }
+
+  async function agentDispatch(payload = {}, { signal = null } = {}) {
+    if (closed) throw new Error('session runtime host is closed');
+    const dispatchId = String(payload?.dispatchId || '');
+    if (!dispatchId) throw new Error('agent dispatch id is required');
+    if (agentDispatchRuns.has(dispatchId)) {
+      throw new Error(`agent dispatch ${dispatchId} is already running`);
+    }
+    const controller = new AbortController();
+    const abort = () => {
+      if (controller.signal.aborted) return;
+      try { controller.abort(signal?.reason); } catch { try { controller.abort(); } catch {} }
+    };
+    if (signal?.aborted) abort();
+    else signal?.addEventListener?.('abort', abort, { once: true });
+    agentDispatchRuns.set(dispatchId, controller);
+    try {
+      if (controller.signal.aborted) throw controller.signal.reason || new Error('agent dispatch canceled');
+      const agent = String(payload.agent || '');
+      const { dispatch } = await agentGraph();
+      await ensureAgentSessionPublisher();
+      await prepareAgentProviders();
+      if (controller.signal.aborted) throw controller.signal.reason || new Error('agent dispatch canceled');
+      let dispatcher = agentDispatchers.get(agent);
+      if (!dispatcher) {
+        dispatcher = dispatch.makeAgentDispatch({
+          agent,
+          ...(payload.options && typeof payload.options === 'object' ? payload.options : {}),
+        });
+        agentDispatchers.set(agent, dispatcher);
+      }
+      const params = payload.params && typeof payload.params === 'object' ? payload.params : {};
+      return await dispatcher({
+        prompt: String(params.prompt ?? ''),
+        preset: params.preset || undefined,
+        cwd: typeof params.cwd === 'string' && params.cwd ? params.cwd : undefined,
+        parentSignal: controller.signal,
+        ...(Number.isFinite(Number(params.idleTimeoutMs)) && Number(params.idleTimeoutMs) > 0
+          ? { idleTimeoutMs: Number(params.idleTimeoutMs) }
+          : {}),
+      });
+    } finally {
+      signal?.removeEventListener?.('abort', abort);
+      agentDispatchRuns.delete(dispatchId);
+    }
+  }
+
+  return {
+    create,
+    prewarm,
+    agentDispatch,
+    async agentControl(args = {}, context = {}) {
+      if (closed) throw new Error('session runtime host is closed');
+      const runtime = ownerRuntime(context?.callerSessionId);
+      if (!runtime?.agentControl) {
+        throw new Error(`session ${context?.callerSessionId || 'unknown'} is not loaded`);
+      }
+      return runtime.agentControl(args);
+    },
+    refreshRuntimeWorkload() {
+      return Promise.resolve(this.workloads);
+    },
+    subscribeAgentSessionStates(listener) {
+      if (typeof listener !== 'function') return () => {};
+      agentSessionListeners.add(listener);
+      void ensureAgentSessionPublisher().catch((error) => {
+        log(`agent session publisher failed (non-fatal): ${error?.message || error}`);
+      });
+      for (const [sessionId, snapshot] of agentSessionSnapshots) {
+        try { listener({ sessionId, snapshot }); } catch {}
+      }
+      return () => agentSessionListeners.delete(listener);
+    },
+    get workloads() {
+      const memory = process.memoryUsage();
+      return {
+        mode: 'in-process',
+        refreshedAt: Date.now(),
+        shardCount: 0,
+        shards: [],
+        worker: {
+          pid: process.pid,
+          runtimes: records.size,
+          memory: {
+            rss: memory.rss,
+            heapTotal: memory.heapTotal,
+            heapUsed: memory.heapUsed,
+            external: memory.external,
+          },
+        },
+      };
+    },
+    async close(reason = 'session runtime host closed') {
+      if (closed) return;
+      closed = true;
+      try { unsubscribeAgentSessionPublisher?.(); } catch {}
+      unsubscribeAgentSessionPublisher = null;
+      agentSessionListeners.clear();
+      agentSessionSnapshots.clear();
+      pendingAgentSessionProjections.clear();
+      for (const controller of agentDispatchRuns.values()) {
+        try { controller.abort(new Error(reason)); } catch {}
+      }
+      agentDispatchRuns.clear();
+      const active = [...records.values()];
+      await Promise.allSettled(active.map((record) => record.runtime.dispose?.(reason)));
+      records.clear();
+      recordsBySessionId.clear();
+    },
+    get status() {
+      return {
+        mode: 'in-process',
+        active: !closed,
+        worker: {
+          pid: process.pid,
+          pids: [process.pid],
+          runtimes: records.size,
+        },
+        shards: [],
+        shardCount: 0,
+        providerCooldown: null,
+      };
+    },
+  };
+}

package/src/standalone/session-runtime-inline-host.test.mjs

@@ -0,0 +1,83 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createInlineSessionRuntimeHost } from './session-runtime-inline-host.mjs';
+
+function createFakeLocalModule(events) {
+  return {
+    async createLocalSessionRuntime(options = {}) {
+      events.push(['create', options]);
+      const listeners = new Set();
+      const state = { sessionId: options.sessionId || null };
+      return {
+        id: state.sessionId,
+        getState: () => state,
+        subscribe(listener) {
+          listeners.add(listener);
+          return () => listeners.delete(listener);
+        },
+        async dispose(reason) {
+          events.push(['dispose', reason]);
+        },
+        async agentControl(args) {
+          return JSON.stringify(args);
+        },
+      };
+    },
+    async preloadSessionRuntimeModule() {
+      events.push(['prewarm', 'runtime']);
+    },
+    async preloadAgentLoopRuntime() {
+      events.push(['prewarm', 'agent-loop']);
+    },
+    async preloadKeychainSecrets() {
+      events.push(['prewarm', 'keychain']);
+    },
+  };
+}
+
+test('inline host keeps session actors in the daemon process and releases them', async () => {
+  const events = [];
+  const host = createInlineSessionRuntimeHost({
+    cwd: 'C:\\project',
+    loadLocalModule: async () => createFakeLocalModule(events),
+  });
+
+  const first = await host.create({ sessionId: 'session-a' });
+  const second = await host.create({ sessionId: 'session-b', cwd: 'D:\\other' });
+
+  assert.equal(host.status.mode, 'in-process');
+  assert.equal(host.status.worker.pid, process.pid);
+  assert.equal(host.status.worker.runtimes, 2);
+  assert.equal(events[0][1].cwd, 'C:\\project');
+  assert.equal(events[1][1].cwd, 'D:\\other');
+  assert.equal(
+    await host.agentControl({ type: 'list' }, { callerSessionId: 'session-a' }),
+    '{"type":"list"}',
+  );
+
+  await first.dispose('idle');
+  assert.equal(host.status.worker.runtimes, 1);
+  await host.close('done');
+  assert.equal(host.status.active, false);
+  assert.equal(host.status.worker.runtimes, 0);
+  assert.equal(events.some(([type, reason]) => type === 'dispose' && reason === 'done'), true);
+  void second;
+});
+
+test('inline host prewarm deliberately leaves the memory process cold', async () => {
+  const events = [];
+  const host = createInlineSessionRuntimeHost({
+    loadLocalModule: async () => createFakeLocalModule(events),
+  });
+
+  await host.prewarm();
+  await host.prewarm();
+
+  assert.deepEqual(
+    events.filter(([type]) => type === 'prewarm').map(([, target]) => target).sort(),
+    ['agent-loop', 'keychain', 'runtime'],
+  );
+  await host.close('done');
+});
+

package/src/standalone/session-runtime-provider-cooldown.mjs

@@ -0,0 +1,78 @@
+'use strict';
+
+// Cross-shard provider cooldown encoding.
+//
+// Fast-mode capacity cooldown is an ACCOUNT-wide fact kept in process-local
+// policy state. With the runtime split across several shard processes, a
+// cooldown discovered by one shard must reach the others or its siblings keep
+// hammering a pool that is already known to be drained.
+//
+// The policy module owns the decision rules, so a replay is expressed through
+// its PUBLIC API as the same capacity rejection the discovering shard saw:
+// this file only encodes/decodes that fact. The policy applies its own minimum
+// window, so a replay can only ever be equal or MORE conservative than the
+// observation — never a shorter or cleared cooldown.
+
+const ECHO_TOLERANCE_MS = 1_000;
+
+/** Read this process's live cooldown as a wire-safe record. */
+export function readProviderCooldown(policy, now = Date.now()) {
+  if (!policy) return null;
+  let remaining = 0;
+  let disabledReason = null;
+  try {
+    remaining = policy.fastModeCooldownRemainingMs(now);
+    disabledReason = policy.fastModeDisabledReason();
+  } catch { return null; }
+  return {
+    untilMs: Number.isFinite(remaining) && remaining > 0 ? now + remaining : 0,
+    disabledReason: disabledReason || null,
+    observedAt: now,
+  };
+}
+
+/** True only for a materially LONGER cooldown or a newly disabled pool. */
+export function providerCooldownAdvanced(previous, next) {
+  const priorUntil = Number(previous?.untilMs) || 0;
+  const nextUntil = Number(next?.untilMs) || 0;
+  const nextReason = next?.disabledReason ? String(next.disabledReason) : null;
+  const priorReason = previous?.disabledReason ? String(previous.disabledReason) : null;
+  return nextUntil > priorUntil + ECHO_TOLERANCE_MS
+    || (Boolean(nextReason) && nextReason !== priorReason);
+}
+
+export function mergeKnownProviderCooldown(previous, next) {
+  return {
+    untilMs: Math.max(Number(previous?.untilMs) || 0, Number(next?.untilMs) || 0),
+    disabledReason: (next?.disabledReason ? String(next.disabledReason) : null)
+      || (previous?.disabledReason ? String(previous.disabledReason) : null),
+  };
+}
+
+/** Replay a sibling shard's cooldown into this process's policy state. */
+export function applyProviderCooldown(policy, cooldown, now = Date.now()) {
+  if (!policy) return false;
+  const untilMs = Number(cooldown?.untilMs) || 0;
+  const disabledReason = cooldown?.disabledReason ? String(cooldown.disabledReason) : '';
+  const policyLimits = policy._FAST_MODE_POLICY || {};
+  let applied = false;
+  if (disabledReason && policyLimits.OVERAGE_DISABLED_HEADER) {
+    policy.noteFastModeCapacityError({
+      httpStatus: 429,
+      headers: { [policyLimits.OVERAGE_DISABLED_HEADER]: disabledReason },
+    }, { fast: true, now });
+    applied = true;
+  }
+  const remainingMs = untilMs - now;
+  // Below the policy's short-retry bound the discovering shard itself keeps
+  // fast mode, so there is nothing to replicate.
+  const shortRetryMs = Number(policyLimits.SHORT_RETRY_THRESHOLD_MS) || 0;
+  if (remainingMs >= shortRetryMs && remainingMs > 0) {
+    policy.noteFastModeCapacityError(
+      { httpStatus: 429, retryAfterMs: remainingMs },
+      { fast: true, now },
+    );
+    applied = true;
+  }
+  return applied;
+}

package/src/standalone/session-runtime-provider-cooldown.test.mjs

@@ -0,0 +1,80 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import * as fastMode from '../runtime/agent/orchestrator/providers/anthropic-fast-mode.mjs';
+import {
+  applyProviderCooldown,
+  mergeKnownProviderCooldown,
+  providerCooldownAdvanced,
+  readProviderCooldown,
+} from './session-runtime-provider-cooldown.mjs';
+
+test('a sibling shard cooldown is replayed into this process without hammering the pool', () => {
+  fastMode.clearFastModeCooldown();
+  try {
+    const now = Date.now();
+    assert.equal(fastMode.fastModeAvailable(now), true);
+
+    const applied = applyProviderCooldown(fastMode, { untilMs: now + 120_000 }, now);
+    assert.equal(applied, true);
+    assert.equal(fastMode.fastModeAvailable(now), false);
+    // The policy owns the floor: a replay is never SHORTER than observed.
+    assert.ok(fastMode.fastModeCooldownRemainingMs(now) >= 120_000);
+
+    // Reading it back reproduces the cooldown for the next shard in line.
+    const observed = readProviderCooldown(fastMode, now);
+    assert.ok(observed.untilMs >= now + 120_000);
+    assert.equal(observed.disabledReason, null);
+  } finally {
+    fastMode.clearFastModeCooldown();
+  }
+});
+
+test('an expired or short replay never clears a live cooldown', () => {
+  fastMode.clearFastModeCooldown();
+  try {
+    const now = Date.now();
+    applyProviderCooldown(fastMode, { untilMs: now + 300_000 }, now);
+    const remaining = fastMode.fastModeCooldownRemainingMs(now);
+    // Stale/short frames are ignored; the live cooldown survives.
+    assert.equal(applyProviderCooldown(fastMode, { untilMs: now - 5_000 }, now), false);
+    assert.equal(applyProviderCooldown(fastMode, { untilMs: now + 500 }, now), false);
+    assert.equal(fastMode.fastModeCooldownRemainingMs(now), remaining);
+    assert.equal(fastMode.fastModeAvailable(now), false);
+  } finally {
+    fastMode.clearFastModeCooldown();
+  }
+});
+
+test('a disabled fast pool replays as a terminal disable', () => {
+  fastMode.clearFastModeCooldown();
+  try {
+    const now = Date.now();
+    assert.equal(
+      applyProviderCooldown(fastMode, { untilMs: 0, disabledReason: 'overage unavailable' }, now),
+      true,
+    );
+    assert.equal(fastMode.fastModeDisabledReason(), 'overage unavailable');
+    assert.equal(fastMode.fastModeAvailable(now), false);
+    const observed = readProviderCooldown(fastMode, now);
+    assert.equal(observed.disabledReason, 'overage unavailable');
+  } finally {
+    fastMode.clearFastModeCooldown();
+  }
+});
+
+test('replayed state is not echoed back as a new local discovery', () => {
+  const known = mergeKnownProviderCooldown(
+    { untilMs: 0, disabledReason: null },
+    { untilMs: 10_000, disabledReason: null },
+  );
+  assert.equal(known.untilMs, 10_000);
+  assert.equal(providerCooldownAdvanced(known, { untilMs: 10_000 }), false);
+  assert.equal(providerCooldownAdvanced(known, { untilMs: 10_500 }), false);
+  assert.equal(providerCooldownAdvanced(known, { untilMs: 30_000 }), true);
+  assert.equal(providerCooldownAdvanced(known, { untilMs: 0, disabledReason: 'off' }), true);
+  assert.equal(
+    providerCooldownAdvanced({ ...known, disabledReason: 'off' }, { untilMs: 0, disabledReason: 'off' }),
+    false,
+  );
+});