@animalabs/agent-framework 0.22.4 → 0.23.1

package/src/modules/workspace/types.ts

@@ -45,7 +45,16 @@ export interface MountConfig {
    * `^\..+\.sw[px]$`, `~$` and `\.subl.*\.tmp$`.
    */
   ignore?: string[];
-  /** Whether to follow symlinks (default: false) */
+  /**
+   * Whether to follow symlinks (default: false). Without it, no symlink on a
+   * path is followed: not one at the path itself, and not one among the
+   * directories on its way beneath the mount's root, wherever it leads. A path
+   * with a symlink among its directories is refused naming the link, and for
+   * a link inside the mount, its target. A mount root that is
+   * itself a symlink is still the root. With it, a symlink on a path is
+   * followed while what it reaches stays inside the mount. Either way, a
+   * listing or a sync's walk descends into no symlinked directory.
+   */
   followSymlinks?: boolean;
   /** Maximum file size in bytes (default: 5MB) */
   maxFileSize?: number;

package/src/modules/workspace/watcher.ts

@@ -6,8 +6,8 @@
  */
 
 import { watch, type FSWatcher } from 'chokidar';
-import { mkdirSync, statSync } from 'node:fs';
-import { basename, sep } from 'node:path';
+import { closeSync, constants, fstatSync, mkdirSync, openSync, statSync, type Stats } from 'node:fs';
+import { basename, resolve, sep } from 'node:path';
 import { passedOverAt } from './observe.js';
 import { type MountConfig } from './types.js';
 
@@ -43,6 +43,8 @@ interface RootIdentity {
   birthtimeMs: number;
 }
 
+const identityOf = (stat: Stats): RootIdentity => ({ dev: stat.dev, ino: stat.ino, birthtimeMs: stat.birthtimeMs });
+
 /**
  * Manages filesystem watching for a single mount.
  * Handles debouncing, ignore patterns, and write suppression.
@@ -58,11 +60,20 @@ export class MountWatcher {
   private suppressedPaths = new Set<string>();
   private suppressionTimers = new Map<string, ReturnType<typeof setTimeout>>();
   private rootIdentity: RootIdentity | null = null;
+  // The root as last attached, held open on Linux (see holdRoot).
+  private rootFd: number | null = null;
   private detached = false;
   private attaching = false;
   private stopped = true;
   private readonly debounceMs: number;
   private readonly config: MountConfig;
+  /**
+   * The root as the watcher makes, holds, watches and checks it, and as each
+   * event's path is read against: the configured path resolved (a link in it
+   * kept), since chokidar hands back the paths it reports normalized, and
+   * those of a root configured as `./m` matched none of them.
+   */
+  private readonly root: string;
   private readonly onChangeCallback: (changes: FsChange[]) => void;
   private readonly lifecycle: WatcherLifecycle;
 
@@ -74,6 +85,7 @@ export class MountWatcher {
     private readonly others: readonly string[] = [],
   ) {
     this.config = config;
+    this.root = resolve(config.path);
     this.debounceMs = config.watchDebounceMs ?? 300;
     this.onChangeCallback = onChange;
     this.lifecycle = lifecycle;
@@ -100,7 +112,7 @@ export class MountWatcher {
     // directories a user asked us only to read would be surprising.
     if (this.config.mode === 'read-write') {
       try {
-        mkdirSync(this.config.path, { recursive: true });
+        mkdirSync(this.root, { recursive: true });
       } catch (err) {
         this.lifecycle.onError?.(err instanceof Error ? err : new Error(String(err)));
       }
@@ -108,7 +120,7 @@ export class MountWatcher {
 
     const ignore = this.config.ignore ?? [];
 
-    this.watcher = watch(this.config.path, {
+    this.watcher = watch(this.root, {
       // What a walk passes over by design, by the path relative to the mount:
       // another mount's directory, the mount's ignore list and editors' swap
       // and backup files. chokidar 4
@@ -165,13 +177,19 @@ export class MountWatcher {
     this.watcher.on('error', (err) => {
       this.reportError(err);
     });
-    this.watcher.on('raw', (event: string, rawPath: string, _details: unknown) => {
-      if (event !== 'rename') return;
-      // A rename on the watched root's path/basename is the one signal that
-      // survives inode reuse on Linux, where unlinkDir/error never fire.
-      if (this.isRootPath(rawPath) || basename(rawPath) === basename(this.config.path)) {
-        void this.checkRootLiveness({ force: true });
-      }
+    this.watcher.on('raw', (event: string, rawPath: string | null) => {
+      // libuv reports the root's own move as a rename under the root's name,
+      // and its removal too once nothing holds it open. An entry beneath the
+      // root with that name comes the same way, as does, on macOS, an
+      // FSEvents event for the root that carries no modification flags, such
+      // as its making just before the watch. A held root tells these apart
+      // (checkRootLiveness), so the rename runs the check at once. A root
+      // that isn't held can be made again with the removed one's identity,
+      // so there the rename forces a re-attach. A rename without a name, as
+      // libuv gives for a file whose path it can't read, is passed over.
+      if (event !== 'rename' || typeof rawPath !== 'string') return;
+      if (basename(rawPath) !== basename(this.root)) return;
+      void this.checkRootLiveness({ force: this.rootFd === null });
     });
 
     this.captureRootIdentity();
@@ -196,6 +214,8 @@ export class MountWatcher {
     this.suppressionTimers.clear();
     this.suppressedPaths.clear();
     this.pendingChanges.clear();
+    // Before the close, so a close that fails still lets go of the root.
+    this.releaseRoot();
 
     if (this.watcher) {
       await this.watcher.close();
@@ -291,6 +311,15 @@ export class MountWatcher {
     this.rootPollTimer.unref();
   }
 
+  /**
+   * Whether the root is still the directory the watcher attached to, checked
+   * every `watchRootPollMs` and at a rename under the root's name. A root
+   * replaced at its path, or whose held directory has been removed, is
+   * attached to again, and with `force` so is one that looks unchanged. A
+   * root that's gone is let go of: a read-write mount makes it again and
+   * attaches to it, and a read-only one waits, detached, until a check finds
+   * it back.
+   */
   private async checkRootLiveness(opts: { force?: boolean } = {}): Promise<void> {
     if (this.stopped || this.attaching) return;
 
@@ -298,8 +327,10 @@ export class MountWatcher {
     try {
       current = this.readRootIdentity();
     } catch (err) {
-      if (this.isErrno(err, 'ENOENT')) {
+      // A held root that has been removed is gone, whatever the path's error.
+      if (this.isErrno(err, 'ENOENT') || this.heldRootRemoved()) {
         this.detached = true;
+        this.releaseRoot();
         if (this.config.mode === 'read-write') {
           await this.reattach();
         }
@@ -319,7 +350,7 @@ export class MountWatcher {
     }
 
     if (!opts.force && !this.detached && this.rootIdentity
-      && this.sameIdentity(current, this.rootIdentity)) {
+      && this.sameIdentity(current, this.rootIdentity) && !this.heldRootRemoved()) {
       return;
     }
 
@@ -333,8 +364,15 @@ export class MountWatcher {
     try {
       const oldWatcher = this.watcher;
       this.watcher = null;
+      this.releaseRoot();
       if (oldWatcher) {
-        await oldWatcher.close();
+        try {
+          await oldWatcher.close();
+        } catch (err) {
+          // chokidar removes its listeners before it closes, so the old
+          // instance reports nothing more, and the root is attached to again.
+          this.reportError(err);
+        }
       }
       if (this.stopped) return;
 
@@ -351,9 +389,11 @@ export class MountWatcher {
 
   private captureRootIdentity(): void {
     try {
-      this.rootIdentity = this.readRootIdentity();
+      this.rootIdentity = this.holdRoot();
       this.detached = false;
     } catch (err) {
+      // What holdRoot opened before it failed isn't held.
+      this.releaseRoot();
       if (this.isErrno(err, 'ENOENT')) {
         this.rootIdentity = null;
         this.detached = true;
@@ -365,14 +405,79 @@ export class MountWatcher {
     }
   }
 
+  /**
+   * The root's identity, with the root held open on Linux until the watcher
+   * lets go of it: at a re-attach, when the root is found gone, or at the
+   * stop. The held directory then says itself whether it has been removed
+   * (heldRootRemoved). A removed directory's inode number can otherwise go
+   * to the next directory made, as ext4 gives it, and one held open isn't
+   * given out. Elsewhere, or where the root can't be opened as a directory,
+   * as without read permission, at the process's file limit or when the
+   * path isn't a directory, it isn't held, and its identity is read from its
+   * path. So too where the root's link count reads 0 as it's opened: if
+   * that's the file system's count for a directory in place, a later check
+   * would take the root for removed and re-attach at every poll.
+   */
+  private holdRoot(): RootIdentity {
+    if (process.platform !== 'linux') return this.readRootIdentity();
+    let fd: number;
+    try {
+      // A directory only, so a FIFO at the path fails at once rather than
+      // blocking until a writer opens it.
+      fd = openSync(this.root, constants.O_RDONLY | constants.O_DIRECTORY);
+    } catch {
+      return this.readRootIdentity();
+    }
+    this.rootFd = fd;
+    const stats = fstatSync(fd);
+    if (stats.nlink === 0) {
+      this.releaseRoot();
+      return this.readRootIdentity();
+    }
+    return identityOf(stats);
+  }
+
+  /**
+   * Whether the directory the watcher holds has been removed, which its link
+   * count says whatever has since been made at its path. On a file system
+   * whose inode numbers a server gives out, the hold can't keep a root made
+   * again from taking the removed one's number, and a removal by another
+   * client shows once this one revalidates the directory's cached
+   * attributes. A held directory that can't be read, as a stale one on a
+   * network file system, counts as removed.
+   */
+  private heldRootRemoved(): boolean {
+    if (this.rootFd === null) return false;
+    try {
+      return fstatSync(this.rootFd).nlink === 0;
+    } catch {
+      return true;
+    }
+  }
+
+  private releaseRoot(): void {
+    if (this.rootFd === null) return;
+    const fd = this.rootFd;
+    this.rootFd = null;
+    try {
+      closeSync(fd);
+    } catch (err) {
+      // Linux frees the descriptor whatever close returns, so the error is
+      // reported and what called this goes on.
+      this.reportError(err);
+    }
+  }
+
   private readRootIdentity(): RootIdentity {
-    const stat = statSync(this.config.path);
-    return { dev: stat.dev, ino: stat.ino, birthtimeMs: stat.birthtimeMs };
+    return identityOf(statSync(this.root));
   }
 
   private sameIdentity(a: RootIdentity, b: RootIdentity): boolean {
-    // birthtimeMs is only a secondary tripwire: sub-millisecond replacements
-    // can reuse both the inode and timestamp, so raw rename remains essential.
+    // birthtimeMs tells a root made again from a removed one whose inode
+    // number it took, unless both were made within one tick of the clock or
+    // the file system keeps no birth time. A held root's removal shows in its
+    // link count instead, and where the root isn't held the rename's force
+    // covers those.
     return a.dev === b.dev && a.ino === b.ino && a.birthtimeMs === b.birthtimeMs;
   }
 
@@ -389,9 +494,7 @@ export class MountWatcher {
     // Chokidar hands back platform-separated absolute paths; compare with
     // the platform separator and normalize the result to the '/'-separated
     // logical form the rest of the workspace uses. No-op on POSIX.
-    const base = this.config.path.endsWith(sep)
-      ? this.config.path
-      : this.config.path + sep;
+    const base = this.root.endsWith(sep) ? this.root : this.root + sep;
     if (absolutePath.startsWith(base)) {
       return absolutePath.slice(base.length).split(sep).join('/');
     }
@@ -399,9 +502,7 @@ export class MountWatcher {
   }
 
   private isRootPath(absolutePath: string): boolean {
-    const root = this.config.path.endsWith(sep)
-      ? this.config.path.slice(0, -1)
-      : this.config.path;
+    const root = this.root.endsWith(sep) ? this.root.slice(0, -1) : this.root;
     const candidate = absolutePath.endsWith(sep)
       ? absolutePath.slice(0, -1)
       : absolutePath;

package/src/silent-heartbeat.ts

@@ -1,40 +1,70 @@
 /**
- * Stored-row handling for silent heartbeat ticks.
+ * Request-only rows: user turns a request carries before a stored response
+ * that the store never holds, rendered again by every later compile.
  *
- * A silent tick stores no prompt row (#216): its reply is written straight
- * after whatever the window held before it — often the previous assistant
- * message, since a suppressed tick leaves no delivery receipt behind. The
- * wire formatter merges consecutive same-role messages, so without a turn
- * between them the tick would read as an unprompted continuation of the
- * earlier response and one assistant message would carry signed thinking
- * from two separate responses (a provider 400 when it is the latest
- * assistant message; see `Agent.addAssistantResponse`).
+ * Two kinds exist, and both are anchored to the response they prompted:
  *
- * Every row a tick writes is therefore stamped with `metadata.silentHeartbeat`
- * and, at request-build time only, a terse user turn is rendered immediately
- * before the first of the tick's rows that survives compilation. The
- * separator is never stored and its position is a function of the stamped
- * rows alone, so every compile renders it in the same place (the tick's own
- * request ends on the same turn), which keeps the prompt-cache prefix
- * stable — unlike a per-compile injection that re-anchors to the newest user
- * message.
+ * - A silent heartbeat tick stores no prompt row (#216): its reply is written
+ *   straight after whatever the window held before it — often the previous
+ *   assistant message, since a suppressed tick leaves no delivery receipt
+ *   behind. Every row a tick writes is stamped with `metadata.silentHeartbeat`,
+ *   and a separator carrying the tick's instruction is rendered before the
+ *   first of the tick's rows that survives compilation.
+ * - A compile that ends on the agent's own message gets a trailing
+ *   `[Continue]` turn (some models reject a trailing assistant message). The
+ *   reply it prompts is stored straight after that message, so the reply's
+ *   rows are stamped `metadata.promptedBy` (`RequestOnlyPrompt`), and the turn
+ *   is rendered before the first of them that survives. A reply follows the
+ *   prompt when what it was sent ends on that `[Continue]`, or on the tool
+ *   results of a reply that followed it (`toolLoopPrompt`): a stream start
+ *   and each round of a stream alike. A reply sent anything else after the
+ *   results (a message that arrived meanwhile) follows that, and carries no
+ *   prompt.
+ *
+ * Without the row, the wire formatter merges consecutive same-role messages:
+ * the reply would read as an unprompted continuation of the earlier response,
+ * and one assistant message would carry signed thinking from two separate
+ * responses (a provider 400 when it is the latest assistant message; see
+ * `Agent.addAssistantResponse`). And the request that minted the reply held
+ * the row: a provider that binds signed thinking to the prefix it was minted
+ * under (context-manager #155) refuses that thinking once a later request
+ * drops it. Each row's text is read from the stamp (what the request that
+ * minted the reply rendered, so a later change to the constant changes no
+ * stored reply's prefix) and its position is a function of the stamped rows
+ * alone, so every compile renders it in the same place (the request that
+ * minted the reply ends on that same turn), which keeps the prompt-cache
+ * prefix and the binding stable — unlike a per-compile injection that
+ * re-anchors to the newest user message, or a system prompt that changes for
+ * one turn.
  *
  * Known limit: compiled messages carry no store provenance, so a stored row
  * is recognised only by structural identity the provider made unique
- * (tool_use ids, thinking signatures). A tick reply with neither — unsigned
- * and tool-free — gets no separator and still merges as before. Without
- * signed thinking that merge carries no provider-rejection risk; it is only
- * a misreading. Reply text is deliberately never used as identity: identical
- * replies ("all quiet") would collide, and an ordinary reply with the same
- * text could take a tick's separator and rewrite cached history. Exact
- * matching for every row would need the compile result to expose each
- * message's source rows.
+ * (tool_use ids, thinking signatures). A reply with neither — unsigned and
+ * tool-free — gets no row and still merges as before. Without signed thinking
+ * that merge carries no provider-rejection risk; it is only a misreading.
+ * Reply text is deliberately never used as identity: identical replies ("all
+ * quiet") would collide, and an ordinary reply with the same text could take
+ * another reply's row and rewrite cached history. Exact matching for every
+ * row would need the compile result to expose each message's source rows.
  */
 import type { ContentBlock, NormalizedMessage } from '@animalabs/membrane';
 
-/** Request-only separator text. Constant on purpose: it carries no time or
- * id, so it is byte-identical on every compile. */
-export const SILENT_HEARTBEAT_SEPARATOR = '[heartbeat tick]';
+/** Request-only separator a silent tick's request ends on. It carries the
+ * tick's instruction, so the tick's own request reads it as its prompt, and
+ * every later compile renders it again before the tick's first surviving row.
+ * Constant on purpose: it carries no time or id. Each tick's rows record the
+ * text their request rendered (`SilentHeartbeatStamp.separator`), so changing
+ * this constant changes only ticks that open afterwards. */
+export const SILENT_HEARTBEAT_SEPARATOR =
+  '[silent heartbeat] Scheduled private self-check. Review pending matters privately. ' +
+  'Do not narrate or publish plain prose; use an explicit send tool only if you deliberately choose to contact someone.';
+
+/** The separator ticks rendered before their rows recorded its text: rows
+ * stamped without `separator` still render it, byte for byte. */
+const LEGACY_SILENT_HEARTBEAT_SEPARATOR = '[heartbeat tick]';
+
+/** Request-only turn a compile that ends on the agent's own message gets. */
+export const CONTINUE_ROW = '[Continue]';
 
 /** Identity of one authenticated silent heartbeat tick. */
 export interface SilentHeartbeatTick {
@@ -50,20 +80,63 @@ export interface SilentHeartbeatTick {
  * (tool_result rows are stored as `user`). */
 export interface SilentHeartbeatStamp extends SilentHeartbeatTick {
   agentName: string;
+  /** The separator text the tick's request rendered, which later compiles
+   * render again. Absent on rows stamped before it was recorded; they render
+   * the bare marker those requests carried. */
+  separator?: string;
+}
+
+/** One tick's key in an index or a rendered window: the server and its event
+ * id together, since two servers' events can share an id. */
+export function tickKey(tick: SilentHeartbeatTick): string {
+  return JSON.stringify([tick.serverId, tick.eventId]);
 }
 
 /** The tick stamp on a stored row's metadata, if any. */
 export function silentHeartbeatOf(metadata: unknown): SilentHeartbeatStamp | undefined {
   const stamp = (metadata as { silentHeartbeat?: unknown } | undefined)?.silentHeartbeat;
   if (!stamp || typeof stamp !== 'object') return undefined;
-  const { eventId, serverId, agentName } = stamp as Record<string, unknown>;
+  const { eventId, serverId, agentName, separator } = stamp as Record<string, unknown>;
   return typeof eventId === 'string' && typeof serverId === 'string' && typeof agentName === 'string'
-    ? { eventId, serverId, agentName }
+    ? { eventId, serverId, agentName, ...(typeof separator === 'string' ? { separator } : {}) }
     : undefined;
 }
 
+/** A request-only turn a request ended on before the agent's reply, as
+ * `metadata.promptedBy` on the rows of each reply that follows it: `turn`
+ * names the one prompt, and `text` is what the request rendered. */
+export interface RequestOnlyPrompt {
+  turn: string;
+  text: string;
+}
+
+/** The stamps on a row a turn stores after a request-only turn
+ * (`silentHeartbeatOf`, `promptedByOf` read them back). A type alias, so a
+ * value fits `MessageMetadata`'s index signature without a cast, and a
+ * misspelled key fails to compile. */
+export type RequestOnlyStamps = {
+  silentHeartbeat?: SilentHeartbeatStamp;
+  promptedBy?: RequestOnlyPrompt;
+};
+
+/** The request-only prompt a stored row replies to, if any. */
+export function promptedByOf(metadata: unknown): RequestOnlyPrompt | undefined {
+  const prompt = (metadata as { promptedBy?: unknown } | undefined)?.promptedBy;
+  if (!prompt || typeof prompt !== 'object') return undefined;
+  const { turn, text } = prompt as Record<string, unknown>;
+  return typeof turn === 'string' && typeof text === 'string' ? { turn, text } : undefined;
+}
+
 export function silentHeartbeatSeparatorTurn(): NormalizedMessage {
-  return { participant: 'user', content: [{ type: 'text', text: SILENT_HEARTBEAT_SEPARATOR }] };
+  return requestOnlyTurn(SILENT_HEARTBEAT_SEPARATOR);
+}
+
+export function continueTurn(): NormalizedMessage {
+  return requestOnlyTurn(CONTINUE_ROW);
+}
+
+function requestOnlyTurn(text: string): NormalizedMessage {
+  return { participant: 'user', content: [{ type: 'text', text }] };
 }
 
 /**
@@ -76,7 +149,7 @@ export function silentHeartbeatSeparatorTurn(): NormalizedMessage {
 function identityKeys(content: ContentBlock[]): string[] {
   const keys: string[] = [];
   for (const block of content) {
-    if (block.type === 'tool_use' && typeof block.id === 'string' && block.id) keys.push(`tool_use:${block.id}`);
+    if (block.type === 'tool_use' && typeof block.id === 'string' && block.id) keys.push(toolUseKey(block.id));
     else if (block.type === 'thinking' && typeof block.signature === 'string' && block.signature) {
       keys.push(`thinking:${block.signature}`);
     } else if (block.type === 'redacted_thinking' && typeof block.data === 'string' && block.data) {
@@ -86,56 +159,108 @@ function identityKeys(content: ContentBlock[]): string[] {
   return keys;
 }
 
+function toolUseKey(id: string): string {
+  return `tool_use:${id}`;
+}
+
 export interface StoredRowLike {
   participant: string;
   content: ContentBlock[];
   metadata?: unknown;
 }
 
-export interface SilentTickIndex {
-  /** Identity key of every assistant row this agent stored during a tick → tick event id. */
-  rows: Map<string, string>;
-  /** Ticks this agent has already stored rows for (its own, not another resident's). */
-  started: Set<string>;
+export interface RequestOnlyRowIndex {
+  /** Identity key of every assistant row this agent stored during a silent
+   *  tick → the tick (`tickKey`), and the separator text to render before
+   *  its first surviving row. */
+  ticks: Map<string, { tick: string; text: string }>;
+  /** Identity key of every assistant row this agent stored in reply to a
+   *  request-only prompt → that prompt. */
+  prompts: Map<string, RequestOnlyPrompt>;
 }
 
-/** Index the rows this agent stored during silent ticks. */
-export function indexSilentTickRows(stored: readonly StoredRowLike[], agentName: string): SilentTickIndex {
-  const rows = new Map<string, string>();
-  const started = new Set<string>();
+/** Index the agent's own rows that follow request-only turns: the rows of its
+ * silent ticks, and the rows of each reply to a `[Continue]`. The two are
+ * independent, so a row can be both. Only stamped rows are keyed, so an
+ * agent's history walk costs a metadata read per row. */
+export function indexRequestOnlyRows(stored: readonly StoredRowLike[], agentName: string): RequestOnlyRowIndex {
+  const ticks = new Map<string, { tick: string; text: string }>();
+  const prompts = new Map<string, RequestOnlyPrompt>();
   for (const row of stored) {
-    const stamp = silentHeartbeatOf(row.metadata);
-    if (!stamp || stamp.agentName !== agentName) continue;
-    started.add(stamp.eventId);
     if (row.participant !== agentName) continue;
-    for (const key of identityKeys(row.content)) rows.set(key, stamp.eventId);
+    const stamp = silentHeartbeatOf(row.metadata);
+    const ownTick = stamp !== undefined && stamp.agentName === agentName;
+    const prompt = promptedByOf(row.metadata);
+    if (!ownTick && !prompt) continue;
+    const keys = identityKeys(row.content);
+    if (ownTick) {
+      const tick = { tick: tickKey(stamp), text: stamp.separator ?? LEGACY_SILENT_HEARTBEAT_SEPARATOR };
+      for (const key of keys) ticks.set(key, tick);
+    }
+    if (prompt) for (const key of keys) prompts.set(key, prompt);
   }
-  return { rows, started };
+  return { ticks, prompts };
 }
 
 /**
- * Insert the separator turn immediately before the first surviving row of
- * each tick in a compiled window — the tick's first row when it is rendered,
- * otherwise whichever later row a strategy kept. Rows folded into summaries
+ * The prompt a reply continues when what it is sent ends on `last`: if
+ * `last` holds tool results, the prompt of the reply that called those tools
+ * (this reply continues that reply's tool loop); otherwise none. Read from
+ * the stored stamps, so it doesn't depend on anything held in memory. A
+ * request that ends on its own `[Continue]` mints a new prompt instead.
+ */
+export function toolLoopPrompt(
+  last: NormalizedMessage | undefined,
+  index: RequestOnlyRowIndex,
+): RequestOnlyPrompt | undefined {
+  if (!last) return undefined;
+  for (const block of last.content) {
+    if (block.type !== 'tool_result') continue;
+    const prompt = index.prompts.get(toolUseKey(block.toolUseId));
+    if (prompt) return prompt;
+  }
+  return undefined;
+}
+
+export interface RenderedRequestOnlyRows {
+  messages: NormalizedMessage[];
+  /** The ticks (`tickKey`) whose separator this window renders. A tick none
+   *  of whose rows survive compilation renders none. */
+  separatedTicks: Set<string>;
+}
+
+/**
+ * Insert the request-only turns into a compiled window, each immediately
+ * before the first of its rows that survives compilation (the first row when
+ * it is rendered, otherwise whichever later row a strategy kept): a tick's
+ * separator, and the prompt each reply to `[Continue]` followed, after any
+ * separator, as the reply's request had them. Rows folded into summaries
  * simply do not match; ordinary messages pass through untouched.
  */
-export function separateSilentHeartbeatTicks(
+export function renderRequestOnlyRows(
   messages: NormalizedMessage[],
-  rows: ReadonlyMap<string, string>,
+  index: RequestOnlyRowIndex,
   agentName: string,
-): NormalizedMessage[] {
-  if (rows.size === 0) return messages;
-  const separated = new Set<string>();
+): RenderedRequestOnlyRows {
+  const separatedTicks = new Set<string>();
+  const promptedTurns = new Set<string>();
+  if (index.ticks.size === 0 && index.prompts.size === 0) return { messages, separatedTicks };
   const out: NormalizedMessage[] = [];
   for (const message of messages) {
     if (message.participant === agentName) {
-      const eventId = identityKeys(message.content).map((key) => rows.get(key)).find((id) => id !== undefined);
-      if (eventId !== undefined && !separated.has(eventId)) {
-        separated.add(eventId);
-        out.push(silentHeartbeatSeparatorTurn());
+      const keys = identityKeys(message.content);
+      const tick = keys.map((key) => index.ticks.get(key)).find((t) => t !== undefined);
+      if (tick !== undefined && !separatedTicks.has(tick.tick)) {
+        separatedTicks.add(tick.tick);
+        out.push(requestOnlyTurn(tick.text));
+      }
+      const prompt = keys.map((key) => index.prompts.get(key)).find((p) => p !== undefined);
+      if (prompt !== undefined && !promptedTurns.has(prompt.turn)) {
+        promptedTurns.add(prompt.turn);
+        out.push(requestOnlyTurn(prompt.text));
       }
     }
     out.push(message);
   }
-  return out;
+  return { messages: out, separatedTicks };
 }