@zgeoff/atc 2.14.0 → 2.15.1

package/src/protocol/daemon-channel.ts

@@ -0,0 +1,17 @@
+/**
+ * One open protocol connection to a daemon, as a caller that does not own
+ * the transport drives it: the handshake, correlated requests, a callback
+ * for when the connection ends, and closing it.
+ */
+export interface DaemonChannel {
+  onClose: () => void;
+  readonly sendHello: (build: string) => Promise<Readonly<Record<string, unknown>>>;
+
+  // A request with a principal acts as that principal.
+  readonly sendRequest: (
+    m: string,
+    p?: Readonly<Record<string, unknown>>,
+    as?: string,
+  ) => Promise<Readonly<Record<string, unknown>>>;
+  readonly stop: () => void;
+}

package/src/protocol/hook-event.ts

@@ -0,0 +1,11 @@
+import type { SessionID } from '../shared/session-id';
+
+/**
+ * One line a hook reporter sends: the atc session it reports on, the agent's
+ * hook event name, and the hook's payload as the agent gave it.
+ */
+export interface HookEvent {
+  atcId: SessionID;
+  event: string;
+  payload: Record<string, unknown>;
+}

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/pinned-group-key.ts

@@ -0,0 +1,2 @@
+// Never a filesystem path, so a repository can't collide with it.
+export const PINNED_GROUP_KEY = ' pinned';

package/src/protocol/session-state.ts

@@ -0,0 +1,5 @@
+/**
+ * Where a session stands for the person watching it: busy, waiting on them,
+ * finished with a turn, or ended.
+ */
+export type SessionState = 'running' | 'needs_you' | 'done' | 'exited';

package/src/protocol/sort-grouped-session-views.ts

@@ -0,0 +1,29 @@
+import { PINNED_GROUP_KEY } from './pinned-group-key';
+import { sortSessionViews } from './sort-session-views';
+import type { SortableSessionView } from './sortable-session-view';
+
+// Overlay display order for the grouped view: the flat sort with each
+// repository's sessions pulled together at the position of its best-ranked
+// member, so the renderer's adjacency-based headers appear once per group.
+// Pinned sessions form their own leading group. A sub-session keys by its
+// parent, so a set never splits across groups.
+export function sortGroupedSessionViews<
+  T extends SortableSessionView & { readonly repoRoot: string },
+>(list: readonly T[]): T[] {
+  const byID = new Map(list.map((s) => [s.id, s]));
+  const buckets = new Map<string, T[]>();
+
+  for (const s of sortSessionViews(list)) {
+    const owner = (s.parent === null ? undefined : byID.get(s.parent)) ?? s;
+    const key = owner.pinned ? PINNED_GROUP_KEY : owner.repoRoot;
+    const bucket = buckets.get(key);
+
+    if (bucket === undefined) {
+      buckets.set(key, [s]);
+    } else {
+      bucket.push(s);
+    }
+  }
+
+  return [...buckets.values()].flat();
+}

package/src/protocol/sort-session-views.ts

@@ -0,0 +1,41 @@
+import type { SessionState } from './session-state';
+import type { SortableSessionView } from './sortable-session-view';
+
+// Overlay order: pinned sessions first in most-recently-attached order, then
+// everyone else by urgency — who needs you, finished turns, busy, dead —
+// with most-recently-attached breaking ties inside each state. A
+// sub-session sits directly under its parent, ranked among its siblings
+// alone, so its attention never moves the parent's row; a sub-session whose
+// parent is not listed ranks as a top-level row.
+export function sortSessionViews<T extends SortableSessionView>(list: readonly T[]): T[] {
+  const rank: Record<SessionState, number> = {
+    needs_you: 0,
+    done: 1,
+    running: 2,
+    exited: 3,
+  };
+
+  const ranked = [...list].toSorted((a, b) => {
+    if (a.pinned !== b.pinned) {
+      return a.pinned ? -1 : 1;
+    }
+
+    const recency = b.lastAttachedAt - a.lastAttachedAt || b.createdAt - a.createdAt;
+
+    return a.pinned ? recency : rank[a.state] - rank[b.state] || recency;
+  });
+
+  const listed = new Set(ranked.map((s) => s.id));
+
+  const sorted: T[] = [];
+
+  for (const s of ranked) {
+    if (s.parent !== null && listed.has(s.parent)) {
+      continue;
+    }
+
+    sorted.push(s, ...ranked.filter((child) => child.parent === s.id));
+  }
+
+  return sorted;
+}

package/src/protocol/sortable-session-view.ts

@@ -0,0 +1,13 @@
+import type { SessionState } from './session-state';
+
+/**
+ * The fields of a session row that the overlay orders by.
+ */
+export interface SortableSessionView {
+  readonly id: string;
+  readonly parent: string | null;
+  readonly state: SessionState;
+  readonly pinned: boolean;
+  readonly lastAttachedAt: number;
+  readonly createdAt: number;
+}

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/shared/agent-id.ts

@@ -0,0 +1,6 @@
+/**
+ * Which agent a session runs under: the key the adapter registry is looked
+ * up by. Every agent CLI supplies one, and so does every configured backend
+ * that drives a CLI it does not own, so two ids can share one kind.
+ */
+export type AgentID = string;

package/src/shared/collect-gateways.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { AgentID } from '../agents/agent-adapter';
+import type { AgentID } from './agent-id';
 import { buildOptionalStringArray } from './build-optional-string-array';
 import { isRecord } from './report';
 

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

@@ -0,0 +1,11 @@
+import type { AgentID } from './agent-id';
+
+/**
+ * Missing and empty values become Claude so a fleet written before the agent
+ * column still restores as Claude. Any other string is returned as it stands,
+ * registered or not: an id whose adapter is gone must reach the caller intact
+ * so the session can be shown and refused, never quietly run as Claude.
+ */
+export function toAgentID(raw: unknown): AgentID {
+  return typeof raw === 'string' && raw !== '' ? raw : 'claude';
+}

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

@@ -1,12 +1,12 @@
 import { z } from 'zod';
-import { toAgentID } from '../agents/agent-adapter';
-import type { AgentID } from '../agents/agent-adapter';
+import type { AgentID } from '../shared/agent-id';
 import type { AgentSessionID } from '../shared/agent-session-id';
 import { buildOptionalBoolean } from '../shared/build-optional-boolean';
 import { buildOptionalString } from '../shared/build-optional-string';
 import type { DaemonID } from '../shared/daemon-id';
 import { isRecord } from '../shared/report';
 import type { SessionID } from '../shared/session-id';
+import { toAgentID } from '../shared/to-agent-id';
 import { toAgentSessionID } from '../shared/to-agent-session-id';
 import type { SessionWorkspace } from './workspace-materialization';
 
@@ -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

@@ -3,19 +3,20 @@ import { randomUUID } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { Kysely, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, sql } from 'kysely';
 import type { Expression, ExpressionBuilder, SqlBool, Transaction } from 'kysely';
-import { toAgentID } from '../agents/agent-adapter';
-import type { AdapterEvent, AgentID } from '../agents/agent-adapter';
-import type { HookEvent } from '../daemon/hooks';
+import type { AdapterEvent } from '../protocol/adapter-event';
 import { DaemonError } from '../protocol/daemon-error';
+import type { HookEvent } from '../protocol/hook-event';
+import type { AgentID } from '../shared/agent-id';
 import type { AgentSessionID } from '../shared/agent-session-id';
+import { BunSqliteDriver } from '../shared/bun-sqlite-driver';
 import type { DaemonID } from '../shared/daemon-id';
 import type { MessageID } from '../shared/message-id';
 import type { SessionID } from '../shared/session-id';
+import { toAgentID } from '../shared/to-agent-id';
 import { toAgentSessionID } from '../shared/to-agent-session-id';
 import { toDaemonID } from '../shared/to-daemon-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, LegacyFleetEntry } from './fleet-entry';
 import type { EffectTarget, IdempotencyClaim, IdempotencyRecord } from './idempotency-record';
@@ -241,12 +242,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 +266,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 +333,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();
+      }
     });
   }