mixdog 0.9.174 → 1.0.0

package/src/{standalone → session-runtime/services}/agent-task-status.mjs

@@ -1,7 +1,7 @@
 import {
   agentWatchdogPolicyActive,
   evaluateAgentWatchdogAbort,
-} from '../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
+} from '../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 
 const ACTIVE_RUNTIME_STAGES = new Set([
   'connecting',

package/src/{standalone → session-runtime/services}/agent-tool/close-flow/close-all.mjs

@@ -1,8 +1,8 @@
 // Bulk teardown: closing every agent session a Lead owns, cancelling the
 // background tasks left running, and purging the worker rows behind them.
 // Single-target close lives in ../close-flow.mjs and is injected as `close`.
-import { cancelBackgroundTask, listBackgroundTasks } from '../../../runtime/shared/background-tasks.mjs';
-import { presentErrorText } from '../../../runtime/shared/err-text.mjs';
+import { cancelBackgroundTask, listBackgroundTasks } from '../../../../runtime/shared/background-tasks.mjs';
+import { presentErrorText } from '../../../../runtime/shared/err-text.mjs';
 import { clean } from '../helpers.mjs';
 import { isLeadPoolAgent } from '../worker-rows.mjs';
 

package/src/{standalone → session-runtime/services}/agent-tool/close-flow.mjs

@@ -4,7 +4,7 @@ import {
   getBackgroundTask,
   listBackgroundTasks,
   taskIdFromArgs,
-} from '../../runtime/shared/background-tasks.mjs';
+} from '../../../runtime/shared/background-tasks.mjs';
 import { agentScope, clean, clearAgentStatuslineRoute } from './helpers.mjs';
 import { isLeadPoolAgent } from './worker-rows.mjs';
 import { createCloseAll } from './close-flow/close-all.mjs';

package/src/{standalone → session-runtime/services}/agent-tool/execute.mjs

@@ -1,4 +1,4 @@
-import { errorLine } from '../../runtime/shared/err-text.mjs';
+import { errorLine } from '../../../runtime/shared/err-text.mjs';
 import { createSendDispatch } from './execute-send.mjs';
 import { createSpawnDispatch } from './execute-spawn.mjs';
 import { agentScope, clean } from './helpers.mjs';

package/src/{standalone → session-runtime/services}/agent-tool/helpers.mjs

@@ -4,14 +4,14 @@ import { isAbsolute, join, resolve } from 'node:path';
 import {
   normalizeAgentPermissionOrNone,
   parseMarkdownFrontmatter,
-} from '../../runtime/shared/markdown-frontmatter.mjs';
+} from '../../../runtime/shared/markdown-frontmatter.mjs';
 import {
   clearGatewaySessionRoute,
   writeGatewaySessionRoutes,
-} from '../../vendor/statusline/src/gateway/session-routes.mjs';
+} from '../../../vendor/statusline/src/gateway/session-routes.mjs';
 import { PRESET_ALIASES } from './tool-def.mjs';
-import { positiveInt } from '../../runtime/shared/numbers.mjs';
-import { clean } from '../../runtime/shared/clean.mjs';
+import { positiveInt } from '../../../runtime/shared/numbers.mjs';
+import { clean } from '../../../runtime/shared/clean.mjs';
 
 export { positiveInt };
 
@@ -59,7 +59,7 @@ export function agentTagOf(session) {
   return clean(session?.agentTag);
 }
 
-export { stampMs } from '../../runtime/shared/agent-reap-state.mjs';
+export { stampMs } from '../../../runtime/shared/agent-reap-state.mjs';
 
 export function normalizeAgentName(value) {
   const id = clean(value)
@@ -256,7 +256,7 @@ function formatElapsedMs(ms) {
   return remMin ? `${hr}h${remMin}m` : `${hr}h`;
 }
 
-export function elapsedFromStamps(startedAt, finishedAt, _status) {
+export function elapsedFromStamps(startedAt, finishedAt) {
   const start = Date.parse(clean(startedAt));
   if (!Number.isFinite(start)) return null;
   const finish = Date.parse(clean(finishedAt));

package/src/session-runtime/services/agent-tool/index-write-queue.mjs

@@ -0,0 +1,209 @@
+// index-write-queue.mjs
+// One in-process writer for a shared JSON index file (worker / Lead pool
+// indexes). It replaces synchronous locked read-modify-writes, whose lock wait
+// (Atomics.wait) and disk I/O ran on the daemon event loop.
+//
+// write(mutator) still runs the mutator synchronously and exactly once, against
+// the in-memory projection (disk document + every not-yet-persisted change), so
+// callers keep their read-your-writes and "did it apply?" semantics. What is
+// persisted is the mutator's EFFECT (per-key set/delete + priority keys), not
+// the mutator: an async job replays those effects onto the fresh on-disk
+// document under the cross-process lock, so concurrent writers of other keys
+// are merged, never overwritten. Jobs run strictly one at a time in FIFO order.
+import { updateJsonAtomic, updateJsonAtomicSync } from '../../../runtime/shared/atomic-file.mjs';
+import { registerJsonProjection } from '../../../runtime/shared/pending-json-projection.mjs';
+import { sleep } from '../../../runtime/shared/sleep.mjs';
+
+const RETRY_DELAYS_MS = [50, 250, 1000];
+const unsettled = new Set(); // queues holding unpersisted writes
+// Exit is the one place a bounded synchronous lock wait is acceptable: the
+// loop is gone, and a dropped settlement would leave rows "running" forever.
+const EXIT_LOCK_TIMEOUT_MS = 250;
+
+function snapshot(arg) {
+  if (arg instanceof Map) {
+    const copy = new Map();
+    for (const [key, value] of arg) copy.set(key, JSON.stringify(value));
+    return copy;
+  }
+  if (arg instanceof Set) return new Set(arg);
+  return null;
+}
+
+/** Effects of `run` on the Map/Set arguments, as replayable ops. */
+function recordOps(args, run) {
+  const before = args.map(snapshot);
+  run();
+  return args.map((arg, index) => {
+    const prior = before[index];
+    if (arg instanceof Map) {
+      const set = [];
+      const del = [];
+      for (const [key, value] of arg) {
+        const json = JSON.stringify(value);
+        if (prior.get(key) !== json) set.push([key, json]);
+      }
+      for (const key of prior.keys()) if (!arg.has(key)) del.push(key);
+      return { set, del };
+    }
+    if (arg instanceof Set) return { add: [...arg].filter((value) => !prior.has(value)) };
+    return null;
+  });
+}
+
+function replayOps(ops, args) {
+  args.forEach((arg, index) => {
+    const op = ops[index];
+    if (!op) return;
+    if (arg instanceof Map) {
+      for (const key of op.del) arg.delete(key);
+      for (const [key, json] of op.set) arg.set(key, JSON.parse(json));
+    } else if (arg instanceof Set) {
+      for (const value of op.add) arg.add(value);
+    }
+  });
+}
+
+/**
+ * @param {object} options
+ * @param {string|null} options.file       index file; null → every write is a no-op
+ * @param {(cur: any, mutator: Function) => any} options.rewrite
+ *        builds the next document from a raw one; `mutator` receives the keyed collections
+ * @param {() => any} options.readDoc      fresh raw document from disk (sync read)
+ * @param {() => void} [options.onPersisted]  the file changed on disk
+ */
+export function createIndexWriteQueue({ file, rewrite, readDoc, onPersisted = () => {} }) {
+  let projection = null; // raw document including unpersisted ops, else null
+  const self = { flush, flushSync: () => flushSync() };
+  if (file) registerJsonProjection(file, () => projection);
+  let version = 0;
+  let pending = []; // op sets not yet handed to a job
+  let inflight = []; // op sets of the running job
+  let running = null;
+  let timer = null;
+
+  function clearTimer() {
+    if (!timer) return;
+    clearImmediate(timer);
+    timer = null;
+  }
+
+  function schedule() {
+    if (timer || running || pending.length === 0) return;
+    timer = setImmediate(drain);
+  }
+
+  async function persist(batch) {
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        await updateJsonAtomic(
+          file,
+          (cur) =>
+            rewrite(cur, (...args) => {
+              for (const ops of batch) replayOps(ops, args);
+            }),
+          { lock: true }
+        );
+        return;
+      } catch {
+        if (attempt >= RETRY_DELAYS_MS.length) return; // dropped, like the sync writer's swallowed failure
+        await sleep(RETRY_DELAYS_MS[attempt]);
+      }
+    }
+  }
+
+  function drain() {
+    timer = null;
+    if (running || pending.length === 0) return;
+    inflight = pending;
+    pending = [];
+    const batch = inflight;
+    running = persist(batch).then(() => {
+      inflight = [];
+      running = null;
+      onPersisted();
+      if (pending.length === 0) {
+        projection = null;
+        unsettled.delete(self);
+      }
+      schedule();
+    });
+  }
+
+  /** Resolves once everything written so far is on disk (or dropped). */
+  async function flush() {
+    for (;;) {
+      if (running) {
+        await running;
+        continue;
+      }
+      if (pending.length === 0) return;
+      clearTimer();
+      drain();
+    }
+  }
+
+  /** Exit path: persist inflight + pending ops synchronously (bounded lock wait). */
+  function flushSync() {
+    const ops = [...inflight, ...pending];
+    if (!file || ops.length === 0) return true;
+    clearTimer();
+    pending = [];
+    try {
+      updateJsonAtomicSync(
+        file,
+        (cur) =>
+          rewrite(cur, (...args) => {
+            for (const set of ops) replayOps(set, args);
+          }),
+        { lock: true, timeoutMs: EXIT_LOCK_TIMEOUT_MS }
+      );
+    } catch {
+      pending = ops;
+      return false;
+    }
+    inflight = [];
+    projection = null;
+    unsettled.delete(self);
+    onPersisted();
+    return true;
+  }
+
+  return {
+    /** Run `mutator` now against the projection; persist its effect later.
+     *  Returns the projected document, or null (no file / mutator threw). */
+    write(mutator) {
+      if (!file || typeof mutator !== 'function') return null;
+      try {
+        let ops = null;
+        const next = rewrite(projection ?? readDoc(), (...args) => {
+          ops = recordOps(args, () => mutator(...args));
+        });
+        projection = next;
+        version += 1;
+        pending.push(ops);
+        unsettled.add(self);
+        schedule();
+        return next;
+      } catch {
+        return null;
+      }
+    },
+    /** Document including unpersisted writes, or null when disk is current. */
+    projection: () => projection,
+    version: () => version,
+    hasUnpersisted: () => projection !== null,
+    flush,
+    flushSync,
+  };
+}
+
+/** Synchronous variant (exit paths, tests that read the file directly). */
+export function flushAllIndexWritesSync() {
+  for (const queue of [...unsettled]) queue.flushSync();
+}
+
+/** Resolves once every queue in this process has persisted what it holds. */
+export async function flushAllIndexWrites() {
+  while (unsettled.size > 0) await Promise.all([...unsettled].map((queue) => queue.flush()));
+}

package/src/{standalone → session-runtime/services}/agent-tool/job-task-reconcile.mjs

@@ -19,9 +19,9 @@
 // Every call is idempotent (the first terminal state wins, so the outer reject
 // path cannot double-notify) and absorbs its own errors, so reporting on a
 // turn can never break the turn.
-import { reconcileBackgroundTask } from '../../runtime/shared/background-tasks.mjs';
+import { reconcileBackgroundTask } from '../../../runtime/shared/background-tasks.mjs';
 
-export function reconcileJobTerminalResult(job, value) {
+function reconcileJobTerminalResult(job, value) {
   if (!job?.taskId) return;
   try {
     reconcileBackgroundTask(

package/src/{standalone → session-runtime/services}/agent-tool/job-views/job-lookup.mjs

@@ -3,7 +3,11 @@
 // against the background-task registry, then — because background tasks are
 // process-memory only while a worker SESSION can outlive its spawn task (task
 // pruned, engine restarted) — a synthetic job built from the worker session.
-import { getBackgroundTask, listBackgroundTasks, taskIdFromArgs } from '../../../runtime/shared/background-tasks.mjs';
+import {
+  getBackgroundTask,
+  listBackgroundTasks,
+  taskIdFromArgs,
+} from '../../../../runtime/shared/background-tasks.mjs';
 import { clean } from '../helpers.mjs';
 
 /** The worker's readable result: its last non-empty assistant message, else

package/src/{standalone → session-runtime/services}/agent-tool/job-views/job-render.mjs

@@ -2,7 +2,7 @@
 // Shaping jobs for callers: the job list rows and the single-job status card,
 // each pairing the task's own fields with either live worker progress or the
 // frozen terminal view.
-import { listBackgroundTasks } from '../../../runtime/shared/background-tasks.mjs';
+import { listBackgroundTasks } from '../../../../runtime/shared/background-tasks.mjs';
 import { positiveInt, terminalPidForContext } from '../helpers.mjs';
 import { isTerminalJobStatus, terminalJobFrozenFields } from './session-progress.mjs';
 

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

@@ -0,0 +1,101 @@
+// job-views/session-progress.mjs
+// Live progress of a worker session (stage, silence, watchdog, queued
+// follow-ups) and the frozen fields a finished job reports instead.
+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';
+
+// Job statuses that can never progress again (mirrors TERMINAL_STATUSES in
+// runtime/shared/background-tasks.mjs; 'canceled' accepted defensively).
+const TERMINAL_JOB_STATUSES = new Set(['completed', 'failed', 'cancelled', 'canceled']);
+
+export function isTerminalJobStatus(status) {
+  return TERMINAL_JOB_STATUSES.has(
+    String(status ?? '')
+      .trim()
+      .toLowerCase()
+  );
+}
+
+// A finished job is frozen history. Tags are reused, so its meta.sessionId can
+// point at a session that is NOW running a *different* job; reading live
+// progress for it made every old completed row inherit the current worker's
+// stage ("20 completed rows all reporting streaming/model active"). Terminal
+// rows therefore report only their own recorded status: no live worker
+// snapshot, no silent_for/watchdog/queued_followups.
+export function terminalJobFrozenFields(status, now = Date.now()) {
+  const stage =
+    String(status ?? '')
+      .trim()
+      .toLowerCase() || 'unknown';
+  return {
+    workerStatus: stage,
+    stage,
+    clientHostPid: null,
+    lastStreamDeltaAt: null,
+    ...buildAgentTaskProgressFields({ now, runtimeStage: stage, taskStatus: stage }),
+  };
+}
+
+/** A worker/job row as the published session state carries it. That state
+ *  (statusline, desktop, phone, live-share viewers) re-reads agent status on a
+ *  2s pulse, and these fields are the agent card's diagnostics, derived from
+ *  the read time or the last stream delta: they changed on every read while
+ *  nothing a surface shows did, so each pulse re-sent both row lists. Surfaces
+ *  derive elapsed time from startedAt/turnStartedAt; the agent card still reads
+ *  the diagnostics through renderJob/list directly. */
+export function liveAgentStatusRow(row) {
+  if (!row || typeof row !== 'object') return row;
+  const {
+    silent_for: _silentFor,
+    staleSeconds: _staleSeconds,
+    lastStreamDeltaAt: _lastStreamDeltaAt,
+    last_progress: _lastProgress,
+    diagnostic: _diagnostic,
+    ...stable
+  } = row;
+  return stable;
+}
+
+export function createSessionProgress({ mgr }) {
+  function sessionProgressExtras(sessionId, role, now = Date.now(), taskStatus = null) {
+    if (!sessionId) return {};
+    const session = mgr.getSession(sessionId);
+    const runtime = mgr.getSessionRuntime?.(sessionId) || null;
+    const snapshot =
+      typeof mgr.getSessionProgressSnapshot === 'function' ? mgr.getSessionProgressSnapshot(sessionId) : null;
+    const policy = role ? resolveAgentWatchdogPolicy(role) : null;
+    const queuedFollowups =
+      typeof mgr.getSessionPendingMessageDepth === 'function' ? mgr.getSessionPendingMessageDepth(sessionId) : null;
+    return buildAgentTaskProgressFields({
+      now,
+      sessionStatus: session?.status || null,
+      runtimeStage: runtime?.stage || snapshot?.stage || session?.status || null,
+      snapshot,
+      runtime,
+      policy,
+      watchdogState: getProgressWatchdogState(mgr, sessionId),
+      queuedFollowups,
+      taskStatus,
+      lastToolCall: runtime?.lastToolCall || null,
+    });
+  }
+
+  function jobWorkerSnapshot(sessionId) {
+    if (!sessionId) return null;
+    const session = mgr.getSession(sessionId);
+    if (!session) return null;
+    const runtime = mgr.getSessionRuntime?.(sessionId);
+    const status = session.closed === true ? 'closed' : session.status || 'idle';
+    const progress = sessionProgressExtras(sessionId, session.agent || null);
+    return {
+      workerStatus: status,
+      stage: progress.worker_stage || runtime?.stage || status,
+      clientHostPid: session.clientHostPid || null,
+      lastStreamDeltaAt: runtime?.lastStreamDeltaAt ? new Date(runtime.lastStreamDeltaAt).toISOString() : null,
+      ...progress,
+    };
+  }
+
+  return { sessionProgressExtras, jobWorkerSnapshot };
+}

package/src/{standalone → session-runtime/services}/agent-tool/job-views/spawn-meta.mjs

@@ -1,7 +1,7 @@
 // job-views/spawn-meta.mjs
 // The task meta a spawn carries: from a prepared spawn, from raw args while
 // the spawn is still pending, and merging later updates into a job.
-import { sanitizeTaskMeta } from '../../../runtime/shared/background-tasks.mjs';
+import { sanitizeTaskMeta } from '../../../../runtime/shared/background-tasks.mjs';
 import { clean, normalizeAgentName, presetKey } from '../helpers.mjs';
 import { resolveAgentSpawnPreset } from '../spawn-preset.mjs';
 

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

@@ -0,0 +1,59 @@
+// Job/session view layer: pure readers over the tag registry + job stores. The
+// views live under ./job-views/:
+//   session-progress — live worker progress and the frozen terminal fields
+//   agent-list       — the /agents list projection
+//   job-lookup       — read/status resolution, with the worker-session fallback
+//   job-render       — job list rows and the single-job status card
+//   spawn-meta       — task meta for prepared / pending spawns and meta merges
+import { ACTIVE_STAGES } from './tool-def.mjs';
+import { createProviderInit } from './provider-init.mjs';
+import { createAgentList } from './job-views/agent-list.mjs';
+import { createJobLookup } from './job-views/job-lookup.mjs';
+import { createJobRender } from './job-views/job-render.mjs';
+import { createSessionProgress } from './job-views/session-progress.mjs';
+import { mergeJobMeta, pendingSpawnMeta, preparedSpawnMeta } from './job-views/spawn-meta.mjs';
+
+export function createJobViews({
+  mgr,
+  getLiveSession,
+  reg,
+  DEFAULT_SPAWN_PREP_TIMEOUT_MS,
+  refreshTagsFromSessions,
+  agentSessionEntries,
+  tags,
+  cfgMod,
+}) {
+  function isSessionBusy(sessionId) {
+    const runtime = mgr.getSessionRuntime?.(sessionId);
+    if (runtime?.controller?.signal && !runtime.controller.signal.aborted) return true;
+    if (runtime?.stage) return ACTIVE_STAGES.has(runtime.stage);
+    const session = getLiveSession(sessionId);
+    return ACTIVE_STAGES.has(session?.status || '');
+  }
+
+  // Provider init de-dup lives in ./agent-tool/provider-init.mjs; the factory
+  // keeps its per-provider chain/ready state private per agent instance. The
+  // chain-gate defaults to the spawn-prep cap (see provider-init.mjs comments).
+  const { ensureProvider } = createProviderInit(reg, DEFAULT_SPAWN_PREP_TIMEOUT_MS);
+
+  const progress = createSessionProgress({ mgr });
+  const list = createAgentList({ mgr, refreshTagsFromSessions, agentSessionEntries, progress });
+  const lookup = createJobLookup({ mgr, tags, refreshTagsFromSessions });
+  const render = createJobRender({ progress });
+
+  return {
+    isSessionBusy,
+    ensureProvider,
+    list,
+    sessionProgressExtras: progress.sessionProgressExtras,
+    jobWorkerSnapshot: progress.jobWorkerSnapshot,
+    listJobs: render.listJobs,
+    getJob: lookup.getJob,
+    workerFallbackJob: lookup.workerFallbackJob,
+    getJobOrWorker: lookup.getJobOrWorker,
+    renderJob: render.renderJob,
+    preparedSpawnMeta,
+    pendingSpawnMeta: (args = {}, extras = {}) => pendingSpawnMeta(cfgMod, args, extras),
+    mergeJobMeta,
+  };
+}

package/src/session-runtime/services/agent-tool/lead-worker-index/index-file.mjs

@@ -0,0 +1,48 @@
+// The Lead pool index file: read the normalized rows, or rewrite them through
+// the single in-process writer queue (index-write-queue.mjs) keyed by worker row.
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { createIndexWriteQueue } from '../index-write-queue.mjs';
+import { workerRowKey } from '../worker-rows.mjs';
+import { LEAD_WORKER_INDEX_FILE } from '../tool-def.mjs';
+import { normalizeLeadRows } from './lead-rows.mjs';
+
+function rewriteLeadDocument(current, mutator) {
+  const byKey = new Map();
+  for (const row of normalizeLeadRows(current)) byKey.set(workerRowKey(row), row);
+  mutator(byKey);
+  const workers = {};
+  for (const row of byKey.values()) workers[workerRowKey(row)] = row;
+  return { version: 1, updatedAt: new Date().toISOString(), workers };
+}
+
+function readDocument(file) {
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function createLeadIndexFile({ dataDir }) {
+  const path = () => (dataDir ? resolve(dataDir, LEAD_WORKER_INDEX_FILE) : null);
+  const file = path();
+  const queue = createIndexWriteQueue({
+    file,
+    rewrite: rewriteLeadDocument,
+    readDoc: () => readDocument(file),
+  });
+
+  // Reads see this process's own unpersisted writes.
+  function read() {
+    if (!file) return [];
+    const doc = queue.projection();
+    if (doc) return normalizeLeadRows(doc);
+    const parsed = readDocument(file);
+    return parsed ? normalizeLeadRows(parsed) : [];
+  }
+
+  const write = (mutator) => queue.write(mutator);
+
+  return { path, read, write, flush: queue.flush, flushSync: queue.flushSync };
+}

package/src/{standalone → session-runtime/services}/agent-tool/lead-worker-index/row-settlement.mjs

@@ -33,8 +33,8 @@ export function createRowSettlement({ dataDir, cfgMod }) {
     return !(updated > 0 && now - updated <= LEAD_POOL_FRESH_MS);
   }
 
-  /** Settle one active row. `touch` marks a turn that ended HERE (fresh idle
-   *  stamps + reap window); recovery leaves the dead runtime's stamps alone so
-   *  ordering and an already scheduled reap keep their original moment. */
+  // idleLeadRow(row, now, touch): `touch` marks a turn that ended HERE (fresh
+  // idle stamps + reap window); recovery leaves the dead runtime's stamps alone
+  // so ordering and an already scheduled reap keep their original moment.
   return { staleActiveLeadRow, idleLeadRow: idleRow };
 }

package/src/{standalone → session-runtime/services}/agent-tool/lead-worker-index.mjs

@@ -8,7 +8,7 @@
 // a growing elapsed for a session that stopped (user report). Flush on exit,
 // and recover what an exit could not write on the next construction
 // (registerExitFlush / runtimeAlive live in helpers.mjs).
-import { resolveAgentTerminalReapMs } from '../../session-runtime/config-helpers.mjs';
+import { resolveAgentTerminalReapMs } from '../../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { clean, registerExitFlush } from './helpers.mjs';
 import { leadPoolTag, workerRowKey } from './worker-rows.mjs';
 import { ACTIVE_LEAD_STATUS, isActiveLeadRow } from './lead-worker-index/lead-rows.mjs';
@@ -96,6 +96,8 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
     const stale = rows.filter((row) => settlement.staleActiveLeadRow(row, now));
     const recovered = new Map();
     if (stale.length) {
+      // The write mutator runs synchronously against this process's view of
+      // the index, so `recovered` is complete when write() returns.
       index.write((byKey) => {
         recovered.clear();
         for (const row of stale) {
@@ -115,11 +117,17 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
   }
 
   recoverStaleLeadRows();
-  registerExitFlush(flushActiveLeadRows);
+  registerExitFlush(() => {
+    flushActiveLeadRows();
+    // Writes are persisted by an async queue; the loop is gone at exit.
+    index.flushSync();
+  });
 
   return {
     leadWorkerIndexPath: index.path,
     readLeadWorkerRows: index.read,
+    /** Resolves once every queued Lead index write is on disk. */
+    flushLeadWorkerIndexWrites: index.flush,
     upsertLeadSession,
     removeLeadWorkerRow,
     flushActiveLeadRows,

package/src/{standalone → session-runtime/services}/agent-tool/notify/early-completion.mjs

@@ -2,8 +2,8 @@
 // transition a Lead sees before the worker's session is persisted. The
 // body-carrying delivery stays with the canonical notifyTaskCompletion; owner
 // delivery itself is injected as `notifyOwner` from ../notify.mjs.
-import { toolCompletionInstruction } from '../../../runtime/shared/tool-execution-contract.mjs';
-import { renderBackgroundTask, sanitizeTaskMeta } from '../../../runtime/shared/background-tasks.mjs';
+import { toolCompletionInstruction } from '../../../../runtime/shared/tool-execution-contract.mjs';
+import { renderBackgroundTask, sanitizeTaskMeta } from '../../../../runtime/shared/background-tasks.mjs';
 import { clean } from '../helpers.mjs';
 
 export function createEarlyCompletionNotice({ notifyOwner }) {

package/src/{standalone → session-runtime/services}/agent-tool/notify.mjs

@@ -1,11 +1,11 @@
 // Owner/worker completion-notification helpers, a factory so the mgr-bound
 // closures stay per agent instance; deps are injected.
-import { modelVisibleToolCompletionMessage } from '../../runtime/shared/tool-execution-contract.mjs';
-import { markCompletionEntry } from '../../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
+import { modelVisibleToolCompletionMessage } from '../../../runtime/shared/tool-execution-contract.mjs';
+import { markCompletionEntry } from '../../../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
 import {
   isDeliveredCompletion,
   logDuplicateSkip,
-} from '../../runtime/agent/orchestrator/session/manager/delivered-completions.mjs';
+} from '../../../runtime/agent/orchestrator/session/manager/delivered-completions.mjs';
 import { clean } from './helpers.mjs';
 import { createEarlyCompletionNotice } from './notify/early-completion.mjs';
 
@@ -59,7 +59,7 @@ export function createNotify(mgr, { notifySessionCompletion } = {}) {
     }
   }
 
-  function workerNotifyFn(workerSessionId, _notifyContext = {}) {
+  function workerNotifyFn(workerSessionId) {
     const workerId = clean(workerSessionId);
     return (text, meta = {}) => {
       // Tool completions produced inside a Subagent belong to that Subagent's

package/src/{standalone → session-runtime/services}/agent-tool/render.mjs

@@ -1,5 +1,5 @@
 // Pure result-rendering and finish-classification helpers.
-import { oneLine } from '../../runtime/shared/clean.mjs';
+import { oneLine } from '../../../runtime/shared/clean.mjs';
 import { compactIso, elapsedFromStamps, stripFinalAnswerWrapper } from './helpers.mjs';
 
 // A worker that gets truncated mid-synthesis or produces an empty terminal
@@ -77,7 +77,7 @@ function taskDiagnosticLines(value) {
   if (value.diagnostic) lines.push(`diagnostic: ${value.diagnostic}`);
   if (value.startedAt) lines.push(`started: ${compactIso(value.startedAt)}`);
   if (value.finishedAt) lines.push(`finished: ${compactIso(value.finishedAt)}`);
-  const elapsed = elapsedFromStamps(value.startedAt, value.finishedAt, value.status);
+  const elapsed = elapsedFromStamps(value.startedAt, value.finishedAt);
   if (elapsed) lines.push(`elapsed: ${elapsed}`);
   return lines;
 }