@detergent-software/conductor 3.5.0-dev.16 → 3.5.0-dev.18

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

@@ -1,7 +1,9 @@
 {
   "name": "conductor",
-  "version": "2.0.0",
+  "version": "3.5.0-dev.18",
   "description": "The conductor's plugin, loaded only into the sessions it starts: the mod (the console's band, pane and commands, and each session's report to the daemon), the console skill, the reference work skill and the verification-skill pair.",
-  "author": { "name": "Detergent Software" },
+  "author": {
+    "name": "Detergent Software"
+  },
   "types": "./types/index.d.ts"
 }

package/plugin/hooks/model.ts

@@ -655,15 +655,30 @@ export function approvedPlanItem(inbox: readonly ConductorInboxItem[], ref: stri
 // of a daemon kept in CONDUCTOR_HOME would otherwise report to ~/.conductor (ATK-525). The package's
 // own plugin folder (a `claude plugin test`, a `--plugin-dir` on a checkout) has none: its CLI sits
 // beside it, and its home is the environment's (homeOf).
-export function daemonOf(root: string, conductorJson: null | string): { cli: string; home: null | string } {
-  let named: { cli?: unknown; home?: unknown } = {};
-  try {
-    if (conductorJson !== null) named = JSON.parse(conductorJson) as typeof named;
-  } catch {
-    // Not JSON: as if there were none.
-  }
+// The version is the build's whose CLI the mod runs, which the pane shows (ATK-882): conductor.json
+// names it in the daemon's copy, and elsewhere the folder's .claude-plugin/plugin.json does, which
+// the release keeps equal to the package's. Null when neither says.
+export function daemonOf(
+  root: string,
+  conductorJson: null | string,
+  manifestJson: null | string = null,
+): { cli: string; home: null | string; version: null | string } {
+  const parsed = (json: null | string): Record<string, unknown> => {
+    try {
+      const value: unknown = json === null ? null : JSON.parse(json);
+      return isRecord(value) ? value : {};
+    } catch {
+      // Not JSON: as if there were none.
+      return {};
+    }
+  };
+  const named = parsed(conductorJson);
   const text = (value: unknown): null | string => (typeof value === 'string' && value !== '' ? value : null);
-  return { cli: text(named.cli) ?? `${root}/../build/cli.js`, home: text(named.home) };
+  return {
+    cli: text(named.cli) ?? `${root}/../build/cli.js`,
+    home: text(named.home),
+    version: text(named.version) ?? text(parsed(manifestJson).version),
+  };
 }
 
 // The port and token files' text as an endpoint; null unless both are whole.
@@ -784,15 +799,20 @@ export function runText(
 }
 
 // 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.
+// the first two. A daemon older than the notifier answers /notify 404, which leaves `notify` null,
+// and one older than ATK-882 sends no version (or an empty one), which leaves `daemonVersion` null.
+// `modVersion` is the mod's to fill in (register.tsx, refresh).
 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: [] };
+  if (workers === null) return unanswered(errorOf(fleet), readAt);
   const items = inbox.status === 200 ? parseInbox(inbox.body) : null;
-  if (items === null) return { error: errorOf(inbox), inbox: [], notify: null, readAt, workers: [] };
+  if (items === null) return unanswered(errorOf(inbox), readAt);
+  const version = isRecord(fleet.body) ? fleet.body.version : null;
   return {
+    daemonVersion: typeof version === 'string' && version !== '' ? version : null,
     error: null,
     inbox: items,
+    modVersion: null,
     notify: notify?.status === 200 ? parseNotify(notify.body) : null,
     readAt,
     workers,
@@ -813,6 +833,20 @@ export function triageText(item: string, action: 'hold' | 'queue', answer: ApiAn
   return `${action === 'queue' ? 'queued' : 'held'} ${key}: its inbox item resolves on the next tick, and ${then}`;
 }
 
+// The snapshot when no daemon answered: the error, and nothing else.
+export function unanswered(error: string, readAt: number): ConductorSnapshot {
+  return { daemonVersion: null, error, inbox: [], modVersion: null, notify: null, readAt, workers: [] };
+}
+
+// The pane header's versions (ATK-882): the mod's alone when the daemon runs the same build; else
+// `mod <a>` and `daemon <b>` (`daemon ?` from a daemon too old to say), the daemon's to highlight.
+// Null when the mod doesn't know its own version.
+export function versionParts(mod: null | string, daemon: null | string): null | { daemon: null | string; mod: string } {
+  if (mod === null) return null;
+  if (daemon === mod) return { daemon: null, mod };
+  return { daemon: `daemon ${daemon ?? '?'}`, mod: `mod ${mod}` };
+}
+
 const DAYS = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
 
 // `/notify` with no profile: the profile, quiet hours, Remote Control.

package/plugin/hooks/register.tsx

@@ -53,6 +53,8 @@ import {
   takesAnswer,
   tokens,
   triageText,
+  unanswered,
+  versionParts,
   WARM_AFTER_MS,
   WARM_PROMPT,
   whyText,
@@ -238,18 +240,10 @@ async function copy(
   $.ui.toast(copied.isCopied ? `copied: ${text}` : `not copied: ${text}`);
 }
 
-// The conductor this plugin folder belongs to (model.ts, daemonOf). Read once per load: the file
-// changes only with the folder, and that reloads this module.
+// The conductor this plugin folder belongs to (model.ts, daemonOf). Its CLI and home are read once
+// per load: the file changes only with the folder, and that reloads this module.
 async function daemon($: EngineInterface): Promise<ReturnType<typeof daemonOf>> {
-  named ??= (async () => {
-    let text: null | string = null;
-    try {
-      text = await $.fs.read(`${$.plugin.root}/conductor.json`);
-    } catch {
-      // The package's own plugin folder has none.
-    }
-    return daemonOf($.plugin.root, text);
-  })();
+  named ??= pluginFolder($);
   return named;
 }
 
@@ -359,6 +353,13 @@ async function markSkillLoaded($: EngineInterface): Promise<void> {
   await update($, cleared, () => null);
 }
 
+// The mod's version, read again on each refresh (ATK-882): a refresh of the daemon's copy that
+// changes only conductor.json and plugin.json may not reload this module, and a version the load
+// kept would show as a mismatch with a daemon on the new build.
+async function modVersion($: EngineInterface): Promise<null | string> {
+  return (await pluginFolder($)).version;
+}
+
 // 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.
@@ -420,7 +421,8 @@ async function onLine($: EngineInterface, text: string): Promise<void> {
     switch (act.kind) {
       case 'disconnected': {
         const readAt = await $.clock.now();
-        await update($, snapshot, () => ({ error: NOT_RUNNING, inbox: [], notify: null, readAt, workers: [] }));
+        const mod = await modVersion($);
+        await update($, snapshot, () => ({ ...unanswered(NOT_RUNNING, readAt), modVersion: mod }));
         return;
       }
       case 'escalate':
@@ -478,6 +480,23 @@ async function override($: EngineInterface, command: 'focus' | 'pause' | 'unpaus
   }
 }
 
+// The plugin folder's conductor.json and, for the package's own folder, which has none, its
+// manifest's version.
+async function pluginFolder($: EngineInterface): Promise<ReturnType<typeof daemonOf>> {
+  const readOrNull = async (path: string): Promise<null | string> => {
+    try {
+      return await $.fs.read(path);
+    } catch {
+      return null;
+    }
+  };
+  const [conductorJson, manifestJson] = await Promise.all([
+    readOrNull(`${$.plugin.root}/conductor.json`),
+    readOrNull(`${$.plugin.root}/.claude-plugin/plugin.json`),
+  ]);
+  return daemonOf($.plugin.root, conductorJson, manifestJson);
+}
+
 // 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.
@@ -507,9 +526,10 @@ async function push($: EngineInterface, message: string): Promise<void> {
   }
 }
 
-// Reads /fleet, /inbox and /notify into the state the drawings read.
+// Reads /fleet, /inbox and /notify, and the mod's own version, into the state the drawings read.
 async function refresh($: EngineInterface): Promise<ConductorSnapshot> {
   const readAt = await $.clock.now();
+  const mod = modVersion($);
   let next: ConductorSnapshot;
   try {
     const at = await endpoint($);
@@ -520,14 +540,9 @@ async function refresh($: EngineInterface): Promise<ConductorSnapshot> {
     ]);
     next = snapshotOf(fleet, inbox, readAt, notify);
   } catch (error) {
-    next = {
-      error: error instanceof Error ? error.message : String(error),
-      inbox: [],
-      notify: null,
-      readAt,
-      workers: [],
-    };
+    next = unanswered(error instanceof Error ? error.message : String(error), readAt);
   }
+  next = { ...next, modVersion: await mod };
   await update($, snapshot, () => next);
   return next;
 }
@@ -971,22 +986,39 @@ export const register: Register = (on) => {
         <Link href={href} key={key} label={`open ${label}`} />
       );
     if (snap === null) return <Text dimColor>Reading the conductor…</Text>;
+    // The mod's version after the counts, so a narrow pane cuts it before them; a daemon on another
+    // build gets a line of its own, highlighted, so nothing cuts it (ATK-882). With no daemon
+    // answering, the mod's alone.
     if (snap.error !== null) {
       return (
         <Box flexDirection='column'>
-          <Text bold>{TITLE}</Text>
+          <Text bold wrap='truncate'>
+            {TITLE}
+            {snap.modVersion !== null && <Text dimColor>{`  ${snap.modVersion}`}</Text>}
+          </Text>
           <Text>{snap.error}</Text>
         </Box>
       );
     }
+    const versions = versionParts(snap.modVersion, snap.daemonVersion);
+    const stale = versions?.daemon ?? null;
     const columns = fleetColumns(snap.workers);
     return (
       <Box flexDirection='column'>
         <Text bold wrap='truncate'>
           {TITLE}
           {'  '}
-          <Text dimColor>{statusText(snap)}</Text>
+          <Text dimColor>
+            {statusText(snap)}
+            {versions !== null && stale === null ? ` · ${versions.mod}` : ''}
+          </Text>
         </Text>
+        {versions !== null && stale !== null && (
+          <Text wrap='truncate'>
+            <Text dimColor>{`${versions.mod} · `}</Text>
+            <Text color='warning'>{stale}</Text>
+          </Text>
+        )}
         {snap.notify !== null && (
           <Box columnGap={2} flexWrap='wrap'>
             {e.surface !== 'mobile' && 'Select' in ui ? (

package/plugin/types/index.d.ts

@@ -28,10 +28,14 @@ export type ConductorNotify = {
 };
 
 // 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.
+// `notify` is null from a daemon older than the notifier, `daemonVersion` from one older than ATK-882
+// (GET /fleet's `version`). `modVersion` is the mod's own, read from its plugin folder with each
+// refresh (ATK-882); null when the folder doesn't say.
 export type ConductorSnapshot = {
+  daemonVersion: null | string;
   error: null | string;
   inbox: ConductorInboxItem[];
+  modVersion: null | string;
   notify: ConductorNotify | null;
   readAt: number;
   workers: ConductorWorker[];