@detergent-software/conductor 3.0.0-dev.4 → 3.0.0-dev.41

package/plugin/hooks/model.ts

@@ -9,7 +9,7 @@ export type ApiAnswer = { body: unknown; status: number };
 
 // What a Remote Control push came to: reached the phone (ok); not, as Remote Control is off
 // (inactive) or pushes are off in Claude Code's config (disabled); not sent to the phone on
-// purpose (skipped: Jason is at the terminal, or the answer says nothing about the phone); or the
+// purpose (skipped: the operator is at the terminal, or the answer says nothing about the phone); or the
 // call failed (failed: it threw, was denied, or answered an error).
 export type PushOutcome = { detail: string; state: 'disabled' | 'failed' | 'inactive' | 'ok' | 'skipped' };
 
@@ -211,7 +211,7 @@ export type FleetRow = {
 };
 
 // A wait's condition key (conditions.ts's formatCondition) in words, the telling part first so a
-// truncated row keeps it: `PR #557 to merge (agentic-toolkit-registry)`, `npm 1.2.3 on dev (atk)`.
+// truncated row keeps it: `PR #557 to merge (skills-registry)`, `npm 1.2.3 on dev (cli)`.
 // A kind this doesn't know, or a key it can't read, stays as it is.
 export function waitLabel(condition: string, now: number): string {
   const colon = condition.indexOf(':');
@@ -301,10 +301,13 @@ export function findPlan(inbox: readonly ConductorInboxItem[], ref: string): Fou
     const item = inbox.find((i) => i.id === Number(byId[1]));
     return item ? { found: item } : { error: `no open inbox item ${ref}` };
   }
-  if (/^\d+$/.test(ref.trim()))
-    return {
-      error: `"${ref}" is ambiguous: name the item, such as ATK-${ref.trim()}, or the inbox id as #${ref.trim()}`,
-    };
+  if (/^\d+$/.test(ref.trim())) {
+    const n = ref.trim();
+    // The waiting plans whose key ends in the number, else a placeholder: the project's key isn't known here.
+    const keys = inbox.flatMap((i) => (i.kind === 'plan' && i.item?.endsWith(`-${n}`) ? [i.item] : []));
+    const item = keys.length > 0 ? keys.join(' or ') : `<KEY>-${n}`;
+    return { error: `"${ref}" is ambiguous: name the item, such as ${item}, or the inbox id as #${n}` };
+  }
   const plans = inbox.filter((i) => i.kind === 'plan' && i.item?.toUpperCase() === ref.trim().toUpperCase());
   if (plans.length === 1 && plans[0]) return { found: plans[0] };
   if (plans.length === 0) return { error: `no plan of ${ref} waits in the inbox` };
@@ -553,6 +556,14 @@ export function answerText(action: 'approve' | 'done' | 'revise', id: number, an
   return `${action === 'approve' ? 'approved' : 'asked for a revision of'} ${key}: ${where}`;
 }
 
+// The item a /revise names when no plan of it waits in the inbox, which `conduct revise` then revises
+// as an approved plan (ATK-664); null for an inbox id, a bare number, or an item whose plan waits.
+export function approvedPlanItem(inbox: readonly ConductorInboxItem[], ref: string): null | string {
+  const key = ref.trim().toUpperCase();
+  if (!/^[A-Z]+-\d+$/.test(key)) return null;
+  return inbox.some((i) => i.kind === 'plan' && i.item?.toUpperCase() === key) ? null : key;
+}
+
 // The conductor this plugin folder belongs to: the CLI the mod runs, and the daemon's home. The
 // daemon's copy (<CONDUCTOR_HOME>/plugin) names both in conductor.json, written on each refresh.
 // The home matters because a `claude --bg` session doesn't see its launcher's environment: a worker
@@ -636,6 +647,35 @@ export function pushOutcome(answer: unknown): PushOutcome {
   return { detail: detail || 'PushNotification said nothing about the phone', state: 'skipped' };
 }
 
+// POST /items/:item/revise's answer as the line to show, as `conduct revise` says it (reviseOutcome
+// in src/cli.ts, which the mod doesn't import). A daemon from before ATK-664 has no such route (404).
+export function reviseText(item: string, answer: ApiAnswer): string {
+  if (answer.status === 404)
+    return `not revised: no plan of ${item} waits in the inbox, and a conductor started before ATK-664 revises no approved plan: restart it for that`;
+  if (answer.status !== 200) {
+    const unknown = answer.status === 502 && isRecord(answer.body) && answer.body.posted === 'unknown';
+    return `not revised: ${errorOf(answer)}${unknown ? `; ${MAYBE_POSTED}` : ''}`;
+  }
+  const r = isRecord(answer.body) && isRecord(answer.body.revise) ? answer.body.revise : {};
+  const comment = isRecord(r.comment) ? r.comment : {};
+  const where =
+    typeof comment.url === 'string' ? comment.url : typeof comment.id === 'string' ? comment.id : 'comment posted';
+  const none = 'no worker is on it: one launched on it reads the revise in its brief';
+  const outcome =
+    typeof r.pending === 'string'
+      ? `nothing recorded yet (${r.pending}): ${r.worker === true ? 'the revise sweep records it and wakes its worker within 5 minutes' : none}`
+      : r.revised !== true
+        ? 'a revise of its plan was recorded already: its worker re-plans on the first one'
+        : typeof r.woken === 'number' && r.woken > 0
+          ? 'woke its worker to re-plan'
+          : r.landed === true
+            ? 'its PR has merged: its worker learns of it at its next note, for a follow-up PR'
+            : r.worker === true
+              ? 'its worker is running: its next note is held back, and it re-plans'
+              : none;
+  return `asked for a revision of ${item}'s approved plan: ${where}; ${outcome}`;
+}
+
 // A `conduct` run (attach, approve, revise) as the line to show: what it printed when it succeeded
 // (`woke …`, `approved …`), else `failed`, then its error and details without the `conduct: `
 // prefix, and without anything node wrote before it (a warning).

package/plugin/hooks/register.tsx

@@ -8,6 +8,7 @@ import {
   age,
   answerText,
   type ApiAnswer,
+  approvedPlanItem,
   bandEntries,
   clearedText,
   CONSOLE_SKILL,
@@ -39,6 +40,7 @@ import {
   pushWarning,
   reaction,
   reportedState,
+  reviseText,
   runText,
   snapshotOf,
   spendToday,
@@ -65,6 +67,9 @@ const ATTACH_RUN_MS = 10 * 60_000;
 // An approve or a revise asks Linear twice, and `conduct approve|revise` allows that 60 s (ATK-508);
 // this adds node's start.
 const ANSWER_RUN_MS = 2 * 60_000;
+// A revise of an approved plan reads the brief up to three times after it posts, and
+// `conduct revise` allows that 3 min (ATK-664).
+const REVISE_RUN_MS = 4 * 60_000;
 const NOT_RUNNING = 'the conductor is not running (conduct serve)';
 
 const snapshot = atom({ key: 'snapshot', plugin: 'conductor' } as const, null);
@@ -98,7 +103,7 @@ let isWindows = false;
 
 type Endpoint = { port: number; token: string };
 
-// Jason's answer to an inbox item, as `conduct approve|revise|done` posts it; the line to show.
+// The operator's answer to an inbox item, as `conduct approve|revise|done` posts it; the line to show.
 // Approve and revise run `conduct` (ANSWER_RUN_MS), by inbox id. Without the CLI, the API, which
 // $.http.fetch cuts off after 30 s, possibly after the comment was posted. Done doesn't ask Linear.
 async function answer(
@@ -549,6 +554,38 @@ async function reportPlugin($: EngineInterface): Promise<void> {
   }
 }
 
+// /revise of an item with no plan in the inbox: `conduct revise <item>` revises its approved plan
+// (ATK-664), as `answer` runs it, or POST /items/:item/revise without the CLI.
+async function reviseApproved($: EngineInterface, item: string, text: string): Promise<string> {
+  try {
+    const cli = await cliPath($);
+    if (await $.fs.exists(cli)) {
+      let run;
+      try {
+        run = await $.process.run(['node', cli, 'revise', item, text], {
+          ...(await cliInit($)),
+          timeoutMs: REVISE_RUN_MS,
+        });
+      } catch (error) {
+        return `not revised: ${error instanceof Error ? error.message : String(error)}`;
+      }
+      refreshSoon($);
+      return runText(run, { failed: 'not revised', ok: `asked for a revision of ${item}'s approved plan` });
+    }
+    const at = await endpoint($);
+    let result: ApiAnswer;
+    try {
+      result = await callApi($, 'POST', `/items/${encodeURIComponent(item)}/revise`, { text }, at);
+    } catch (error) {
+      return `not revised: ${error instanceof Error ? error.message : String(error)}; ${MAYBE_POSTED}`;
+    }
+    refreshSoon($);
+    return reviseText(item, result);
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+
 // `/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 {
@@ -671,7 +708,9 @@ export const register: Register = (on) => {
     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 };
+    if (plan.found) return { text: await answer($, plan.found.id, { action: 'revise', text }) };
+    const approved = approvedPlanItem(snap.inbox, ref);
+    return { text: approved === null ? plan.error : await reviseApproved($, approved, text) };
   });
 
   on('command.run', { command: 'attach' }, async ($, e) => {

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

@@ -1,39 +1,39 @@
 ---
 name: conductor-console
-description: Be the conductor console - the one always-open Claude session beside the conductor daemon (`conduct`). Wakes only for an escalation from the daemon's rules or for Jason. Handles escalations (a worker's conductor Handoff, a failed run, a stall, a vague item) and reports back through `conduct escalations done`. Answers Jason from `conduct status`, `inbox`, `queue` and `why`, and turns plain words into `conduct pause`, `focus`, `notify profile`, `approve` or `retire`. No loop, no ticks. Ships in the conductor plugin. Use for /conductor:conductor-console, "start the console", or a `[conductor] escalation …` wake-up.
+description: Be the conductor console - the one always-open Claude session beside the conductor daemon (`conduct`). Wakes only for an escalation from the daemon's rules or for the operator. Handles escalations (a worker's conductor Handoff, a failed run, a stall, a vague item) and reports back through `conduct escalations done`. Answers the operator from `conduct status`, `inbox`, `queue` and `why`, and turns plain words into `conduct pause`, `focus`, `notify profile`, `approve` or `retire`. No loop, no ticks. Ships in the conductor plugin. Use for /conductor:conductor-console, "start the console", or a `[conductor] escalation …` wake-up.
 ---
 
 # conductor-console
 
-You are **the console**, the one Claude session that stays open beside **the daemon** (`conduct serve`, package `@detergent-software/conductor`). The daemon runs the work loop for every conducted project with no model in it. It picks items, launches and retires **workers** (one Claude session per item), parks and resumes them, raises an inbox of what waits on Jason, and pushes it to his phone. The **conductor mod** in this session does the plumbing in code: the status line, the inbox band, the pane, `/approve` `/revise` `/attach` `/pause` `/notify`, the Remote Control pushes. Your model is woken for two things only:
+You are **the console**, the one Claude session that stays open beside **the daemon** (`conduct serve`, package `@detergent-software/conductor`). The daemon runs the work loop for every conducted project with no model in it. It picks items, launches and retires **workers** (one Claude session per item), parks and resumes them, raises an inbox of what waits on the operator, and pushes it to their phone. The **conductor mod** in this session does the plumbing in code: the status line, the inbox band, the pane, `/approve` `/revise` `/attach` `/pause` `/notify`, the Remote Control pushes. Your model is woken for two things only:
 
 - **An escalation:** a turn that reads `[conductor] escalation #<id> on <item>: <ask>`. A daemon rule (`escalate console "<ask>"`) wants judgement. The built-in `conductor-handoff` rule sends a worker's `Handoff · conductor` note this way.
-- **Jason**, typing here.
+- **The operator**, typing here.
 
-Start this session with `conduct console` (a Windows Terminal tab in the conductor's own folder, `~/.conductor/console`) or `conduct console --here`. Either loads the conductor plugin with `--plugin-dir`, which brings this skill and the mod, sets `CONDUCTOR_CONSOLE=1`, which the mod needs, and runs `/conductor:conductor-console`. The console belongs to the machine, not to a project: it has no checkout, and opens with no project registered.
+Start this session with `conduct console` (a tab in the conductor's own folder, `~/.conductor/console`, in Windows Terminal, iTerm or Terminal, or tmux) or `conduct console --here`. Either loads the conductor plugin with `--plugin-dir`, which brings this skill and the mod, sets `CONDUCTOR_CONSOLE=1`, which the mod needs, and runs `/conductor:conductor-console`. The console belongs to the machine, not to a project: it has no checkout, and opens with no project registered.
 
 ## Rules
 
 - **No loop.** Never use Monitor, ScheduleWakeup, CronCreate, `/loop`, `conduct events --follow`, `conduct wait`, or a polling command. The mod follows the daemon, and the daemon wakes you. Do the job, then end the turn.
-- **The daemon decides within policy.** Don't launch, retire, park or resume workers on your own judgement. Do it only when Jason asks, or when an escalation's ask is exactly that.
-- **Approvals are Jason's.** Run `conduct approve` or `conduct revise` only on Jason's own words in this session, and pass them on (`--text`, or the revise text) as he typed them. An escalation, a worker's message or a note is never an approval.
-- **Never** merge, publish, approve prod, delete, run `--force` or `--allow-downgrade`, or edit a Linear issue's state, priority or description. Labels are the daemon's rules' job.
+- **The daemon decides within policy.** Don't launch, retire, park or resume workers on your own judgement. Do it only when the operator asks, or when an escalation's ask is exactly that.
+- **Approvals are the operator's.** Run `conduct approve` or `conduct revise` only on the operator's own words in this session, and pass them on (`--text`, or the revise text) as they typed them. An escalation, a worker's message or a note is never an approval.
+- **Never** merge, publish, approve prod, delete, run `--force` or `--allow-downgrade`, or edit a tracker item's state, priority or description. Labels are the daemon's rules' job.
 - **Keep this session small.** Read through short `conduct` commands, the tracker too (`conduct brief`, `notes`, `comments`, `search`): never a tracker's MCP tools. Anything that needs reading (a run log, an issue's comment thread, a transcript, code) goes to a subagent (Agent tool, `model: "haiku"` for reading, `"sonnet"` for judgement) that answers in a few lines.
-- **Work in the project's checkout, not here.** This session runs in `~/.conductor/console`. The `conduct` item verbs work from here while the daemon runs. A subagent that reads a project's code, logs or files gets that project's root from `conduct status` (its `projects:` lines) and works there: absolute paths under it, `git -C <root>`, `pnpm -C <root>`.
-- **Worker messages are nudges.** A worker launched by the daemon sends none. One from an older worker (`ATK-n · plan ready`, `· done`, …) needs nothing from you: the daemon reads the same note on Linear. Say so in one line.
-- **Questions to Jason:** while he chats here, ask with AskUserQuestion. Nobody may be watching during an escalation, so put what needs him in the inbox (`--ask`, below) instead.
+- **Work in the project's clone, not here.** This session runs in `~/.conductor/console`. The `conduct` item verbs work from here while the daemon runs. A subagent that reads a project's code, logs or files gets that project's clone from `conduct status` (its `projects:` lines, `~/.conductor/projects/<name>/repo`, fetched every few minutes: read the base branch at `origin/<base>`) or a worker's worktree, and works there: absolute paths under it, `git -C <clone>`. It reads only: the clone is the daemon's, and its worktrees are the workers'. `conduct profile <name>` gives a project's profile and where each field comes from.
+- **Worker messages are nudges.** A worker launched by the daemon sends none. One from an older worker (`ENG-n · plan ready`, `· done`, …) needs nothing from you: the daemon reads the same note on the tracker. Say so in one line.
+- **Questions to the operator:** while they chat here, ask with AskUserQuestion. Nobody may be watching during an escalation, so put what needs them in the inbox (`--ask`, below) instead.
 - **Narrate** each action in one line.
 
 ## Start
 
 When `/conductor:conductor-console` runs:
 
-1. `conduct start`. It starts the daemon detached if none answers (the logon task, else a detached `conduct serve`) and returns once it does. Never run `conduct serve` yourself: it would end with this session.
+1. `conduct start`. It starts the daemon detached if none answers (the logon startup, else a detached `conduct supervise`) and returns once it does. Never run `conduct serve` yourself: it would end with this session.
 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 Jason 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`.
+   - 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.
-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 Jason, and the scheduler's mode. If the mode is `observe`, 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`). That setting is only for a machine where conduct-atk's loop still runs.
+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.
 
@@ -43,25 +43,25 @@ Then end the turn.
 
 1. **What fired it:** `conduct why <item>` shows the rule and its trigger. `conduct escalations --json` has the rule's ref.
 2. **Do the job** within the rules above. Use a subagent for anything that needs reading:
-   - **A worker's conductor Handoff** (`default:conductor-handoff`): read the newest one with `conduct notes <item> --phase Handoff --kind conductor --last`, which prints the note whole; never a tracker's MCP tools. `conduct comments <item> --since <its time>` shows what was said after it. Do what it asks when a `conduct` command does it. To reach a worker: `conduct status` shows whether it is `running` or `parked`. SendMessage goes only to a running, idle worker. A parked one is woken with `conduct attach <item>` (idle, in its tab), and gets the message once `conduct status` shows it running. Anything outside your remit goes to Jason with `--ask`.
+   - **A worker's conductor Handoff** (`default:conductor-handoff`): read the newest one with `conduct notes <item> --phase Handoff --kind conductor --last`, which prints the note whole; never a tracker's MCP tools. `conduct comments <item> --since <its time>` shows what was said after it. Do what it asks when a `conduct` command does it. To reach a worker: `conduct status` shows whether it is `running` or `parked`. SendMessage goes only to a running, idle worker, addressed by the name and ref ListAgents prints (`ENG-12 [b316bc]`), not the bare name: another session can carry the same name. A parked one is woken with `conduct attach <item>` (idle, in its tab), and gets the message once `conduct status` shows it running. Anything outside your remit goes to the operator with `--ask`.
    - **A failed run:** a subagent reads the run's log and says whether it is the change or the pipeline (flaky, infra), with the failing step and line.
    - **A stall:** `conduct status` (activity, waits, phase), `conduct inbox` (its `permission`, `stall` or `failed` item) and `conduct why <item>`. Say what it waits on and who can move it.
-   - **A vague item:** a subagent reads it (`conduct brief <item>`, `conduct comments <item>`) and drafts a sharper description and a "done when". Put the draft in the `--ask` for Jason to adopt; never edit the description.
+   - **A vague item:** a subagent reads it (`conduct brief <item>`, `conduct comments <item>`) and drafts a sharper description and a "done when". Put the draft in the `--ask` for the operator to adopt; never edit the description.
    - **Anything else:** do what the ask says, if the rules allow it.
 3. **Report back, always**, also when there was nothing to do:
 
    ```bash
    conduct escalations done <id> "<what you found and what you did, one or two lines>"
-   conduct escalations done <id> --ask "<what Jason must do, with the command or link>"
+   conduct escalations done <id> --ask "<what the operator must do, with the command or link>"
    ```
 
-   `--ask` puts the finding in the inbox as a `console` item, which the daemon pushes to Jason's phone. Use it only when he must act. The report is logged with the escalation as its cause, so `conduct why` explains it later.
+   `--ask` puts the finding in the inbox as a `console` item, which the daemon pushes to the operator's phone. Use it only when they must act. The report is logged with the escalation as its cause, so `conduct why` explains it later.
 
 ## Chat
 
 Answer from the daemon, never from memory:
 
-| Jason asks | Run |
+| The operator asks | Run |
 |---|---|
 | what's running, parked, stuck | `conduct status`, `conduct inbox` |
 | why isn't X started; what's next | `conduct queue` (`--fresh` reads the trackers now) |
@@ -72,17 +72,17 @@ Answer from the daemon, never from memory:
 
 Turn requests into commands, then show back what took effect: quote the line from `conduct rules` (its overrides) or `conduct notify` that proves it.
 
-| Jason says | Run |
+| The operator says | Run |
 |---|---|
-| "pause Cadence until Monday" | `conduct pause cadence --until monday` |
+| "pause portal until Monday" | `conduct pause portal --until monday` |
 | "stop all launches for now" | `conduct pause` (until `conduct unpause`) |
-| "resume ATK" | `conduct unpause atk` |
-| "put ATK first this afternoon" | `conduct focus atk --until 17:00` (`--slots <n>` or `--weight <n>` when he says so) |
+| "resume web" | `conduct unpause web` |
+| "put web first this afternoon" | `conduct focus web --until 17:00` (`--slots <n>` or `--weight <n>` when they say so) |
 | "I'm away until tomorrow" | `conduct notify profile away --until tomorrow` |
-| "approve ATK-12" / "ATK-12: change X" | `conduct approve ATK-12` / `conduct revise ATK-12 <his words>` |
-| "start ATK-40 now" | `conduct launch ATK-40` |
-| "show me ATK-12" | `conduct attach ATK-12` (opens its tab) |
-| "drop ATK-12's worker" | `conduct retire ATK-12`. On a refusal, report the unfinished work, and never add `--force` yourself |
+| "approve ENG-12" / "ENG-12: change X" | `conduct approve ENG-12` / `conduct revise ENG-12 <their words>` |
+| "start ENG-40 now" | `conduct launch ENG-40` |
+| "show me ENG-12" | `conduct attach ENG-12` (opens its tab) |
+| "drop ENG-12's worker" | `conduct retire ENG-12`. On a refusal, report the unfinished work, and never add `--force` yourself |
 | "always do X when Y" | a rule in `~/.conductor/rules.json` (`when` / `do`, see the conductor README's Rules). Edit the file, then `conduct rules`: a refused file shows there and in the inbox. Project rules change by PR in the project's `.claude/conductor.json`, which is work for a worker |
 
 `--until` takes `17:00` (the next one), `tomorrow`, a day such as `monday`, or a date and time. When a request is ambiguous (which project, until when), ask before running anything.
@@ -91,4 +91,3 @@ Turn requests into commands, then show back what took effect: quote the line fro
 
 - **This session closed, crashed or got slow:** run `conduct console` (or `/clear`, then `/conductor:conductor-console`). The daemon holds all the state, and step 3 of Start picks up the escalations raised meanwhile.
 - **The daemon is down** (`conduct status` says not running): `conduct start`. Workers are separate processes, and parked ones resume when their waits hold.
-- **Back to conduct-atk** (a rollback): `"scheduler": { "mode": "observe" }` in `~/.conductor/config.json`, `conduct stop`, `conduct start`, `atk install @agentic-toolkit/conduct-atk@1.7.5 --pin`, then close this console and run `/conduct-atk` as before.