mixdog 1.3.5 → 1.4.1

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

@@ -1,9 +1,10 @@
 // One-off model selection for a spawn the user explicitly pinned to a model.
 // The agent's preset route stays the default; this only runs when `model` is
-// passed. The query is matched against the live provider catalog — exact id,
-// then exact display name, then every query word — and a catalog miss retries
-// once on a refreshed catalog. One match runs; several or none fail with
-// candidates instead of substituting another model.
+// passed. The query is matched against the quick/cached provider catalog —
+// literal id, then normalized id, then exact display name, then every query
+// word — and a catalog miss retries once on a catalog refreshed for the
+// requested provider (concurrent misses share that refresh). One match runs;
+// several or none fail with candidates instead of substituting another model.
 import { clean } from './helpers.mjs';
 
 const CANDIDATE_LIMIT = 8;
@@ -20,7 +21,7 @@ const terms = (value) =>
     .filter(Boolean);
 const label = (row) => `${row.provider}/${row.id}`;
 
-function providerRows(rows, provider) {
+export function providerRows(rows, provider) {
   if (!provider) return rows;
   const wanted = norm(provider);
   const exact = rows.filter((row) => norm(row.provider) === wanted);
@@ -33,6 +34,8 @@ function matchModels(rows, query) {
   // Nothing to match on ("???"): `[].every` would accept every row.
   if (!words.length) return [];
   const tiers = [
+    // A literal id wins over its normalized look-alikes (`foo-bar` vs `foo_bar`).
+    (row) => row.id === query,
     (row) => norm(row.id) === wanted,
     (row) => norm(row.display) === wanted,
     (row) => words.every((word) => `${norm(row.id)} ${norm(row.display)}`.includes(word)),
@@ -49,6 +52,34 @@ function candidates(rows) {
   return rows.length > CANDIDATE_LIMIT ? `${shown}, … (${rows.length} total)` : shown;
 }
 
+// A quick read answered from the loaded catalog marks every row complete.
+// Otherwise a hit stands only when it is a literal id of the exact provider the
+// caller named, which the full catalog would pick the same way.
+function quickAnswerHolds(rows, hits, model, provider) {
+  if (rows.length > 0 && rows.every((row) => row.catalogComplete === true)) return true;
+  const wanted = norm(provider);
+  return hits.length > 0 && wanted !== '' && hits.every((row) => row.id === model && norm(row.provider) === wanted);
+}
+
+// The forced refresh in flight per catalog reader and provider scope: concurrent
+// misses share it instead of each refreshing.
+const refreshing = new WeakMap();
+
+// One forced refresh, scoped to the requested provider when one is given.
+function refreshedRows(listProviderModels, provider) {
+  if (!refreshing.has(listProviderModels)) refreshing.set(listProviderModels, new Map());
+  const inflight = refreshing.get(listProviderModels);
+  const scope = norm(provider);
+  if (!inflight.has(scope)) {
+    const request = listProviderModels({ force: true, ...(provider ? { provider } : {}) });
+    inflight.set(
+      scope,
+      request.finally(() => inflight.delete(scope))
+    );
+  }
+  return inflight.get(scope);
+}
+
 /** Resolve args.provider/args.model to one exact catalog route. Without a
  *  catalog (headless/daemon surfaces) exact provider + model pass through. */
 export async function resolveRequestedModel(args, listProviderModels) {
@@ -64,10 +95,20 @@ export async function resolveRequestedModel(args, listProviderModels) {
     if (!terms(model).length) throw new Error(`agent spawn: model "${model}" for provider "${provider}" not found`);
     return args;
   }
-  let pool = providerRows(await listProviderModels(), provider);
+  // The quick/cached catalog answers first. A loaded catalog is final, so its
+  // hit never waits on a provider; an incomplete one (cold or partial) may
+  // lack the model that wins, or one that makes the name ambiguous, so only a
+  // literal id inside an exact, explicitly named provider is taken from it.
+  // Anything else waits for the full catalog.
+  const quickRows = await listProviderModels({ quick: true });
+  let pool = providerRows(quickRows, provider);
   let hits = matchModels(pool, model);
+  if (!quickAnswerHolds(quickRows, hits, model, provider)) {
+    pool = providerRows(await listProviderModels(), provider);
+    hits = matchModels(pool, model);
+  }
   if (!hits.length) {
-    pool = providerRows(await listProviderModels({ force: true }), provider);
+    pool = providerRows(await refreshedRows(listProviderModels, provider), provider);
     hits = matchModels(pool, model);
   }
   if (hits.length === 1) return { ...args, provider: hits[0].provider, model: hits[0].id };

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

@@ -1,5 +1,7 @@
 // Pure result-rendering and finish-classification helpers.
 import { oneLine } from '../../../runtime/shared/clean.mjs';
+import { isActiveWorkerRow } from './job-views/agent-list.mjs';
+import { isTerminalJobStatus } from './job-views/session-progress.mjs';
 import { compactIso, elapsedFromStamps, stripFinalAnswerWrapper } from './helpers.mjs';
 
 // A worker that gets truncated mid-synthesis or produces an empty terminal
@@ -32,25 +34,77 @@ export function abnormalEmptyFinishError(result, agent) {
   }
 }
 
-// The /agents roster: worker rows then task rows.
-function renderRoster(value) {
+const ROSTER_TAIL = 5;
+const ROSTER_MATCH_CAP = 25;
+
+function workerLine(worker) {
+  const status = worker.status || 'idle';
+  const stage = worker.worker_stage || worker.stage;
+  const progress = oneLine(worker.last_progress);
+  const summary = progress.length > 60 ? `${progress.slice(0, 59)}…` : progress;
+  return `- ${worker.tag}  ${status}${stage && stage !== status ? `/${stage}` : ''}${summary ? `  ${summary}` : ''}`;
+}
+
+function jobLine(job) {
+  const error = job.status === 'failed' ? oneLine(job.error) : '';
+  return `- ${job.task_id}  ${job.type}  ${job.status}  ${job.tag || '-'}${error ? ` error=${error}` : ''}`;
+}
+
+const stamp = (row) => String(row.updatedAt || row.lastUsedAt || row.finishedAt || row.startedAt || '');
+
+// Inactive rows: newest first (stable for rows without stamps).
+const newestFirst = (rows) => rows.slice().sort((a, b) => stamp(b).localeCompare(stamp(a)));
+
+// Inactive rows collapse to a count plus a short tail. A `tag` filter lists the
+// matching inactive rows (bounded) so a specific one can still be found.
+function inactiveSection(label, rows, render, tagOf, filter) {
+  if (rows.length === 0) return [];
+  const needle = filter.toLowerCase();
+  const matched = needle
+    ? rows.filter((row) =>
+        String(tagOf(row) ?? '')
+          .toLowerCase()
+          .includes(needle)
+      )
+    : null;
+  const shown = newestFirst(matched ?? rows).slice(0, matched ? ROSTER_MATCH_CAP : ROSTER_TAIL);
+  const shownFilter = filter.replace(/\s+/g, ' ');
+  const head = matched
+    ? `${label}: ${rows.length} (${matched.length} match tag "${shownFilter}", showing ${shown.length})`
+    : `${label}: ${rows.length} (latest ${shown.length}; pass tag=<text> to find one)`;
+  // Bulleted: a non-bullet line would make the list read as an authored response.
+  return [`- ${head}`, ...shown.map(render)];
+}
+
+// The /agents roster: active workers and running tasks in full; idle/closed
+// workers and finished tasks as counts with a bounded tail.
+function renderRoster(value, filter = '') {
   const workers = Array.isArray(value.workers) ? value.workers : [];
   const jobs = Array.isArray(value.jobs) ? value.jobs : [];
   const lines = [`agents: ${workers.length} · tasks: ${jobs.length}`];
+  const isActive = (worker) => Boolean(worker.awaitingUser) || isActiveWorkerRow(worker);
+  const isRunning = (job) => !isTerminalJobStatus(job.status);
   // Keep list bullets: agent cards distinguish these rows from authored responses.
-  for (const worker of workers) {
-    const status = worker.status || 'idle';
-    const stage = worker.worker_stage || worker.stage;
-    const progress = oneLine(worker.last_progress);
-    const summary = progress.length > 60 ? `${progress.slice(0, 59)}…` : progress;
-    lines.push(
-      `- ${worker.tag}  ${status}${stage && stage !== status ? `/${stage}` : ''}${summary ? `  ${summary}` : ''}`
-    );
-  }
-  for (const job of jobs) {
-    const error = job.status === 'failed' ? oneLine(job.error) : '';
-    lines.push(`- ${job.task_id}  ${job.type}  ${job.status}  ${job.tag || '-'}${error ? ` error=${error}` : ''}`);
-  }
+  lines.push(...workers.filter(isActive).map(workerLine));
+  lines.push(...jobs.filter(isRunning).map(jobLine));
+  lines.push(
+    ...inactiveSection(
+      'idle/closed agents',
+      workers.filter((w) => !isActive(w)),
+      workerLine,
+      (w) => w.tag,
+      filter
+    )
+  );
+  lines.push(
+    ...inactiveSection(
+      'finished tasks',
+      jobs.filter((j) => !isRunning(j)),
+      jobLine,
+      (j) => j.tag || j.task_id,
+      filter
+    )
+  );
   if (workers.length === 0 && jobs.length === 0) lines.push('(no agents or tasks)');
   return lines.join('\n');
 }
@@ -151,11 +205,11 @@ function renderContent(value) {
   return `${header}\n${stripFinalAnswerWrapper(value.content)}`;
 }
 
-export function renderResult(value, { includeDiagnostics = false } = {}) {
+export function renderResult(value, { includeDiagnostics = false, listFilter = '' } = {}) {
   if (value === undefined || value === null) return '';
   if (typeof value === 'string') return value;
   if (value && typeof value === 'object') {
-    if (Array.isArray(value.workers) || Array.isArray(value.jobs)) return renderRoster(value);
+    if (Array.isArray(value.workers) || Array.isArray(value.jobs)) return renderRoster(value, listFilter);
     // close-flow results carry `closed` plus task_id: render the close outcome.
     // close-flow results carry `closed` plus task_id: render the close outcome.
     if (value.closed !== undefined) return renderClosed(value);

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

@@ -1,4 +1,5 @@
 import { configuredAgentRouteCandidates } from '../../../runtime/shared/agent-route-config.mjs';
+import { executionFallbacks } from '../../../runtime/shared/model-route-chain.mjs';
 import {
   agentPresetName,
   clean,
@@ -29,8 +30,14 @@ export function resolveAgentSpawnPreset(config, args = {}) {
   const agentName = normalizeAgentName(args.agent);
   // The agent's stored route: config.agents, or a store bot's own folder.
   const candidates = !clean(args.preset) ? configuredAgentRouteCandidates(config, agentName) : [];
-  const agentRoute = candidates.map((candidate) => normalizeAgentRoute(candidate)).find(Boolean) || null;
-  const storedFallbacks = candidates.find((candidate) => normalizeAgentRoute(candidate))?.fallbacks;
+  const storedCandidate = candidates.find((candidate) => normalizeAgentRoute(candidate));
+  const agentRoute = storedCandidate ? normalizeAgentRoute(storedCandidate) : null;
+  const storedFallbacks = agentRoute
+    ? executionFallbacks({ ...agentRoute, fallbacks: storedCandidate.fallbacks })
+    : undefined;
+  // Where the spawned session reads its fallback chain at each hop
+  // (route-fallback-chain.mjs): this agent's route, else Main's.
+  const fallbackSource = { agent: agentName };
   if (agentRoute) {
     return {
       presetName: agentPresetName(agentName),
@@ -41,6 +48,7 @@ export function resolveAgentSpawnPreset(config, args = {}) {
         provider: agentRoute.provider,
         model: agentRoute.model,
         ...(storedFallbacks?.length ? { fallbacks: storedFallbacks.map(normalizeAgentRoute) } : {}),
+        fallbackSource,
         effort: agentRoute.effort,
         fast: agentRoute.fast === true,
         ...(agentRoute.autoEffort === false ? { autoEffort: false } : {}),
@@ -54,12 +62,13 @@ export function resolveAgentSpawnPreset(config, args = {}) {
 
   const mainPreset = !clean(args.preset) ? findPreset(config, config?.default) : null;
   if (normalizeAgentRoute(mainPreset)) {
-    return { presetName: mainPreset.id || mainPreset.name, preset: mainPreset };
+    return { presetName: mainPreset.id || mainPreset.name, preset: { ...mainPreset, fallbackSource } };
   }
 
   const presetName = clean(args.preset);
   if (!presetName) throw new Error(`agent: agent "${agentName}" has no Main model assignment`);
-  const preset = findPreset(config, presetName) || synthesizePreset(config, presetName);
+  const stored = findPreset(config, presetName);
+  const preset = stored ? { ...stored, fallbackSource: { preset: presetName } } : synthesizePreset(config, presetName);
   if (!preset) throw new Error(`agent: preset "${presetName}" not found`);
   if (!normalizeAgentRoute(preset)) throw new Error(`agent: preset "${presetName}" has no complete route`);
   return { presetName, preset };

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

@@ -121,6 +121,7 @@ export function createTagRegistry({ dataDir, cfgMod, mgr }) {
     updateLeadWorkerCwd,
     forgetLeadSession,
     removeWorkerRow,
+    markReleased: index.markReleased,
     refreshTagsFromIndex,
     tags,
     tagAgents: tagMaps.tagAgents,

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

@@ -28,7 +28,7 @@ export const AGENT_TOOL = {
     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. Close finished agents yourself.',
+    '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. Completion notifications arrive automatically; use status/read only for manual recovery. Close finished agents yourself.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -36,21 +36,21 @@ export const AGENT_TOOL = {
         type: 'string',
         enum: ['spawn', 'send', 'list', 'close', 'cancel', 'status', 'read', 'cleanup'],
         description:
-          'Required action. New spawn requires agent and one of prompt/message/file; send requires tag and one of prompt/message/file; read/status/close/cancel require task_id or tag; list/cleanup require no target.',
+          'Required action. New spawn requires agent and one of prompt/message/file; send requires tag and one of prompt/message/file; read/status/close/cancel require task_id or tag; list/cleanup require no target. list shows active agents and running tasks in full; idle/closed agents and finished tasks are counts plus a short latest tail (list with tag=<text> shows matching ones: case-insensitive substring, at most 25 per section).',
       },
-      task_id: { type: 'string', description: 'Task ID returned by spawn/send; target for read/status/close/cancel.' },
+      task_id: { type: 'string', description: 'Task ID returned by spawn/send.' },
       agent: {
         type: 'string',
-        description: 'Workflow agent id. Required for a new spawn; same-tag reuse can inherit it.',
+        description: 'Workflow agent id; same-tag reuse can inherit it.',
       },
       tag: {
         type: 'string',
         description:
-          'Stable scope handle. Reuse the same tag for the same scope; never derive a variant by appending a number or suffix. send requires it, while spawn can generate one when omitted.',
+          'Stable scope handle; never derive a variant by appending a number or suffix. spawn generates one when omitted.',
       },
-      prompt: { type: 'string', description: 'Spawn task brief; also accepted for send.' },
-      message: { type: 'string', description: 'Send follow-up; also accepted for spawn.' },
-      file: { type: 'string', description: 'Path to task text; alternative to prompt/message for spawn/send.' },
+      prompt: { type: 'string', description: 'Spawn task brief.' },
+      message: { type: 'string', description: 'Send follow-up.' },
+      file: { type: 'string', description: 'Path to task text; used instead of prompt/message.' },
       cwd: { type: 'string', description: 'Project directory for a new or respawned agent.' },
       context: { type: 'string', description: 'Extra context for the spawn/send turn.' },
       attachments: {
@@ -63,7 +63,7 @@ export const AGENT_TOOL = {
       model: {
         type: 'string',
         description:
-          "Spawn only, and only when the user explicitly names a model: runs this one spawn on it instead of the agent's preset route, which stays the default (omit otherwise). Id, display name, or words of it; ambiguous or unknown names fail with candidates. The agent still supplies role and permissions.",
+          "Spawn only, and only when the user explicitly names a model: runs this one spawn on it instead of the agent's preset route. Id, display name, or words of it; ambiguous or unknown names fail with candidates. The agent still supplies role and permissions.",
       },
       provider: { type: 'string', description: 'Narrows model to one provider; requires model.' },
       effort: { type: 'string', description: 'Reasoning effort for an explicit model.' },

package/src/session-runtime/services/agent-tool/worker-index/awaiting-user-sync.mjs

@@ -0,0 +1,51 @@
+// worker-index/awaiting-user-sync.mjs
+// A worker row's approval wait (`awaitingUser`), fenced to its session's turn
+// and kept in step with the runtime this process runs for that session. Owns
+// the sessions whose deferred rows still wait in the mutation batch.
+import { clean } from '../helpers.mjs';
+import { applyAwaitingUser, awaitingUserWouldChange } from './approval-wait.mjs';
+
+export function createAwaitingUserSync(store, mgr) {
+  // Sessions whose deferred rows still wait in the batch; reconciled once the
+  // batch lands in the store.
+  const unreconciled = new Set();
+
+  /** Persist (or clear) a worker's approval wait as a field update fenced to
+   *  the session and its turn (`turnAt`, ms): a row whose turn started later is
+   *  left alone. Writes only when a row of that session exists and would
+   *  change, so a Lead's own approvals cost nothing; a row that is not in the
+   *  store yet takes the wait when it lands (reconcileAwaitingUser). */
+  function setAwaitingUser(sessionId, awaitingUser, { turnAt = 0 } = {}) {
+    const fence = {
+      sessionId: clean(sessionId),
+      awaitingUser: awaitingUser === 'approval' ? 'approval' : null,
+      turnAt: Number(turnAt) || 0,
+    };
+    if (!fence.sessionId || !awaitingUserWouldChange(store.readAll(), fence)) return false;
+    store.update((byKey) => applyAwaitingUser(byKey, fence));
+    return true;
+  }
+
+  /** The runtime of a session this process runs is the authority on its
+   *  approval wait (the runtime-liveness counter behind `awaitingUser`): every
+   *  row it creates or refreshes takes that state, so a missed or stale
+   *  transition heals on the next write. No runtime here: not ours to judge. */
+  function reconcileAwaitingUser(sessionId) {
+    const runtime = mgr.getSessionRuntime?.(sessionId);
+    if (runtime) setAwaitingUser(sessionId, runtime.awaitingUser, { turnAt: runtime.askStartedAt });
+  }
+
+  /** A deferred row of `sessionId` is queued; reconciled when its batch lands. */
+  function deferReconcile(sessionId) {
+    unreconciled.add(sessionId);
+  }
+
+  /** The batch landed: reconcile every session whose deferred row it carried. */
+  function reconcileDeferred() {
+    const ids = [...unreconciled];
+    unreconciled.clear();
+    for (const id of ids) reconcileAwaitingUser(id);
+  }
+
+  return { setAwaitingUser, reconcileAwaitingUser, deferReconcile, reconcileDeferred };
+}

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

@@ -0,0 +1,55 @@
+// worker-index/disposal.mjs
+// Disposing a worker index: queued rows persist first, then `teardown`
+// releases its registrations; a failed drain leaves them for a retry. Owns
+// the disposed / in-flight dispose state.
+export function createIndexDisposal({ batch, store, teardown }) {
+  let disposed = false;
+  let disposePromise = null;
+
+  async function drainThenTeardown() {
+    batch.flush();
+    await store.flush();
+    teardown();
+  }
+
+  /** Persist queued rows, then release the exit registration. Active rows are
+   *  NOT settled: they are keyed by process pid, which every inline runtime in
+   *  the daemon shares, so settling here would idle other runtimes' workers.
+   *  When the sync flush cannot run (this process's async writer holds the
+   *  lock) the exit hook and store ref stay until the async drain settles. */
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    let flushed = false;
+    try {
+      batch.flush();
+      flushed = store.flushSync();
+    } catch {}
+    if (flushed) {
+      teardown();
+      return;
+    }
+    disposePromise = drainThenTeardown().catch(reopenAfterFailedDrain);
+  }
+
+  /** A failed drain tears nothing down; allow a later dispose to retry it. */
+  function reopenAfterFailedDrain() {
+    disposed = false;
+    disposePromise = null;
+  }
+
+  /** Awaitable dispose: drain everything, then tear down. A failed drain
+   *  rejects and leaves the registrations in place. */
+  function disposeAsync() {
+    if (!disposePromise) {
+      disposed = true;
+      disposePromise = drainThenTeardown().catch((error) => {
+        reopenAfterFailedDrain();
+        throw error;
+      });
+    }
+    return disposePromise;
+  }
+
+  return { dispose, disposeAsync };
+}

package/src/session-runtime/services/agent-tool/worker-index/released-store.mjs

@@ -0,0 +1,123 @@
+// worker-index/released-store.mjs
+// Which agent sessions their owner closed (the agent tool's `close`): session
+// id → when. A closed session stays open and resumable, so a session scan
+// (also after a daemon restart) would list it again; the marker is what keeps
+// its rows `released` until a new turn starts on it. It lives in a file of its
+// own beside the worker index, so a writer that rebuilds the index document
+// (an older daemon) can never drop it. Entries expire after the tombstone TTL,
+// judged on every read, not only when the file changes.
+import { readFileSync, statSync } from 'node:fs';
+
+import { parseJsonText } from '../../../../runtime/shared/atomic-file.mjs';
+import { createIndexWriteQueue } from '../index-write-queue.mjs';
+import { TAG_TOMBSTONE_TTL_MS } from '../worker-rows.mjs';
+
+export const RELEASED_FILE = 'agent-workers-released.json';
+
+/** id → epoch ms of every entry of a raw document (expired ones included). */
+function parseReleased(doc) {
+  const raw = doc?.released && typeof doc.released === 'object' ? doc.released : {};
+  return new Map(
+    Object.entries(raw)
+      .map(([sessionId, at]) => [sessionId, Date.parse(String(at)) || 0])
+      .filter(([sessionId]) => sessionId)
+  );
+}
+
+/** The next document: unexpired entries plus the mutator's changes. */
+function rewriteReleased(cur, mutator) {
+  const cutoff = Date.now() - TAG_TOMBSTONE_TTL_MS;
+  const entries = new Map();
+  for (const [sessionId, at] of parseReleased(cur)) {
+    if (at >= cutoff) entries.set(sessionId, new Date(at).toISOString());
+  }
+  mutator(entries);
+  return { version: 1, released: Object.fromEntries(entries) };
+}
+
+/** `file` may be null (no data dir): reads are empty and writes are no-ops. */
+export function createReleasedStore(file) {
+  let cache = null; // { mtimeMs, size, doc, at }
+  let dirty = true;
+  // Unpersisted writes are read from the queue's projection.
+  let projected = null; // { version, at }
+
+  const queue = createIndexWriteQueue({
+    file,
+    rewrite: rewriteReleased,
+    readDoc: () => {
+      dirty = true;
+      entries();
+      return cache?.doc ?? null;
+    },
+    onPersisted: () => {
+      dirty = true;
+    },
+  });
+
+  /** id → epoch ms, as written (not yet filtered by expiry). */
+  function entries() {
+    const doc = queue.projection();
+    if (doc) {
+      if (!projected || projected.version !== queue.version()) {
+        projected = { version: queue.version(), at: parseReleased(doc) };
+      }
+      return projected.at;
+    }
+    if (!file) return new Map();
+    // Only a missing file is an empty store; any other read error propagates
+    // (queue.write reports it and queues nothing; a reader sees it thrown).
+    let st;
+    try {
+      st = statSync(file);
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+      cache = null;
+      return new Map();
+    }
+    if (!dirty && cache && cache.mtimeMs === st.mtimeMs && cache.size === st.size) return cache.at;
+    let parsed = null;
+    let text = null;
+    try {
+      text = readFileSync(file, 'utf8');
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+    }
+    if (text !== null) {
+      try {
+        parsed = parseJsonText(text);
+      } catch (error) {
+        // Left on disk and reported; the next save moves it aside to
+        // `<file>.corrupt-<ts>` (atomic-file's damaged-state recovery) instead
+        // of overwriting it.
+        process.stderr.write(`[released-store] ${file} is malformed (${error.message}); markers unreadable\n`);
+      }
+    }
+    cache = { mtimeMs: st.mtimeMs, size: st.size, doc: parsed, at: parseReleased(parsed) };
+    dirty = false;
+    return cache.at;
+  }
+
+  return {
+    /** Whether the owner closed this session less than the TTL ago. */
+    isReleased: (sessionId) => entries().get(sessionId) >= Date.now() - TAG_TOMBSTONE_TTL_MS,
+    mark(sessionIds) {
+      const at = new Date().toISOString();
+      queue.write((entriesById) => {
+        for (const sessionId of sessionIds) entriesById.set(sessionId, at);
+      });
+    },
+    clear(sessionId) {
+      if (!entries().has(sessionId)) return;
+      queue.write((entriesById) => {
+        entriesById.delete(sessionId);
+      });
+    },
+    flush: queue.flush,
+    flushSync: queue.flushSync,
+    hasUnpersisted: queue.hasUnpersisted,
+    invalidate: () => {
+      dirty = true;
+    },
+  };
+}

package/src/session-runtime/services/agent-tool/worker-index/restart-settlement.mjs

@@ -0,0 +1,112 @@
+// worker-index/restart-settlement.mjs
+// Rows whose turn a process exit or restart ended: this process's active rows
+// settled as failed on exit, stale active rows and approval waits settled at
+// startup and on later sweeps, and the owner's restart-failure notification
+// stamped once queued. Owns the keys of the rows this process marked active.
+import { positiveInt } from '../helpers.mjs';
+import { workerRowKey } from '../worker-rows.mjs';
+import { clearAwaitingUser } from './approval-wait.mjs';
+import {
+  createRowLiveness,
+  isActiveWorkerRow,
+  isStaleApprovalWait,
+  isUnnotifiedRestartFailure,
+  PROCESS_RESTART_FAILURE,
+  runtimeDied,
+} from './row-liveness.mjs';
+
+export function createRestartSettlement({ store, cfgMod, mgr }) {
+  const liveness = createRowLiveness({
+    cfgMod,
+    isSessionRunning: (sessionId) => mgr.isSessionTurnInFlight?.(sessionId) === true,
+  });
+  // Rows this process marked active; settled as failed on exit (their turn
+  // dies with the process) so a crash of the host never leaves them
+  // "running" forever.
+  const activeWorkerKeys = new Set();
+
+  /** Track whether the row written under `key` is one this process runs. */
+  function trackActiveRow(key, row) {
+    if (isActiveWorkerRow(row)) activeWorkerKeys.add(key);
+    else activeWorkerKeys.delete(key);
+  }
+
+  function flushActiveWorkerRows() {
+    if (!activeWorkerKeys.size) return;
+    const keys = [...activeWorkerKeys];
+    activeWorkerKeys.clear();
+    const now = Date.now();
+    store.write((byKey) => {
+      for (const key of keys) {
+        const current = byKey.get(key);
+        if (!current || positiveInt(current.runtimePid) !== process.pid) continue;
+        if (isActiveWorkerRow(current)) {
+          byKey.set(key, liveness.failedRow(current, now, PROCESS_RESTART_FAILURE, true));
+        }
+      }
+    });
+  }
+
+  // Startup recovery: stale active rows settle — as failed when another
+  // process ran their turn (it is gone, or is the predecessor still shutting
+  // down: either way the turn never finished), otherwise to idle — and an
+  // approval wait left behind by a runtime that is gone (daemon restart) is
+  // cleared. `deadOnly` (later sweeps) settles only rows whose runtime is
+  // provably dead, never a live process's quiet turn.
+  function recoverStaleWorkerRows({ deadOnly = false } = {}) {
+    const now = Date.now();
+    const rows = store.readAll();
+    const isStale = deadOnly
+      ? (row) => isActiveWorkerRow(row) && runtimeDied(row)
+      : (row) => liveness.isStaleActive(row, now);
+    const staleActive = rows.filter(isStale);
+    const staleWaits = rows.some(isStaleApprovalWait);
+    if (!staleActive.length && !staleWaits) return false;
+    if (staleActive.length) {
+      store.write((byKey) => {
+        for (const row of staleActive) {
+          const key = workerRowKey(row);
+          const current = byKey.get(key);
+          if (!current || !isStale(current)) continue;
+          const ranElsewhere = positiveInt(current.runtimePid) && positiveInt(current.runtimePid) !== process.pid;
+          byKey.set(
+            key,
+            ranElsewhere ? liveness.failedRow(current, now, PROCESS_RESTART_FAILURE) : liveness.idleRow(current, now)
+          );
+        }
+      });
+    }
+    if (staleWaits) store.update((byKey) => clearAwaitingUser(byKey, isStaleApprovalWait));
+    return true;
+  }
+
+  /** Rows whose turn a process restart ended and whose owner has not been told
+   *  yet — whoever settled the row (this process at startup, or the
+   *  predecessor's exit flush). Read-only: the caller enqueues the owner's
+   *  notification durably, THEN calls `markRestartNotified`, so a crash in
+   *  between retries (the notification's stable id makes the retry exactly-once). */
+  function pendingRestartFailures() {
+    return store.readAll().filter(isUnnotifiedRestartFailure);
+  }
+
+  /** Stamp these rows as told, once their notification is durably queued. */
+  function markRestartNotified(rows) {
+    const stamp = new Date().toISOString();
+    store.write((byKey) => {
+      for (const row of rows) {
+        const key = workerRowKey(row);
+        const current = byKey.get(key);
+        if (!current || !isUnnotifiedRestartFailure(current)) continue;
+        byKey.set(key, { ...current, restartNotified: stamp });
+      }
+    });
+  }
+
+  return {
+    trackActiveRow,
+    flushActiveWorkerRows,
+    recoverStaleWorkerRows,
+    pendingRestartFailures,
+    markRestartNotified,
+  };
+}