@zgeoff/atc 2.15.0 → 2.15.2

package/src/mcp/reconnecting-caller.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { DaemonClient } from '../client/daemon-client';
+import type { DaemonChannel } from '../protocol/daemon-channel';
 import type { DaemonFeature } from '../protocol/daemon-features';
 import { parseDaemonFeatures } from '../protocol/parse-daemon-features';
 import { requireDaemonFeatures } from './require-daemon-features';
@@ -30,7 +30,7 @@ const KEYED_METHODS: ReadonlyMap<string, DaemonFeature> = new Map<string, Daemon
 
 // One handshaken connection and the features its daemon announced.
 interface DaemonConnection {
-  readonly client: DaemonClient;
+  readonly client: DaemonChannel;
   readonly features: ReadonlySet<DaemonFeature>;
 }
 
@@ -48,13 +48,22 @@ export class ReconnectingCaller implements FleetCaller {
 
   private readonly build: string;
 
+  private readonly openChannel: (socketPath: string) => Promise<DaemonChannel>;
+
   private client: Promise<DaemonConnection> | null = null;
 
-  private readonly closed = new WeakSet<DaemonClient>();
+  private readonly closed = new WeakSet<DaemonChannel>();
 
-  constructor(socketPath: string, build: string) {
+  // The last argument connects to the daemon at a socket path; each channel
+  // it returns is handshaken here before a request rides it.
+  constructor(
+    socketPath: string,
+    build: string,
+    openChannel: (socketPath: string) => Promise<DaemonChannel>,
+  ) {
     this.socketPath = socketPath;
     this.build = build;
+    this.openChannel = openChannel;
   }
 
   // The required features are checked against each connection right before
@@ -141,10 +150,10 @@ export class ReconnectingCaller implements FleetCaller {
       }
     };
 
-    let client: DaemonClient;
+    let client: DaemonChannel;
 
     try {
-      client = await DaemonClient.open(this.socketPath);
+      client = await this.openChannel(this.socketPath);
     } catch (error) {
       resetClient();
       throw error;

package/src/mcp/remove-client.ts

@@ -1,5 +1,5 @@
 import type { Kysely } from 'kysely';
-import type { MCPAuthSchema } from './types';
+import type { MCPAuthSchema } from './mcp-auth-schema';
 
 /**
  * Removes a client and everything it holds: its access and refresh tokens,

package/src/mcp/revoke-grant.ts

@@ -1,5 +1,5 @@
 import type { Kysely } from 'kysely';
-import type { MCPAuthSchema } from './types';
+import type { MCPAuthSchema } from './mcp-auth-schema';
 
 /**
  * Revokes a grant: its access and refresh tokens go, along with the

package/src/mcp/types.ts

@@ -25,44 +25,6 @@ export interface ToolContext {
   readonly sender: { readonly kind: 'fixed' | 'default'; readonly name: string };
 }
 
-/**
- * The columns of the authorization server's database that atc reads and
- * writes itself. better-auth owns the tables and their migrations; dates are
- * ISO 8601 strings and string lists are JSON arrays.
- */
-export interface MCPAuthSchema {
-  readonly oauthClient: {
-    readonly id: string;
-    readonly clientId: string;
-    readonly name: string | null;
-    readonly redirectUris: string;
-    readonly createdAt: string | null;
-  };
-  readonly oauthAccessToken: {
-    readonly id: string;
-    readonly token: string;
-    readonly clientId: string;
-    readonly sessionId: string | null;
-    readonly authorizationCodeId: string | null;
-  };
-  readonly oauthRefreshToken: {
-    readonly id: string;
-    readonly clientId: string;
-    readonly sessionId: string | null;
-    readonly authorizationCodeId: string | null;
-    readonly scopes: string;
-    readonly createdAt: string;
-    readonly expiresAt: string;
-    readonly revoked: string | null;
-  };
-  readonly oauthConsent: { readonly id: string; readonly clientId: string };
-  readonly oauthResource: { readonly identifier: string };
-  readonly session: { readonly id: string; readonly expiresAt: string };
-
-  // When each grant last reached /mcp, keyed by the grant's authorization code id.
-  readonly atc_grant_use: { readonly grant_id: string; readonly last_used_at: string };
-}
-
 /**
  * The authorization server's store: the better-auth instance and the
  * database under it.

package/src/mcp-http-server.ts

@@ -1,5 +1,6 @@
 import { mkdirSync } from 'node:fs';
 import { bootDaemonClient } from './client/boot-daemon';
+import { DaemonClient } from './client/daemon-client';
 import { collectClients } from './mcp/collect-clients';
 import { openMCPAuth } from './mcp/open-mcp-auth';
 import { ReconnectingCaller } from './mcp/reconnecting-caller';
@@ -27,7 +28,7 @@ export async function runMCPHTTPServer(build: string, flags: MCPHTTPFlags): Prom
 
   mkdirSync(stateDir, { recursive: true });
 
-  const caller = new ReconnectingCaller(boot.socketPath, build);
+  const caller = new ReconnectingCaller(boot.socketPath, build, (path) => DaemonClient.open(path));
 
   const server = await startMCPHTTPServer({
     caller,

package/src/protocol/adapter-event.ts

@@ -0,0 +1,25 @@
+import type { AgentSessionID } from '../shared/agent-session-id';
+
+/**
+ * What an adapter makes of one hook event: the agent-neutral kind and the
+ * fields the daemon and the store act on.
+ */
+export interface AdapterEvent {
+  kind: 'started' | 'needs-input' | 'turn-done' | 'prompt-submitted' | 'ended' | 'heartbeat';
+  agentSessionID?: AgentSessionID;
+  message?: string;
+
+  // Fuller activity text than message: what the agent last said or was
+  // asked, for briefing. Bounded by the adapter.
+  detail?: string;
+
+  // Opaque handle the adapter can later pull a session name from.
+  nameSource?: string;
+
+  // Claude resume-existence path. Distinct from nameSource: a naming
+  // handle is not a resume gate.
+  transcriptSource?: string;
+
+  // The agent's whole final message for a finished turn; detail holds a bounded preview of it.
+  result?: string;
+}

package/src/protocol/count-session-states.ts

@@ -0,0 +1,16 @@
+import type { SessionState } from './session-state';
+
+/**
+ * How many of the sessions are in each state.
+ */
+export function countSessionStates(
+  list: readonly { readonly state: SessionState }[],
+): Record<SessionState, number> {
+  const c = { needs_you: 0, running: 0, done: 0, exited: 0 };
+
+  for (const s of list) {
+    c[s.state]++;
+  }
+
+  return c;
+}

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

package/src/store/run-migrations.ts

@@ -56,6 +56,8 @@ interface EventsTable {
 
 interface SpawnHistoryTable {
   cwd: string;
+  target: string;
+  target_identity: string;
   last_spawn: number;
 }
 
@@ -152,8 +154,9 @@ export interface StateStoreSchema {
 // 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, until the
 // rebuild that keys the table by the atc session id. events later gains
-// columns of its own, as does messages, while spawn_history and prefs have
-// carried one shape since they were added.
+// columns of its own, as does messages, spawn_history is rebuilt to key each
+// directory by the target it was spawned on, and prefs has carried one shape
+// since it was added.
 const MIGRATIONS: Record<string, Migration> = {
   '001_create_initial_schema': {
     async up(db: Kysely<StateStoreSchema>) {
@@ -446,6 +449,29 @@ const MIGRATIONS: Record<string, Migration> = {
       await db.schema.alterTable('events').addColumn('report_text', 'text').execute();
     },
   },
+  '024_rebuild_spawn_history_keyed_by_target': {
+    async up(db: Kysely<StateStoreSchema>) {
+      // The ledger records this step only after it returns, so a crash in
+      // between leaves a rebuilt table behind a ledger that still lacks it.
+      const columns = await sql<ColumnInfoRow>`PRAGMA table_info(spawn_history)`.execute(db);
+
+      if (columns.rows.some((column) => column.name === 'target')) {
+        return;
+      }
+
+      await sql`BEGIN IMMEDIATE`.execute(db);
+
+      try {
+        await updateSpawnHistoryKeyToTarget(db);
+
+        await sql`COMMIT`.execute(db);
+      } catch (error) {
+        await sql`ROLLBACK`.execute(db);
+
+        throw error;
+      }
+    },
+  },
 };
 
 const PROVIDER: MigrationProvider = {
@@ -457,8 +483,9 @@ const PROVIDER: MigrationProvider = {
  * `Migrator`, one additive step at a time. A database from before the
  * ladder existed is recognized at whichever shape it stopped at by a
  * baselining pass that records the steps its columns already satisfy, so
- * only what is genuinely missing runs. One step rebuilds the fleet table
- * under a new key and carries every row across; no step drops a row.
+ * only what is genuinely missing runs. Two steps rebuild a table under a
+ * new key, the fleet and the spawn history, and carry every row across; no
+ * step drops a row.
  */
 export async function runMigrations(db: Kysely<StateStoreSchema>): Promise<void> {
   // A baselined step can land out of order relative to a step that turned
@@ -652,6 +679,30 @@ interface ColumnInfoRow {
   type: string;
 }
 
+// The identity of the local target with no options. Every spawn from before
+// spawns recorded their target ran there.
+const LEGACY_SPAWN_TARGET_IDENTITY = 'local-pty:44136fa355b3678a';
+
+async function updateSpawnHistoryKeyToTarget(db: Kysely<StateStoreSchema>): Promise<void> {
+  await sql`
+    CREATE TABLE spawn_history_rebuilt (
+      cwd TEXT NOT NULL,
+      target TEXT NOT NULL,
+      target_identity TEXT NOT NULL,
+      last_spawn INTEGER NOT NULL,
+      PRIMARY KEY (cwd, target, target_identity)
+    )
+  `.execute(db);
+
+  await sql`
+    INSERT INTO spawn_history_rebuilt (cwd, target, target_identity, last_spawn)
+    SELECT cwd, 'local', ${LEGACY_SPAWN_TARGET_IDENTITY}, last_spawn FROM spawn_history
+  `.execute(db);
+
+  await sql`DROP TABLE spawn_history`.execute(db);
+  await sql`ALTER TABLE spawn_history_rebuilt RENAME TO spawn_history`.execute(db);
+}
+
 async function collectFleetColumns(db: Kysely<StateStoreSchema>): Promise<ReadonlySet<string>> {
   const result = await sql<ColumnInfoRow>`PRAGMA table_info(fleet)`.execute(db);
 

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';
@@ -63,6 +64,27 @@ export interface StoredEvent {
   readonly label?: string;
 }
 
+// The target a spawn ran on: its name and the identity the spawned session
+// was bound to there.
+interface SpawnTarget {
+  readonly target: string;
+  readonly targetIdentity: string;
+}
+
+// A directory a spawn ran in and the target it ran on.
+export interface SpawnDir {
+  readonly cwd: string;
+  readonly grant: SpawnTarget;
+}
+
+/**
+ * Another message one turn answered, and the atc id it was sent to.
+ */
+export interface TurnSibling {
+  readonly id: MessageID;
+  readonly atcID: SessionID;
+}
+
 /**
  * One report as the trail holds it. A report recorded before the trail kept
  * whole texts has only its preview, so its text is that preview and
@@ -512,24 +534,38 @@ export class StateStore {
     return row?.ts === null || row?.ts === undefined ? null : Date.parse(row.ts);
   }
 
-  async recordSpawnDir(cwd: string): Promise<void> {
+  async recordSpawnDir(cwd: string, grant: SpawnTarget): Promise<void> {
     await this.db
       .insertInto('spawn_history')
-      .values({ cwd, last_spawn: Date.now() })
+      .values({
+        cwd,
+        target: grant.target,
+        target_identity: grant.targetIdentity,
+        last_spawn: Date.now(),
+      })
       .onConflict((oc) =>
-        oc.column('cwd').doUpdateSet((eb) => ({ last_spawn: eb.ref('excluded.last_spawn') })),
+        oc
+          .columns(['cwd', 'target', 'target_identity'])
+          .doUpdateSet((eb) => ({ last_spawn: eb.ref('excluded.last_spawn') })),
       )
       .execute();
   }
 
-  async collectSpawnDirs(): Promise<string[]> {
+  /**
+   * Each directory a spawn ran in, with the target it ran on, most recent
+   * first. A directory spawned on several targets has one entry for each.
+   */
+  async collectSpawnDirs(): Promise<SpawnDir[]> {
     const rows = await this.db
       .selectFrom('spawn_history')
-      .select('cwd')
+      .select(['cwd', 'target', 'target_identity'])
       .orderBy('last_spawn', 'desc')
       .execute();
 
-    return rows.map((row) => row.cwd);
+    return rows.map((row) => ({
+      cwd: row.cwd,
+      grant: { target: row.target, targetIdentity: row.target_identity },
+    }));
   }
 
   async loadLastUsedAgent(): Promise<AgentID> {
@@ -606,7 +642,7 @@ export class StateStore {
 
   // The other messages of the same session the given message's turn
   // answered, oldest first; none when the message has no turn.
-  async collectTurnSiblings(record: MessageRecord): Promise<MessageID[]> {
+  async collectTurnSiblings(record: MessageRecord): Promise<TurnSibling[]> {
     if (record.turn === undefined) {
       return [];
     }
@@ -618,7 +654,7 @@ export class StateStore {
 
     const rows = await this.db
       .selectFrom('messages')
-      .select('id')
+      .select(['id', 'atc_id'])
       .where('turn_id', '=', record.turn)
       .where('id', '!=', record.id)
       .where((eb) => buildOwnerFilter(eb, owner))
@@ -626,7 +662,7 @@ export class StateStore {
       .orderBy(sql`rowid`, 'asc')
       .execute();
 
-    return rows.map((row) => toMessageID(row.id));
+    return rows.map((row) => ({ id: toMessageID(row.id), atcID: toSessionID(row.atc_id) }));
   }
 
   async updateMessageDelivered(