@zgeoff/atc 2.13.0 → 2.15.0

package/src/daemon/hooks.ts

@@ -1,4 +1,5 @@
 import { unlinkSync } from 'node:fs';
+import { LineDecoder } from '../protocol/line-decoder';
 import { socketPath } from '../shared/config';
 import type { SessionID } from '../shared/session-id';
 import { parseHookLine } from './parse-hook-line';
@@ -9,12 +10,9 @@ export interface HookEvent {
   payload: Record<string, unknown>;
 }
 
-// Per-connection read state: the unterminated tail of the line in progress,
-// and a streaming decoder so a multi-byte character split across two reads
-// decodes whole.
+// Per-connection read state: the connection's own line framing.
 interface HookConnection {
-  pending: string;
-  readonly decoder: TextDecoder;
+  readonly lines: LineDecoder;
 }
 
 export function startHookServer(onEvent: (e: HookEvent) => void, path: string = socketPath) {
@@ -26,17 +24,7 @@ export function startHookServer(onEvent: (e: HookEvent) => void, path: string =
     unix: path,
     socket: {
       data(socket, buf) {
-        const conn = socket.data;
-        const buffered = conn.pending + conn.decoder.decode(buf, { stream: true });
-        const lines = buffered.split('\n');
-
-        conn.pending = lines.pop() ?? '';
-
-        for (const line of lines) {
-          if (line.trim() === '') {
-            continue;
-          }
-
+        for (const line of socket.data.lines.splitChunk(buf)) {
           const event = parseHookLine(line);
 
           if (event !== null) {
@@ -45,7 +33,7 @@ export function startHookServer(onEvent: (e: HookEvent) => void, path: string =
         }
       },
       open(socket) {
-        socket.data = { pending: '', decoder: new TextDecoder() };
+        socket.data = { lines: new LineDecoder() };
       },
       error() {},
     },

package/src/daemon/imp-client-port.ts

@@ -18,12 +18,15 @@ import type {
 import { ImpPortError } from './imp-port-error';
 
 /**
- * Where impd listens and the token the daemon calls it with. The token
- * comes from the daemon's environment, never from a config file.
+ * Where impd listens, and how the daemon reads the token it calls impd
+ * with: null for no token. The port reads the token again before each
+ * call and connection, so a token that changes at its source takes effect
+ * on the next one. A read that throws fails that call without reaching
+ * impd.
  */
 export interface ImpClientPortOptions {
   readonly url: string;
-  readonly token: string | null;
+  readonly readToken: () => string | null;
 }
 
 /**
@@ -35,30 +38,26 @@ export interface ImpClientPortOptions {
 export class ImpClientPort implements ImpPort {
   private readonly url: string;
 
-  private readonly token: string | null;
+  private readonly readToken: () => string | null;
 
-  private readonly client: ImpClient;
+  // The client for the token read last, rebuilt when the token changes.
+  private client: Readonly<{ token: string | null; client: ImpClient }> | null = null;
 
   constructor(options: ImpClientPortOptions) {
     this.url = options.url;
-    this.token = options.token;
-
-    this.client = createImpClient({
-      url: options.url,
-      ...(options.token === null ? {} : { token: options.token }),
-    });
+    this.readToken = options.readToken;
   }
 
   // An impd from before the flags has neither.
   readonly readFeatures = async (): Promise<ImpFeatures> => {
-    const info = await this.tryCall(() => this.client.system.info());
+    const info = await this.tryCall((client) => client.system.info());
 
     return info.features ?? { sessionOffsets: false, leases: false };
   };
 
   readonly readImp = async (name: string): Promise<ImpView | null> => {
     try {
-      const imp = await this.tryCall(() => this.client.imps.get({ name }));
+      const imp = await this.tryCall((client) => client.imps.get({ name }));
 
       return {
         name: imp.name,
@@ -76,8 +75,8 @@ export class ImpClientPort implements ImpPort {
   };
 
   readonly createImp = async (spec: ImpCreateSpec): Promise<ImpView> => {
-    const imp = await this.tryCall(() =>
-      this.client.imps.create({
+    const imp = await this.tryCall((client) =>
+      client.imps.create({
         name: spec.name,
         ...(spec.image === undefined ? {} : { image: spec.image }),
         ...(spec.memoryMib === undefined ? {} : { memoryMib: spec.memoryMib }),
@@ -92,7 +91,9 @@ export class ImpClientPort implements ImpPort {
     label: string,
     ttlSeconds: number,
   ): Promise<ImpLease> => {
-    const lease = await this.tryCall(() => this.client.leases.acquire({ name, label, ttlSeconds }));
+    const lease = await this.tryCall((client) =>
+      client.leases.acquire({ name, label, ttlSeconds }),
+    );
 
     return toLease(lease);
   };
@@ -102,23 +103,23 @@ export class ImpClientPort implements ImpPort {
     label: string,
     ttlSeconds: number,
   ): Promise<ImpLease> => {
-    const lease = await this.tryCall(() => this.client.leases.renew({ name, label, ttlSeconds }));
+    const lease = await this.tryCall((client) => client.leases.renew({ name, label, ttlSeconds }));
 
     return toLease(lease);
   };
 
   readonly releaseLease = async (name: string, label: string): Promise<boolean> => {
-    const result = await this.tryCall(() => this.client.leases.release({ name, label }));
+    const result = await this.tryCall((client) => client.leases.release({ name, label }));
 
     return result.released;
   };
 
   readonly suspendImp = async (name: string): Promise<void> => {
-    await this.tryCall(() => this.client.imps.sleep({ name }));
+    await this.tryCall((client) => client.imps.sleep({ name }));
   };
 
   readonly destroyImp = async (name: string): Promise<void> => {
-    await this.tryCall(() => this.client.imps.destroy({ name }));
+    await this.tryCall((client) => client.imps.destroy({ name }));
   };
 
   // The exec WebSocket answers only after it opens, so nothing reaches the
@@ -127,9 +128,23 @@ export class ImpClientPort implements ImpPort {
     request: ImpSessionRequest,
     handlers: ImpSessionHandlers,
   ): ImpSessionConnection => {
+    const token = this.tryReadToken();
+
+    // A token that cannot be read ends the connection the way impd's
+    // refusal of a token does, without dialing impd.
+    if (token instanceof ImpPortError) {
+      return {
+        outcome: Promise.resolve({ kind: 'unauthorized' }),
+        write: () => {},
+        resize: () => {},
+        sendSignal: () => {},
+        close: () => {},
+      };
+    }
+
     const session = openExecSession({
       baseUrl: this.url,
-      token: this.token,
+      token,
       start:
         request.kind === 'start'
           ? {
@@ -179,8 +194,8 @@ export class ImpClientPort implements ImpPort {
 
   // oxlint-disable-next-line prefer-readonly-parameter-types -- the command's input bytes have no readonly form
   readonly runCommand = async (name: string, command: ImpCommand): Promise<ImpCommandResult> => {
-    const result = await this.tryCall(() =>
-      this.client.run(name, command.argv, {
+    const result = await this.tryCall((client) =>
+      client.run(name, command.argv, {
         ...(command.cwd === undefined ? {} : { cwd: command.cwd }),
         ...(command.stdin === undefined ? {} : { stdin: command.stdin }),
       }),
@@ -194,12 +209,30 @@ export class ImpClientPort implements ImpPort {
     guestPath: string,
     onConnection: (connection: ImpRelayConnection) => void,
   ): ImpReverseForward => {
+    const token = this.tryReadToken();
+
+    if (token instanceof ImpPortError) {
+      return { listening: Promise.reject(token), stop: () => {} };
+    }
+
     const forward = openReverseForward({
       baseUrl: this.url,
-      token: this.token,
+      token,
       name,
       guest: { network: 'unix', path: guestPath },
-      connect: (url, headers) => new WebSocket(url, { headers }),
+
+      // The client reuses the headers of the listening socket for every
+      // guest connection relay, so each socket reads the token afresh. A
+      // token that cannot be read dials without one, which impd refuses.
+      connect: (url, headers) => {
+        const { authorization: _, ...rest } = headers;
+        const current = this.tryReadToken();
+
+        return new WebSocket(url, {
+          headers:
+            typeof current === 'string' ? { ...rest, authorization: `Bearer ${current}` } : rest,
+        });
+      },
       onConnection: (accept) => {
         onConnection(openRelay(accept));
       },
@@ -215,13 +248,36 @@ export class ImpClientPort implements ImpPort {
 
   // Runs one client call, turning impd's refusals and transport failures
   // into port errors.
-  private async tryCall<T>(call: () => Promise<T>): Promise<T> {
+  private async tryCall<T>(call: (client: ImpClient) => Promise<T>): Promise<T> {
     try {
-      return await call();
+      return await call(this.loadClient());
     } catch (error) {
       throw toPortError(error);
     }
   }
+
+  // The token as it reads now, or the port error its read throws.
+  private tryReadToken(): string | null | ImpPortError {
+    try {
+      return this.readToken();
+    } catch (error) {
+      return toPortError(error);
+    }
+  }
+
+  // The client that calls impd with the token as it reads now.
+  private loadClient(): ImpClient {
+    const token = this.readToken();
+
+    if (this.client === null || this.client.token !== token) {
+      this.client = {
+        token,
+        client: createImpClient({ url: this.url, ...(token === null ? {} : { token }) }),
+      };
+    }
+
+    return this.client.client;
+  }
 }
 
 // A lease as the client returns it.

package/src/daemon/imp-provider.ts

@@ -1,4 +1,5 @@
 import { DaemonError } from '../protocol/daemon-error';
+import { LineDecoder } from '../protocol/line-decoder';
 import { isCompiledBinary } from '../shared/is-compiled-binary';
 import { buildTarArchive } from './build-tar-archive';
 import type {
@@ -523,22 +524,15 @@ function buildSocketName(sessionID: string): string {
 
 // Frames a guest connection's bytes into lines, both ways.
 function toHarnessRelay(connection: ImpRelayConnection): HarnessRelay {
-  const decoder = new TextDecoder();
+  const decoder = new LineDecoder();
   const encoder = new TextEncoder();
 
   const lineListeners: ((line: string) => void)[] = [];
-  let pending = '';
 
   connection.onData((data) => {
-    const lines = `${pending}${decoder.decode(data, { stream: true })}`.split('\n');
-
-    pending = lines.pop() ?? '';
-
-    for (const line of lines) {
-      if (line.trim() !== '') {
-        for (const listener of lineListeners) {
-          listener(line);
-        }
+    for (const line of decoder.splitChunk(data)) {
+      for (const listener of lineListeners) {
+        listener(line);
       }
     }
   });

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/daemon/read-imp-token.ts

@@ -0,0 +1,30 @@
+import { readFileSync } from 'node:fs';
+import { ImpPortError } from './imp-port-error';
+
+/**
+ * The impd token held in the file at `path`, without one trailing newline.
+ * An empty or unreadable file throws an `UNAUTHORIZED` port error whose
+ * message holds the path and the read's error code, never file content.
+ */
+export function readImpToken(path: string): string {
+  let text: string;
+
+  try {
+    text = readFileSync(path, 'utf8');
+  } catch (error) {
+    const code =
+      error instanceof Error && 'code' in error && typeof error.code === 'string'
+        ? error.code
+        : 'unknown error';
+
+    throw new ImpPortError('UNAUTHORIZED', `cannot read the impd token file ${path}: ${code}`);
+  }
+
+  const token = text.endsWith('\n') ? text.slice(0, -1) : text;
+
+  if (token === '') {
+    throw new ImpPortError('UNAUTHORIZED', `the impd token file ${path} is empty`);
+  }
+
+  return token;
+}

package/src/daemon/sessions.ts

@@ -232,6 +232,10 @@ export class SessionManager {
   // of the same session does not start a second harness.
   private readonly adopting = new Set<SessionID>();
 
+  // Sessions dropped from the list on purpose whose rows the next fleet
+  // write deletes; each stays here until a write carrying it lands.
+  private readonly removedIDs = new Set<SessionID>();
+
   // The epoch the next harness start or attach takes, unique across every
   // session this manager holds.
   private nextBridgeEpoch = 1;
@@ -1350,6 +1354,8 @@ export class SessionManager {
   private remove(s: Session) {
     this.sessions = this.sessions.filter((x) => x.id !== s.id);
 
+    this.removedIDs.add(s.id);
+
     if (this.focusedId === s.id) {
       this.focusedId = null;
     }
@@ -1383,8 +1389,11 @@ export class SessionManager {
   }
 
   // Persisted continuously so a crash (or quit) leaves a restorable fleet.
-  // Deliberate kills rewrite the file; unexpected session/atc deaths do not,
-  // so the last known fleet survives for `R` restore. Sessions whose
+  // A write covers the listed sessions and the ones dropped on purpose
+  // since the last write; a stored row the daemon has not restored yet
+  // stays as it is, so a write before `R` keeps it restorable. Deliberate
+  // kills rewrite the fleet; unexpected session/atc deaths do not, so the
+  // last known fleet survives for `R` restore. Sessions whose
   // terminal is gone persist as exited entries, so the killed archive
   // survives a daemon restart too. A session the agent has not yet given
   // its own session id persists as well, under its atc session id alone.
@@ -1416,7 +1425,13 @@ export class SessionManager {
       });
     }
 
-    await this.store.writeFleet(fleet);
+    const removed = [...this.removedIDs];
+
+    await this.store.writeFleet(fleet, removed);
+
+    for (const id of removed) {
+      this.removedIDs.delete(id);
+    }
   }
 
   // A write nobody awaits that fails leaves the stored rows as they were,

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/mcp-server.ts

@@ -2,6 +2,7 @@ import { bootDaemonClient } from './client/boot-daemon';
 import { answerRPCRequest } from './mcp/answer-rpc-request';
 import { requireDaemonFeatures } from './mcp/require-daemon-features';
 import type { FleetCaller, ToolContext } from './mcp/types';
+import { LineDecoder } from './protocol/line-decoder';
 
 /**
  * An MCP server over stdio bridging to the atc daemon: any MCP client —
@@ -34,26 +35,14 @@ export async function runMCPServer(build: string): Promise<void> {
     sender: { kind: 'default', name: callerSessionID ?? 'mcp' },
   };
 
-  const decoder = new TextDecoder('utf-8');
-
-  let buffer = '';
+  const decoder = new LineDecoder();
 
   // Each request runs on its own, so a long poll never holds up the others;
   // responses carry their request's id.
   const inFlight = new Set<Promise<void>>();
 
   for await (const chunk of Bun.stdin.stream()) {
-    buffer += decoder.decode(chunk, { stream: true });
-
-    const lines = buffer.split('\n');
-
-    buffer = lines.pop() ?? '';
-
-    for (const line of lines) {
-      if (line.trim() === '') {
-        continue;
-      }
-
+    for (const line of decoder.splitChunk(chunk)) {
       const finished = Promise.withResolvers<void>();
 
       inFlight.add(finished.promise);

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/line-decoder.ts

@@ -0,0 +1,34 @@
+/**
+ * Splits one stream of newline-framed text into whole lines. Bytes decode
+ * as UTF-8 with state kept across reads, so a multi-byte character split
+ * between two reads decodes whole. The unterminated tail waits for the read
+ * that ends it, and a line holding only whitespace is dropped. A carriage
+ * return before the newline stays on the line.
+ */
+export class LineDecoder {
+  private readonly decoder = new TextDecoder();
+
+  private pending = '';
+
+  get pendingLength(): number {
+    return this.pending.length;
+  }
+
+  // oxlint-disable-next-line prefer-readonly-parameter-types -- a socket read buffer has no readonly form
+  splitChunk(bytes: Uint8Array): string[] {
+    return this.splitText(this.decodeText(bytes));
+  }
+
+  // oxlint-disable-next-line prefer-readonly-parameter-types -- a socket read buffer has no readonly form
+  decodeText(bytes: Uint8Array): string {
+    return this.decoder.decode(bytes, { stream: true });
+  }
+
+  splitText(text: string): string[] {
+    const lines = `${this.pending}${text}`.split('\n');
+
+    this.pending = lines.pop() ?? '';
+
+    return lines.filter((line) => line.trim() !== '');
+  }
+}

package/src/{shared → protocol}/open-bridge-socket.ts

@@ -1,3 +1,5 @@
+import { LineDecoder } from './line-decoder';
+
 /**
  * One line-framed connection to a session bridge, from inside a remote
  * session: each line the bridge writes arrives whole, and each line written
@@ -20,10 +22,9 @@ export async function openBridgeSocket(
   onLine: (line: Readonly<Record<string, unknown>>) => void,
 ): Promise<BridgeSocket> {
   const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
+  const decoder = new LineDecoder();
 
   const closed = Promise.withResolvers<void>();
-  let pending = '';
 
   let unsent = new Uint8Array(0);
 
@@ -31,11 +32,7 @@ export async function openBridgeSocket(
     unix: path,
     socket: {
       data(_socket, buf) {
-        const lines = `${pending}${decoder.decode(buf, { stream: true })}`.split('\n');
-
-        pending = lines.pop() ?? '';
-
-        for (const line of lines) {
+        for (const line of decoder.splitChunk(buf)) {
           const parsed = parseLine(line);
 
           if (parsed !== null) {

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/report.ts

@@ -1,9 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { sendBridgeRequest } from './protocol/send-bridge-request';
 import { sendReport } from './shared/report';
 import { REPORT_KINDS } from './shared/report-kinds';
-import { sendBridgeRequest } from './shared/send-bridge-request';
 
 interface ReportOptions {
   readonly message: string;

package/src/run-bridge-tap.ts

@@ -1,8 +1,8 @@
 import { readFileSync, readdirSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { openBridgeSocket } from './shared/open-bridge-socket';
-import type { BridgeSocket } from './shared/open-bridge-socket';
+import { openBridgeSocket } from './protocol/open-bridge-socket';
+import type { BridgeSocket } from './protocol/open-bridge-socket';
 
 const INBOX_MESSAGE_SCHEMA = z.looseObject({
   ev: z.literal('InboxMessage'),

package/src/statusline.ts

@@ -1,9 +1,9 @@
 import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { sendBridgeRequest } from './protocol/send-bridge-request';
 import { statusFile } from './shared/config';
 import { isRecord, sendReport } from './shared/report';
-import { sendBridgeRequest } from './shared/send-bridge-request';
 
 /**
  * Runs as the statusLine command injected into wrangled sessions. Chains the

package/src/store/fleet-entry.ts

@@ -72,7 +72,10 @@ export interface FleetEntry {
 export interface FleetStore {
   readonly daemonID: DaemonID;
   readonly loadFleet: () => Promise<FleetEntry[]>;
-  readonly writeFleet: (entries: readonly FleetEntry[]) => Promise<void>;
+  readonly writeFleet: (
+    entries: readonly FleetEntry[],
+    removed?: readonly SessionID[],
+  ) => Promise<void>;
   readonly updateFleetEntry: (sessionID: SessionID, fields: FleetEntryUpdate) => Promise<void>;
 }