@zgeoff/atc 2.13.0 → 2.15.0

package/README.md

@@ -94,7 +94,8 @@ list.
 If the daemon dies, press `R` on the home screen and every session respawns from its transcript.
 After you upgrade atc, the status bar shows `⟳ update ready`, and `u` restarts the daemon and
 restores the fleet when you are ready. The bar shows `⟳ restarting daemon` until the restart
-finishes.
+finishes. When the running daemon speaks another protocol version, `atc` asks before it restarts the
+daemon, since the restart ends every session the daemon hosts.
 
 atc runs inside zellij or tmux. Give the pane locked mode so the leader key reaches atc.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "2.13.0",
+  "version": "2.15.0",
   "description": "Terminal control tower for coding-agent sessions",
   "homepage": "https://github.com/zgeoff/atc#readme",
   "bugs": "https://github.com/zgeoff/atc/issues",

package/src/client/boot-daemon.ts

@@ -4,15 +4,18 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { toAgentID } from '../agents/agent-adapter';
 import type { AgentID } from '../agents/agent-adapter';
+import { DaemonError } from '../protocol/daemon-error';
 import type { DaemonFeature } from '../protocol/daemon-features';
 import { parseDaemonFeatures } from '../protocol/parse-daemon-features';
+import { PROTOCOL_V } from '../protocol/protocol';
 import { daemonPidFile, daemonRecordFile, daemonSocketPath } from '../shared/config';
 import { findDaemonRecord } from '../shared/find-daemon-record';
 import { getBuild } from '../shared/get-build';
 import { isCompiledBinary } from '../shared/is-compiled-binary';
 import { makeSingleFlight } from '../shared/make-single-flight';
-import { isRecord } from '../shared/report';
 import { DaemonClient } from './daemon-client';
+import { formatProtocolMismatch } from './format-protocol-mismatch';
+import type { ProtocolMismatch } from './format-protocol-mismatch';
 import { pickStaleDaemonPID } from './pick-stale-daemon-pid';
 
 export interface DaemonBoot {
@@ -28,18 +31,28 @@ export interface DaemonBoot {
   readonly socketPath: string;
 }
 
+export interface DaemonBootOptions {
+  // Called when the daemon speaks another protocol version. Resolving true
+  // stops that daemon and boots one from this build, which ends every
+  // session it hosts; without the callback, or resolving false, the boot
+  // rejects and the daemon keeps running.
+  readonly onProtocolMismatch?: (mismatch: ProtocolMismatch) => Promise<boolean>;
+}
+
 /**
  * Opens a handshaken client to the daemon, booting the daemon first when
  * neither the computed socket nor the one in the daemon's record answers.
- * Overlapping calls in one process share a single boot. A daemon from an older build stays in service — killing
- * it would kill every hosted session — and is reported as stale so the
- * caller can offer a deliberate restart. Only a protocol mismatch, where
- * talking would misbehave, forces the restart immediately. The expected
- * build is read from disk on every attempt: a long-lived caller holding a
- * build string from its own boot would otherwise flag daemons that are
- * already current.
+ * Overlapping calls in one process share a single boot. A daemon from an
+ * older build stays in service, since stopping it would end every hosted
+ * session, and is reported as stale so the caller can offer a deliberate
+ * restart. A daemon on another protocol version stays in service too: the
+ * boot rejects with `protocol_mismatch` and a message holding both builds,
+ * both versions, and the way to restart it, unless the caller's
+ * `onProtocolMismatch` confirms a restart. The expected build is read from
+ * disk on every attempt: a long-lived caller holding a build string from
+ * its own boot would otherwise flag daemons that are already current.
  */
-export async function bootDaemonClient(): Promise<DaemonBoot> {
+export async function bootDaemonClient(options: DaemonBootOptions = {}): Promise<DaemonBoot> {
   for (let attempt = 0; attempt < 2; attempt++) {
     const build = getBuild();
 
@@ -60,21 +73,35 @@ export async function bootDaemonClient(): Promise<DaemonBoot> {
     } catch (error) {
       client.stop();
 
-      if (attempt > 0 || !isProtocolMismatch(error)) {
+      if (attempt > 0 || !(error instanceof DaemonError) || error.code !== 'protocol_mismatch') {
         throw error;
       }
 
-      await stopStaleDaemon(opened.socketPath);
+      const mismatch: ProtocolMismatch = {
+        socketPath: opened.socketPath,
+        daemonPID: findDaemonPID(opened.socketPath),
+        clientBuild: build,
+        clientProtocol: PROTOCOL_V,
+        daemonMessage: error.message,
+      };
+
+      // Without a pid there is no daemon this client could stop, so the
+      // caller is not asked.
+      if (
+        mismatch.daemonPID === null ||
+        options.onProtocolMismatch === undefined ||
+        !(await options.onProtocolMismatch(mismatch))
+      ) {
+        throw new DaemonError('protocol_mismatch', formatProtocolMismatch(mismatch));
+      }
+
+      await stopDaemon(mismatch.daemonPID);
     }
   }
 
   throw new Error('the atc daemon could not be restarted');
 }
 
-function isProtocolMismatch(error: unknown): boolean {
-  return isRecord(error) && error['code'] === 'protocol_mismatch';
-}
-
 interface OpenedDaemon {
   readonly client: DaemonClient;
   readonly socketPath: string;
@@ -177,18 +204,17 @@ function isProcessAlive(pid: number): boolean {
   }
 }
 
-async function stopStaleDaemon(socketPath: string): Promise<void> {
-  const pid = pickStaleDaemonPID({
+// The pid of the daemon behind the socket that refused the handshake.
+function findDaemonPID(socketPath: string): number | null {
+  return pickStaleDaemonPID({
     socketPath,
     record: findDaemonRecord(daemonRecordFile),
     pidFileSocketPath: daemonSocketPath,
     pidFilePID: findPidFilePID(),
   });
+}
 
-  if (pid === null) {
-    return;
-  }
-
+async function stopDaemon(pid: number): Promise<void> {
   try {
     process.kill(pid, 'SIGTERM');
   } catch {

package/src/client/daemon-client.ts

@@ -1,4 +1,5 @@
 import { DaemonError } from '../protocol/daemon-error';
+import { LineDecoder } from '../protocol/line-decoder';
 import { OutboundQueue } from '../protocol/outbound-queue';
 import { PROTOCOL_V, decodeMessage, encodeMessage } from '../protocol/protocol';
 import type { EventMsg, ResponseMsg } from '../protocol/protocol';
@@ -20,9 +21,7 @@ export class DaemonClient {
 
   private queue: OutboundQueue | null = null;
 
-  private buffer = '';
-
-  private readonly decoder = new TextDecoder();
+  private readonly lines = new LineDecoder();
 
   private nextID = 1;
 
@@ -41,7 +40,7 @@ export class DaemonClient {
       unix: socketPath,
       socket: {
         data(_s, buf) {
-          client.applyChunk(client.decodeChunk(buf));
+          client.applyChunk(buf);
         },
         drain() {
           client.queue?.drain();
@@ -99,25 +98,9 @@ export class DaemonClient {
     this.drainPending('client closed');
   }
 
-  // Decodes with state kept across reads, so a multi-byte character split
-  // between two reads decodes whole.
   // oxlint-disable-next-line prefer-readonly-parameter-types -- a socket read buffer has no readonly form
-  private decodeChunk(buf: Uint8Array): string {
-    return this.decoder.decode(buf, { stream: true });
-  }
-
-  private applyChunk(chunk: string): void {
-    this.buffer += chunk;
-
-    const lines = this.buffer.split('\n');
-
-    this.buffer = lines.pop() ?? '';
-
-    for (const line of lines) {
-      if (line.trim() === '') {
-        continue;
-      }
-
+  private applyChunk(buf: Uint8Array): void {
+    for (const line of this.lines.splitChunk(buf)) {
       this.applyLine(line);
     }
   }

package/src/client/format-protocol-mismatch.ts

@@ -0,0 +1,37 @@
+// A daemon that refused this client's handshake because it speaks another
+// protocol version.
+export interface ProtocolMismatch {
+  readonly socketPath: string;
+
+  // The daemon's pid from its record or pid file, or null when neither
+  // belongs to the socket that refused.
+  readonly daemonPID: number | null;
+
+  readonly clientBuild: string;
+  readonly clientProtocol: number;
+
+  // The daemon's own refusal, which holds its build and protocol version.
+  readonly daemonMessage: string;
+}
+
+/**
+ * Describes a daemon on another protocol version: both builds and both
+ * versions, that it was left running, and how to restart it on purpose.
+ */
+export function formatProtocolMismatch(mismatch: ProtocolMismatch): string {
+  const pid = mismatch.daemonPID === null ? 'pid unknown' : `pid ${mismatch.daemonPID}`;
+
+  // Without a pid the TUI cannot stop the daemon either, so the restart is
+  // left to the user.
+  const restart =
+    mismatch.daemonPID === null
+      ? `To restart it, find its pid with \`ss -xlp | grep ${mismatch.socketPath}\` on Linux or \`lsof -U | grep ${mismatch.socketPath}\` on macOS, stop that process, and run \`atc\` again: every hosted session ends, and \`R\` respawns them from their transcripts.`
+      : 'To restart it, run `atc` from the build you want and confirm its restart prompt: every hosted session ends, and the fleet is restored on the new daemon.';
+
+  return [
+    `the atc daemon (${pid}, socket ${mismatch.socketPath}) speaks another protocol than this client, ${mismatch.clientBuild} on protocol v${mismatch.clientProtocol}.`,
+    `The daemon answered: ${mismatch.daemonMessage}`,
+    'It was left running, so the sessions it hosts keep running.',
+    restart,
+  ].join('\n');
+}

package/src/client/index.ts

@@ -10,6 +10,7 @@ import { bootDaemonClient } from './boot-daemon';
 import { buildClientMachine } from './build-client-machine';
 import { buildLeaderChords } from './build-leader-chords';
 import { findFuzzyScore, formatDir } from './dirs';
+import type { ProtocolMismatch } from './format-protocol-mismatch';
 import { KEY, isDown, isUp, planTextEdit } from './keys';
 import { parseDaemonEvent } from './parse-daemon-event';
 import { pickTabTarget } from './pick-tab-target';
@@ -781,7 +782,17 @@ const service = createActor(
   }),
 );
 
-const boot = await bootDaemonClient();
+// A daemon on another protocol is restarted only when the user confirms
+// it, and the fleet it hosted is then restored on the new one.
+let restartedOnBoot = false;
+
+const boot = await bootDaemonClient({
+  onProtocolMismatch: async (mismatch) => {
+    restartedOnBoot = await waitForRestartConsent(mismatch);
+
+    return restartedOnBoot;
+  },
+});
 
 let client = boot.client;
 let daemonStale = boot.stale;
@@ -790,8 +801,50 @@ let daemonRestarting = false;
 lastUsedAgent = boot.lastUsedAgent;
 client.onEvent = applyDaemonEvent;
 
+if (restartedOnBoot) {
+  await sendQuiet('fleet.restore', { cols: cols(), rows: ptyRows() });
+}
+
 await refreshMirror();
 
+/**
+ * Asks on the terminal whether to restart a daemon that speaks another
+ * protocol, reading a single key. Anything but `y` declines, and so does a
+ * terminal that cannot answer.
+ */
+async function waitForRestartConsent(mismatch: ProtocolMismatch): Promise<boolean> {
+  if (!process.stdin.isTTY) {
+    return false;
+  }
+
+  process.stderr.write(
+    [
+      `atc: the daemon (pid ${mismatch.daemonPID}) speaks another protocol than this client, ${mismatch.clientBuild} on protocol v${mismatch.clientProtocol}.`,
+      `The daemon answered: ${mismatch.daemonMessage}`,
+      'Restart it now? Every session it hosts ends, then the fleet is restored on the new daemon. [y/N] ',
+    ].join('\n'),
+  );
+
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+
+  const key = await new Promise<string>((resolve) => {
+    process.stdin.once('data', (buf: Buffer) => {
+      resolve(buf.toString());
+    });
+  });
+
+  process.stdin.setRawMode(false);
+  process.stdin.pause();
+
+  const confirmed = key === 'y' || key === 'Y';
+  const echo = confirmed ? 'y\n' : 'n\n';
+
+  process.stderr.write(echo);
+
+  return confirmed;
+}
+
 async function refreshMirror() {
   const list = await client.sendRequest('session.list');
 

package/src/daemon/build-imp-provider.ts

@@ -1,9 +1,10 @@
 import { ImpClientPort } from './imp-client-port';
 import { ImpProvider } from './imp-provider';
+import { readImpToken } from './read-imp-token';
 
 /**
  * The provider of an `imp` target, or the problem that keeps it from one.
- * A problem never includes the token or any other environment value.
+ * A problem never includes a token or any other environment value.
  */
 export interface ImpProviderBuild {
   readonly provider: ImpProvider | null;
@@ -12,13 +13,16 @@ export interface ImpProviderBuild {
 
 /**
  * The provider of target `id` from its `imp` options: `url` is where impd
- * listens, and `tokenEnv` holds the name of the daemon's environment
- * variable that carries the token, so no credential sits in the config.
- * `image`, `memoryMib`, `guestDir`, and `guestATC` pass through. No
- * provider when `url` is missing, so the target lists and refuses every
- * spawn. A `tokenEnv` that is not a non-empty string, or whose variable is
- * unset or empty in `env`, is a problem and leaves no provider; a target
- * without `tokenEnv` calls impd with no token.
+ * listens, and at most one of `tokenEnv` and `tokenFile` gives the token,
+ * so no credential sits in the config. `tokenEnv` holds the name of the
+ * daemon's environment variable that carries the token, read once here.
+ * `tokenFile` holds the path of a file that carries it, read here and again
+ * before each impd call and connection. `image`, `memoryMib`, `guestDir`,
+ * and `guestATC` pass through. No provider when `url` is missing, so the
+ * target lists and refuses every spawn. Both token options, either one not
+ * a non-empty string, an unset or empty variable, or an empty or unreadable
+ * file is a problem and leaves no provider; a target without either calls
+ * impd with no token.
  */
 export function buildImpProvider(
   id: string,
@@ -26,29 +30,18 @@ export function buildImpProvider(
   env: Readonly<Record<string, string | undefined>> = process.env,
 ): ImpProviderBuild {
   const url = options['url'];
-  const tokenEnv = options['tokenEnv'];
 
   if (typeof url !== 'string' || url === '') {
     return { provider: null, problem: null };
   }
 
-  if (tokenEnv !== undefined && (typeof tokenEnv !== 'string' || tokenEnv === '')) {
-    return {
-      provider: null,
-      problem: `target ${JSON.stringify(id)} must give tokenEnv as a non-empty string`,
-    };
-  }
-
-  const token = tokenEnv === undefined ? null : env[tokenEnv];
+  const source = loadTokenSource(id, options, env);
 
-  if (token === undefined || token === '') {
-    return {
-      provider: null,
-      problem: `target ${JSON.stringify(id)} reads its impd token from ${String(tokenEnv)}, which is unset or empty in the daemon's environment`,
-    };
+  if (typeof source === 'string') {
+    return { provider: null, problem: source };
   }
 
-  const provider = new ImpProvider(new ImpClientPort({ url, token }), {
+  const provider = new ImpProvider(new ImpClientPort({ url, readToken: source.readToken }), {
     ...pickString(options, 'image'),
     ...pickString(options, 'guestDir'),
     ...pickString(options, 'guestATC'),
@@ -58,6 +51,60 @@ export function buildImpProvider(
   return { provider, problem: null };
 }
 
+// How the port reads the token: a function, so a file token rereads.
+interface TokenSource {
+  readonly readToken: () => string | null;
+}
+
+// The token source the options give, or the problem that keeps the target
+// from one. A problem holds a variable's name or a file's path, never a
+// token.
+function loadTokenSource(
+  id: string,
+  options: Readonly<Record<string, unknown>>,
+  env: Readonly<Record<string, string | undefined>>,
+): TokenSource | string {
+  const tokenEnv = options['tokenEnv'];
+  const tokenFile = options['tokenFile'];
+  const target = JSON.stringify(id);
+
+  if (tokenEnv !== undefined && tokenFile !== undefined) {
+    return `target ${target} must give its impd token through tokenEnv or tokenFile, not both`;
+  }
+
+  if (tokenFile !== undefined) {
+    if (typeof tokenFile !== 'string' || tokenFile === '') {
+      return `target ${target} must give tokenFile as a non-empty string`;
+    }
+
+    try {
+      readImpToken(tokenFile);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+
+      return `target ${target} reads its impd token from a file it cannot use: ${detail}`;
+    }
+
+    return { readToken: () => readImpToken(tokenFile) };
+  }
+
+  if (tokenEnv === undefined) {
+    return { readToken: () => null };
+  }
+
+  if (typeof tokenEnv !== 'string' || tokenEnv === '') {
+    return `target ${target} must give tokenEnv as a non-empty string`;
+  }
+
+  const token = env[tokenEnv];
+
+  if (token === undefined || token === '') {
+    return `target ${target} reads its impd token from ${tokenEnv}, which is unset or empty in the daemon's environment`;
+  }
+
+  return { readToken: () => token };
+}
+
 function pickString(
   options: Readonly<Record<string, unknown>>,
   key: 'image' | 'guestDir' | 'guestATC',

package/src/daemon/build-report-trail-entry.ts

@@ -5,8 +5,9 @@ import type { TrailEntry } from '../store/trail-entry';
 import type { NoteReport } from './parse-report';
 
 /**
- * The trail entry for one note a session reported, carrying its label, a
- * preview of its text, and the id its reporter gave it, when it gave one.
+ * The trail entry for one note a session reported, carrying its label, its
+ * text and a preview of it, and the id its reporter gave it, when it gave
+ * one.
  */
 export function buildReportTrailEntry(
   sessionID: SessionID,
@@ -22,6 +23,7 @@ export function buildReportTrailEntry(
     kind: 'report',
     label: report.label,
     detail: truncateDetail(report.text),
+    text: report.text,
     ...(reportID === undefined ? {} : { reportID }),
   };
 }

package/src/daemon/build-report-view.ts

@@ -0,0 +1,41 @@
+import { encodeCursor } from '../protocol/encode-cursor';
+import type { StoredReport } from '../store/state-store';
+import type { SessionDescriptor } from './sessions';
+
+/**
+ * One report as `report.get` returns it: the cursor of its event, when it
+ * arrived, the session that sent it and that session's name, its label, its
+ * text, and whether that text is whole.
+ */
+export interface ReportView {
+  readonly report: string;
+  readonly at: number;
+  readonly session: string;
+  readonly name: string | null;
+  readonly label: string;
+  readonly text: string;
+  readonly complete: boolean;
+}
+
+export function buildReportView(
+  stored: StoredReport,
+  sessions: readonly SessionDescriptor[],
+): ReportView {
+  // A row written before atc session ids stayed stable across restores
+  // carries an earlier atc id, so the agent session id links it.
+  const live =
+    (stored.agentSessionID === null
+      ? undefined
+      : sessions.find((s) => s.agentSessionID === stored.agentSessionID)) ??
+    sessions.find((s) => s.id === stored.atcID);
+
+  return {
+    report: encodeCursor({ kind: 'events', id: stored.id }),
+    at: stored.at,
+    session: live?.id ?? stored.atcID,
+    name: live?.name ?? null,
+    label: stored.label,
+    text: stored.text,
+    complete: stored.complete,
+  };
+}

package/src/daemon/build-scoped-context.ts

@@ -203,6 +203,11 @@ export function buildScopedContext(
 
       return ctx.readEvents(afterID, limit, waitMs, sessionID, merged);
     },
+    readReport: (id, outer) => {
+      const merged = outer === null ? access : outer.merge(access);
+
+      return ctx.readReport(id, merged);
+    },
     writeSessionMessage: (sessionID, from, text, keyed) =>
       canSee(sessionID)
         ? ctx.writeSessionMessage(sessionID, from, text, buildPrincipalKey(keyed))

package/src/daemon/daemon-connection.ts

@@ -4,6 +4,7 @@ import { DaemonError } from '../protocol/daemon-error';
 import { DAEMON_FEATURES } from '../protocol/daemon-features';
 import { decodeCursor } from '../protocol/decode-cursor';
 import { encodeCursor } from '../protocol/encode-cursor';
+import { LineDecoder } from '../protocol/line-decoder';
 import { OutboundQueue } from '../protocol/outbound-queue';
 import type { SocketWriter } from '../protocol/outbound-queue';
 import { parseRequestParams } from '../protocol/parse-request-params';
@@ -28,6 +29,7 @@ import type { Dims } from './attach-registry';
 import type { AgentEntry } from './build-agent-list';
 import type { FleetEvent } from './build-fleet-events';
 import { buildPayloadHash } from './build-payload-hash';
+import type { ReportView } from './build-report-view';
 import { buildScopedContext } from './build-scoped-context';
 import type { TargetEntry } from './build-target-list';
 import type { KeyedRequest } from './idempotency-ledger';
@@ -189,6 +191,11 @@ export interface DaemonContext {
     access: TargetAccess | null,
   ) => Promise<EventsPage>;
 
+  // One report by the trail id of its event, or null for a trail id that
+  // holds no report, or whose report's session is outside the access when
+  // there is one.
+  readonly readReport: (id: number, access: TargetAccess | null) => Promise<ReportView | null>;
+
   // Answers with the `session.message` ok payload, which a keyed retry
   // replays with the message's current status, or with the refusal.
   readonly writeSessionMessage: (
@@ -272,9 +279,7 @@ export class DaemonConnection {
 
   private readonly queue: OutboundQueue;
 
-  private buffer = '';
-
-  private readonly decoder = new TextDecoder();
+  private readonly lines = new LineDecoder();
 
   private helloed = false;
 
@@ -346,28 +351,18 @@ export class DaemonConnection {
   // between two reads decodes whole.
   // oxlint-disable-next-line prefer-readonly-parameter-types -- a socket read buffer has no readonly form
   decodeChunk(buf: Uint8Array): string {
-    return this.decoder.decode(buf, { stream: true });
+    return this.lines.decodeText(buf);
   }
 
   applyChunk(chunk: string): void {
-    const buffered = this.buffer + chunk;
-
-    if (buffered.length > MAX_LINE) {
+    if (this.lines.pendingLength + chunk.length > MAX_LINE) {
       this.sendErr(0, 'bad_args', `line exceeds ${MAX_LINE} bytes`);
       this.peer.end();
 
       return;
     }
 
-    const lines = buffered.split('\n');
-
-    this.buffer = lines.pop() ?? '';
-
-    for (const line of lines) {
-      if (line.trim() === '') {
-        continue;
-      }
-
+    for (const line of this.lines.splitText(chunk)) {
       if (!this.applyLine(line)) {
         this.peer.end();
 
@@ -799,6 +794,11 @@ export class DaemonConnection {
 
         return;
       }
+      case 'report.get': {
+        await this.applyReportGet(req, ctx);
+
+        return;
+      }
       default: {
         this.sendErr(req.id, 'unknown_method', `unknown method '${req.m}'`);
       }
@@ -1150,6 +1150,32 @@ export class DaemonConnection {
     });
   }
 
+  // A cursor that is not an events cursor, one at a row that holds no
+  // report, and one at a report outside the access all get one refusal, so
+  // the refusal is the same for a report out of reach and a missing one.
+  private async applyReportGet(req: RequestMsg, ctx: DaemonContext): Promise<void> {
+    const parsed = parseRequestParams('report.get', req.p);
+
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
+
+      return;
+    }
+
+    const decoded = decodeCursor(parsed.data.report);
+
+    const view =
+      decoded === null || decoded.kind !== 'events' ? null : await ctx.readReport(decoded.id, null);
+
+    if (view === null) {
+      this.sendErr(req.id, 'bad_args', `no report '${parsed.data.report}'`);
+
+      return;
+    }
+
+    this.sendOk(req.id, { ...view });
+  }
+
   private async applySessionMessage(req: RequestMsg, ctx: DaemonContext): Promise<void> {
     const parsed = parseRequestParams('session.message', req.p);
 

package/src/daemon/daemon.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { unlinkSync, writeFileSync } from 'node:fs';
-import { hostname } from 'node:os';
+import { hostname, tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import type { AdapterEvent, AgentAdapter } from '../agents/agent-adapter';
 import { planTypedLineInput } from '../agents/plan-typed-line-input';
@@ -32,6 +32,7 @@ import type { ExecutionTarget } from './build-execution-targets';
 import { buildFleetEvents } from './build-fleet-events';
 import { buildMessageTrailEntry } from './build-message-trail-entry';
 import { buildReportTrailEntry } from './build-report-trail-entry';
+import { buildReportView } from './build-report-view';
 import { buildSessionEvent } from './build-session-event';
 import { buildSessionMessageEvent } from './build-session-message-event';
 import { buildSessionReportEvent } from './build-session-report-event';
@@ -907,6 +908,7 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
         log: (line) => {
           mgr.log(line);
         },
+        stagingRoot: tmpdir(),
       },
     );
   };
@@ -1568,6 +1570,11 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
         await eventSignal.waitForNext(generation, remaining);
       }
     },
+    readReport: async (id, access) => {
+      const stored = await store.findReport(id, buildEventScope(null, access));
+
+      return stored === null ? null : buildReportView(stored, mgr.collectDescriptors());
+    },
     writeSessionMessage: async (sessionID, from, text, keyed) => {
       if (keyed === null) {
         const refusal = findMessageRefusal(sessionID);