@detergent-software/conductor 3.6.0-dev.5 → 3.6.0-dev.6

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 Releases are tagged `conductor-v<version>` and staged on npm by `atk-conductor-release` (`pipelines/release-conductor.yml`), which writes each section below. `scripts/check-changelog.mjs` fails when a tag has no section here.
 
+## [3.6.0-dev.6](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/branchCompare?baseVersion=GTconductor-v3.6.0-dev.5&targetVersion=GTconductor-v3.6.0-dev.6) (2026-11-07)
+
+### Bug Fixes
+
+* **conductor:** address review of the console's skill check (ATK-941) ([80e5ce2](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/commit/80e5ce2da137517b3007f8a63108bf9bbd44bac0))
+* **conductor:** read the console's skill from what the model is sent (ATK-941) ([c451be1](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/commit/c451be1b348c4f0bd51f1c771be78dceaa4e048e))
+
 ## [3.6.0-dev.5](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/branchCompare?baseVersion=GTconductor-v3.6.0-dev.4&targetVersion=GTconductor-v3.6.0-dev.5) (2026-11-07)
 
 ### Bug Fixes

package/README.md

@@ -974,7 +974,7 @@ The mod is the plugin's hooks module, code that costs no tokens, which does the
   - **the band** above the prompt while the inbox has items: one hotkey per item (a plan approves after a second press, `y`, since a digit typed into an empty prompt presses a band button; an npm OTP copies its `npm stage approve` line; the rest open the pane), and `o` for the pane;
   - **the pane** (`/conductor`, `o`, or opened at the start, docked as a sidebar on a fullscreen terminal of 144 columns or more): the notification profile (a picker; buttons on mobile) and Remote Control's state, the inbox with each item's actions (approve, revise, answer on a `scope`, `blocked`, `human` or `operator` Handoff, or a `failed` one whose worker waits on its item, which fills `/answer #<id> ` in the prompt, copy a command, open a link, done; on a Windows terminal, open is a button that opens a web link in the default browser once, since a ctrl+click on a link in a pane opened it twice, ATK-494), the workers by project (each project's rule has [pause] and [focus]), and today's spend. The header counts the workers running and parked and the inbox in words. Each worker is one line in columns that line up across projects, cut to the pane's width so it never wraps: a glyph, the item, its phase, its PR, what it waits on in words (`PR #557 to merge (skills-registry)`, `npm 8.9.0-dev.1 on dev (cli)`, `login (ado)`) or else its activity, and the age. As the pane narrows, the age goes first, then the wait, then the PR and the phase (ATK-521). The glyphs are one cell wide: `●` in a turn, `◌` up between turns, `!` stuck on a prompt, `○` parked, `×` failed or gone, `·` starting. A row expands to attach and why, its tokens today, its whole PR ref and its raw wait keys;
   - **commands answered in code**, never by the model: `/conductor`, `/inbox`, `/approve <item | #id>`, `/revise <item | #id> <text>`, `/answer <item | #id> <text>` (`conduct done #<id> --answer <text>`, the text as typed), `/attach <item | worker>`, `/notify [<profile> [--until <when>]]`, `/pause [<project>] [--until <when>]`, `/unpause [<project>]`, `/focus-project <project> [--until <when>]` (puts its items first, until midnight without `--until`; not `/focus`, which is Claude Code's own);
-  - **the skill, loaded in code** (ATK-385, ATK-840, ATK-843): a console whose conversation lacks `/conductor:conductor-console` (one started by hand, as `claude --plugin-dir … -n conductor`, after a `/clear` or a resume, or after a compaction that kept only a summary of the skill: the mod checks what the compaction kept for the skill's first line of prose, and writes `conductor: the compaction kept|dropped /conductor:conductor-console` to the debug log) shows `console without its skill: /conductor:conductor-console loads with the next prompt` in the band, and the mod loads the skill itself with the next prompt, not the model. The operator's prompt carries the skill's text (its `SKILL.md` without the frontmatter, read from the plugin folder) as context the model reads first, with a line to run its Start, then answer. An escalation runs `/conductor:conductor-console` with the escalation as its arguments, since the mod's own `prompt.submit` hook never sees a prompt the mod submits. Nothing runs at the clear itself. A slash command loads nothing (`/conductor:conductor-console` loads itself): it carries a line asking the model to load the skill, as before, and so does every prompt while the file can't be read, or an escalation whose run the engine refuses;
+  - **the skill, loaded in code** (ATK-385, ATK-840, ATK-843, ATK-941): a console whose conversation lacks `/conductor:conductor-console` (one started by hand, as `claude --plugin-dir … -n conductor`, or after a `/clear` or a resume) shows `console without its skill: /conductor:conductor-console loads with the next prompt` in the band, and the mod loads the skill itself with the next prompt, not the model. The operator's prompt carries the skill's text (its `SKILL.md` without the frontmatter, read from the plugin folder) as context the model reads first, with a line to run its Start, then answer. An escalation runs `/conductor:conductor-console` with the escalation as its arguments, since the mod's own `prompt.submit` hook never sees a prompt the mod submits. Nothing runs at the clear itself. After a compaction or a resume, the next prompt or escalation reads the conversation as the model is sent it (`$.session.messages({ as: 'api' })`) for the skill's first line of prose, and loads nothing when it is there. A compaction raises no band warning: the mod can't tell until that read. The engine puts a skill that ran back after a compaction's boundary as a meta message, which the compaction's own rows leave out. After a compaction, the debug log reads `conductor: compacted; the next prompt checks for /conductor:conductor-console`, then `conductor: the compaction kept|dropped /conductor:conductor-console`. A slash command loads nothing (`/conductor:conductor-console` expands the skill with its own prompt, which carries nothing): it carries a line asking the model to load the skill, as before, and so does every prompt while the file can't be read, or an escalation whose run the engine refuses;
   - **a warm prompt cache while it idles** (ATK-386). The console's cache lasts an hour after its last use, and a wake after that writes the whole context again. So 55 minutes after the console's last turn, the mod sends one ping (`$.model.fork`, the console's own last request plus a one-word ask, no tools, no turn in the transcript). The API serves the ping from the cache for a tenth of a write's price, and the hour starts over. It pings again every 55 minutes until a turn comes, and each turn starts the timer over. At an idle point it runs `/clear` instead when the context is 150k or more, or after 12 pings in a row (the 13th idle point, about 12 hours after the last turn), and the band says `fresh console (cleared while idle: …)` until the next prompt, when the mod loads the skill (above). A ping that read less than half the context from the cache (the cache was gone anyway, as under a 5-minute TTL) stops the pings until the next turn. Each ping and clear goes to `POST /console/cache`, which logs a `console.cache` event with the context size and what the ping cost. A fork isn't in the transcript, so that event is the only place its cost shows;
   - **the stream**: it runs `node <the cli.js that conductor.json names> events --follow --console` (`--console` tells the daemon a console is open), redraws on each event, toasts each new inbox item, and acts on three events:
 

package/package.json

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

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

@@ -1,6 +1,6 @@
 {
   "name": "conductor",
-  "version": "3.6.0-dev.5",
+  "version": "3.6.0-dev.6",
   "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"

package/plugin/hooks/register.tsx

@@ -90,11 +90,14 @@ const confirming = atom({ key: 'confirming', plugin: 'conductor' } as const, nul
 const expanded = atom({ key: 'expanded', plugin: 'conductor' } as const, null);
 const hasSkill = atom({ key: 'hasSkill', plugin: 'conductor' } as const, false);
 const cleared = atom({ key: 'cleared', plugin: 'conductor' } as const, null);
+const compacted = atom({ key: 'compacted', plugin: 'conductor' } as const, false);
 
 // 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;
+// The read consoleHasSkill has in flight (ATK-941).
+let skillCheck: null | Promise<boolean> = null;
 let isRefreshing = false;
 // The plugin folder's conductor.json, read once per load (daemon).
 let named: null | Promise<ReturnType<typeof daemonOf>> = null;
@@ -235,6 +238,21 @@ async function confirm($: EngineInterface, id: number): Promise<void> {
   $.clock.after(CONFIRM_MS, () => void update($, confirming, (staged) => (staged === id ? null : staged)));
 }
 
+// ATK-941: whether the console's conversation holds its skill, as the model is sent it. Taken on
+// trust while the skill is loaded and nothing compacted since; otherwise read from
+// $.session.messages({ as: 'api' }), as a worker's is (ATK-937). The rows leave out meta messages,
+// which is where a skill's expansion is and where the engine puts it back after a compaction, and
+// a resumed conversation may hold it already. An empty conversation (a /clear, a start) holds
+// nothing. A skill file that can't be read counts as gone, so the prompt asks the model to load it.
+// A prompt and an escalation at once share one read, so they don't both load the skill.
+async function consoleHasSkill($: EngineInterface): Promise<boolean> {
+  if (!(await read($, compacted)) && (await read($, hasSkill))) return true;
+  skillCheck ??= readConsoleSkill($).finally(() => {
+    skillCheck = null;
+  });
+  return skillCheck;
+}
+
 async function copy(
   $: EngineInterface,
   text: string,
@@ -355,6 +373,7 @@ async function loadSkill($: EngineInterface): Promise<string> {
 async function markSkillLoaded($: EngineInterface): Promise<void> {
   await update($, hasSkill, () => true);
   await update($, cleared, () => null);
+  await update($, compacted, () => false);
 }
 
 // The mod's version, read again on each refresh (ATK-882): a refresh of the daemon's copy that
@@ -431,7 +450,7 @@ async function onLine($: EngineInterface, text: string): Promise<void> {
       }
       case 'escalate':
         // The one place the mod wakes the console's model: facts only, as the rules engine wrote them.
-        if (await read($, hasSkill)) await $.prompt.submit({ text: act.text });
+        if (await consoleHasSkill($)) await $.prompt.submit({ text: act.text });
         else await escalateWithSkill($, act.text);
         return;
       case 'ignore':
@@ -530,6 +549,47 @@ async function push($: EngineInterface, message: string): Promise<void> {
   }
 }
 
+// consoleHasSkill's read. A conversation that can't be read, or a skill whose first line of prose is
+// too short to tell apart (keepsSkill), leaves the state as it was.
+async function readConsoleSkill($: EngineInterface): Promise<boolean> {
+  const isCompacted = await read($, compacted);
+  let messages: unknown;
+  try {
+    messages = await $.session.messages({ as: 'api' });
+  } catch (error) {
+    $.ui.log(
+      `conductor: the conversation can't be read (${error instanceof Error ? error.message : String(error)}); /${CONSOLE_SKILL} not checked`,
+      { to: 'debug' },
+    );
+    return read($, hasSkill);
+  }
+  let isHeld = false;
+  let unread = '';
+  if (Array.isArray(messages) && messages.length > 0) {
+    let body: null | string = null;
+    try {
+      body = await loadSkill($);
+    } catch (error) {
+      unread = ` (its file can't be read: ${error instanceof Error ? error.message : String(error)})`;
+    }
+    if (body !== null && !keepsSkill([body], body)) {
+      $.ui.log(`conductor: /${CONSOLE_SKILL} has no first line of prose to tell it by; not checked`, { to: 'debug' });
+      await update($, compacted, () => false);
+      return read($, hasSkill);
+    }
+    if (body !== null) isHeld = keepsSkill(apiTexts(messages), body);
+  }
+  if (isCompacted) {
+    $.ui.log(`conductor: the compaction ${isHeld ? 'kept' : 'dropped'} /${CONSOLE_SKILL}${unread}`, { to: 'debug' });
+  }
+  if (isHeld) await markSkillLoaded($);
+  else {
+    await update($, hasSkill, () => false);
+    await update($, compacted, () => false);
+  }
+  return isHeld;
+}
+
 // 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();
@@ -781,38 +841,27 @@ export const register: Register = (on) => {
       disarmIdle();
       warms = 0;
       await update($, hasSkill, () => false);
+      await update($, compacted, () => false);
       if (!isClearing) await update($, cleared, () => null);
     }
     return next(e);
   });
 
   // ATK-843: a compaction ends no conversation, but it can drop the skill: the mod's copy is a block
-  // beside one prompt, which a summary only paraphrases. What the compaction kept says which, and the
-  // next prompt loads the skill again when it went, as after a /clear. A skill file that can't be
-  // read counts as gone, so that prompt asks the model to load it.
+  // beside one prompt, which a summary only paraphrases. The engine puts a skill that ran back after
+  // the boundary as a meta message, which the compaction's rows leave out (ATK-941), and a read of
+  // the conversation here still shows the old one (ATK-937), so the next prompt or escalation reads
+  // what the model is sent (consoleHasSkill) and loads the skill again only when it went.
   // Whether the skill was there is read before the compaction runs: an escalation meanwhile marks it
   // loaded for a run that comes after, which the compaction can't hold yet.
   on('session.compact', async ($, e, next) => {
     const isWatched = isConsole && e.agentId === undefined && e.trigger !== 'precompute';
     const hadSkill = isWatched && (await read($, hasSkill));
-    const compacted = await next(e);
-    if (!hadSkill || compacted.skip !== undefined) return compacted;
-    // The skill's text in a message, or in a tool's result when the Skill tool loaded it.
-    const texts = compacted.messages.flatMap((message) => [
-      message.text,
-      ...message.toolUses.map((use) => use.text ?? ''),
-      ...(message.toolResults ?? []).map((result) => result.text),
-    ]);
-    let isKept = false;
-    let unread = '';
-    try {
-      isKept = keepsSkill(texts, await loadSkill($));
-    } catch (error) {
-      unread = ` (its file can't be read: ${error instanceof Error ? error.message : String(error)})`;
-    }
-    $.ui.log(`conductor: the compaction ${isKept ? 'kept' : 'dropped'} /${CONSOLE_SKILL}${unread}`, { to: 'debug' });
-    if (!isKept) await update($, hasSkill, () => false);
-    return compacted;
+    const result = await next(e);
+    if (!hadSkill || result.skip !== undefined) return result;
+    await update($, compacted, () => true);
+    $.ui.log(`conductor: compacted; the next prompt checks for /${CONSOLE_SKILL}`, { to: 'debug' });
+    return result;
   });
 
   // ATK-386: each of the console's own turns starts its idle point over, and a turn in progress
@@ -841,14 +890,15 @@ export const register: Register = (on) => {
   // ATK-840: the first prompt of a console without its skill (the operator's or an escalation's)
   // carries the skill, loaded by the mod, so its rules hold without the model choosing to load it;
   // it counts once the prompt has entered. A slash command loads nothing: the skill's own expands
-  // before it, and the rest carry the line asking the model to load it, as does every prompt while
-  // the skill's file can't be read.
+  // with it, inside next (skill.prompt, ATK-941), and the rest carry the line asking the model to
+  // load it, as does every prompt while the skill's file can't be read.
   on('prompt.submit', async ($, e, next) => {
     if (!isConsole) {
       const context = await workerContext($, e);
       return next(context === null ? e : { ...e, context: [...(e.context ?? []), context] });
     }
-    if (await read($, hasSkill)) return next(e);
+    if (e.command?.name === CONSOLE_SKILL) return next(e);
+    if (await consoleHasSkill($)) return next(e);
     const ask = (): ReturnType<typeof next> => next({ ...e, context: [...(e.context ?? []), NO_SKILL_CONTEXT] });
     if (e.command !== undefined) return ask();
     let loaded: string;

package/plugin/types/index.d.ts

@@ -66,6 +66,9 @@ declare module 'claude-code' {
       // 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: null | string;
+      // Whether a compaction ran since the console last had its skill (ATK-941): the next prompt or
+      // escalation reads the conversation to tell whether it still holds the skill.
+      compacted: boolean;
       // The inbox id whose approve waits on a second press in the band.
       confirming: null | number;
       // The worker whose row the pane shows expanded, by name.