mixdog 1.3.1 → 1.3.3

package/src/session-runtime/workspace/worktree-tool.mjs

@@ -0,0 +1,194 @@
+/**
+ * The Lead's managed-worktree operations behind the `git` tool
+ * (`action: "worktree"` and the mapped `git worktree …` commands), over the
+ * same workspace authority the desktop branch menu drives:
+ *
+ * - The caller's own session runs through this runtime's workspace API with
+ *   `ownTurn` (the calling turn is tolerated; workers, background shells and
+ *   other sessions in an affected folder are not).
+ * - Another session runs through session control (the daemon's
+ *   `session.configure` lane): no `ownTurn`, so a target with a running turn,
+ *   workers or background shells refuses (WORKTREE_BUSY_JOBS).
+ *
+ * Every failure keeps its typed WorktreeError (code, details); interactive
+ * refusals (WORKTREE_DIRTY_CHOICE, WORKTREE_LARGE_REPO_CONFIRM) carry what the
+ * caller needs to ask the user before it calls again.
+ */
+import { worktreeError, worktreeNameError } from '../../runtime/shared/worktrees/contract.mjs';
+import { samePath } from '../../runtime/shared/worktrees/paths.mjs';
+import { assertWorktreeMutationAllowed, worktreeCallerScope } from '../services/worktree-access.mjs';
+
+const loadManager = () => import('../../runtime/shared/worktrees/manager.mjs');
+
+/**
+ * @param {object} deps
+ * @param {() => any} deps.getSession The Lead session this runtime hosts (its trusted caller scope).
+ * @param {() => any} deps.getWorkspaceApi The runtime's workspace transitions (late-bound).
+ * @param {((args: object, context: object) => Promise<any>)|null} [deps.executeSessionControl] Cross-session lane.
+ * @param {object|null} [deps.manager] Managed-worktree backend override (tests).
+ */
+export function createWorktreeToolHost({
+  getSession,
+  getWorkspaceApi,
+  executeSessionControl = null,
+  manager = null,
+}) {
+  const backend = () => (manager ? Promise.resolve(manager) : loadManager());
+
+  function workspaceApi() {
+    const api = getWorkspaceApi();
+    if (!api) throw new Error('git worktree: managed worktrees are unavailable in this runtime');
+    return api;
+  }
+
+  /**
+   * The workspace lane of `sessionId`: the caller's own (null/equal) or
+   * another session's, which carries the caller's trusted `scope` for the
+   * daemon to check again.
+   */
+  function laneFor(sessionId, callerSessionId, scope) {
+    if (!sessionId || sessionId === callerSessionId) {
+      const api = workspaceApi();
+      return {
+        own: true,
+        menu: () => api.getBranchMenu(),
+        call: (method, input) => api[method](input, { ownTurn: true }),
+      };
+    }
+    if (typeof executeSessionControl !== 'function') {
+      throw new Error("git worktree: another session's workspace is unavailable in this runtime");
+    }
+    const control = (method, input) =>
+      executeSessionControl(
+        { action: 'worktree', session_id: sessionId, method, ...(input ? { input } : {}) },
+        { callerSessionId, callerScope: scope }
+      );
+    return { own: false, menu: () => control('getBranchMenu'), call: control };
+  }
+
+  async function enter(lane, request) {
+    if (request.branch) {
+      return lane.call('selectBranch', {
+        branch: request.branch,
+        create: request.create === true,
+        confirmLarge: request.confirmLarge === true,
+        txId: request.txId,
+      });
+    }
+    // A valid slug names the worktree; any other text is a hint the slug is made from.
+    const name = typeof request.name === 'string' ? request.name.trim() : '';
+    const slug = name && !worktreeNameError(name) ? name : null;
+    return lane.call('requestWorktree', {
+      provision: true,
+      name: slug,
+      prompt: slug ? '' : name,
+      ...(request.carry ? { carryChanges: request.carry } : {}),
+      confirmLarge: request.confirmLarge === true,
+      txId: request.txId,
+    });
+  }
+
+  /** Back to the project folder (the branch checked out there); the worktree stays retained. */
+  async function back(lane, request) {
+    const menu = await lane.menu();
+    const workspace = menu.workspace;
+    if (!workspace.worktreeId && samePath(workspace.cwd, workspace.projectPath)) {
+      return { revision: workspace.revision, workspace, unchanged: true };
+    }
+    const projectBranch = menu.occupancy.find((row) => row.kind === 'current')?.branch ?? null;
+    if (!projectBranch) {
+      throw worktreeError(
+        'WORKTREE_UNSUPPORTED_REPO',
+        'The project folder has no checked-out branch to return to (detached HEAD).'
+      );
+    }
+    return lane.call('selectBranch', { branch: projectBranch, expectedRevision: workspace.revision, txId: request.txId });
+  }
+
+  /** The desktop's "merge": into the confirmed merge target, then the cleanup autoCleanup allows. */
+  async function merge(lane) {
+    const { workspace } = await lane.menu();
+    return lane.call('mergeWorkspace', {
+      confirmed: true,
+      target: workspace.mergeTarget ?? null,
+      expectedRevision: workspace.revision,
+      cleanup: true,
+    });
+  }
+
+  /**
+   * `git worktree remove <path>`: the managed removal of whichever owner
+   * holds it — this session's snapshot, or the worktree a session retains
+   * (its own lane: the same guards as the desktop's removal).
+   */
+  async function removePath(request, callerSessionId, scope) {
+    const entry = await (await backend()).getWorktreeByPath(request.path);
+    if (!entry) {
+      throw new Error(
+        `git worktree remove: ${request.path} is not a Mixdog-managed worktree; unmanaged worktrees are not removed through the git tool`
+      );
+    }
+    if (entry.kind === 'snapshot') return workspaceApi().removeSnapshot({ path: entry.path, force: request.force });
+    if (!entry.ownerSessionId) {
+      throw new Error(
+        `git worktree remove: no session retains ${entry.path}; git worktree prune removes it once it is clean and merged`
+      );
+    }
+    const lane = laneFor(entry.ownerSessionId, callerSessionId, scope);
+    const menu = await lane.menu();
+    if (menu.retainedWorktree?.id !== entry.id) {
+      throw new Error(
+        `git worktree remove: ${entry.path} is not the current worktree of session ${entry.ownerSessionId}; enter it (worktree_action enter, branch ${entry.branch}) first, then remove it`
+      );
+    }
+    return lane.call('removeWorktree', { force: request.force === true, expectedRevision: menu.workspace.revision });
+  }
+
+  /**
+   * @param {{ op: string } & Record<string, any>} request
+   * @param {{ callerSessionId: string }} context
+   */
+  async function run(request, { callerSessionId }) {
+    // Trusted state of the calling Lead, never model input: every operation
+    // but `list` needs an attended conversation.
+    const scope = worktreeCallerScope(getSession());
+    if (request.op !== 'list') assertWorktreeMutationAllowed(scope, `git worktree ${request.op}`);
+    const lane = () => laneFor(request.sessionId, callerSessionId, scope);
+    switch (request.op) {
+      case 'enter':
+        return enter(lane(), request);
+      case 'return':
+        return back(lane(), request);
+      case 'merge':
+        return merge(lane());
+      case 'remove':
+        return lane().call('removeWorktree', { force: request.force === true });
+      case 'list':
+        return workspaceApi().listWorktrees({ includeSnapshots: true });
+      case 'prune':
+        return workspaceApi().pruneWorktrees({ repoCommonDir: request.repoCommonDir ?? null });
+      case 'add':
+        return workspaceApi().addBranchWorktree({
+          branch: request.branch,
+          create: request.create === true,
+          startPoint: request.startPoint ?? null,
+          confirmLarge: request.confirmLarge === true,
+          txId: request.txId,
+          repoCommonDir: request.repoCommonDir ?? null,
+        });
+      case 'snapshot':
+        return workspaceApi().createSnapshot({
+          commit: request.commit,
+          confirmLarge: request.confirmLarge === true,
+          txId: request.txId,
+          repoCommonDir: request.repoCommonDir ?? null,
+        });
+      case 'remove-path':
+        return removePath(request, callerSessionId, scope);
+      default:
+        throw new TypeError(`git worktree: unknown operation ${request.op}`);
+    }
+  }
+
+  return { run };
+}

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-lag-profiler.mjs

@@ -20,7 +20,9 @@ export const LAG_PROFILE_KEEP = 10;
 export const LAG_PROFILE_TOP = 15;
 export const LAG_PROFILE_SAMPLING_US = 1000;
 export const LAG_P99_THRESHOLD_MS = 1000;
-export const LAG_MAX_THRESHOLD_MS = 2000;
+// The owner lease's stall threshold: any window holding one logged
+// `event loop stalled` line is kept.
+export const LAG_MAX_THRESHOLD_MS = 1000;
 
 const PROFILE_FILE_RE = /^daemon-lag-.+\.cpuprofile$/;
 const SRC_ROOT = fileURLToPath(new URL('..', import.meta.url));

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

@@ -1,19 +1,85 @@
 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 { assertWorktreeMutationAllowed } from '../session-runtime/services/worktree-access.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';
+import { isAgentOnlySession } from '../runtime/agent/orchestrator/session/store-summary-visibility.mjs';
+import { readSessionSidebarState } from '../runtime/shared/session-sidebar-host.mjs';
+import { agentRoomHost } from '../runtime/shared/agent-room-host.mjs';
+import {
+  roomIdOfSession,
+  roomMemberOfSession,
+  roomSessionId,
+} from '../runtime/agent/orchestrator/session/agent-room.mjs';
 
 const TARGET_ACTIONS = new Set(['status', 'read', 'send', 'cancel', 'delete']);
 const MUTATING_ACTIONS = new Set(['send', 'cancel', 'delete']);
+// The workspace methods `worktree` reaches on another session (all on the
+// session protocol's read/configure allowlists).
+const WORKTREE_METHODS = new Set(['getBranchMenu', 'requestWorktree', 'selectBranch', 'mergeWorkspace', 'removeWorktree']);
+// 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';
+
+/** The member a send to room log `sessionId` addresses, through the desktop
+ *  room host: `{ host, agentId, sessionId, text }`; throws when no desktop is
+ *  attached or no member resolves. */
+async function roomAddressee(sessionId, args) {
+  let host;
+  try {
+    host = agentRoomHost();
+  } catch (error) {
+    throw new Error(`session: cannot send to ${sessionId}: ${error.message}`);
+  }
+  const member = await host.member(sessionId, { to: args.to, prompt: args.prompt }).catch((error) => {
+    throw new Error(`session: ${error?.message || error}`);
+  });
+  return { host, ...member };
+}
 
 /** Model-facing session operations over the same service used by desktop and TUI. */
 export function createSessionControl({
   getSessionService,
   agentTasks = createAgentTaskSessions({ getSessionService }),
+  botStatus = createBotStatus({ getSessionService }),
 }) {
+  /**
+   * Another session's workspace for the git tool's worktree operations
+   * (session-runtime/workspace/worktree-tool.mjs): one workspace method with
+   * one input, through the same configure / read lanes the desktop uses. No
+   * `ownTurn` ever crosses: the target must be idle. A change (anything but
+   * the menu read) needs the caller's trusted scope (`callerScope`, from
+   * worktree-access.mjs worktreeCallerScope) to be an attended conversation.
+   */
+  async function worktreeControl(args, caller, callerScope) {
+    const sessionId = typeof args.session_id === 'string' ? args.session_id.trim() : '';
+    if (!SESSION_ID_PATTERN.test(sessionId)) throw new Error('session: session_id is required for action=worktree');
+    if (sessionId === caller) throw new Error('session: worktree control must target another session');
+    if (!WORKTREE_METHODS.has(args.method)) throw new Error(`session: unsupported worktree method "${args.method}"`);
+    if (args.method !== 'getBranchMenu') assertWorktreeMutationAllowed(callerScope, `session: worktree ${args.method}`);
+    const service = getSessionService();
+    if (!service) throw new Error('session: session service is unavailable');
+    if (args.method === 'getBranchMenu') {
+      return (await service.readSession({ sessionId, action: 'getBranchMenu', args: [] })).value;
+    }
+    const result = await service.configureSession(
+      { sessionId, action: args.method, args: [args.input ?? {}] },
+      { revision: 1 }
+    );
+    return result.value;
+  }
+
   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' &&
+      action !== 'worktree' &&
+      !TARGET_ACTIONS.has(action)
+    ) {
       throw new Error(`session: unsupported remote action "${action}"`);
     }
     const caller = context.callerSessionId;
@@ -22,8 +88,11 @@ export function createSessionControl({
     }
     // `callerAgentId`: set only for an attended agent conversation (workspace-tools.mjs).
     if (action === 'create') return agentTasks.create(args, context);
+    if (action === 'worktree') return worktreeControl(args, caller, context.callerScope);
+    // `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) {
@@ -45,31 +114,121 @@ export function createSessionControl({
     const service = getSessionService();
     if (!service) throw new Error('session: session service is unavailable');
     if (action === 'list') {
-      const page = await service.listSessionCatalog({ page: { limit, cursor: args.cursor || null } });
-      return sessionListOutput(page, limit);
+      for (const flag of ['include_agents', 'include_archived']) {
+        if (args[flag] !== undefined && typeof args[flag] !== 'boolean') {
+          throw new Error(`session: ${flag} must be a boolean`);
+        }
+      }
+      // 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. Sub-agent sessions (a
+      // parent finds its own through the agent tool) and archived ones (the
+      // desktop's flag) only on request; the scan pages past the rows left
+      // out, so a page is never short while more rows match.
+      const own = scopedBot(context.callerScope);
+      const archived = (await readSessionSidebarState())?.archived ?? {};
+      const keep = (row) =>
+        (!own || sessionBotOf(row) === own) &&
+        (args.include_agents === true || !isAgentOnlySession(row)) &&
+        (args.include_archived === true || !Object.hasOwn(archived, row.id));
+      // Bounded: past 10000 rows scanned with fewer than `limit` matching, the
+      // page ends (possibly empty) with a nextCursor to continue from.
+      const scan = await scanCatalog(service, keep, { cursor: args.cursor || null, want: limit, maxRows: 10_000 });
+      const sessions = scan.rows.map((row) => (Object.hasOwn(archived, row.id) ? { ...row, archived: true } : row));
+      return sessionListOutput({ sessions, nextCursor: scan.nextCursor }, limit, { rich: own !== null });
     }
     if (action === 'send') {
       if (typeof args.prompt !== 'string' || !args.prompt.trim()) {
         throw new Error('session: prompt is required for action=send');
       }
+      // A room member's session is the room's to drive: a message goes to the
+      // room, naming the member.
+      if (roomMemberOfSession(sessionId)) {
+        throw new Error(
+          `session: ${sessionId} is a group-room member's session; send to its room (session_id ${roomSessionId(roomMemberOfSession(sessionId).roomId)}) with to: <member>`
+        );
+      }
+      // A send to a room's log is a message to one member there (`to`, or a
+      // leading @name), run by the desktop room host; the member's turn in
+      // its member session is the turn that answers and reports.
+      const room = roomIdOfSession(sessionId) ? await roomAddressee(sessionId, args) : null;
+      if (room?.sessionId === caller) throw new Error('session: send must target another session');
       // 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);
-      const origin = await agentTasks.reportOrigin(sessionId, context.callerAgentId, caller);
+      const prompt = handoffContent(room ? room.text : args.prompt, context.attachmentParts);
+      const turnSessionId = room ? room.sessionId : sessionId;
+      const from = { sessionId: caller, ...(context.callerAgentId ? { agentId: context.callerAgentId } : {}) };
+      // The member's turn carries the send's hop (`transcriptMeta.hop`), so a
+      // chain through the room counts on toward MAX_BOT_HOPS.
+      const submit = room
+        ? async ({ id, onSettled, follow, transcriptMeta } = {}) => ({
+            accepted:
+              (await room.host.ask(sessionId, {
+                agentId: room.agentId,
+                prompt,
+                from,
+                ...(id ? { id } : {}),
+                ...(transcriptMeta?.hop > 0 ? { hop: transcriptMeta.hop } : {}),
+                ...(onSettled ? { onSettled } : {}),
+                ...(follow ? { follow } : {}),
+              })) === true,
+          })
+        : null;
+      const addressed = room ? { to: room.agentId } : {};
+      let origin = await agentTasks.reportOrigin(turnSessionId, 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 { accepted, reportsBack } = await agentTasks.send(sessionId, prompt, origin);
-        return { sessionId, accepted, reportsBack };
+        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(turnSessionId, prompt, origin, submit);
+        return { sessionId, ...addressed, ...sent, ...(hop > 0 ? { hop } : {}) };
       }
-      const result = await service.submitSession({
+      const hop = turnHop > 0 ? chained(turnHop + 1) : 0;
+      let accepted;
+      if (submit) accepted = (await submit(hop > 0 ? { transcriptMeta: { hop } } : {})).accepted;
+      else {
+        // New work from this sender: a delegated target acts as the sender does.
+        await rebindDelegation(sessionId, caller);
+        const result = await service.submitSession({
+          sessionId,
+          prompt,
+          options: { mode: 'prompt', transcriptMeta: { sender: 'lead', ...(hop > 0 ? { hop } : {}) } },
+        });
+        accepted = result.accepted === true;
+      }
+      return {
         sessionId,
-        prompt,
-        options: { mode: 'prompt', transcriptMeta: { sender: 'lead' } },
-      });
-      return { sessionId, accepted: result.accepted === true, reportsBack: false };
+        ...addressed,
+        accepted,
+        reportsBack: false,
+        ...(accepted ? { reportsBackReason: NOT_BOT_REASON } : {}),
+        ...(hop > 0 ? { hop } : {}),
+      };
     }
     if (action === 'cancel') {
+      // A room's exchange is run by the desktop room host, so its stop (the UI
+      // stop button) ends it; the log is not a session the service can abort.
+      if (roomIdOfSession(sessionId)) {
+        let host;
+        try {
+          host = agentRoomHost();
+        } catch (error) {
+          throw new Error(`session: cannot cancel ${sessionId}: ${error.message}`);
+        }
+        return { sessionId, aborted: host.stop(sessionId) === true };
+      }
       const result = await service.abortSession({ sessionId });
       return { sessionId, aborted: result.aborted === true };
     }
@@ -91,7 +250,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,
@@ -100,6 +259,5 @@ export function createSessionControl({
       busy: snapshot.busy === true,
       quotaResume: snapshot.quotaResume ?? null,
     };
-    return status;
   };
 }

package/src/standalone/daemon-telemetry.mjs

@@ -184,6 +184,10 @@ export function createDaemonTelemetry({
   log = () => {},
   getWork = () => ({}),
   onInterval = null,
+  // Runs once when the loop starts, before its first window: a probe that
+  // judges each window (the lag profiler) arms here so the first one covers
+  // boot instead of starting only at the first tick.
+  onStart = null,
   now,
   pid,
   memoryUsage,
@@ -239,6 +243,11 @@ export function createDaemonTelemetry({
     }, ms);
     handle?.unref?.();
     timer = handle;
+    try {
+      onStart?.();
+    } catch {
+      /* a start probe must not stop the sample loop */
+    }
     return timer;
   }
 

package/src/standalone/daemon.mjs

@@ -359,6 +359,11 @@ slowSpans.setLog(log);
 daemonTelemetry = createDaemonTelemetry({
   log,
   getWork: inFlightWork,
+  // Arms the profiler at daemon-ready when lag-profile.on exists (a no-op
+  // without it), so the first window holds the startup stalls.
+  onStart() {
+    void lagProfiler.tick();
+  },
   onInterval() {
     // eventLoopDelay is reset at the end of every tick, so this status is the
     // lag of the 30s window that just ended — the same window the lag
@@ -928,7 +933,14 @@ async function main() {
   });
   canonicalAgentControl = agentControl;
   // Agents' cross-session sends and task sessions, and their report watches.
-  const agentTasks = createAgentTaskSessions({ getSessionService: () => sessionService });
+  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();
@@ -990,15 +1002,26 @@ async function main() {
     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. Resolves whether the turn was taken.
-    wake: async (sessionId, prompt, { id } = {}) =>
-      (
-        await sessionService.submitSession({
-          sessionId,
-          prompt,
-          options: { mode: 'prompt', kickoff: true, ...(id ? { id } : {}) },
-        })
-      )?.accepted === true,
+    // 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,

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';
@@ -41,13 +41,22 @@ import {
   createTranscriptSpillBuffer,
   sweepStaleTranscriptSpillDirsOnce,
 } from '../tui/session/transcript-spill.mjs';
+import { importInStages } from './staged-import.mjs';
 
 const SESSION_RUNTIME_MODULE = '../mixdog-session-runtime.mjs';
+// Its one module (only mixdog-session-runtime.mjs imports it): its boot
+// modules are the graph's stages.
+const SESSION_RUNTIME_CORE = '../session-runtime/runtime-core.mjs';
+const importSessionRuntimeInStages = () =>
+  importInStages(
+    new URL(SESSION_RUNTIME_MODULE, import.meta.url).href,
+    new URL(SESSION_RUNTIME_CORE, import.meta.url).href
+  );
 
 // Shared across create calls so concurrent session startups import the
 // runtime graph once.
 let sessionRuntimeModulePromise = null;
-let sessionRuntimeImporter = () => import(SESSION_RUNTIME_MODULE);
+let sessionRuntimeImporter = importSessionRuntimeInStages;
 function importSessionRuntimeModule() {
   // A failed import is forgotten so the next caller retries lazily.
   sessionRuntimeModulePromise ??= Promise.resolve()
@@ -79,14 +88,13 @@ export async function warmLocalSessionRuntime() {
 
 /** Test seam: replace the dynamic import of the session-runtime module. */
 export function setSessionRuntimeImporterForTest(importer) {
-  sessionRuntimeImporter = importer || (() => import(SESSION_RUNTIME_MODULE));
+  sessionRuntimeImporter = importer || importSessionRuntimeInStages;
   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 +314,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 +351,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?.();