@detergent-software/conductor 1.0.0-dev.2 → 1.0.0-dev.21

package/mod/.claude-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "conductor",
+  "version": "1.0.0",
+  "description": "The conductor console's plumbing: a status line in every session, and in the console the inbox band, the fleet pane, zero-token commands, Remote Control pushes and escalation wake-ups.",
+  "author": { "name": "Emergent Software" },
+  "types": "./types/index.d.ts"
+}

package/mod/README.md

@@ -0,0 +1,17 @@
+# Conductor mod
+
+A Claude Code plugin (a hooks module) that does the conductor console's plumbing in code, so it costs no tokens: a status line in every session and, in the console (`CONDUCTOR_CONSOLE=1`), the inbox band, the fleet pane, `/conductor` `/inbox` `/approve` `/revise` `/attach` `/notify` `/pause` `/unpause` `/focus-project`, toasts, Remote Control pushes (and the one warning when Remote Control is off), and the one model wake-up for an escalation. What it shows and does is in the conductor README's *Mod* section (`apps/conductor/README.md`).
+
+Install it with the daemon's CLI, which ships this folder:
+
+```text
+conduct install-mod
+```
+
+| File | Holds |
+|---|---|
+| `hooks/register.tsx` | the hooks: session start, commands, the band, the pane, the event stream; only its top-level functions take `$` |
+| `hooks/model.ts` | the logic without the engine: parsing the daemon's answers, what the status line, band and pane show, what each event asks for |
+| `types/index.d.ts` | the `$.state` contract (`conductor.snapshot`, `confirming`, `expanded`) |
+| `tests/conductor.test.tsx` | `claude plugin test`: the hooks against the engine, the daemon faked beneath them |
+| `tests/model.spec.ts` | vitest (`pnpm -C apps/conductor test`, in CI): `model.ts` |

package/mod/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.tsx"] }

package/mod/hooks/model.ts

@@ -0,0 +1,457 @@
+// The conductor mod's logic, with nothing of the engine in it: what the daemon's answers mean, what
+// the status line, band and pane show, and what each event asks the mod to do. register.tsx does
+// the engine's part (only its top-level functions may take `$`); vitest tests this file in CI
+// (apps/conductor/mod/tests/model.spec.ts).
+import type { ConductorInboxItem, ConductorNotify, ConductorSnapshot, ConductorWorker } from '../types';
+
+// A daemon API answer: its status and parsed JSON body.
+export type ApiAnswer = { body: unknown; status: number };
+
+// One line of `conduct events --follow`: an event of the log (with its id), or the stream's state.
+export type StreamLine = { data: Record<string, unknown>; id: number | null; kind: string; subject: string | null };
+
+// What an event asks of the mod. Only `escalate` wakes the console's model.
+export type Reaction =
+  | { kind: 'disconnected' }
+  | { kind: 'escalate'; text: string }
+  | { kind: 'ignore' }
+  | { kind: 'push'; message: string }
+  | { kind: 'refresh'; toast: string | null }
+  | { kind: 'send'; text: string; to: string };
+
+// What a Remote Control push came to: reached the phone (ok); not, as Remote Control is off
+// (inactive) or pushes are off in Claude Code's config (disabled); not sent to the phone on
+// purpose (skipped: Jason is at the terminal, or the answer says nothing about the phone); or the
+// call failed (failed: it threw, was denied, or answered an error).
+export type PushOutcome = { detail: string; state: 'disabled' | 'failed' | 'inactive' | 'ok' | 'skipped' };
+
+// Said once in the console when pushes stop reaching the phone (ATK-255), by why.
+export function pushWarning(outcome: PushOutcome): null | string {
+  switch (outcome.state) {
+    case 'disabled':
+      return "conductor: mobile pushes are off in Claude Code's config, so pushes reach this terminal only. Turn them on, or /notify away for Pushover.";
+    case 'failed':
+      return `conductor: a Remote Control push failed (${outcome.detail}). /notify away sends by Pushover instead.`;
+    case 'inactive':
+      return 'conductor: Remote Control is off, so pushes reach this terminal only. Connect Remote Control, or /notify away for Pushover.';
+    case 'ok':
+    case 'skipped':
+      return null;
+  }
+}
+
+// The state the daemon records for a push's outcome (POST /notify/report).
+export function reportedState(outcome: PushOutcome): 'failing' | 'inactive' | 'ok' | 'skipped' {
+  if (outcome.state === 'disabled') return 'inactive';
+  return outcome.state === 'failed' ? 'failing' : outcome.state;
+}
+
+// A band entry and the act its press does.
+export type BandEntry = { act: 'approve' | 'copy' | 'pane'; hotkey: string; id: number; label: string; text: string };
+
+export type ProjectGroup = { project: string; rows: ConductorWorker[]; running: number };
+
+// A lookup by the item key, or an inbox id written #12; a message when it doesn't resolve to one.
+export type Found<T> = { error: string; found?: undefined } | { error?: undefined; found: T };
+
+const BAND_LIMIT = 5;
+
+// `conductor 3▶ 2⏸ ✉2`, or undefined (the line cleared) 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}`;
+}
+
+// The band's buttons: a plan approves (behind a confirm), an npm OTP copies its command, the rest
+// open the pane, where each item's commands and links are.
+export function bandEntries(inbox: readonly ConductorInboxItem[]): BandEntry[] {
+  return inbox.slice(0, BAND_LIMIT).map((item, i) => {
+    const key = item.item ?? `#${item.id}`;
+    const hotkey = String(i + 1);
+    if (item.kind === 'plan' && item.item !== null) return { act: 'approve', hotkey, id: item.id, label: `approve ${key}`, text: item.text };
+    const command = item.commands[0];
+    if (item.kind === 'npm-otp' && command !== undefined) return { act: 'copy', hotkey, id: item.id, label: `copy OTP line ${key}`, text: command };
+    return { act: 'pane', hotkey, id: item.id, label: `${item.kind} ${key}`, text: item.text };
+  });
+}
+
+// The fleet by project, running workers first within each, projects by name.
+export function projectGroups(workers: readonly ConductorWorker[]): ProjectGroup[] {
+  const byProject = new Map<string, ConductorWorker[]>();
+  for (const w of workers) byProject.set(w.project, [...(byProject.get(w.project) ?? []), w]);
+  return [...byProject.entries()]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([project, rows]) => ({
+      project,
+      rows: [...rows].sort((a, b) => Number(b.status === 'running') - Number(a.status === 'running') || a.name.localeCompare(b.name)),
+      running: rows.filter((w) => w.status === 'running').length,
+    }));
+}
+
+// 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 waits on or does: its open wait, else the session's activity.
+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());
+  if (byId) {
+    const item = inbox.find((i) => i.id === Number(byId[1]));
+    return item ? { found: item } : { error: `no open inbox item ${ref}` };
+  }
+  if (/^\d+$/.test(ref.trim())) return { error: `"${ref}" is ambiguous: name the item, such as ATK-${ref.trim()}, or the inbox id as #${ref.trim()}` };
+  const plans = inbox.filter((i) => i.kind === 'plan' && i.item?.toUpperCase() === ref.trim().toUpperCase());
+  if (plans.length === 1 && plans[0]) return { found: plans[0] };
+  if (plans.length === 0) return { error: `no plan of ${ref} waits in the inbox` };
+  return { error: `several plans of ${ref} wait: name one as ${plans.map((p) => `#${p.id}`).join(' or ')}` };
+}
+
+// A worker in flight by name or item; a name match wins, as `conduct attach` finds it.
+export function findWorker(workers: readonly ConductorWorker[], ref: string): Found<ConductorWorker> {
+  const byName = workers.filter((w) => w.name === ref);
+  const matches = byName.length > 0 ? byName : workers.filter((w) => w.item.toUpperCase() === ref.toUpperCase());
+  if (matches.length === 1 && matches[0]) return { found: matches[0] };
+  if (matches.length === 0) return { error: `no worker "${ref}" in flight` };
+  return { error: `"${ref}" names several workers: ${matches.map((w) => `${w.name} in ${w.project}`).join(', ')}` };
+}
+
+// `/inbox`'s answer: one line per item, then its commands and links.
+export function inboxText(inbox: readonly ConductorInboxItem[], now: number): string {
+  if (inbox.length === 0) return 'The inbox is empty.';
+  return inbox
+    .flatMap((i) => [
+      `#${i.id}  ${i.kind}  ${i.item ?? ''}${i.project ? ` (${i.project})` : ''}  ${age(i.raisedAt, now)}`,
+      `    ${i.text}`,
+      ...i.commands.map((c) => `    $ ${c}`),
+      ...i.links.map((l) => `    ${l}`),
+    ])
+    .join('\n');
+}
+
+// "now", "12m", "3h", "2d".
+export function age(iso: string, now: number): string {
+  const minutes = Math.floor((now - Date.parse(iso)) / 60_000);
+  if (!(minutes >= 1)) return 'now';
+  if (minutes < 60) return `${minutes}m`;
+  if (minutes < 24 * 60) return `${Math.floor(minutes / 60)}h`;
+  return `${Math.floor(minutes / (24 * 60))}d`;
+}
+
+// The time left until `iso`: "12m", "3h", "2d"; "<1m" when it is (almost) up.
+export function remaining(iso: string, now: number): string {
+  const minutes = Math.floor((Date.parse(iso) - now) / 60_000);
+  if (!(minutes >= 1)) return '<1m';
+  if (minutes < 60) return `${minutes}m`;
+  if (minutes < 24 * 60) return `${Math.floor(minutes / 60)}h`;
+  return `${Math.floor(minutes / (24 * 60))}d`;
+}
+
+// 950, 42k, 6.1M.
+export function tokens(n: number): string {
+  if (n < 1000) return String(n);
+  if (n < 1_000_000) return `${Math.round(n / 1000)}k`;
+  return `${(n / 1_000_000).toFixed(1)}M`;
+}
+
+export function spendToday(workers: readonly ConductorWorker[]): number {
+  return workers.reduce((sum, w) => sum + w.spendToday, 0);
+}
+
+// One line of the follow stream, or null for anything that isn't an event object.
+export function parseLine(line: string): null | StreamLine {
+  let value: unknown;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord(value) || typeof value.kind !== 'string') return null;
+  return {
+    data: isRecord(value.data) ? value.data : {},
+    id: typeof value.id === 'number' ? value.id : null,
+    kind: value.kind,
+    subject: typeof value.subject === 'string' ? value.subject : null,
+  };
+}
+
+// What an event asks of the mod. Remote Control pushes, escalations and worker messages are
+// contracts the daemon's notifier (ATK-313) and rules (ATK-315) emit; the mod only carries them out.
+export function reaction(line: StreamLine): Reaction {
+  const text = (key: string): null | string => {
+    const value = line.data[key];
+    return typeof value === 'string' && value.trim() !== '' ? value : null;
+  };
+  switch (line.kind) {
+    case 'conduct.connected':
+      return { kind: 'refresh', toast: null };
+    case 'conduct.disconnected':
+      return { kind: 'disconnected' };
+    case 'console.escalated': {
+      const ask = text('text');
+      // The id is what the console reports back on (`conduct escalations done <id>`).
+      return ask === null
+        ? { kind: 'ignore' }
+        : { kind: 'escalate', text: `[conductor] escalation${line.id === null ? '' : ` #${line.id}`}${line.subject ? ` on ${line.subject}` : ''}: ${ask}` };
+    }
+    case 'inbox.raised': {
+      const ask = text('text');
+      return { kind: 'refresh', toast: ask === null ? null : `conductor: ${line.subject ? `${line.subject} · ` : ''}${ask}` };
+    }
+    case 'notify.failed':
+    case 'notify.routed':
+    case 'notify.sent':
+      // Nothing the mod draws: only notify.profile and notify.channel change the pane.
+      return { kind: 'ignore' };
+    case 'notify.requested': {
+      const message = text('message');
+      return line.data.channel === 'remote-control' && message !== null ? { kind: 'push', message } : { kind: 'ignore' };
+    }
+    case 'watcher.stats':
+      return { kind: 'ignore' };
+    case 'worker.message-requested': {
+      const to = text('to');
+      const message = text('message');
+      return to === null || message === null ? { kind: 'ignore' } : { kind: 'send', text: message, to };
+    }
+    default:
+      return { kind: 'refresh', toast: null };
+  }
+}
+
+// GET /fleet's body, kept to the fields the mod draws; null when it isn't one.
+export function parseFleet(body: unknown): ConductorWorker[] | null {
+  if (!isRecord(body) || !Array.isArray(body.workers)) return null;
+  return body.workers.flatMap((w): ConductorWorker[] => {
+    if (!isRecord(w) || typeof w.id !== 'number' || typeof w.name !== 'string' || typeof w.status !== 'string') return [];
+    const spend = isRecord(w.spend) && typeof w.spend.today === 'number' ? w.spend.today : 0;
+    const waits = Array.isArray(w.waits)
+      ? w.waits.flatMap((x) => (isRecord(x) && typeof x.condition === 'string' && x.resolvedAt === null ? [x.condition] : []))
+      : [];
+    return [
+      {
+        activity: typeof w.activity === 'string' ? w.activity : w.status,
+        id: w.id,
+        item: typeof w.item === 'string' ? w.item : w.name,
+        name: w.name,
+        phase: typeof w.phase === 'string' ? w.phase : null,
+        project: typeof w.project === 'string' ? w.project : '?',
+        spendToday: spend,
+        status: w.status,
+        updatedAt: typeof w.updatedAt === 'string' ? w.updatedAt : '',
+        waits,
+      },
+    ];
+  });
+}
+
+// GET /inbox's body; null when it isn't one.
+export function parseInbox(body: unknown): ConductorInboxItem[] | null {
+  if (!isRecord(body) || !Array.isArray(body.items)) return null;
+  return body.items.flatMap((i): ConductorInboxItem[] => {
+    if (!isRecord(i) || typeof i.id !== 'number' || typeof i.kind !== 'string' || typeof i.text !== 'string') return [];
+    return [
+      {
+        commands: strings(i.commands),
+        id: i.id,
+        item: typeof i.item === 'string' ? i.item : null,
+        kind: i.kind,
+        links: strings(i.links),
+        project: typeof i.project === 'string' ? i.project : null,
+        raisedAt: typeof i.raisedAt === 'string' ? i.raisedAt : '',
+        text: i.text,
+      },
+    ];
+  });
+}
+
+// The error an API answer carries (`{ error, details }`), as one line.
+export function errorOf(answer: ApiAnswer): string {
+  const { body } = answer;
+  if (isRecord(body) && typeof body.error === 'string') return [body.error, ...strings(body.details)].join('; ');
+  return `the conductor answered ${answer.status}`;
+}
+
+// POST /inbox/:id/resolve's answer as the line to show, as `conduct approve|revise|done` says it.
+export function answerText(action: 'approve' | 'done' | 'revise', id: number, answer: ApiAnswer): string {
+  if (answer.status !== 200) return `not ${action === 'done' ? 'done' : `${action}d`}: ${errorOf(answer)}`;
+  const body = isRecord(answer.body) ? answer.body : {};
+  const key = isRecord(body.item) && typeof body.item.item === 'string' ? body.item.item : `#${id}`;
+  if (action === 'done') return `done: ${key}`;
+  const comment = isRecord(body.comment) ? body.comment : {};
+  const where = typeof comment.url === 'string' ? comment.url : typeof comment.id === 'string' ? comment.id : 'comment posted';
+  return `${action === 'approve' ? 'approved' : 'asked for a revision of'} ${key}: ${where}`;
+}
+
+// The daemon's home as the CLI finds it (apps/conductor/src/paths.ts): CONDUCTOR_HOME, else
+// .conductor under USERPROFILE or HOME.
+export function homeOf(env: { conductorHome?: string; home?: string; userProfile?: string }): null | string {
+  if (env.conductorHome) return env.conductorHome;
+  const user = env.userProfile || env.home;
+  return user ? `${user.replace(/[\\/]+$/, '')}/.conductor` : null;
+}
+
+// The port and token files' text as an endpoint; null unless both are whole.
+export function endpointOf(portText: string, tokenText: string): { port: number; token: string } | null {
+  const port = Number(portText.trim());
+  const token = tokenText.trim();
+  return Number.isInteger(port) && port > 0 && /^[0-9a-f]{64}$/.test(token) ? { port, token } : null;
+}
+
+// GET /fleet, GET /inbox and GET /notify as one snapshot; `error` set when the daemon didn't answer
+// the first two. A daemon older than the notifier answers /notify 404, which leaves `notify` null.
+export function snapshotOf(fleet: ApiAnswer, inbox: ApiAnswer, readAt: number, notify?: ApiAnswer): ConductorSnapshot {
+  const workers = fleet.status === 200 ? parseFleet(fleet.body) : null;
+  if (workers === null) return { error: errorOf(fleet), inbox: [], notify: null, readAt, workers: [] };
+  const items = inbox.status === 200 ? parseInbox(inbox.body) : null;
+  if (items === null) return { error: errorOf(inbox), inbox: [], notify: null, readAt, workers: [] };
+  return { error: null, inbox: items, notify: notify?.status === 200 ? parseNotify(notify.body) : null, readAt, workers };
+}
+
+// GET /notify's body, kept to what the mod draws; null when it isn't one.
+export function parseNotify(body: unknown): ConductorNotify | null {
+  if (!isRecord(body) || typeof body.profile !== 'string') return null;
+  const channels = isRecord(body.channels) ? body.channels : {};
+  const remote = isRecord(channels['remote-control']) ? channels['remote-control'] : {};
+  return {
+    held: typeof body.held === 'number' ? body.held : 0,
+    profile: body.profile,
+    profiles: strings(body.profiles),
+    profileUntil: typeof body.profileUntil === 'string' ? body.profileUntil : null,
+    quietNow: body.quietNow === true,
+    remoteControl: typeof remote.state === 'string' ? remote.state : 'unknown',
+  };
+}
+
+// What `$.tool.call` of PushNotification answered: `{ result: { pushSent, disabledReason }, text }`.
+// Only a push that reached the phone is ok; Remote Control off (no_transport, or the text saying
+// so) is inactive; pushes turned off in the config are disabled; the rest say nothing of the phone.
+export function pushOutcome(answer: unknown): PushOutcome {
+  const call = isRecord(answer) ? answer : {};
+  if (typeof call.deny === 'string') return { detail: `refused: ${call.deny}`, state: 'failed' };
+  const result = isRecord(call.result) ? call.result : {};
+  const detail = typeof call.text === 'string' && call.text.trim() !== '' ? call.text.trim() : typeof result.message === 'string' ? result.message : '';
+  if (call.isError === true) return { detail: detail || 'PushNotification answered an error', state: 'failed' };
+  if (result.pushSent === true) return { detail, state: 'ok' };
+  if (result.disabledReason === 'config_off') return { detail: "Mobile push not sent (off in Claude Code's config)", state: 'disabled' };
+  if (result.disabledReason === 'no_transport' || /remote control inactive/i.test(detail)) {
+    return { detail: detail || 'Mobile push not sent (Remote Control inactive)', state: 'inactive' };
+  }
+  if (result.disabledReason === 'user_present') return { detail: 'Mobile push not sent: you were at the terminal (user_present)', state: 'skipped' };
+  return { detail: detail || 'PushNotification said nothing about the phone', state: 'skipped' };
+}
+
+// `/notify <profile> [--until <when>]`: --until is a local time (the next one), a date (local
+// midnight) or a date and time, as `conduct notify profile` reads it.
+export function notifyArgs(args: string, now: number): { error: string } | { name: string; until: null | string } {
+  const typed = /^(\S+)(?:\s+--until\s+(\S+))?$/.exec(args.trim());
+  if (!typed?.[1]) return { error: 'usage: /notify [<profile> [--until <when>]]' };
+  const when = typed[2];
+  if (when === undefined) return { name: typed[1], until: null };
+  const until = untilOf(when, now);
+  return typeof until === 'string' ? { name: typed[1], until } : until;
+}
+
+const DAYS = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+
+// `--until <when>` as an ISO time: 17:00 (the next one), tomorrow or a day (local midnight), a date
+// (local midnight), or a date and time, as `conduct` reads them.
+export function untilOf(when: string, now: number): string | { error: string } {
+  const clock = /^([01]?\d|2[0-3]):([0-5]\d)$/.exec(when);
+  const lower = when.toLowerCase();
+  const day = DAYS.findIndex((d) => d === lower || d.slice(0, 3) === lower);
+  const at = new Date(now);
+  if (clock) {
+    at.setHours(Number(clock[1]), Number(clock[2]), 0, 0);
+    if (at.getTime() <= now) at.setDate(at.getDate() + 1);
+  } else if (lower === 'tomorrow' || day !== -1) {
+    at.setHours(0, 0, 0, 0);
+    at.setDate(at.getDate() + (lower === 'tomorrow' ? 1 : (day - at.getDay() + 7) % 7 || 7));
+  } else {
+    at.setTime(new Date(/^\d{4}-\d{2}-\d{2}$/.test(when) ? `${when}T00:00` : when).getTime());
+  }
+  if (Number.isNaN(at.getTime())) {
+    return { error: `--until "${when}" is not a time: 17:00, tomorrow, a day such as monday, or a date and time such as 2026-10-12T09:00` };
+  }
+  return at.toISOString();
+}
+
+// `/pause [<project>] [--until <when>]`, `/unpause [<project>]` and `/focus-project <project> [--until
+// <when>]` as POST /overrides' body. A focus with no end lasts until midnight, and puts the
+// project's items first (weight 100).
+export function overrideArgs(command: 'focus' | 'pause' | 'unpause', args: string, now: number): { body: Record<string, unknown> } | { error: string } {
+  const typed = /^(?:([a-z][a-z0-9-]*))?(?:\s*--until\s+(\S+))?$/.exec(args.trim());
+  const usage = { error: command === 'focus' ? 'usage: /focus-project <project> [--until <when>]' : `usage: /${command} [<project>]${command === 'pause' ? ' [--until <when>]' : ''}` };
+  if (!typed) return usage;
+  const [, project, when] = typed;
+  if (command === 'unpause') return when === undefined ? { body: { action: 'unpause', by: 'conductor mod /unpause', ...(project ? { project } : {}) } } : usage;
+  const until = when === undefined ? (command === 'focus' ? untilOf('tomorrow', now) : null) : untilOf(when, now);
+  if (until !== null && typeof until !== 'string') return until;
+  if (command === 'focus') {
+    if (!project) return usage;
+    return { body: { action: 'focus', by: 'conductor mod /focus-project', project, until, weight: 100 } };
+  }
+  return { body: { action: 'pause', by: 'conductor mod /pause', ...(project ? { project } : {}), ...(until === null ? {} : { until }) } };
+}
+
+// POST /overrides' answer as the line to show.
+export function overrideText(command: 'focus' | 'pause' | 'unpause', project: null | string, answer: ApiAnswer, now: number): string {
+  if (answer.status === 404) return 'the running conductor has no overrides: restart it on this build (conduct upgrade)';
+  if (answer.status !== 201) return `not ${command === 'focus' ? 'focused' : `${command}d`}: ${errorOf(answer)}`;
+  const set = isRecord(answer.body) && Array.isArray(answer.body.set) ? answer.body.set.filter(isRecord) : [];
+  const until = typeof set[0]?.until === 'string' ? ` for ${remaining(set[0].until, now)}` : '';
+  const who = project ?? 'every project';
+  if (command === 'pause') return `paused launches in ${who}${until || ' until /unpause'}`;
+  if (command === 'unpause') return `launches in ${who} are no longer paused`;
+  return `${who} goes first${until}`;
+}
+
+// GET /why?item=…'s answer: the rule behind the item's newest action, in one line.
+export function whyText(item: string, answer: ApiAnswer): string {
+  if (answer.status === 404) return 'the running conductor has no conduct why: restart it on this build (conduct upgrade)';
+  if (answer.status !== 200) return `why ${item}: ${errorOf(answer)}`;
+  const first = isRecord(answer.body) && Array.isArray(answer.body.items) ? answer.body.items.find(isRecord) : undefined;
+  if (!first) return `no action on ${item} was caused by a rule`;
+  const rule = isRecord(first.rule) ? first.rule : null;
+  const latest = Array.isArray(first.chain) && isRecord(first.chain[0]) ? first.chain[0] : null;
+  const what = latest && typeof latest.kind === 'string' ? `${latest.kind}: ` : '';
+  if (!rule || typeof rule.ref !== 'string') return `${item}: ${what}no rule`;
+  const text = typeof rule.when === 'string' && Array.isArray(rule.do) ? ` (when ${rule.when} → ${strings(rule.do).join('; ')})` : '';
+  return `${item}: ${what}${rule.ref}${text}`;
+}
+
+// `/notify` with no profile: the profile, quiet hours, Remote Control.
+export function notifyText(notify: ConductorNotify | null, now: number): string {
+  if (notify === null) return 'the running conductor has no notifier: restart it on this build (conduct upgrade)';
+  const until = notify.profileUntil === null ? '' : ` for ${remaining(notify.profileUntil, now)} more`;
+  return [
+    `notify profile: ${notify.profile}${until} (profiles: ${notify.profiles.join(', ')}; /notify <profile> switches)`,
+    `Remote Control: ${notify.remoteControl}${notify.quietNow ? ` · quiet hours now, ${notify.held} held for the summary` : ''}`,
+  ].join('\n');
+}
+
+// POST /notify/profile's answer as the line to show.
+export function profileText(name: string, answer: ApiAnswer, now: number): string {
+  if (answer.status !== 200) return `notify profile not switched: ${errorOf(answer)}`;
+  const notify = parseNotify(answer.body);
+  const until = notify?.profileUntil ? ` for ${remaining(notify.profileUntil, now)}` : '';
+  return `notify profile: ${notify?.profile ?? name}${until}`;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function strings(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((v): v is string => typeof v === 'string') : [];
+}