mixdog 0.9.151 → 0.9.153

package/src/standalone/agent-tool/spawn-flow.test.mjs

@@ -61,3 +61,44 @@ test('agent job completion uses immutable caller owner and never invokes stale n
   assert.match(deliveries.at(-1).text, /owner handoff/);
   cleanupBackgroundTasks({ surface: 'agent', force: true });
 });
+
+test('a user-cancelled Agent turn settles the worker row as cancelled, not error', async () => {
+  const updates = [];
+  const flow = createSpawnFlow({
+    mgr: {
+      getSession: () => ({ messages: [] }),
+    },
+    upsertWorkerSessionDeferred(_session, _tag, patch) {
+      updates.push(patch);
+    },
+    emitSubagentEvent() {},
+    scheduleReap() {},
+    createTurnReviewCollector: () => ({
+      onToolResult() {},
+      complete() {},
+    }),
+    sessionSurface: {
+      canonical: true,
+      canRun: () => true,
+      async runTurn() {
+        throw new Error('cancelled by agent close');
+      },
+    },
+  });
+  const job = { taskId: 'task-agent-cancelled', status: 'cancelled' };
+
+  await assert.rejects(flow.runSpawn({
+    args: {},
+    tag: 'cancelled-worker',
+    session: { id: 'sess_cancelled_worker' },
+    agent: 'worker',
+    preset: { provider: 'test-provider', model: 'test-model' },
+    presetName: 'worker-route',
+    workerCwd: 'C:\\Project\\tree',
+    prompt: 'cancel me',
+    watchdogPolicy: null,
+  }, { callerSessionId: 'sess_lead' }, job), /cancelled by agent close/);
+
+  assert.equal(updates.at(-1).status, 'cancelled');
+  assert.equal(updates.at(-1).stage, 'cancelled');
+});

package/src/standalone/agent-tool/tool-def.mjs

@@ -20,7 +20,7 @@ export const AGENT_TOOL = {
     destructiveHint: true,
     idempotentHint: false,
     openWorldHint: true,
-    agentHidden: true,
+    agentHidden: false,
   },
   description: 'Run scoped agent work as background tasks. spawn/send return task_id immediately. Reuse one tag for one scope for its whole lifetime; give distinct tags only to independent scopes. Never mint a new tag because a session expired or was lost — same-tag spawn respawns it with the full brief. Wait for completion notifications; use status/read only for manual recovery.',
   inputSchema: {

package/src/standalone/agent-tool/worker-index.mjs

@@ -7,6 +7,7 @@ import { readFileSync, statSync } from 'node:fs';
 import { resolve } from 'node:path';
 
 import { updateJsonAtomicSync } from '../../runtime/shared/atomic-file.mjs';
+import { resolveAgentTerminalReapMs } from '../../session-runtime/config-helpers.mjs';
 import { WORKER_INDEX_FILE } from './tool-def.mjs';
 import { agentTagOf, clean, positiveInt, rowMatchesContext } from './helpers.mjs';
 import {
@@ -17,8 +18,37 @@ import {
   workerRowKey,
 } from './worker-rows.mjs';
 
+const ACTIVE_WORKER_STATUS =
+  /^(?:connecting|requesting|streaming|tool[-_\s]?running|running|queued|pending|starting|cancelling)$/i;
+const WORKER_POOL_FRESH_MS = 2 * 60 * 1000;
+const exitFlushes = new Set();
+let exitFlushInstalled = false;
+
+function registerExitFlush(flush) {
+  exitFlushes.add(flush);
+  if (exitFlushInstalled) return;
+  exitFlushInstalled = true;
+  process.on('exit', () => {
+    for (const entry of exitFlushes) {
+      try { entry(); } catch { /* exit flush is best effort */ }
+    }
+  });
+}
+
+function runtimeAlive(pid) {
+  const id = Number(pid) || 0;
+  if (id <= 0 || id === process.pid) return true;
+  try {
+    process.kill(id, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'EPERM';
+  }
+}
+
 export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCwds }) {
   const pendingMutators = [];
+  const activeWorkerKeys = new Set();
   let flushTimer = null;
   // Mtime-keyed parse cache. A single spawn calls refreshTagsFromSessions /
   // resolveTag / nextTag, which each re-read and re-parse this file; across a
@@ -48,6 +78,7 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
       .map((row) => ({
         tag: clean(row.tag),
         sessionId: clean(row.sessionId),
+        parentSessionId: clean(row.parentSessionId) || null,
         ownerSessionId: clean(row.ownerSessionId || row.parentSessionId) || null,
         agent: clean(row.agent) || null,
         provider: clean(row.provider) || null,
@@ -64,6 +95,7 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
         turnStartedAt: clean(row.turnStartedAt) || null,
         reapAt: clean(row.reapAt) || null,
         clientHostPid: positiveInt(row.clientHostPid),
+        runtimePid: positiveInt(row.runtimePid),
         cwd: clean(row.cwd) || null,
         task_id: clean(row.task_id || row.taskId) || null,
         error: clean(row.error) || null,
@@ -159,6 +191,47 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
     }
   }
 
+  function workerHeartbeatFresh(sessionId, now) {
+    const id = clean(sessionId);
+    if (!dataDir || !id) return false;
+    try {
+      const mtimeMs = statSync(resolve(dataDir, 'sessions', `${id}.hb`)).mtimeMs || 0;
+      return mtimeMs > 0 && now - mtimeMs <= WORKER_POOL_FRESH_MS;
+    } catch {
+      return false;
+    }
+  }
+
+  function staleActiveWorkerRow(row, now) {
+    const active = ACTIVE_WORKER_STATUS.test(clean(row?.status))
+      || ACTIVE_WORKER_STATUS.test(clean(row?.stage));
+    if (!active) return false;
+    if (positiveInt(row.runtimePid) && !runtimeAlive(row.runtimePid)) return true;
+    if (workerHeartbeatFresh(row.sessionId, now)) return false;
+    const updated = Date.parse(clean(row.updatedAt)) || 0;
+    return !(updated > 0 && now - updated <= WORKER_POOL_FRESH_MS);
+  }
+
+  function terminalReapAt(row, now) {
+    let reapMs = null;
+    try { reapMs = resolveAgentTerminalReapMs(cfgMod.loadConfig(), row?.provider); }
+    catch { reapMs = null; }
+    return reapMs == null ? null : new Date(now + reapMs).toISOString();
+  }
+
+  function idleWorkerRow(row, now, touch = false) {
+    const stamp = new Date(now).toISOString();
+    return {
+      ...row,
+      status: 'idle',
+      stage: 'idle',
+      turnStartedAt: null,
+      finishedAt: touch ? stamp : (clean(row.finishedAt) || clean(row.updatedAt) || stamp),
+      updatedAt: touch ? stamp : (clean(row.updatedAt) || stamp),
+      reapAt: touch ? terminalReapAt(row, now) : (clean(row.reapAt) || terminalReapAt(row, now)),
+    };
+  }
+
   // Spawn-path writes are batched onto one microtask so a parallel fanout pays
   // a single locked rewrite instead of one per worker.
   function flushWorkerIndexMutations() {
@@ -197,6 +270,9 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
     return {
       tag,
       sessionId,
+      parentSessionId: clean(extra.parentSessionId)
+        || clean(session?.parentSessionId)
+        || null,
       ownerSessionId: clean(extra.ownerSessionId || extra.parentSessionId)
         || clean(session?.ownerSessionId || session?.parentSessionId)
         || null,
@@ -219,6 +295,7 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
       // the new absolute deadline immediately afterwards via scheduleReap().
       reapAt: clean(extra.reapAt) || null,
       clientHostPid: positiveInt(extra.clientHostPid) || positiveInt(session?.clientHostPid),
+      runtimePid: positiveInt(extra.runtimePid) || process.pid,
       cwd: clean(session?.cwd) || clean(extra.cwd) || null,
       task_id: clean(extra.task_id || extra.taskId) || null,
       error: clean(extra.error) || null,
@@ -234,6 +311,10 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
   function upsertWorkerRow(row, { defer = false } = {}) {
     const normalized = normalizeWorkerRows({ workers: [row] })[0];
     if (!normalized) return false;
+    const key = workerRowKey(normalized);
+    if (ACTIVE_WORKER_STATUS.test(normalized.status)
+      || ACTIVE_WORKER_STATUS.test(normalized.stage)) activeWorkerKeys.add(key);
+    else activeWorkerKeys.delete(key);
     const bindTag = !isLeadPoolAgent(normalized.agent);
     if (bindTag) {
       tags.set(normalized.tag, normalized.sessionId);
@@ -288,6 +369,45 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
     return rows;
   }
 
+  function flushActiveWorkerRows() {
+    if (!activeWorkerKeys.size) return;
+    const keys = [...activeWorkerKeys];
+    activeWorkerKeys.clear();
+    const now = Date.now();
+    writeWorkerRows((byKey) => {
+      for (const key of keys) {
+        const current = byKey.get(key);
+        if (!current || positiveInt(current.runtimePid) !== process.pid) continue;
+        const active = ACTIVE_WORKER_STATUS.test(clean(current.status))
+          || ACTIVE_WORKER_STATUS.test(clean(current.stage));
+        if (active) byKey.set(key, idleWorkerRow(current, now, true));
+      }
+    });
+  }
+
+  function recoverStaleWorkerRows() {
+    const now = Date.now();
+    const stale = readAllWorkerRows().filter((row) => staleActiveWorkerRow(row, now));
+    if (!stale.length) return false;
+    writeWorkerRows((byKey) => {
+      for (const row of stale) {
+        const key = workerRowKey(row);
+        const current = byKey.get(key);
+        if (!current || !staleActiveWorkerRow(current, now)) continue;
+        byKey.set(key, idleWorkerRow(current, now));
+      }
+    });
+    return true;
+  }
+
+  function flushWorkerIndexOnExit() {
+    flushWorkerIndexMutations();
+    flushActiveWorkerRows();
+  }
+
+  recoverStaleWorkerRows();
+  registerExitFlush(flushWorkerIndexOnExit);
+
   return {
     workerIndexPath,
     invalidateWorkerRowsCache: invalidateCache,
@@ -304,5 +424,8 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
     upsertWorkerSessionDeferred,
     removeWorkerRow,
     refreshTagsFromIndex,
+    flushActiveWorkerRows,
+    flushWorkerIndexOnExit,
+    recoverStaleWorkerRows,
   };
 }

package/src/standalone/agent-tool/worker-index.test.mjs

@@ -0,0 +1,132 @@
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import { listStoredAgentWorkers } from '../../runtime/agent/orchestrator/session/store-summary-reader.mjs';
+import { createWorkerIndex } from './worker-index.mjs';
+
+function workerIndex(root) {
+  return createWorkerIndex({
+    dataDir: root,
+    cfgMod: { loadConfig: () => ({}) },
+    mgr: { getSessionRuntime: () => null },
+    tags: new Map(),
+    tagAgents: new Map(),
+    tagCwds: new Map(),
+  });
+}
+
+function writeWorkers(root, workers) {
+  writeFileSync(join(root, 'agent-workers.json'), JSON.stringify({ workers }));
+}
+
+test('worker boot recovery settles a running row whose runtime died', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-worker-recover-'));
+  const previous = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = root;
+  try {
+    mkdirSync(join(root, 'sessions'));
+    const now = Date.now();
+    writeWorkers(root, {
+      crashed: {
+        tag: 'crashed',
+        sessionId: 'crashed',
+        ownerSessionId: 'lead-a',
+        agent: 'worker',
+        status: 'running',
+        stage: 'running',
+        runtimePid: 0x7fffffff,
+        turnStartedAt: new Date(now - 5_000).toISOString(),
+        updatedAt: new Date(now - 5_000).toISOString(),
+      },
+      live: {
+        tag: 'live',
+        sessionId: 'live',
+        ownerSessionId: 'lead-a',
+        agent: 'worker',
+        status: 'running',
+        stage: 'running',
+        runtimePid: process.pid,
+        turnStartedAt: new Date(now - 5_000).toISOString(),
+        updatedAt: new Date(now - 5_000).toISOString(),
+      },
+    });
+
+    workerIndex(root);
+
+    const stored = JSON.parse(readFileSync(join(root, 'agent-workers.json'), 'utf8'));
+    assert.equal(stored.workers.crashed.status, 'idle');
+    assert.equal(stored.workers.crashed.stage, 'idle');
+    assert.equal(stored.workers.crashed.turnStartedAt, null);
+    assert.equal(stored.workers.live.status, 'running');
+
+    const pool = listStoredAgentWorkers();
+    assert.equal(pool.find((row) => row.sessionId === 'crashed')?.status, 'idle');
+    assert.equal(pool.find((row) => row.sessionId === 'live')?.status, 'running');
+  } finally {
+    if (previous === undefined) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previous;
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('cold pool reader does not trust an expired running worker row', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-worker-cold-stale-'));
+  const previous = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = root;
+  try {
+    mkdirSync(join(root, 'sessions'));
+    const old = new Date(Date.now() - 3 * 60 * 1000).toISOString();
+    writeWorkers(root, {
+      stale: {
+        tag: 'stale',
+        sessionId: 'stale',
+        ownerSessionId: 'lead-a',
+        agent: 'worker',
+        status: 'running',
+        stage: 'running',
+        turnStartedAt: old,
+        updatedAt: old,
+      },
+    });
+
+    const row = listStoredAgentWorkers().find((entry) => entry.sessionId === 'stale');
+    assert.equal(row?.status, 'idle');
+    assert.equal(row?.stage, 'idle');
+    assert.equal(row?.turnStartedAt, null);
+  } finally {
+    if (previous === undefined) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previous;
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('worker exit flush commits queued state before settling active work', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-worker-exit-flush-'));
+  try {
+    mkdirSync(join(root, 'sessions'));
+    const index = workerIndex(root);
+    index.upsertWorkerSessionDeferred({
+      id: 'exit-worker',
+      ownerSessionId: 'lead-a',
+      agentTag: 'exit-worker',
+      agent: 'worker',
+      createdAt: new Date().toISOString(),
+    }, 'exit-worker', {
+      status: 'running',
+      stage: 'running',
+      turnStartedAt: new Date().toISOString(),
+    });
+
+    index.flushWorkerIndexOnExit();
+
+    const stored = JSON.parse(readFileSync(join(root, 'agent-workers.json'), 'utf8'));
+    assert.equal(stored.workers['exit-worker'].status, 'idle');
+    assert.equal(stored.workers['exit-worker'].stage, 'idle');
+    assert.equal(stored.workers['exit-worker'].turnStartedAt, null);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/src/standalone/agent-tool/worker-rows.mjs

@@ -74,7 +74,7 @@ export function applyWorkerRowUpsert(byKey, normalized) {
   if (!key) return;
   const prev = byKey.get(key) || {};
   const merged = { ...prev, ...normalized };
-  for (const field of ['ownerSessionId', 'agent', 'provider', 'model', 'preset', 'effort', 'fast', 'clientHostPid', 'cwd', 'task_id', 'permission', 'toolPermission', 'turnStartedAt']) {
+  for (const field of ['parentSessionId', 'ownerSessionId', 'agent', 'provider', 'model', 'preset', 'effort', 'fast', 'clientHostPid', 'runtimePid', 'cwd', 'task_id', 'permission', 'toolPermission', 'turnStartedAt']) {
     if ((merged[field] === null || merged[field] === '') && prev[field] != null && prev[field] !== '') {
       merged[field] = prev[field];
     }
@@ -89,6 +89,7 @@ export function applyWorkerRowUpsert(byKey, normalized) {
 export function workerRowToSession(row = {}) {
   return {
     id: row.sessionId,
+    parentSessionId: row.parentSessionId || row.ownerSessionId || null,
     ownerSessionId: row.ownerSessionId || null,
     agentTag: row.tag,
     agent: row.agent || null,

package/src/standalone/agent-tool.mjs

@@ -97,10 +97,13 @@ export function createStandaloneAgent({
   mcpScopeId = null,
   onSubagentEvent,
   notifySessionCompletion,
+  sessionSurface = null,
   awaitKeychainPrewarm = async () => {},
   isKeychainPrewarmReady = () => true,
 }) {
   const mgr = baseMgr;
+  const canUseSessionSurface = (session) => typeof sessionSurface?.runTurn === 'function'
+    && sessionSurface.canRun?.(session) !== false;
   const statusListeners = new Set();
   const notifyStatusChange = () => {
     for (const listener of [...statusListeners]) {
@@ -118,6 +121,8 @@ export function createStandaloneAgent({
       notifyContext?.callerSessionId
       || notifyContext?.sessionId
       || notifyContext?.routingSessionId
+      || session?.parentSessionId
+      || notifyContext?.ownerSessionId
       || session?.ownerSessionId,
     );
     const handle = beginAgentTurnReview(ownerSessionId, session?.id, { tag, agent });
@@ -230,6 +235,7 @@ export function createStandaloneAgent({
       emitSubagentEvent,
       notifyStatusChange,
       notifySessionCompletion,
+      sessionSurface,
       scheduleReap,
       cfgMod,
       dataDir,
@@ -288,11 +294,12 @@ export function createStandaloneAgent({
           provider: session.provider,
           model: session.model,
           content: result?.content || '',
+          ...(sessionSurface?.canonical === true ? { handoffOnly: true } : {}),
           ...(abnormalError ? { error: abnormalError } : {}),
         };
       };
       handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(sessionId));
-      const result = await mgr.askSession(sessionId, prompt, args.context || null, null, session.cwd || defaultCwd, null, {
+      const turnHooks = {
         notifyFn: workerNotifyFn(sessionId, notifyContext || {}),
         onToolResult: (message) => turnReview.onToolResult(message),
         ...(job ? {
@@ -304,7 +311,24 @@ export function createStandaloneAgent({
             reconcileJobTerminalResult(job, value);
           },
         } : {}),
-      });
+      };
+      const result = canUseSessionSurface(session)
+        ? await sessionSurface.runTurn({
+            session,
+            prompt,
+            context: args.context || null,
+            cwd: session.cwd || defaultCwd,
+            ...turnHooks,
+          })
+        : await mgr.askSession(
+            sessionId,
+            prompt,
+            args.context || null,
+            null,
+            session.cwd || defaultCwd,
+            null,
+            turnHooks,
+          );
       // Early preview no longer suppresses the canonical body notification;
       // notifyTaskCompletion fires once with output via resolve/reconcile.
       const finalValue = completionValue(result);
@@ -359,7 +383,9 @@ export function createStandaloneAgent({
   // live session (reuse path). Busy sessions queue the prompt; idle ones run a
   // background send job that continues the existing session (context kept).
   function dispatchToExistingSession(prepared, notifyContext, extras = {}) {
-    if (isSessionBusy(prepared.sessionId) && typeof mgr.enqueuePendingMessage === 'function') {
+    if (!canUseSessionSurface(prepared.session)
+      && isSessionBusy(prepared.sessionId)
+      && typeof mgr.enqueuePendingMessage === 'function') {
       const queueDepth = mgr.enqueuePendingMessage(prepared.sessionId, prepared.prompt);
       return renderResult({
         queued: true,
@@ -383,7 +409,7 @@ export function createStandaloneAgent({
     return renderResult({ ...extras, ...renderJob(job, false) });
   }
 
-  function close(args, context = {}) {
+  async function close(args, context = {}) {
     const scopedContext = agentScope(args, context);
     refreshTagsFromSessions({ scanSessions: wantsSessionScan(args), context: scopedContext });
     const taskId = taskIdFromArgs(args);
@@ -415,6 +441,9 @@ export function createStandaloneAgent({
       throw new Error(`agent close: target "${target}" is a Lead session`);
     }
     cancelReap(sessionId);
+    const descendantSessionIds = typeof mgr.descendantSessionIds === 'function'
+      ? mgr.descendantSessionIds(sessionId)
+      : [];
     const tag = tagForSession(sessionId);
     clearAgentStatuslineRoute(sessionId);
     // Cancel any running background task bound to this session BEFORE closing
@@ -430,13 +459,18 @@ export function createStandaloneAgent({
     // Close (and stamp cancelStatus) BEFORE dropping the worker row. Removing
     // the row first left the next pool read with only a leftover heartbeat,
     // which republished the session as `running`.
-    const ok = mgr.closeSession(sessionId, 'cli-agent-close');
+    const ok = await mgr.closeSession(sessionId, 'cli-agent-close');
     if (task?.taskId) cancelBackgroundTask(task.taskId, 'cancelled by agent close');
     // Drop the row only once the cancellation is DURABLY recorded. A close that
     // failed still forgot the row, leaving the next pool read with a fresh
     // heartbeat and no cancelled state — which republished the session as
     // `running`, the exact lingering row this whole path exists to prevent.
     if (ok) forgetTerminalSession(tag, sessionId);
+    if (ok) {
+      for (const descendantSessionId of descendantSessionIds) {
+        removeWorkerRow({ sessionId: descendantSessionId });
+      }
+    }
     return { closed: ok, tag, sessionId, task_id: task?.taskId || null };
   }
 
@@ -455,7 +489,7 @@ export function createStandaloneAgent({
     };
   }
 
-  function closeAll(reason = 'cli-agent-close-all', scope = {}) {
+  async function closeAll(reason = 'cli-agent-close-all', scope = {}) {
     // Scoped teardown (one Lead closing/deleting/switching) must close ONLY
     // that Lead's workers: the worker index and task registry are shared by
     // every Lead in the process, and the old unscoped sweep wiped sibling
@@ -467,7 +501,7 @@ export function createStandaloneAgent({
     const failed = [];
     for (const { tag, session } of agentSessionEntries({ scanSessions: false, context })) {
       try {
-        closed.push(close({ sessionId: session.id }, context));
+        closed.push(await close({ sessionId: session.id }, context));
       } catch (err) {
         failed.push({ tag, error: presentErrorText(err, { surface: 'agent' }) });
       }
@@ -538,12 +572,25 @@ export function createStandaloneAgent({
       const callerCwd = clean(context.cwd || context.callerCwd);
       const scopedContext = agentScope(args, context);
       const notifyContext = context;
+      if (typeof mgr.rehydrateAgentSessions === 'function') {
+        await mgr.rehydrateAgentSessions();
+        // Rebuild tag ownership from canonical records even if a daemon crash
+        // happened before the auxiliary worker row was flushed.
+        refreshTagsFromSessions({ scanSessions: true, context: scopedContext });
+      }
       if (type === 'list') return renderResult({ workers: list({ scanSessions: wantsSessionScan(args), context: scopedContext }), jobs: listJobs(scopedContext) });
       if (type === 'status') return renderResult(renderJob(getJobOrWorker(args, scopedContext), false));
-      if (type === 'read') return renderResult(renderJob(getJobOrWorker(args, scopedContext), true));
+      if (type === 'read') {
+        const job = getJobOrWorker(args, scopedContext);
+        if (job?.taskId == null && typeof mgr.readSessionHandoff === 'function') {
+          const handoff = await mgr.readSessionHandoff(job.meta?.sessionId);
+          if (handoff) job.result = handoff;
+        }
+        return renderResult(renderJob(job, true));
+      }
       if (type === 'cleanup') return renderResult(cleanup(args, scopedContext));
-      if (type === 'cancel') return renderResult(close(args, scopedContext));
-      if (type === 'close') return renderResult(close(args, scopedContext));
+      if (type === 'cancel') return renderResult(await close(args, scopedContext));
+      if (type === 'close') return renderResult(await close(args, scopedContext));
       if (type === 'send') {
         try {
           const prepared = await prepareSend(args, scopedContext);