@zgeoff/atc 2.28.0 → 2.30.0

package/src/client/spawn-picker.ts

@@ -124,10 +124,14 @@ type SourceStepAction =
  * optional first prompt. The sources are the ones the daemon offers, in
  * its order, and Tab cycles them; a daemon that offers none gets the local
  * directory flow alone. A source of directories is followed by the
- * execution target when the daemon has more than one. A source of git
+ * execution target when more than one target can run it. A source of git
  * repositories opens the target first, then its candidates, the ref, and a
  * confirm screen with the destination the checkout lands in, so every
  * request about the repository is made for the target the spawn runs on.
+ * A choice of agent or target with one row the source can use is no
+ * choice: the flow takes that row and goes on, and Esc from the step after
+ * it goes back past it. A daemon that lists targets none of which can run
+ * the source shows the target step with the reason.
  * Typed input a source does not match against its candidates is read by
  * the source, then by the others in order. Every path out of the flow
  * either attaches the new session or returns the client to the screen it
@@ -155,6 +159,10 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
   // edit or a fresh install lands without a client restart.
   private picks: AgentPick[] = [];
 
+  // Whether the agent step waits on the daemon's targets and sources once
+  // an agent is chosen.
+  private sourcesPending = false;
+
   // The directories the directory step lists, and the label each shows.
   private dirs: string[] = [];
 
@@ -180,6 +188,10 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
 
   private target: TargetPick | null = null;
 
+  // Why the flow offers no target although the daemon lists some, or null
+  // when it offers some or the daemon lists none.
+  private targetGap: string | null = null;
+
   // The git source's candidates and the scope they were listed under, or
   // the notice that stands in for a list the daemon could not give, with
   // the source and target they were listed for. A listing runs behind the
@@ -265,7 +277,9 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
     this.input = '';
     this.sources = null;
     this.sourceIndex = -1;
+    this.sourcesPending = false;
     this.target = null;
+    this.targetGap = null;
     this.repo = null;
     this.ref = null;
     this.sourceDraft = '';
@@ -291,6 +305,14 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
     this.pending = null;
 
     process.stdout.write(ansi.clear);
+
+    // One installed agent is no choice to make, so the flow goes on with it.
+    if (this.picks.length === 1) {
+      void this.openFirstSource();
+
+      return;
+    }
+
     this.render();
   }
 
@@ -325,6 +347,17 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
       return;
     }
 
+    // The agent step waiting on the daemon's targets and sources takes Esc
+    // and the leader, and every other key waits for the answer.
+    if (
+      this.step === 'agent' &&
+      this.sourcesPending &&
+      edit.kind !== 'cancel' &&
+      edit.kind !== 'leader'
+    ) {
+      return;
+    }
+
     const tab = buf.length === 1 && buf[0] === KEY.tab;
 
     // A tab to a source of directories waits for its listing on the step it
@@ -387,10 +420,14 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
 
       // An empty menu means every configured binary is missing, so the hint
       // carries the fix instead of the movement keys.
-      const hint =
-        this.picks.length === 0
-          ? 'no agent CLI found — set claudeBin, grokBin, or codexBin in config.json · esc cancel'
-          : '↑↓ move · ⏎ select · esc cancel';
+      let hint = '↑↓ move · ⏎ select · esc cancel';
+
+      if (this.picks.length === 0) {
+        hint =
+          'no agent CLI found — set claudeBin, grokBin, or codexBin in config.json · esc cancel';
+      } else if (this.sourcesPending) {
+        hint = 'reading targets and sources… · esc cancel';
+      }
 
       drawPicker({
         title: `${verb}: agent`,
@@ -488,13 +525,21 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
 
     const git = this.isGitFlow();
     const what = git ? 'the repository' : formatDir(this.dir);
+    let hint = `where ${what} runs · ↑↓ move · ⏎ select · esc back`;
+
+    // A step with no target the source can run on says what is missing.
+    if (this.collectEligibleTargets().length === 0) {
+      const gap = this.targetGap ?? `none of these targets can run ${what}`;
+
+      hint = `${gap} · set targets in config.json · esc back`;
+    }
 
     drawPicker({
       title: `${verb}: target`,
       items: this.targets.map((t) => formatTargetPick(t)),
       selected: this.selected,
       input: '',
-      hint: this.refusal ?? `where ${what} runs · ↑↓ move · ⏎ select · esc back`,
+      hint: this.refusal ?? hint,
       dimmed: new Set(
         this.targets.flatMap((t, i) =>
           t.takesWorkspace || (!git && t.available && t.inPlace) ? [] : [i],
@@ -666,11 +711,19 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
 
     if (this.step === 'dir') {
       this.openAgentStep();
-    } else if (this.step === 'source') {
+
+      return;
+    }
+
+    if (this.step === 'source') {
       this.sourceDraft = typed;
 
       this.applySourceCancel();
-    } else if (this.step === 'ref') {
+
+      return;
+    }
+
+    if (this.step === 'ref') {
       this.input = this.repo?.label ?? '';
       this.repo = null;
       this.step = 'source';
@@ -684,10 +737,8 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
       if (this.isGitFlow()) {
         this.input = this.buildDestination();
         this.step = 'confirm';
-      } else {
-        this.openTargetStep(() => {
-          this.step = 'dir';
-        });
+      } else if (!this.openTargetStep()) {
+        this.step = 'dir';
       }
     } else {
       this.input = this.name;
@@ -698,20 +749,33 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
     this.render();
   }
 
+  // Goes back to the agent step, or leaves the flow when one installed
+  // agent left no agent step to go back to.
   private openAgentStep() {
+    if (this.picks.length === 1) {
+      this.quitFlow();
+
+      return;
+    }
+
     this.selected = Math.max(
       0,
       this.picks.findIndex((p) => p.agent === this.agent),
     );
 
+    this.sourcesPending = false;
     this.step = 'agent';
+
+    process.stdout.write(ansi.clear);
+    this.render();
   }
 
-  // Leaves a git source step backwards: to the target step when the daemon
-  // has more than one target, else to the agent.
+  // Leaves a git source step backwards: to the target step when the spawn
+  // has one, else to the agent.
   private applySourceCancel() {
-    if (this.targets.length >= 2) {
-      this.openTargetStep(() => {});
+    if (this.openTargetStep()) {
+      process.stdout.write(ansi.clear);
+      this.render();
 
       return;
     }
@@ -737,8 +801,6 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
 
     if (index === -1) {
       this.openAgentStep();
-      process.stdout.write(ansi.clear);
-      this.render();
 
       return;
     }
@@ -841,9 +903,9 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
     this.dir = dir;
     this.input = '';
 
-    this.openTargetStep(() => {
+    if (!this.openTargetStep()) {
       this.step = 'name';
-    });
+    }
 
     process.stdout.write(ansi.clear);
     this.render();
@@ -1028,8 +1090,8 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
   }
 
   // Moves the flow to a source of git repositories, carrying the typed text
-  // across: the target step first when the daemon has more than one target
-  // and the flow had no repository target yet, then the source step, which
+  // across: the target step first when the spawn has one and the flow had
+  // no repository target yet, then the source step, which
   // acts as asked once it opens.
   private openGitSource(index: number, draft: string, action: SourceStepAction) {
     const fromGit = this.isGitFlow();
@@ -1045,16 +1107,13 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
       return;
     }
 
-    if (this.targets.length >= 2) {
-      this.openTargetStep(() => {});
+    if (this.openTargetStep()) {
       process.stdout.write(ansi.clear);
       this.render();
 
       return;
     }
 
-    this.target = this.targets[0] ?? null;
-
     this.openSourceStep();
   }
 
@@ -1599,19 +1658,22 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
     return this.target ?? this.targets.find((t) => t.isDefault) ?? null;
   }
 
-  // Opens the target step when the daemon has more than one target, and
-  // the fallback step otherwise. The chosen target is selected, else for a
-  // repository the default when it takes a workspace and the first target
-  // that does when it does not, else the default.
-  private openTargetStep(fallback: () => void) {
-    if (this.targets.length < 2) {
-      // The one target is the spawn's, default or not, so the spawn names it
-      // and its provider decides whether a directory runs in place.
-      this.target = this.targets[0] ?? null;
+  // Opens the target step when more than one target can run the flow's
+  // source, or none can although the daemon lists targets, and answers
+  // whether it did. The chosen target is selected, else for a repository
+  // the default when it takes a workspace and the first target that does
+  // when it does not, else the default.
+  private openTargetStep(): boolean {
+    const eligible = this.collectEligibleTargets();
 
-      fallback();
+    if (eligible.length === 1 || (this.targets.length === 0 && this.targetGap === null)) {
+      // The one target that can run the source is the spawn's, default or
+      // not, so the spawn names it and its provider decides whether a
+      // directory runs in place. A daemon that lists no targets runs the
+      // spawn on its default.
+      this.target = eligible[0] ?? null;
 
-      return;
+      return false;
     }
 
     const preferred =
@@ -1629,6 +1691,15 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
 
     this.input = '';
     this.step = 'target';
+
+    return true;
+  }
+
+  // The targets the flow's source can run on.
+  private collectEligibleTargets(): TargetPick[] {
+    const git = this.isGitFlow();
+
+    return this.targets.filter((t) => findTargetRefusal(t, git) === null);
   }
 
   // Reads the daemon's targets and sources once the agent is chosen, and
@@ -1638,6 +1709,10 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
     const generation = this.generation;
     let listed: Readonly<Record<string, unknown>> = {};
 
+    this.sourcesPending = true;
+
+    this.render();
+
     try {
       listed = await this.deps.sendRequest('agents.list');
     } catch {}
@@ -1649,12 +1724,20 @@ export class SpawnPicker<TMirror extends { readonly id: string }> {
     // An agent that takes its credential from impd's broker runs only on a
     // target that reaches the broker.
     const brokered = isBrokerAgent(listed['agents'], this.agent);
-    const picks = collectTargetPicks(listed).filter((t) => !brokered || t.brokerAuth);
+    const listedTargets = collectTargetPicks(listed);
+    const picks = listedTargets.filter((t) => !brokered || t.brokerAuth);
 
     // An adopt resumes a session from its history on this host, which a
     // fresh checkout elsewhere does not hold, so it is offered only the
     // targets that run here.
     this.targets = this.resume ? picks.filter((t) => t.available && t.inPlace) : picks;
+    this.targetGap = null;
+
+    if (listedTargets.length > 0 && picks.length === 0) {
+      this.targetGap = `no target reaches the credential broker ${this.agent} needs`;
+    } else if (listedTargets.length > 0 && this.targets.length === 0) {
+      this.targetGap = 'no target on this host can adopt a session';
+    }
 
     const announced = parseAnnouncedSources(listed['sources']);
     const index = this.resume ? announced.findIndex((source) => source.kind === 'path') : 0;

package/src/client/to-mirror-session.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import type { SessionState } from '../protocol/session-state';
 import type { AgentID } from '../shared/agent-id';
+import { isRecord } from '../shared/report';
 import { toAgentID } from '../shared/to-agent-id';
 
 export interface MirrorSession {
@@ -20,8 +21,24 @@ export interface MirrorSession {
   canEject: boolean;
   agent: AgentID;
   parent: string | null;
+
+  // The execution target the session runs on, from the descriptor's
+  // locator; 'local' when the descriptor carries none.
+  target: string;
+
+  // The model the session was spawned with, as the daemon stores it: null
+  // when it runs the agent's default. An alias a gateway's models map
+  // resolves is resolved at draw time, where the map is at hand.
+  model: string | null;
+
+  // Where the session's harness stands: running, suspended inside a
+  // sleeping host, or exited. Distinct from `state`, which carries the
+  // attention a live harness last reported.
+  harness: HarnessLifecycle;
 }
 
+export type HarnessLifecycle = 'running' | 'suspended' | 'exited';
+
 // Only the fields a mirror can't function without; an unparseable descriptor
 // is skipped rather than thrown into the event loop. Unknown keys pass
 // through so the lenient fallbacks below can still read them.
@@ -63,5 +80,32 @@ export function toMirrorSession(value: unknown): MirrorSession | null {
     canEject: record['canEject'] === true,
     agent: toAgentID(record['agent']),
     parent: typeof record['parent'] === 'string' ? record['parent'] : null,
+    target: readTargetID(record['locator']),
+    model: typeof record['model'] === 'string' ? record['model'] : null,
+    harness: readHarnessLifecycle(record['lifecycle'], record.alive),
   };
 }
+
+// The locator's target id, with 'local' for a descriptor that carries no
+// locator at all.
+function readTargetID(locator: unknown): string {
+  if (isRecord(locator) && typeof locator['targetID'] === 'string') {
+    return locator['targetID'];
+  }
+
+  return 'local';
+}
+
+// The harness layer of a descriptor's lifecycle, falling back to what the
+// alive flag says when the lifecycle is missing.
+function readHarnessLifecycle(lifecycle: unknown, alive: boolean): HarnessLifecycle {
+  if (isRecord(lifecycle)) {
+    const harness = lifecycle['harness'];
+
+    if (harness === 'running' || harness === 'suspended' || harness === 'exited') {
+      return harness;
+    }
+  }
+
+  return alive ? 'running' : 'exited';
+}

package/src/client/ui.ts

@@ -3,9 +3,11 @@ import type { SessionState } from '../protocol/session-state';
 import type { AgentID } from '../shared/agent-id';
 import { RESET_INPUT_MODES } from '../shared/reset-input-modes';
 import { formatDir } from './dirs';
-import { formatOverlayAgentMark } from './format-overlay-agent-mark';
+import { planOverlayColumns } from './plan-overlay-columns';
+import type { OverlayColumnPlan } from './plan-overlay-columns';
 import { planVacatedRows } from './plan-vacated-rows';
 import type { BoxExtent } from './plan-vacated-rows';
+import type { HarnessLifecycle } from './to-mirror-session';
 
 // The slice of a session the drawing layer needs; satisfied by both the
 // daemon's sessions and the wire descriptors a client mirrors.
@@ -39,13 +41,6 @@ const GLYPH: Record<SessionState, string> = {
   exited: `${ESC}[90m✗${ESC}[0m`,
 };
 
-const STATE_LABEL: Record<SessionState, string> = {
-  needs_you: 'NEEDS YOU',
-  running: 'running',
-  done: 'done',
-  exited: 'exited',
-};
-
 function out(s: string) {
   process.stdout.write(s);
 }
@@ -194,14 +189,25 @@ export interface OverlaySessionView extends SessionView {
   readonly agent: AgentID;
   readonly pinned: boolean;
   readonly repoRoot: string;
+  readonly target: string;
+  readonly model: string | null;
+
+  // Where the session's harness stands, apart from the attention its state
+  // carries: running, suspended inside a sleeping host, or exited.
+  readonly harness: HarnessLifecycle;
 }
 
 export interface OverlayView {
   sessions: readonly OverlaySessionView[];
 
-  // The overlay column character per agent id, for the ids that do not use
-  // the built-in one.
-  agentMarks: Readonly<Record<AgentID, string>>;
+  // The readable name per agent id, and each agent's tier-alias map, from
+  // the daemon's `agents.list` answer over the config.
+  agentLabels: Readonly<Record<AgentID, string>>;
+  agentModels: Readonly<Record<AgentID, Readonly<Record<string, string>>>>;
+
+  // Whether more than one execution target is available to spawn on, which
+  // is what brings the target column in.
+  showTarget: boolean;
   selected: number;
   confirmKill: boolean;
 
@@ -213,6 +219,67 @@ export interface OverlayView {
   grouped: boolean;
 }
 
+// A daemon-supplied id or alias can name an inherited property, so map
+// reads go through an own-property check instead of indexing blindly.
+function readMapValue<V>(map: Readonly<Record<string, V>>, key: string): V | undefined {
+  return Object.hasOwn(map, key) ? map[key] : undefined;
+}
+
+// A session's model as the row draws it: the daemon answer's alias target,
+// or the raw model string when the answer maps nothing for it.
+function resolveModelAlias(
+  models: Readonly<Record<AgentID, Readonly<Record<string, string>>>>,
+  agent: AgentID,
+  model: string,
+): string {
+  const aliases = readMapValue(models, agent);
+
+  return aliases === undefined ? model : (readMapValue(aliases, model) ?? model);
+}
+
+// A session row draws status (the attention glyph plus the unread mark),
+// pin, name, the flat view's directory, then the target, harness, model,
+// harness lifecycle, and last event columns the width plan allows.
+export function buildSessionRow(
+  s: Readonly<OverlaySessionView>,
+  plan: Readonly<OverlayColumnPlan>,
+  view: Readonly<OverlayView>,
+  sel: boolean,
+): Row {
+  const sub = s.parent !== null && view.sessions.some((x) => x.id === s.parent);
+
+  const name =
+    plan.nameWidth >= 4 && sub
+      ? `↳ ${truncate(s.name, plan.nameWidth - 2)}`.padEnd(plan.nameWidth)
+      : truncate(s.name, plan.nameWidth).padEnd(plan.nameWidth);
+
+  const dir =
+    plan.dirWidth > 0 ? truncate(formatDir(s.cwd), plan.dirWidth).padEnd(plan.dirWidth) : '';
+
+  const target =
+    plan.targetWidth > 0 ? truncate(s.target, plan.targetWidth).padEnd(plan.targetWidth) : '';
+
+  const label = readMapValue(view.agentLabels, s.agent) ?? s.agent;
+  const harness = truncate(label, plan.harnessWidth).padEnd(plan.harnessWidth);
+  const resolved = s.model === null ? '' : resolveModelAlias(view.agentModels, s.agent, s.model);
+
+  const model =
+    plan.modelWidth > 0 ? truncate(resolved, plan.modelWidth).padEnd(plan.modelWidth) : '';
+
+  const lifecycle = truncate(s.harness, plan.lifecycleWidth).padEnd(plan.lifecycleWidth);
+  const event = truncate(s.lastMsg, plan.eventWidth).padEnd(plan.eventWidth);
+  const cells = [name, dir, target, harness, model, lifecycle, event].filter((cell) => cell !== '');
+  const body = cells.join(' ');
+  const styledBody = sel ? `${ESC}[7m${body}${ESC}[0m` : body;
+  const unread = s.unread ? `${ESC}[1;33m!${ESC}[0m` : ' ';
+  const pin = s.pinned ? `${ESC}[93m⋆${ESC}[0m` : ' ';
+
+  return {
+    styled: `${GLYPH[s.state]}${unread}${pin} ${styledBody}`,
+    width: 4 + body.length,
+  };
+}
+
 export function drawOverlay(view: OverlayView) {
   const width = Math.min(cols() - 4, 90);
   const rowsList: Row[] = [boxTop(width, 'sessions')];
@@ -223,6 +290,35 @@ export function drawOverlay(view: OverlayView) {
     rowsList.push(dimRow(width, empty));
   }
 
+  // The harness label and the model each row would draw, so the columns
+  // take the width of what is actually on screen.
+  const harnessMax = Math.max(
+    0,
+    ...view.sessions.map((s) => (readMapValue(view.agentLabels, s.agent) ?? s.agent).length),
+  );
+
+  const modelMax = Math.max(
+    0,
+    ...view.sessions.map((s) => {
+      if (s.model === null) {
+        return 0;
+      }
+
+      return resolveModelAlias(view.agentModels, s.agent, s.model).length;
+    }),
+  );
+
+  const targetMax = Math.max(0, ...view.sessions.map((s) => s.target.length));
+
+  const plan = planOverlayColumns({
+    innerWidth: width - 4,
+    grouped: view.grouped,
+    showTarget: view.showTarget,
+    targetMax,
+    harnessMax,
+    modelMax,
+  });
+
   // The grouped view clusters sessions under dim repository headers, with
   // pinned sessions leading in their own cluster; the flat view shows a
   // directory column instead. The rows keep the sorted order either way. A
@@ -239,22 +335,9 @@ export function drawOverlay(view: OverlayView) {
       rowsList.push(dimRow(width, `▸ ${s.pinned ? 'pinned' : formatDir(s.repoRoot)}`));
     }
 
-    const sel = i === view.selected;
-    const name = (sub ? `↳ ${truncate(s.name, 14)}` : truncate(s.name, 16)).padEnd(16);
-    const state = STATE_LABEL[s.state].padEnd(9);
-    const dir = view.grouped ? '' : ` ${truncate(formatDir(s.cwd), 18).padEnd(18)}`;
-    const msgWidth = Math.max(4, width - 4 - 4 - 17 - 10 - (view.grouped ? 0 : 19));
-    const msg = truncate(s.lastMsg, msgWidth).padEnd(msgWidth);
-    const unread = s.unread ? `${ESC}[1;33m!${ESC}[0m` : ' ';
-    const pin = s.pinned ? `${ESC}[93m⋆${ESC}[0m` : ' ';
-    const mark = formatOverlayAgentMark(s.agent, view.agentMarks);
-    const styledMark = mark === ' ' ? mark : `${ESC}[90m${mark}${ESC}[0m`;
-    const body = `${name} ${state}${dir} ${msg}`;
-    const styledBody = sel ? `${ESC}[7m${body}${ESC}[0m` : body;
+    const row = buildSessionRow(s, plan, view, i === view.selected);
 
-    rowsList.push(
-      boxRow(width, `${GLYPH[s.state]}${unread}${pin}${styledMark}${styledBody}`, 4 + body.length),
-    );
+    rowsList.push(boxRow(width, row.styled, row.width));
   }
 
   rowsList.push(boxDivider(width));
@@ -371,7 +454,6 @@ export function drawHelp() {
     'p  pin or unpin — pinned sessions stay on top',
     '    a sub-session pins with its parent',
     'g  toggle grouping by repository',
-    '    Grok rows show a dim g after the pin mark',
     'n  new session',
     'r  adopt an external session',
     '/  filter · ↑↓/jk move · q quit',