mixdog 1.3.2 → 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-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,25 +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' && action !== 'bots' && !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;
@@ -28,6 +88,7 @@ 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() : '';
@@ -53,30 +114,70 @@ export function createSessionControl({
     const service = getSessionService();
     if (!service) throw new Error('session: session service is unavailable');
     if (action === 'list') {
+      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.
+      // 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);
-      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, { rich: own === '' });
+      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);
-      let 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.
@@ -91,20 +192,25 @@ export function createSessionControl({
         // 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 sent = await agentTasks.send(turnSessionId, prompt, origin, submit);
+        return { sessionId, ...addressed, ...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,
-        options: { mode: 'prompt', transcriptMeta: { sender: 'lead', ...(hop > 0 ? { hop } : {}) } },
-      });
-      const accepted = result.accepted === true;
+      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,
+        ...addressed,
         accepted,
         reportsBack: false,
         ...(accepted ? { reportsBackReason: NOT_BOT_REASON } : {}),
@@ -112,6 +218,17 @@ export function createSessionControl({
       };
     }
     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 };
     }

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

package/src/standalone/local-session-runtime.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,7 +88,7 @@ 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;
 }
 

package/src/standalone/session-protocol.mjs

@@ -22,6 +22,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getLeadPersona',
   'getLeadAgentBody',
   'getLeadStatus',
+  'getLeadHomeRoute',
   'getAutoClear',
   'getChannelSettings',
   'getChannelSetup',

package/src/standalone/session-runtime-inline-host/boot-loaders.mjs

@@ -57,6 +57,8 @@ export function createInlineBootLoaders({
     if (isClosed()) return false;
     try {
       const module = await loadLocalModule();
+      // A loop turn between the two graph loads: one piece held the loop.
+      await new Promise((resolve) => setImmediate(resolve));
       if (isClosed()) return false;
       return (await module.warmLocalSessionRuntime?.()) !== false;
     } catch {

package/src/standalone/session-service/agent-route-follow.mjs

@@ -0,0 +1,69 @@
+// A bot's saved model route reaches the chats it already has: its home thread
+// and its group-room member sessions, from their next turn (the session route
+// API's deferred pick, the one every model picker uses: a running turn finishes
+// on the model it started on). The latest saved route wins. A thread no
+// runtime hosts keeps its model until it is opened (the desktop refreshes it
+// then, agent-home-sessions.ts).
+import { subscribeAgentRouteChanges } from '../../session-runtime/agent-profile-changes.mjs';
+import { agentHomeSessionId } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { roomMemberOfSession } from '../../runtime/agent/orchestrator/session/agent-room.mjs';
+
+const ROUTE_KEYS = [
+  'provider',
+  'model',
+  'effort',
+  'fast',
+  'autoEffort',
+  'modelParameters',
+  'contextPercent',
+  'contextTokens',
+];
+
+/** The pick the session route API takes for a saved route. */
+function sessionRoutePick(route) {
+  const pick = { sessionOnly: true };
+  for (const key of ROUTE_KEYS) if (route?.[key] !== undefined && route[key] !== null) pick[key] = route[key];
+  return pick;
+}
+
+export function createAgentRouteFollow({ sessionsById, sessionOwner, advance, publishStep, log }) {
+  // Each chat takes its updates one at a time, in the order they were
+  // published: a slow chat never lets an older route land after a newer one.
+  const tails = new Map(); // sessionId -> Promise of its last queued update
+
+  function apply(sessionId, pick) {
+    const entry = sessionOwner(sessionId);
+    if (typeof entry?.runtime?.setRoute !== 'function') return Promise.resolve();
+    return Promise.resolve()
+      .then(async () => {
+        await entry.runtime.setRoute(pick);
+        const step = advance(entry);
+        if (step.changed) publishStep(entry, step);
+      })
+      .catch((error) => {
+        // A route the runtime refuses (provider signed out) leaves the chat on its model.
+        log(`agent route change not applied to ${sessionId}: ${error?.message || error}`);
+      });
+  }
+
+  function enqueue(sessionId, pick) {
+    const queued = (tails.get(sessionId) || Promise.resolve()).then(() => apply(sessionId, pick));
+    tails.set(sessionId, queued);
+    queued.then(() => {
+      if (tails.get(sessionId) === queued) tails.delete(sessionId);
+    });
+    return queued;
+  }
+
+  // Every matching chat is queued before the first await: publications queue in order.
+  function follow(agentId, route) {
+    const home = agentHomeSessionId(agentId);
+    if (!home || !route?.provider || !route?.model) return Promise.resolve();
+    const pick = sessionRoutePick(route);
+    const queued = [...sessionsById.keys()]
+      .filter((sessionId) => sessionId === home || roomMemberOfSession(sessionId)?.agentId === agentId)
+      .map((sessionId) => enqueue(sessionId, pick));
+    return Promise.all(queued);
+  }
+  return subscribeAgentRouteChanges(follow);
+}

package/src/standalone/session-service/session-calls/session-turns.mjs

@@ -62,15 +62,43 @@ export function createSessionTurnCalls(ctx) {
     return step;
   };
 
-  async function submitSession({ sessionId, prompt, options = {}, open: openHints = {}, baseRevision = null } = {}) {
+  // Intakes in flight per session: an abort of the session also cancels an
+  // attachment conversion that has not yet become a turn.
+  const intakeAborts = new Map();
+
+  async function submitSession({
+    sessionId,
+    prompt,
+    options = {},
+    open: openHints = {},
+    baseRevision = null,
+    signal = null,
+  } = {}) {
     const id = String(sessionId || '');
     if (!id) throw new TypeError('sessionId is required');
     const entry = await entryForSession(id, openHints || {});
     const target = entry.runtime.submitAsync;
     if (typeof target !== 'function') throw new TypeError('session runtime must implement submitAsync');
-    const intake = await preparePromptSubmissionForProvider(materializePromptSubmission(prompt, options || {}), {
-      nativePdf: providerNativePdf(entry.runtime.provider || entry.runtime.session?.provider || ''),
-    });
+    const intakeAbort = new AbortController();
+    const forwardAbort = () => intakeAbort.abort(signal.reason);
+    if (signal?.aborted) forwardAbort();
+    else signal?.addEventListener?.('abort', forwardAbort, { once: true });
+    if (!intakeAborts.has(id)) intakeAborts.set(id, new Set());
+    intakeAborts.get(id).add(intakeAbort);
+    let intake;
+    try {
+      intake = await preparePromptSubmissionForProvider(
+        materializePromptSubmission(prompt, options || {}),
+        { nativePdf: providerNativePdf(entry.runtime.provider || entry.runtime.session?.provider || '') },
+        { signal: intakeAbort.signal }
+      );
+    } finally {
+      signal?.removeEventListener?.('abort', forwardAbort);
+      intakeAborts.get(id)?.delete(intakeAbort);
+      if (!intakeAborts.get(id)?.size) intakeAborts.delete(id);
+    }
+    // A cancel that landed after the last conversion step must not submit.
+    intakeAbort.signal.throwIfAborted();
     // Await intake only: submitAsync resolves once the prompt is represented by
     // the queue/user row, while provider execution remains daemon-owned and
     // detached.
@@ -131,6 +159,7 @@ export function createSessionTurnCalls(ctx) {
   async function abortSession({ sessionId, open: openHints = {}, options = {}, baseRevision = null } = {}) {
     const id = String(sessionId || '');
     if (!id) throw new TypeError('sessionId is required');
+    for (const intakeAbort of intakeAborts.get(id) ?? []) intakeAbort.abort();
     const entry = await entryForSession(id, openHints || {});
     const target = entry.runtime.abort;
     if (typeof target !== 'function') throw new TypeError('session action abort is unavailable');