mixdog 1.3.4 → 1.3.5

package/src/runtime/agent/orchestrator/session/message-reactions.mjs

@@ -0,0 +1,89 @@
+// session/message-reactions.mjs
+// A bot's emoji reaction on a message the user wrote, shown under the user's
+// bubble. It is stored on that message (`meta.transcript.reactions`, one
+// `{ agentId, emoji, at }` per bot), so it travels with the transcript: a
+// reload, a restart and every synced client read it from there. In a group
+// room the message is the user's row in the room's log, and each member's
+// reaction is kept beside the others'.
+import { sessionMessageText } from '../runtime-core/session-text.mjs';
+import { isInternalTranscriptDisplayText } from '../../../shared/tool-execution-contract.mjs';
+import { normalizeMessageReactions } from '../../../shared/transcript-metadata.mjs';
+import { isRoomRowMessage } from './agent-room.mjs';
+
+/** Whether `message` is one the user wrote: a prompt typed (or steered) into
+ *  the chat, or the user's own row in a room's log. Runtime notices, routine
+ *  fires, posted results and other bots' messages are not. */
+export function isReactableMessage(message) {
+  if (message?.role !== 'user' || !message.meta || typeof message.meta !== 'object') return false;
+  const { meta } = message;
+  const transcript = meta.transcript;
+  if (typeof transcript?.messageId !== 'string' || !transcript.messageId) return false;
+  if (isRoomRowMessage(message)) return meta.room.kind === 'user' && !meta.room.fromSession;
+  if ((meta.source && meta.source !== 'steering') || meta.synthetic === true) return false;
+  if (transcript.fromAgent || transcript.routineTrigger) return false;
+  return !isInternalTranscriptDisplayText(sessionMessageText(message.content));
+}
+
+/**
+ * Set `agentId`'s reaction (`emoji`; '' removes it) on the user message
+ * `messagesBack` user messages before the newest one in `messages`. One
+ * reaction per bot: a new one takes the place of the old. `othersKeep`: an
+ * emoji another bot already left there is refused (a group room's members do
+ * not repeat each other). Returns `{ previous, message, messageId, reactions,
+ * changed }`; `message` is a new object (the store's delta saves see a change
+ * by identity), placed by the caller. Throws when there is no such message.
+ */
+export function reactToMessage(messages, { agentId, emoji, messagesBack = 0, othersKeep = false, at = Date.now() }) {
+  const list = Array.isArray(messages) ? messages : [];
+  let seen = 0;
+  let previous = null;
+  for (let index = list.length - 1; index >= 0; index -= 1) {
+    if (!isReactableMessage(list[index])) continue;
+    if (seen === messagesBack) {
+      previous = list[index];
+      break;
+    }
+    seen += 1;
+  }
+  if (!previous) {
+    throw new Error(
+      seen ? `react: there are only ${seen} user messages to react to` : 'react: there is no user message to react to'
+    );
+  }
+  const transcript = previous.meta.transcript;
+  const current = normalizeMessageReactions(transcript.reactions);
+  const own = current.find((entry) => entry.agentId === agentId);
+  if (emoji && othersKeep) {
+    const taken = current.find((entry) => entry.agentId !== agentId && entry.emoji === emoji);
+    if (taken) throw new Error(`react: ${taken.agentId} already left ${emoji} on that message`);
+  }
+  const messageId = transcript.messageId;
+  if (own?.emoji === emoji || (!own && !emoji)) {
+    return { previous, message: previous, messageId, reactions: current, changed: false };
+  }
+  const entry = { agentId, emoji, at };
+  let reactions;
+  if (!emoji) reactions = current.filter((each) => each.agentId !== agentId);
+  else if (own) reactions = current.map((each) => (each.agentId === agentId ? entry : each));
+  else reactions = [...current, entry];
+  const { reactions: _old, ...rest } = transcript;
+  const message = {
+    ...previous,
+    meta: { ...previous.meta, transcript: reactions.length ? { ...rest, reactions } : rest },
+  };
+  return { previous, message, messageId, reactions, changed: true };
+}
+
+/** reactToMessage on a stored session: the running turn's working transcript
+ *  when a turn is in flight (its end commits that transcript), and the
+ *  session's own message list, both holding the replaced message. */
+export function reactInSession(session, change) {
+  const working = Array.isArray(session?.liveTurnMessages) ? session.liveTurnMessages : null;
+  const result = reactToMessage(working || session?.messages, change);
+  if (!result.changed) return result;
+  for (const list of [working, session.messages]) {
+    const index = Array.isArray(list) ? list.indexOf(result.previous) : -1;
+    if (index >= 0) list[index] = result.message;
+  }
+  return result;
+}

package/src/runtime/agent/orchestrator/session/message-reactions.test-support.mjs

@@ -0,0 +1,75 @@
+// A real agent-loop turn in a bot's home chat whose model first calls `react`
+// with `args`, then answers with empty text (and, if nudged, with 'Sure.').
+// The react call runs through the real tool batch and the real react handler,
+// so its tool result is the one a live turn would see.
+import { agentLoop } from './agent-loop.mjs';
+import { setInternalToolsProvider } from '../internal-tools.mjs';
+import { REACTION_TOOL_DEFS } from '../runtime-core/reaction-tool-defs.mjs';
+import { createReactionToolHandlers } from '../../../../session-runtime/internal-tool-executor/reaction-tool.mjs';
+
+let scopeSeq = 0;
+
+// `reply`: the text the model answers with after reacting (default none).
+// `nextPrompt`: a second user turn run afterwards in the same session, whose
+// model answers 'Next.' — the provider prefix guard carries across both.
+export async function runReactionTurn(
+  args,
+  { onToolCall = null, onToolResult = () => {}, reply = '', nextPrompt = '' } = {}
+) {
+  const scopeId = `reaction-turn-${process.pid}-${++scopeSeq}`;
+  const prompt = { role: 'user', content: '고마워', meta: { transcript: { at: 1, messageId: 'msg_user_1' } } };
+  const session = {
+    id: 'sess_home_reviewer',
+    owner: 'cli',
+    agent: 'lead',
+    mcpScopeId: scopeId,
+    tools: [...REACTION_TOOL_DEFS],
+    messages: [prompt],
+    contextWindow: 200_000,
+    rawContextWindow: 200_000,
+    compaction: { auto: false },
+  };
+  const { react } = createReactionToolHandlers({ rt: { session }, live: () => null });
+  const dispose = setInternalToolsProvider({
+    scopeId,
+    tools: [...REACTION_TOOL_DEFS],
+    executor: (_name, toolArgs, callerCtx) => react(toolArgs, { callerCtx }),
+  });
+  const results = [];
+  let sends = 0;
+  const provider = {
+    async send() {
+      sends += 1;
+      if (sends === 1) return { content: '', toolCalls: [{ id: 'call_react', name: 'react', arguments: args }] };
+      if (sends > 3 || (reply && sends === 3)) return { content: 'Next.', toolCalls: [], stopReason: 'end_turn' };
+      return { content: sends === 2 ? reply : 'Sure.', toolCalls: [], stopReason: 'end_turn' };
+    },
+  };
+  const loopOpts = {
+    session,
+    sessionId: session.id,
+    onToolResult: (message) => {
+      results.push(message);
+      onToolResult(message);
+    },
+  };
+  try {
+    // The turn's working transcript is the loop's own list, as in a live turn.
+    const working = [prompt];
+    session.liveTurnMessages = working;
+    const result = await agentLoop(provider, working, 'fake-model', session.tools, onToolCall, process.cwd(), loopOpts);
+    session.messages = [...working];
+    delete session.liveTurnMessages;
+    let next = null;
+    if (nextPrompt) {
+      if (result.content) session.messages.push({ role: 'assistant', content: result.content });
+      session.messages.push({ role: 'user', content: nextPrompt });
+      session.liveTurnMessages = session.messages;
+      next = await agentLoop(provider, session.messages, 'fake-model', session.tools, null, process.cwd(), loopOpts);
+    }
+    const user = session.messages.find((message) => message.role === 'user');
+    return { result, next, sends, results, reactions: user?.meta?.transcript?.reactions || [] };
+  } finally {
+    dispose();
+  }
+}

package/src/runtime/agent/orchestrator/session/routine-result.d.mts

@@ -35,12 +35,10 @@ export interface RoutineNotice {
   }>;
 }
 
-export const ROUTINE_RESULT_SOURCE: 'schedule-result';
 export const TASK_LOOP_CAP: number;
 export function routineSummary(text: unknown): string;
 export const REPLY_LIMIT: number;
 export function boundedReply(text: unknown): { text: string; chars: number };
-export const WAKE_TEXT_BUDGET: number;
 export function routineResultMessage(options: {
   kind?: 'schedule' | 'webhook';
   name: string;

package/src/runtime/agent/orchestrator/session/routine-result.mjs

@@ -13,7 +13,7 @@ import { artifactLines, artifactRecords, normalizeHandoffFiles } from '../../../
 import { transcriptAttachmentFields } from '../../../shared/transcript-metadata.mjs';
 import { agentIdOfHomeSession } from './agent-home.mjs';
 
-export const ROUTINE_RESULT_SOURCE = 'schedule-result';
+const ROUTINE_RESULT_SOURCE = 'schedule-result';
 const SUMMARY_LIMIT = 600;
 
 /** The one-line, bounded summary a routine result keeps of its run output. */
@@ -206,6 +206,8 @@ export function agentTaskMessage({
   files = [],
   omitted = 0,
   hop = 0,
+  sendId = '',
+  sendIds = [],
   at = Date.now(),
   messageId,
 }) {
@@ -260,6 +262,11 @@ export function agentTaskMessage({
         ...(agentIdOfHomeSession(taskSessionId) ? { agentId: agentIdOfHomeSession(taskSessionId) } : {}),
         // Bot-to-bot chain position of the send this answers (session-runtime/bot-hops.mjs).
         ...(hop > 0 ? { hop } : {}),
+        // The send this report answers (the send result's `sendId`).
+        ...(sendId ? { sendId } : {}),
+        // Every send of a turn that answered several (folded into one turn):
+        // the one report ends all of them, `sendId` being the first.
+        ...(sendIds.length > 1 ? { sendIds } : {}),
         ...(produced.length ? { files: produced } : {}),
       },
       transcript: { at, ...(messageId ? { messageId } : {}), ...(attachments.length ? { attachments } : {}) },
@@ -268,7 +275,7 @@ export function agentTaskMessage({
 }
 
 /** Reply text one wake message carries across all its reports. */
-export const WAKE_TEXT_BUDGET = 24000;
+const WAKE_TEXT_BUDGET = 24000;
 
 /** A task report's content with its reply replaced by the row's one-line
  *  summary and a pointer to the session; null for any other message. */
@@ -385,6 +392,8 @@ export function routineResultNotice(message) {
         sessionId,
         ...(session ? { target: 'session' } : {}),
         ...(agentId ? { agentId } : {}),
+        ...(routine.sendId ? { sendId: routine.sendId } : {}),
+        ...(routine.sendIds?.length > 1 ? { sendIds: routine.sendIds } : {}),
         ...(files.length ? { files } : {}),
       },
       // The stored files, in the field a prompt row draws its attachments from.

package/src/runtime/agent/orchestrator/session/send-with-recovery.mjs

@@ -252,6 +252,10 @@ export async function sendWithRecovery(ctx) {
     retryAttemptNumber: Math.max(0, Number(transportRetriesUsed) || 0),
     retryMaxForDisplay,
   });
+  // The tail reminder this request carries; every assistant turn committed from
+  // its response stores it (turnReminder) so a provider in turn-scoped mode can
+  // re-send it verbatim before that turn (tail-reminder-split.mjs).
+  let turnReminder = '';
   try {
     let response;
     try {
@@ -266,22 +270,36 @@ export async function sendWithRecovery(ctx) {
       // Ephemeral tail reminder (tail-reminder-rules.mjs): added to this request's
       // copy only, never to the stored transcript.
       const requestMessages = withTailReminder(messages, { session: ctx.sessionRef, provider, model });
+      if (requestMessages !== messages) turnReminder = String(requestMessages.at(-1).content);
       response = await provider.send(requestMessages, model, sendTools.length ? sendTools : undefined, admittedOpts);
       hooks.logTurnTiming('ok');
     } catch (sendErr) {
       hooks.logTurnTiming(`err:${sendErr?.code || sendErr?.name || 'unknown'}`);
       stampStreamOutcome(sendErr, hooks.relayWitness);
-      return await recoverFromSendError(sendErr, { ...ctx, relayWitness: hooks.relayWitness });
+      return withTurnReminder(
+        await recoverFromSendError(sendErr, { ...ctx, relayWitness: hooks.relayWitness }),
+        turnReminder
+      );
     }
     // streamedChars: what this send put on screen through onTextDelta (net of
     // acknowledged retractions), so the loop can withdraw it if it discards
     // the response and re-sends.
-    return { action: 'proceed', response, streamedChars: hooks.relayWitness.text.length };
+    return withTurnReminder(
+      { action: 'proceed', response, streamedChars: hooks.relayWitness.text.length },
+      turnReminder
+    );
   } finally {
     hooks.restore();
   }
 }
 
+// A proceeding response — complete, promoted incomplete, recovered tool calls
+// or a cut kept as shown — was generated under this request's reminder.
+function withTurnReminder(result, turnReminder) {
+  if (turnReminder && result?.action === 'proceed' && result.response) result.response.turnReminder = turnReminder;
+  return result;
+}
+
 function loopTag({ sessionId, nextIteration }) {
   return `sess=${sessionId || 'unknown'} iter=${nextIteration}`;
 }

package/src/runtime/agent/orchestrator/session/store-agent-worker-header-cache.mjs

@@ -0,0 +1,85 @@
+/**
+ * Persisted copy of the agent pool's session-header cache. The in-memory
+ * cache of store-agent-worker-rows.mjs died with the daemon, so the first
+ * pool listing after every restart re-read every worker transcript (~1,700
+ * records, ~1 GB) just to rebuild headers that had not changed: seconds of
+ * I/O and CPU right when the restored conversation was loading.
+ *
+ * The file only seeds the in-memory cache. Every seeded entry is still served
+ * under that cache's full-stamp policy — the record must still have the exact
+ * { dev, ino, size, mtimeNs, ctimeNs } its header was read from, a stamp that
+ * was settled when cached — so a record changed while no daemon ran (or by
+ * another process) is read again. Being a cache, an absent, unreadable,
+ * damaged, other-version or other-field-set file seeds nothing (a bad entry
+ * alone is skipped) and is replaced by the next write; writes are atomic.
+ */
+import { randomBytes } from 'node:crypto';
+import { readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { sessionStampOf } from './store/canonical-reader.mjs';
+import { isStoredSessionId } from './store-summary-fields.mjs';
+import { dataDir } from './store-summary-locations.mjs';
+
+const VERSION = 1;
+const STAMP_KEYS = ['dev', 'ino', 'size', 'mtimeNs', 'ctimeNs'];
+const UNSIGNED = /^\d+$/;
+
+export function storedAgentWorkerHeaderCachePath(dir = dataDir()) {
+  return join(dir, 'agent-worker-header-cache.json');
+}
+
+function decodeStamp(value) {
+  if (!Array.isArray(value) || value.length !== STAMP_KEYS.length) return null;
+  if (!value.every((part) => typeof part === 'string' && UNSIGNED.test(part))) return null;
+  return sessionStampOf(Object.fromEntries(STAMP_KEYS.map((key, index) => [key, BigInt(value[index])])));
+}
+
+function decodeHeader(value, fields) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  return Object.keys(value).every((key) => fields.has(key)) ? value : null;
+}
+
+/** sessionId -> { stamp, header } from the file at `path`; empty when the
+ *  file is absent, unreadable, damaged, or written for another version or
+ *  header field list. */
+export async function readPersistedWorkerHeaders(path, fields) {
+  const entries = new Map();
+  let doc;
+  try {
+    doc = JSON.parse(await readFile(path, 'utf8'));
+  } catch {
+    return entries;
+  }
+  if (doc?.version !== VERSION || doc.fields !== fields.join(',')) return entries;
+  if (!doc.sessions || typeof doc.sessions !== 'object' || Array.isArray(doc.sessions)) return entries;
+  const wanted = new Set(fields);
+  for (const [sessionId, entry] of Object.entries(doc.sessions)) {
+    if (!isStoredSessionId(sessionId) || !entry || typeof entry !== 'object') continue;
+    const stamp = decodeStamp(entry.stamp);
+    const header = decodeHeader(entry.header, wanted);
+    if (stamp && header) entries.set(sessionId, { stamp, header });
+  }
+  return entries;
+}
+
+/** Replaces the file at `path` with `entries` (sessionId -> { stamp, header })
+ *  by rename, so a reader sees the old file or the new one, never a torn one.
+ *  Resolves false instead of throwing: a lost write only costs the next
+ *  restart some re-reads. The data directory is never created: a store that
+ *  is gone gets no cache. */
+export async function writePersistedWorkerHeaders(path, fields, entries) {
+  const sessions = {};
+  for (const [sessionId, { stamp, header }] of entries) {
+    sessions[sessionId] = { stamp: STAMP_KEYS.map((key) => String(stamp[key])), header };
+  }
+  // The temp shape is atomic-file.mjs's `<name>.mixdog-tmp-<hex>`.
+  const tmp = `${path}.mixdog-tmp-${randomBytes(8).toString('hex')}`;
+  try {
+    await writeFile(tmp, JSON.stringify({ version: VERSION, fields: fields.join(','), sessions }), { flag: 'wx' });
+    await rename(tmp, path);
+    return true;
+  } catch {
+    await unlink(tmp).catch(() => {});
+    return false;
+  }
+}

package/src/runtime/agent/orchestrator/session/store-agent-worker-rows.mjs

@@ -17,7 +17,7 @@
  */
 import { readFileSync } from 'node:fs';
 import { readFile, stat } from 'node:fs/promises';
-import { join } from 'node:path';
+import { basename, join } from 'node:path';
 import {
   isSettledSessionStamp,
   sameSessionStamp,
@@ -27,6 +27,11 @@ import {
 import { readJsonProjection } from '../../../shared/pending-json-projection.mjs';
 import { listStoredAgentWorkers as assembleStoredAgentWorkers } from './store-agent-worker-pool.mjs';
 import { readTopLevelFields } from './store-agent-worker-header.mjs';
+import {
+  readPersistedWorkerHeaders,
+  storedAgentWorkerHeaderCachePath,
+  writePersistedWorkerHeaders,
+} from './store-agent-worker-header-cache.mjs';
 import {
   TAG_TOMBSTONE_TTL_MS,
   agentPaneVisible,
@@ -330,8 +335,104 @@ const WORKER_HEADER_FIELDS = [
 // assembly the first answer stands, absent or unreadable included.
 let passHeaders = null; // path -> header | null, live only during an assembly
 
-function workerSessionHeaderPath(sessionId) {
-  return join(dataDir(), 'sessions', `${sessionId}.json`);
+function workerSessionHeaderPath(sessionId, dir = dataDir()) {
+  return join(dir, 'sessions', `${sessionId}.json`);
+}
+
+// Every change to the header cache is counted, so the persisted copy is
+// rewritten only when the cache it mirrors moved.
+let headerCacheEdits = 0;
+
+function cacheHeader(path, entry) {
+  workerSessionHeaderCache.set(path, entry);
+  headerCacheEdits += 1;
+}
+
+function dropHeader(path) {
+  if (workerSessionHeaderCache.delete(path)) headerCacheEdits += 1;
+}
+
+// The header cache outlives the daemon through store-agent-worker-header-
+// cache.mjs: the first awaited listing of a data directory seeds the cache
+// from its file (entries already in memory win), and an awaited listing that
+// changed the cache schedules a rewrite. The write waits out
+// HEADER_PERSIST_DELAY_MS — off the boot path, and at most one write per
+// window however often agents churn. Seeded entries pass the same full-stamp
+// check as any other, so a seed never serves a header its file no longer has.
+const HEADER_PERSIST_DELAY_MS = 10_000;
+let seededDir = null;
+let seeding = null;
+// The edit count the last write left on disk, and the directory it went to:
+// a count persisted for one data directory says nothing about another.
+let persistedEdits = 0;
+let persistedDir = null;
+let persistTimer = null;
+let persistTimerDir = null;
+let persistWrite = null;
+
+function seedPersistedHeaders() {
+  const dir = dataDir();
+  if (seededDir !== dir) {
+    seededDir = dir;
+    seeding = readPersistedWorkerHeaders(storedAgentWorkerHeaderCachePath(dir), WORKER_HEADER_FIELDS).then(
+      (entries) => {
+        for (const [sessionId, { stamp, header }] of entries) {
+          const path = workerSessionHeaderPath(sessionId, dir);
+          if (!workerSessionHeaderCache.has(path)) workerSessionHeaderCache.set(path, { stamp, header, pass: 0 });
+        }
+      }
+    );
+  }
+  return seeding;
+}
+
+function schedulePersistHeaders() {
+  const dir = dataDir();
+  // A write pending for the directory this listing left is dropped: the
+  // listing just forgot that directory's unread headers, so writing it now
+  // would shrink its file. Its last written cache still stands.
+  if (persistTimer && persistTimerDir !== dir) {
+    clearTimeout(persistTimer);
+    persistTimer = null;
+  }
+  if (persistTimer || (persistedDir === dir && headerCacheEdits === persistedEdits)) return;
+  persistTimerDir = dir;
+  persistTimer = setTimeout(() => {
+    persistTimer = null;
+    persistHeaders(persistTimerDir);
+  }, HEADER_PERSIST_DELAY_MS);
+  persistTimer.unref?.();
+}
+
+function persistHeaders(dir) {
+  if (persistWrite) return persistWrite;
+  const edits = headerCacheEdits;
+  const entries = [];
+  for (const [path, entry] of workerSessionHeaderCache) {
+    const sessionId = basename(path, '.json');
+    if (isStoredSessionId(sessionId) && workerSessionHeaderPath(sessionId, dir) === path) {
+      entries.push([sessionId, entry]);
+    }
+  }
+  persistWrite = writePersistedWorkerHeaders(storedAgentWorkerHeaderCachePath(dir), WORKER_HEADER_FIELDS, entries).then(
+    (written) => {
+      if (written) {
+        persistedEdits = edits;
+        persistedDir = dir;
+      }
+      persistWrite = null;
+    }
+  );
+  return persistWrite;
+}
+
+/** Test/diagnostic seam: writes a scheduled header-cache persist now and
+ *  resolves once no write is in flight. */
+export function flushStoredAgentWorkerHeaderCache() {
+  if (!persistTimer) return persistWrite || Promise.resolve();
+  clearTimeout(persistTimer);
+  persistTimer = null;
+  return persistHeaders(persistTimerDir);
 }
 
 function readWorkerSessionHeader(sessionId) {
@@ -358,15 +459,18 @@ function observeStamp(path) {
 // window when read. Size + mtime alone let an equal-length rewrite that kept
 // its mtime serve stale ownership, status and cancel fields.
 function probeWorkerSessionHeader(path) {
-  // Absent and unreadable alike: no header.
+  // Absent and unreadable alike: no header, and no cached one kept for it.
   const before = observeStamp(path);
-  if (!before) return null;
+  if (!before) {
+    dropHeader(path);
+    return null;
+  }
   const cached = workerSessionHeaderCache.get(path);
   if (cached && sameSessionStamp(cached.stamp, before)) {
     cached.pass = headerPass;
     return cached.header;
   }
-  workerSessionHeaderCache.delete(path);
+  dropHeader(path);
   // A rewrite re-reads only this record, and only its top-level fields are
   // decoded: the transcript bytes are validated, never materialized.
   let header = null;
@@ -378,7 +482,7 @@ function probeWorkerSessionHeader(path) {
   if (!header) return null;
   workerHeaderReads += 1;
   if (isSettledSessionStamp(before) && sameSessionStamp(before, observeStamp(path))) {
-    workerSessionHeaderCache.set(path, { stamp: before, header, pass: headerPass });
+    cacheHeader(path, { stamp: before, header, pass: headerPass });
   }
   return header;
 }
@@ -395,10 +499,13 @@ async function observeStampAsync(path) {
  *  same full-stamp cache policy. */
 async function probeWorkerSessionHeaderAsync(path) {
   const before = await observeStampAsync(path);
-  if (!before) return null;
+  if (!before) {
+    dropHeader(path);
+    return null;
+  }
   const cached = workerSessionHeaderCache.get(path);
   if (cached && sameSessionStamp(cached.stamp, before)) return cached.header;
-  workerSessionHeaderCache.delete(path);
+  dropHeader(path);
   let header = null;
   try {
     header = readTopLevelFields(await readFile(path), WORKER_HEADER_FIELDS);
@@ -408,7 +515,7 @@ async function probeWorkerSessionHeaderAsync(path) {
   if (!header) return null;
   workerHeaderReads += 1;
   if (isSettledSessionStamp(before) && sameSessionStamp(before, await observeStampAsync(path))) {
-    workerSessionHeaderCache.set(path, { stamp: before, header, pass: headerPass });
+    cacheHeader(path, { stamp: before, header, pass: headerPass });
   }
   return header;
 }
@@ -418,7 +525,9 @@ async function probeWorkerSessionHeaderAsync(path) {
 const HEADER_READ_CONCURRENCY = 4;
 
 async function prefetchWorkerHeaders(sessionIds, headers) {
-  const paths = [...new Set([...sessionIds].map(workerSessionHeaderPath))].filter((path) => !headers.has(path));
+  const paths = [...new Set([...sessionIds].map((sessionId) => workerSessionHeaderPath(sessionId)))].filter(
+    (path) => !headers.has(path)
+  );
   let next = 0;
   const drain = async () => {
     while (next < paths.length) {
@@ -634,7 +743,7 @@ export function listStoredAgentWorkers({ runningSessionIds = null } = {}) {
 // Keep what the latest assembly read, whatever the index size; forget the rest.
 function forgetUnreadHeaders() {
   for (const [path, entry] of workerSessionHeaderCache) {
-    if (entry.pass !== headerPass) workerSessionHeaderCache.delete(path);
+    if (entry.pass !== headerPass) dropHeader(path);
   }
 }
 
@@ -643,6 +752,8 @@ function forgetUnreadHeaders() {
  *  each Lead row's, and each child's owner) are read first with awaited
  *  stats and reads; the assembly then runs over what was read, with no file
  *  access left in it (any header it still asks for falls back to a read).
+ *  The first listing after a restart seeds the header cache from its
+ *  persisted copy, so only records changed since are read again.
  *  `runningSessionIds` may be a function, asked once the reads are done. */
 export async function listStoredAgentWorkersAsync({ runningSessionIds = null } = {}) {
   const agentIndexPath = storedAgentWorkerIndexPath();
@@ -650,6 +761,7 @@ export async function listStoredAgentWorkersAsync({ runningSessionIds = null } =
   const [agentIndex, leadIndex] = await Promise.all([
     readWorkerIndexFileAsync(agentIndexPath),
     readWorkerIndexFileAsync(leadIndexPath),
+    seedPersistedHeaders(),
   ]);
   const headers = new Map();
   const childRows = workerRows(agentIndex);
@@ -683,6 +795,7 @@ export async function listStoredAgentWorkersAsync({ runningSessionIds = null } =
     passHeaders = null;
     passIndexes = null;
     forgetUnreadHeaders();
+    schedulePersistHeaders();
   }
 }
 

package/src/runtime/agent/orchestrator/session/tail-reminder-rules.mjs

@@ -1,8 +1,14 @@
 // Tail reminders: short per-model/per-language nudges appended to the very end
 // of an outgoing request (after the last tool result), fresh on every request.
-// They are never stored in session history or transcripts, and the Anthropic
-// builders place their last cache breakpoint BEFORE them, so the cached prefix
-// stays byte-identical from one request to the next.
+// They are never stored as messages of their own; the Anthropic builders place
+// their last cache breakpoint BEFORE them. The assistant turn a request produces
+// keeps that request's reminder text (`turnReminder`, send-with-recovery.mjs).
+// How each provider places them (providers/lib/tail-reminder-split.mjs):
+//   - legacy: the reminder ends this request only and is gone from the next;
+//   - turn-scoped (first-party Anthropic on a supported model, opt-in per
+//     provider): a clear_at system message that every later request re-sends
+//     verbatim before its assistant turn, so the wire is append-only and the
+//     model's earlier thinking stays bound to an unchanged prefix.
 //
 // HOW TO ADD A RULE (a new per-model/per-language fix needs nothing else):
 //   1. Append {id, when, text} to TAIL_REMINDER_RULES. `when` holds any of
@@ -17,7 +23,7 @@ import { AGENT_MODE } from './agent-mode.mjs';
 import { _buildLeadLanguage } from './manager/rules-cache.mjs';
 import { TAIL_REMINDER_META } from '../providers/lib/tail-reminder-split.mjs';
 
-export const TAIL_REMINDER_TAGS = Object.freeze(['provider', 'model', 'language', 'role']);
+const TAIL_REMINDER_TAGS = Object.freeze(['provider', 'model', 'language', 'role']);
 const ROLES = ['lead', 'bot', 'worker'];
 
 const PROVIDER_FAMILIES = Object.freeze({
@@ -84,7 +90,7 @@ export function modelFamilyId(model) {
 }
 
 /** The session's role: 'worker' (agent-owned), 'bot' (agent mode) or 'lead'. */
-export function tailReminderRole(session) {
+function tailReminderRole(session) {
   if (session?.owner === 'agent') return 'worker';
   return session?.sessionMode === AGENT_MODE ? 'bot' : 'lead';
 }

package/src/runtime/agent/orchestrator/session/tool-batch/state.mjs

@@ -33,6 +33,10 @@ export function createBatchState(ctx) {
     pushToolResultMessage: ctx.pushToolResultMessage,
     throwIfAborted: ctx.throwIfAborted,
     repeatFailLimit: ctx.repeatFailLimit,
+    // Calls of this batch a capped turn may still run (session/loop/turn-limits.mjs).
+    callsAllowed: Number.isFinite(ctx.callsAllowed) ? ctx.callsAllowed : Infinity,
+    // After this time (epoch ms) no call of the batch starts.
+    wrapUpAt: Number.isFinite(ctx.wrapUpAt) ? ctx.wrapUpAt : Infinity,
     toolBatchId: ctx.toolBatchId,
     executeToolFn: typeof ctx.executeToolFn === 'function' ? ctx.executeToolFn : executeTool,
     dedupStubTotal: ctx.dedupStubTotal,

package/src/runtime/agent/orchestrator/session/tool-batch.mjs

@@ -12,6 +12,7 @@ import { executeBatchCall } from './tool-batch/execute-call.mjs';
 import { recordCallOutcome } from './tool-batch/record-outcome.mjs';
 import { finalizeBatchResults } from './tool-batch/finalize.mjs';
 import { flushBatch } from './tool-batch/flush.mjs';
+import { turnLimitRefusal } from './loop/turn-limits.mjs';
 
 export async function processToolBatch(ctx) {
   const batch = createBatchState(ctx);
@@ -19,6 +20,10 @@ export async function processToolBatch(ctx) {
   for (let callIndex = 0; callIndex < calls.length; callIndex += 1) {
     const call = calls[callIndex];
     if (isBuiltinTool(call.name)) call.name = canonicalizeBuiltinToolName(call.name);
+    if (callIndex >= batch.callsAllowed || Date.now() >= batch.wrapUpAt) {
+      stageToolResult(batch, turnLimitRefusal(call));
+      continue;
+    }
     const { skip, ctSig, sigs } = preDispatchSkip(batch, call);
     if (skip !== null) {
       stageToolResult(batch, skip);