@detergent-software/conductor 2.1.1-dev.1 → 2.2.0-dev.1

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 Releases are tagged `conductor-v<version>` and staged on npm by `atk-conductor-release` (`pipelines/release-conductor.yml`), which writes each section below. `scripts/check-changelog.mjs` fails when a tag has no section here.
 
+## [2.2.0-dev.1](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/branchCompare?baseVersion=GTconductor-v2.1.1-dev.1&targetVersion=GTconductor-v2.2.0-dev.1) (2026-10-16)
+
+### Features
+
+* **conductor:** fleet pane rows in columns with waits in words ([3d79d73](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/commit/3d79d7398e45db3e2a05ea569c594b95dbcfcdc7))
+
+### Bug Fixes
+
+* **conductor:** keep the fleet row's wait at narrow widths ([9ccf333](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/commit/9ccf33371347ef43bdd0e6d08f43b6f193eb3200))
+
 ## [2.1.1-dev.1](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/branchCompare?baseVersion=GTconductor-v2.1.0&targetVersion=GTconductor-v2.1.1-dev.1) (2026-10-16)
 
 ### Refactoring

package/README.md

@@ -729,7 +729,7 @@ It runs `claude -n conductor --permission-mode auto -- /conductor-console` with
 - **Other sessions** get nothing from it: no status line, and no calls to the daemon.
 - **The console**, the session started with `CONDUCTOR_CONSOLE=1` (`conduct console` starts it; see Console), reads `GET /fleet`, `GET /inbox` and `GET /notify` every 30 s and gets:
   - **the band** above the prompt while the inbox has items: one hotkey per item (a plan approves after a second press, `y`, since a digit typed into an empty prompt presses a band button; an npm OTP copies its `npm stage approve` line; the rest open the pane), and `o` for the pane;
-  - **the pane** (`/conductor`, `o`, or opened at the start, docked as a sidebar on a fullscreen terminal of 144 columns or more): the notification profile (a picker; buttons on mobile) and Remote Control's state, the inbox with each item's actions (approve, revise, copy a command, open a link, done; on a Windows terminal, open is a button that opens a web link in the default browser once, since a ctrl+click on a link in a pane opened it twice, ATK-494), the workers by project (each project's rule has [pause] and [focus]; a row expands to attach and why), and today's spend;
+  - **the pane** (`/conductor`, `o`, or opened at the start, docked as a sidebar on a fullscreen terminal of 144 columns or more): the notification profile (a picker; buttons on mobile) and Remote Control's state, the inbox with each item's actions (approve, revise, copy a command, open a link, done; on a Windows terminal, open is a button that opens a web link in the default browser once, since a ctrl+click on a link in a pane opened it twice, ATK-494), the workers by project (each project's rule has [pause] and [focus]), and today's spend. The header counts the workers running and parked and the inbox in words. Each worker is one line in columns that line up across projects, cut to the pane's width so it never wraps: a glyph, the item, its phase, its PR, what it waits on in words (`PR #557 to merge (agentic-toolkit-registry)`, `npm 8.9.0-dev.1 on dev (atk)`, `login (ado)`) or else its activity, and the age. As the pane narrows, the age goes first, then the wait, then the PR and the phase (ATK-521). The glyphs are one cell wide: `●` in a turn, `◌` up between turns, `!` stuck on a prompt, `○` parked, `×` failed or gone, `·` starting. A row expands to attach and why, its tokens today, its whole PR ref and its raw wait keys;
   - **commands answered in code**, never by the model: `/conductor`, `/inbox`, `/approve <item | #id>`, `/revise <item | #id> <text>`, `/attach <item | worker>`, `/notify [<profile> [--until <when>]]`, `/pause [<project>] [--until <when>]`, `/unpause [<project>]`, `/focus-project <project> [--until <when>]` (puts its items first, until midnight without `--until`; not `/focus`, which is Claude Code's own);
   - **a check that `/conductor-console` ran**: a console started without it (by hand, as `claude -n conductor`) shows `console without its skill: run /conductor-console` in the band, and each prompt, Jason's or an escalation's, carries a line telling the model to load the skill before it answers. Running the skill (`/conductor-console`, or the model's Skill tool) clears both, until a `/clear` or a resume starts a conversation without it;
   - **a warm prompt cache while it idles** (ATK-386). The console's cache lasts an hour after its last use, and a wake after that writes the whole context again. So 55 minutes after the console's last turn, the mod sends one ping (`$.model.fork`, the console's own last request plus a one-word ask, no tools, no turn in the transcript). The API serves the ping from the cache for a tenth of a write's price, and the hour starts over. It pings again every 55 minutes until a turn comes, and each turn starts the timer over. At an idle point it runs `/clear` instead when the context is 150k or more, or after 12 pings in a row (the 13th idle point, about 12 hours after the last turn), and the band says `fresh console (cleared while idle: …)` until the next prompt loads the skill. A ping that read less than half the context from the cache (the cache was gone anyway, as under a 5-minute TTL) stops the pings until the next turn. Each ping and clear goes to `POST /console/cache`, which logs a `console.cache` event with the context size and what the ping cost. A fork isn't in the transcript, so that event is the only place its cost shows;

package/mod/hooks/model.ts

@@ -121,12 +121,12 @@ export type Found<T> = { error: string; found?: undefined } | { error?: undefine
 
 const BAND_LIMIT = 5;
 
-// `conductor 3▶ 2⏸ ✉2` for the pane's title, or undefined when no daemon answers.
+// `3 running · 2 parked · inbox 2` beside the pane's title, or undefined when no daemon answers.
 export function statusText(snapshot: ConductorSnapshot | null): string | undefined {
   if (snapshot === null || snapshot.error !== null) return undefined;
   const running = snapshot.workers.filter((w) => w.status === 'running').length;
   const parked = snapshot.workers.filter((w) => w.status === 'parked').length;
-  return `conductor ${running}▶ ${parked}⏸ ✉${snapshot.inbox.length}`;
+  return `${running} running · ${parked} parked · inbox ${snapshot.inbox.length}`;
 }
 
 // The band's buttons: a plan approves (behind a confirm), an npm OTP copies its command, the rest
@@ -159,20 +159,172 @@ export function projectGroups(workers: readonly ConductorWorker[]): ProjectGroup
     }));
 }
 
-// A worker row's glyph: ▶ running, ⏸ parked, ✖ failed or stopped, · otherwise (launching, exited).
-export function glyph(status: string): string {
-  if (status === 'running') return '▶';
-  if (status === 'parked') return '⏸';
-  if (status === 'failed' || status === 'stopped-unexpectedly') return '✖';
-  return '·';
-}
+// What a worker is up to, by its status and its session's activity (manager.ts's activityOf):
+// in a turn, up between turns, stuck on a prompt (`waiting on permission`), parked on a wait,
+// failed or gone (exited too), or not up yet (launching, starting).
+export type WorkerState = 'failed' | 'idle' | 'parked' | 'prompt' | 'starting' | 'working';
+
+export function workerState(w: Pick<ConductorWorker, 'activity' | 'status'>): WorkerState {
+  if (w.status === 'failed' || w.status === 'stopped-unexpectedly' || w.status === 'exited') return 'failed';
+  if (w.status === 'parked') return 'parked';
+  if (w.status !== 'running') return 'starting';
+  if (w.activity === 'working') return 'working';
+  if (w.activity.startsWith('idle')) return 'idle';
+  if (w.activity.startsWith('waiting on ')) return 'prompt';
+  if (w.activity === 'stopped' || w.activity === 'no session') return 'failed';
+  return 'starting';
+}
+
+// A row's glyph and its theme color. None has an emoji form, which Windows Terminal draws two cells
+// wide (⏸ ✖ ✉ did, ATK-521); the shapes are East Asian ambiguous width, one cell outside CJK setups.
+export const GLYPHS: Readonly<Record<WorkerState, { char: string; color: string }>> = {
+  failed: { char: '×', color: 'error' },
+  idle: { char: '◌', color: 'suggestion' },
+  parked: { char: '○', color: 'subtle' },
+  prompt: { char: '!', color: 'warning' },
+  starting: { char: '·', color: 'subtle' },
+  working: { char: '●', color: 'success' },
+};
 
 // A worker's PR as its row shows it: `#1850`; the expanded row shows the whole ref.
 export function prLabel(pr: null | string): string {
   return pr === null ? '' : `#${pr.slice(pr.lastIndexOf('#') + 1)}`;
 }
 
-// What a worker waits on or does: its open wait, else the session's activity.
+const PR_EVENTS: Readonly<Record<string, string>> = { merged: 'to merge' };
+
+// A wait's condition key (conditions.ts's formatCondition) in words, the telling part first so a
+// truncated row keeps it: `PR #557 to merge (agentic-toolkit-registry)`, `npm 1.2.3 on dev (atk)`.
+// A kind this doesn't know, or a key it can't read, stays as it is.
+export function waitLabel(condition: string, now: number): string {
+  const colon = condition.indexOf(':');
+  if (colon === -1) return condition;
+  const rest = condition.slice(colon + 1);
+  const read = (pattern: RegExp): string[] | null => pattern.exec(rest)?.slice(1) ?? null;
+  const short = (sha: string): string => sha.slice(0, 7);
+  const last = (path: string): string => path.slice(path.lastIndexOf('/') + 1);
+  switch (condition.slice(0, colon)) {
+    case 'approval':
+      return 'plan approval';
+    case 'health': {
+      const [env = '', field = '', value = ''] = read(/^([^:]+):(commit|version)=(.+)$/) ?? [];
+      if (env) return `${env} health at ${field === 'commit' ? short(value) : value}`;
+      break;
+    }
+    case 'item': {
+      const [item = '', field = '', value = ''] = read(/^[^:]+:([^:]+):(state|label|note)=(.*)$/) ?? [];
+      if (item) return `${item} ${field} ${value}`.trimEnd();
+      break;
+    }
+    case 'login': {
+      const [provider = ''] = read(/^([^:]+):/) ?? [];
+      if (provider) return `login (${provider})`;
+      break;
+    }
+    case 'merge': {
+      const [sha = '', only] = read(/^(?:ado|github):[^@]+@([0-9a-f]+)(?::for=(.+))?$/i) ?? [];
+      if (sha) return `runs of ${short(sha)}${only ? ` (${only})` : ''}`;
+      break;
+    }
+    case 'npm': {
+      const [pkg = '', version = '', tag = ''] = read(/^(.+)@([^@:]+):([^:]+)$/) ?? [];
+      if (pkg) return `npm ${version} on ${tag} (${last(pkg)})`;
+      break;
+    }
+    case 'pr': {
+      const [host = '', repo = '', number = '', on = ''] = read(/^(ado|github):([^#]+)#(\d+):(\w+)$/) ?? [];
+      // An ADO PR is in the project's own repo; a GitHub one names its repo.
+      if (host) return `PR #${number} ${PR_EVENTS[on] ?? on}${host === 'github' ? ` (${last(repo)})` : ''}`;
+      break;
+    }
+    case 'run': {
+      const [pipeline = '', id = ''] = read(/^(?:ado|github):(.+)#(\d+):done$/) ?? [];
+      if (pipeline) return `run #${id} to finish (${last(pipeline).replace(/\.ya?ml$/, '')})`;
+      break;
+    }
+    case 'time':
+      if (!Number.isNaN(Date.parse(rest))) return `timer, ${remaining(rest, now)} left`;
+      break;
+  }
+  return condition;
+}
+
+// What a worker waits on, in words (and how many more waits), else the session's activity.
+export function workerDoing(w: ConductorWorker, now: number): string {
+  const [first, ...more] = w.waits;
+  if (first === undefined) return w.activity;
+  return `${waitLabel(first, now)}${more.length > 0 ? ` +${more.length}` : ''}`;
+}
+
+// The fleet's column widths: the widest name, phase (at most PHASE_MAX) and PR across every project,
+// so the rows line up under each other wherever they are.
+export type FleetColumns = { key: number; phase: number; pr: number };
+
+// One worker's row as the pane draws it, in segments, each with its leading space: together at
+// most the pane's width, so it never wraps. `isWait` says `doing` is a wait (drawn full strength).
+export type FleetRow = {
+  age: string;
+  color: string;
+  doing: string;
+  glyph: string;
+  isWait: boolean;
+  key: string;
+  meta: string;
+};
+
+const PHASE_MAX = 13;
+const DOING_MIN = 12;
+const DOING_SHORT = 6;
+const AGE_WIDTH = 4;
+
+export function fleetColumns(workers: readonly ConductorWorker[]): FleetColumns {
+  const widest = (texts: string[]): number => Math.max(0, ...texts.map((t) => t.length));
+  return {
+    key: widest(workers.map((w) => w.name)),
+    phase: Math.min(PHASE_MAX, widest(workers.map((w) => w.phase ?? ''))),
+    pr: widest(workers.map((w) => prLabel(w.pr))),
+  };
+}
+
+// The row in `width` cells: glyph, name, phase, PR, what it does or waits on, age. Where they don't
+// all fit, the age goes first, then the doing text, then the PR, then the phase. Which columns show
+// depends only on the fleet's widths, so every row keeps the same ones.
+export function fleetRow(w: ConductorWorker, columns: FleetColumns, width: number, now: number): FleetRow {
+  const key = Math.max(1, Math.min(columns.key, width - 2));
+  const shown = new Map<'age' | 'doing' | 'phase' | 'pr', number>([
+    ['phase', columns.phase],
+    ['pr', columns.pr],
+    ['doing', DOING_MIN],
+    ['age', AGE_WIDTH],
+  ]);
+  for (const [column, cells] of shown) if (cells === 0 && column !== 'doing') shown.delete(column);
+  const need = (): number => 2 + key + [...shown.values()].reduce((sum, cells) => sum + cells + 1, 0);
+  for (const column of ['age', 'doing', 'pr', 'phase'] as const) if (need() > width) shown.delete(column);
+  // The doing text comes back in what room is left, while that still shows a few words.
+  if (!shown.has('doing') && width - need() - 1 >= DOING_SHORT) shown.set('doing', width - need() - 1);
+  const cell = (column: 'age' | 'doing' | 'phase' | 'pr', text: string): string => {
+    const cells = shown.get(column);
+    if (cells === undefined) return '';
+    return ` ${column === 'doing' ? fit(text, cells + Math.max(0, width - need())) : fit(text, cells)}`;
+  };
+  const { char, color } = GLYPHS[workerState(w)];
+  return {
+    age: shown.has('age') ? ` ${age(w.updatedAt, now).padStart(AGE_WIDTH)}` : '',
+    color,
+    doing: cell('doing', workerDoing(w, now)),
+    glyph: char,
+    isWait: w.waits.length > 0,
+    key: ` ${fit(w.name, key)}`,
+    meta: `${cell('phase', w.phase ?? '')}${cell('pr', prLabel(w.pr))}`,
+  };
+}
+
+// `text` in exactly `cells` cells: padded, or cut with an ellipsis.
+function fit(text: string, cells: number): string {
+  if (text.length <= cells) return text.padEnd(cells);
+  return cells <= 1 ? '…'.slice(0, cells) : `${text.slice(0, cells - 1).trimEnd()}…`.padEnd(cells);
+}
+
 // A link the terminal's [open] hands to the OS opener (ATK-494): one a Link would make a link of,
 // an https: URL or http://localhost. Anything else, such as a path, stays a Link, drawn as text.
 export function isWebLink(href: string): boolean {
@@ -184,10 +336,6 @@ export function isWebLink(href: string): boolean {
   }
 }
 
-export function workerDoing(w: ConductorWorker): string {
-  return w.waits[0] ?? w.activity;
-}
-
 // The open plan of `ref` (as `conduct approve` finds it): an item key, or an inbox id as #12.
 export function findPlan(inbox: readonly ConductorInboxItem[], ref: string): Found<ConductorInboxItem> {
   const byId = /^#(\d+)$/.exec(ref.trim());

package/mod/hooks/register.tsx

@@ -14,7 +14,8 @@ import {
   errorOf,
   findPlan,
   findWorker,
-  glyph,
+  fleetColumns,
+  fleetRow,
   homeOf,
   idleAction,
   inboxText,
@@ -29,7 +30,6 @@ import {
   parseLine,
   type PingOutcome,
   pingOutcome,
-  prLabel,
   profileText,
   projectGroups,
   type PushOutcome,
@@ -45,7 +45,6 @@ import {
   WARM_AFTER_MS,
   WARM_PROMPT,
   whyText,
-  workerDoing,
 } from './model.ts';
 
 const PANE = 'conductor';
@@ -744,10 +743,13 @@ export const register: Register = (on) => {
         </Box>
       );
     }
+    const columns = fleetColumns(snap.workers);
     return (
       <Box flexDirection='column'>
-        <Text bold>
-          {TITLE} <Text dimColor>{statusText(snap)}</Text>
+        <Text bold wrap='truncate'>
+          {TITLE}
+          {'  '}
+          <Text dimColor>{statusText(snap)}</Text>
         </Text>
         {snap.notify !== null && (
           <Box columnGap={2} flexWrap='wrap'>
@@ -846,36 +848,40 @@ export const register: Register = (on) => {
                 onPress={async () => $.ui.toast(await override($, 'focus', group.project))}
               />
             </Box>
-            {group.rows.map((w) => (
-              <Box flexDirection='column' key={`worker-${w.id}`}>
-                <Button
-                  key={`row-${w.id}`}
-                  onPress={() => update($, expanded, (name) => (name === w.name ? null : w.name))}
-                  plain
-                >
-                  {glyph(w.status)} {w.name} {w.phase ?? ''}
-                  {w.pr === null ? '' : ` ${prLabel(w.pr)}`}{' '}
-                  <Text dimColor>
-                    {workerDoing(w)} · {age(w.updatedAt, now)} · {tokens(w.spendToday)} tok
-                  </Text>
-                </Button>
-                {open === w.name && (
-                  <Box columnGap={2} flexWrap='wrap' marginLeft={2}>
-                    <Button
-                      key={`attach-${w.id}`}
-                      label='attach'
-                      onPress={async () => $.ui.toast(await attach($, w.id, w.name))}
-                    />
-                    <Button key={`why-${w.id}`} label='why' onPress={async () => $.ui.toast(await why($, w.item))} />
-                    <Text dimColor>
-                      {w.status}
-                      {w.pr === null ? '' : ` · PR ${w.pr}`}
-                      {w.waits.length > 0 ? ` · waits on ${w.waits.join(', ')}` : ''}
-                    </Text>
-                  </Box>
-                )}
-              </Box>
-            ))}
+            {group.rows.map((w) => {
+              // One line in the fleet's columns, cut to the pane's width so it never wraps.
+              const row = fleetRow(w, columns, e.props.bodyColumns, now);
+              return (
+                <Box flexDirection='column' key={`worker-${w.id}`}>
+                  <Button
+                    key={`row-${w.id}`}
+                    onPress={() => update($, expanded, (name) => (name === w.name ? null : w.name))}
+                    plain
+                  >
+                    <Text color={row.color}>{row.glyph}</Text>
+                    <Text bold>{row.key}</Text>
+                    <Text dimColor>{row.meta}</Text>
+                    <Text dimColor={!row.isWait}>{row.doing}</Text>
+                    <Text dimColor>{row.age}</Text>
+                  </Button>
+                  {open === w.name && (
+                    <Box columnGap={2} flexWrap='wrap' marginLeft={2}>
+                      <Button
+                        key={`attach-${w.id}`}
+                        label='attach'
+                        onPress={async () => $.ui.toast(await attach($, w.id, w.name))}
+                      />
+                      <Button key={`why-${w.id}`} label='why' onPress={async () => $.ui.toast(await why($, w.item))} />
+                      <Text dimColor>
+                        {w.status} · {tokens(w.spendToday)} tok today
+                        {w.pr === null ? '' : ` · PR ${w.pr}`}
+                        {w.waits.length > 0 ? ` · waits on ${w.waits.join(', ')}` : ''}
+                      </Text>
+                    </Box>
+                  )}
+                </Box>
+              );
+            })}
           </Box>
         ))}
         <Text dimColor wrap='truncate'>

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@detergent-software/conductor",
-	"version": "2.1.1-dev.1",
+	"version": "2.2.0-dev.1",
 	"description": "Conductor: the local daemon that runs conducted projects' work loops (conduct serve) and its conduct CLI.",
 	"type": "module",
 	"bin": {