mixdog 1.0.11 → 1.1.0

package/src/session-runtime/provider-models/catalog-load.mjs

@@ -92,8 +92,10 @@ export function createCatalogLoader({
       const key = `${row.provider}:${row.id}`;
       if (seen.has(key)) continue;
       seen.add(key);
-      results.push(row);
       if (meta.snapshotIsCurrent(revision, seq)) meta.remember(row.provider, row.id, row);
+      // A hidden custom model leaves the picker; its metadata still resolves
+      // for sessions and saved routes already on it.
+      if (row.hidden !== true) results.push(row);
     }
     profile('load:done', {
       ms: (performance.now() - startedAt).toFixed(1),

package/src/session-runtime/provider-models/row-hydration.mjs

@@ -3,32 +3,58 @@
 // settings (alias, effort, fast, parameters, context budget) layered on top,
 // then the route-provider-first sort.
 import { effortItemsFor } from '../../runtime/agent/orchestrator/runtime-core/effort.mjs';
-import { fastCapableFor, fastPreferenceFor } from '../../runtime/agent/orchestrator/runtime-core/model-capabilities.mjs';
+import {
+  fastCapableFor,
+  fastPreferenceFor,
+  ultrafastCapableFor,
+} from '../../runtime/agent/orchestrator/runtime-core/model-capabilities.mjs';
 import { modelSettingsFor } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
-import { effortConfigurationMode } from '../../runtime/agent/orchestrator/providers/effort-configuration.mjs';
+import {
+  customAutoEffortCapable,
+  effortConfigurationMode,
+} from '../../runtime/agent/orchestrator/providers/effort-configuration.mjs';
 import { getProvider } from '../../runtime/agent/orchestrator/providers/registry.mjs';
 
+const ULTRAFAST_SPEED_OPTION = Object.freeze({
+  id: 'serviceTier',
+  label: 'Speed',
+  kind: 'enum',
+  options: [
+    { value: 'priority', label: 'Fast' },
+    { value: 'ultrafast', label: 'Ultrafast' },
+  ],
+});
+
 export function hydrateProviderModelRow(cfg, row) {
   const saved = modelSettingsFor(cfg, row.provider, row.id);
   // Display-only user alias (modelSettings["provider/model"].alias). It
   // replaces the label everywhere the row's `display` is shown; the id and
   // route selection are untouched.
   const alias = typeof saved.alias === 'string' ? saved.alias.trim() : '';
+  const fastCapable = fastCapableFor(row.provider, row);
+  const existingOptions = Array.isArray(row.modelParameterOptions) ? row.modelParameterOptions : [];
+  const modelParameterOptions =
+    fastCapable && ultrafastCapableFor(row.provider, row)
+      ? [...existingOptions.filter((option) => option?.id !== ULTRAFAST_SPEED_OPTION.id), ULTRAFAST_SPEED_OPTION]
+      : row.modelParameterOptions;
   return {
     ...row,
     ...(alias ? { display: alias, displayAlias: alias } : {}),
+    ...(modelParameterOptions ? { modelParameterOptions } : {}),
     effortOptions: effortItemsFor(row.provider, row, null),
-    fastCapable: fastCapableFor(row.provider, row),
+    fastCapable,
     fastPreferred: Object.hasOwn(saved, 'fast')
       ? saved.fast === true
       : row.defaultFast === true || fastPreferenceFor(cfg, row.provider, row.id),
-    // Auto effort only changes effort where that keeps the prompt cache.
-    autoEffortCapable: Boolean(
-      effortConfigurationMode(row.provider, row.id, {
-        ...(getProvider(row.provider)?.config || {}),
-        modelParameters: saved.modelParameters || {},
-      })
-    ),
+    // Auto effort only changes effort where that keeps the prompt cache, or
+    // per request on a custom Chat/Responses model that declares levels.
+    autoEffortCapable:
+      Boolean(
+        effortConfigurationMode(row.provider, row.id, {
+          ...(getProvider(row.provider)?.config || {}),
+          modelParameters: saved.modelParameters || {},
+        })
+      ) || customAutoEffortCapable(row.provider, cfg?.providers?.[row.provider]?.protocol, row),
     savedEffort: saved.effort || null,
     savedFast: Object.hasOwn(saved, 'fast') ? saved.fast === true : undefined,
     savedModelParameters: saved.modelParameters || {},

package/src/session-runtime/quick-model-rows/model-meta.mjs

@@ -2,6 +2,31 @@
 // model record filled from it.
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { getModelMetadataSync } from '../../runtime/agent/orchestrator/providers/model-catalog.mjs';
+import { isCustomProviderName } from '../../runtime/agent/orchestrator/providers/custom-reasoning.mjs';
+
+const CUSTOM_DECLARED_FIELDS = [
+  'supportsReasoning',
+  'reasoningOptions',
+  'reasoningLevels',
+  'reasoningContentField',
+  'hidden',
+  'manual',
+  'customReasoning',
+];
+
+/** A custom provider's effective row is authoritative: every contract field it
+ *  states (an explicit [] or false included) wins over catalog metadata, and
+ *  declared levels are not overridden by catalog effort options. First-party
+ *  rows get nothing here. */
+export function declaredCustomFields(provider, model) {
+  if (!isCustomProviderName(provider) || !model || typeof model !== 'object') return {};
+  const out = {};
+  for (const key of CUSTOM_DECLARED_FIELDS) {
+    if (Object.hasOwn(model, key) && model[key] !== undefined) out[key] = model[key];
+  }
+  if (Object.hasOwn(out, 'reasoningLevels') && !Object.hasOwn(out, 'reasoningOptions')) out.reasoningOptions = [];
+  return out;
+}
 
 export function metadataFor(provider, modelId) {
   try {
@@ -28,5 +53,6 @@ export function hydratedModel(provider, model = {}) {
         ? base.reasoningOptions
         : meta.reasoningOptions || [],
     reasoningContentField: base?.reasoningContentField || meta.reasoningContentField || null,
+    ...declaredCustomFields(provider, base),
   };
 }

package/src/session-runtime/quick-model-rows/provider-rows.mjs

@@ -3,7 +3,27 @@
 // workflow and agent routes), deduplicated per provider:model.
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { providerCachedModelsSync } from '../../runtime/agent/orchestrator/providers/provider-catalog-cache.mjs';
-import { metadataFor } from './model-meta.mjs';
+import {
+  effectiveCustomModelRows,
+  normalizeCustomProviderConfig,
+} from '../../runtime/agent/orchestrator/providers/custom-provider.mjs';
+import { declaredCustomFields, metadataFor } from './model-meta.mjs';
+
+// A custom provider's picker models: its effective rows (discovered + saved
+// overrides + manual models), read from the v2 config; a legacy `models`
+// config is migrated by the normalizer. A config that does not normalize
+// cannot run, so it lists nothing. `discovered` defaults to the cached catalog;
+// a saved route on an uncached model passes its own row so the same overrides
+// (hidden, metadata, reasoning) apply to it as in the full catalog.
+function customProviderModels(provider, providerConfig, discovered = providerCachedModelsSync(provider)) {
+  let config;
+  try {
+    config = normalizeCustomProviderConfig(providerConfig);
+  } catch {
+    return [];
+  }
+  return effectiveCustomModelRows(config, discovered, { providerId: provider });
+}
 
 export function createQuickProviderRows({
   getRoute,
@@ -39,16 +59,19 @@ export function createQuickProviderRows({
         reasoningOptions: model.reasoningOptions?.length ? model.reasoningOptions : meta.reasoningOptions || [],
         reasoningContentField: model.reasoningContentField || meta.reasoningContentField || null,
         mode: model.mode || meta.mode || 'chat',
+        ...declaredCustomFields(provider, model),
       });
-      rows.push(row);
       modelMetaByRoute.set(modelMetaKey(provider, modelId), row);
+      // A hidden model leaves the picker (a saved route on it included) while
+      // its metadata keeps resolving for sessions already on it.
+      if (row.hidden !== true) rows.push(row);
     };
     const addRoute = (routeLike = {}) => {
       const provider = clean(routeLike.provider);
       const model = clean(routeLike.model);
       if (!provider || !model || isDeletedCustom(provider)) return;
       const meta = metadataFor(provider, model);
-      addModel(provider, {
+      const routeRow = {
         id: model,
         name: routeLike.modelDisplay || routeLike.display || model,
         display: routeLike.modelDisplay || routeLike.display || model,
@@ -61,7 +84,14 @@ export function createQuickProviderRows({
         reasoningOptions: meta.reasoningOptions || [],
         reasoningContentField: meta.reasoningContentField || null,
         mode: 'chat',
-      });
+      };
+      const customConfig = customProviders[provider];
+      if (customConfig?.type === 'custom') {
+        const row = customProviderModels(provider, customConfig, [routeRow]).find((item) => item.id === model);
+        if (row) addModel(provider, row);
+        return;
+      }
+      addModel(provider, routeRow);
     };
 
     // A custom-* id with no live custom config entry was deleted: stale
@@ -72,16 +102,12 @@ export function createQuickProviderRows({
       !(customProviders[provider]?.type === 'custom' && customProviders[provider].enabled !== false);
     for (const [provider, providerConfig] of Object.entries(customProviders)) {
       if (!providerConfig?.enabled) continue;
-      if (providerConfig.type === 'custom') {
-        // Configured models are listed at once, before any catalog refresh.
-        for (const model of providerConfig.models || []) {
-          addModel(provider, {
-            ...model,
-            outputTokens: model.maxOutputTokens || null,
-          });
-        }
-      }
-      for (const model of providerCachedModelsSync(provider)) addModel(provider, model);
+      // Configured custom models are listed at once, before any catalog refresh.
+      const models =
+        providerConfig.type === 'custom'
+          ? customProviderModels(provider, providerConfig)
+          : providerCachedModelsSync(provider);
+      for (const model of models) addModel(provider, model);
     }
     addRoute(route);
     for (const preset of pickerConfig.presets || []) addRoute(preset);

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

@@ -3,7 +3,10 @@
 // live state getters plus the closure callbacks (`deps`). Each surface lives in
 // its own module and shares the extension-change sync and scope decorators.
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
-import { EXTENSION_SCOPE_KINDS, withExtensionScope } from '../runtime/agent/orchestrator/runtime-core/extension-scopes.mjs';
+import {
+  EXTENSION_SCOPE_KINDS,
+  withExtensionScope,
+} from '../runtime/agent/orchestrator/runtime-core/extension-scopes.mjs';
 import { createExtensionSync } from './resource-extension-sync.mjs';
 import { createScopeDecorators } from './resource-scope-decorate.mjs';
 import { createMcpResourceApi } from './resource-mcp-api.mjs';
@@ -60,5 +63,9 @@ export function createResourceApi(deps) {
     deleteHookRule(index) {
       return hooks.deleteRule(index);
     },
+    /** Write debounced rule toggles now; throws when the save fails. */
+    flushHookRules() {
+      hooks.flushRules();
+    },
   };
 }

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

@@ -24,6 +24,15 @@ export function resolveRouteEffortState(targetRoute = {}, modelMeta = null) {
   return { effectiveEffort, fastCapable, metadataResolved };
 }
 
+// Fast capability for a route selection or tuning write. Placeholder metadata
+// (`{ id, provider }`, a catalog that is not loaded yet) is unknown, not "no
+// Fast": clamping on it turned the selected route AND the saved model setting
+// to fast:false. Unknown keeps the requested value; the provider still checks
+// the exact tier before send.
+export function selectionFastCapable(provider, modelMeta, effort, modelParameters) {
+  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

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

@@ -19,6 +19,8 @@ function bootParams({
   effort,
   fast,
   modelParameters,
+  contextPercent,
+  selectedContextWindow,
   cwd = process.cwd(),
   toolMode = 'full',
   toolProfile = 'interactive',
@@ -36,6 +38,8 @@ function bootParams({
     effort,
     fast,
     modelParameters,
+    contextPercent,
+    selectedContextWindow,
     cwd,
     toolMode,
     toolProfile,

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

@@ -1,4 +1,5 @@
 import { SESSION_ID_PATTERN } from '../runtime/agent/orchestrator/runtime-core/session-id.mjs';
+import { SessionAddressError, bindSessionAddress } from './session-address.mjs';
 
 function requiredSessionId(value) {
   const sessionId = String(value || '').trim();
@@ -25,9 +26,19 @@ export function createRuntimeFacade({
   getContextStatusForSession,
   renameSessionTitle,
 }) {
-  const currentSessionId = () => state.session?.id || state.reservedSessionId || null;
+  // The durable address outlives the session object (terminal/closed, evicted).
+  const currentSessionId = () => state.session?.id || state.reservedSessionId || state.addressedSessionId || null;
   return {
     ...leadingApi,
+    /** Bind the durable address to the conversation this runtime just
+     *  loaded (resume / load-on-demand). Idempotent for the same id. */
+    bindSessionAddress(sessionId) {
+      const id = requiredSessionId(sessionId);
+      if (state.session?.id && state.session.id !== id) {
+        throw new SessionAddressError(`runtime holds ${state.session.id}, not ${id}`, id);
+      }
+      return bindSessionAddress(state, id) === id;
+    },
     get id() {
       return currentSessionId();
     },
@@ -48,6 +59,14 @@ export function createRuntimeFacade({
     get model() {
       return state.route.model;
     },
+    // The current session object's own route; diverges from provider/model
+    // (the selected route) after a model change on a session with history.
+    get sessionProvider() {
+      return state.session?.provider ?? null;
+    },
+    get sessionModel() {
+      return state.session?.model ?? null;
+    },
     get effort() {
       return state.route.effectiveEffort || state.route.effort || state.route.preset?.effort || null;
     },

package/src/session-runtime/runtime-feature-gates.mjs

@@ -8,6 +8,7 @@ import { builtinFeatureActive, featureDisallowedToolsFor, localGitToolsActive }
 import { recapEnabled } from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { browserBridgeAvailableSync } from '../runtime/browser-bridge/client.mjs';
 import { computerBridgeAvailableSync } from '../runtime/computer-bridge/client.mjs';
+import { terminalBridgeAvailableSync } from '../runtime/terminal-bridge/client.mjs';
 
 export function createRuntimeFeatureGates({ getConfig, getToolProfile }) {
   return {
@@ -28,6 +29,7 @@ export function createRuntimeFeatureGates({ getConfig, getToolProfile }) {
       featureDisallowedToolsFor(getConfig(), {
         browserAvailable: browserBridgeAvailableSync(),
         computerAvailable: computerBridgeAvailableSync(),
+        terminalAvailable: terminalBridgeAvailableSync(),
         toolProfile: getToolProfile(),
       }),
   };

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

@@ -1,13 +1,24 @@
+import { registerCacheInvalidationListener } from '../runtime/agent/orchestrator/tools/builtin/cache-layers.mjs';
+import { turnReviewReply } from '../runtime/shared/turn-review-reply.mjs';
 import {
   getSessionReviewDiff,
   getTurnReviewDiff,
   revertTurnReview,
   revertTurnReviewFile,
 } from '../runtime/shared/turn-snapshot.mjs';
+import { noteTurnWorktreeChange } from '../runtime/shared/turn-worktree-snapshot.mjs';
+
+// Tool writes (apply_patch, mutating shell commands, git, watcher events)
+// reach the live review snapshot as its change signal: a review poll right
+// after them captures the worktree, an unsignaled poll may reuse the last one.
+registerCacheInvalidationListener((paths) => noteTurnWorktreeChange(paths));
 
 export function createRuntimeReviewApi({ getCwd, getSessionId }) {
   return {
-    getTurnReviewDiff: (options = {}) => getTurnReviewDiff(getCwd(), getSessionId(), options),
+    // `known` (the client's tag) and `summary` are answered here, so an
+    // unchanged review crosses the wire as a short tag reply.
+    getTurnReviewDiff: (options = {}) =>
+      turnReviewReply((reviewOptions) => getTurnReviewDiff(getCwd(), getSessionId(), reviewOptions), options),
     getSessionReviewDiff: () => getSessionReviewDiff(getCwd(), getSessionId()),
     revertTurnReview: (checkpointId) => revertTurnReview(getCwd(), getSessionId(), checkpointId),
     revertTurnReviewFile: (file, checkpointId) => revertTurnReviewFile(getCwd(), getSessionId(), file, checkpointId),

package/src/session-runtime/services/agent-tool/helpers.mjs

@@ -30,7 +30,10 @@ let exitFlushInstalled = false;
 /** Run every registered flush once on process exit (best effort). */
 export function registerExitFlush(flush) {
   exitFlushes.add(flush);
-  if (exitFlushInstalled) return;
+  const unregister = () => {
+    exitFlushes.delete(flush);
+  };
+  if (exitFlushInstalled) return unregister;
   exitFlushInstalled = true;
   process.on('exit', () => {
     for (const entry of exitFlushes) {
@@ -41,6 +44,12 @@ export function registerExitFlush(flush) {
       }
     }
   });
+  return unregister;
+}
+
+/** Test seam: number of live exit registrations. */
+export function exitFlushCount() {
+  return exitFlushes.size;
 }
 
 /** Unstamped legacy rows report alive: only the freshness window judges them. */
@@ -211,6 +220,10 @@ export function normalizeAgentRoute(routeLike) {
     model,
     effort: clean(routeLike?.effort) || undefined,
     fast: routeLike?.fast === true,
+    ...(routeLike?.modelParameters && typeof routeLike.modelParameters === 'object'
+      ? { modelParameters: { ...routeLike.modelParameters } }
+      : {}),
+    ...(Number(routeLike?.contextPercent) > 0 ? { contextPercent: Number(routeLike.contextPercent) } : {}),
   };
 }
 

package/src/session-runtime/services/agent-tool/index-write-queue.mjs

@@ -78,9 +78,11 @@ function compactOps(batch) {
       for (const [key, json] of op.set) slot.final.set(key, json);
     });
   }
-  return slots.map((slot) =>
-    !slot ? null : slot.add ? { add: slot.add } : { del: slot.del, set: slot.final }
-  );
+  return slots.map((slot) => {
+    if (!slot) return null;
+    if (slot.add) return { add: slot.add };
+    return { del: slot.del, set: slot.final };
+  });
 }
 
 function replayOps(ops, args) {
@@ -132,12 +134,7 @@ export function createIndexWriteQueue({ file, rewrite, readDoc, onPersisted = ()
   async function persist(batch) {
     for (let attempt = 0; ; attempt += 1) {
       try {
-        await updateJsonAtomic(
-          file,
-          (cur) =>
-            rewrite(cur, (...args) => replayBatch(batch, args)),
-          { lock: true }
-        );
+        await updateJsonAtomic(file, (cur) => rewrite(cur, (...args) => replayBatch(batch, args)), { lock: true });
         return;
       } catch {
         if (attempt >= RETRY_DELAYS_MS.length) return; // dropped, like the sync writer's swallowed failure
@@ -184,12 +181,10 @@ export function createIndexWriteQueue({ file, rewrite, readDoc, onPersisted = ()
     clearTimer();
     pending = [];
     try {
-      updateJsonAtomicSync(
-        file,
-        (cur) =>
-          rewrite(cur, (...args) => replayBatch(ops, args)),
-        { lock: true, timeoutMs: EXIT_LOCK_TIMEOUT_MS }
-      );
+      updateJsonAtomicSync(file, (cur) => rewrite(cur, (...args) => replayBatch(ops, args)), {
+        lock: true,
+        timeoutMs: EXIT_LOCK_TIMEOUT_MS,
+      });
     } catch {
       pending = ops;
       return false;

package/src/session-runtime/services/agent-tool/lead-worker-index/reap-timers.mjs

@@ -27,5 +27,10 @@ export function createLeadReapTimers({ removeRow }) {
     reapTimers.set(sessionId, handle);
   }
 
-  return { cancel, schedule };
+  function cancelAll() {
+    for (const handle of reapTimers.values()) clearTimeout(handle);
+    reapTimers.clear();
+  }
+
+  return { cancel, cancelAll, schedule };
 }

package/src/session-runtime/services/agent-tool/lead-worker-index.mjs

@@ -117,13 +117,31 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
   }
 
   recoverStaleLeadRows();
-  registerExitFlush(() => {
+  function flushLeadIndexOnExit() {
     flushActiveLeadRows();
     // Writes are persisted by an async queue; the loop is gone at exit.
     index.flushSync();
-  });
+  }
+  const unregisterExitFlush = registerExitFlush(flushLeadIndexOnExit);
+  let disposed = false;
+
+  /** Persist queued rows, drop owned reap timers, unregister. `settle` (a real
+   *  teardown) also idles this runtime's own active Lead rows; a dispose that
+   *  keeps background work (idle eviction) leaves them for the next owner. */
+  function dispose({ settle = false } = {}) {
+    if (disposed) return;
+    disposed = true;
+    try {
+      if (settle) flushActiveLeadRows();
+      index.flushSync();
+    } finally {
+      reaps.cancelAll();
+      unregisterExitFlush();
+    }
+  }
 
   return {
+    dispose,
     leadWorkerIndexPath: index.path,
     readLeadWorkerRows: index.read,
     /** Resolves once every queued Lead index write is on disk. */

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

@@ -8,6 +8,7 @@ import { presetKey, writeAgentStatuslineRoute } from '../helpers.mjs';
 import { resolveAgentWatchdogPolicy } from '../../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 import { prepareAgentSession } from '../../../../runtime/agent/orchestrator/agent-runtime/session-builder.mjs';
 import { getProvider } from '../../../../runtime/agent/orchestrator/providers/registry.mjs';
+import { resolveRouteContextState } from '../../../route-state.mjs';
 import { createSpawnPlanner } from './spawn-plan.mjs';
 
 /** The route fields every worker-row and tag record carries. */
@@ -22,9 +23,9 @@ export function presetDescriptor(agent, preset, presetName) {
   };
 }
 
-// Spawn prewarm builds the materialized stable prompt and keeps the resulting
-// Codex-style client handle reserved for the first turn. Fire-and-forget:
-// failures fall back to the lazy per-send handshake.
+// Spawn prewarm opens the session's pooled socket ahead of the first turn
+// (connection only). Fire-and-forget: failures fall back to the lazy
+// per-send handshake.
 // MIXDOG_AGENT_SPAWN_WS_PREWARM=0 disables.
 function maybePrewarmSpawnTransport(plan, session) {
   if (process.env.MIXDOG_AGENT_SPAWN_WS_PREWARM === '0') return;
@@ -80,14 +81,21 @@ export function createSpawnPreparer({
   }
 
   async function createSpawnedSession(plan, spec, prepState) {
+    // A sub-100 context share needs the window it selects; a percent alone
+    // keeps the full served window.
+    const sessionSpec = { ...spec };
+    if (plan.preset.contextPercent) {
+      const { contextPercent, selectedContextWindow } = resolveRouteContextState(plan.preset, null);
+      Object.assign(sessionSpec, { contextPercent, selectedContextWindow });
+    }
     if (sessionSurface?.canonical === true && typeof sessionSurface.createChild === 'function') {
-      return sessionSurface.createChild({ spec, prompt: plan.prompt, tag: plan.tag });
+      return sessionSurface.createChild({ spec: sessionSpec, prompt: plan.prompt, tag: plan.tag });
     }
     await ensureProvider(plan.config, plan.preset.provider);
     if (prepState?.timedOut) {
       throw new Error('agent spawn prep timed out before session bind');
     }
-    return prepareAgentSession(spec);
+    return prepareAgentSession(sessionSpec);
   }
 
   async function prepareSpawnInProcess(args, callerCwd = null, context = {}, prepState = null) {
@@ -116,5 +124,5 @@ export function createSpawnPreparer({
     return prepareSpawnInProcess(args, callerCwd, context, prepState);
   }
 
-  return { prepareSpawn, prepareSpawnInProcess };
+  return { prepareSpawn, prepareSpawnInProcess, createSpawnedSession };
 }

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

@@ -42,6 +42,8 @@ export function resolveAgentSpawnPreset(config, args = {}) {
         model: agentRoute.model,
         effort: agentRoute.effort,
         fast: agentRoute.fast === true,
+        ...(agentRoute.modelParameters ? { modelParameters: agentRoute.modelParameters } : {}),
+        ...(agentRoute.contextPercent ? { contextPercent: agentRoute.contextPercent } : {}),
         tools: 'full',
       },
     };

package/src/session-runtime/services/agent-tool/tag-registry.mjs

@@ -23,12 +23,22 @@ export function createTagRegistry({ dataDir, cfgMod, mgr }) {
     tagCwds: tagMaps.tagCwds,
   });
   const { readWorkerRows, upsertWorkerSessionDeferred, removeWorkerRow, refreshTagsFromIndex } = index;
-  const { upsertLeadSession } = createLeadWorkerIndex({
+  const leadIndex = createLeadWorkerIndex({
     dataDir,
     cfgMod,
     workerRowFromSession: index.workerRowFromSession,
   });
 
+  const { upsertLeadSession } = leadIndex;
+
+  function dispose(options) {
+    try {
+      index.dispose();
+    } finally {
+      leadIndex.dispose(options);
+    }
+  }
+
   function getLiveSession(sessionId) {
     if (!sessionId) return null;
     const session = mgr.getSession(sessionId);
@@ -84,6 +94,7 @@ export function createTagRegistry({ dataDir, cfgMod, mgr }) {
   reaper.recoverTerminalReaps();
 
   return {
+    dispose,
     readAllTagTombstones: index.readAllTagTombstones,
     readTagTombstones: index.readTagTombstones,
     readWorkerRows,

package/src/session-runtime/services/agent-tool/worker-index.mjs

@@ -128,9 +128,25 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
   }
 
   recoverStaleWorkerRows();
-  registerExitFlush(flushWorkerIndexOnExit);
+  const unregisterExitFlush = registerExitFlush(flushWorkerIndexOnExit);
+  let disposed = false;
+
+  /** Persist queued rows, then release the exit registration. Active rows are
+   *  NOT settled: they are keyed by process pid, which every inline runtime in
+   *  the daemon shares, so settling here would idle other runtimes' workers. */
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    try {
+      batch.flush();
+      store.flushSync();
+    } finally {
+      unregisterExitFlush();
+    }
+  }
 
   return {
+    dispose,
     workerIndexPath: () => file,
     invalidateWorkerRowsCache: store.invalidate,
     readAllWorkerRows: store.readAll,

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

@@ -147,5 +147,6 @@ export function createStandaloneAgent({
     recoverWorkers,
     upsertLeadSession: registry.upsertLeadSession,
     closeAll: closeFlow.closeAll,
+    dispose: (options) => registry.dispose(options),
   };
 }