@detergent-software/conductor 1.0.0-dev.9 → 1.0.1-dev.1

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

@@ -1,7 +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.",
+  "description": "The conductor console's plumbing: 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

@@ -1,6 +1,6 @@
 # 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`, 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`).
+A Claude Code plugin (a hooks module) that does the conductor console's plumbing in code, so it costs no tokens. Only the console (`CONDUCTOR_CONSOLE=1`) gets anything from it: 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), the one model wake-up for an escalation, a nudge to load `/conductor-console` in a console started without it, and a warm prompt cache while the console idles (a ping every 55 minutes, or a `/clear` past 150k or a night of pings). 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:
 
@@ -11,7 +11,7 @@ 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 |
+| `hooks/model.ts` | the logic without the engine: parsing the daemon's answers, what the 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/model.ts

@@ -1,5 +1,5 @@
 // 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 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';
@@ -46,6 +46,70 @@ export function reportedState(outcome: PushOutcome): 'failing' | 'inactive' | 'o
   return outcome.state === 'failed' ? 'failing' : outcome.state;
 }
 
+// The skill a console runs first (ATK-385). `conduct console` starts with it as the first prompt;
+// a console started by hand (`claude -n conductor`) has to be told.
+export const CONSOLE_SKILL = 'conductor-console';
+// What the model reads beside each prompt of a console whose skill hasn't run.
+export const NO_SKILL_CONTEXT = `This session is the conductor console (CONDUCTOR_CONSOLE=1), but /${CONSOLE_SKILL} hasn't run in it, so its rules don't hold. Load the ${CONSOLE_SKILL} skill with the Skill tool and follow it, then answer this prompt.`;
+export const NO_SKILL_WARNING = `console without its skill: run /${CONSOLE_SKILL}`;
+
+// ATK-386: the console idles for hours, and its prompt cache lives an hour past its last use, so a
+// wake after that wrote its whole context again (89k in ATK-365's run). A fork reads that context
+// back from the cache for a tenth of a write's price and starts its hour over, so the mod pings
+// just inside the hour; past a size, or after a night of pings, a /clear costs nothing and the
+// next wake starts from a fresh console instead.
+export const WARM_AFTER_MS = 55 * 60_000;
+export const FRESH_AT_TOKENS = 150_000;
+export const MAX_WARMS = 12;
+// The fork's one user message: its answer is thrown away, so the shorter the better.
+export const WARM_PROMPT = 'Cache keep-alive from the conductor mod: answer with the one word ok.';
+
+// What the console does at an idle point: ping to keep the cache warm, or start fresh.
+export type IdleAction = { kind: 'clear'; reason: string } | { kind: 'warm' };
+
+// `contextTokens` is the context the last response was answered over (absent before the first);
+// `warms` the pings since the last real turn.
+export function idleAction({ contextTokens, warms }: { contextTokens: number | undefined; warms: number }): IdleAction {
+  if (contextTokens !== undefined && contextTokens >= FRESH_AT_TOKENS) return { kind: 'clear', reason: `context ${tokens(contextTokens)} ≥ ${tokens(FRESH_AT_TOKENS)}` };
+  if (warms >= MAX_WARMS) return { kind: 'clear', reason: `${warms} pings since the last turn` };
+  return { kind: 'warm' };
+}
+
+// What a ping came to: the cache held (warm), it had lapsed anyway so pinging doesn't work here
+// (cold: a 5-minute TTL, a model change), the call failed, or there was nothing to fork.
+export type PingOutcome = { kind: 'cold' | 'failed' | 'warm'; usage: CacheUsage | null } | { kind: 'nothing' };
+export type CacheUsage = { cacheRead: number; cacheWrite: number; input: number; output: number };
+
+// `$.model.fork`'s result. The cache held when it served at least half the context the console's
+// last response was answered over; without that figure, when it served more than it wrote.
+export function pingOutcome(result: unknown, contextTokens: number | undefined): PingOutcome {
+  const call = isRecord(result) ? result : {};
+  if (call.isAnswered === false && call.reason === 'nothing-to-fork') return { kind: 'nothing' };
+  const usage = usageOf(call.usage);
+  if (call.isAnswered !== true || usage === null) return { kind: 'failed', usage };
+  const held = contextTokens === undefined ? usage.cacheRead > usage.cacheWrite : usage.cacheRead >= contextTokens / 2;
+  return { kind: held ? 'warm' : 'cold', usage };
+}
+
+// The band's line after the mod cleared an idle console, in place of the no-skill warning.
+export function clearedText(reason: string): string {
+  return `fresh console (cleared while idle: ${reason}); /${CONSOLE_SKILL} loads with the next prompt`;
+}
+
+function usageOf(value: unknown): CacheUsage | null {
+  if (!isRecord(value)) return null;
+  const count = (key: string): number => {
+    const n = value[key];
+    return typeof n === 'number' ? n : 0;
+  };
+  return {
+    cacheRead: count('cache_read_input_tokens'),
+    cacheWrite: count('cache_creation_input_tokens'),
+    input: count('input_tokens'),
+    output: count('output_tokens'),
+  };
+}
+
 // A band entry and the act its press does.
 export type BandEntry = { act: 'approve' | 'copy' | 'pane'; hotkey: string; id: number; label: string; text: string };
 
@@ -56,7 +120,7 @@ export type Found<T> = { error: string; found?: undefined } | { error?: undefine
 
 const BAND_LIMIT = 5;
 
-// `conductor 3▶ 2⏸ ✉2`, or undefined (the line cleared) when no daemon answers.
+// `conductor 3▶ 2⏸ ✉2` for 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;
@@ -199,7 +263,10 @@ export function reaction(line: StreamLine): Reaction {
       return { kind: 'disconnected' };
     case 'console.escalated': {
       const ask = text('text');
-      return ask === null ? { kind: 'ignore' } : { kind: 'escalate', text: `[conductor] escalation${line.subject ? ` on ${line.subject}` : ''}: ${ask}` };
+      // 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');
@@ -214,6 +281,7 @@ export function reaction(line: StreamLine): Reaction {
       const message = text('message');
       return line.data.channel === 'remote-control' && message !== null ? { kind: 'push', message } : { kind: 'ignore' };
     }
+    case 'console.cache':
     case 'watcher.stats':
       return { kind: 'ignore' };
     case 'worker.message-requested': {
@@ -355,17 +423,76 @@ export function notifyArgs(args: string, now: number): { error: string } | { nam
   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);
-  let at: Date;
+  const lower = when.toLowerCase();
+  const day = DAYS.findIndex((d) => d === lower || d.slice(0, 3) === lower);
+  const at = new Date(now);
   if (clock) {
-    at = new Date(now);
     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 = new Date(/^\d{4}-\d{2}-\d{2}$/.test(when) ? `${when}T00:00` : when);
+    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: a local time such as 17:00, or a date and time such as 2026-10-12T09:00` };
-  return { name: typed[1], until: at.toISOString() };
+  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.

package/mod/hooks/register.tsx

@@ -1,5 +1,5 @@
 import { atom, read, update } from 'claude-code';
-import type { EngineInterface, Register } from 'claude-code';
+import type { EngineInterface, Register, RenderElement, Timer } from 'claude-code';
 
 import type { ConductorSnapshot } from '../types';
 
@@ -8,16 +8,25 @@ import {
   type ApiAnswer,
   answerText,
   bandEntries,
+  clearedText,
+  CONSOLE_SKILL,
   endpointOf,
   errorOf,
   findPlan,
   findWorker,
   glyph,
   homeOf,
+  idleAction,
   inboxText,
+  NO_SKILL_CONTEXT,
+  NO_SKILL_WARNING,
   notifyArgs,
   notifyText,
+  overrideArgs,
+  overrideText,
   parseLine,
+  type PingOutcome,
+  pingOutcome,
   profileText,
   projectGroups,
   type PushOutcome,
@@ -29,13 +38,16 @@ import {
   spendToday,
   statusText,
   tokens,
+  WARM_AFTER_MS,
+  WARM_PROMPT,
+  whyText,
   workerDoing,
 } from './model.ts';
 
 const PANE = 'conductor';
 const TITLE = 'Conductor';
-// Every session reads /fleet and /inbox this often for the status line; the console also follows
-// the event stream, so this is its safety net and what re-ages its rows.
+// The console reads /fleet and /inbox this often. It also follows the event stream, so this is its
+// safety net and what re-ages its rows.
 const POLL_MS = 30_000;
 const DEBOUNCE_MS = 300;
 const RESTART_MS = 5_000;
@@ -46,8 +58,10 @@ const NOT_RUNNING = 'the conductor is not running (conduct serve)';
 const snapshot = atom({ plugin: 'conductor', key: 'snapshot' } as const, null);
 const confirming = atom({ plugin: 'conductor', key: 'confirming' } as const, null);
 const expanded = atom({ plugin: 'conductor', key: 'expanded' } as const, null);
+const hasSkill = atom({ plugin: 'conductor', key: 'hasSkill' } as const, false);
+const cleared = atom({ plugin: 'conductor', key: 'cleared' } as const, null);
 
-// The console is the session started with CONDUCTOR_CONSOLE=1 (the console skill sets it): only it
+// The console is the session started with CONDUCTOR_CONSOLE=1 (`conduct console` sets it): only it
 // draws the band and the pane, answers the commands, follows the stream and acts on events. Both
 // flags start over with the module, and session.start sets the first again after a reload.
 let isConsole = false;
@@ -56,6 +70,15 @@ let isRefreshing = false;
 let lastEventId: null | number = null;
 // Set once the console has said that pushes no longer reach the phone; a push that does clears it.
 let warnedInactive = false;
+// ATK-386: the console's idle point, armed by each of its own turns; the pings since the last one;
+// the console's turns so far, so a turn that starts while the idle point runs keeps it from
+// counting a ping or clearing; the turn ids of pings, should the engine raise turns for a fork,
+// which are no turns of the console's; and whether the /clear running is the mod's own.
+let idleTimer: null | Timer = null;
+let warms = 0;
+let turnsStarted = 0;
+const pingTurns = new Set<string>();
+let isClearing = false;
 
 type Endpoint = { port: number; token: string };
 
@@ -94,7 +117,7 @@ async function callApi($: EngineInterface, method: 'GET' | 'POST', path: string,
   return { body: parsed, status: answer.status };
 }
 
-// Reads /fleet, /inbox and /notify into the state the drawings read, and the status line.
+// Reads /fleet, /inbox and /notify into the state the drawings read.
 async function refresh($: EngineInterface): Promise<ConductorSnapshot> {
   const readAt = await $.clock.now();
   let next: ConductorSnapshot;
@@ -110,7 +133,6 @@ async function refresh($: EngineInterface): Promise<ConductorSnapshot> {
     next = { error: error instanceof Error ? error.message : String(error), inbox: [], notify: null, readAt, workers: [] };
   }
   await update($, snapshot, () => next);
-  $.ui.status(statusText(next));
   return next;
 }
 
@@ -135,7 +157,6 @@ async function onLine($: EngineInterface, text: string): Promise<void> {
       case 'disconnected': {
         const readAt = await $.clock.now();
         await update($, snapshot, () => ({ error: NOT_RUNNING, inbox: [], notify: null, readAt, workers: [] }));
-        $.ui.status(undefined);
         return;
       }
       case 'escalate':
@@ -183,6 +204,72 @@ async function push($: EngineInterface, message: string): Promise<void> {
   }
 }
 
+// Starts the console's idle point over: WARM_AFTER_MS from now, unless a turn comes first.
+function armIdle($: EngineInterface): void {
+  idleTimer?.cancel();
+  idleTimer = $.clock.after(WARM_AFTER_MS, () => void onIdle($));
+}
+
+function disarmIdle(): void {
+  idleTimer?.cancel();
+  idleTimer = null;
+}
+
+// The console has been idle WARM_AFTER_MS: keep its cache warm with a ping, or clear it (ATK-386).
+// Either is told to the daemon, which logs it as a `console.cache` event: a fork is no turn of the
+// transcript, so the event is the only place its cost shows.
+// A turn that starts meanwhile has the console in use again: its end arms the next idle point, so
+// this one stands down (no /clear under it, no ping counted against it).
+async function onIdle($: EngineInterface): Promise<void> {
+  idleTimer = null;
+  const turnsBefore = turnsStarted;
+  const isIdle = (): boolean => turnsStarted === turnsBefore;
+  const contextTokens = (await $.session.usage()).context.tokens;
+  if (!isIdle()) return;
+  const act = idleAction({ contextTokens, warms });
+  if (act.kind === 'clear') {
+    await update($, cleared, () => act.reason);
+    if (!isIdle()) {
+      await update($, cleared, () => null);
+      return;
+    }
+    isClearing = true;
+    try {
+      await $.command.run({ command: 'clear' });
+    } catch (error) {
+      await update($, cleared, () => null);
+      $.ui.log(`conductor: the idle /clear failed: ${error instanceof Error ? error.message : String(error)}`, { to: 'debug' });
+      return;
+    } finally {
+      isClearing = false;
+    }
+    await reportCache($, { action: 'clear', contextTokens: contextTokens ?? null, reason: act.reason });
+    return;
+  }
+  let outcome: PingOutcome;
+  try {
+    outcome = pingOutcome(await $.model.fork({ prompt: WARM_PROMPT }), contextTokens);
+  } catch (error) {
+    $.ui.log(`conductor: the cache ping failed: ${error instanceof Error ? error.message : String(error)}`, { to: 'debug' });
+    outcome = { kind: 'failed', usage: null };
+  }
+  if (outcome.kind === 'nothing') return;
+  if (isIdle()) {
+    warms++;
+    // A ping that found the cache gone (or failed) stops here: the next real turn arms it again.
+    if (outcome.kind === 'warm') armIdle($);
+  }
+  await reportCache($, { action: outcome.kind, contextTokens: contextTokens ?? null, usage: outcome.usage, warms });
+}
+
+async function reportCache($: EngineInterface, body: Record<string, unknown>): Promise<void> {
+  try {
+    await callApi($, 'POST', '/console/cache', body);
+  } catch (error) {
+    $.ui.log(`conductor: console cache report failed: ${error instanceof Error ? error.message : String(error)}`, { to: 'debug' });
+  }
+}
+
 // `/notify <profile> [--until <when>]` and the pane's picker: switch the notification profile.
 async function switchProfile($: EngineInterface, name: string, until: null | string = null): Promise<string> {
   try {
@@ -208,7 +295,8 @@ async function follow($: EngineInterface): Promise<void> {
     const startedAt = await $.clock.now();
     let buffer = '';
     try {
-      const argv = ['node', cli, 'events', '--follow', ...(lastEventId === null ? [] : ['--since', String(lastEventId)])];
+      // --console: while this stream is open, the daemon knows escalations have a console to wake.
+      const argv = ['node', cli, 'events', '--follow', '--console', ...(lastEventId === null ? [] : ['--since', String(lastEventId)])];
       for await (const chunk of $.process.spawn({ argv })) {
         if (chunk.stream !== 'stdout') continue;
         buffer += chunk.text;
@@ -238,6 +326,29 @@ async function answer($: EngineInterface, id: number, body: { action: 'approve'
   }
 }
 
+// `/pause`, `/unpause`, `/focus-project` and the pane's buttons: an override that ends on its own, as
+// `conduct pause|unpause|focus` sets it; the line to show.
+async function override($: EngineInterface, command: 'focus' | 'pause' | 'unpause', args: string): Promise<string> {
+  const now = await $.clock.now();
+  const typed = overrideArgs(command, args, now);
+  if ('error' in typed) return typed.error;
+  try {
+    const project = typeof typed.body.project === 'string' ? typed.body.project : null;
+    return overrideText(command, project, await callApi($, 'POST', '/overrides', typed.body), now);
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+
+// The rule behind an item's newest action (`conduct why <item>`), in one line.
+async function why($: EngineInterface, item: string): Promise<string> {
+  try {
+    return whyText(item, await callApi($, 'GET', `/why?item=${encodeURIComponent(item)}`));
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+
 async function attach($: EngineInterface, id: number, name: string): Promise<string> {
   try {
     const result = await callApi($, 'POST', `/workers/${id}/attach`);
@@ -270,6 +381,9 @@ async function registerCommands($: EngineInterface): Promise<void> {
   await $.command.register({ argumentHint: '<item | #id> <what to change>', description: 'Ask for a revised plan (posts revise: … as you)', name: 'revise' });
   await $.command.register({ argumentHint: '<item | worker>', description: 'Wake a parked worker and open it in a tab', name: 'attach' });
   await $.command.register({ argumentHint: '[<profile> [--until <when>]]', description: 'Show or switch the notification profile (default, away, focus …)', name: 'notify' });
+  await $.command.register({ argumentHint: '[<project>] [--until <when>]', description: 'No new launches in a project (every project without one)', name: 'pause' });
+  await $.command.register({ argumentHint: '[<project>]', description: 'Launch again after /pause', name: 'unpause' });
+  await $.command.register({ argumentHint: '<project> [--until <when>]', description: "Put a project's items first (until midnight without --until)", name: 'focus-project' });
 }
 
 export const register: Register = (on) => {
@@ -277,9 +391,9 @@ export const register: Register = (on) => {
     const started = await next(e);
     if (!e.isInteractive) return started;
     isConsole = (await $.env.get('CONDUCTOR_CONSOLE')) === '1';
+    if (!isConsole) return started;
     $.clock.every(POLL_MS, () => void refresh($));
     await refresh($);
-    if (!isConsole) return started;
     await registerCommands($);
     void follow($);
     // Docked as a sidebar on a wide fullscreen terminal; below that it waits until opened.
@@ -287,6 +401,60 @@ export const register: Register = (on) => {
     return started;
   });
 
+  // A console the skill never ran in (one started by hand as `claude -n conductor`, ATK-385) is
+  // told to load it before it answers, each prompt until it has. `/conductor-console` or the Skill
+  // tool expands it before its prompt is submitted; a /clear or a resume starts a conversation
+  // without it.
+  on('skill.prompt', { skill: CONSOLE_SKILL }, async ($, e, next) => {
+    const prompt = await next(e);
+    if (isConsole) {
+      await update($, hasSkill, () => true);
+      await update($, cleared, () => null);
+    }
+    return prompt;
+  });
+
+  // A conversation ending (exit, /clear, resume) ends its idle point too. Only the mod's own /clear
+  // keeps the band's "cleared while idle" line (ATK-386).
+  on('session.end', async ($, e, next) => {
+    if (isConsole) {
+      disarmIdle();
+      warms = 0;
+      await update($, hasSkill, () => false);
+      if (!isClearing) await update($, cleared, () => null);
+    }
+    return next(e);
+  });
+
+  // ATK-386: each of the console's own turns starts its idle point over, and a turn in progress
+  // holds it off. A subagent's turn raises no turn.start and its turn.complete carries its agentId;
+  // a ping's, should the engine raise one, carries the ping's prompt.
+  on('turn.start', async ($, e, next) => {
+    if (isConsole) {
+      if (e.text === WARM_PROMPT) pingTurns.add(e.turnId);
+      else {
+        turnsStarted++;
+        disarmIdle();
+      }
+    }
+    return next(e);
+  });
+
+  on('turn.complete', async ($, e, next) => {
+    const done = await next(e);
+    if (isConsole && e.agentId === undefined && !pingTurns.delete(e.turnId)) {
+      warms = 0;
+      armIdle($);
+    }
+    return done;
+  });
+
+  on('prompt.submit', async ($, e, next) => {
+    if (!isConsole || (await read($, hasSkill))) return next(e);
+    $.ui.log(`conductor: /${CONSOLE_SKILL} hasn't run; asking the model to load it`, { to: 'debug' });
+    return next({ ...e, context: [...(e.context ?? []), NO_SKILL_CONTEXT] });
+  });
+
   on('command.run', { command: 'conductor' }, async ($) => {
     await openPane($);
     return { text: 'Conductor pane opened.' };
@@ -336,18 +504,45 @@ export const register: Register = (on) => {
     return { text: snap.error ?? notifyText(snap.notify, await $.clock.now()) };
   });
 
+  on('command.run', { command: 'pause' }, async ($, e) => ({ text: await override($, 'pause', e.args) }));
+  on('command.run', { command: 'unpause' }, async ($, e) => ({ text: await override($, 'unpause', e.args) }));
+  on('command.run', { command: 'focus-project' }, async ($, e) => ({ text: await override($, 'focus', e.args) }));
+
   // The band above the prompt, in the console, while the inbox has items. A bare digit typed into
-  // an empty prompt presses a band Button, so a plan's approve takes a second press (`y`).
+  // an empty prompt presses a band Button, so a plan's approve takes a second press (`y`). Until
+  // /conductor-console runs, a warning sits above it, or above the engine's own (ATK-385); after the
+  // mod cleared an idle console, a plain line that says so instead (ATK-386).
   on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
     if (!isConsole || e.props.hasSurvey) return next(e);
-    const snap = await read($, snapshot);
-    if (snap === null || snap.error !== null || snap.inbox.length === 0) return next(e);
     const { Box, Button, Text } = $.ui.resolve(e);
+    const isWarned = !(await read($, hasSkill));
+    const clearedBy = await read($, cleared);
+    const withWarning = (row: RenderElement): RenderElement =>
+      isWarned ? (
+        <Box flexDirection="column">
+          {clearedBy === null ? (
+            <Box key="no-skill">
+              <Text bold color="warning">
+                {NO_SKILL_WARNING}
+              </Text>
+            </Box>
+          ) : (
+            <Box key="cleared">
+              <Text dimColor>{clearedText(clearedBy)}</Text>
+            </Box>
+          )}
+          {row}
+        </Box>
+      ) : (
+        row
+      );
+    const snap = await read($, snapshot);
+    if (snap === null || snap.error !== null || snap.inbox.length === 0) return isWarned ? withWarning(await next(e)) : next(e);
     const entries = bandEntries(snap.inbox);
     const confirmId = await read($, confirming);
     const pending = entries.find((x) => x.act === 'approve' && x.id === confirmId);
     if (pending) {
-      return (
+      return withWarning(
         <Box columnGap={2} flexWrap="wrap">
           <Text bold>conductor</Text>
           <Text>
@@ -364,10 +559,10 @@ export const register: Register = (on) => {
             variant="primary"
           />
           <Button hotkey="n" key="cancel" label="n cancel" onPress={() => update($, confirming, () => null)} />
-        </Box>
+        </Box>,
       );
     }
-    return (
+    return withWarning(
       <Box columnGap={2} flexWrap="wrap">
         <Text bold>conductor · inbox {snap.inbox.length}</Text>
         {entries.map((x) => (
@@ -384,7 +579,7 @@ export const register: Register = (on) => {
         ))}
         {snap.inbox.length > entries.length && <Text dimColor>+{snap.inbox.length - entries.length} more</Text>}
         <Button hotkey="o" key="open-pane" label="o panel" onPress={() => openPane($)} />
-      </Box>
+      </Box>,
     );
   });
 
@@ -472,9 +667,13 @@ export const register: Register = (on) => {
         ))}
         {projectGroups(snap.workers).map((group) => (
           <Box flexDirection="column" key={`project-${group.project}`}>
-            <Text dimColor wrap="truncate">
-              {rule(`${group.project} · ${group.running}/${group.rows.length} running`)}
-            </Text>
+            <Box columnGap={1}>
+              <Text dimColor wrap="truncate">
+                {rule(`${group.project} · ${group.running}/${group.rows.length} running`).slice(0, Math.max(10, e.props.bodyColumns - 18))}
+              </Text>
+              <Button key={`pause-${group.project}`} label="pause" onPress={async () => $.ui.toast(await override($, 'pause', group.project))} />
+              <Button key={`focus-${group.project}`} label="focus" 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>
@@ -486,6 +685,7 @@ export const register: Register = (on) => {
                 {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.waits.length > 0 ? ` · waits on ${w.waits.join(', ')}` : ''}

package/mod/types/index.d.ts

@@ -51,6 +51,12 @@ declare module 'claude-code' {
       confirming: number | null;
       // The worker whose row the pane shows expanded, by name.
       expanded: string | null;
+      // Whether /conductor-console ran in this conversation (ATK-385). Kept in $.state, so a reload
+      // of the mod doesn't forget it; a /clear or a resume (session.end) sets it back to false.
+      hasSkill: boolean;
+      // Why the mod last cleared the idle console (ATK-386), until /conductor-console runs again;
+      // null when it didn't. The band says so in place of the no-skill warning.
+      cleared: string | null;
       snapshot: ConductorSnapshot | null;
     };
   }

package/package.json

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