mixdog 1.1.2 → 1.2.0

package/src/runtime/agent/orchestrator/session/compaction-archive-capture.mjs

@@ -0,0 +1,362 @@
+/**
+ * Capture side of the display-only compaction archive (compaction-archive.mjs).
+ *
+ * A committed compaction hands over the transcript it replaced and the one
+ * that replaced it. What left the model context — the messages whose stable
+ * id (message-ids.mjs) the result no longer holds, and the lost parts of kept
+ * messages (compactionArchiveProjection) — is projected to transcript items
+ * exactly like stored history
+ * (restoreTranscriptItems over media-sanitized messages, so tool cards and
+ * diffs survive), namespaced as `arch<seq>_…` with `archived: true`, and
+ * appended as ONE segment to the session's sidecar, followed by the
+ * compaction divider.
+ *
+ * The commit only selects the dropped messages and allocates the segment
+ * number (`session.compaction.archive.nextSeq`, saved with the commit); the
+ * projection and the write run on a later event-loop turn, serialized per
+ * session and fenced against a delete. Nothing here touches
+ * `session.messages`.
+ */
+import { randomBytes } from 'node:crypto';
+import { existsSync, unlinkSync } from 'node:fs';
+import { open, readFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { renameWithRetrySync } from '../../../shared/atomic-file.mjs';
+import { writeStderrBestEffort } from '../../../shared/best-effort-stderr.mjs';
+
+import { sanitizeContentForStoredHistory } from '../providers/media-normalization.mjs';
+import { getStoreDir } from './store/paths-heartbeat.mjs';
+import { forgetSessionSaveBaseline } from './store/save-worker.mjs';
+import { messageIdOf, stampMessageIds } from './message-ids.mjs';
+import { restoreTranscriptItems } from './transcript-restore/restore.mjs';
+import {
+  COMPACTION_ARCHIVE_MAX_BYTES,
+  COMPACTION_DIVIDER_LABEL,
+  compactionArchiveDeleteEpoch,
+  compactionArchivePath,
+  compactionSegmentHead,
+  compactionSegmentLine,
+} from './compaction-archive.mjs';
+
+export { COMPACTION_DIVIDER_LABEL };
+
+const pendingWrites = new Map();
+
+// ── Dropped messages: by stable id only ──────────────────────────────────────
+
+function toolCallsOf(message) {
+  const calls = Array.isArray(message.toolCalls) ? message.toolCalls : message.tool_calls;
+  return Array.isArray(calls) ? calls : [];
+}
+
+function callIdOf(call) {
+  return String(call?.id || '');
+}
+
+function resultCallIdOf(message) {
+  return message.role === 'tool' ? String(message.tool_call_id || message.toolCallId || '') : '';
+}
+
+function hasText(content) {
+  if (typeof content === 'string') return content.trim().length > 0;
+  return Array.isArray(content) && content.some((part) => typeof part?.text === 'string' && part.text.trim());
+}
+
+/** The stable ids `messages` carries (stampMessageIds / carryMessageId). */
+function idsOf(messages) {
+  const ids = new Set();
+  for (const message of messages) {
+    const id = messageIdOf(message);
+    if (id) ids.add(id);
+  }
+  return ids;
+}
+
+/**
+ * Messages of `before` whose stable id the compacted `after` no longer holds,
+ * in their original order. Identity is the id alone — never an object
+ * reference, a position or content. A message without an id (a string-meta
+ * context marker, see message-ids.mjs) has no display identity and is never
+ * reported.
+ */
+export function droppedByCompaction(before, after) {
+  const kept = idsOf(Array.isArray(after) ? after : []);
+  return (Array.isArray(before) ? before : []).filter((message) => {
+    const id = messageIdOf(message);
+    return id && !kept.has(id);
+  });
+}
+
+/**
+ * What a compaction took out of the model context, in `before` order, for the
+ * display archive: every dropped message, plus — for a kept message whose
+ * rewrite lost part of it — the lost part (tool calls no copy still carries,
+ * text when no copy has any) as a message of the same id. The tool results of
+ * those calls are dropped messages, so their cards restore whole.
+ * `textIds` are the ids whose text rows left the context: the dropped
+ * messages and the kept ones that lost all their text.
+ */
+export function compactionArchiveProjection(before, after) {
+  const copiesById = new Map();
+  for (const message of Array.isArray(after) ? after : []) {
+    const id = messageIdOf(message);
+    if (!id) continue;
+    if (!copiesById.has(id)) copiesById.set(id, []);
+    copiesById.get(id).push(message);
+  }
+  const messages = [];
+  const textIds = [];
+  for (const message of Array.isArray(before) ? before : []) {
+    const id = messageIdOf(message);
+    if (!id) continue;
+    const copies = copiesById.get(id);
+    if (!copies) {
+      messages.push(message);
+      textIds.push(id);
+      continue;
+    }
+    const keptCalls = new Set(copies.flatMap((copy) => toolCallsOf(copy).map(callIdOf)));
+    const lostCalls = toolCallsOf(message).filter((call) => callIdOf(call) && !keptCalls.has(callIdOf(call)));
+    const lostText = hasText(message.content) && !copies.some((copy) => hasText(copy.content));
+    if (!lostCalls.length && !lostText) continue;
+    if (lostText) textIds.push(id);
+    const { toolCalls: _calls, tool_calls: _wireCalls, ...rest } = message;
+    messages.push({
+      ...rest,
+      content: lostText ? message.content : '',
+      ...(lostCalls.length ? { toolCalls: lostCalls } : {}),
+    });
+  }
+  return { messages, textIds };
+}
+
+/** What a live view needs to find the rows of what left the context: the
+ *  stable ids whose text rows went (projection `textIds`) and the tool calls
+ *  that went (dropped results and calls no kept copy carries). */
+export function droppedIdentitySummary(projection) {
+  const callIds = new Set();
+  for (const message of projection.messages) {
+    for (const call of toolCallsOf(message)) if (callIdOf(call)) callIds.add(callIdOf(call));
+    const resultId = resultCallIdOf(message);
+    if (resultId) callIds.add(resultId);
+  }
+  return { messageIds: [...new Set(projection.textIds)], callIds: [...callIds] };
+}
+
+/** Stamp stable ids on the transcript a compaction is about to run on (or a
+ *  resumed session restores rows from) and make sure they are persisted: the
+ *  next save goes out whole instead of as a delta that would leave the
+ *  stamped, already-saved messages unchanged on disk. Returns the count. */
+export function stampCompactionMessageIds(messages, sessionId) {
+  const stamped = stampMessageIds(messages, { sessionId });
+  if (stamped && sessionId) forgetSessionSaveBaseline(String(sessionId));
+  return stamped;
+}
+// ── Segment projection and publication ───────────────────────────────────────
+
+function storedHistoryMessage(message) {
+  const content = sanitizeContentForStoredHistory(message.content);
+  return content === message.content ? message : { ...message, content };
+}
+
+/** The display items of one segment: what left the context
+ *  (compactionArchiveProjection messages) as stored history restores it,
+ *  namespaced and marked archived, then the divider. Empty when nothing
+ *  visible left. */
+export function compactionSegmentItems(messages, { sessionId, seq, at }) {
+  const restored = restoreTranscriptItems(messages.map(storedHistoryMessage), { sessionId });
+  if (!restored.length) return [];
+  const prefix = `hist_${sessionId}_`;
+  const items = restored.map((item) => {
+    const id = String(item?.id ?? '');
+    return { ...item, id: `arch${seq}_${id.startsWith(prefix) ? id.slice(prefix.length) : id}`, archived: true };
+  });
+  items.push({
+    kind: 'statusdone',
+    id: `arch${seq}_divider`,
+    status: 'compacted',
+    label: COMPACTION_DIVIDER_LABEL,
+    at,
+  });
+  return items;
+}
+
+function itemBytes(item) {
+  return Buffer.byteLength(JSON.stringify(item));
+}
+
+/** A segment line whose bytes plus its trailing newline fit `maxBytes`: a
+ *  segment that alone exceeds the cap keeps its newest items (and the
+ *  divider). `bytes` includes the newline. */
+function cappedSegmentLine({ seq, prev, at, items }, maxBytes) {
+  let line = compactionSegmentLine({ seq, prev, at, items });
+  let bytes = Buffer.byteLength(line) + 1;
+  if (bytes <= maxBytes) return { line, bytes };
+  const sizes = items.map(itemBytes);
+  let start = 0;
+  while (bytes > maxBytes && start < items.length - 1) {
+    bytes -= sizes[start] + 1;
+    start += 1;
+  }
+  line = compactionSegmentLine({ seq, prev, at, items: items.slice(start) });
+  return { line, bytes: Buffer.byteLength(line) + 1 };
+}
+
+let publishHook = null;
+/** Test seam: runs after a segment's temp file is written, right before the
+ *  fenced publication. */
+export function _setCompactionArchivePublishHook(hook) {
+  publishHook = typeof hook === 'function' ? hook : null;
+}
+
+let syncFile = (handle) => handle.sync();
+/** Test seam: replaces the temp file's fsync (null restores it). */
+export function _setCompactionArchiveFsync(sync) {
+  syncFile = typeof sync === 'function' ? sync : (handle) => handle.sync();
+}
+
+const recordExists = (dir, sessionId) => existsSync(join(dir, `${sessionId}.json`));
+
+/** Write `text` to a private temp file and fsync it — a failed write or
+ *  fsync fails the publication — then publish it with a synchronous fence
+ *  check + rename: a delete that bumped the epoch (or removed the record)
+ *  since `epoch` was captured wins. Any outcome but a rename removes the temp
+ *  file. */
+async function publishArchive({ dir, path, sessionId, text, epoch }) {
+  const tmp = join(dir, `.${basename(path)}.${randomBytes(8).toString('hex')}.tmp`);
+  const removeTmp = () => {
+    try {
+      unlinkSync(tmp);
+    } catch {
+      /* already gone */
+    }
+  };
+  try {
+    const handle = await open(tmp, 'wx', 0o600);
+    try {
+      await handle.writeFile(text, 'utf8');
+      await syncFile(handle);
+    } finally {
+      await handle.close();
+    }
+    if (publishHook) await publishHook({ sessionId, path, tmp });
+  } catch (error) {
+    removeTmp();
+    throw error;
+  }
+  // No await between the fence and the rename.
+  if (compactionArchiveDeleteEpoch(sessionId) !== epoch || !recordExists(dir, sessionId)) {
+    removeTmp();
+    return false;
+  }
+  try {
+    renameWithRetrySync(tmp, path);
+  } catch (error) {
+    removeTmp();
+    throw error;
+  }
+  return true;
+}
+
+async function appendSegment({ sessionId, seq, at, items, clearedThrough, maxBytes, epoch }) {
+  const dir = getStoreDir();
+  const path = compactionArchivePath(dir, sessionId);
+  // A deleted session must not regrow its archive.
+  if (!path || compactionArchiveDeleteEpoch(sessionId) !== epoch || !recordExists(dir, sessionId)) return null;
+  let text = '';
+  try {
+    text = await readFile(path, 'utf8');
+  } catch {
+    text = '';
+  }
+  const existing = [];
+  for (const line of text.split('\n')) {
+    const head = compactionSegmentHead(line);
+    // Segments a clear hid are dropped on the next write.
+    if (head && head.seq > clearedThrough && head.seq !== seq) existing.push({ line, head });
+  }
+  const prev = existing.length ? existing.at(-1).head.seq : null;
+  const segment = cappedSegmentLine({ seq, prev, at, items }, maxBytes);
+  let total = segment.bytes;
+  for (const entry of existing) total += Buffer.byteLength(entry.line) + 1;
+  while (existing.length && total > maxBytes) {
+    total -= Buffer.byteLength(existing.shift().line) + 1;
+  }
+  const lines = [...existing.map((entry) => entry.line), segment.line];
+  if (!(await publishArchive({ dir, path, sessionId, text: `${lines.join('\n')}\n`, epoch }))) return null;
+  return lines.map((line) => compactionSegmentHead(line)).filter(Boolean);
+}
+
+/**
+ * Archive what a committed compaction dropped. Synchronous part: select the
+ * dropped messages, capture the delete fence and allocate the segment number
+ * on `session.compaction.archive`; the rest runs later. Returns
+ * `{ dropped, identities, written }` — the dropped message count, their
+ * identities for a live view (droppedIdentitySummary) and the pending write
+ * (resolves to the retained segment list) — or null when nothing visible was
+ * dropped (a rewrite-only compaction).
+ */
+export function scheduleCompactionArchive({
+  session,
+  sessionId = null,
+  before,
+  after,
+  at = Date.now(),
+  maxBytes = COMPACTION_ARCHIVE_MAX_BYTES,
+}) {
+  const id = String(sessionId || session?.id || '');
+  if (!session || typeof session !== 'object' || !compactionArchivePath('', id)) return null;
+  const projection = compactionArchiveProjection(before, after);
+  // Only what the transcript shows is archived; a pass that took out nothing
+  // visible (a rewrite, control rows, hidden context) leaves the view live.
+  // Short-circuits on the first visible message.
+  if (!projection.messages.some((message) => restoreTranscriptItems([message], { sessionId: id }).length > 0)) {
+    return null;
+  }
+  const dropped = droppedByCompaction(before, after);
+  if (!session.compaction || typeof session.compaction !== 'object') session.compaction = {};
+  const previous =
+    session.compaction.archive && typeof session.compaction.archive === 'object' ? session.compaction.archive : {};
+  const seq = Math.max(1, Math.floor(Number(previous.nextSeq) || 1));
+  const clearedThrough = Math.max(0, Math.floor(Number(previous.clearedThrough) || 0));
+  const epoch = compactionArchiveDeleteEpoch(id);
+  session.compaction.archive = { ...previous, nextSeq: seq + 1 };
+  const run = async () => {
+    await new Promise((resolve) => setImmediate(resolve));
+    const items = compactionSegmentItems(projection.messages, { sessionId: id, seq, at });
+    if (!items.length) return null;
+    const segments = await appendSegment({ sessionId: id, seq, at, items, clearedThrough, maxBytes, epoch });
+    const archive = session.compaction?.archive;
+    // Small metadata only; a later clear may have hidden this segment.
+    if (segments && archive && typeof archive === 'object' && !(Number(archive.clearedThrough) >= seq)) {
+      archive.segments = segments;
+    }
+    return segments;
+  };
+  const task = (pendingWrites.get(id) || Promise.resolve()).then(run).catch((error) => {
+    writeStderrBestEffort(`[session] compaction archive write failed (sess=${id}): ${error?.message || error}\n`);
+    return null;
+  });
+  pendingWrites.set(id, task);
+  void task.finally(() => {
+    if (pendingWrites.get(id) === task) pendingWrites.delete(id);
+  });
+  return { dropped: dropped.length, identities: droppedIdentitySummary(projection), written: task };
+}
+
+/** Hide everything archived so far (a clear): later reads and the next write
+ *  skip those segments. */
+export function hideCompactionArchive(session) {
+  const archive = session?.compaction?.archive;
+  if (!archive || typeof archive !== 'object') return;
+  session.compaction.archive = {
+    ...archive,
+    clearedThrough: Math.max(0, Math.floor(Number(archive.nextSeq) || 1) - 1),
+    segments: [],
+  };
+}
+
+/** Settles once every archive write scheduled so far has finished. */
+export async function flushCompactionArchiveWrites() {
+  await Promise.all([...pendingWrites.values()]);
+}

package/src/runtime/agent/orchestrator/session/compaction-archive.mjs

@@ -0,0 +1,253 @@
+/**
+ * Display-only archive of the conversation a compaction dropped.
+ *
+ * One JSONL sidecar per session next to its record
+ * (`<id>.compaction-archive.jsonl`), one line per compaction segment, oldest
+ * first. A segment holds the transcript ITEMS (the pane's display shape, never
+ * model messages) its compaction removed from the model context, followed by
+ * the "Conversation compacted" divider. Each line opens with a fixed header
+ * (`{"v":1,"seq":N,"id":"segN","prev":…,"at":…,"count":…,"bytes":…,"items":[…]}`)
+ * so a reader can pick segments by number without parsing their items.
+ *
+ * Nothing here ever reaches `session.messages` or a provider payload: the
+ * archive is read only by the stored-transcript projection and the paged
+ * history loader. Leaf module (no store.mjs, no config) so the cold catalog
+ * path can read it; the writer lives in compaction-archive-capture.mjs.
+ */
+import { unlinkSync } from 'node:fs';
+import { open } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export const COMPACTION_ARCHIVE_SUFFIX = '.compaction-archive.jsonl';
+/** The one label every compaction boundary row carries (persisted and live),
+ *  translated by the desktop as the app's compaction wording. */
+export const COMPACTION_DIVIDER_LABEL = 'Conversation compacted';
+/** Per-session cap; the oldest segments are dropped past it. */
+export const COMPACTION_ARCHIVE_MAX_BYTES = 32 * 1024 * 1024;
+
+const SESSION_ID = /^[A-Za-z0-9_-]+$/;
+const SEGMENT_HEAD = /^\{"v":1,"seq":(\d+),"id":"[^"]*","prev":(null|"[^"]*"),"at":(\d+),"count":(\d+),"bytes":(\d+),/;
+
+/** The archive sidecar of `sessionId` inside a sessions directory, or null
+ *  for an id that is not a stored session id. */
+export function compactionArchivePath(storeDir, sessionId) {
+  const id = String(sessionId || '');
+  if (!SESSION_ID.test(id)) return null;
+  return join(storeDir, `${id}${COMPACTION_ARCHIVE_SUFFIX}`);
+}
+
+/** The visible archive a session record names: segments numbered in
+ *  (after, before). A clear hides everything archived before it. Null when
+ *  nothing is visible. */
+export function compactionArchiveRange(session) {
+  const archive = session?.compaction?.archive;
+  if (!archive || typeof archive !== 'object') return null;
+  const before = Number(archive.nextSeq);
+  const after = Math.max(0, Math.floor(Number(archive.clearedThrough) || 0));
+  if (!Number.isInteger(before) || before - 1 <= after) return null;
+  return { after, before };
+}
+
+/** A segment line's header fields, or null for a line that is not one. */
+export function compactionSegmentHead(line) {
+  const match = SEGMENT_HEAD.exec(String(line || ''));
+  if (!match) return null;
+  return {
+    seq: Number(match[1]),
+    id: `seg${match[1]}`,
+    prev: match[2] === 'null' ? null : match[2].slice(1, -1),
+    at: Number(match[3]),
+    count: Number(match[4]),
+    bytes: Number(match[5]),
+  };
+}
+
+/** One segment as its JSONL line (no trailing newline). */
+export function compactionSegmentLine({ seq, prev, at, items }) {
+  const body = JSON.stringify(items);
+  return `{"v":1,"seq":${seq},"id":"seg${seq}","prev":${prev == null ? 'null' : JSON.stringify(`seg${prev}`)},"at":${Math.max(0, Math.floor(Number(at) || 0))},"count":${items.length},"bytes":${Buffer.byteLength(body)},"items":${body}}`;
+}
+
+function segmentItems(text) {
+  try {
+    const items = JSON.parse(text)?.items;
+    return Array.isArray(items) ? items : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * One page from a segment list (oldest → newest heads; `load(entry)` yields a
+ * segment's items): segments numbered in (after, before), newest first,
+ * skipping the `skip` newest items a reader already holds and returning at
+ * most `limit` items above them, in display order. Item counts come from
+ * the segment headers: a segment wholly inside the skipped rows or past the
+ * page is never read or parsed. `hasOlder` says whether older items remain.
+ */
+async function pageFromSegments(
+  entries,
+  load,
+  { after = 0, before = Number.POSITIVE_INFINITY, skip = 0, limit = 0 } = {}
+) {
+  const held = Math.max(0, Math.floor(Number(skip) || 0));
+  const wanted = Math.max(0, Math.floor(Number(limit) || 0));
+  const parts = [];
+  // Items newer than this entry, counted from the newest.
+  let newer = 0;
+  let more = false;
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const { head } = entries[index];
+    if (head.seq <= after || head.seq >= before || head.count < 1) continue;
+    if (newer >= held + wanted) {
+      more = true;
+      break;
+    }
+    const count = head.count;
+    if (newer + count > held) {
+      // This segment holds rows of the page: newest-first offsets
+      // [max(held, newer), min(held + wanted, newer + count)) of it.
+      const items = await load(entries[index]);
+      const fromEnd = Math.max(0, held - newer);
+      const take = Math.min(held + wanted, newer + count) - Math.max(held, newer);
+      const end = items.length - fromEnd;
+      parts.push(items.slice(Math.max(0, end - take), Math.max(0, end)));
+      if (newer + count > held + wanted) more = true;
+    }
+    newer += count;
+  }
+  return { items: parts.reverse().flat(), hasOlder: more };
+}
+
+/** pageFromSegments over archive text (tests and in-memory callers). */
+export function compactionArchivePageFromText(text, range = {}) {
+  const entries = [];
+  for (const line of String(text || '').split('\n')) {
+    const head = compactionSegmentHead(line);
+    if (head) entries.push({ head, line });
+  }
+  return pageFromSegments(entries, (entry) => segmentItems(entry.line), range);
+}
+
+// Per-sidecar segment index (byte offsets + headers), keyed by the file
+// identity it was built from: a page reads only the segments it reaches, and
+// the headers are indexed once per change rather than once per page.
+const INDEX_CACHE_LIMIT = 16;
+const archiveIndexes = new Map();
+
+const HEAD_PROBE_BYTES = 512;
+const ITEMS_KEY = '"items":';
+const SCAN_CHUNK_BYTES = 64 * 1024;
+
+/** Offset of the first newline at or after `from` (or `size`), scanning. */
+async function nextNewline(handle, from, size) {
+  const chunk = Buffer.alloc(SCAN_CHUNK_BYTES);
+  for (let at = from; at < size; at += SCAN_CHUNK_BYTES) {
+    const { bytesRead } = await handle.read(chunk, 0, Math.min(SCAN_CHUNK_BYTES, size - at), at);
+    const hit = chunk.subarray(0, bytesRead).indexOf(0x0a);
+    if (hit >= 0) return at + hit;
+  }
+  return size;
+}
+
+/** Segment offsets of an archive file. Each header names its items' byte
+ *  length, so the index reads only the headers and jumps over the bodies; a
+ *  line whose header does not account for its length is scanned past. */
+async function indexArchive(handle, size) {
+  const entries = [];
+  const probe = Buffer.alloc(HEAD_PROBE_BYTES);
+  let start = 0;
+  while (start < size) {
+    const { bytesRead } = await handle.read(probe, 0, Math.min(HEAD_PROBE_BYTES, size - start), start);
+    const text = probe.toString('latin1', 0, bytesRead);
+    const match = SEGMENT_HEAD.exec(text);
+    let end = -1;
+    if (match && text.startsWith(ITEMS_KEY, match[0].length)) {
+      // `…"items":<body>}` — the header is ASCII, so chars are bytes.
+      const candidate = start + match[0].length + ITEMS_KEY.length + Number(match[5]) + 1;
+      if (candidate === size) end = candidate;
+      else if (candidate < size) {
+        const tail = Buffer.alloc(1);
+        await handle.read(tail, 0, 1, candidate);
+        if (tail[0] === 0x0a) end = candidate;
+      }
+    }
+    if (end >= 0) entries.push({ head: compactionSegmentHead(text), start, length: end - start });
+    else end = await nextNewline(handle, start, size);
+    start = end + 1;
+  }
+  return entries;
+}
+
+async function archiveIndexFor(path, handle) {
+  const info = await handle.stat();
+  const stamp = `${info.dev}:${info.ino}:${info.size}:${info.mtimeMs}`;
+  const cached = archiveIndexes.get(path);
+  if (cached?.stamp === stamp) {
+    archiveIndexes.delete(path);
+    archiveIndexes.set(path, cached);
+    return cached.entries;
+  }
+  const entries = await indexArchive(handle, info.size);
+  archiveIndexes.set(path, { stamp, entries });
+  while (archiveIndexes.size > INDEX_CACHE_LIMIT) archiveIndexes.delete(archiveIndexes.keys().next().value);
+  return entries;
+}
+
+/** One page of a session's archive sidecar (see pageFromSegments). The
+ *  open handle pins the file a concurrent atomic replace may swap out, so
+ *  the index and the segment reads describe the same bytes. */
+export async function readCompactionArchivePage(storeDir, sessionId, range = {}) {
+  const path = compactionArchivePath(storeDir, sessionId);
+  if (!path) return { items: [], hasOlder: false };
+  let handle;
+  try {
+    handle = await open(path, 'r');
+  } catch {
+    // Display-only history: an absent or unreadable archive shows nothing.
+    archiveIndexes.delete(path);
+    return { items: [], hasOlder: false };
+  }
+  try {
+    const entries = await archiveIndexFor(path, handle);
+    return await pageFromSegments(
+      entries,
+      async (entry) => {
+        const buffer = Buffer.alloc(entry.length);
+        await handle.read(buffer, 0, entry.length, entry.start);
+        return segmentItems(buffer.toString('utf8'));
+      },
+      range
+    );
+  } catch {
+    return { items: [], hasOlder: false };
+  } finally {
+    await handle.close().catch(() => {});
+  }
+}
+
+// Delete fence: every deletion bumps the session's epoch. A writer captures
+// the epoch before it starts and publishes only if it is unchanged at the
+// (synchronous) rename, so a delete that lands while a segment is being
+// written is never undone by that write.
+const deleteEpochs = new Map();
+
+export function compactionArchiveDeleteEpoch(sessionId) {
+  return deleteEpochs.get(String(sessionId || '')) || 0;
+}
+
+/** Remove a session's archive (session delete) and fence every write that
+ *  started before it. Best-effort: true when the sidecar is gone afterwards. */
+export function deleteCompactionArchive(storeDir, sessionId) {
+  const path = compactionArchivePath(storeDir, sessionId);
+  if (!path) return false;
+  const id = String(sessionId);
+  deleteEpochs.set(id, compactionArchiveDeleteEpoch(id) + 1);
+  archiveIndexes.delete(path);
+  try {
+    unlinkSync(path);
+    return true;
+  } catch (error) {
+    return error?.code === 'ENOENT';
+  }
+}

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn/continuation.mjs

@@ -34,7 +34,7 @@ export function resumeContinuation(
     return false;
   }
   if (!segments.commitIntermediate(response)) return false;
-  if (hasContent) segments.record(response.content);
+  if (hasContent) segments.record(response.content, { committed: true });
   state.providerContinuationCount += 1;
   state.continuationsSinceToolBatch += 1;
   state.emptyNudgeStreak = 0;

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn/diagnostic.mjs

@@ -1,8 +1,2 @@
 // stderr diagnostics for the no-tool recovery ladders; never throws.
-export function writeLoopDiagnostic(line) {
-  try {
-    process.stderr.write(line);
-  } catch {
-    /* diagnostics only */
-  }
-}
+export { writeStderrBestEffort as writeLoopDiagnostic } from '../../../../../shared/best-effort-stderr.mjs';

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn/refusal.mjs

@@ -15,7 +15,7 @@ export function resolveRefusal(response, hasContent, { state, segments, messages
   // A provider may emit harmless narration before its safety classifier
   // terminates the turn. Preserve that partial turn and its stop reason,
   // but never mistake the non-empty text for a successful completion.
-  if (hasContent && segments.commitIntermediate(response)) segments.record(response.content);
+  if (hasContent && segments.commitIntermediate(response)) segments.record(response.content, { committed: true });
   messages.push({
     role: 'user',
     content: REFUSAL_RECOVERY_PROMPT,

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn/segments.mjs

@@ -21,14 +21,15 @@ export function createTurnSegments({ messages, opts, suppressMidTurnText }) {
     // live. A suppressed sub-agent session neither surfaces nor accumulates
     // text — except on the max-output ladder, whose parts must still rebuild
     // the complete answer the caller receives (keepWhenSuppressed).
-    record(text, { keepWhenSuppressed = false } = {}) {
+    // `committed: true` marks text that is the just-committed message's own.
+    record(text, { keepWhenSuppressed = false, committed = false } = {}) {
       if (suppressMidTurnText) {
         if (keepWhenSuppressed) parts.push(text);
         return;
       }
       parts.push(text);
       try {
-        opts.onAssistantText?.(text);
+        opts.onAssistantText?.(text, { committed });
       } catch {
         /* best-effort */
       }

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn.mjs

@@ -108,7 +108,8 @@ export function createNoToolTurnResolver({
         drainSteering('terminal', {
           maxPriority: 'next',
           beforeAppend: () => {
-            if (segments.commitIntermediate(response) && hasContent) segments.record(response.content);
+            if (segments.commitIntermediate(response) && hasContent)
+              segments.record(response.content, { committed: true });
           },
         })
       ) {

package/src/runtime/agent/orchestrator/session/loop/send-phase.mjs

@@ -375,6 +375,7 @@ export function settleSendResult(state, round, sent) {
             model: response.model || model,
             usage: reportedUsage,
             sendTools: round.sendTools,
+            toolCalls: response.toolCalls?.length || 0,
           })
         )
       );