mixdog 1.4.1 → 1.4.3

package/src/session-runtime/routine-home-turn.mjs

@@ -14,7 +14,10 @@
  * (outbound actions are allowed within the bot's permissions; payments and
  * permanent deletes are refused, human-gate/run-policy.mjs). Resolves with the
  * reply once the turn ends; rejects when the turn fails, is cancelled, or the
- * caller's `signal` aborts (which also aborts the turn once it runs). A
+ * caller's `signal` aborts (which also aborts the turn once it runs). With an
+ * `executorAgentId` the fire is first carried out by that sub-agent
+ * (routine-executor.mjs) and the turn holds only its final report, which the
+ * bot relays; the quiet marker as the report wakes nobody and resolves it. A
  * heartbeat turn past its wall-clock cap is aborted and resolves with no reply
  * (`timedOut`).
  */
@@ -25,12 +28,16 @@ import { automationPromptContent } from '../runtime/shared/automation-attachment
 import { ROUTINE_LIMITS } from '../runtime/shared/routine-limits.mjs';
 import {
   HEARTBEAT_TURN_LIMITS,
+  ROUTINE_QUIET,
   isHeartbeatSession,
+  isRoutineQuietReply,
   normalizeRoutineTrigger,
+  routineRelayHeader,
   routineTriggerHeader,
 } from '../runtime/shared/routine-trigger.mjs';
 import { agentHomeLiveSurface, scheduleOwnerAgentId } from './agent-home-delivery.mjs';
 import { markUnattendedRun, unattendedRunOf } from './held-requests.mjs';
+import { runRoutineExecutor } from './routine-executor.mjs';
 
 // Routine turns waiting or running per home thread.
 const waiting = new Map();
@@ -72,6 +79,9 @@ export async function runRoutineTurn(
     // thread and the routine trigger header.
     sessionId = null,
     header = null,
+    // A workflow sub-agent that carries the fire out first (routine-executor.mjs):
+    // the bot's turn then holds only its final report, for the bot to relay.
+    executorAgentId = null,
   },
   {
     surface = agentHomeLiveSurface(),
@@ -79,9 +89,10 @@ export async function runRoutineTurn(
     limit = ROUTINE_LIMITS.homeQueueLimit,
     log = (line) => process.stderr.write(`mixdog routines: ${line}\n`),
     timers = globalThis,
+    executor = runRoutineExecutor,
   } = {}
 ) {
-  const body = String(prompt || '').trim();
+  let body = String(prompt || '').trim();
   if (!body) throw new Error(`${kind} "${name}" has no instructions`);
   if (signal?.aborted) throw abortError(signal);
   if (typeof surface?.submit !== 'function') throw new Error('routine run: the session service is not running');
@@ -91,12 +102,42 @@ export async function runRoutineTurn(
   if (!home || home.closed === true) {
     throw new Error(`the bot "${agentId}" has no chat yet: open it once in the app`);
   }
+  let opening = header || routineTriggerHeader({ kind, name, project: cwd ? String(cwd) : '' });
+  let selection = String(skillSelection ?? body);
+  let turnAttachments = attachments;
+  if (executorAgentId) {
+    const report = String(
+      (await executor(
+        {
+          agentId: executorAgentId,
+          kind,
+          name,
+          ownerAgentId: agentId,
+          prompt: body,
+          skillSelection: selection,
+          attachments,
+          cwd,
+          signal,
+        },
+        { surface }
+      )) ?? ''
+    ).trim();
+    if (signal?.aborted) throw abortError(signal);
+    if (!report) throw new Error(`${kind} "${name}": executor agent "${executorAgentId}" returned no report`);
+    // Nothing to tell: the bot is not woken.
+    if (isRoutineQuietReply(report)) return { sessionId: homeId, result: ROUTINE_QUIET };
+    // The bot only relays the report: it is derived from whatever the executor
+    // read (a webhook's payload included), so it selects no skill.
+    body = report;
+    opening = routineRelayHeader({ kind, name, executor: executorAgentId, project: cwd ? String(cwd) : '' });
+    selection = '';
+    turnAttachments = null;
+  }
   const queued = waiting.get(homeId) || 0;
   if (queued >= limit) throw new Error(`${limit} routine runs already wait in this bot's chat`);
   waiting.set(homeId, queued + 1);
   const trigger = normalizeRoutineTrigger({ kind, name, event });
-  const opening = header || routineTriggerHeader({ kind, name, project: cwd ? String(cwd) : '' });
-  const content = automationPromptContent(`${opening}\n\n${body}`, attachments);
+  const content = automationPromptContent(`${opening}\n\n${body}`, turnAttachments);
   return new Promise((resolve, reject) => {
     let started = false;
     let aborted = false;
@@ -150,7 +191,7 @@ export async function runRoutineTurn(
       restorable: false,
       // Esc ends this fire; it is never put back in the queue.
       abortDiscardOnAbort: true,
-      skillSelection: String(skillSelection ?? body),
+      skillSelection: selection,
       transcriptMeta: { routineTrigger: trigger },
       onCommitted: () => {
         if (started) return;

package/src/session-runtime/runtime-facade.mjs

@@ -24,6 +24,7 @@ export function createRuntimeFacade({
   getOrchestrationMode,
   getOutputStyle,
   getContextStatus,
+  getContextStatusSettled = async (options) => getContextStatus(options),
   getContextStatusForSession,
   renameSessionTitle,
 }) {
@@ -144,6 +145,10 @@ export function createRuntimeFacade({
     contextStatus(options) {
       return getContextStatus(options);
     },
+    /** The context status once an empty session took moved settings (async callers). */
+    contextStatusSettled(options) {
+      return getContextStatusSettled(options);
+    },
     contextStatusForSession(session) {
       return getContextStatusForSession(session);
     },

package/src/session-runtime/runtime-feature-gates.mjs

@@ -6,13 +6,10 @@
 // deps, so the runtime can hand them straight through.
 import {
   builtinFeatureActive,
-  featureDisallowedToolsFor,
   localGitToolsActive,
 } from '../runtime/agent/orchestrator/runtime-core/builtin-features.mjs';
 import { recapEnabled } from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
-import { browserBridgeAvailableSync } from '../runtime/browser-bridge/client.mjs';
-import { computerBridgeAvailableSync } from '../runtime/computer-bridge/client.mjs';
-import { terminalBridgeAvailableSync } from '../runtime/terminal-bridge/client.mjs';
+import { liveFeatureDisallowedTools } from '../runtime/agent/orchestrator/runtime-core/tool-availability.mjs';
 
 export function createRuntimeFeatureGates({ getConfig, getToolProfile }) {
   return {
@@ -29,12 +26,6 @@ export function createRuntimeFeatureGates({ getConfig, getToolProfile }) {
     tidyToolEnabledFn: () => builtinFeatureActive(getConfig(), 'tidy'),
     // Browser/Computer activate on live desktop-bridge presence, so the probe
     // runs per call instead of being captured at boot.
-    featureDisallowedTools: () =>
-      featureDisallowedToolsFor(getConfig(), {
-        browserAvailable: browserBridgeAvailableSync(),
-        computerAvailable: computerBridgeAvailableSync(),
-        terminalAvailable: terminalBridgeAvailableSync(),
-        toolProfile: getToolProfile(),
-      }),
+    featureDisallowedTools: () => liveFeatureDisallowedTools(getConfig(), { toolProfile: getToolProfile() }),
   };
 }

package/src/session-runtime/schedule-session-run.mjs

@@ -26,6 +26,7 @@ export async function runScheduleSession(
         kind: 'schedule',
         name: schedule.name,
         ownerAgentId: schedule.ownerAgentId,
+        executorAgentId: schedule.executorAgentId || null,
         prompt: body,
         attachments: schedule.attachments,
         cwd: schedule.cwd || null,

package/src/session-runtime/services/agent-tool/job-task-reconcile.mjs

@@ -84,11 +84,16 @@ export function reconcileJobCancelled(job, value) {
   } catch {}
 }
 
-export function reconcileJobStreamStalled(job, error) {
+/** A turn that threw. `identity` is the owner-facing result shape: a failure
+ *  after answers the turn went on past (error.carriedReport, turn-report.mjs)
+ *  reports them with the failure. */
+export function reconcileJobStreamStalled(job, error, identity = {}) {
   if (!job?.taskId || job._terminalResultValue !== undefined) return;
+  const report = typeof error?.carriedReport === 'string' ? error.carriedReport : '';
   try {
     reconcileBackgroundTask(job.taskId, {
       status: 'failed',
+      ...(report ? { result: { ...identity, content: report } } : {}),
       error,
       terminalReason: 'agent-stream-stalled',
     });

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

@@ -4,6 +4,8 @@
 import { resolveAgentWatchdogPolicy } from '../../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 import { buildAgentTaskProgressFields } from '../../agent-task-status.mjs';
 import { getProgressWatchdogState } from '../../agent-watchdog-registry.mjs';
+import { _liveSessions } from '../../../../runtime/agent/orchestrator/session/store/live-state.mjs';
+import { todoProgress } from '../../../../runtime/agent/orchestrator/runtime-core/todo-list.mjs';
 
 // Job statuses that can never progress again (mirrors TERMINAL_STATUSES in
 // runtime/shared/background-tasks.mjs; 'canceled' accepted defensively).
@@ -46,6 +48,11 @@ export function terminalJobFrozenFields(status, now = Date.now()) {
  *  the diagnostics through renderJob/list directly. */
 export function liveAgentStatusRow(row) {
   if (!row || typeof row !== 'object') return row;
+  // The agent's own todo progress, from its live session only (an evicted
+  // idle worker is not re-read on every pulse).
+  const live = row.sessionId ? _liveSessions.get(row.sessionId) : null;
+  const todo = live ? todoProgress(live) : null;
+  if (todo) row = { ...row, todo };
   const {
     silent_for: _silentFor,
     staleSeconds: _staleSeconds,

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

@@ -1,12 +1,26 @@
 import {
   isAgentProgressWatchdogAbortError,
+  noteStoppedShellJobsOnError,
   resolveAgentWatchdogPolicy,
   resolveHandoffMessageStartIndex,
   turnPartialHandoff,
   watchdogPartialHandoffFromError,
   watchdogStoppedHandoff,
 } from '../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
-import { clean, normalizeAgentName, resolvePrompt } from './helpers.mjs';
+import { reconcileAgentSession } from '../../../runtime/agent/orchestrator/agent-runtime/session-builder.mjs';
+import {
+  agentPresetName,
+  clean,
+  normalizeAgentName,
+  presetKey,
+  readAgentFrontmatterPermission,
+  resolvePrompt,
+} from './helpers.mjs';
+import { normalizeAgentPermission } from '../../../runtime/shared/markdown-frontmatter.mjs';
+import { resolveAgentSessionPermission } from '../../../runtime/agent/orchestrator/internal-agents.mjs';
+import { resolveAgentSpawnPreset } from './spawn-preset.mjs';
+import { flushPendingSessionConfigWrites } from '../../config-lifecycle/config-writers.mjs';
+import { AGENT_ROUTE_KEYS } from '../../agent-profile-changes.mjs';
 import { abnormalEmptyFinishError, renderResult } from './render.mjs';
 import {
   reconcileJobCancelled,
@@ -20,15 +34,39 @@ import { handoffContent } from '../../handoff-attachments.mjs';
 import { rebindDelegation } from '../../../runtime/agent/orchestrator/session/human-gate/delegation.mjs';
 import { settledWorkerStatus } from './worker-index/row-liveness.mjs';
 import { whileTurnDispatched } from '../../../runtime/agent/orchestrator/session/manager/runtime-state.mjs';
+import { takeStoppedShellJobs } from '../../../runtime/agent/orchestrator/session/manager/turn-reap.mjs';
+import { turnReportText } from '../../../runtime/agent/orchestrator/session/loop/turn-report.mjs';
 
 function workerResultIdentity({ session, tag, sessionId }) {
   return { tag, sessionId, agent: session.agent || null, provider: session.provider, model: session.model };
 }
 
+/** A reused worker runs with the permission its agent's definition grants
+ *  now, resolved as a spawn resolves it (spawn-plan.mjs). */
+export function followAgentPermission(session, { dataDir, sourceRoot }) {
+  const agent = normalizeAgentName(session?.agent);
+  if (!agent || !dataDir) return;
+  const defined = normalizeAgentPermission(readAgentFrontmatterPermission(agent, dataDir, sourceRoot));
+  const permission = resolveAgentSessionPermission(agent, defined || null);
+  if (permission) session.permission = permission;
+  else delete session.permission;
+}
+
 // `send` to an existing worker: resolve the live session, run one follow-up
 // turn under the progress watchdog, and reconcile the job/worker row. Busy
 // sessions queue the prompt instead.
-export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionSurface, registry, views, spawnFlow }) {
+export function createSendFlow({
+  mgr,
+  cfgMod = null,
+  dataDir = null,
+  STANDALONE_SOURCE_ROOT = null,
+  defaultCwd,
+  sessionSurface,
+  canUseSessionSurface,
+  registry,
+  views,
+  spawnFlow,
+}) {
   async function prepareSend(args, context = {}) {
     registry.refreshTagsFromSessions({ scanSessions: registry.wantsSessionScan(args), context });
     const target = clean(args.tag || args.sessionId);
@@ -49,7 +87,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       const abnormalError = abnormalEmptyFinishError(result, session.agent || sendAgent);
       return {
         ...workerResultIdentity({ session, tag, sessionId }),
-        content: result?.content || '',
+        content: turnReportText(result),
         ...(sessionSurface?.canonical === true ? { handoffOnly: true } : {}),
         ...(abnormalError ? { error: abnormalError } : {}),
       };
@@ -80,6 +118,13 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       if (canUseSessionSurface(session)) {
         return sessionSurface.runTurn({ session, prompt, context: args.context || null, cwd, ...turnHooks });
       }
+      // An in-process session has no turn start of its own to reconcile it
+      // (a canonical child's runtime does, reconcileTurnSettings): bring its
+      // settings-gated tools, connectors, compaction, prompt settings and its
+      // agent's permission (as its definition stands: a narrowed one applies)
+      // to the settings now.
+      reconcileAgentSession(session);
+      followAgentPermission(session, { dataDir, sourceRoot: STANDALONE_SOURCE_ROOT });
       return mgr.askSession(sessionId, prompt, args.context || null, null, cwd, null, turnHooks);
     });
   }
@@ -92,7 +137,12 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     // the watchdog sweep re-stamps turnStartedAt at each turn boundary.
     const watchdogPolicy = resolveAgentWatchdogPolicy(
       sendAgent,
-      spawnFlow.agentWatchdogOverrides({ agent: sendAgent, provider: session.provider, model: session.model })
+      spawnFlow.agentWatchdogOverrides({
+        agent: sendAgent,
+        provider: session.provider,
+        model: session.model,
+        ...(session.modelParameters ? { modelParameters: session.modelParameters } : {}),
+      })
     );
     const watchdog = spawnFlow.startProgressIdleWatchdog(sessionId, watchdogPolicy, sendAgent, {
       onTurnStart: spawnFlow.turnStartStamper(session, tag),
@@ -122,7 +172,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(sessionId));
       const turnHooks = buildTurnHooks({ sessionId, notifyContext, job, turnReview, completionValue });
       const result = await runTurn(prepared, turnHooks);
-      // Early preview no longer suppresses the canonical body notification;
+      // The early preview does not suppress the canonical body notification;
       // notifyTaskCompletion fires once with output via resolve/reconcile.
       const finalValue = completionValue(result);
       if (job?.status === 'cancelled') {
@@ -146,7 +196,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
         finalStatus = 'idle';
         const value = {
           ...workerResultIdentity({ session, tag, sessionId }),
-          content: watchdogStoppedHandoff(error, partial),
+          content: watchdogStoppedHandoff(error, partial, await takeStoppedShellJobs(sessionId)),
           stallAbort: true,
         };
         if (job) job._terminalResultValue = value;
@@ -154,7 +204,8 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
         return value;
       }
       finalStatus = 'error';
-      reconcileJobStreamStalled(job, error);
+      noteStoppedShellJobsOnError(error, await takeStoppedShellJobs(sessionId));
+      reconcileJobStreamStalled(job, error, workerResultIdentity({ session, tag, sessionId }));
       throw error;
     } finally {
       turnReview.complete();
@@ -196,8 +247,69 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
   // `send` branch AND by the `spawn` branch when an explicit tag maps to a
   // live session (reuse path). Busy sessions queue the prompt; idle ones run a
   // background send job that continues the existing session (context kept).
+  // A worker that runs on its agent's configured route follows that route, as
+  // a bot's home chat does (agent-route-follow.mjs): a model picked for the
+  // agent since the spawn applies from this send. A worker started on an
+  // explicit model or preset keeps it.
+  async function agentRouteToFollow({ session }) {
+    const agent = normalizeAgentName(session?.agent);
+    if (!agent || !cfgMod?.loadConfig) return null;
+    await flushPendingSessionConfigWrites();
+    let current;
+    try {
+      current = resolveAgentSpawnPreset(cfgMod.loadConfig(), { agent });
+    } catch {
+      return null;
+    }
+    const spawnedOn = clean(session.presetName || session.preset);
+    const own = new Set([`agent-${agent}`, agentPresetName(agent), presetKey(current.preset), current.presetName]);
+    if (!spawnedOn || !own.has(spawnedOn)) return null;
+    const preset = current.preset;
+    if (!preset.provider || !preset.model) return null;
+    // Every route key the agent's route sets (an effort or Fast change alone
+    // included); a key it leaves unset is the route default either way.
+    const value = (key, source) => {
+      if (key === 'fast') return source?.fast === true;
+      if (key === 'autoEffort') return source?.autoEffort !== false;
+      return source?.[key] == null ? null : JSON.stringify(source[key]);
+    };
+    const set = AGENT_ROUTE_KEYS.filter(
+      (key) => key === 'fast' || key === 'autoEffort' || (preset[key] !== undefined && preset[key] !== null)
+    );
+    const matches = (target) => set.every((key) => value(key, preset) === value(key, target));
+    // Against the route the session's next turn runs on: one held for it
+    // (heldRoute, an in-process worker that was busy), else its own.
+    if (matches(session)) {
+      // Saved back to the running route: an earlier hold is obsolete.
+      if (session.heldRoute) mgr.holdSessionRoute?.(session.id, null);
+      return null;
+    }
+    if (session.heldRoute && matches({ ...session, ...session.heldRoute })) return null;
+    const route = {};
+    for (const key of set) {
+      if (key === 'fast') route.fast = preset.fast === true;
+      else if (key === 'autoEffort') {
+        if (preset.autoEffort === false) route.autoEffort = false;
+      } else route[key] = preset[key];
+    }
+    return route;
+  }
+
   async function dispatchToExistingSession(requested, notifyContext, extras = {}) {
-    const prepared = requested.route ? await applyRequestedRoute(requested) : requested;
+    let followed = requested.route ? null : await agentRouteToFollow(requested);
+    if (followed && !canUseSessionSurface(requested.session)) {
+      // An in-process session takes the followed route in place, between
+      // turns; a running one finishes on the route it started on and holds
+      // the new one for its next turn, which runs the queued work.
+      if (!views.isSessionBusy(requested.sessionId)) {
+        const { session } = requested;
+        const crossProvider = followed.provider !== session.provider || followed.model !== session.model;
+        mgr.updateSessionRoute?.(requested.sessionId, followed, { session, crossProvider });
+      } else mgr.holdSessionRoute?.(requested.sessionId, followed);
+      followed = null;
+    }
+    const routed = followed ? { ...requested, route: followed } : requested;
+    const prepared = routed.route ? await applyRequestedRoute(routed) : routed;
     const { session, sessionId, prompt } = prepared;
     const tag = registry.tagForSession(sessionId);
     if (canUseSessionSurface(session) && views.isSessionBusy(sessionId)) {

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

@@ -10,6 +10,7 @@ import { clean, terminalPidForContext } from '../helpers.mjs';
 import { renderResult } from '../render.mjs';
 import { closeManagedSession } from '../../../lifecycle/shared.mjs';
 import { hopOf } from '../../../../runtime/shared/bot-hops.mjs';
+import { notDoneReport } from '../../../../runtime/agent/orchestrator/runtime-core/todo-list.mjs';
 
 /** The completion callback that hands a worker's result back to its caller session; null without a handoff. */
 function handoffNotifier(handoffSessionId, notifySessionCompletion) {
@@ -86,6 +87,17 @@ export function createJobStarter({ mgr, notifyStatusChange, notifySessionComplet
         }
       },
     });
+    // Success, failure or cancellation: the report names what the agent's own
+    // todo list leaves undone. The Lead never receives the list otherwise.
+    task.reportAppendix = () => {
+      const sessionId = task.meta?.sessionId || jobMeta?.sessionId;
+      if (!sessionId) return '';
+      try {
+        return notDoneReport(mgr.getSession(sessionId));
+      } catch {
+        return '';
+      }
+    };
     // The model's tool call that started this job owns it (its result message
     // carries the id: agent-task-starts.mjs).
     recordAgentTaskStart(notifyContext?.toolCallId, task.taskId);

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

@@ -22,6 +22,7 @@ import { workspaceCwdLock } from '../../../workspace/admission-gate.mjs';
 import { isContactAgentId } from '../../../../runtime/agent/orchestrator/runtime-core/workflow-ids.mjs';
 import { assertBotChainTarget } from '../../../../runtime/shared/bot-hops.mjs';
 import { actingAgentOf, delegationChainOf } from '../../../bot-chain.mjs';
+import { flushPendingSessionConfigWrites } from '../../../config-lifecycle/config-writers.mjs';
 
 export function createSpawnPlanner({
   mgr = null,
@@ -36,6 +37,10 @@ export function createSpawnPlanner({
 }) {
   /** Shared spawn-prep validations (agent/preset/tag/cwd/prompt). */
   async function resolveSpawnPlan(args, callerCwd, context, prepState) {
+    // A setting a runtime of this process adopted (an agent's model picked a
+    // moment ago) is written behind a debounce: drain it so the read below
+    // sees what the runtimes hold in memory.
+    await flushPendingSessionConfigWrites();
     const config = cfgMod.loadConfig();
     const agent = normalizeAgentName(args.agent);
     if (!agent) throw new Error('agent spawn: agent is required');

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

@@ -77,8 +77,8 @@ export function createSpawnPreparer({
    *  first-response deadline and the provider's first-response budget for the
    *  routed model (headers, and first output), handed to
    *  resolveAgentWatchdogPolicy. A provider on the shared window names none. */
-  function agentWatchdogOverrides({ agent, provider, model }) {
-    const budget = getProvider(provider)?.firstResponseBudget?.(model);
+  function agentWatchdogOverrides({ agent, provider, model, modelParameters }) {
+    const budget = getProvider(provider)?.firstResponseBudget?.(model, { modelParameters });
     return {
       firstResponseTimeoutMs: readAgentFirstResponseTimeoutMs(agent, dataDir, STANDALONE_SOURCE_ROOT) ?? undefined,
       providerFirstByteTimeoutMs: budget?.transportMs,
@@ -145,7 +145,12 @@ export function createSpawnPreparer({
       prompt: plan.prompt,
       watchdogPolicy: resolveAgentWatchdogPolicy(
         plan.agent,
-        agentWatchdogOverrides({ agent: plan.agent, provider: plan.preset.provider, model: plan.preset.model })
+        agentWatchdogOverrides({
+          agent: plan.agent,
+          provider: plan.preset.provider,
+          model: plan.preset.model,
+          modelParameters: plan.preset.modelParameters,
+        })
       ),
     };
   }

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

@@ -16,6 +16,7 @@ import { abnormalEmptyFinishError } from '../render.mjs';
 import { createProgressWatchdogRegistry } from '../../agent-watchdog-registry.mjs';
 import {
   isAgentProgressWatchdogAbortError,
+  noteStoppedShellJobsOnError,
   resolveHandoffMessageStartIndex,
   turnPartialHandoff,
   watchdogPartialHandoffFromError,
@@ -27,6 +28,8 @@ import { presetDescriptor } from './spawn-prep.mjs';
 import { workerStageForStatus } from '../worker-rows.mjs';
 import { handoffContent } from '../../../handoff-attachments.mjs';
 import { whileTurnDispatched } from '../../../../runtime/agent/orchestrator/session/manager/runtime-state.mjs';
+import { takeStoppedShellJobs } from '../../../../runtime/agent/orchestrator/session/manager/turn-reap.mjs';
+import { turnReportText } from '../../../../runtime/agent/orchestrator/session/loop/turn-report.mjs';
 
 // Mid-turn worker persistence cadence. The watchdog sweep runs every second;
 // a transcript save is far more expensive than a bookkeeping stamp, so the
@@ -112,7 +115,7 @@ export function createSpawnRunner({
       tag,
       sessionId: session.id,
       ...presetDescriptor(agent, preset, presetName),
-      content: result?.content || '',
+      content: turnReportText(result),
       ...(sessionSurface?.canonical === true ? { handoffOnly: true } : {}),
       ...(abnormalError ? { error: abnormalError } : {}),
     };
@@ -122,11 +125,24 @@ export function createSpawnRunner({
     const { args, session, workerCwd } = prepared;
     // The caller's forwarded files ride along as attachment parts.
     const prompt = handoffContent(prepared.prompt, args.attachmentParts);
+    // Host-set only (a routine executor, routine-executor.mjs): the trusted
+    // text skills are selected from, so nothing else in the prompt selects one.
+    const selection = typeof args.skillSelection === 'string' ? { skillSelection: args.skillSelection } : {};
     return whileTurnDispatched(session.id, () => {
       if (typeof sessionSurface?.runTurn === 'function' && sessionSurface.canRun?.(session) !== false) {
-        return sessionSurface.runTurn({ session, prompt, context: args.context || null, cwd: workerCwd, ...turnHooks });
+        return sessionSurface.runTurn({
+          session,
+          prompt,
+          context: args.context || null,
+          cwd: workerCwd,
+          ...selection,
+          ...turnHooks,
+        });
       }
-      return mgr.askSession(session.id, prompt, args.context || null, null, workerCwd, null, turnHooks);
+      return mgr.askSession(session.id, prompt, args.context || null, null, workerCwd, null, {
+        ...turnHooks,
+        ...selection,
+      });
     });
   }
 
@@ -178,8 +194,8 @@ export function createSpawnRunner({
           : {}),
       };
       const result = await runTurn(prepared, turnHooks);
-      // The early preview no longer promises body suppression, so the canonical
-      // notifyTaskCompletion is left to fire exactly once with output via the
+      // The early preview does not promise body suppression, so the canonical
+      // notifyTaskCompletion fires exactly once with output via the
       // resolve/reconcile/finally path.
       const finalValue = completionValue(result);
       if (job?.status === 'cancelled') {
@@ -209,7 +225,7 @@ export function createSpawnRunner({
           tag,
           sessionId: session.id,
           ...presetDescriptor(agent, preset, presetName),
-          content: watchdogStoppedHandoff(error, partial),
+          content: watchdogStoppedHandoff(error, partial, await takeStoppedShellJobs(session.id)),
           stallAbort: true,
         };
         if (job) job._terminalResultValue = value;
@@ -217,7 +233,12 @@ export function createSpawnRunner({
         return value;
       }
       finalStatus = 'error';
-      reconcileJobStreamStalled(job, error);
+      noteStoppedShellJobsOnError(error, await takeStoppedShellJobs(session.id));
+      reconcileJobStreamStalled(job, error, {
+        tag,
+        sessionId: session.id,
+        ...presetDescriptor(agent, preset, presetName),
+      });
       throw error;
     } finally {
       turnReview.complete();

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

@@ -2,7 +2,15 @@ import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ensureProcessListenerHeadroom } from '../../runtime/shared/process-listener-headroom.mjs';
 import { AGENT_TOOL } from './agent-tool/tool-def.mjs';
-import { agentScope, envTimeoutMs, callerSessionForContext, terminalPidForContext } from './agent-tool/helpers.mjs';
+import { cancelBackgroundTask } from '../../runtime/shared/background-tasks.mjs';
+import { closeManagedSession } from '../lifecycle/shared.mjs';
+import {
+  agentScope,
+  clean,
+  envTimeoutMs,
+  callerSessionForContext,
+  terminalPidForContext,
+} from './agent-tool/helpers.mjs';
 import { createTagRegistry } from './agent-tool/tag-registry.mjs';
 import { createJobViews } from './agent-tool/job-views.mjs';
 import { liveAgentStatusRow } from './agent-tool/job-views/session-progress.mjs';
@@ -106,6 +114,9 @@ export function createStandaloneAgent({
   });
   const sendFlow = createSendFlow({
     mgr,
+    cfgMod,
+    dataDir,
+    STANDALONE_SOURCE_ROOT,
     defaultCwd,
     sessionSurface,
     canUseSessionSurface,
@@ -129,6 +140,44 @@ export function createStandaloneAgent({
     listProviderModels,
   });
 
+  /**
+   * Run one workflow agent (`args.agent`, `args.prompt`, optional `cwd` and
+   * `attachmentParts`) to completion and resolve `{ sessionId, content }` —
+   * for a caller that has no session to hand the result to (a routine's
+   * executor, routine-executor.mjs). `context.callerSessionId` is the id the
+   * agent is created under: its run stamp and unattended policy come from it.
+   * Rejects when the agent fails or is cancelled, or `signal` aborts (which
+   * cancels it). The agent's session is closed afterwards.
+   */
+  async function runToCompletion(args = {}, context = {}, { signal = null } = {}) {
+    await awaitKeychainPrewarm();
+    const abortError = () =>
+      signal?.reason instanceof Error ? signal.reason : new Error(String(signal?.reason || 'agent run aborted'));
+    if (signal?.aborted) throw abortError();
+    const job = spawnFlow.startDeferredSpawnJob({ ...args, type: 'spawn' }, clean(context.callerCwd), context, context);
+    const onAbort = () => cancelBackgroundTask(job.taskId, 'agent run aborted', { notify: false });
+    signal?.addEventListener?.('abort', onAbort, { once: true });
+    let value = null;
+    try {
+      value = await job.promise;
+    } finally {
+      signal?.removeEventListener?.('abort', onAbort);
+    }
+    const sessionId = clean(job.meta?.sessionId) || clean(value?.sessionId);
+    if (sessionId) {
+      try {
+        await closeManagedSession(mgr, sessionId, 'routine-executor-finished');
+      } catch {
+        /* the run's result stands; a close that fails is swept with idle agents */
+      }
+    }
+    if (signal?.aborted) throw abortError();
+    if (job.status === 'cancelled') throw new Error('the agent run was cancelled');
+    if (job.status !== 'completed') throw new Error(job.error || 'the agent run failed');
+    const result = value ?? job.result;
+    return { sessionId: sessionId || null, content: String(result?.content ?? '') };
+  }
+
   function getStatus(context = {}) {
     if (!isKeychainPrewarmReady()) {
       void awaitKeychainPrewarm();
@@ -162,6 +211,7 @@ export function createStandaloneAgent({
   return {
     tools: [AGENT_TOOL],
     execute,
+    runToCompletion,
     onStatusChange: (listener) => {
       if (typeof listener !== 'function') return () => {};
       statusListeners.add(listener);