@zgeoff/atc 2.6.0 → 2.8.0

package/src/daemon/parse-report.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import type { MessageID } from '../shared/message-id';
+import { toMessageID } from '../shared/to-message-id';
+
+interface AnsweredReport {
+  readonly kind: 'answered';
+  readonly message: MessageID;
+  readonly answer: string;
+}
+
+export interface NoteReport {
+  readonly kind: 'note';
+  readonly label: string;
+  readonly text: string;
+}
+
+export type Report = AnsweredReport | NoteReport;
+
+const REPORT_SCHEMA = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('answered'), message: z.string().min(1), answer: z.string() }),
+  z.object({ kind: z.literal('note'), label: z.string().min(1).max(64), text: z.string().min(1) }),
+]);
+
+/**
+ * Parses a Report envelope's payload into the report its kind discriminates,
+ * or null when it matches no known kind.
+ */
+export function parseReport(payload: Readonly<Record<string, unknown>>): Report | null {
+  const parsed = REPORT_SCHEMA.safeParse(payload);
+
+  if (!parsed.success) {
+    return null;
+  }
+
+  if (parsed.data.kind === 'note') {
+    return { kind: 'note', label: parsed.data.label, text: parsed.data.text };
+  }
+
+  return {
+    kind: 'answered',
+    message: toMessageID(parsed.data.message),
+    answer: parsed.data.answer,
+  };
+}

package/src/daemon/session-runtime.ts

@@ -37,6 +37,15 @@ export class SessionRuntime {
   // clears it, and a spawn that never reports leaves it stranded harmlessly.
   pendingLastUsed = false;
 
+  // When the agent reported SessionStart since its terminal last booted, or
+  // null before it has. A message queues for a grace window after that, and
+  // beyond it only if a tap has attached since the boot.
+  startedAt: number | null = null;
+
+  // Whether a tap has attached since the terminal last booted. A tap that
+  // later dropped may be restarting, so it keeps the inbox open.
+  tapAttached = false;
+
   dispose(): void {
     clearTimeout(this.resizeTimer);
     clearTimeout(this.detectTimer);

package/src/daemon/start-headless-run.ts

@@ -1,8 +1,10 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import type { AgentSessionID } from '../shared/agent-session-id';
-import { collectCleanEnv } from '../shared/collect-clean-env';
+import { socketPath } from '../shared/config';
 import { isCompiledBinary } from '../shared/is-compiled-binary';
 import { isRecord } from '../shared/report';
+import type { SessionID } from '../shared/session-id';
+import { buildHeadlessEnv } from './build-headless-env';
 import { resolveHeadlessExecutable } from './resolve-headless-executable';
 
 const PERMISSION_MODES = [
@@ -21,6 +23,8 @@ interface HeadlessRunOptions {
   readonly resume?: AgentSessionID;
   readonly permissionMode?: string;
   readonly settings?: string;
+  readonly sessionID?: SessionID;
+  readonly pluginDir?: string;
 }
 
 interface HeadlessRunHooks {
@@ -54,7 +58,11 @@ export function startHeadlessRun(
         prompt: opts.prompt,
         options: {
           cwd: opts.cwd,
-          env: collectCleanEnv(),
+          env: buildHeadlessEnv({
+            socketPath,
+            ...(opts.pluginDir === undefined ? {} : { pluginDir: opts.pluginDir }),
+            ...(opts.sessionID === undefined ? {} : { sessionID: opts.sessionID }),
+          }),
           abortController: controller,
           stderr: (data: string) => {
             stderrTail = `${stderrTail}${data}`.slice(-2000);

package/src/daemon/start-headless-turn.ts

@@ -31,6 +31,7 @@ export function startHeadlessTurn(
       prompt,
       ...(s.agentSessionID === undefined ? {} : { resume: s.agentSessionID }),
       permissionMode: 'auto',
+      sessionID,
     },
     {
       onOutput: (text) => {

package/src/daemon/tap-registry.ts

@@ -0,0 +1,67 @@
+import type { MessageID } from '../shared/message-id';
+import type { SessionID } from '../shared/session-id';
+
+interface TapEntry<TClient> {
+  readonly client: TClient;
+  readonly claimed: Set<MessageID>;
+}
+
+/**
+ * Which connection taps each session's inbox; one tap per session, the
+ * latest wins; each message is handed to a tap once.
+ */
+export class TapRegistry<TClient> {
+  private readonly bySession = new Map<SessionID, TapEntry<TClient>>();
+
+  /**
+   * Makes the client the session's tap and returns the client it displaced,
+   * or null when there was none or it is the same connection.
+   */
+  attach(sessionID: SessionID, client: TClient): TClient | null {
+    const previous = this.bySession.get(sessionID)?.client ?? null;
+
+    this.bySession.set(sessionID, { client, claimed: new Set() });
+
+    return previous === client ? null : previous;
+  }
+
+  detachAll(client: TClient): void {
+    for (const [sessionID, entry] of this.bySession) {
+      if (entry.client === client) {
+        this.bySession.delete(sessionID);
+      }
+    }
+  }
+
+  /**
+   * Forgets the session's tap and returns its client, or null when the
+   * session had none.
+   */
+  removeSession(sessionID: SessionID): TClient | null {
+    const previous = this.bySession.get(sessionID)?.client ?? null;
+
+    this.bySession.delete(sessionID);
+
+    return previous;
+  }
+
+  hasTap(sessionID: SessionID): boolean {
+    return this.bySession.has(sessionID);
+  }
+
+  isTap(sessionID: SessionID, client: TClient): boolean {
+    return this.bySession.get(sessionID)?.client === client;
+  }
+
+  claimDelivery(sessionID: SessionID, messageID: MessageID): TClient | null {
+    const entry = this.bySession.get(sessionID);
+
+    if (entry === undefined || entry.claimed.has(messageID)) {
+      return null;
+    }
+
+    entry.claimed.add(messageID);
+
+    return entry.client;
+  }
+}

package/src/mcp-server.ts

@@ -187,6 +187,38 @@ const TOOLS: readonly MCPTool[] = [
       'Catch up on the fleet: session events (started, prompt-submitted, needs-input, turn-done, ended) since a cursor, oldest first, each with the session id and name. Without a cursor it returns the most recent events. Pass the returned cursor next time. waitMs holds the call open until an event arrives.',
     inputSchema: EVENTS_READ_INPUT,
   },
+  {
+    name: 'atc_session_message',
+    description:
+      "Send a session a message and get its id back; poll atc_message_get with the id for its status and answer. The message waits in the session inbox until the session takes it, and its status moves accepted, delivered, answered. A message is refused as unsupported when the session's agent has no message tap (Grok, Codex), or when a Claude session reported SessionStart more than 15 seconds ago and no tap has attached since. It is refused as session_dead when the session has no live process and as no_such_session for an unknown id. Otherwise it queues, including while a session restores or after its tap dropped. The message is never typed into the terminal.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        session: { type: 'string', description: 'The atc session id, from atc_session_list' },
+        text: { type: 'string', description: 'The message text' },
+        from: {
+          type: 'string',
+          description:
+            'Who the message is from; defaults to the calling session id, or mcp outside a session',
+        },
+      },
+      required: ['session', 'text'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'atc_message_get',
+    description:
+      'Read one message sent with atc_session_message: its id, session, from, text, status (accepted, delivered, or answered), the answer once answered, and the sentAt, deliveredAt, and answeredAt timestamps. Poll it until the status is answered.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        message: { type: 'string', description: 'The message id atc_session_message returned' },
+      },
+      required: ['message'],
+      additionalProperties: false,
+    },
+  },
 ];
 
 /**
@@ -424,6 +456,30 @@ async function runTool(
 
       return JSON.stringify(ok, null, 2);
     }
+    case 'atc_session_message': {
+      const caller = process.env['ATC_SESSION_ID'];
+      const given = args['from'];
+      let from = 'mcp';
+
+      if (typeof given === 'string' && given !== '') {
+        from = given;
+      } else if (caller !== undefined && caller !== '') {
+        from = caller;
+      }
+
+      const ok = await client.sendRequest('session.message', {
+        session: args['session'],
+        text: args['text'],
+        from,
+      });
+
+      return JSON.stringify(ok, null, 2);
+    }
+    case 'atc_message_get': {
+      const ok = await client.sendRequest('message.get', { message: args['message'] });
+
+      return JSON.stringify(ok, null, 2);
+    }
     default: {
       throw new Error(`unknown tool '${name}'`);
     }

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

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { buildOptionalBoolean } from '../shared/build-optional-boolean';
 import { buildOptionalString } from '../shared/build-optional-string';
 import { toAgentSessionID } from '../shared/to-agent-session-id';
+import { toMessageID } from '../shared/to-message-id';
 import { toSessionID } from '../shared/to-session-id';
 
 const EJECT_DEFAULT_PROMPT =
@@ -97,6 +98,17 @@ export const REQUEST_PARAM_SCHEMAS = {
     limit: buildDefaultedNumber(50).transform((v) => Math.min(Math.max(Math.trunc(v), 1), 200)),
     waitMs: buildDefaultedNumber(0).transform((v) => Math.min(Math.max(Math.trunc(v), 0), 30_000)),
   }),
+  'session.message': SESSION_DEFAULTED.extend({
+    from: buildDefaultedNonEmptyString('unknown'),
+    text: buildDefaultedString(''),
+  }).refine((v) => v.text !== '', { message: 'session.message requires text' }),
+  'session.tap': SESSION_DEFAULTED,
+  'message.get': z
+    .object({ message: buildDefaultedString('').transform(toMessageID) })
+    .refine((v) => v.message !== '', { message: 'message.get requires a message' }),
+  'message.ack': SESSION_DEFAULTED.extend({
+    message: buildDefaultedString('').transform(toMessageID),
+  }).refine((v) => v.message !== '', { message: 'message.ack requires a message' }),
 } as const;
 
 function buildDefaultedString(fallback: string) {

package/src/report.ts

@@ -0,0 +1,59 @@
+import { sendReport } from './shared/report';
+import { REPORT_KINDS } from './shared/report-kinds';
+
+interface ReportOptions {
+  readonly message: string;
+  readonly label: string;
+}
+
+/**
+ * Runs inside wrangled sessions: reads stdin verbatim and forwards it to the
+ * atc socket as a Report envelope of the given kind. An `answered` report
+ * carries stdin as the final text for the given message; a `note` carries
+ * it as text for the user under the given label, `progress` when none is
+ * given. Always exits 0 so it never blocks the session it reports on.
+ */
+export async function runReport(kind: string, options: ReportOptions): Promise<void> {
+  try {
+    const sock = process.env['ATC_SOCKET'];
+    const atcId = process.env['ATC_SESSION_ID'];
+
+    if (
+      sock !== undefined &&
+      sock !== '' &&
+      atcId !== undefined &&
+      atcId !== '' &&
+      REPORT_KINDS.some((known) => known === kind)
+    ) {
+      const stdin = await new Response(Bun.stdin.stream()).text();
+
+      const payload = buildReportPayload(kind, options, stdin);
+
+      if (payload !== null) {
+        const line = `${JSON.stringify({ atcId, event: 'Report', payload })}\n`;
+
+        await sendReport(sock, line, 2000);
+      }
+    }
+  } catch {}
+
+  process.exit(0);
+}
+
+function buildReportPayload(
+  kind: string,
+  options: ReportOptions,
+  stdin: string,
+): Record<string, string> | null {
+  if (kind === 'answered') {
+    return options.message === '' ? null : { kind, message: options.message, answer: stdin };
+  }
+
+  if (kind === 'note') {
+    return stdin.trim() === ''
+      ? null
+      : { kind, label: options.label === '' ? 'progress' : options.label, text: stdin };
+  }
+
+  return null;
+}

package/src/shared/message-id.ts

@@ -0,0 +1,7 @@
+import type { Tagged } from 'type-fest';
+
+/**
+ * An atc-minted message id; keys the messages table and every message
+ * request and event.
+ */
+export type MessageID = Tagged<string, 'MessageID'>;

package/src/shared/report-kinds.ts

@@ -0,0 +1 @@
+export const REPORT_KINDS = ['answered', 'note'] as const;

package/src/shared/report.ts

@@ -4,12 +4,28 @@
 async function sendLine(sock: string, line: string): Promise<void> {
   const resolvers = Promise.withResolvers<void>();
 
+  const bytes = new TextEncoder().encode(line);
+
+  let written = 0;
+
   await Bun.connect({
     unix: sock,
     socket: {
+      // A write returns the bytes the socket accepted and drops the rest, so
+      // a line larger than the socket buffer goes out across drain calls.
       open(s) {
-        s.write(line);
-        s.end();
+        written += s.write(bytes.subarray(written));
+
+        if (written >= bytes.length) {
+          s.end();
+        }
+      },
+      drain(s) {
+        written += s.write(bytes.subarray(written));
+
+        if (written >= bytes.length) {
+          s.end();
+        }
       },
       close() {
         resolvers.resolve();

package/src/shared/to-message-id.ts

@@ -0,0 +1,11 @@
+import type { MessageID } from './message-id';
+
+/**
+ * Trusts a string as an atc message id. This is the one point in the
+ * codebase where a plain string becomes a `MessageID`, and it adds no
+ * runtime check: the caller asserts the string identifies an atc message.
+ */
+export function toMessageID(id: string): MessageID {
+  // oxlint-disable-next-line no-unsafe-type-assertion -- the one point where a string is trusted as a MessageID
+  return id as MessageID;
+}

package/src/store/message-owner.ts

@@ -0,0 +1,9 @@
+import type { AgentSessionID } from '../shared/agent-session-id';
+import type { SessionID } from '../shared/session-id';
+
+// Which session a message belongs to: the atc id it was sent to, or the
+// agent session id that survives a restore's re-minted atc id.
+export interface MessageOwner {
+  readonly atcID: SessionID;
+  readonly agentSessionID?: AgentSessionID;
+}

package/src/store/message-record.ts

@@ -0,0 +1,18 @@
+import type { AgentSessionID } from '../shared/agent-session-id';
+import type { MessageID } from '../shared/message-id';
+import type { SessionID } from '../shared/session-id';
+
+export type MessageStatus = 'accepted' | 'delivered' | 'answered';
+
+export interface MessageRecord {
+  readonly id: MessageID;
+  readonly atcID: SessionID;
+  readonly agentSessionID?: AgentSessionID;
+  readonly from: string;
+  readonly text: string;
+  readonly status: MessageStatus;
+  readonly sentAt: number;
+  readonly deliveredAt?: number;
+  readonly answeredAt?: number;
+  readonly answer?: string;
+}

package/src/store/run-migrations.ts

@@ -2,6 +2,7 @@ import { sql } from 'kysely';
 import type { Generated, Kysely } from 'kysely';
 import { DEFAULT_MIGRATION_TABLE, Migrator } from 'kysely/migration';
 import type { Migration, MigrationProvider, MigrationResultSet } from 'kysely/migration';
+import type { MessageStatus } from './message-record';
 
 interface FleetTable {
   agent_session_id: string;
@@ -38,6 +39,19 @@ interface PrefsTable {
   value: string;
 }
 
+interface MessagesTable {
+  id: string;
+  atc_id: string;
+  agent_session_id: string | null;
+  sender: string;
+  text: string;
+  status: MessageStatus;
+  sent_at: number;
+  delivered_at: number | null;
+  answered_at: number | null;
+  answer: string | null;
+}
+
 /**
  * The state store's schema: what the query builder and the migration
  * ladder both build against.
@@ -47,13 +61,14 @@ export interface StateStoreSchema {
   events: EventsTable;
   spawn_history: SpawnHistoryTable;
   prefs: PrefsTable;
+  messages: MessagesTable;
 }
 
 // Every shape the fleet table has shipped with: the oldest carries only
 // agent_session_id under its Claude-era name plus name and cwd, and each
 // later step adds one column the daemon grew to depend on. events later gains
-// columns of its own, while spawn_history and prefs have carried one shape
-// since they were added.
+// columns of its own, while spawn_history, prefs, and messages have carried one
+// shape since they were added.
 const MIGRATIONS: Record<string, Migration> = {
   '001_create_initial_schema': {
     async up(db: Kysely<StateStoreSchema>) {
@@ -166,6 +181,41 @@ const MIGRATIONS: Record<string, Migration> = {
       );
     },
   },
+  '011_create_messages': {
+    async up(db: Kysely<StateStoreSchema>) {
+      await db.schema
+        .createTable('messages')
+        .ifNotExists()
+        .addColumn('id', 'text', (c) => c.primaryKey())
+        .addColumn('atc_id', 'text', (c) => c.notNull())
+        .addColumn('agent_session_id', 'text')
+        .addColumn('sender', 'text', (c) => c.notNull())
+        .addColumn('text', 'text', (c) => c.notNull())
+        .addColumn('status', 'text', (c) => c.notNull())
+        .addColumn('sent_at', 'integer', (c) => c.notNull())
+        .addColumn('delivered_at', 'integer')
+        .addColumn('answered_at', 'integer')
+        .addColumn('answer', 'text')
+        .execute();
+    },
+  },
+  '012_index_messages_by_owner': {
+    async up(db: Kysely<StateStoreSchema>) {
+      await db.schema
+        .createIndex('messages_atc_id_status_sent_at')
+        .ifNotExists()
+        .on('messages')
+        .columns(['atc_id', 'status', 'sent_at'])
+        .execute();
+
+      await db.schema
+        .createIndex('messages_agent_session_id_status_sent_at')
+        .ifNotExists()
+        .on('messages')
+        .columns(['agent_session_id', 'status', 'sent_at'])
+        .execute();
+    },
+  },
 };
 
 const PROVIDER: MigrationProvider = {

package/src/store/state-store.ts

@@ -1,16 +1,21 @@
 import { Database } from 'bun:sqlite';
 import { existsSync, readFileSync } from 'node:fs';
 import { Kysely, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, sql } from 'kysely';
+import type { Expression, ExpressionBuilder, SqlBool } from 'kysely';
 import { toAgentID } from '../agents/agent-adapter';
 import type { AdapterEvent, AgentID } from '../agents/agent-adapter';
 import type { HookEvent } from '../daemon/hooks';
 import type { AgentSessionID } from '../shared/agent-session-id';
+import type { MessageID } from '../shared/message-id';
 import type { SessionID } from '../shared/session-id';
 import { toAgentSessionID } from '../shared/to-agent-session-id';
+import { toMessageID } from '../shared/to-message-id';
 import { toSessionID } from '../shared/to-session-id';
 import { BunSqliteDriver } from './bun-sqlite-driver';
 import { parseFleetEntry } from './fleet-entry';
 import type { FleetEntry, FleetEntryUpdate } from './fleet-entry';
+import type { MessageOwner } from './message-owner';
+import type { MessageRecord } from './message-record';
 import { runMigrations } from './run-migrations';
 import type { StateStoreSchema } from './run-migrations';
 
@@ -32,8 +37,8 @@ export interface StoredEvent {
 
 /**
  * Daemon state in one SQLite store: the restorable fleet, the hook-event
- * trail that events.read and lastActivityAt read, and the spawn-directory
- * history. The statusline contract
+ * trail that events.read and lastActivityAt read, the spawn-directory
+ * history, and the per-session message inbox. The statusline contract
  * file (status.json) stays a plain file because reporters inside wrangled
  * sessions read it without speaking to the daemon. An existing fleet.json
  * seeds the fleet table once, so upgrading never loses a restorable fleet.
@@ -293,6 +298,115 @@ export class StateStore {
       .execute();
   }
 
+  // oxlint-disable-next-line prefer-readonly-parameter-types -- every field is readonly; the branded id has no readonly form to wrap it in
+  async writeMessage(record: MessageRecord): Promise<void> {
+    await this.db
+      .insertInto('messages')
+      .values({
+        id: record.id,
+        atc_id: record.atcID,
+        agent_session_id: record.agentSessionID ?? null,
+        sender: record.from,
+        text: record.text,
+        status: record.status,
+        sent_at: record.sentAt,
+        delivered_at: record.deliveredAt ?? null,
+        answered_at: record.answeredAt ?? null,
+        answer: record.answer ?? null,
+      })
+      .execute();
+  }
+
+  async collectPendingMessages(owner: MessageOwner): Promise<MessageRecord[]> {
+    const rows = await this.db
+      .selectFrom('messages')
+      .selectAll()
+      .where('status', '=', 'accepted')
+      .where((eb) => buildOwnerFilter(eb, owner))
+      .orderBy('sent_at', 'asc')
+      .orderBy(sql`rowid`, 'asc')
+      .execute();
+
+    return rows.map((row) => toMessageRecord(row));
+  }
+
+  async findMessage(id: MessageID, owner: MessageOwner): Promise<MessageRecord | null> {
+    const row = await this.db
+      .selectFrom('messages')
+      .selectAll()
+      .where('id', '=', id)
+      .where((eb) => buildOwnerFilter(eb, owner))
+      .executeTakeFirst();
+
+    return row === undefined ? null : toMessageRecord(row);
+  }
+
+  async findMessageByID(id: MessageID): Promise<MessageRecord | null> {
+    const row = await this.db
+      .selectFrom('messages')
+      .selectAll()
+      .where('id', '=', id)
+      .executeTakeFirst();
+
+    return row === undefined ? null : toMessageRecord(row);
+  }
+
+  async updateMessageDelivered(
+    id: MessageID,
+    owner: MessageOwner,
+    at: number,
+  ): Promise<MessageRecord | null> {
+    const row = await this.db
+      .updateTable('messages')
+      .set({ status: 'delivered', delivered_at: at })
+      .where('id', '=', id)
+      .where('status', '=', 'accepted')
+      .where((eb) => buildOwnerFilter(eb, owner))
+      .returningAll()
+      .executeTakeFirst();
+
+    return row === undefined ? null : toMessageRecord(row);
+  }
+
+  async updateMessageAnswered(
+    id: MessageID,
+    owner: MessageOwner,
+    answer: string,
+    at: number,
+  ): Promise<MessageRecord | null> {
+    const row = await this.db
+      .updateTable('messages')
+      .set({ status: 'answered', answered_at: at, answer })
+      .where('id', '=', id)
+      .where('status', 'in', ['accepted', 'delivered'])
+      .where((eb) => buildOwnerFilter(eb, owner))
+      .returningAll()
+      .executeTakeFirst();
+
+    return row === undefined ? null : toMessageRecord(row);
+  }
+
+  // Messages sent before the agent reported its session id carry no agent
+  // session id; this stamps them once it is known, and moves every message
+  // from a previous agent session id to a changed one.
+  async updateMessageOwner(
+    atcID: SessionID,
+    previous: AgentSessionID | undefined,
+    next: AgentSessionID,
+  ): Promise<void> {
+    await this.db
+      .updateTable('messages')
+      .set({ agent_session_id: next })
+      .where((eb) => {
+        const unstamped = eb.and([eb('atc_id', '=', atcID), eb('agent_session_id', 'is', null)]);
+
+        return previous === undefined
+          ? unstamped
+          : eb.or([unstamped, eb('agent_session_id', '=', previous)]);
+      })
+      .execute();
+  }
+
   async stop(): Promise<void> {
     await this.db.destroy();
 
@@ -361,3 +475,31 @@ function buildStoredEvents(rows: readonly EventRow[]): StoredEvent[] {
 
   return events;
 }
+
+function buildOwnerFilter(
+  eb: ExpressionBuilder<StateStoreSchema, 'messages'>, // oxlint-disable-line prefer-readonly-parameter-types -- a kysely expression builder bound to a live query; not meaningfully freezable
+  owner: MessageOwner,
+): Expression<SqlBool> {
+  const byAtcID = eb('atc_id', '=', owner.atcID);
+
+  return owner.agentSessionID === undefined
+    ? byAtcID
+    : eb.or([byAtcID, eb('agent_session_id', '=', owner.agentSessionID)]);
+}
+
+function toMessageRecord(row: Readonly<StateStoreSchema['messages']>): MessageRecord {
+  return {
+    id: toMessageID(row.id),
+    atcID: toSessionID(row.atc_id),
+    ...(row.agent_session_id === null
+      ? {}
+      : { agentSessionID: toAgentSessionID(row.agent_session_id) }),
+    from: row.sender,
+    text: row.text,
+    status: row.status,
+    sentAt: row.sent_at,
+    ...(row.delivered_at === null ? {} : { deliveredAt: row.delivered_at }),
+    ...(row.answered_at === null ? {} : { answeredAt: row.answered_at }),
+    ...(row.answer === null ? {} : { answer: row.answer }),
+  };
+}