@zgeoff/atc 2.14.0 → 2.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "2.14.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/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/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/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';
@@ -278,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;
 
@@ -352,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();
 

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/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-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/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/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>;
 }
 

package/src/store/state-store.ts

@@ -241,12 +241,22 @@ export class StateStore {
     return recency;
   }
 
-  // Replaces this daemon's rows wholesale and leaves every other daemon's
-  // rows as they stand. A session another daemon owns, or one whose stored
-  // ownership epoch has moved past this daemon's, rejects the whole write
-  // with stale_epoch.
-  async writeFleet(entries: readonly FleetEntry[]): Promise<void> {
+  // Rewrites this daemon's rows for the given entries and drops its rows
+  // for the removed sessions, plus any row of its own that an entry
+  // replaces by holding the same agent session id. Every other row stays as
+  // it stands, so a row the daemon never loaded survives a write. A session
+  // another daemon owns, or one whose stored ownership epoch has moved past
+  // this daemon's, rejects the whole write with stale_epoch.
+  async writeFleet(
+    entries: readonly FleetEntry[],
+    removed: readonly SessionID[] = [],
+  ): Promise<void> {
     const kept = buildFleetWithoutReplacedRows(entries);
+    const sessionIDs = [...entries.map((entry) => entry.sessionID), ...removed];
+
+    const agentSessionIDs = entries.flatMap((entry) =>
+      entry.agentSessionID === undefined ? [] : [entry.agentSessionID],
+    );
 
     await this.db.transaction().execute(async (trx) => {
       await requireCurrentOwnership(
@@ -255,17 +265,35 @@ export class StateStore {
         entries.map((entry) => entry.sessionID),
       );
 
-      await trx
-        .deleteFrom('fleet')
-        .where('session_id', 'in', (eb) =>
-          eb
-            .selectFrom('session_owner')
-            .select('session_id')
-            .where('daemon_id', '=', this.daemonID),
-        )
-        .execute();
+      const replaced =
+        agentSessionIDs.length === 0
+          ? []
+          : await trx
+              .selectFrom('fleet')
+              .select(['session_id', 'agent_session_id'])
+              .where('agent_session_id', 'in', agentSessionIDs)
+              .execute();
 
-      await trx.deleteFrom('session_owner').where('daemon_id', '=', this.daemonID).execute();
+      const dropped = [...new Set([...sessionIDs, ...replaced.map((row) => row.session_id)])];
+
+      if (dropped.length > 0) {
+        await trx
+          .deleteFrom('fleet')
+          .where('session_id', 'in', dropped)
+          .where('session_id', 'in', (eb) =>
+            eb
+              .selectFrom('session_owner')
+              .select('session_id')
+              .where('daemon_id', '=', this.daemonID),
+          )
+          .execute();
+
+        await trx
+          .deleteFrom('session_owner')
+          .where('daemon_id', '=', this.daemonID)
+          .where('session_id', 'in', dropped)
+          .execute();
+      }
 
       const updatedAt = Date.now();
 
@@ -304,6 +332,38 @@ export class StateStore {
           })
           .execute();
       }
+
+      // A stored row this write leaves in place follows its replaced parent
+      // to the session that replaced it, or to that session's own parent
+      // when the replacement is itself a sub-session.
+      const survivors = new Map(
+        kept.flatMap((entry) =>
+          entry.agentSessionID === undefined ? [] : [[entry.agentSessionID, entry] as const],
+        ),
+      );
+
+      for (const row of replaced) {
+        const survivor =
+          row.agent_session_id === null
+            ? undefined
+            : survivors.get(toAgentSessionID(row.agent_session_id));
+
+        if (survivor === undefined || survivor.sessionID === row.session_id) {
+          continue;
+        }
+
+        await trx
+          .updateTable('fleet')
+          .set({ parent_session_id: survivor.parent ?? survivor.sessionID })
+          .where('parent_session_id', '=', row.session_id)
+          .where('session_id', 'in', (eb) =>
+            eb
+              .selectFrom('session_owner')
+              .select('session_id')
+              .where('daemon_id', '=', this.daemonID),
+          )
+          .execute();
+      }
     });
   }