mixdog 0.9.85 → 0.9.87

package/src/session-runtime/prewarm.mjs

@@ -91,6 +91,40 @@ export function createPrewarmSchedulers({
     timer.unref?.();
   }
 
+  // Tool-runtime warmup: the per-call cold starts a session's FIRST tool call
+  // would otherwise pay — pwsh standby processes (~300ms each) and the o200k
+  // encoder + token-count worker (~100ms). Each part is independent and
+  // best-effort; failures only mark the boot profile.
+  function scheduleToolRuntimeWarmup(delayMs = 2500) {
+    if (envFlag('MIXDOG_DISABLE_TOOL_PREWARM')) {
+      bootProfile('tool-runtime:prewarm-skipped');
+      return;
+    }
+    const timer = setTimeout(() => void (async () => {
+      if (isCloseRequested()) return;
+      try {
+        const { prewarmShellStandbys } = await import('../runtime/agent/orchestrator/tools/builtin/bash-tool.mjs');
+        bootProfile('tool-runtime:shell-standby', { warmed: prewarmShellStandbys() === true });
+      } catch (error) {
+        bootProfile('tool-runtime:shell-standby-failed', { error: error?.message || String(error) });
+      }
+      try {
+        const { prewarmTokenEstimator } = await import('../runtime/agent/orchestrator/session/context-utils.mjs');
+        bootProfile('tool-runtime:token-estimator', { warmed: prewarmTokenEstimator() === true });
+      } catch (error) {
+        bootProfile('tool-runtime:token-estimator-failed', { error: error?.message || String(error) });
+      }
+      try {
+        const { prewarmAgentShard } = await import('../standalone/agent-shard/shard-pool.mjs');
+        const warmed = await prewarmAgentShard();
+        if (warmed) bootProfile('tool-runtime:agent-shard', { warmed: true });
+      } catch (error) {
+        bootProfile('tool-runtime:agent-shard-failed', { error: error?.message || String(error) });
+      }
+    })(), delayMs);
+    timer.unref?.();
+  }
+
   function invokeChannelStart() {
     if (state.channelStartPromise) return state.channelStartPromise;
     const startedAt = performance.now();
@@ -142,6 +176,7 @@ export function createPrewarmSchedulers({
   return {
     scheduleCodeGraphPrewarm,
     scheduleLeadSessionPrewarm,
+    scheduleToolRuntimeWarmup,
     invokeChannelStart,
     scheduleChannelStart,
   };

package/src/session-runtime/provider-auth-api.mjs

@@ -31,6 +31,7 @@ export function createProviderAuthApi({
   refreshProviderCatalogs,
   cachedProviderSetup,
   getUsageDashboard,
+  consumeCodexRateLimitResetCredit,
   collectProviderModels,
 }) {
   function refreshProviderCatalogsSoon() {
@@ -79,6 +80,13 @@ export function createProviderAuthApi({
     async getUsageDashboard(options = {}) {
       return await getUsageDashboard(options);
     },
+    async consumeCodexRateLimitResetCredit(options = {}) {
+      await awaitKeychainPrewarm();
+      if (typeof consumeCodexRateLimitResetCredit !== 'function') {
+        throw new Error('Codex reset is unavailable');
+      }
+      return await consumeCodexRateLimitResetCredit(options);
+    },
     async authenticateProvider(providerId, secret) {
       await awaitKeychainPrewarm();
       const result = String(secret || '').trim()

package/src/session-runtime/provider-usage.mjs

@@ -14,6 +14,7 @@ export function createProviderUsage({
   providerSetup,
   createUsageDashboard,
   fetchOAuthUsageSnapshot,
+  consumeOpenAICodexResetCredit,
   isCloseRequested,
   getProviderSetupWarmupTimer,
   scheduleProviderSetupWarmup,
@@ -64,8 +65,9 @@ export function createProviderUsage({
   }
 
   async function getUsageDashboard(options = {}) {
-    const forceSetup = options?.force === true || options?.refresh === true;
-    if (!forceSetup && caches.usageDashboardCache.dashboard) {
+    const refreshUsage = options?.refresh === true;
+    const forceSetup = options?.force === true || (refreshUsage && options?.refreshSetup !== false);
+    if (!forceSetup && !refreshUsage && caches.usageDashboardCache.dashboard) {
       const cached = {
         ...caches.usageDashboardCache.dashboard,
         refresh: false,
@@ -78,7 +80,7 @@ export function createProviderUsage({
       }
       return cached;
     }
-    if (!forceSetup && caches.usageDashboardPromise) return await caches.usageDashboardPromise;
+    if (!forceSetup && !refreshUsage && caches.usageDashboardPromise) return await caches.usageDashboardPromise;
     const quickSetup = options?.quickSetup !== false;
     const getProvider = (providerId) => reg().getProvider(providerId);
     const log = (message) => {
@@ -98,16 +100,26 @@ export function createProviderUsage({
       });
     }
     const buildDashboard = async () => {
+      let setup;
+      try {
+        setup = await cachedProviderSetup({ force: forceSetup, quick: false });
+      } catch {
+        // One unavailable keychain/provider descriptor must not take down the
+        // whole dashboard. The no-secrets/no-local snapshot still lets cached
+        // and provider-native quota windows refresh.
+        log('provider setup failed; falling back to quick setup');
+        setup = await cachedProviderSetup({ force: forceSetup, quick: true });
+      }
       const dashboard = await createUsageDashboard(displayConfig(), {
         ...(options || {}),
-        setup: await cachedProviderSetup({ force: forceSetup, quick: false }),
+        setup,
         getProvider,
         log,
       });
       caches.usageDashboardCache = { dashboard, at: Date.now() };
       return dashboard;
     };
-    if (forceSetup) return await buildDashboard();
+    if (forceSetup || refreshUsage) return await buildDashboard();
     caches.usageDashboardPromise = buildDashboard()
       .finally(() => {
         caches.usageDashboardPromise = null;
@@ -115,6 +127,18 @@ export function createProviderUsage({
     return await caches.usageDashboardPromise;
   }
 
+  async function consumeCodexRateLimitResetCredit(options = {}) {
+    if (typeof consumeOpenAICodexResetCredit !== 'function') {
+      throw new Error('Codex reset is unavailable');
+    }
+    const providerObj = reg().getProvider('openai-oauth');
+    if (!providerObj) throw new Error('Codex is not signed in');
+    const result = await consumeOpenAICodexResetCredit(providerObj, options);
+    caches.usageDashboardCache = {};
+    const dashboard = await getUsageDashboard({ refresh: true, refreshSetup: false });
+    return { ...result, dashboard };
+  }
+
   return {
     refreshStatuslineUsageSnapshot,
     cachedProviderSetup,
@@ -122,5 +146,6 @@ export function createProviderUsage({
     // (settings hydration) can serve the quick snapshot until then.
     hasProviderSetupCached: () => Boolean(caches.providerSetupCache.setup),
     getUsageDashboard,
+    consumeCodexRateLimitResetCredit,
   };
 }

package/src/session-runtime/remote-control.mjs

@@ -10,8 +10,6 @@ export function createRemoteControl({
   setRemoteEnabled,
   getRemoteSessionId,
   setRemoteSessionId,
-  setRemoteClaimPending,
-  isRemoteClaimPending,
   isCloseRequested,
   clearChannelStartTimer,
   remoteTransitions,
@@ -28,22 +26,11 @@ export function createRemoteControl({
   bootProfile,
   envFlag,
 }) {
-  // FORCE-TAKEOVER for an explicit claim: it always (re)claims the seat and
-  // rebinds forwarding to this session, even when the worker already runs
-  // (`/remote` re-issued after another session took the seat).
-  function startRemote(options = {}) {
-    const intent = options?.intent === 'auto' ? 'auto' : 'explicit';
-    if (intent === 'auto') {
-      // Auto-start attempts a claim-if-vacant: remoteEnabled flips only when the
-      // worker reports it actually acquired the seat, so a live owner elsewhere
-      // leaves this session non-remote.
-      setRemoteClaimPending(true);
-    } else {
-      setRemoteEnabled(true);
-      // Explicit toggle: the CURRENT session owns the relay (lazy create adopts
-      // inside ensureRemoteTranscriptWriter when no session exists yet).
-      setRemoteSessionId(getSession()?.id || null);
-    }
+  // Manual ON always targets the current session and explicitly overrides any
+  // previous manual owner. There is no auto/claim-if-vacant path.
+  function startRemote() {
+    setRemoteEnabled(true);
+    setRemoteSessionId(getSession()?.id || null);
     // The worker forwards transcript ingests to the memory service, so its port
     // must be live before the first ingest.
     startMemoryDaemonEagerly({ getMemoryModule, bootProfile });
@@ -65,7 +52,6 @@ export function createRemoteControl({
         // boots the worker, which runs headless when messaging is off.
         if (!channelsEnabled() && !(await hasActiveAutomation().catch(() => false))) {
           bootProfile('channels:start-disabled');
-          setRemoteClaimPending(false);
           return isRemoteEnabled();
         }
         // A backend switch may still be writing; drain it before the worker
@@ -83,39 +69,16 @@ export function createRemoteControl({
         ensureRemoteTranscriptWriter();
         // Re-check after the awaits: stop/supersede or runtime close may have
         // landed mid-chain — never boot for a session that turned remote off.
-        if ((!isRemoteEnabled() && !isRemoteClaimPending()) || isCloseRequested()) {
-          setRemoteClaimPending(false);
-          return false;
-        }
-        // The fork reads process.env synchronously, so set the inherited intent
-        // immediately before it and restore right after: the pollution window is
-        // this fork instead of the whole boot chain.
-        const previousIntent = process.env.MIXDOG_REMOTE_INTENT;
-        try {
-          process.env.MIXDOG_REMOTE_INTENT = intent;
-          await invokeChannelStart();
-        } finally {
-          if (previousIntent === undefined) delete process.env.MIXDOG_REMOTE_INTENT;
-          else process.env.MIXDOG_REMOTE_INTENT = previousIntent;
-        }
-        if ((!isRemoteEnabled() && !isRemoteClaimPending()) || isCloseRequested()) {
-          setRemoteClaimPending(false);
-          return false;
-        }
-        // Explicit claims are unconditional; auto-start dispatches the same
-        // activation as claim-if-vacant so it promotes an automation-only daemon
-        // without stealing a live remote owner.
+        if (!isRemoteEnabled() || isCloseRequested()) return false;
+        await invokeChannelStart();
+        if (!isRemoteEnabled() || isCloseRequested()) return false;
         await channels.execute('activate_channel_bridge', {
           active: true,
-          claimIfVacant: intent === 'auto',
           sessionId: getSession()?.id || getRemoteSessionId() || null,
           transcriptPath: getTranscriptPath(),
         });
-        // The worker's acquire/supersede notification now owns the transition.
-        setRemoteClaimPending(false);
         return isRemoteEnabled();
       } catch (error) {
-        setRemoteClaimPending(false);
         if (isRemoteEnabled()) {
           setRemoteEnabled(false);
           setRemoteSessionId(null);
@@ -135,7 +98,6 @@ export function createRemoteControl({
     const releasingSessionId = getRemoteSessionId() || getSession()?.id || null;
     setRemoteEnabled(false);
     setRemoteSessionId(null);
-    setRemoteClaimPending(false);
     clearChannelStartTimer();
     return remoteTransitions.run(async () => {
       try {
@@ -156,7 +118,6 @@ export function createRemoteControl({
   function stopRemote(reason) {
     setRemoteEnabled(false);
     setRemoteSessionId(null);
-    setRemoteClaimPending(false);
     clearChannelStartTimer();
     channels.stop(reason || 'remote-disabled').catch(() => {});
     return true;

package/src/session-runtime/remote-transcript.mjs

@@ -17,7 +17,6 @@ export function createRemoteTranscript({
   isCloseRequested,
   channelsEnabled,
   channels,
-  mgr,
   bootProfile,
 }) {
   let writer = null;
@@ -36,9 +35,8 @@ export function createRemoteTranscript({
     flushPendingTranscriptRebind,
   };
 
-  // Bind (or refresh) the writer for the CURRENT session+cwd. The owner gate
-  // covers lazy create: an unset owner adopts this session, a LIVE owner blocks
-  // every other session, and a dead owner hands the relay over.
+  // Bind (or refresh) only the manually selected session. Session creation,
+  // close, or liveness never transfers Remote ownership.
   function ensureRemoteTranscriptWriter() {
     const session = getSession();
     if (!isRemoteEnabled() || !session?.id) return false;
@@ -46,9 +44,7 @@ export function createRemoteTranscript({
     if (!owner) {
       setRemoteSessionId(session.id);
     } else if (session.id !== owner) {
-      const ownerSession = mgr.getSession(owner);
-      if (ownerSession && ownerSession.closed !== true && ownerSession.status !== 'closed') return false;
-      setRemoteSessionId(session.id);
+      return false;
     }
     const cwd = getCwd();
     const key = `${session.id}\u0000${cwd}`;

package/src/session-runtime/route-preparation.mjs

@@ -0,0 +1,24 @@
+// One background route preparation can be associated with the currently
+// resumed session. Resume/navigation reads do not wait for it; the next real
+// turn does. Clearing replaces the visible gate without attempting to cancel
+// provider initialization that may already be shared elsewhere.
+export function createRoutePreparationGate({ onError } = {}) {
+  let pending = Promise.resolve();
+
+  return {
+    clear() {
+      pending = Promise.resolve();
+    },
+    start(task) {
+      const operation = Promise.resolve().then(task);
+      pending = operation;
+      // Keep the original rejecting promise for waiters while still marking a
+      // background failure as observed until a submit reaches the same gate.
+      void operation.catch((error) => onError?.(error));
+      return operation;
+    },
+    wait() {
+      return pending;
+    },
+  };
+}