mixdog 1.3.1 → 1.3.2

package/src/session-runtime/mcp-glue/initial-connect-gate.mjs

@@ -0,0 +1,57 @@
+// The turn gate on the initial MCP connect: a bounded wait, never a rejection.
+
+// Turn gate: await the in-flight INITIAL connect, bounded by both the global
+// server startup budget and the caller's TTFT grace. A server still
+// connecting after the grace flows through the existing late-tool deferred
+// announcement path unchanged.
+export async function awaitInitialConnect({ state, mcpClient, resolveEffectiveMcpServers }, maxWaitMs = undefined) {
+  const inFlight = state.mcpConnectInFlight;
+  if (!inFlight) return;
+  let budgetMs = 10000;
+  try {
+    // The gate must outlast the slowest enabled server's own startup budget;
+    // a server with its budget disabled (0) means the connect may never
+    // settle, so the whole gate is disabled (handled below).
+    const configs = Object.values(resolveEffectiveMcpServers().servers).filter((cfg) => cfg?.enabled !== false);
+    const budgets = (configs.length > 0 ? configs : [{}])
+      .map((cfg) => mcpClient.resolveMcpStartupTimeoutMs?.(cfg))
+      .filter((value) => Number.isFinite(value));
+    if (budgets.length > 0) budgetMs = budgets.includes(0) ? 0 : Math.max(...budgets);
+  } catch {
+    /* fall back to default budget */
+  }
+  if (maxWaitMs !== null && maxWaitMs !== undefined) {
+    const requestedMaxWaitMs = Number(maxWaitMs);
+    if (Number.isFinite(requestedMaxWaitMs) && requestedMaxWaitMs >= 0) {
+      budgetMs = Math.min(budgetMs, requestedMaxWaitMs);
+    }
+  }
+  // Budget disabled (0/off) = no per-server startup timeout, so the connect
+  // promise may never settle; never gate the turn on it — fall back to the
+  // legacy fire-and-forget behavior (late servers use the deferred path).
+  if (!(budgetMs > 0)) return;
+  let timer = null;
+  let expired = false;
+  const budget = new Promise((resolveBudget) => {
+    timer = setTimeout(() => {
+      expired = true;
+      resolveBudget();
+    }, budgetMs);
+  });
+  try {
+    // Follow replacement connects (a reconnect queued behind the captured
+    // run installs a new in-flight promise) inside ONE fixed deadline.
+    // Failures are already captured in state.mcpFailures, so rejections are
+    // swallowed: this gate must never reject the turn.
+    let current = inFlight;
+    while (current && !expired) {
+      await Promise.race([Promise.resolve(current).catch(() => {}), budget]);
+      if (expired) break;
+      // Let a queued reconnect install its promise before re-checking.
+      await Promise.race([new Promise((resolveTick) => setImmediate(resolveTick)), budget]);
+      current = state.mcpConnectInFlight;
+    }
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}

package/src/session-runtime/mcp-glue/server-connection.mjs

@@ -0,0 +1,71 @@
+// Connecting, disconnecting and reconciling individual MCP servers in the live
+// registry. The caller (connect.mjs) owns the serialization and the shared state.
+import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { ensurePluginServerData } from './plugin-servers.mjs';
+
+export function createServerConnection({
+  mcpClient,
+  state,
+  resolveEffectiveMcpServers,
+  getMcpScopeId,
+  scopeOptions,
+  applied,
+  fingerprint,
+  syncScopeRoot,
+}) {
+  // Connect/disconnect exactly one server in the live registry, leaving all
+  // others untouched. Used by the enable/disable toggle so a single-server
+  // change never triggers a full disconnectAll()/reconnect freeze. Only an
+  // explicit sign-in passes `login` ({ openBrowser }): every other connect is
+  // non-interactive and reports a server that needs one as sign-in required.
+  async function applyMcpServerConnection(name, enabled, servers = resolveEffectiveMcpServers().servers, login = null) {
+    const target = clean(name);
+    if (!target) return;
+    // Changing this server's state clears any stale failure record for it.
+    if (Array.isArray(state.mcpFailures)) {
+      state.mcpFailures = state.mcpFailures.filter((row) => row.name !== target);
+    }
+    const cfg = servers[target];
+    if (enabled === false || !cfg || cfg.enabled === false) {
+      applied().delete(target);
+      await mcpClient.disconnectMcpServer?.(target, scopeOptions());
+      return;
+    }
+    applied().set(target, fingerprint(cfg));
+    // Close-then-connect as one generation-guarded op: a shutdown landing
+    // between the close and the connect never resurrects the server.
+    try {
+      ensurePluginServerData(cfg);
+      await mcpClient.reconnectSingleMcpServer(
+        getMcpScopeId(),
+        target,
+        cfg,
+        login ? { interactive: true, openBrowser: login.openBrowser } : {}
+      );
+    } catch (error) {
+      const failure = { name: target, msg: error?.message || String(error) };
+      if (error?.authRequired) failure.authRequired = true;
+      const failures = Array.isArray(error?.failures) ? error.failures : [failure];
+      state.mcpFailures = [...(state.mcpFailures || []), ...failures];
+    }
+  }
+
+  // Bring the registry in line with the effective set: drop servers that are
+  // gone or disabled, (re)connect servers that are new or whose resolved
+  // config changed; untouched servers keep their connection.
+  async function reconcileServers() {
+    syncScopeRoot();
+    const { servers } = resolveEffectiveMcpServers();
+    const known = applied();
+    const drops = [...known.keys()].filter((name) => !servers[name] || servers[name].enabled === false);
+    const connects = Object.entries(servers)
+      .filter(([name, cfg]) => cfg?.enabled !== false && known.get(name) !== fingerprint(cfg))
+      .map(([name]) => name);
+    await Promise.allSettled([
+      ...drops.map((name) => applyMcpServerConnection(name, false, servers)),
+      ...connects.map((name) => applyMcpServerConnection(name, true, servers)),
+    ]);
+  }
+
+  return { applyMcpServerConnection, reconcileServers };
+}

package/src/session-runtime/media-api.mjs

@@ -41,8 +41,11 @@ export function createMediaApi() {
       });
       return { status: await module.getVoiceStatus(), error };
     },
-    async listMediaLanes() {
-      return (await lanes()).listMediaLanes();
+    // `budgetMs` (Studio) caps the per-lane catalog wait; slower lanes come
+    // back `catalogPending`. Capped so a caller cannot park the call.
+    async listMediaLanes(options) {
+      const budgetMs = Math.min(30_000, Math.max(0, Math.trunc(Number(options?.budgetMs) || 0)));
+      return (await lanes()).listMediaLanes({ budgetMs });
     },
     // The Studio's current selection is the runtime's default: a tool call
     // that omits lane/model follows it. Studio pushes on every settled change.

package/src/session-runtime/model-route/route-tuning.mjs

@@ -67,7 +67,10 @@ export function createRouteTuning(deps, persist) {
     },
     async setEffort(value) {
       const normalized = normalizeEffortInput(value);
-      setRouteState({ ...getRoute(), effort: normalized });
+      // An explicit level is the user's choice for this route: Auto effort
+      // would replace it on the next turn (its base is fixed), so the pick
+      // turns the route's Auto off until it is switched back on.
+      setRouteState({ ...getRoute(), effort: normalized, ...(normalized ? { autoEffort: false } : {}) });
       const modelMeta = await lookupModelMeta(getRoute().provider, getRoute().model);
       const fastCapable = selectionFastCapable(getRoute().provider, modelMeta, normalized, getRoute().modelParameters);
       await commitRouteTuning(fastCapable, modelMeta);

package/src/session-runtime/model-route/set-route.mjs

@@ -24,6 +24,11 @@ import {
 } from '../../runtime/agent/orchestrator/runtime-core/session-route-policy.mjs';
 import { rebuildToolSurfaceForProviderWithMigration } from '../../runtime/agent/orchestrator/session/loop/tool-exposure-migration.mjs';
 import { UNOWNED_LEASE, openRouteLease } from './route-ownership.mjs';
+import { resolveSessionMode } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
+import { ownerRouteFallbacks } from '../../runtime/agent/orchestrator/session/manager/owner-route-fallbacks.mjs';
+import { normalizeWorkflowRoute } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
+import { routeChain, validateRouteChainProviders } from '../../runtime/shared/model-route-chain.mjs';
+import { resolveChainEntry } from '../workflow-agents-api/agent-route.mjs';
 
 /** The request, completed from the live route where the caller left gaps. */
 function completeRequest(deps, next) {
@@ -105,6 +110,32 @@ async function recreateEmptySession(deps, lease) {
   if (closed) await createCurrentSession('model-switch-empty');
 }
 
+/** The fallback chain a Lead-class session follows on `route`: its owner's chain
+ *  while the route is the owner's primary model, none otherwise (see
+ *  owner-route-fallbacks.mjs). Nothing for an agent's session, which keeps its own. */
+export function sessionRouteFallbackFields(deps, session, route) {
+  const { mode, agentId } = resolveSessionMode({ session });
+  if (!agentId) return {};
+  return {
+    routeFallbacks: ownerRouteFallbacks({
+      sessionMode: mode,
+      agentId,
+      provider: route.provider,
+      model: route.model,
+      config: deps.getConfig(),
+    }),
+  };
+}
+
+/** A same-model selection (a bot profile saved with new fallbacks) restarts the
+ *  addressed session's chain when the owner's chain no longer matches it. */
+function refreshSessionFallbacks(deps, session) {
+  const fields = sessionRouteFallbackFields(deps, session, deps.getRoute());
+  if (!fields.routeFallbacks) return;
+  if (JSON.stringify(fields.routeFallbacks) === JSON.stringify(session.routeFallbacks || [])) return;
+  deps.mgr.updateSessionRoute?.(session.id, fields, { session });
+}
+
 /** Rewrite the addressed empty session to the route it was asked to run on. */
 function updateSessionInPlace(deps, session, updateOptions) {
   const { getRoute, getSession, setSession, mgr, statusRoutes } = deps;
@@ -119,6 +150,7 @@ function updateSessionInPlace(deps, session, updateOptions) {
     contextPercent: route.contextPercent,
     contextTokens: route.contextTokens || null,
     selectedContextWindow: route.selectedContextWindow || null,
+    ...sessionRouteFallbackFields(deps, session, route),
   };
   const updated = mgr.updateSessionRoute?.(session.id, fields, updateOptions);
   if (updated) setSession(updated);
@@ -183,6 +215,27 @@ function switchSessionInPlace(deps, session) {
   return recorded ? boundary : null;
 }
 
+/** The Lead's fallback models after this selection, checked like an agent's
+ *  chain (leaf routes, distinct providers): an explicit list replaces the
+ *  stored one ([] clears it), a selection without one keeps it. */
+async function leadFallbackChain(deps, next, primary) {
+  const storedPreset = findPreset(deps.getConfig(), workflowPresetId('lead'));
+  const requested = hasOwn(next || {}, 'fallbacks') ? next.fallbacks : storedPreset?.fallbacks;
+  if (!Array.isArray(requested) || !requested.length) return [];
+  const chain = routeChain({ provider: primary.provider, model: primary.model, fallbacks: requested });
+  validateRouteChainProviders(chain);
+  const storedChain = routeChain(storedPreset || {});
+  // Each entry goes through the agents' normalizer (fast clamp, context window).
+  const resolved = [];
+  for (const entry of chain.slice(1)) {
+    const previous = storedChain.find((c) => c.provider === entry.provider && c.model === entry.model);
+    resolved.push(await resolveChainEntry(deps, entry, previous || {}));
+  }
+  return (
+    normalizeWorkflowRoute({ provider: primary.provider, model: primary.model, fallbacks: resolved })?.fallbacks || []
+  );
+}
+
 /** Validate, persist and adopt the requested route as the runtime's route. */
 async function adoptRoute(deps, persist, next, options, lease) {
   const {
@@ -195,6 +248,12 @@ async function adoptRoute(deps, persist, next, options, lease) {
     scheduleStatuslineUsageRefresh,
   } = deps;
   const { selectedRoute, fastCapable, modelMeta } = await resolveSelectedRoute(deps, next);
+  // The Lead's fallback chain travels with an explicit main-model choice only
+  // (the Lead editor, the setup tool); a session's own pick never touches it.
+  const persistedRoute =
+    options?.keepMainModel === false && options?.sessionOnly !== true
+      ? { ...selectedRoute, fallbacks: await leadFallbackChain(deps, next, selectedRoute) }
+      : selectedRoute;
   // The Lead route a conditional fill wrote, until the file confirms it.
   let filled = null;
   // Provider readiness may outlast the session the selection was made for.
@@ -222,7 +281,7 @@ async function adoptRoute(deps, persist, next, options, lease) {
         // The main model changes only on an explicit main-model choice
         // (keepMainModel: false, e.g. the setup tool); every other selection
         // — the session surface's model pick, an heir — keeps it.
-        const leadRoute = persist.persistAdoptedModelSettings(selectedRoute, {
+        const leadRoute = persist.persistAdoptedModelSettings(persistedRoute, {
           keepMainModel: options?.keepMainModel !== false,
           onlyIfAbsent: options?.onlyIfEmpty === true,
         });
@@ -340,6 +399,7 @@ export function createSetRoute(deps, persist) {
         return modelSwitch ? { ...getRoute(), modelSwitch } : getRoute();
       }
       persist.applySessionTuning();
+      refreshSessionFallbacks(deps, session);
       return getRoute();
     }
     // An addressed runtime keeps its durable id: the empty session is updated

package/src/session-runtime/owned-automation-run.mjs

@@ -101,7 +101,7 @@ async function queueResult(row, item, entry, { deliver, recordDelivery, onDelive
 /**
  * `row` is `{ name, ownerAgentId }`; `run({ signal })` resolves `{ sessionId,
  * result }` (`signal` is the caller's cancellation, if any). Resolves the
- * outcome, or `{ skipped: true, reason: 'owner' | 'overlap' | 'backoff' }`
+ * outcome, or `{ skipped: true, reason: 'owner' | 'overlap' | 'backoff' | 'paused' }`
  * (an owner skip also names `ownerProblem` and its `message`); a failed run
  * rejects.
  */
@@ -141,6 +141,13 @@ export async function runOwnedAutomation(kind, row, run, deps = {}) {
       const state = await Promise.resolve()
         .then(() => record.state(name))
         .catch(() => null);
+      // Switched off (by the user, or by the failure limit): the cron claim and
+      // the webhook handler already refuse it, but a one-shot timer or a
+      // dispatch that raced the pause must not run it either.
+      if (state?.enabled === false) {
+        log(`${kind} "${name}": skipped, switched off`);
+        return await skip('paused');
+      }
       const wait = routineBackoffRemaining(state, now(), limits);
       if (wait > 0) {
         log(`${kind} "${name}": skipped, backing off ${Math.ceil(wait / 1000)}s after failures in a row`);

package/src/session-runtime/room-member-gate.mjs

@@ -2,6 +2,9 @@
 // anything that can change files or state asks the user through the ordinary
 // approval flow, whatever the agent's own permission or hook rules say — even
 // an agent that normally runs auto-approved. A hook's deny still wins.
+// Opening a task session (`session create`) runs as freely as in the agent's
+// home thread: it changes nothing itself, and the task session is the user's
+// own coding Lead, whose every side effect follows its usual approval rules.
 import { analyzeShellCommandEffects } from '../runtime/agent/orchestrator/tools/builtin/shell-analysis.mjs';
 
 const READ_ONLY_TOOLS = new Set([
@@ -37,12 +40,22 @@ export async function isReadOnlyRoomCall({ name, args, cwd }, analyze = analyzeS
   }
 }
 
+/** Whether `name(args)` opens a task session (session create). */
+export function isTaskSessionCreate({ name, args }) {
+  return (
+    name === 'session' &&
+    String(args?.action ?? '')
+      .trim()
+      .toLowerCase() === 'create'
+  );
+}
+
 /** The PreToolUse decision for a room member's call: the hook's own `decision`
- *  when it denies or the call only reads; otherwise an approval ask that keeps
- *  any rewrite the hook made. */
+ *  when it denies, the call only reads, or it opens a task session; otherwise
+ *  an approval ask that keeps any rewrite the hook made. */
 export async function roomMemberToolDecision(call, decision, analyze) {
   const action = String(decision?.action || decision?.decision || '').toLowerCase();
   if (action === 'deny' || action === 'block') return decision;
-  if (await isReadOnlyRoomCall(call, analyze)) return decision;
+  if (isTaskSessionCreate(call) || (await isReadOnlyRoomCall(call, analyze))) return decision;
   return { ...(decision && typeof decision === 'object' ? decision : {}), action: 'ask', reason: ROOM_APPROVAL_REASON };
 }

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

@@ -22,6 +22,10 @@ export function createRouteResolution({ rt, collectProviderModels, ensureProvide
     if (routeHasModel()) return rt.route;
     const models = await runAbortable(signal, () => collectProviderModels());
     throwIfAborted(signal);
+    // A model chosen during the catalog read stands: a new task's reservation
+    // prewarm starts on the empty route, its draft model lands meanwhile, and
+    // the first prompt joins this very prewarm.
+    if (routeHasModel()) return rt.route;
     if (!models?.length) {
       throw new Error('No provider models available. Open /providers to sign in, then /model to choose a model.');
     }
@@ -47,15 +51,19 @@ export function createRouteResolution({ rt, collectProviderModels, ensureProvide
       .find((option) => option?.id === 'context')
       ?.options?.find((option) => clean(option?.value) === contextValue);
     const modelDisplay = routeModelDisplay(rt.config, targetRoute, modelMeta);
-    const selectedContextWindow = [contextState.selectedContextWindow, contextOption?.contextWindow]
+    // Without a known window the selection (share, exact tokens, resolved
+    // window) is kept as requested — the session sizes it from the provider's
+    // window; dropping it silently put the route back on the model's default.
+    // With one it is the clamped value, absent when it is the default window.
+    const windowKnown = contextState.contextDefaultPercent !== undefined;
+    const selectedContextWindow = [
+      contextState.selectedContextWindow,
+      contextOption?.contextWindow,
+      windowKnown ? undefined : targetRoute.selectedContextWindow,
+    ]
       .map(Number)
       .find((value) => value > 0);
-    // Without a known window the exact selection is kept as requested; with
-    // one it is the clamped value, absent when it is the default window.
-    const contextTokens =
-      contextState.contextDefaultPercent === undefined
-        ? normalizeContextTokens(targetRoute.contextTokens)
-        : contextState.contextTokens;
+    const contextTokens = windowKnown ? contextState.contextTokens : normalizeContextTokens(targetRoute.contextTokens);
     const { contextTokens: _requestedTokens, ...routeFields } = targetRoute;
     rt.route = {
       ...routeFields,
@@ -63,7 +71,7 @@ export function createRouteResolution({ rt, collectProviderModels, ensureProvide
       fastCapable,
       effectiveEffort,
       effortOptions: effortItemsFor(rt.route.provider, modelMeta, effectiveEffort),
-      contextPercent: contextState.contextPercent,
+      contextPercent: windowKnown ? contextState.contextPercent : targetRoute.contextPercent,
       contextDefaultPercent: contextState.contextDefaultPercent,
       ...(contextTokens ? { contextTokens } : {}),
       ...(selectedContextWindow ? { selectedContextWindow } : {}),

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

@@ -7,8 +7,6 @@ import {
 import { clean, hasOwn } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { coerceEffortFor } from '../runtime/agent/orchestrator/runtime-core/effort.mjs';
 import { fastCapableFor } from '../runtime/agent/orchestrator/runtime-core/model-capabilities.mjs';
-import { providerCachedModelMetadataSync } from '../runtime/agent/orchestrator/providers/provider-catalog-cache.mjs';
-import { contextWindowRange, normalizeContextTokens } from '../runtime/shared/llm/default-context-window.mjs';
 
 export function resolveRouteEffortState(targetRoute = {}, modelMeta = null) {
   const requested = hasOwn(targetRoute, 'effort') ? targetRoute.effort : targetRoute.preset?.effort || null;
@@ -36,63 +34,7 @@ export function selectionFastCapable(provider, modelMeta, effort, modelParameter
   return !modelMetaLooksResolved(modelMeta) || fastCapableFor(provider, modelMeta, effort, modelParameters);
 }
 
-// The persisted provider model rows are the SAME source the picker sized its
-// slider against, so they carry both windows (openai-oauth: 272k default /
-// 1M max). Reading them keeps a percentage saved against the picker's scale
-// meaningful; anything that only knows a single window would silently rescale
-// it (30% of 272k instead of 30% of 1M).
-function cachedRouteWindows(provider, model) {
-  const row = providerCachedModelMetadataSync(provider, model)?.rawProviderModel || null;
-  if (!row) return null;
-  const contextWindow = Number(row.contextWindow ?? row.context_window ?? row.max_input_tokens) || 0;
-  const maxContextWindow = Number(row.maxContextWindow ?? row.max_context_window) || 0;
-  return contextWindow > 0 || maxContextWindow > 0 ? { contextWindow, maxContextWindow } : null;
-}
-
-export function resolveRouteContextState(targetRoute = {}, modelMeta = null, windowLookup = cachedRouteWindows) {
-  // Only providers that implement getCachedModelInfo (openai-oauth, cursor,
-  // openai-compat, opencode-go) hand lookupModelMeta a window; every other one
-  // (anthropic-oauth, grok-oauth, gemini, …) gets the bare `{ id, provider }`
-  // placeholder. Reading the window from that alone yields 0, which dropped the
-  // saved context percentage for the entire session — while resolveSessionContextMeta
-  // went on to size that session from the provider/catalog window (Claude Opus 5:
-  // a full 1M rather than the selected 500k). Read the cached provider row here so
-  // the percentage and the session boundary cannot disagree.
-  const windowMeta =
-    Number(modelMeta?.contextWindow) > 0 || Number(modelMeta?.maxContextWindow) > 0
-      ? modelMeta
-      : windowLookup?.(clean(targetRoute?.provider), clean(targetRoute?.model)) || modelMeta;
-  const { defaultWindow, maxWindow } = contextWindowRange({
-    provider: clean(targetRoute?.provider),
-    contextWindow: windowMeta?.contextWindow,
-    maxContextWindow: windowMeta?.maxContextWindow,
-  });
-  if (!maxWindow) {
-    return { contextPercent: undefined, contextDefaultPercent: undefined, selectedContextWindow: undefined };
-  }
-  const contextDefaultPercent = Math.max(10, Math.min(100, Math.round((defaultWindow / maxWindow) * 10) * 10));
-  // An exact token selection overrides the 10% stops. It is clamped to the
-  // selectable range; one that lands on the default window is the default.
-  const requestedTokens = normalizeContextTokens(targetRoute?.contextTokens);
-  if (requestedTokens) {
-    const contextTokens = Math.max(Math.ceil(maxWindow * 0.1), Math.min(maxWindow, requestedTokens));
-    if (contextTokens === defaultWindow) {
-      return { contextPercent: contextDefaultPercent, contextDefaultPercent, selectedContextWindow: defaultWindow };
-    }
-    const contextPercent = Math.max(10, Math.min(100, Math.round((contextTokens / maxWindow) * 10) * 10));
-    return { contextPercent, contextDefaultPercent, selectedContextWindow: contextTokens, contextTokens };
-  }
-  const requested = Number(targetRoute?.contextPercent);
-  const contextPercent =
-    Number.isFinite(requested) && requested > 0
-      ? Math.max(10, Math.min(100, Math.round(requested / 10) * 10))
-      : contextDefaultPercent;
-  const selectedContextWindow =
-    contextPercent === contextDefaultPercent
-      ? defaultWindow
-      : Math.max(1, Math.floor((maxWindow * contextPercent) / 100));
-  return { contextPercent, contextDefaultPercent, selectedContextWindow };
-}
+export { resolveRouteContextState } from '../runtime/agent/orchestrator/runtime-core/route-context-state.mjs';
 
 /**
  * Human label for the statusline. A display-only user alias

package/src/session-runtime/routine-home-turn.mjs

@@ -9,8 +9,10 @@
  * it rides the thread's queue as its own `routine` entry (one per turn, never
  * merged or steered into another), shows as a routine marker row, and selects
  * skills only from the routine's instructions (`skillSelection`), never from a
- * webhook payload. While it runs the thread counts as unattended, so its
- * approvals are held for the owner (held-requests.mjs). Resolves with the
+ * webhook payload. While it runs the thread counts as an unattended run
+ * (held-requests.mjs): the saved routine is the user's grant, so it never asks
+ * (outbound actions are allowed within the bot's permissions; payments and
+ * permanent deletes are refused, human-gate/run-policy.mjs). Resolves with the
  * reply once the turn ends; rejects when the turn fails, is cancelled, or the
  * caller's `signal` aborts (which also aborts the turn once it runs).
  */
@@ -126,7 +128,7 @@ export async function runRoutineTurn(
       onCommitted: () => {
         if (started) return;
         started = true;
-        // Nobody watches this turn: its approvals are held for the owner.
+        // Nobody watches this turn: it never asks (run-policy.mjs).
         unmark = markUnattendedRun(homeId, { kind, agentId, name });
         if (aborted) void abortTurn();
       },

package/src/session-runtime/runtime-bootstrap.mjs

@@ -13,22 +13,24 @@ import {
   CODE_GRAPH_TOOL_DEFS,
   STATUSLINE_SESSION_ROUTES,
   STANDALONE_ROOT,
-  STANDALONE_DATA_DIR,
+  standaloneDataDir,
 } from './runtime-paths.mjs';
 
 export function prepareStandaloneEnvironment() {
   process.env.MIXDOG_QUIET_SESSION_LOG ??= '1';
   const startedAt = performance.now();
+  // Resolved per runtime start: this start's data folder, not the first one's.
+  const dataDir = standaloneDataDir();
   ensureStandaloneEnvironment({
     rootDir: STANDALONE_ROOT,
-    dataDir: STANDALONE_DATA_DIR,
+    dataDir,
   });
   // Office journals exist only for cross-process crash recovery, so startup just
   // prunes expired ones in the background. Surfacing them as session context made
   // every new session (agents included) re-announce unrelated leftovers for the
   // full 30-day retention window; recovery stays reachable on demand through
   // office action=transactions / action=recover.
-  listOfficeJournals(STANDALONE_DATA_DIR).catch(() => {});
+  listOfficeJournals(dataDir).catch(() => {});
   bootProfile('standalone-env:ready', { ms: (performance.now() - startedAt).toFixed(1) });
 }
 

package/src/session-runtime/runtime-paths.mjs

@@ -1,6 +1,6 @@
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { resolvePluginData } from '../runtime/shared/plugin-paths.mjs';
 
 export const RUNTIME = '../runtime/agent/orchestrator';
 export const WEB_SEARCH_RUNTIME = '../runtime/web-search/index.mjs';
@@ -12,10 +12,16 @@ export const STATUSLINE_SESSION_ROUTES = '../vendor/statusline/src/gateway/sessi
 
 const SESSION_RUNTIME_DIR = dirname(fileURLToPath(import.meta.url));
 export const STANDALONE_ROOT = dirname(SESSION_RUNTIME_DIR);
-const mixdogHome = process.env.MIXDOG_HOME || join(homedir(), '.mixdog');
-export const STANDALONE_DATA_DIR = process.env.MIXDOG_DATA_DIR || join(mixdogHome, 'data');
+
+/**
+ * The standalone data directory, resolved from the environment on every call.
+ * A runtime start (a pristine boundary, a second page session) retargets
+ * MIXDOG_DATA_DIR, so a load-time constant would point every later start back
+ * at the first run's folder.
+ */
+export const standaloneDataDir = resolvePluginData;
 
 /** The data directory a runtime writes to: its config module's plugin data dir, else the standalone default. */
 export function pluginDataDir(cfgMod) {
-  return cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
+  return cfgMod.getPluginData?.() || standaloneDataDir();
 }

package/src/session-runtime/runtime-tunables.mjs

@@ -36,6 +36,12 @@ export function readRuntimeTunables() {
     // connected tools fold synchronously; in-flight servers join through the
     // late-tool announcement path. Operators may opt back into a grace window.
     mcpTurnGraceMs: envDelayMs('MIXDOG_MCP_TURN_GRACE_MS', 0, { min: 0, max: 2_000 }),
+    // A spawned agent's first turn may be its only one, so it waits for the
+    // initial connect — but only this long: a slow-but-alive server (a
+    // 20 s handshake is seen in the wild) must not hold the first model
+    // request for its whole startup budget. Later servers join through the
+    // late-tool announcement path on the agent's next turn.
+    mcpAgentGraceMs: envDelayMs('MIXDOG_MCP_AGENT_GRACE_MS', 3_000, { min: 0, max: 30_000 }),
     // Boot-time remote start is deferred past the first frame; see the caller.
     remoteAutoStartDelayMs: envDelayMs('MIXDOG_REMOTE_AUTOSTART_DELAY_MS', 1_500, { min: 0, max: 60_000 }),
     providerWarmupEnabled:

package/src/session-runtime/services/agent-tool/close-flow/close-all.mjs

@@ -5,6 +5,7 @@ import { cancelBackgroundTask, listBackgroundTasks } from '../../../../runtime/s
 import { presentErrorText } from '../../../../runtime/shared/err-text.mjs';
 import { clean } from '../helpers.mjs';
 import { isLeadPoolAgent } from '../worker-rows.mjs';
+import { isUnnotifiedRestartFailure } from '../worker-index/row-liveness.mjs';
 
 export function createCloseAll({ registry, close }) {
   const { tags, tagAgents, tagCwds } = registry;
@@ -17,11 +18,13 @@ export function createCloseAll({ registry, close }) {
 
   // Drop the closed workers' rows: every non-Lead row for an unscoped
   // teardown, only this owner's (plus the rows just closed) for a scoped one.
+  // A row whose owner is still owed its restart failure stays (a process exit
+  // closes every worker; the next process tells the owner).
   function purgeWorkerRows(ownerSessionId, closedSessionIds) {
     registry.flushWorkerIndexMutations();
     registry.writeWorkerRows((byKey, tombstonesByKey) => {
       for (const [key, row] of [...byKey.entries()]) {
-        if (isLeadPoolAgent(row.agent)) continue;
+        if (isLeadPoolAgent(row.agent) || isUnnotifiedRestartFailure(row)) continue;
         if (
           ownerSessionId &&
           clean(row.ownerSessionId) !== ownerSessionId &&
@@ -38,15 +41,20 @@ export function createCloseAll({ registry, close }) {
   // Lead's workers: the worker index and task registry are shared by every
   // Lead in the process, and an unscoped sweep wiped sibling Leads' idle
   // workers mid-window.
+  // A process exit (`scope.processExit`) closes the workers but keeps their
+  // rows: the next process lists the finished ones for their pane window and
+  // settles the ones the exit cut off (restart-notify), exactly as after a
+  // crash. Dropping them emptied every sub-agent list after a daemon restart.
   return async function closeAll(reason = 'cli-agent-close-all', scope = {}) {
     const ownerSessionId = clean(scope.callerSessionId);
+    const keepRows = scope.processExit === true;
     const context = ownerSessionId ? { callerSessionId: ownerSessionId } : {};
     registry.refreshTagsFromSessions({ scanSessions: false, context });
     const closed = [];
     const failed = [];
     for (const { tag, session } of registry.agentSessionEntries({ scanSessions: false, context })) {
       try {
-        closed.push(await close({ sessionId: session.id }, context));
+        closed.push(await close({ sessionId: session.id }, context, { keepRow: keepRows }));
       } catch (err) {
         failed.push({ tag, error: presentErrorText(err, { surface: 'agent' }) });
       }
@@ -57,6 +65,7 @@ export function createCloseAll({ registry, close }) {
       closed.push({ closed: true, tag: task.tag || null, sessionId: task.sessionId || null, task_id: task.task_id });
     }
     if (!ownerSessionId) resetLocalTagState();
+    if (keepRows) return { closed, failed };
     const closedSessionIds = new Set(closed.map((row) => clean(row.sessionId)).filter(Boolean));
     purgeWorkerRows(ownerSessionId, closedSessionIds);
     return { closed, failed };

package/src/session-runtime/services/agent-tool/close-flow.mjs

@@ -37,7 +37,9 @@ export function createCloseFlow({ mgr, registry, views }) {
     }
   }
 
-  async function close(args, context = {}) {
+  /** `keepRow`: a process exit closes the worker but leaves its row (and its
+   *  descendants') for the next process (close-all.mjs). */
+  async function close(args, context = {}, { keepRow = false } = {}) {
     const scopedContext = agentScope(args, context);
     registry.refreshTagsFromSessions({ scanSessions: registry.wantsSessionScan(args), context: scopedContext });
     const taskId = taskIdFromArgs(args);
@@ -73,7 +75,7 @@ export function createCloseFlow({ mgr, registry, views }) {
     if (task?.taskId) cancelBackgroundTask(task.taskId, CLOSE_REASON);
     // Drop the row only once the cancellation is DURABLY recorded: a failed
     // close that still forgot the row would leave no cancelled state behind.
-    if (ok) {
+    if (ok && !keepRow) {
       registry.forgetTerminalSession(tag, sessionId);
       for (const descendantSessionId of descendantSessionIds) {
         registry.removeWorkerRow({ sessionId: descendantSessionId });

package/src/session-runtime/services/agent-tool/execute-send.mjs

@@ -70,6 +70,7 @@ export function createSendDispatch({ registry, defaultCwd, sendFlow, spawnFlow,
   async function send(args, { scopedContext, callerCwd, context, notifyContext }) {
     try {
       const prepared = await sendFlow.prepareSend(args, scopedContext);
+      await sendFlow.adoptCaller(prepared, notifyContext);
       return sendFlow.dispatchToExistingSession(prepared, notifyContext);
     } catch (err) {
       return await respawnDeadTagSend(err, args, { callerCwd, context, notifyContext });

package/src/session-runtime/services/agent-tool/execute-spawn.mjs

@@ -51,6 +51,7 @@ export function createSpawnDispatch({
     }
     if (liveSessionId && registry.getLiveSession(liveSessionId)) {
       const prepared = await sendFlow.prepareSend({ ...args, tag: explicitTag }, scopedContext);
+      await sendFlow.adoptCaller(prepared, notifyContext);
       const route = requestedRoute(args);
       return {
         reused: sendFlow.dispatchToExistingSession(route ? { ...prepared, route } : prepared, notifyContext, {