mixdog 1.3.1 → 1.3.3

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

@@ -22,7 +22,10 @@ function customProviderModels(provider, providerConfig, discovered = providerCac
   } catch {
     return [];
   }
-  return effectiveCustomModelRows(config, discovered, { providerId: provider });
+  const providerName = clean(config.name);
+  return effectiveCustomModelRows(config, discovered, { providerId: provider }).map((row) =>
+    providerName ? { ...row, providerName } : row
+  );
 }
 
 export function createQuickProviderRows({
@@ -53,6 +56,8 @@ export function createQuickProviderRows({
         display: model.display || model.name || modelId,
         contextWindow: model.contextWindow || meta.contextWindow || null,
         outputTokens: model.outputTokens || meta.outputTokens || null,
+        // An explicit value (an override's false included) wins; the catalog fills the rest.
+        supportsVision: model.supportsVision ?? meta.supportsVision,
         supportsReasoning: model.supportsReasoning === true || meta.supportsReasoning === true,
         supportsFunctionCalling: model.supportsFunctionCalling === true || meta.supportsFunctionCalling === true,
         supportsPromptCaching: model.supportsPromptCaching === true || meta.supportsPromptCaching === true,
@@ -78,6 +83,7 @@ export function createQuickProviderRows({
         contextWindow: meta.contextWindow || null,
         outputTokens: meta.outputTokens || null,
         latest: routeLike.latest === true,
+        supportsVision: meta.supportsVision,
         supportsReasoning: !!routeLike.effort || meta.supportsReasoning === true,
         supportsFunctionCalling: meta.supportsFunctionCalling === true,
         supportsPromptCaching: meta.supportsPromptCaching === true,

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-review-api.mjs

@@ -2,6 +2,7 @@ import { registerCacheInvalidationListener } from '../runtime/agent/orchestrator
 import { turnReviewReply } from '../runtime/shared/turn-review-reply.mjs';
 import {
   clearSessionChangeHistory,
+  forgetTurnSnapshotSession,
   getSessionReviewDiff,
   getSessionReviewFilePatch,
   getTurnChanges,
@@ -19,8 +20,10 @@ import { registerSessionPurgeHook } from '../runtime/agent/orchestrator/session/
 
 // A deleted history stays deleted for as long as its session exists; the
 // session's own deletion takes the marker — and its stored first-seen file
-// contents — with it.
+// contents — with it, and its in-memory turn, parked worker reviews and
+// bound worker trackers.
 registerSessionPurgeHook((sessionId) => {
+  forgetTurnSnapshotSession(sessionId);
   void forgetSessionChangeHistoryMarker(sessionId);
   void forgetSessionBaselines(sessionId);
 });

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, {

package/src/session-runtime/services/agent-tool/job-views/agent-list.mjs

@@ -25,11 +25,16 @@ export function isActiveWorkerRow(row = {}) {
   return !isTerminalWorkerStatus(effective);
 }
 
-function agentRow({ tag, session, runtime, progress, now, indexRow = null }) {
+function rowState(session, runtime) {
   const status = session.closed === true ? 'closed' : session.status || 'idle';
   const stage =
     session.stage ||
     (status === 'idle' || status === 'error' || status === 'closed' ? status : runtime?.stage || status);
+  return { status, stage };
+}
+
+function agentRow({ tag, session, runtime, progress, now, indexRow = null }) {
+  const { status, stage } = rowState(session, runtime);
   // Additive: the current turn's start (worker index, stamped at dispatch) so
   // surfaces time a continued worker from its turn, not from createdAt.
   const turnStartedAt = indexRow?.turnStartedAt || session.turnStartedAt || null;
@@ -76,24 +81,34 @@ export function createAgentList({ mgr, refreshTagsFromSessions, agentSessionEntr
   return function list({ scanSessions = false, context = {}, includeTerminal = false } = {}) {
     refreshTagsFromSessions({ scanSessions, context });
     const now = Date.now();
-    const rows = agentSessionEntries({ scanSessions, context }).map(({ tag, session, indexRow, loaded }) =>
-      agentRow({
-        tag,
-        session,
-        indexRow,
-        runtime: mgr.getSessionRuntime?.(session.id),
-        // A tag-bound entry is the getSession answer itself; an index row or
-        // a scanned summary is only a projection and still reads the session.
-        progress: progress.sessionProgressExtras(
-          session.id,
-          session.agent || null,
+    const rows = [];
+    for (const { tag, session, indexRow, loaded } of agentSessionEntries({ scanSessions, context })) {
+      const runtime = mgr.getSessionRuntime?.(session.id);
+      // Whether a row is listed depends on its status and stage alone, so a
+      // finished worker is dropped before its progress is read: that read
+      // loads the worker's stored session, and a Lead's status pulse (every
+      // 2 s) would otherwise read every worker it ever ran, whole transcripts
+      // on first sight, synchronously on the daemon loop.
+      if (!includeTerminal && !isActiveWorkerRow(rowState(session, runtime))) continue;
+      rows.push(
+        agentRow({
+          tag,
+          session,
+          indexRow,
+          runtime,
+          // A tag-bound entry is the getSession answer itself; an index row or
+          // a scanned summary is only a projection and still reads the session.
+          progress: progress.sessionProgressExtras(
+            session.id,
+            session.agent || null,
+            now,
+            null,
+            loaded ? { loaded: session } : {}
+          ),
           now,
-          null,
-          loaded ? { loaded: session } : {}
-        ),
-        now,
-      })
-    );
-    return includeTerminal ? rows : rows.filter((row) => isActiveWorkerRow(row));
+        })
+      );
+    }
+    return rows;
   };
 }

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

@@ -28,6 +28,16 @@ export function restartNotificationId(row) {
   return `restart:${clean(row.task_id) || `${clean(row.sessionId)}:${clean(row.finishedAt)}`}`;
 }
 
+/** The agent task id an execution id names: a task's own id, or the task a
+ *  restart notification (restartNotificationId) reports; null for one keyed
+ *  by session because its row recorded no task id. */
+export function agentTaskIdOfExecution(executionId) {
+  const id = clean(executionId);
+  if (!id.startsWith('restart:')) return id || null;
+  const rest = id.slice('restart:'.length);
+  return rest && !rest.includes(':') ? rest : null;
+}
+
 /** `pendingRestartFailures()` lists rows whose owner is not yet told;
  *  `markRestartNotified(rows)` stamps them. `mgr` supplies the persisted
  *  pending queue (enqueuePendingMessage / markCompletionEntry /

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

@@ -17,7 +17,13 @@ import {
 } from './job-task-reconcile.mjs';
 import { createTurnReviewCollector } from './turn-review.mjs';
 import { handoffContent } from '../../handoff-attachments.mjs';
+import { rebindDelegation } from '../../../runtime/agent/orchestrator/session/human-gate/delegation.mjs';
 import { settledWorkerStatus } from './worker-index/row-liveness.mjs';
+import { whileTurnDispatched } from '../../../runtime/agent/orchestrator/session/manager/runtime-state.mjs';
+
+function workerResultIdentity({ session, tag, sessionId }) {
+  return { tag, sessionId, agent: session.agent || null, provider: session.provider, model: session.model };
+}
 
 // `send` to an existing worker: resolve the live session, run one follow-up
 // turn under the progress watchdog, and reconcile the job/worker row. Busy
@@ -42,11 +48,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     return (result) => {
       const abnormalError = abnormalEmptyFinishError(result, session.agent || sendAgent);
       return {
-        tag,
-        sessionId,
-        agent: session.agent || null,
-        provider: session.provider,
-        model: session.model,
+        ...workerResultIdentity({ session, tag, sessionId }),
         content: result?.content || '',
         ...(sessionSurface?.canonical === true ? { handoffOnly: true } : {}),
         ...(abnormalError ? { error: abnormalError } : {}),
@@ -74,10 +76,12 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     const cwd = session.cwd || defaultCwd;
     // The caller's forwarded files ride along as attachment parts.
     const prompt = handoffContent(text, args.attachmentParts);
-    if (canUseSessionSurface(session)) {
-      return sessionSurface.runTurn({ session, prompt, context: args.context || null, cwd, ...turnHooks });
-    }
-    return mgr.askSession(sessionId, prompt, args.context || null, null, cwd, null, turnHooks);
+    return whileTurnDispatched(sessionId, () => {
+      if (canUseSessionSurface(session)) {
+        return sessionSurface.runTurn({ session, prompt, context: args.context || null, cwd, ...turnHooks });
+      }
+      return mgr.askSession(sessionId, prompt, args.context || null, null, cwd, null, turnHooks);
+    });
   }
 
   async function runSend(prepared, notifyContext = null, job = null) {
@@ -110,11 +114,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     const settleCancelled = (error, result = null) => {
       finalStatus = 'cancelled';
       reconcileJobCancelled(job, {
-        tag,
-        sessionId,
-        agent: session.agent || null,
-        provider: session.provider,
-        model: session.model,
+        ...workerResultIdentity({ session, tag, sessionId }),
         content: turnPartialHandoff(error, mgr.getSession(sessionId), handoffMsgStart) || result?.content || '',
       });
     };
@@ -145,11 +145,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       if (partial) {
         finalStatus = 'idle';
         const value = {
-          tag,
-          sessionId,
-          agent: session.agent || null,
-          provider: session.provider,
-          model: session.model,
+          ...workerResultIdentity({ session, tag, sessionId }),
           content: watchdogStoppedHandoff(error, partial),
           stallAbort: true,
         };
@@ -164,7 +160,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       turnReview.complete();
       watchdog?.stop?.();
       registry.upsertWorkerSessionDeferred(session, tag, {
-        ...settledWorkerStatus(finalStatus, stalled),
+        ...settledWorkerStatus(finalStatus, stalled, job),
         finishedAt: new Date().toISOString(),
       });
       reconcileJobFinally(job, finalStatus);
@@ -188,6 +184,14 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     return { ...prepared, session: mgr.getSession(sessionId) || session };
   }
 
+  // The calling session hands this worker new work (a `send`, or a spawn of its
+  // tag): from now on the worker acts as that caller does, so a run's worker
+  // asks when the attended chat reuses it and the other way round. Not for a
+  // completion wake, which is the worker's own continuation.
+  function adoptCaller({ sessionId }, notifyContext) {
+    return rebindDelegation(sessionId, notifyContext?.callerSessionId);
+  }
+
   // Shared send dispatch for an already-resolved live session. Used by the
   // `send` branch AND by the `spawn` branch when an explicit tag maps to a
   // live session (reuse path). Busy sessions queue the prompt; idle ones run a
@@ -255,5 +259,5 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     return true;
   }
 
-  return { prepareSend, dispatchToExistingSession, wakeIdleWorker };
+  return { prepareSend, adoptCaller, dispatchToExistingSession, wakeIdleWorker };
 }

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

@@ -4,10 +4,12 @@
  * agent work, and status publication at start and after terminal settlement.
  */
 import { sanitizeTaskMeta, startBackgroundTask } from '../../../../runtime/shared/background-tasks.mjs';
+import { recordAgentTaskStart } from '../../../../runtime/shared/agent-task-starts.mjs';
 import { resourceAdmission } from '../../../../runtime/shared/resource-admission.mjs';
 import { clean, terminalPidForContext } from '../helpers.mjs';
 import { renderResult } from '../render.mjs';
 import { closeManagedSession } from '../../../lifecycle/shared.mjs';
+import { hopOf } from '../../../../runtime/shared/bot-hops.mjs';
 
 /** The completion callback that hands a worker's result back to its caller session; null without a handoff. */
 function handoffNotifier(handoffSessionId, notifySessionCompletion) {
@@ -29,6 +31,8 @@ export function createJobStarter({ mgr, notifyStatusChange, notifySessionComplet
       ownerSessionId: ownerSessionId || null,
       clientHostPid: clientHostPid || null,
       notifyFn: handoffNotifier(handoffSessionId, notifySessionCompletion),
+      // The turn that started the job: its completion returns at that bot-chain hop (bot-hops.mjs).
+      ...(hopOf(notifyContext?.hop) ? { hop: notifyContext.hop } : {}),
     };
     const jobMeta = sanitizeTaskMeta({
       ...(meta || {}),
@@ -82,6 +86,9 @@ export function createJobStarter({ mgr, notifyStatusChange, notifySessionComplet
         }
       },
     });
+    // The model's tool call that started this job owns it (its result message
+    // carries the id: agent-task-starts.mjs).
+    recordAgentTaskStart(notifyContext?.toolCallId, task.taskId);
     notifyStatusChange();
     return task;
   };

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

@@ -9,6 +9,7 @@ import { resolveAgentWatchdogPolicy } from '../../../../runtime/agent/orchestrat
 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 { contextSelectionFromState } from '../../../../runtime/agent/orchestrator/runtime-core/route-context-state.mjs';
 import { createSpawnPlanner } from './spawn-plan.mjs';
 import { enterWorkerSpawn } from '../../../workspace/admission-gate.mjs';
 
@@ -97,11 +98,13 @@ 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.
+    // keeps the full served window. A model whose window is not known yet
+    // resolves to nothing: the agent's own choice then travels as stored (the
+    // session sizes it from the provider's window) instead of being dropped
+    // for the model's default.
     const sessionSpec = { ...spec };
     if (plan.preset.contextPercent || plan.preset.contextTokens) {
-      const { contextPercent, selectedContextWindow, contextTokens } = resolveRouteContextState(plan.preset, null);
-      Object.assign(sessionSpec, { contextPercent, selectedContextWindow }, contextTokens ? { contextTokens } : {});
+      Object.assign(sessionSpec, contextSelectionFromState(resolveRouteContextState(plan.preset, null), plan.preset));
     }
     if (sessionSurface?.canonical === true && typeof sessionSurface.createChild === 'function') {
       return sessionSurface.createChild({ spec: sessionSpec, prompt: plan.prompt, tag: plan.tag });

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

@@ -26,6 +26,7 @@ import { saveSessionAsync } from '../../../../runtime/agent/orchestrator/session
 import { presetDescriptor } from './spawn-prep.mjs';
 import { workerStageForStatus } from '../worker-rows.mjs';
 import { handoffContent } from '../../../handoff-attachments.mjs';
+import { whileTurnDispatched } from '../../../../runtime/agent/orchestrator/session/manager/runtime-state.mjs';
 
 // Mid-turn worker persistence cadence. The watchdog sweep runs every second;
 // a transcript save is far more expensive than a bookkeeping stamp, so the
@@ -121,10 +122,12 @@ export function createSpawnRunner({
     const { args, session, workerCwd } = prepared;
     // The caller's forwarded files ride along as attachment parts.
     const prompt = handoffContent(prepared.prompt, args.attachmentParts);
-    if (typeof sessionSurface?.runTurn === 'function' && sessionSurface.canRun?.(session) !== false) {
-      return sessionSurface.runTurn({ session, prompt, context: args.context || null, cwd: workerCwd, ...turnHooks });
-    }
-    return mgr.askSession(session.id, prompt, args.context || null, null, workerCwd, null, turnHooks);
+    return whileTurnDispatched(session.id, () => {
+      if (typeof sessionSurface?.runTurn === 'function' && sessionSurface.canRun?.(session) !== false) {
+        return sessionSurface.runTurn({ session, prompt, context: args.context || null, cwd: workerCwd, ...turnHooks });
+      }
+      return mgr.askSession(session.id, prompt, args.context || null, null, workerCwd, null, turnHooks);
+    });
   }
 
   async function runSpawn(prepared, notifyContext = null, job = null) {
@@ -221,7 +224,7 @@ export function createSpawnRunner({
       watchdog?.stop?.();
       upsertWorkerSessionDeferred(session, tag, {
         ...presetDescriptor(agent, preset, presetName),
-        ...settledWorkerStatus(finalStatus, stalled),
+        ...settledWorkerStatus(finalStatus, stalled, job),
         finishedAt: new Date().toISOString(),
       });
       setImmediate(notifyStatusChange);