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

package/mod/hooks/register.tsx

@@ -0,0 +1,543 @@
+import { atom, read, update } from 'claude-code';
+import type { EngineInterface, Register } from 'claude-code';
+
+import type { ConductorSnapshot } from '../types';
+
+import {
+  age,
+  type ApiAnswer,
+  answerText,
+  bandEntries,
+  endpointOf,
+  errorOf,
+  findPlan,
+  findWorker,
+  glyph,
+  homeOf,
+  inboxText,
+  notifyArgs,
+  notifyText,
+  overrideArgs,
+  overrideText,
+  parseLine,
+  profileText,
+  projectGroups,
+  type PushOutcome,
+  pushOutcome,
+  pushWarning,
+  reaction,
+  reportedState,
+  snapshotOf,
+  spendToday,
+  statusText,
+  tokens,
+  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.
+const POLL_MS = 30_000;
+const DEBOUNCE_MS = 300;
+const RESTART_MS = 5_000;
+// A band approve waiting on its `y` lapses after this.
+const CONFIRM_MS = 30_000;
+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);
+
+// 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;
+let isRefreshing = false;
+// The newest event id the stream showed, so a restarted `conduct events` picks up after it.
+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;
+
+type Endpoint = { port: number; token: string };
+
+// The running daemon's port and token, from its home's files. Throws when none runs.
+async function endpoint($: EngineInterface): Promise<Endpoint> {
+  const home = homeOf({
+    conductorHome: await $.env.get('CONDUCTOR_HOME'),
+    home: await $.env.get('HOME'),
+    userProfile: await $.env.get('USERPROFILE'),
+  });
+  if (home === null) throw new Error(NOT_RUNNING);
+  let found: Endpoint | null;
+  try {
+    found = endpointOf(await $.fs.read(`${home}/port`), await $.fs.read(`${home}/token`));
+  } catch {
+    found = null;
+  }
+  if (found === null) throw new Error(NOT_RUNNING);
+  return found;
+}
+
+// One call on the daemon's API (127.0.0.1, with its token). Throws when none runs.
+async function callApi($: EngineInterface, method: 'GET' | 'POST', path: string, body?: unknown, at?: Endpoint): Promise<ApiAnswer> {
+  const found = at ?? (await endpoint($));
+  const answer = await $.http.fetch(`http://127.0.0.1:${found.port}${path}`, {
+    body: body === undefined ? undefined : JSON.stringify(body),
+    headers: { authorization: `Bearer ${found.token}`, ...(body === undefined ? {} : { 'content-type': 'application/json' }) },
+    method,
+  });
+  let parsed: unknown = null;
+  try {
+    parsed = answer.text ? JSON.parse(answer.text) : null;
+  } catch {
+    parsed = answer.text;
+  }
+  return { body: parsed, status: answer.status };
+}
+
+// Reads /fleet, /inbox and /notify into the state the drawings read, and the status line.
+async function refresh($: EngineInterface): Promise<ConductorSnapshot> {
+  const readAt = await $.clock.now();
+  let next: ConductorSnapshot;
+  try {
+    const at = await endpoint($);
+    const [fleet, inbox, notify] = await Promise.all([
+      callApi($, 'GET', '/fleet', undefined, at),
+      callApi($, 'GET', '/inbox', undefined, at),
+      callApi($, 'GET', '/notify', undefined, at),
+    ]);
+    next = snapshotOf(fleet, inbox, readAt, notify);
+  } catch (error) {
+    next = { error: error instanceof Error ? error.message : String(error), inbox: [], notify: null, readAt, workers: [] };
+  }
+  await update($, snapshot, () => next);
+  $.ui.status(statusText(next));
+  return next;
+}
+
+// Many events land together (a note raises an item and a wait); one read covers them.
+function refreshSoon($: EngineInterface): void {
+  if (isRefreshing) return;
+  isRefreshing = true;
+  $.clock.after(DEBOUNCE_MS, () => {
+    isRefreshing = false;
+    void refresh($);
+  });
+}
+
+// One line of the follow stream, carried out.
+async function onLine($: EngineInterface, text: string): Promise<void> {
+  const line = parseLine(text);
+  if (line === null) return;
+  if (line.id !== null) lastEventId = line.id;
+  const act = reaction(line);
+  try {
+    switch (act.kind) {
+      case 'disconnected': {
+        const readAt = await $.clock.now();
+        await update($, snapshot, () => ({ error: NOT_RUNNING, inbox: [], notify: null, readAt, workers: [] }));
+        $.ui.status(undefined);
+        return;
+      }
+      case 'escalate':
+        // The one place the mod wakes the console's model: facts only, as the rules engine wrote them.
+        await $.prompt.submit({ text: act.text });
+        return;
+      case 'ignore':
+        return;
+      case 'push':
+        await push($, act.message);
+        return;
+      case 'refresh':
+        if (act.toast !== null) $.ui.toast(act.toast);
+        refreshSoon($);
+        return;
+      case 'send':
+        await $.session.send({ text: act.text, to: act.to });
+        return;
+    }
+  } catch (error) {
+    $.ui.log(`conductor: ${line.kind} failed: ${error instanceof Error ? error.message : String(error)}`, { to: 'debug' });
+  }
+}
+
+// Pushes to the phone through PushNotification, tells the daemon what came of it whatever it was
+// (`conduct notify` shows it), and says once in the console when pushes stop reaching the phone
+// (ATK-255): Remote Control off, pushes off in the config, or the call failing.
+async function push($: EngineInterface, message: string): Promise<void> {
+  let outcome: PushOutcome;
+  try {
+    outcome = pushOutcome(await $.tool.call({ message, status: 'proactive', tool: 'PushNotification' }));
+  } catch (error) {
+    outcome = { detail: error instanceof Error ? error.message : String(error), state: 'failed' };
+  }
+  const warning = pushWarning(outcome);
+  if (outcome.state === 'ok') warnedInactive = false;
+  if (warning !== null && !warnedInactive) {
+    warnedInactive = true;
+    $.ui.toast(warning);
+  }
+  try {
+    await callApi($, 'POST', '/notify/report', { channel: 'remote-control', result: outcome.detail, state: reportedState(outcome) });
+  } catch (error) {
+    $.ui.log(`conductor: notify 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 {
+    const result = await callApi($, 'POST', '/notify/profile', until === null ? { name } : { name, until });
+    refreshSoon($);
+    return profileText(name, result, await $.clock.now());
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+
+// `conduct events --follow` from this package's own build, so the mod and the CLI are one version
+// and no .cmd shim is in the way. It reconnects by itself; a child that ends is started again after
+// the last event it showed, so nothing in between is lost. One that keeps exiting at once (no
+// build, no node) is given up on, and the poll carries on alone.
+async function follow($: EngineInterface): Promise<void> {
+  const cli = `${$.plugin.root}/../build/cli.js`;
+  if (!(await $.fs.exists(cli))) {
+    $.ui.log(`conductor: no ${cli}; the console polls instead of following events`, { to: 'debug' });
+    return;
+  }
+  for (let quickExits = 0; quickExits < 3; ) {
+    const startedAt = await $.clock.now();
+    let buffer = '';
+    try {
+      const argv = ['node', cli, 'events', '--follow', ...(lastEventId === null ? [] : ['--since', String(lastEventId)])];
+      for await (const chunk of $.process.spawn({ argv })) {
+        if (chunk.stream !== 'stdout') continue;
+        buffer += chunk.text;
+        for (let end = buffer.indexOf('\n'); end >= 0; end = buffer.indexOf('\n')) {
+          const text = buffer.slice(0, end).trim();
+          buffer = buffer.slice(end + 1);
+          if (text !== '') await onLine($, text);
+        }
+      }
+    } catch (error) {
+      $.ui.log(`conductor: conduct events failed: ${error instanceof Error ? error.message : String(error)}`, { to: 'debug' });
+    }
+    quickExits = (await $.clock.now()) - startedAt < 10_000 ? quickExits + 1 : 0;
+    await new Promise<void>((done) => $.clock.after(RESTART_MS, done));
+  }
+  $.ui.log('conductor: conduct events keeps exiting; the console polls instead', { to: 'debug' });
+}
+
+// Jason's answer to an inbox item, as `conduct approve|revise|done` posts it; the line to show.
+async function answer($: EngineInterface, id: number, body: { action: 'approve' | 'done' } | { action: 'revise'; text: string }): Promise<string> {
+  try {
+    const result = await callApi($, 'POST', `/inbox/${id}/resolve`, body);
+    refreshSoon($);
+    return answerText(body.action, id, result);
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+
+// `/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`);
+    refreshSoon($);
+    return result.status === 200 ? `attached to ${name}` : `could not attach to ${name}: ${errorOf(result)}`;
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+
+async function copy($: EngineInterface, text: string, surface: Parameters<EngineInterface['ui']['copy']>[0]['surface']): Promise<void> {
+  const copied = await $.ui.copy({ surface, text });
+  $.ui.toast(copied.isCopied ? `copied: ${text}` : `not copied: ${text}`);
+}
+
+// Stages a band approve for its `y`; it lapses unless pressed within CONFIRM_MS.
+async function confirm($: EngineInterface, id: number): Promise<void> {
+  await update($, confirming, () => id);
+  $.clock.after(CONFIRM_MS, () => void update($, confirming, (staged) => (staged === id ? null : staged)));
+}
+
+async function openPane($: EngineInterface): Promise<void> {
+  await $.ui.open({ focus: true, id: PANE, title: TITLE });
+}
+
+async function registerCommands($: EngineInterface): Promise<void> {
+  await $.command.register({ description: 'Open the conductor pane: the inbox, the fleet and spend', name: 'conductor' });
+  await $.command.register({ description: 'What waits on you in the conductor, with commands and links', name: 'inbox' });
+  await $.command.register({ argumentHint: '<item | #id>', description: "Approve an item's plan (posts approve as you)", name: 'approve' });
+  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) => {
+  on('session.start', async ($, e, next) => {
+    const started = await next(e);
+    if (!e.isInteractive) return started;
+    isConsole = (await $.env.get('CONDUCTOR_CONSOLE')) === '1';
+    $.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.
+    void $.ui.open({ id: PANE, title: TITLE });
+    return started;
+  });
+
+  on('command.run', { command: 'conductor' }, async ($) => {
+    await openPane($);
+    return { text: 'Conductor pane opened.' };
+  });
+
+  on('command.run', { command: 'inbox' }, async ($) => {
+    const snap = await refresh($);
+    return { text: snap.error ?? inboxText(snap.inbox, await $.clock.now()) };
+  });
+
+  on('command.run', { command: 'approve' }, async ($, e) => {
+    const ref = e.args.trim();
+    if (ref === '') return { text: 'usage: /approve <item | #id>' };
+    const snap = await refresh($);
+    if (snap.error !== null) return { text: snap.error };
+    const plan = findPlan(snap.inbox, ref);
+    return { text: plan.found ? await answer($, plan.found.id, { action: 'approve' }) : plan.error };
+  });
+
+  on('command.run', { command: 'revise' }, async ($, e) => {
+    // The item, then the text as typed: its lines and spacing are the instructions.
+    const typed = /^(\S+)\s+([\s\S]*\S)\s*$/.exec(e.args.trim());
+    const ref = typed?.[1] ?? '';
+    const text = typed?.[2] ?? '';
+    if (ref === '' || text === '') return { text: 'usage: /revise <item | #id> <what to change>' };
+    const snap = await refresh($);
+    if (snap.error !== null) return { text: snap.error };
+    const plan = findPlan(snap.inbox, ref);
+    return { text: plan.found ? await answer($, plan.found.id, { action: 'revise', text }) : plan.error };
+  });
+
+  on('command.run', { command: 'attach' }, async ($, e) => {
+    const ref = e.args.trim();
+    if (ref === '') return { text: 'usage: /attach <item | worker>' };
+    const snap = await refresh($);
+    if (snap.error !== null) return { text: snap.error };
+    const worker = findWorker(snap.workers, ref);
+    return { text: worker.found ? await attach($, worker.found.id, worker.found.name) : worker.error };
+  });
+
+  on('command.run', { command: 'notify' }, async ($, e) => {
+    if (e.args.trim() !== '') {
+      const typed = notifyArgs(e.args, await $.clock.now());
+      return { text: 'error' in typed ? typed.error : await switchProfile($, typed.name, typed.until) };
+    }
+    const snap = await refresh($);
+    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`).
+  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 entries = bandEntries(snap.inbox);
+    const confirmId = await read($, confirming);
+    const pending = entries.find((x) => x.act === 'approve' && x.id === confirmId);
+    if (pending) {
+      return (
+        <Box columnGap={2} flexWrap="wrap">
+          <Text bold>conductor</Text>
+          <Text>
+            {pending.label}? {pending.text}
+          </Text>
+          <Button
+            hotkey="y"
+            key="confirm"
+            label="y approve"
+            onPress={async () => {
+              await update($, confirming, () => null);
+              $.ui.toast(await answer($, pending.id, { action: 'approve' }));
+            }}
+            variant="primary"
+          />
+          <Button hotkey="n" key="cancel" label="n cancel" onPress={() => update($, confirming, () => null)} />
+        </Box>
+      );
+    }
+    return (
+      <Box columnGap={2} flexWrap="wrap">
+        <Text bold>conductor · inbox {snap.inbox.length}</Text>
+        {entries.map((x) => (
+          <Button
+            hotkey={x.hotkey}
+            key={`item-${x.id}`}
+            label={`${x.hotkey} ${x.label}`}
+            onPress={async (press) => {
+              if (x.act === 'approve') await confirm($, x.id);
+              else if (x.act === 'copy') await copy($, x.text, press.surface);
+              else await openPane($);
+            }}
+          />
+        ))}
+        {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>
+    );
+  });
+
+  // The pane: the notification profile, the inbox, then the fleet by project, then today's spend.
+  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
+    const ui = $.ui.resolve(e);
+    const { Box, Button, Link, Text } = ui;
+    const snap = await read($, snapshot);
+    const open = await read($, expanded);
+    const now = await $.clock.now();
+    const rule = (title: string): string => `─ ${title} ${'─'.repeat(Math.max(0, e.props.bodyColumns - title.length - 3))}`;
+    if (snap === null) return <Text dimColor>Reading the conductor…</Text>;
+    if (snap.error !== null) {
+      return (
+        <Box flexDirection="column">
+          <Text bold>{TITLE}</Text>
+          <Text>{snap.error}</Text>
+        </Box>
+      );
+    }
+    return (
+      <Box flexDirection="column">
+        <Text bold>
+          {TITLE} <Text dimColor>{statusText(snap)}</Text>
+        </Text>
+        {snap.notify !== null && (
+          <Box columnGap={2} flexWrap="wrap">
+            {e.surface !== 'mobile' && 'Select' in ui ? (
+              <ui.Select
+                key="notify-profile"
+                label="notify "
+                onSelect={async (name) => $.ui.toast(await switchProfile($, name))}
+                options={snap.notify.profiles.map((p) => ({ value: p }))}
+                value={snap.notify.profile}
+              />
+            ) : (
+              snap.notify.profiles.map((p) => (
+                <Button
+                  key={`profile-${p}`}
+                  label={p === snap.notify?.profile ? `notify: ${p}` : p}
+                  onPress={async () => $.ui.toast(await switchProfile($, p))}
+                  variant={p === snap.notify?.profile ? 'primary' : undefined}
+                />
+              ))
+            )}
+            <Text dimColor>
+              Remote Control: {snap.notify.remoteControl}
+              {snap.notify.quietNow ? ` · quiet hours, ${snap.notify.held} held` : ''}
+            </Text>
+          </Box>
+        )}
+        <Text dimColor wrap="truncate">
+          {rule(`Inbox (${snap.inbox.length})`)}
+        </Text>
+        {snap.inbox.length === 0 && <Text dimColor>Nothing waits on you.</Text>}
+        {snap.inbox.map((item, i) => (
+          <Box flexDirection="column" key={`inbox-${item.id}`} marginBottom={1}>
+            <Text>
+              [{i + 1}] <Text bold>{item.item ?? `#${item.id}`}</Text> {item.kind} <Text dimColor>{age(item.raisedAt, now)}</Text>
+            </Text>
+            <Text>{item.text}</Text>
+            <Box columnGap={2} flexWrap="wrap">
+              {item.kind === 'plan' && item.item !== null && (
+                <Button
+                  key={`approve-${item.id}`}
+                  label="approve"
+                  onPress={async () => $.ui.toast(await answer($, item.id, { action: 'approve' }))}
+                  variant="primary"
+                />
+              )}
+              {item.kind === 'plan' && item.item !== null && (
+                <Button key={`revise-${item.id}`} label="revise" onPress={() => $.prompt.fill({ text: `/revise ${item.item ?? ''} ` })} />
+              )}
+              {item.commands.slice(0, 2).map((command, n) => (
+                <Button key={`copy-${item.id}-${n}`} label={`copy: ${command}`} onPress={(press) => copy($, command, press.surface)} />
+              ))}
+              {item.links.slice(0, 2).map((href, n) => (
+                <Link href={href} key={`link-${item.id}-${n}`} label="open" />
+              ))}
+              {item.kind !== 'plan' && (
+                <Button key={`done-${item.id}`} label="done" onPress={async () => $.ui.toast(await answer($, item.id, { action: 'done' }))} />
+              )}
+            </Box>
+          </Box>
+        ))}
+        {projectGroups(snap.workers).map((group) => (
+          <Box flexDirection="column" key={`project-${group.project}`}>
+            <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>
+                  {glyph(w.status)} {w.name} {w.phase ?? ''}{' '}
+                  <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.waits.length > 0 ? ` · waits on ${w.waits.join(', ')}` : ''}
+                    </Text>
+                  </Box>
+                )}
+              </Box>
+            ))}
+          </Box>
+        ))}
+        <Text dimColor wrap="truncate">
+          {rule(`Today: ${tokens(spendToday(snap.workers))} tokens · ${snap.workers.length} workers`)}
+        </Text>
+      </Box>
+    );
+  });
+};

package/mod/types/index.d.ts

@@ -0,0 +1,57 @@
+// The daemon's answers as the mod reads them: GET /fleet's workers and GET /inbox's items, with
+// only the fields the mod draws.
+export type ConductorWorker = {
+  activity: string;
+  id: number;
+  item: string;
+  name: string;
+  phase: string | null;
+  project: string;
+  spendToday: number;
+  status: string;
+  updatedAt: string;
+  waits: string[];
+};
+
+export type ConductorInboxItem = {
+  commands: string[];
+  id: number;
+  item: string | null;
+  kind: string;
+  links: string[];
+  project: string | null;
+  raisedAt: string;
+  text: string;
+};
+
+// GET /notify as the mod draws it: the profile, the others to switch to, Remote Control's state.
+export type ConductorNotify = {
+  held: number;
+  profile: string;
+  profiles: string[];
+  profileUntil: string | null;
+  quietNow: boolean;
+  remoteControl: string;
+};
+
+// What the mod last read from the daemon; `error` set (and the lists empty) when none answered.
+// `notify` is null from a daemon older than the notifier.
+export type ConductorSnapshot = {
+  error: string | null;
+  inbox: ConductorInboxItem[];
+  notify: ConductorNotify | null;
+  readAt: number;
+  workers: ConductorWorker[];
+};
+
+declare module 'claude-code' {
+  interface PluginState {
+    conductor: {
+      // The inbox id whose approve waits on a second press in the band.
+      confirming: number | null;
+      // The worker whose row the pane shows expanded, by name.
+      expanded: string | null;
+      snapshot: ConductorSnapshot | null;
+    };
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@detergent-software/conductor",
-	"version": "1.0.0-dev.2",
+	"version": "1.0.0-dev.20",
 	"description": "Conductor: the local daemon that runs conducted projects' work loops (conduct serve) and its conduct CLI.",
 	"type": "module",
 	"bin": {
@@ -9,6 +9,9 @@
 	"files": [
 		"build",
 		"!build/__tests__",
+		"mod",
+		"!mod/tests",
+		"!mod/.claude-plugin/types",
 		"CHANGELOG.md"
 	],
 	"scripts": {
@@ -34,6 +37,7 @@
 	},
 	"dependencies": {
 		"jsonc-parser": "^3.3.1",
+		"semver": "^7.7.0",
 		"zod": "^4.0.0"
 	},
 	"devDependencies": {
@@ -43,6 +47,7 @@
 		"@semantic-release/git": "^10.0.1",
 		"@semantic-release/release-notes-generator": "^14.1.0",
 		"@types/node": "^24.0.0",
+		"@types/semver": "^7.5.0",
 		"@vitest/eslint-plugin": "^1.0.0",
 		"conventional-changelog-conventionalcommits": "^9.1.0",
 		"eslint": "^9.0.0",