mixdog 1.3.1 → 1.3.2

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

@@ -29,9 +29,52 @@ 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)));
@@ -76,49 +119,6 @@ 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}"`);
@@ -175,7 +175,7 @@ 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 });

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,19 +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;
@@ -22,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) {
@@ -45,8 +53,19 @@ 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()) {
@@ -57,17 +76,40 @@ export function createSessionControl({
       // 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);
+      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 { 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(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,
-        options: { mode: 'prompt', transcriptMeta: { sender: 'lead' } },
+        options: { mode: 'prompt', transcriptMeta: { sender: 'lead', ...(hop > 0 ? { hop } : {}) } },
       });
-      return { sessionId, accepted: result.accepted === true, reportsBack: false };
+      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 });
@@ -91,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,
@@ -100,6 +142,5 @@ export function createSessionControl({
       busy: snapshot.busy === true,
       quotaResume: snapshot.quotaResume ?? null,
     };
-    return status;
   };
 }

package/src/standalone/daemon.mjs

@@ -928,7 +928,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 +997,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';
@@ -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 {

package/src/standalone/session-protocol.mjs

@@ -15,6 +15,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getAgentAvatarImage',
   'getAgentConnectors',
   'getProjectConnectors',
+  'getAgentAlwaysAllowedTools',
   'getAgentPermissions',
   'listConnectors',
   'listConnectorTools',
@@ -45,6 +46,8 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getQuotaHistory',
   'getRecapSettings',
   'getSessionTitleSettings',
+  'getLeadAppearance',
+  'getBotOrder',
   'getWebSearchRoute',
   'getSettingsSnapshot',
   'getSystemShell',
@@ -188,6 +191,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setAgentConnectorToolPermission',
   'setProjectConnectorEnabled',
   'setAgentPermission',
+  'recordAgentApprovalAudit',
   'saveLeadPersona',
   'saveLeadAgentBody',
   'setLeadCreated',
@@ -233,6 +237,8 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setProgressHint',
   'setRecapEnabled',
   'setAiSessionTitles',
+  'setLeadAppearance',
+  'setBotOrder',
   'setRoute',
   'setScheduleEnabled',
   'setWebSearchRoute',
@@ -241,6 +247,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setToolMode',
   'setWebSearchEnabled',
   'setInstructionFiles',
+  'setAutoEffortBase',
   'setWebhookConfig',
   'setWebhookEnabled',
   'setWorkflow',

package/src/standalone/session-service.mjs

@@ -23,6 +23,7 @@ import { createViewerRegistry } from './session-service/viewers.mjs';
 import { createSessionEntries } from './session-service/entries.mjs';
 import { createSessionCalls } from './session-service/session-calls.mjs';
 import { createQuotaResumeScheduler } from './session-service/quota-resume.mjs';
+import { registerDelegatedApprovalOpener } from '../runtime/shared/delegated-approval-host.mjs';
 
 const EXTERNAL_SESSION_ACTIONS = new Set([
   ...SESSION_READ_ACTION_SET,
@@ -205,6 +206,9 @@ export function createSessionService({
     retainUnwatched: retention.retainUnwatched,
     createSession: calls.createSession,
   });
+  // A sub-agent's approval shows in its top-level chat; one not loaded is
+  // brought up so the copy (and its notifications) appear there.
+  const unregisterApprovalOpener = registerDelegatedApprovalOpener((sessionId) => calls.materializeSession(sessionId));
   const quotaUsableReader = typeof readQuotaUsable === 'function' ? readQuotaUsable : async () => false;
   const quotaResume = quotaResumeStore
     ? createQuotaResumeScheduler({
@@ -219,6 +223,7 @@ export function createSessionService({
   function stop(reason = 'service stop') {
     if (stopPromise) return stopPromise;
     closed = true;
+    unregisterApprovalOpener();
     quotaResume?.stop();
     stopPromise = Promise.resolve().then(async () => {
       try {
@@ -243,6 +248,11 @@ export function createSessionService({
     return Boolean(owner) && retention.stateBusy(owner.runtime?.getState?.());
   }
 
+  /** Whether the runtime hosting `sessionId` shows an approval card waiting on the user. */
+  function liveSessionAwaitingApproval(sessionId) {
+    return Boolean(projection.sessionOwner(sessionId)?.runtime?.getState?.()?.toolApproval);
+  }
+
   /** Show a transcript notice in the hosted runtime of `sessionId` (no turn)
    *  and publish it to its views; false when no runtime hosts it. */
   function pushLiveSessionNotice(sessionId, { text, tone = 'info', ...options } = {}) {
@@ -300,6 +310,7 @@ export function createSessionService({
     methods: {
       ...calls,
       liveSessionBusy,
+      liveSessionAwaitingApproval,
       pushLiveSessionNotice,
       stop,
       startQuotaResume: () => quotaResume?.start(),

package/src/standalone/session-state-projection.mjs

@@ -1,4 +1,6 @@
 import { sanitizeForWire } from './session-wire-values.mjs';
+import { stripAgentMessageEnvelope } from '../runtime/shared/agent-message-envelope.mjs';
+import { transcriptSourceFields } from '../runtime/shared/transcript-metadata.mjs';
 
 /** Immutable source fields keep their wire identity until they actually change.
  * In particular, a live tail must not rebuild the settled transcript or resend
@@ -29,15 +31,23 @@ export function projectSessionState(entry, raw) {
     }
     let cloned;
     if (key === 'queued' && Array.isArray(value)) {
-      cloned = value.map((item) => ({
-        id: item?.id,
-        submittedAt: item?.submittedAt,
-        text: String(item?.displayText ?? item?.text ?? '').slice(0, 2_000),
-        displayText: String(item?.displayText ?? item?.text ?? '').slice(0, 2_000),
-        mode: item?.mode || 'prompt',
-        priority: item?.priority || 'next',
-        ...(Array.isArray(item?.images) && item.images.length ? { images: item.images } : {}),
-      }));
+      cloned = value.map((item) => {
+        // A queued bot message reads like its delivered row: the sender tag
+        // and the message without its envelope.
+        const source = transcriptSourceFields(item?.transcriptMeta);
+        const queuedText = String(item?.displayText ?? item?.text ?? '');
+        const text = (source.fromAgent ? stripAgentMessageEnvelope(queuedText) : queuedText).slice(0, 2_000);
+        return {
+          id: item?.id,
+          submittedAt: item?.submittedAt,
+          text,
+          displayText: text,
+          mode: item?.mode || 'prompt',
+          priority: item?.priority || 'next',
+          ...source,
+          ...(Array.isArray(item?.images) && item.images.length ? { images: item.images } : {}),
+        };
+      });
     } else if (key === 'items' && Array.isArray(value)) {
       const items = entry.itemCache;
       const nextItems = new Map();