mixdog 1.2.5 → 1.3.0

package/src/session-runtime/workflow-agents-api/workflow-packs.mjs

@@ -48,11 +48,21 @@ export function createWorkflowPacksApi(deps) {
     }));
   }
 
-  async function setWorkflow(workflowId) {
+  // `{ scope: 'session' }` (the composer's selector in a session): a session
+  // with a conversation switches alone from its next turn
+  // (switchSessionWorkflow) and the configured workflow — the default for new
+  // sessions — stays as it is. Without a conversation, and without the
+  // scope, the choice becomes the configured workflow and an empty session
+  // picks it up in place, as before.
+  async function setWorkflow(workflowId, options = {}) {
     const requested = normalizeWorkflowId(workflowId, DEFAULT_WORKFLOW_ID);
     const id = requested === 'solo' ? DEFAULT_WORKFLOW_ID : requested;
     const pack = loadWorkflowPack(resolveDataDir(deps), id);
     if (!pack || pack.id !== id) throw new Error(`workflow "${workflowId}" not found`);
+    if (options?.scope === 'session') {
+      const switched = await deps.switchSessionWorkflow?.(id);
+      if (switched) return { ...switched.workflow, ...switched };
+    }
     saveActiveWorkflow(id);
     const applied = await deps.refreshEmptySessionToolPolicy?.();
     deps.invalidatePreSessionToolSurface?.();

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

@@ -1,5 +1,6 @@
 import { createOnboardingApi } from './workflow-agents-api/onboarding.mjs';
 import { createAgentEditorApi } from './workflow-agents-api/agent-editor.mjs';
+import { createAgentConnectorsApi } from './workflow-agents-api/agent-connectors.mjs';
 import { createAgentRouteApi } from './workflow-agents-api/agent-route.mjs';
 import { createWorkflowPacksApi } from './workflow-agents-api/workflow-packs.mjs';
 import { createStyleAndModeApi } from './workflow-agents-api/style-and-mode.mjs';
@@ -11,9 +12,11 @@ import { createStyleAndModeApi } from './workflow-agents-api/style-and-mode.mjs'
 // getOnboardingStatus from the composed runtime API through `this`.
 export function createWorkflowAgentsApi(deps) {
   const routeApi = createAgentRouteApi(deps);
+  const editorApi = createAgentEditorApi({ ...deps, setAgentRoute: routeApi.setAgentRoute });
   return {
     ...createOnboardingApi(deps),
-    ...createAgentEditorApi({ ...deps, setAgentRoute: routeApi.setAgentRoute }),
+    ...editorApi,
+    ...createAgentConnectorsApi(deps, editorApi),
     ...routeApi,
     ...createWorkflowPacksApi(deps),
     ...createStyleAndModeApi(deps),

package/src/standalone/channel-transport/http-routes.mjs

@@ -31,9 +31,10 @@ export function createChannelRoutes({
   // Checked on every register/call/agent dispatch, first and again right
   // before the work is handed on (the lease may have been fenced while the
   // body was still arriving): a daemon that lost (or cannot re-verify) its
-  // owner lease serves nothing.
-  function refuseUnadmitted(res) {
-    if (admitWork()) return false;
+  // owner lease serves nothing. `admitWork` may answer asynchronously (a
+  // request arriving during the lease's re-verification waits for it).
+  async function refuseUnadmitted(res) {
+    if (await admitWork()) return false;
     sendError(res, 'daemon owner lease is not held', 503);
     return true;
   }
@@ -54,10 +55,10 @@ export function createChannelRoutes({
   }
 
   async function register(req, res) {
-    if (refuseUnadmitted(res)) return;
+    if (await refuseUnadmitted(res)) return;
     if (state.drainCommitted) return sendDraining(res);
     const body = await readChannelBody(req);
-    if (refuseUnadmitted(res)) return;
+    if (await refuseUnadmitted(res)) return;
     const clientToken = registry.registerClient({
       leadPid: body.leadPid,
       cwd: body.cwd,
@@ -96,11 +97,11 @@ export function createChannelRoutes({
   // channels client registry alive. The broker itself owns a parallel fair
   // scheduler and per-call cancellation.
   async function agentDispatch(req, res) {
-    if (refuseUnadmitted(res)) return;
+    if (await refuseUnadmitted(res)) return;
     if (state.drainCommitted) return sendDraining(res);
     if (!agentBroker?.dispatch) return sendError(res, 'agent broker unavailable', 503);
     const body = await readChannelBody(req);
-    if (refuseUnadmitted(res)) return;
+    if (await refuseUnadmitted(res)) return;
     const callId = String(body.callId || '').trim();
     if (!callId) return sendError(res, 'callId required', 400);
     res.on('close', () => {
@@ -130,10 +131,10 @@ export function createChannelRoutes({
   }
 
   async function call(req, res) {
-    if (refuseUnadmitted(res)) return;
+    if (await refuseUnadmitted(res)) return;
     if (state.drainCommitted) return sendDraining(res);
     const body = await readChannelBody(req);
-    if (refuseUnadmitted(res)) return;
+    if (await refuseUnadmitted(res)) return;
     const clientToken = body.token || null;
     const c = clientToken ? clients.get(clientToken) : null;
     if (!c) return sendError(res, 'unknown client token', 404);

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

@@ -8,8 +8,6 @@
 // this control exists — the host takes `execute` as a constructor option), and
 // `cwd`. Output: { canonicalAgentTool, execute }.
 
-import { deliverAutomationCompletion } from '../session-runtime/automation-agents.mjs';
-
 export function createCanonicalAgentControl({ getSessionService, getSessionRuntimeHost, cwd }) {
   let canonicalAgentToolPromise = null;
 
@@ -34,12 +32,7 @@ export function createCanonicalAgentControl({ getSessionService, getSessionRunti
           isKeychainPrewarmReady: () => true,
           sessionSurface: sessionService.agentSurface,
           notifySessionCompletion(ownerSessionId, text, meta = {}) {
-            // A schedule/webhook run owns no session runtime; its own
-            // agent-result waiter takes the completions it is owed.
-            return (
-              getSessionRuntimeHost()?.notifySessionCompletion?.(ownerSessionId, text, meta) === true ||
-              deliverAutomationCompletion(ownerSessionId, text, meta)
-            );
+            return getSessionRuntimeHost()?.notifySessionCompletion?.(ownerSessionId, text, meta) === true;
           },
         });
       })

package/src/standalone/daemon-desktop-runtime.mjs

@@ -12,22 +12,33 @@
  *  this daemon's in-memory turn activity (every session runs inline here, so
  *  it is the single source of truth; worker index files only declare work). */
 async function loadSessionStoreWithRuntimeActivity() {
-  const [store, runtime, progress] = await Promise.all([
+  const [store, runtime, progress, tasks] = await Promise.all([
     import('../runtime/agent/orchestrator/session/store-summary-reader.mjs'),
     // The import-free leaf holding the runtime map: no session manager graph.
     import('../runtime/agent/orchestrator/session/manager/runtime-state.mjs'),
     import('../runtime/agent/orchestrator/session/agent-pool-progress.mjs'),
+    import('../runtime/shared/background-tasks.mjs'),
   ]);
   return {
     ...store,
     // Running rows also carry their turn's progress stamp and stage (the
-    // quiet-time cue), read from the same runtime map.
-    listStoredAgentWorkers: () =>
-      progress.withTurnProgress(
-        store.listStoredAgentWorkers({ runningSessionIds: runtime.inFlightSessionActivity().working }),
+    // quiet-time cue), read from the same runtime map; an idle row whose
+    // agent handed off background shell work that still runs reads waiting.
+    // The handed-off shell work of every row comes from one task scan. The
+    // store is read with awaited I/O (a listing runs on every activity
+    // change); the running set is taken once those reads are done.
+    listStoredAgentWorkers: async () => {
+      const rows = await store.listStoredAgentWorkersAsync({
+        runningSessionIds: () => runtime.inFlightSessionActivity().working,
+      });
+      const awaiting = tasks.activeBackgroundTaskSessionIds({ surface: 'shell', awaitedOnly: true });
+      return progress.withTurnProgress(
+        rows,
         (sessionId) => runtime.runtimeState.get(sessionId),
-        runtime.isTurnInFlight
-      ),
+        runtime.isTurnInFlight,
+        (sessionId) => awaiting.has(sessionId)
+      );
+    },
   };
 }
 
@@ -53,6 +64,8 @@ export function createDesktopRuntime({ getLocalSessionBridge }) {
     loadStatuslineSegments: () => import('../runtime/shared/statusline/statusline-segments.mjs'),
     loadConfig: () => import('../runtime/shared/config.mjs'),
     loadDocumentPreview: () => import('../runtime/office/pdf/document-preview.mjs'),
+    // The desktop service's git children start on this worker, off the loop.
+    loadProcessRunner: () => import('../runtime/shared/process-runner.mjs'),
     async executeCodeGraphTool(name, args, cwd) {
       const graph = await import('../runtime/agent/orchestrator/tools/code-graph/dispatch.mjs');
       return graph.executeCodeGraphTool(name, args, cwd);

package/src/standalone/daemon-owner.mjs

@@ -15,6 +15,14 @@
 //   being renewed, and every register/call asks `admit()` first. After an
 //   event-loop stall nothing is served until a refresh under the claim lock
 //   proves the record still names it — a contender's claim takes that lock.
+//   A lease that ran out DURING such a stall (live when the loop stopped) is
+//   the one exception to the fence: the holder never had a turn to refresh
+//   or to fence, and a contender's reclaim is decided under the claim lock
+//   against the record's heartbeat there (daemonOwnerIsStale re-checks it),
+//   so a refresh that finds the record still naming this pid proves no
+//   contender took it and none can on its earlier proof. Without that, a sole
+//   daemon whose loop the machine starved past the lease killed itself and
+//   every running turn with no other daemon to take over.
 // - Holder's record names `livenessPort` from its very first claim: a tiny
 //   loopback listener started BEFORE the claim (startOwnerLivenessListener)
 //   answers /health with the pid, through boot and for the process lifetime.
@@ -32,8 +40,9 @@
 // daemon.json publishes, answering with that pid, proves them alive.
 import http from 'node:http';
 import { readFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
 import { isPidAlive } from '../runtime/shared/pid-liveness.mjs';
-import { readSingletonOwner, refreshSingletonOwner } from '../runtime/shared/singleton-owner.mjs';
+import { readSingletonOwner, refreshSingletonOwnerAsync } from '../runtime/shared/singleton-owner.mjs';
 
 export const DAEMON_OWNER_STALE_MS = 60_000;
 export const OWNER_PROBE_TIMEOUT_MS = 3_000;
@@ -58,11 +67,23 @@ export function daemonOwnerTimings(env = process.env) {
 }
 
 /** daemon.json's pid and session endpoint, or null when missing/unreadable. */
+function discoveryOf(parsed) {
+  const session = parsed?.endpoints?.session;
+  return { pid: Number(parsed?.pid) || 0, port: Number(session?.port) || 0, token: session?.token || '' };
+}
+
 export function readDiscovery(discoveryPath) {
   try {
-    const parsed = JSON.parse(readFileSync(discoveryPath, 'utf8'));
-    const session = parsed?.endpoints?.session;
-    return { pid: Number(parsed?.pid) || 0, port: Number(session?.port) || 0, token: session?.token || '' };
+    return discoveryOf(JSON.parse(readFileSync(discoveryPath, 'utf8')));
+  } catch {
+    return null;
+  }
+}
+
+/** readDiscovery without blocking the event loop. */
+export async function readDiscoveryAsync(discoveryPath) {
+  try {
+    return discoveryOf(JSON.parse(await readFile(discoveryPath, 'utf8')));
   } catch {
     return null;
   }
@@ -243,7 +264,10 @@ export function daemonOwnerIsStale(
  * `tickMs` it checks the lease, notices stalls, and every `heartbeatMs`
  * rewrites `owner` with a fresh wall-clock `heartbeatAt` under the claim lock
  * (recreating a deleted record), then calls `onBeat`.
- * - No successful refresh for `fenceMs`: fenced, never renewed (`onFenced`).
+ * - No successful refresh for `fenceMs`: fenced, never renewed (`onFenced`) —
+ *   unless the lease ran out inside one stall (live when the loop stopped):
+ *   then the refresh is retried every tick for `heartbeatMs` after the loop
+ *   resumes, and fenced only if none succeeds by then.
  * - The record names another pid: `onSuperseded(record)`.
  * - A turn gap over `stallMs`: `admit()` refuses work until a refresh succeeds.
  *   The gap is logged once, with `describeStall(fromMono, toMono)` appended.
@@ -258,7 +282,7 @@ export function createOwnerHeartbeat({
   stallMs,
   now = Date.now,
   monoNow = () => performance.now(),
-  refresh = refreshSingletonOwner,
+  refresh = refreshSingletonOwnerAsync,
   log = () => {},
   describeStall = null,
   onBeat = () => {},
@@ -272,6 +296,13 @@ export function createOwnerHeartbeat({
   let lastBeatAt = leaseFrom;
   let lastTurnAt = leaseFrom;
   let needsVerify = false;
+  // Monotonic time the loop resumed from a stall that outlived the lease.
+  let stallResumedAt = null;
+  // The refresh in flight: a promise of its settled status, else null.
+  let pending = null;
+  // When the latest stall was noticed: only a refresh started after it can
+  // re-verify the record (an older one may have read it before the stall).
+  let stallNotedAt = Number.NEGATIVE_INFINITY;
   let timer = null;
 
   function halt(next) {
@@ -284,6 +315,12 @@ export function createOwnerHeartbeat({
     return t - leaseFrom >= fenceMs;
   }
 
+  // Expired and past re-verification: the refreshes failed while the loop
+  // ran, or no refresh landed within `heartbeatMs` of resuming from a stall.
+  function mustFence(t) {
+    return leaseExpired(t) && !(stallResumedAt !== null && t - stallResumedAt < heartbeatMs);
+  }
+
   function fence(t) {
     if (state !== 'active') return;
     halt('fenced');
@@ -298,6 +335,8 @@ export function createOwnerHeartbeat({
     lastTurnAt = t;
     if (t - from <= stallMs) return;
     needsVerify = true;
+    stallNotedAt = t;
+    if (state === 'active' && !leaseExpired(from) && leaseExpired(t)) stallResumedAt = t;
     let detail = '';
     try {
       detail = describeStall?.(from, t) || '';
@@ -310,13 +349,53 @@ export function createOwnerHeartbeat({
     );
   }
 
+  // A refresh's verdict, applied once it is known. Fenced, superseded or
+  // stopped while it ran: nothing is renewed. A renewal counts from the
+  // moment the refresh started (`t`), never from when it answered.
+  function settle(t, heartbeatAt, result) {
+    if (state !== 'active') return result.status;
+    if (result.status === 'refreshed') {
+      if (leaseExpired(t)) {
+        log(
+          `owner lease re-verified ${Math.round(t - leaseFrom)}ms after its last refresh (event-loop stall)` +
+            ' — the record still names this process; serving again'
+        );
+      }
+      leaseFrom = t;
+      lastRefreshAt = heartbeatAt;
+      if (t >= stallNotedAt) {
+        needsVerify = false;
+        stallResumedAt = null;
+      }
+      onBeat();
+    } else if (result.status === 'superseded') {
+      halt('superseded');
+      onSuperseded(result.owner);
+    } else if (result.status === 'busy') {
+      log('owner heartbeat skipped: claim lock busy');
+    }
+    return result.status;
+  }
+
+  function failedRefresh(error) {
+    log(`owner heartbeat failed: ${error?.message || error}`);
+    return { status: 'failed' };
+  }
+
+  // One refresh at a time. An asynchronous refresh (the default: its file
+  // work and lock retries never block the loop) answers 'pending' here and
+  // settles later; the lease and fence keep their monotonic deadlines while
+  // it runs — a refresh still unanswered at the fence does not hold it off.
   function beat() {
     if (state !== 'active') return null;
+    if (pending) return 'pending';
     const t = monoNow();
     lastBeatAt = t;
-    // Checked before every renewal: an overdue beat after a stall must fence,
-    // not extend a lease a contender may already have reclaimed.
-    if (leaseExpired(t)) {
+    // Checked before every renewal: an overdue beat must fence, not extend a
+    // lease a contender may already have reclaimed — except right after a
+    // stall that outlived the lease, where the refresh itself (under the
+    // claim lock) answers whether one did.
+    if (mustFence(t)) {
       fence(t);
       return 'fenced';
     }
@@ -325,28 +404,26 @@ export function createOwnerHeartbeat({
     try {
       result = refresh(ownerPath, { ...record, heartbeatAt });
     } catch (error) {
-      log(`owner heartbeat failed: ${error?.message || error}`);
-      result = { status: 'failed' };
-    }
-    if (result.status === 'refreshed') {
-      leaseFrom = t;
-      lastRefreshAt = heartbeatAt;
-      needsVerify = false;
-      onBeat();
-    } else if (result.status === 'superseded') {
-      halt('superseded');
-      onSuperseded(result.owner);
-    } else if (result.status === 'busy') {
-      log('owner heartbeat skipped: claim lock busy');
+      result = failedRefresh(error);
     }
-    return result.status;
+    if (typeof result?.then !== 'function') return settle(t, heartbeatAt, result);
+    pending = result
+      .then(
+        (value) => value,
+        (error) => failedRefresh(error)
+      )
+      .then((value) => {
+        pending = null;
+        return settle(t, heartbeatAt, value);
+      });
+    return 'pending';
   }
 
   function tick() {
     if (state !== 'active') return;
     const t = monoNow();
     noteTurn(t);
-    if (leaseExpired(t)) fence(t);
+    if (mustFence(t)) fence(t);
     else if (needsVerify ? t - lastBeatAt >= tickMs : t - lastBeatAt >= heartbeatMs) beat();
   }
 
@@ -363,7 +440,7 @@ export function createOwnerHeartbeat({
       // Shutting down: no ticks run to measure stalls; the lease still bounds it.
       if (state === 'stopped') return !leaseExpired(t);
       noteTurn(t);
-      if (leaseExpired(t)) {
+      if (mustFence(t)) {
         fence(t);
         return false;
       }
@@ -372,8 +449,23 @@ export function createOwnerHeartbeat({
       if (needsVerify && t - lastBeatAt >= tickMs) beat();
       return state === 'active' && !needsVerify;
     },
+    /** admit(), but a request arriving while the lease is being re-verified
+     *  waits for the verifying refresh instead of being refused outright: at
+     *  most two refreshes (one started before the stall cannot verify). */
+    async admitAsync() {
+      for (let attempt = 0; attempt < 2; attempt += 1) {
+        if (this.admit()) return true;
+        if (!pending) return false;
+        await pending;
+      }
+      return this.admit();
+    },
     beat,
     tick,
+    /** Settles with the in-flight refresh's status (null when none runs). */
+    settled() {
+      return pending ?? Promise.resolve(null);
+    },
     /** Stop beating (shutdown). admit() keeps refusing once the lease runs out. */
     stop() {
       if (state === 'active') halt('stopped');

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

@@ -1,20 +1,26 @@
 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';
 
 const TARGET_ACTIONS = new Set(['status', 'read', 'send', 'cancel', 'delete']);
 const MUTATING_ACTIONS = new Set(['send', 'cancel', 'delete']);
 
 /** Model-facing session operations over the same service used by desktop and TUI. */
-export function createSessionControl({ getSessionService }) {
+export function createSessionControl({
+  getSessionService,
+  agentTasks = createAgentTaskSessions({ getSessionService }),
+}) {
   return async function executeSessionControl(args = {}, context = {}) {
     const action = args.action;
-    if (action !== 'list' && !TARGET_ACTIONS.has(action)) {
+    if (action !== 'list' && action !== 'create' && !TARGET_ACTIONS.has(action)) {
       throw new Error(`session: unsupported remote action "${action}"`);
     }
     const caller = context.callerSessionId;
     if (typeof caller !== 'string' || !SESSION_ID_PATTERN.test(caller)) {
       throw new Error('session: caller session is required');
     }
+    // `callerAgentId`: set only for an attended agent conversation (workspace-tools.mjs).
+    if (action === 'create') return agentTasks.create(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))) {
       throw new Error(`session: session_id is required for action=${action}`);
@@ -45,6 +51,9 @@ export function createSessionControl({ getSessionService }) {
       if (typeof args.prompt !== 'string' || !args.prompt.trim()) {
         throw new Error('session: prompt is required for action=send');
       }
+      // The agent's follow-up in a task session it created reports back too.
+      const origin = await agentTasks.originFor(sessionId, context.callerAgentId);
+      if (origin) return { sessionId, accepted: await agentTasks.send(sessionId, args.prompt, origin) };
       const result = await service.submitSession({
         sessionId,
         prompt: args.prompt,

package/src/standalone/daemon.mjs

@@ -35,7 +35,8 @@ import path from 'node:path';
 import { rmSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { monitorEventLoopDelay, performance } from 'node:perf_hooks';
-import { writeJsonAtomicSync } from '../runtime/shared/atomic-file.mjs';
+import { writeJsonAtomicAsync } from '../runtime/shared/atomic-file.mjs';
+import { prewarmOwnerOnlyAclWin32 } from '../runtime/shared/file-permissions.mjs';
 import { ensurePrivateRuntimeRoot, resolveRuntimeRoot } from '../runtime/shared/runtime-root.mjs';
 import { ensureProcessListenerHeadroom } from '../runtime/shared/process-listener-headroom.mjs';
 import { listenerLeakWarningLine } from '../runtime/shared/listener-leak-warning.mjs';
@@ -46,6 +47,7 @@ import {
   daemonOwnerTimings,
   discoveryPid,
   proveDaemonOwnerRecord,
+  readDiscoveryAsync,
   startOwnerLivenessListener,
 } from './daemon-owner.mjs';
 import { remoteIntentPath } from '../runtime/shared/remote-intent.mjs';
@@ -75,6 +77,8 @@ import { createStoredSessionViews } from './daemon-stored-session-views.mjs';
 import * as quotaResumeStore from '../runtime/shared/quota-resume-store.mjs';
 import { registerWorktreeCacheCleanups } from '../runtime/shared/worktrees/cache-cleanups.mjs';
 import { createInlineSessionRuntimeHost } from './session-runtime-inline-host.mjs';
+import { recoverScheduleResults, setAgentHomeLiveSurface } from '../session-runtime/agent-home-delivery.mjs';
+import { recoverRoutineDeliveries } from '../session-runtime/owned-automation-run.mjs';
 import { getStandaloneMemoryRuntime } from '../session-runtime/services/memory-runtime-proxy.mjs';
 import { registerTranscriptPurgeHook } from '../session-runtime/session-transcript-purge.mjs';
 import { createBootPhaseProfiler } from './boot-phase-profiler.mjs';
@@ -93,7 +97,6 @@ import { createDesktopRuntime } from './daemon-desktop-runtime.mjs';
 import { createCanonicalAgentControl } from './daemon-agent-control.mjs';
 import { createSessionControl } from './daemon-session-control.mjs';
 import { flushAllIndexWrites } from '../session-runtime/services/agent-tool/index-write-queue.mjs';
-import { registerAutomationAgentTool } from '../session-runtime/automation-agents.mjs';
 import {
   compareRuntimeVersions,
   SESSION_CAPABILITY_FINGERPRINT,
@@ -607,11 +610,12 @@ function daemonStatusSnapshot() {
 }
 
 /** The file every attacher reads to find this daemon: wire identity plus both
- *  loopback endpoints and their privileged tokens. */
+ *  loopback endpoints and their privileged tokens. Written asynchronously
+ *  (the secret file's owner-only ACL included), never on the event loop. */
 function publishDaemonDiscovery({ channel, session, modelProxy = null }) {
   // A re-publish keeps the first publication's startedAt.
   publishedEndpoints = { channel, session, modelProxy, startedAt: publishedEndpoints?.startedAt ?? Date.now() };
-  writeJsonAtomicSync(
+  return writeJsonAtomicAsync(
     DAEMON_DISCOVERY_PATH,
     {
       protocol: SESSION_PROTOCOL,
@@ -658,6 +662,13 @@ function admitOwnerWork() {
   return ownerHeartbeat ? ownerHeartbeat.admit() : true;
 }
 
+/** admitOwnerWork for the HTTP front doors: a request that arrives while the
+ *  lease is being re-verified (the refresh is asynchronous) waits for that
+ *  refresh instead of being refused. */
+function admitOwnerWorkAsync() {
+  return ownerHeartbeat ? ownerHeartbeat.admitAsync() : true;
+}
+
 /** This process no longer holds (or is about to lose) the owner lease: refuse
  *  new work at once, unpublish its endpoint so launchers stop finding it, then
  *  shut down within the shutdown budget — before a contender may reclaim. */
@@ -678,14 +689,31 @@ function fenceDaemon(reason) {
 /** Heartbeat follow-up while this process still owns the lock: a daemon.json
  *  deleted (TEMP cleanup) or overwritten while it runs is written again, so
  *  new clients keep finding the one daemon that serves this data dir. */
+// Read and rewritten asynchronously, one check at a time: this runs after
+// every heartbeat, and its synchronous read of daemon.json was measured
+// blocking the loop for 5.9 s under disk contention.
+let republishing = false;
 function republishMissingDiscovery() {
-  if (!publishedEndpoints || shuttingDown || discoveryPid(DAEMON_DISCOVERY_PATH) === process.pid) return;
-  try {
-    publishDaemonDiscovery(publishedEndpoints);
-    log('daemon.json was missing or named another pid — re-published');
-  } catch (error) {
-    log(`daemon.json re-publish failed: ${error?.message || error}`);
-  }
+  if (!publishedEndpoints || shuttingDown || republishing) return;
+  republishing = true;
+  void (async () => {
+    try {
+      if ((await readDiscoveryAsync(DAEMON_DISCOVERY_PATH))?.pid === process.pid || shuttingDown) return;
+      await publishDaemonDiscovery(publishedEndpoints);
+      // Fenced while it was written: take it back down (fenceDaemon already ran).
+      if (shuttingDown) {
+        if ((await readDiscoveryAsync(DAEMON_DISCOVERY_PATH))?.pid === process.pid) {
+          rmSync(DAEMON_DISCOVERY_PATH, { force: true });
+        }
+        return;
+      }
+      log('daemon.json was missing or named another pid — re-published');
+    } catch (error) {
+      log(`daemon.json re-publish failed: ${error?.message || error}`);
+    } finally {
+      republishing = false;
+    }
+  })();
 }
 
 /** Ready handshake for the spawner, plus the log-sink handoff pinned to the
@@ -757,7 +785,7 @@ async function startChannelFrontDoor({ channelsRuntime, bootPhases }) {
   transport = createChannelTransport({
     handleCall: channelsRuntime.handleCall,
     agentBroker: agentDispatchBroker,
-    admitWork: admitOwnerWork,
+    admitWork: admitOwnerWorkAsync,
     log,
     // The durable channel link lives in this file. Without it a restart loses
     // the pinned session (nothing to restore) and every catalog reports Remote
@@ -898,9 +926,6 @@ async function main() {
     cwd: CWD,
   });
   canonicalAgentControl = agentControl;
-  // Schedules and webhooks run headless here; their sessions reach the same
-  // canonical agent control through the automation tool scope.
-  registerAutomationAgentTool(agentControl.execute);
   const requestedRuntimeMode = String(process.env.MIXDOG_SESSION_RUNTIME_MODE || '')
     .trim()
     .toLowerCase();
@@ -957,6 +982,22 @@ async function main() {
     },
     log,
   });
+  // Schedule results reach an open home thread at once (and wait out its turn).
+  setAgentHomeLiveSurface({
+    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.
+    wake: (sessionId, prompt) =>
+      sessionService.submitSession({ sessionId, prompt, options: { mode: 'prompt', kickoff: true } }),
+    // 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,
+    abort: (sessionId) => sessionService.abortSession({ sessionId }),
+  });
+  // Results queued before a restart are posted now; results a finished run
+  // could not queue (kept on its routine's record) are queued again.
+  recoverScheduleResults().catch((error) => log(`routine results recovery failed: ${error?.message || error}`));
+  recoverRoutineDeliveries().catch((error) => log(`routine delivery recovery failed: ${error?.message || error}`));
   sessionTransport = createSessionTransport({
     // ctx carries the CLIENT token: the session service refcounts views across
     // processes with it, so a terminal exiting cannot destroy the session a
@@ -974,7 +1015,7 @@ async function main() {
       } catch {}
     },
     onUpgradeRequested: requestDaemonReplacement,
-    admitWork: admitOwnerWork,
+    admitWork: admitOwnerWorkAsync,
   });
   const sessionEndpoint = await bootPhases.measure('session-transport-start', () => sessionTransport.start());
   const modelProxyEndpoint = await startModelProxyBridge(bootPhases);
@@ -988,7 +1029,7 @@ async function main() {
     exitRecorder.setReason(`owner claim superseded by pid=${ownerPid} before publish`, 0);
     process.exit(0);
   }
-  publishDaemonDiscovery({ channel: { port, token }, session: sessionEndpoint, modelProxy: modelProxyEndpoint });
+  await publishDaemonDiscovery({ channel: { port, token }, session: sessionEndpoint, modelProxy: modelProxyEndpoint });
   bootPhases.mark('discovery-published');
   log(`session front door on 127.0.0.1:${sessionEndpoint.port}`);
 
@@ -1000,6 +1041,9 @@ async function main() {
     void sessionRuntimeHost?.warmLocalRuntime?.();
   });
   startPostgresInBackground();
+  // Secret writes (token stores, config) find the ACL helpers already running
+  // instead of starting one under their file lock.
+  void prewarmOwnerOnlyAclWin32();
 
   // Automation may spawn the shared daemon; keep schedules/webhooks live.
   // A TUI-spawned daemon keeps the historical eager start (its channels client

package/src/standalone/session-call-cache.mjs

@@ -85,6 +85,10 @@ export function createSessionCallCache({
     // Identity cannot be removed inside the promised retry TTL.
     for (const [key, record] of records) {
       if (records.size <= maxEntries && retainedBytes <= maxBytes) return;
+      // Insertion order is `at` order and settledAt >= at, so no later record
+      // can have left its TTL: stop instead of rescanning every live entry on
+      // each new call while a burst holds the cache above its budget.
+      if (at - record.at < ttlMs) break;
       if (!record.settled || !record.settledAt) continue;
       if (at - record.settledAt < ttlMs) continue;
       remove(key, record);
@@ -120,6 +124,8 @@ export function createSessionCallCache({
       bytes: 0,
       timer: null,
     };
+    // Re-insert at the tail so Map order stays `at` order (prune relies on it).
+    remove(key);
     records.set(key, record);
     prune();
     promise