mixdog 1.3.0 → 1.3.2

package/src/session-runtime/workflow-agents-api/agent-route.mjs

@@ -4,8 +4,22 @@ import { isHiddenAgent } from '../../runtime/agent/orchestrator/internal-agents.
 import { normalizeWorkflowRoute } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
 import { ensureProviderEnabled } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { resolveRouteContextState, selectionFastCapable } from '../route-state.mjs';
-import { canonicalizeAgentRouteStorage, withAgentDisabled } from '../../runtime/shared/agent-route-config.mjs';
-import { agentEditorId } from './shared.mjs';
+import {
+  canonicalizeAgentRouteStorage,
+  isAgentDisabled,
+  withAgentDisabled,
+} from '../../runtime/shared/agent-route-config.mjs';
+import { agentEditorId, resolveDataDir } from './shared.mjs';
+import {
+  isStoreBot,
+  readBotRoute,
+  readMixyRoute,
+  writeBotRoute,
+  writeMixyRoute,
+} from '../../runtime/shared/agent-store.mjs';
+
+/** Mixy's runtime id (agent-home.mjs MIXY_AGENT_ID). */
+const MIXY_RUNTIME_ID = 'lead';
 import { routeChain, validateRouteChainProviders } from '../../runtime/shared/model-route-chain.mjs';
 
 // Agent route persistence. Route-scope isolation: an agent route owns its
@@ -15,16 +29,86 @@ import { routeChain, validateRouteChainProviders } from '../../runtime/shared/mo
 // lead preset, so an agent that reused it silently rewrote Main's effort/fast
 // for the next session. The agent's own stored route is the fallback instead,
 // and the bucket is never written here.
+// Tuning-only edits keep the stored model's effort/fast/modelParameters;
+// a model change starts from the resolved defaults. Fast is then clamped
+// to what the selected model supports. The ONE normalizer of a chain entry:
+// agents, bots, Mixy and the Lead's fallbacks all pass through it.
+export async function resolveChainEntry(deps, requested, stored) {
+  const { getConfig, resolveRoute, lookupModelMeta, ensureProvidersReady } = deps;
+  let selectedRoute = resolveRoute(getConfig(), requested);
+  const sameModel =
+    clean(selectedRoute.provider) === clean(stored.provider) && clean(selectedRoute.model) === clean(stored.model);
+  const inheritedEffort = sameModel ? stored.effort || null : null;
+  const inheritedModelParameters = sameModel ? stored.modelParameters || {} : {};
+  // A requested percent replaces the stored exact window and requested
+  // tokens replace the stored percent.
+  const requestsPercent = requested.contextPercent !== undefined;
+  const requestsTokens = requested.contextTokens !== undefined;
+  const inheritedContextPercent = sameModel && !requestsTokens ? stored.contextPercent : undefined;
+  const inheritedContextTokens = sameModel && !requestsPercent ? stored.contextTokens : undefined;
+  selectedRoute = {
+    ...selectedRoute,
+    effort: requested.effort !== undefined ? selectedRoute.effort : inheritedEffort,
+    fast: requested.fast !== undefined ? selectedRoute.fast === true : sameModel && stored.fast === true,
+    // Main's modelSettings bucket must not decide an agent's Auto effort.
+    autoEffort:
+      requested.autoEffort !== undefined ? requested.autoEffort !== false : !sameModel || stored.autoEffort !== false,
+    modelParameters: requested.modelParameters !== undefined ? selectedRoute.modelParameters : inheritedModelParameters,
+    // resolveRoute reads contextPercent from Main's modelSettings bucket;
+    // an agent route owns its own.
+    contextPercent: requestsPercent ? requested.contextPercent : inheritedContextPercent,
+    contextTokens: requestsTokens ? requested.contextTokens : inheritedContextTokens,
+  };
+  await ensureProvidersReady(ensureProviderEnabled(getConfig(), selectedRoute.provider));
+  const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
+  // Stored clamped, and not at all at the default window, as for Main.
+  const contextState = resolveRouteContextState(selectedRoute, modelMeta);
+  if (contextState.contextDefaultPercent !== undefined) selectedRoute.contextTokens = contextState.contextTokens;
+  const fastCapable = selectionFastCapable(
+    selectedRoute.provider,
+    modelMeta,
+    selectedRoute.effort,
+    selectedRoute.modelParameters
+  );
+  return { ...selectedRoute, fast: fastCapable ? selectedRoute.fast === true : false };
+}
+
 export function createAgentRouteApi(deps) {
-  const { getConfig, resolveRoute, lookupModelMeta, saveConfigAndAdopt, ensureProvidersReady, agentRouteFromConfig } =
-    deps;
+  const { getConfig, resolveRoute, saveConfigAndAdopt, agentRouteFromConfig } = deps;
 
   function saveDisabled(id, disabled) {
     saveConfigAndAdopt(canonicalizeAgentRouteStorage(withAgentDisabled(getConfig(), id, disabled)));
   }
 
+  // A bot of the store keeps its route in its own folder (agent-store.mjs);
+  // Mixy (`lead` here, its runtime id) keeps its own in bots/mixy — never the
+  // Lead's route, which the Main route setter owns.
+  const dataDir = () => (deps.cfgMod || deps.STANDALONE_DATA_DIR ? resolveDataDir(deps) : '');
+  const isMixy = (id) => id === MIXY_RUNTIME_ID && Boolean(dataDir());
+  const storeBot = (id) => isStoreBot(dataDir(), id);
+  function saveRoute(id, route, keepOff) {
+    if (isMixy(id)) {
+      writeMixyRoute(dataDir(), route);
+      return;
+    }
+    if (storeBot(id)) {
+      writeBotRoute(dataDir(), id, route);
+      saveDisabled(id, keepOff);
+      return;
+    }
+    const nextConfig = withAgentDisabled(getConfig(), id, keepOff);
+    nextConfig.agents = { ...(nextConfig.agents || {}), [id]: route };
+    saveConfigAndAdopt(canonicalizeAgentRouteStorage(nextConfig));
+  }
+
   // Only an explicitly empty provider removes an override: the agent inherits Main.
   function clearOverride(id) {
+    if (isMixy(id) || storeBot(id)) {
+      if (isMixy(id)) writeMixyRoute(dataDir(), null);
+      else writeBotRoute(dataDir(), id, null);
+      const inherited = normalizeWorkflowRoute(resolveRoute(getConfig(), {}));
+      return { ...(inherited || {}), inherited: true };
+    }
     const nextConfig = { ...getConfig() };
     const agents = { ...(nextConfig.agents || {}) };
     const hadOverride = Object.hasOwn(agents, id);
@@ -35,55 +119,25 @@ export function createAgentRouteApi(deps) {
     return { ...(inherited || {}), inherited: true };
   }
 
-  // Tuning-only edits keep the stored model's effort/fast/modelParameters;
-  // a model change starts from the resolved defaults. Fast is then clamped
-  // to what the selected model supports.
-  async function resolveSelectedRoute(requested, stored) {
-    let selectedRoute = resolveRoute(getConfig(), requested);
-    const sameModel =
-      clean(selectedRoute.provider) === clean(stored.provider) && clean(selectedRoute.model) === clean(stored.model);
-    const inheritedEffort = sameModel ? stored.effort || null : null;
-    const inheritedModelParameters = sameModel ? stored.modelParameters || {} : {};
-    // A requested percent replaces the stored exact window and requested
-    // tokens replace the stored percent.
-    const requestsPercent = requested.contextPercent !== undefined;
-    const requestsTokens = requested.contextTokens !== undefined;
-    const inheritedContextPercent = sameModel && !requestsTokens ? stored.contextPercent : undefined;
-    const inheritedContextTokens = sameModel && !requestsPercent ? stored.contextTokens : undefined;
-    selectedRoute = {
-      ...selectedRoute,
-      effort: requested.effort !== undefined ? selectedRoute.effort : inheritedEffort,
-      fast: requested.fast !== undefined ? selectedRoute.fast === true : sameModel && stored.fast === true,
-      // Main's modelSettings bucket must not decide an agent's Auto effort.
-      autoEffort:
-        requested.autoEffort !== undefined ? requested.autoEffort !== false : !sameModel || stored.autoEffort !== false,
-      modelParameters:
-        requested.modelParameters !== undefined ? selectedRoute.modelParameters : inheritedModelParameters,
-      // resolveRoute reads contextPercent from Main's modelSettings bucket;
-      // an agent route owns its own.
-      contextPercent: requestsPercent ? requested.contextPercent : inheritedContextPercent,
-      contextTokens: requestsTokens ? requested.contextTokens : inheritedContextTokens,
-    };
-    await ensureProvidersReady(ensureProviderEnabled(getConfig(), selectedRoute.provider));
-    const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
-    // Stored clamped, and not at all at the default window, as for Main.
-    const contextState = resolveRouteContextState(selectedRoute, modelMeta);
-    if (contextState.contextDefaultPercent !== undefined) selectedRoute.contextTokens = contextState.contextTokens;
-    const fastCapable = selectionFastCapable(
-      selectedRoute.provider,
-      modelMeta,
-      selectedRoute.effort,
-      selectedRoute.modelParameters
-    );
-    return { ...selectedRoute, fast: fastCapable ? selectedRoute.fast === true : false };
-  }
-
   async function setAgentRoute(agentId, next) {
     const id = agentEditorId(agentId);
     if (!id) throw new Error(`unknown agent "${agentId}"`);
     if (isHiddenAgent(id)) throw new Error(`agent "${id}" is internal and has no configurable route`);
     const requested = { ...(next || {}) };
-    const stored = agentRouteFromConfig(getConfig(), id) || {};
+    // Compare-and-set: fill the route only while the agent has none. A route
+    // picked while the model resolved below stays (answered with `skipped`).
+    const onlyIfEmpty = requested.onlyIfEmpty === true;
+    delete requested.onlyIfEmpty;
+    const readStored = () => {
+      if (isMixy(id)) return readMixyRoute(dataDir()) || {};
+      if (storeBot(id)) return readBotRoute(dataDir(), id) || {};
+      return agentRouteFromConfig(getConfig(), id) || {};
+    };
+    const kept = () => ({ ...readStored(), id, skipped: true });
+    const stored = readStored();
+    if (onlyIfEmpty && clean(stored.provider)) return kept();
+    // Mixy is never off: its route request is a model pick alone.
+    if (isMixy(id)) delete requested.disabled;
     // Off is an explicit state, stored apart from the route so the model the
     // user picked survives and comes back when the agent is switched on. An
     // off request that also carries a model saves that model and stays off.
@@ -121,16 +175,22 @@ export function createAgentRouteApi(deps) {
       const previous = storedChain.find(
         (candidate) => candidate.provider === entry.provider && candidate.model === entry.model
       );
-      resolved.push(await resolveSelectedRoute(entry, previous || {}));
+      resolved.push(await resolveChainEntry(deps, entry, previous || {}));
     }
     const [primary, ...fallbacks] = resolved;
     const routeToSave = normalizeWorkflowRoute({ ...primary, fallbacks });
     if (!routeToSave) throw new Error('agent route requires provider and model');
+    // No await from here to the write: the emptiness checked is the emptiness
+    // written over. An off agent stays off when it was only back-filled.
+    // A store bot's or Mixy's route is read from its folder on disk right here.
+    // An agent routed in the config file may have been written by another
+    // process whose change notification is still pending: re-read it first.
+    if (onlyIfEmpty && !isMixy(id) && !storeBot(id)) deps.reloadFullConfig?.();
+    if (onlyIfEmpty && clean(readStored().provider)) return kept();
+    const stayOff = onlyIfEmpty ? isAgentDisabled(getConfig(), id) : keepOff;
     // Picking a model is also the "on" switch unless the request keeps it off.
-    const nextConfig = withAgentDisabled(getConfig(), id, keepOff);
-    nextConfig.agents = { ...(nextConfig.agents || {}), [id]: routeToSave };
-    saveConfigAndAdopt(canonicalizeAgentRouteStorage(nextConfig));
-    return keepOff ? { ...routeToSave, id, disabled: true } : routeToSave;
+    saveRoute(id, routeToSave, stayOff);
+    return stayOff ? { ...routeToSave, id, disabled: true } : routeToSave;
   }
 
   return { setAgentRoute };

package/src/session-runtime/workflow-agents-api/onboarding.mjs

@@ -25,6 +25,7 @@ function applyWorkflowSlots(workflowInput, draft) {
       if (!normalized) continue;
       draft.presets = upsertWorkflowPreset(draft.presets, 'lead', normalized);
       draft.defaultPreset = workflowPresetId('lead');
+      draft.leadRoute = normalized;
     } else if (slot === 'agent') {
       if (normalized) draft.agentRoutes.worker = normalized;
       else delete draft.agentRoutes.worker;
@@ -72,10 +73,13 @@ export function createOnboardingApi(deps) {
         presets: Array.isArray(nextConfig.presets) ? nextConfig.presets.slice() : [],
         defaultPreset: nextConfig.default,
         agentRoutes: { ...(nextConfig.agents || {}) },
+        // The Lead route this save writes, from `defaultRoute` or `workflowRoutes.lead`.
+        leadRoute: null,
       };
       if (defaultRoute) {
         draft.presets = upsertWorkflowPreset(draft.presets, 'lead', defaultRoute);
         draft.defaultPreset = workflowPresetId('lead');
+        draft.leadRoute = defaultRoute;
       }
       const workflowInput =
         payload.workflowRoutes && typeof payload.workflowRoutes === 'object' ? payload.workflowRoutes : {};
@@ -104,12 +108,15 @@ export function createOnboardingApi(deps) {
       }
 
       saveConfigAndAdopt(canonicalizeAgentRouteStorage(nextConfig));
-      if (defaultRoute) {
+      // Whatever wrote the Lead route also moves the runtime Main route, in the
+      // same synchronous step as the save: a pending conditional backfill then
+      // finds a route that is not empty instead of overwriting this choice.
+      if (draft.leadRoute) {
         setRouteState(
           resolveRoute(getConfig(), {
-            provider: defaultRoute.provider,
-            model: defaultRoute.model,
-            effort: defaultRoute.effort,
+            provider: draft.leadRoute.provider,
+            model: draft.leadRoute.model,
+            effort: draft.leadRoute.effort,
           })
         );
         deps.invalidatePreSessionToolSurface?.();

package/src/session-runtime/workflow-agents-api/shared.mjs

@@ -1,5 +1,9 @@
 import { oneLine } from '../../runtime/shared/clean.mjs';
-import { normalizeAgentId, normalizeWorkflowId, normalizeWorkflowRoute } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
+import {
+  normalizeAgentId,
+  normalizeWorkflowId,
+  normalizeWorkflowRoute,
+} from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
 
 export function resolveDataDir({ cfgMod, STANDALONE_DATA_DIR }) {
   return cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;

package/src/session-runtime/workflow-agents-api/style-and-mode.mjs

@@ -35,10 +35,23 @@ export function createStyleAndModeApi(deps) {
     return { ...freshStatus, appliedToCurrentSession };
   }
 
-  async function setOrchestrationMode(mode) {
+  // `{ scope: 'session' }` (the composer's selector in a session), like
+  // setWorkflow: a session with a conversation switches alone
+  // (switchSessionOrchestrationMode; deferred to its next turn while one
+  // runs) and the configured mode — the default for new sessions — stays.
+  // Otherwise the choice becomes the configured mode and an empty session
+  // picks it up in place.
+  async function setOrchestrationMode(mode, options = {}) {
     if (!ORCHESTRATION_MODES.includes(mode)) {
       throw new Error(`orchestration mode must be one of ${ORCHESTRATION_MODES.join(', ')}`);
     }
+    if (options?.scope === 'session') {
+      const switched = await deps.switchSessionOrchestrationMode?.(mode);
+      if (switched) {
+        invalidateContextStatusCache();
+        return switched;
+      }
+    }
     saveConfigAndAdopt({ ...getConfig(), orchestrationMode: mode });
     const applied = await deps.refreshEmptySessionToolPolicy?.();
     deps.invalidatePreSessionToolSurface?.();

package/src/session-runtime/workflow-agents-api/workflow-packs.mjs

@@ -1,5 +1,6 @@
 import { join } from 'node:path';
-import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, rmSync } from 'node:fs';
+import { writeFileAtomicSync } from '../../runtime/shared/atomic-file.mjs';
 import { serializeFrontmatterDoc } from '../../runtime/shared/markdown-frontmatter.mjs';
 import {
   normalizeWorkflowId,
@@ -44,6 +45,7 @@ export function createWorkflowPacksApi(deps) {
       name: workflow.name,
       description: workflow.description,
       source: workflow.source,
+      ...(workflow.overridesBuiltIn ? { overridesBuiltIn: true } : {}),
       active: workflow.id === active,
     }));
   }
@@ -106,9 +108,10 @@ export function createWorkflowPacksApi(deps) {
     if (!absorbed) {
       const dir = join(dataDir, 'workflows', id);
       mkdirSync(dir, { recursive: true });
-      writeFileSync(
+      writeFileAtomicSync(
         join(dir, 'WORKFLOW.md'),
-        serializeFrontmatterDoc({ id, name, ...(description ? { description } : {}) }, body)
+        serializeFrontmatterDoc({ id, name, ...(description ? { description } : {}) }, body),
+        { backup: true, mode: 0o644 }
       );
     }
     return getWorkflowPack(id);

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

@@ -4,8 +4,9 @@
  * resume (missing worktree → recovery), and carrying the Project's memory
  * identity into a new worktree.
  */
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { holdsNoData, writeFileAtomicSync } from '../../runtime/shared/atomic-file.mjs';
 import { isWorktreeBound, nextRevision, normalizeSessionWorkspace } from '../../runtime/shared/worktrees/contract.mjs';
 import { isWithin, samePath } from '../../runtime/shared/worktrees/paths.mjs';
 import { resolveProjectId } from '../../runtime/memory/lib/project-id-resolver.mjs';
@@ -103,10 +104,10 @@ export function restoreWorkspaceAfterResume(session) {
  */
 export function copyProjectIdentity(projectPath, worktreePath) {
   const target = join(worktreePath, '.mixdog', 'project.id');
-  if (existsSync(target)) return false;
+  // An id file with no data (empty, or NUL-filled by a crash) is missing.
+  if (existsSync(target) && !holdsNoData(readFileSync(target))) return false;
   const id = resolveProjectId(projectPath);
-  if (!id) return false;
-  mkdirSync(dirname(target), { recursive: true });
-  writeFileSync(target, `${id}\n`, 'utf8');
+  if (!id || holdsNoData(id)) return false;
+  writeFileAtomicSync(target, `${id}\n`, { mode: 0o644 });
   return true;
 }

package/src/standalone/daemon-agent-control.mjs

@@ -54,7 +54,10 @@ export function createCanonicalAgentControl({ getSessionService, getSessionRunti
       ownerSessionId: sessionService.rootOwnerSessionId(parentSessionId),
     };
     if (String(args?.type || '') === '__close_all') {
-      await tool.closeAll?.(String(args?.reason || 'agent owner closed'), { callerSessionId: parentSessionId || null });
+      await tool.closeAll?.(String(args?.reason || 'agent owner closed'), {
+        callerSessionId: parentSessionId || null,
+        processExit: args?.processExit === true,
+      });
       await sessionService.cancelAgentDescendants(parentSessionId, String(args?.reason || 'agent owner closed'));
       return 'agent close all: ok';
     }

package/src/standalone/daemon-session-control.mjs

@@ -1,18 +1,25 @@
 import { SESSION_ID_PATTERN } from '../runtime/agent/orchestrator/runtime-core/session-id.mjs';
 import { sessionListOutput, sessionReadOutput, SESSION_TOOL_OUTPUT_BYTES } from './session-tool-output.mjs';
 import { createAgentTaskSessions } from '../session-runtime/agent-task-sessions.mjs';
+import { createBotStatus, scanCatalog, scopedBot, sessionBotOf } from '../session-runtime/bot-status.mjs';
+import { handoffContent } from '../session-runtime/handoff-attachments.mjs';
+import { BOT_HOP_LIMIT_ERROR, MAX_BOT_HOPS } from '../runtime/shared/bot-hops.mjs';
+import { rebindDelegation } from '../runtime/agent/orchestrator/session/human-gate/delegation.mjs';
 
 const TARGET_ACTIONS = new Set(['status', 'read', 'send', 'cancel', 'delete']);
 const MUTATING_ACTIONS = new Set(['send', 'cancel', 'delete']);
+// Why a send from a conversation that is no bot's reports nothing back.
+const NOT_BOT_REASON = 'only a bot conversation gets session results reported back; check that session for the result';
 
 /** Model-facing session operations over the same service used by desktop and TUI. */
 export function createSessionControl({
   getSessionService,
   agentTasks = createAgentTaskSessions({ getSessionService }),
+  botStatus = createBotStatus({ getSessionService }),
 }) {
   return async function executeSessionControl(args = {}, context = {}) {
     const action = args.action;
-    if (action !== 'list' && action !== 'create' && !TARGET_ACTIONS.has(action)) {
+    if (action !== 'list' && action !== 'create' && action !== 'bots' && !TARGET_ACTIONS.has(action)) {
       throw new Error(`session: unsupported remote action "${action}"`);
     }
     const caller = context.callerSessionId;
@@ -21,8 +28,10 @@ export function createSessionControl({
     }
     // `callerAgentId`: set only for an attended agent conversation (workspace-tools.mjs).
     if (action === 'create') return agentTasks.create(args, context);
+    // `callerScope`: the caller's schedule-access scope (workspace-tools.mjs).
+    if (action === 'bots') return botStatus(args, context);
     const sessionId = typeof args.session_id === 'string' ? args.session_id.trim() : '';
-    if (TARGET_ACTIONS.has(action) && (typeof sessionId !== 'string' || !SESSION_ID_PATTERN.test(sessionId))) {
+    if (TARGET_ACTIONS.has(action) && !SESSION_ID_PATTERN.test(sessionId)) {
       throw new Error(`session: session_id is required for action=${action}`);
     }
     if (MUTATING_ACTIONS.has(action) && sessionId === caller) {
@@ -44,22 +53,63 @@ export function createSessionControl({
     const service = getSessionService();
     if (!service) throw new Error('session: session service is unavailable');
     if (action === 'list') {
+      // Scoped like bots (`callerScope`, bot-status.mjs): the human's sessions
+      // list everything, a bot (or its unattended run) only its own sessions,
+      // anything else the plain rows without previews.
+      const own = scopedBot(context.callerScope);
+      if (own) {
+        const scan = await scanCatalog(service, (row) => sessionBotOf(row) === own, {
+          cursor: args.cursor || null,
+          want: limit,
+        });
+        return sessionListOutput({ sessions: scan.rows, nextCursor: scan.nextCursor }, limit);
+      }
       const page = await service.listSessionCatalog({ page: { limit, cursor: args.cursor || null } });
-      return sessionListOutput(page, limit);
+      return sessionListOutput(page, limit, { rich: own === '' });
     }
     if (action === 'send') {
       if (typeof args.prompt !== 'string' || !args.prompt.trim()) {
         throw new Error('session: prompt is required for action=send');
       }
-      // The agent's follow-up in a task session it created reports back too.
-      const origin = await agentTasks.originFor(sessionId, context.callerAgentId);
-      if (origin) return { sessionId, accepted: await agentTasks.send(sessionId, args.prompt, origin) };
+      // An agent conversation's send reports its turn back to the agent's
+      // home: a task session it created by its stored origin, any other
+      // session by an origin for this send only.
+      // Forwarded files ride along as stored attachment parts (workspace-tools.mjs).
+      const prompt = handoffContent(args.prompt, context.attachmentParts);
+      let origin = await agentTasks.reportOrigin(sessionId, context.callerAgentId, caller);
+      // A send made in a bot-descended turn (`callerHop` > 0), or by a bot to
+      // another session, extends the chain by one; a bot's own task session
+      // only continues it. Refused past the limit, whatever the target.
+      const turnHop = Number(context.callerHop) || 0;
+      const chained = (hop) => {
+        if (hop > MAX_BOT_HOPS) throw new Error(BOT_HOP_LIMIT_ERROR);
+        return hop;
+      };
+      if (origin) {
+        const hop = chained(origin.target === 'session' ? turnHop + 1 : turnHop);
+        if (hop > 0) origin = { ...origin, hop };
+        // The task session a bot created acts as the sending conversation does
+        // from now on (attended chat or run); another's session keeps its own.
+        if (origin.target !== 'session') await rebindDelegation(sessionId, caller);
+        const sent = await agentTasks.send(sessionId, prompt, origin);
+        return { sessionId, ...sent, ...(hop > 0 ? { hop } : {}) };
+      }
+      const hop = turnHop > 0 ? chained(turnHop + 1) : 0;
+      // New work from this sender: a delegated target acts as the sender does.
+      await rebindDelegation(sessionId, caller);
       const result = await service.submitSession({
         sessionId,
-        prompt: args.prompt,
-        options: { mode: 'prompt', transcriptMeta: { sender: 'lead' } },
+        prompt,
+        options: { mode: 'prompt', transcriptMeta: { sender: 'lead', ...(hop > 0 ? { hop } : {}) } },
       });
-      return { sessionId, accepted: result.accepted === true };
+      const accepted = result.accepted === true;
+      return {
+        sessionId,
+        accepted,
+        reportsBack: false,
+        ...(accepted ? { reportsBackReason: NOT_BOT_REASON } : {}),
+        ...(hop > 0 ? { hop } : {}),
+      };
     }
     if (action === 'cancel') {
       const result = await service.abortSession({ sessionId });
@@ -83,7 +133,7 @@ export function createSessionControl({
     });
     const snapshot = result.full;
     if (!snapshot) throw new Error(`session: ${sessionId} is unavailable`);
-    const status = {
+    return {
       sessionId,
       title: snapshot.title ?? null,
       cwd: snapshot.cwd ?? null,
@@ -92,6 +142,5 @@ export function createSessionControl({
       busy: snapshot.busy === true,
       quotaResume: snapshot.quotaResume ?? null,
     };
-    return status;
   };
 }

package/src/standalone/daemon.mjs

@@ -96,6 +96,7 @@ import { createChannelsRuntimeLoader } from './daemon-channels-loader.mjs';
 import { createDesktopRuntime } from './daemon-desktop-runtime.mjs';
 import { createCanonicalAgentControl } from './daemon-agent-control.mjs';
 import { createSessionControl } from './daemon-session-control.mjs';
+import { createAgentTaskSessions } from '../session-runtime/agent-task-sessions.mjs';
 import { flushAllIndexWrites } from '../session-runtime/services/agent-tool/index-write-queue.mjs';
 import {
   compareRuntimeVersions,
@@ -926,6 +927,15 @@ async function main() {
     cwd: CWD,
   });
   canonicalAgentControl = agentControl;
+  // Agents' cross-session sends and task sessions, and their report watches.
+  const agentTasks = createAgentTaskSessions({
+    getSessionService: () => sessionService,
+    // A task session re-attached after a restart takes its agents' queued
+    // results through the owner runtime's notification bus.
+    deliverCompletion: (sessionId, text, meta) =>
+      sessionRuntimeHost?.notifySessionCompletion?.(sessionId, text, meta) === true,
+    settleAgentResults: async () => (await agentControl.canonicalAgentTool()).settleRestartFailures(),
+  });
   const requestedRuntimeMode = String(process.env.MIXDOG_SESSION_RUNTIME_MODE || '')
     .trim()
     .toLowerCase();
@@ -939,7 +949,7 @@ async function main() {
     log,
     measureBootPhase: bootPhases.measure,
     executeAgentControl: agentControl.execute,
-    executeSessionControl: createSessionControl({ getSessionService: () => sessionService }),
+    executeSessionControl: createSessionControl({ getSessionService: () => sessionService, agentTasks }),
   });
   // Codex-style runtime: daemon routing and independent async session actors
   // share one V8 isolate and module graph. CPU-heavy work stays in bounded
@@ -986,9 +996,27 @@ async function main() {
   setAgentHomeLiveSurface({
     busy: (sessionId) => sessionService.liveSessionBusy(sessionId),
     notice: (sessionId, notice) => sessionService.pushLiveSessionNotice(sessionId, notice),
-    // A task session's result (session create): the agent relays it in one turn.
-    wake: (sessionId, prompt) =>
-      sessionService.submitSession({ sessionId, prompt, options: { mode: 'prompt', kickoff: true } }),
+    // A task session's result (session create): the agent relays it in one
+    // turn. Resolves false when the turn was refused, else `{ settled }`, the
+    // turn's end status ('done' when it finished).
+    wake: async (sessionId, prompt, { id, hop = 0 } = {}) => {
+      let settle = () => {};
+      const settled = new Promise((resolveSettled) => {
+        settle = resolveSettled;
+      });
+      const result = await sessionService.submitSession({
+        sessionId,
+        prompt,
+        options: {
+          mode: 'prompt',
+          kickoff: true,
+          ...(id ? { id } : {}),
+          ...(hop > 0 ? { transcriptMeta: { hop } } : {}),
+          onSettled: (detail) => settle(String(detail?.status || 'failed')),
+        },
+      });
+      return result?.accepted === true ? { settled } : false;
+    },
     // A routine fire: one queued turn in its bot's thread (routine-home-turn.mjs).
     submit: async (sessionId, prompt, options) =>
       (await sessionService.submitSession({ sessionId, prompt, options }))?.accepted === true,
@@ -997,6 +1025,8 @@ async function main() {
   // Results queued before a restart are posted now; results a finished run
   // could not queue (kept on its routine's record) are queued again.
   recoverScheduleResults().catch((error) => log(`routine results recovery failed: ${error?.message || error}`));
+  // Agents' sends whose report an earlier process had not queued yet.
+  agentTasks.recover().catch((error) => log(`agent task report recovery failed: ${error?.message || error}`));
   recoverRoutineDeliveries().catch((error) => log(`routine delivery recovery failed: ${error?.message || error}`));
   sessionTransport = createSessionTransport({
     // ctx carries the CLIENT token: the session service refcounts views across

package/src/standalone/local-session-runtime.mjs

@@ -12,7 +12,7 @@ import { performance } from 'node:perf_hooks';
 import { isDeepStrictEqual } from 'node:util';
 import { bootProfile } from '../tui/session/boot-profile.mjs';
 import { createGoalContinuation } from '../tui/session/goal-continuation.mjs';
-import { createToolApproval } from '../tui/session/tool-approval.mjs';
+import { createToolApproval, resolveToolApprovalTimeoutMs } from '../tui/session/tool-approval.mjs';
 import { createToolCardResults } from '../tui/session/tool-card-results.mjs';
 import { createAgentJobFeed } from '../tui/session/agent-job-feed.mjs';
 import { createWorktreeSetupNotices } from '../tui/session/worktree-setup-notice.mjs';
@@ -83,10 +83,9 @@ export function setSessionRuntimeImporterForTest(importer) {
   sessionRuntimeModulePromise = null;
 }
 
-const TOOL_APPROVAL_TIMEOUT_MS = (() => {
-  const value = Number(process.env.MIXDOG_TOOL_APPROVAL_TIMEOUT_MS);
-  return Number.isFinite(value) && value > 0 ? Math.max(1000, Math.round(value)) : 120_000;
-})();
+// An approval waits until the user answers (Deny, Stop or a closing runtime
+// settle it); MIXDOG_TOOL_APPROVAL_TIMEOUT_MS opts into a limit for tests/ops.
+const TOOL_APPROVAL_TIMEOUT_MS = resolveToolApprovalTimeoutMs();
 
 export {
   cleanupStaleTranscriptSpillDirs,
@@ -306,15 +305,22 @@ export async function createLocalSessionRuntime({
     pushItem,
     replaceItems,
   });
-  const { presentNextToolApproval, finishToolApproval, denyAllToolApprovals, requestToolApproval } = createToolApproval(
-    {
-      getState,
-      set,
-      nextId,
-      getDisposed: () => flags.disposed,
-      timeoutMs: TOOL_APPROVAL_TIMEOUT_MS,
-    }
-  );
+  // A sub-agent's approvals also show in the top-level chat (human-gate/gate.mjs).
+  const { approvalSurface } = await import('../runtime/agent/orchestrator/session/human-gate/gate.mjs');
+  const {
+    presentNextToolApproval,
+    finishToolApproval,
+    denyAllToolApprovals,
+    requestToolApproval,
+    adoptDelegatedApprovals,
+  } = createToolApproval({
+    getState,
+    set,
+    nextId,
+    getDisposed: () => flags.disposed,
+    timeoutMs: TOOL_APPROVAL_TIMEOUT_MS,
+    surfaceOf: approvalSurface,
+  });
   const runtimePulse = createRuntimePulse({
     flags,
     getState,
@@ -336,6 +342,8 @@ export async function createLocalSessionRuntime({
   lifecycle.runtimePulseTimer = setInterval(() => {
     headWatch.retarget();
     runtimePulse();
+    // A sub-agent's approval made before this session loaded (or bound its id).
+    adoptDelegatedApprovals();
   }, 2000);
   lifecycle.runtimePulseTimer.unref?.();
 

package/src/standalone/session-client.mjs

@@ -148,12 +148,12 @@ function request({
       }
     );
     req.on('timeout', () => {
-      req.destroy(new Error(`session timeout: ${method} ${urlPath}`));
+      req.destroy(sessionTimeoutError(method, urlPath));
     });
     req.on('error', reject);
     if (deadlineMs > 0) {
       deadlineTimer = setTimeout(() => {
-        const error = new Error(`session timeout: ${method} ${urlPath}`);
+        const error = sessionTimeoutError(method, urlPath);
         reject(error);
         req.destroy(error);
       }, deadlineMs);
@@ -163,6 +163,11 @@ function request({
   });
 }
 
+/** No answer within the request's bound: the daemon may be busy with it, not gone. */
+function sessionTimeoutError(method, urlPath) {
+  return Object.assign(new Error(`session timeout: ${method} ${urlPath}`), { code: 'ESESSIONTIMEOUT' });
+}
+
 /** /health within `timeoutMs` of total duration; null when it does not answer. */
 export async function probeSessionHealth({ port, token, timeoutMs = 800 } = {}) {
   try {