@zgeoff/atc 2.13.0 → 2.14.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.14.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/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-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

@@ -28,6 +28,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 +190,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: (
@@ -799,6 +805,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 +1161,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);

package/src/daemon/materialize-workspace.ts

@@ -1,5 +1,4 @@
 import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { DaemonError } from '../protocol/daemon-error';
 import type { ErrorCode } from '../protocol/protocol';
@@ -36,6 +35,10 @@ interface MaterializeDeps {
   readonly requireProvider: (capability: 'run' | 'transfer') => ExecutionProvider;
   readonly store: Pick<StateStore, 'createMaterialization' | 'updateMaterialization'>;
   readonly log: (line: string) => void;
+
+  // The directory on the daemon's host that holds each clone's staging
+  // directory while the workspace is built.
+  readonly stagingRoot: string;
 }
 
 type MaterializedWorkspace = { readonly kind: 'in_place' } | ReadyWorkspace;
@@ -122,7 +125,7 @@ export async function materializeWorkspace(
   // The staging directory exists only once the row does, and only inside
   // the block that removes it, so neither can outlive a failure of the other.
   try {
-    const staging = await mkdtemp(join(tmpdir(), 'atc-workspace-'));
+    const staging = await mkdtemp(join(deps.stagingRoot, 'atc-workspace-'));
 
     try {
       const ready = await runMaterialization(request, deps, staging, updateProgress, secret);

package/src/mcp/mcp-tools.ts

@@ -115,6 +115,13 @@ const MESSAGE_GET_INPUT: Readonly<Record<string, unknown>> = z.toJSONSchema(
   { io: 'input' },
 );
 
+const REPORT_GET_INPUT: Readonly<Record<string, unknown>> = z.toJSONSchema(
+  z.strictObject({
+    report: z.string().describe("The cursor of the report's event, from atc_events_read"),
+  }),
+  { io: 'input' },
+);
+
 // Output schemas leave further properties open, so a field the daemon adds
 // later never fails a client that validates results against them.
 const MESSAGE_OUTPUT: Readonly<Record<string, unknown>> = {
@@ -277,6 +284,20 @@ const EVENTS_OUTPUT: Readonly<Record<string, unknown>> = {
   required: ['events', 'cursor', 'more'],
 };
 
+const REPORT_OUTPUT: Readonly<Record<string, unknown>> = {
+  type: 'object',
+  properties: {
+    report: { type: 'string' },
+    at: { type: 'number' },
+    session: { type: 'string' },
+    name: { type: ['string', 'null'] },
+    label: { type: 'string' },
+    text: { type: 'string' },
+    complete: { type: 'boolean' },
+  },
+  required: ['report', 'at', 'session', 'name', 'label', 'text', 'complete'],
+};
+
 interface MCPToolAnnotations {
   readonly readOnlyHint: boolean;
   readonly destructiveHint: boolean;
@@ -464,11 +485,21 @@ export const MCP_TOOLS: readonly MCPToolDefinition[] = [
     annotations: READ_ONLY,
     scope: 'read',
     description:
-      'Catch up on the fleet: session events (started, prompt-submitted, needs-input, turn-done, ended), message events (message-accepted, message-delivered, message-answered), and reports (report) since a cursor, oldest first, each with the session id and name. A message event carries the message id; read the full message with atc_message_get. A report event carries its label. Without a cursor it returns the most recent events. Pass the returned cursor next time; more is true when the page stopped before the newest event, so read again at once. session limits the read to one session. waitMs holds the call open until an event arrives; pass it instead of polling in a tight loop.',
+      'Catch up on the fleet: session events (started, prompt-submitted, needs-input, turn-done, ended), message events (message-accepted, message-delivered, message-answered), and reports (report) since a cursor, oldest first, each with the session id and name. A message event carries the message id; read the full message with atc_message_get. A report event carries its label and a preview of its text; read the full text with atc_report_get, passing the cursor of that event. Without a cursor it returns the most recent events. Pass the returned cursor next time; more is true when the page stopped before the newest event, so read again at once. session limits the read to one session. waitMs holds the call open until an event arrives; pass it instead of polling in a tight loop.',
     inputSchema: EVENTS_READ_INPUT,
     outputSchema: EVENTS_OUTPUT,
     requires: { output: 'events.more', inputs: { session: 'events.session' } },
   },
+  {
+    name: 'atc_report_get',
+    annotations: READ_ONLY,
+    scope: 'read',
+    description:
+      "Read one report's full text without messaging the session that sent it. Pass the cursor of the report's event from atc_events_read. Returns the report cursor, at, the session id and name, the label, the text (up to 64 KiB, as the session sent it), and complete, which is false for a report recorded before atc kept full texts: its text is then only the preview the event held. A cursor of an event that is not a report answers as an unknown report.",
+    inputSchema: REPORT_GET_INPUT,
+    outputSchema: REPORT_OUTPUT,
+    requires: { tool: 'report.get' },
+  },
   {
     name: 'atc_session_message',
     annotations: AGENT_FACING,

package/src/mcp/reconnecting-caller.ts

@@ -12,6 +12,7 @@ const RETRYABLE_METHODS: ReadonlySet<string> = new Set([
   'dirs.list',
   'events.read',
   'message.get',
+  'report.get',
   'session.get',
   'session.list',
   'session.read',

package/src/mcp/require-daemon-features.ts

@@ -16,6 +16,7 @@ const FEATURE_USES: Readonly<Record<DaemonFeature, string>> = {
   'spawn.idempotency': "atc_session_spawn's idempotencyKey",
   'spawn.options': "atc_session_spawn's model and effort",
   'spawn.target': "atc_session_spawn's target",
+  'report.get': 'atc_report_get',
   'request.principal': 'the target limits of a remote MCP client',
   'spawn.workspace': "atc_session_spawn's workspace",
 };

package/src/mcp/run-tool.ts

@@ -172,6 +172,11 @@ export function runTool(
 
       return buildObjectResult(ok);
     })
+    .with('atc_report_get', async () => {
+      const ok = await caller.sendRequest('report.get', { report: args['report'] }, ['report.get']);
+
+      return buildObjectResult(ok);
+    })
     .with('atc_session_message', async () => {
       const given = args['from'];
 

package/src/protocol/daemon-features.ts

@@ -53,6 +53,9 @@ export const DAEMON_FEATURES = [
 
   // `session.submit` exists.
   'session.submit',
+
+  // `report.get` exists.
+  'report.get',
 ] as const;
 
 export type DaemonFeature = (typeof DAEMON_FEATURES)[number];

package/src/protocol/request-param-schemas.ts

@@ -216,6 +216,12 @@ export const REQUEST_PARAM_SCHEMAS = {
       waitMs: buildDefaultedWait(),
     })
     .refine((v) => v.message !== '', { message: 'message.get requires a message' }),
+  'report.get': z
+    .object({
+      // The cursor events.read returned with the report's event.
+      report: buildDefaultedString(''),
+    })
+    .refine((v) => v.report !== '', { message: 'report.get requires a report' }),
   'message.ack': SESSION_DEFAULTED.extend({
     message: buildDefaultedString('').transform(toMessageID),
   }).refine((v) => v.message !== '', { message: 'message.ack requires a message' }),

package/src/store/run-migrations.ts

@@ -48,6 +48,10 @@ interface EventsTable {
   // The id a remote session's reporter gave a report row, unique so a
   // resent report lands once; null on every other row.
   report_id: string | null;
+
+  // A report row's whole text, which detail previews; null on every other
+  // row, and on a report row written before the column existed.
+  report_text: string | null;
 }
 
 interface SpawnHistoryTable {
@@ -437,6 +441,11 @@ const MIGRATIONS: Record<string, Migration> = {
         .execute();
     },
   },
+  '023_add_events_report_text': {
+    async up(db: Kysely<StateStoreSchema>) {
+      await db.schema.alterTable('events').addColumn('report_text', 'text').execute();
+    },
+  },
 };
 
 const PROVIDER: MigrationProvider = {

package/src/store/state-store.ts

@@ -63,6 +63,23 @@ export interface StoredEvent {
   readonly label?: string;
 }
 
+/**
+ * One report as the trail holds it. A report recorded before the trail kept
+ * whole texts has only its preview, so its text is that preview and
+ * `complete` is false.
+ */
+export interface StoredReport {
+  readonly id: number;
+
+  // Epoch ms the report arrived.
+  readonly at: number;
+  readonly atcID: SessionID;
+  readonly agentSessionID: AgentSessionID | null;
+  readonly label: string;
+  readonly text: string;
+  readonly complete: boolean;
+}
+
 /**
  * Daemon state in one SQLite store: the restorable fleet, the event trail
  * (hook events, message status changes, and reports) that events.read and
@@ -347,6 +364,7 @@ export class StateStore {
         kind: entry.kind,
         detail: entry.detail,
         report_id: entry.kind === 'report' ? (entry.reportID ?? null) : null,
+        report_text: entry.kind === 'report' ? entry.text : null,
       })
       .onConflict((oc) => oc.column('report_id').doNothing())
       .executeTakeFirst();
@@ -372,6 +390,32 @@ export class StateStore {
     return buildStoredEvents(rows);
   }
 
+  // A row that is not a report, or that lies outside the scope, misses as a
+  // row the trail never held does.
+  async findReport(id: number, scope: EventScope | null = null): Promise<StoredReport | null> {
+    const row = await this.db
+      .selectFrom('events')
+      .select(['id', 'ts', 'atc_id', 'session_id', 'message', 'detail', 'report_text'])
+      .where('id', '=', id)
+      .where('kind', '=', 'report')
+      .where((eb) => buildScopeMatch(eb, scope))
+      .executeTakeFirst();
+
+    if (row === undefined) {
+      return null;
+    }
+
+    return {
+      id: row.id,
+      at: Date.parse(row.ts),
+      atcID: toSessionID(row.atc_id),
+      agentSessionID: row.session_id === null ? null : toAgentSessionID(row.session_id),
+      label: row.message ?? '',
+      text: row.report_text ?? row.detail ?? '',
+      complete: row.report_text !== null,
+    };
+  }
+
   async collectLatestEvents(
     limit: number,
     scope: EventScope | null = null,

package/src/store/trail-entry.ts

@@ -19,6 +19,9 @@ interface ReportTrailEntry extends TrailEntryBase {
   readonly kind: 'report';
   readonly label: string;
 
+  // The report's whole text, which the detail previews.
+  readonly text: string;
+
   // The id a remote session's reporter gave the report, so a resent
   // report is stored once; absent for a report that carries none.
   readonly reportID?: string;