@detergent-software/conductor 3.5.0-dev.1 → 3.5.0-dev.3

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 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.5.0-dev.3](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/branchCompare?baseVersion=GTconductor-v3.5.0-dev.2&targetVersion=GTconductor-v3.5.0-dev.3) (2026-10-29)
+
+### Bug Fixes
+
+* **conductor:** load the console skill again after a compaction (ATK-843) ([793a837](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/commit/793a8377407f7a18c5fdffa09b9a9fd41ccafd00))
+* **conductor:** read the skill's state before the compaction (ATK-843) ([95a10d7](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/commit/95a10d79f462f136fb173cb31f71ba2623ae4bd1))
+
+## [3.5.0-dev.2](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/branchCompare?baseVersion=GTconductor-v3.5.0-dev.1&targetVersion=GTconductor-v3.5.0-dev.2) (2026-10-29)
+
+### Features
+
+* **conductor:** load the console skill in code after a /clear (ATK-840) ([6b13e41](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/commit/6b13e41d3b47946d12a8503f7d6512ee2b3e8f8a))
+
+### Bug Fixes
+
+* **conductor:** mark the console skill loaded only when it is (ATK-840) ([0c8aa3a](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/commit/0c8aa3a02fe55416776456d81dc2b3c6b3b760a8))
+
 ## [3.5.0-dev.1](https://emergentcode.visualstudio.com/Emergent%20Software/_git/Emergent.AgenticToolkit/branchCompare?baseVersion=GTconductor-v3.4.0&targetVersion=GTconductor-v3.5.0-dev.1) (2026-10-27)
 
 ### Features

package/README.md

@@ -955,8 +955,8 @@ 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);
-  - **a check that `/conductor:conductor-console` ran**: a console started without it (by hand, as `claude --plugin-dir … -n conductor`) shows `console without its skill: run /conductor:conductor-console` in the band, and each prompt, the operator's or an escalation's, carries a line telling the model to load the skill before it answers. Running the skill (`/conductor:conductor-console`, or the model's Skill tool) clears both, until a `/clear` or a resume starts a conversation without it;
-  - **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 loads the skill. 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 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;
+  - **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:
 
 | Event | Data | The mod |

package/package.json

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

package/plugin/hooks/model.ts

@@ -48,11 +48,38 @@ export function reportedState(outcome: PushOutcome): 'failing' | 'inactive' | 'o
 
 // The skill a console runs first (ATK-385), as this plugin namespaces it: the engine names a plugin
 // skill `<plugin>:<skill>` in skill.prompt (ATK-525). `conduct console` starts with it as the first
-// prompt; a console started by hand (`claude --plugin-dir … -n conductor`) has to be told.
+// prompt; in a console started by hand (`claude --plugin-dir … -n conductor`), or after a /clear or
+// a resume, the mod loads it with the next prompt (ATK-840).
 export const CONSOLE_SKILL = 'conductor:conductor-console';
-// What the model reads beside each prompt of a console whose skill hasn't run.
+// The skill's file, under the plugin folder ($.plugin.root).
+export const CONSOLE_SKILL_FILE = 'skills/conductor-console/SKILL.md';
+// What the model reads beside a prompt when the mod couldn't read the skill to load it.
 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}`;
+export const NO_SKILL_WARNING = `console without its skill: /${CONSOLE_SKILL} loads with the next prompt`;
+
+// ATK-843: whether a conversation's texts still hold the skill after a compaction. The mark is the
+// body's first line of prose, cut short: a summary paraphrases it, while it may repeat the heading.
+// A first line too short to tell apart (a fence, a rule) marks nothing, so the skill counts as gone.
+export function keepsSkill(texts: readonly string[], body: string): boolean {
+  const prose = body
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find((line) => line !== '' && !line.startsWith('#'));
+  const mark = prose?.slice(0, 120);
+  return mark !== undefined && mark.length >= 40 && texts.some((text) => text.includes(mark));
+}
+
+// What the model reads beside the first prompt of a console without its skill: the skill, as the
+// mod loaded it (ATK-840). It comes after the prompt, so it says to run Start first.
+export function loadedSkillContext(body: string): string {
+  return `This session is the conductor console (CONDUCTOR_CONSOLE=1), and this conversation started without /${CONSOLE_SKILL} (a /clear, a resume, or a console started by hand), so the conductor mod loaded it: the skill follows. Follow it from its Start, then answer the prompt above.\n\n${body}`;
+}
+
+// A SKILL.md without its frontmatter: the text the engine expands for the model.
+export function skillBody(file: string): string {
+  const head = /^\uFEFF?---\r?\n(?:[\s\S]*?\r?\n)?---[ \t]*(?:\r?\n|$)/.exec(file);
+  return (head === null ? file : file.slice(head[0].length)).trim();
+}
 
 // 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

package/plugin/hooks/register.tsx

@@ -13,6 +13,7 @@ import {
   bandEntries,
   clearedText,
   CONSOLE_SKILL,
+  CONSOLE_SKILL_FILE,
   daemonOf,
   endpointOf,
   findHandoff,
@@ -24,6 +25,8 @@ import {
   idleAction,
   inboxText,
   isWebLink,
+  keepsSkill,
+  loadedSkillContext,
   MAYBE_POSTED,
   NO_SKILL_CONTEXT,
   NO_SKILL_WARNING,
@@ -43,6 +46,7 @@ import {
   reportedState,
   reviseText,
   runText,
+  skillBody,
   snapshotOf,
   spendToday,
   statusText,
@@ -275,6 +279,31 @@ async function endpoint($: EngineInterface): Promise<Endpoint> {
   return found;
 }
 
+// ATK-840: an escalation to a console without its skill runs the skill, with the escalation as its
+// arguments: one turn, the skill as the engine expands it. The mod's prompt.submit hook can't load it
+// there, as the engine never runs a hook on what its own plugin submits (the re-entry rule). The
+// console counts as loaded from here, so a prompt or escalation meanwhile doesn't load it twice, and
+// the stream reads on rather than wait out the skill's turn. Should the run be refused, it isn't
+// loaded after all, and the escalation goes as it is, asking the model to load the skill.
+async function escalateWithSkill($: EngineInterface, text: string): Promise<void> {
+  await markSkillLoaded($);
+  void $.command.run({ args: text, command: CONSOLE_SKILL }).catch(async (error: unknown) => {
+    await update($, hasSkill, () => false);
+    $.ui.log(
+      `conductor: /${CONSOLE_SKILL} not run (${error instanceof Error ? error.message : String(error)}); asking the model to load it`,
+      { to: 'debug' },
+    );
+    try {
+      await $.prompt.submit({ text: `${text}\n\n${NO_SKILL_CONTEXT}` });
+    } catch (submitError) {
+      $.ui.log(
+        `conductor: escalate failed: ${submitError instanceof Error ? submitError.message : String(submitError)}`,
+        { to: 'debug' },
+      );
+    }
+  });
+}
+
 // `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
@@ -318,6 +347,18 @@ async function follow($: EngineInterface): Promise<void> {
   $.ui.log('conductor: conduct events keeps exiting; the console polls instead', { to: 'debug' });
 }
 
+// The console skill as the engine would expand it: its file's text without the frontmatter. A mod's
+// `$` has no `$.skill` to run it through the skill.prompt hooks (engine 2.1.312), so none sees it.
+async function loadSkill($: EngineInterface): Promise<string> {
+  return skillBody(await $.fs.read(`${$.plugin.root}/${CONSOLE_SKILL_FILE}`));
+}
+
+// The console's conversation has its skill: the band's warning and its "cleared while idle" go.
+async function markSkillLoaded($: EngineInterface): Promise<void> {
+  await update($, hasSkill, () => true);
+  await update($, cleared, () => 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.
@@ -384,7 +425,8 @@ 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.
-        await $.prompt.submit({ text: act.text });
+        if (await read($, hasSkill)) await $.prompt.submit({ text: act.text });
+        else await escalateWithSkill($, act.text);
         return;
       case 'ignore':
         return;
@@ -667,16 +709,12 @@ 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:conductor-console` or the Skill
-  // tool expands it before its prompt is submitted; a /clear or a resume starts a conversation
-  // without it.
+  // Whether the console's conversation has its skill (ATK-385): `/conductor:conductor-console` or
+  // the Skill tool expands it before its prompt is submitted, and prompt.submit loads it when
+  // neither has (ATK-840). 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);
-    }
+    if (isConsole) await markSkillLoaded($);
     return prompt;
   });
 
@@ -692,6 +730,35 @@ export const register: Register = (on) => {
     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.
+  // 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;
+  });
+
   // 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.
@@ -715,10 +782,28 @@ export const register: Register = (on) => {
     return done;
   });
 
+  // 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.
   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] });
+    const ask = (): ReturnType<typeof next> => next({ ...e, context: [...(e.context ?? []), NO_SKILL_CONTEXT] });
+    if (e.command !== undefined) return ask();
+    let loaded: string;
+    try {
+      loaded = await loadSkill($);
+    } catch (error) {
+      $.ui.log(
+        `conductor: /${CONSOLE_SKILL} not loaded (${error instanceof Error ? error.message : String(error)}); asking the model to load it`,
+        { to: 'debug' },
+      );
+      return ask();
+    }
+    const entered = await next({ ...e, context: [...(e.context ?? []), loadedSkillContext(loaded)] });
+    if (entered.drop === undefined) await markSkillLoaded($);
+    return entered;
   });
 
   on('command.run', { command: 'conductor' }, async ($) => {
@@ -794,8 +879,8 @@ export const register: Register = (on) => {
 
   // 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`). Until
-  // /conductor: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).
+  // the console has its skill, 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 { Box, Button, Text } = $.ui.resolve(e);

package/plugin/skills/conductor-console/SKILL.md

@@ -32,7 +32,7 @@ When `/conductor:conductor-console` runs:
 2. Check the setup in one Bash call: `echo $CONDUCTOR_CONSOLE` and `conduct --version`.
    - Not `1`: say that the band, the pane and the escalation wake-ups are off in this session, and that `conduct console` opens a proper one. Go on with chat.
    - If the operator says the band or pane is missing: the mod comes with the conductor plugin in `~/.conductor/plugin`, which only `conduct console` loads (`--plugin-dir`). Check that the folder holds `hooks/register.tsx`, then run `/reload-plugins`; if it doesn't, `conduct start` (a daemon refreshes it as it starts), then close this session and run `conduct console`.
-3. `conduct escalations`. These are escalations raised while no console was open. Handle each one, oldest first, as below.
+3. `conduct escalations`. These are escalations raised while no console was open. Handle each one, oldest first, as below. When the skill ran with an escalation as its arguments (`[conductor] escalation #<id> …`: the mod woke a console that had lost its skill after a `/clear` or a resume), handle that one here too, once, whether or not the list has it.
 4. Report in two or three lines from `conduct status`, `conduct inbox` and the first line of `conduct queue`: workers running and parked, what waits on the operator, and the scheduler's mode. If the mode is `off`, say that the daemon launches nothing until `"scheduler": { "mode": "on" }` is set in `~/.conductor/config.json` and the daemon is restarted (`conduct stop`, then `conduct start`).
 
 Then end the turn.