@warren-dean/code-kit 0.3.15 → 0.4.1

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
       "name": "code-kit",
       "source": "./",
       "description": "Keeps AI coding agents inside your project's rules, from idea to merged code: spec design, lanes, layer rules, protected paths with an approval log, spec-check and design gates, proof-before-finish checks, dispatch, review, build status and CI verification, configured per project from its docs",
-      "version": "0.3.15",
+      "version": "0.4.1",
       "category": "development",
       "tags": ["guardrails", "architecture", "lanes", "layers", "spec-driven", "ci", "multi-agent"],
       "license": "MIT"

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "code-kit",
-  "version": "0.3.15",
+  "version": "0.4.1",
   "description": "Keeps AI coding agents inside your project's rules, from idea to merged code: spec design, lanes, layer rules, protected paths with an approval log, spec-check and design gates, proof-before-finish checks, dispatch, review, build status and CI verification, configured per project from its docs",
   "author": {
     "name": "Warren Langeveldt"

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 What changed in each release of code-kit, newest first. Versions follow the plugin manifest and the npm package `@warren-dean/code-kit`. Each release is also on [GitHub Releases](https://github.com/warrendeanlangeveldt/code-kit/releases).
 
+## 0.4.1 (2026-10-07)
+
+- **The band keeps other plugins' lines:** code-kit's lines go above whatever else the band holds, such as Context Graph's "N proposals to ratify", instead of replacing it.
+
+## 0.4.0 (2026-10-07)
+
+code-kit in the session: a mod for Claude Code 2.1.287 or later, in the terminal and the Desktop app. Older versions skip it and keep enforcing everything through the hooks, as before. See [In the session](README.md#in-the-session).
+
+- **The band** above the prompt shows what waits for you: approvals agents asked for (**Approve…**, with a reason you keep or rewrite), stories ready for review (**Review**, **Merge**), and a finish check failing. Each has a digit hotkey, and the band is gone when nothing waits.
+- **`/lanes`** opens a pane with each lane's agent, story, branch and state, the agents at work, and what's ready. It stays current within 2 seconds of a change.
+- **Refusal cards:** a code-kit refusal reads as a card with the rule, what to do, and Approve… where an approval would allow it.
+- **`/approvals`** and **`/verify-branch`** print without a model call.
+- **New in the CLI:** `code-kit stops` lists finish checks still failing, and `check --json` reports the config's state for the mod.
+- A merge from the pane says so in its commit.
+- `code-kit` with no command now prints its whole usage.
+
 ## 0.3.15 (2026-10-06)
 
 - **`verify` accepts your Context Graph ratifications:** a change to `.ctx/graph.ctx` whose commits all carry your `Ctx-Ratified-By` trailer passes without an approval-log entry. That's what `ctx ratify --commit` and `ctx drop --commit` write from your terminal, where code-kit's hooks don't run to log it. Agents still can't write that trailer, and a delegated trailer still needs the log.

package/README.md

@@ -101,6 +101,7 @@ Set it up at the start of a new build, straight from the architecture docs, or b
   | `Stop`, `SubagentStop`   | `hooks/stop-check.mjs`      | proof before finishing                                            |
 
 - **For the main session and every subagent**, including agents in worktrees under `.claude/worktrees/`.
+- **In front of you, in the terminal and the Desktop app,** through the code-kit mod (Claude Code 2.1.287 or later; see [In the session](#in-the-session)). It shows and acts, and never enforces: the hooks above do that everywhere, the mod or not.
 - **In CI**, through `code-kit verify` in a GitHub Actions workflow that init can install (`templates/github-workflow.yml`).
 - **Locally, with Node 22 or later.** Nothing is sent anywhere. The CLI in `bin/` runs the same rules from a terminal.
 
@@ -261,6 +262,23 @@ Editing an agent file can't loosen a rule. And the agent files are kit files (`.
 
 **Kept in step.** When the project changes (a new app, a new lane, moved folders), re-run `/code-kit:init`. It drafts new agents for new lanes and updates the paths of existing ones, keeping anything written by hand. You see the difference and approve it before anything changes.
 
+## In the session
+
+With Claude Code 2.1.287 or later, code-kit's mod shows the project in the session, in the terminal (VS Code's terminal included) and the Desktop app. Older versions skip it and keep enforcing everything through the hooks.
+
+- **The band** sits above the prompt whenever something waits for you, and is gone when nothing does. It shows:
+  - approvals agents have asked for: **Approve…** opens a confirmation with a reason prefilled from the request, which you keep or rewrite;
+  - stories finished and waiting for review: **Review** asks the lead to run `/code-kit:review` on the branch, and **Merge** runs `verify`, checks included, then merges if it passes;
+  - a finish check failing in this session: **Lanes** opens the pane.
+
+  Each button has a digit: type it in an empty prompt to press it.
+
+- **`/lanes`** opens the Lanes pane: each lane with its agent, story, branch and state (building, in review, blocked, idle), a mark while its agent is at work, and the stories ready to start. It stays current within 2 seconds of a commit, a branch change, a plan edit or an agent starting or stopping. `/lanes` again, or Escape, closes it.
+- **Refusals** a code-kit hook gives an agent are drawn as cards: what was refused, the rule, what to do, and Approve… where your approval would allow it. The full text is a press away.
+- **`/approvals`** lists the requests waiting and the approvals in force, with minutes left. **`/verify-branch`** runs `code-kit verify` on this branch. Neither calls the model.
+
+Approving from the band records `(approved in the code-kit pane)` with your reason, and a merge from it says it was merged by the person from the pane. Both happen only on your press: the hooks refuse `approve --via pane` and `merge --person` from every agent. Outside a project with `.claude/code-kit.json`, the mod draws nothing. Mods don't draw in the VS Code extension's chat panel, the Agent SDK or `claude -p`.
+
 ## Build
 
 Once init has switched the rules on, the lead runs the build in a loop:
@@ -299,7 +317,7 @@ Lanes never change silently: only when you approve the diff.
 Run from the project root, as `code-kit <command>` once installed (`npm i -g @warren-dean/code-kit`), or `npx @warren-dean/code-kit <command>`. Add `--config .claude/code-kit.draft.json` to any command to read a draft instead. In a session, the `/code-kit:check` skill runs `check` and `unowned` for you. `next` also works in a project without code-kit, or outside a git repository.
 
 ```bash
-code-kit check              # validate and summarise
+code-kit check [--json]     # validate and summarise
 code-kit who <path>...      # owner and layer of each path
 code-kit unowned            # tracked files nobody may write
 code-kit diff --config .claude/code-kit.draft.json  # what a draft changes
@@ -311,6 +329,7 @@ code-kit next [--base ref] [--json]    # the step to take now, from the project'
 code-kit trace <path>... [--json]      # what a file is for: requirements, lane, layer rules
 code-kit merge <branch> --delegated|--person [--into branch]  # merge a branch that passes verify: the lead where approvals.delegate.merge is on, or the person
 code-kit requests [--json]                                   # approval requests the hooks refused, still open, and the approvals in force
+code-kit stops [--session id] [--json]                       # finish checks that refused an agent's last stop and still fail
 code-kit approve <name>... --reason "…" [--lane name] [--delegated | --via pane]  # record a person's approval from chat, or (--delegated) grant one within the delegated rules; a package name stands for its dep- approval
 ```
 

package/bin/code-kit.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // Run from the project root: node "${CLAUDE_PLUGIN_ROOT}/bin/code-kit.mjs" <command>
-//   check                 validate the config and summarise it
+//   check [--json]        validate the config and summarise it
 //   who <path>...         who may write each path, and its layer
 //   unowned               tracked files nobody may write
 //   diff                  what a draft changes against the live config, and whose files move
@@ -18,10 +18,11 @@
 //   merge <branch> --delegated|--person [--into branch]  merge a branch that passes verify: the lead
 //                                    (approvals.delegate.merge) or the person (the code-kit pane)
 //   requests [--json]                 open approval requests and approvals in force
+//   stops [--session id] [--json]     finish checks that refused an agent's last stop, still failing
 //                         record approvals a person gave in chat (with approvals.lead on, the lead runs it)
 // --config <file> reads a draft (.claude/code-kit.draft.json) instead of .claude/code-kit.json.
 import { execFileSync } from 'node:child_process';
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, posix, resolve } from 'node:path';
 import { BASELINE_FILE, loadBaseline } from '../hooks/lib/baseline.mjs';
@@ -71,6 +72,7 @@ const reason = option('--reason');
 const laneName = option('--lane');
 const intoName = option('--into');
 const via = option('--via');
+const sessionId = option('--session');
 const FLAGS = ['--write', '--no-checks', '--json', '--delegated', '--person'];
 const flag = (name) => args.includes(name);
 const writeBaseline = flag('--write');
@@ -92,7 +94,32 @@ function load(path = file) {
   return { raw, config: effectiveConfig(raw, '.') };
 }
 
+/** The config as the mod reads it: whether it's there and valid, and the lead's and lanes' paths. */
+function checkJson() {
+  const report = { file, exists: existsSync(resolve(file)), valid: false, problems: [] };
+  if (!report.exists) return (out(JSON.stringify(report, null, 2)), process.exit(1));
+  let raw;
+  try {
+    raw = JSON.parse(read(file));
+  } catch (e) {
+    report.problems = [e.message];
+    return (out(JSON.stringify(report, null, 2)), process.exit(1));
+  }
+  report.problems = validate(raw);
+  if (report.problems.length) return (out(JSON.stringify(report, null, 2)), process.exit(1));
+  const config = effectiveConfig(raw, '.');
+  report.valid = true;
+  report.lead = { paths: config.lead.paths };
+  report.lanes = Object.fromEntries(
+    Object.entries(config.lanes).map(([name, l]) => [name, { agent: l.agent, paths: l.paths }]),
+  );
+  report.adapters = config.adapters;
+  report.docs = config.docs ?? null;
+  out(JSON.stringify(report, null, 2));
+}
+
 function check() {
+  if (flag('--json')) return checkJson();
   const { raw } = load();
   out(`${file} is valid.`);
   out(`Lead: ${raw.lead.paths.join(', ')}`);
@@ -347,7 +374,7 @@ function merge(branch) {
         '-m',
         `Merge ${branch} into ${into}`,
         '-m',
-        `Verified with code-kit verify (${changed.length} file(s)${lane ? `, held to the ${lane} lane` : ''}) and merged ${byPerson ? 'by the person' : 'by the lead within the delegated rules'}.`,
+        `Verified with code-kit verify (${changed.length} file(s)${lane ? `, held to the ${lane} lane` : ''}) and merged ${byPerson ? 'by the person, from the code-kit pane' : 'by the lead within the delegated rules'}.`,
         branch,
       );
     } catch (e) {
@@ -386,6 +413,33 @@ function requests() {
     );
 }
 
+/** Finish checks still failing: the stop hook's last refusal for each session and agent. */
+function stops() {
+  load();
+  const dir = resolve('.claude/state/stop-blocks');
+  const found = [];
+  for (const name of existsSync(dir) ? readdirSync(dir) : []) {
+    try {
+      const b = JSON.parse(readFileSync(join(dir, name), 'utf8'));
+      if (sessionId && b.session !== sessionId) continue;
+      found.push({
+        session: b.session ?? null,
+        agent: b.agent ?? null,
+        agentType: b.agentType ?? null,
+        title: String(b.message ?? '').split('\n')[0],
+        count: b.count ?? 1,
+        at: b.at ?? null,
+      });
+    } catch {
+      // a file the hook is still writing, or not one of its own
+    }
+  }
+  if (flag('--json')) return out(JSON.stringify(found, null, 2));
+  if (!found.length) return out('No finish check is failing.');
+  for (const s of found)
+    out(`${s.agentType ?? 'the lead'}${s.session ? ` (session ${s.session})` : ''}: ${s.title}`);
+}
+
 function verify() {
   const { config } = load();
   const from = base(config, true);
@@ -616,6 +670,7 @@ const commands = {
   approve: () => (rest.length ? approve(rest) : usage()),
   merge: () => (rest.length === 1 ? merge(rest[0]) : usage()),
   requests,
+  stops,
   trace: () => (rest.length ? trace(rest) : usage()),
   adapters,
   next,
@@ -632,8 +687,9 @@ function usage() {
     'Usage: code-kit check | who <path>... | unowned | diff | baseline [--write] | graph [--depth N]\n' +
       '              | verify [--base ref] [--branch name] [--no-checks] | status [--base ref] [--json]\n' +
       '              | next [--base ref] [--json] | adapters | trace <path>... [--json]\n' +
-      '              | approve <name>... --reason "…" [--lane name]   [--config file]',
-    '              | merge <branch> --delegated|--person [--into branch] | requests [--json]',
+      '              | approve <name>... --reason "…" [--lane name]   [--config file]\n' +
+      '              | merge <branch> --delegated|--person [--into branch] | requests [--json]\n' +
+      '              | stops [--session id] [--json]',
   );
 }
 await (commands[command] ?? usage)();

package/hooks/hooks.json

@@ -1,5 +1,6 @@
 {
   "description": "code-kit: lanes, protected paths with an approval log, spec-check and design gates, layer rules and the project's checks, from .claude/code-kit.json",
+  "modules": ["./mod/register.mjs"],
   "hooks": {
     "PreToolUse": [
       {

package/hooks/mod/register.mjs

@@ -0,0 +1,359 @@
+// The code-kit mod: code-kit in the session, for the person. It draws and acts, but never enforces: the
+// settings hooks beside it enforce the rules, in every session, CI and harness. Claude Code before
+// 2.1.287 doesn't load this module and runs those hooks as before.
+//
+// Everything it shows comes from the code-kit CLI's JSON, run in the session's folder; the mod never
+// imports hooks/lib, which uses node modules a hooks module may not. What it draws is built by the pure
+// functions in view.mjs. It acts only on the person's presses: approving (`approve --via pane`), asking
+// the lead to review, and merging (`merge --person`). No agent reaches those: they are the mod's own
+// buttons, and the hooks refuse both commands from every agent.
+import {
+  APPROVE_ID,
+  NOT_CODE_KIT,
+  PANE_ID,
+  RESULT_ID,
+  approvalsText,
+  agentsAtWork,
+  approvePane,
+  band,
+  bandLines,
+  lanesPane,
+  parseJson,
+  prefilledReason,
+  projectState,
+  refusalCard,
+  refusalView,
+  resultPane,
+} from './view.mjs';
+
+// What the session knows of the project, read again when it changes.
+let model = { state: null, requests: null, stops: [] };
+let reviewing = new Set(); // stories the person asked the lead to review (ACT-3)
+let reviewTurn = null; // 'next' until the lead's review turn starts, then its id
+let approving = null; // the open Approve… confirmation: { request, reason, error }
+let result = null; // what the last merge reported
+let notice = null; // why the person's last act failed
+let act = null; // the session's actions, made at session start
+const refusals = new Map(); // tool_use_id → the refusal text a hook gave (CARD-1)
+const expanded = new Set(); // cards showing their raw text
+const REFUSALS_KEPT = 200;
+
+export function register(on) {
+  on('session.start', async ($, e, next) => {
+    // A name another command already holds is refused; the rest of the mod goes on without it.
+    const unavailable = (name) => (err) =>
+      $.ui.log(`code-kit: /${name} isn't available in this session: ${err?.message ?? err}`);
+    await $.command
+      .register({
+        name: 'lanes',
+        description: "code-kit's lanes: agents, stories, branches and what's ready",
+        immediate: true,
+      })
+      .catch(unavailable('lanes'));
+    await $.command
+      .register({
+        name: 'approvals',
+        description: "code-kit's approval requests waiting, and the approvals in force",
+        immediate: true,
+      })
+      .catch(unavailable('approvals'));
+    await $.command
+      .register({
+        name: 'verify-branch',
+        description: 'Run code-kit verify on this branch, checks included',
+      })
+      .catch(unavailable('verify-branch'));
+    const cli = `${$.plugin.root}/bin/code-kit.mjs`;
+    const cwd = e.cwd ?? (await $.session.cwd());
+    const session = await $.session.id();
+    const json = async (...args) => {
+      const ran = await $.process.run(['node', cli, ...args, '--json'], { cwd });
+      return ran.exitCode === 0 ? parseJson(ran.stdout) : null;
+    };
+    const stamp = async (path) => {
+      const s = await $.fs.stat(`${cwd}/${path}`).catch(() => null);
+      return s ? `${path}@${s.mtimeMs}` : `${path}-`;
+    };
+    const listing = async (path) => {
+      const entries = await $.fs.list(`${cwd}/${path}`).catch(() => []);
+      const stamps = [];
+      for (const entry of entries)
+        stamps.push(
+          entry.kind === 'dir'
+            ? await listing(`${path}/${entry.name}`)
+            : await stamp(`${path}/${entry.name}`),
+        );
+      return stamps.join(',');
+    };
+
+    act = {
+      // Everything the band and the pane show, read again.
+      reload: async () => {
+        const ran = await $.process.run(['node', cli, 'check', '--json'], { cwd });
+        const check = parseJson(ran.stdout);
+        const valid = Boolean(check?.valid);
+        const status = valid ? await json('status') : null;
+        const nextStep = valid ? await json('next') : null;
+        const requests = valid ? await json('requests') : null;
+        const stops = valid ? ((await json('stops', '--session', session)) ?? []) : [];
+        const atWork = agentsAtWork(await $.agent.list());
+        model = {
+          state: projectState(check, status, nextStep, atWork),
+          requests,
+          stops,
+          check,
+          base: status?.base ?? null,
+        };
+        $.ui.invalidate('ui.render');
+      },
+      // What a refresh waits on, read cheaply: branches and HEAD, the config and the plan, requests,
+      // approvals and finish checks, and the agents at work. Only a change runs the CLI.
+      fingerprint: async () => {
+        const refs = await $.process.run(
+          ['git', 'for-each-ref', '--format=%(HEAD)%(objectname) %(refname)', 'refs/heads'],
+          { cwd },
+        );
+        const plan = model.check?.docs?.plan;
+        return [
+          refs.stdout,
+          await stamp('.claude/code-kit.json'),
+          plan ? await stamp(plan) : '',
+          await stamp('.claude/state/requests.jsonl'),
+          await listing('.claude/approvals'),
+          await listing('.claude/state/stop-blocks'),
+          [...agentsAtWork(await $.agent.list())].sort().join(','),
+        ].join('\n');
+      },
+      // PANE-1: open the Lanes pane, or close it when it's open.
+      lanes: async () => {
+        // Asked, not remembered: the person may have closed it with Escape.
+        if ((await $.ui.panes()).some((p) => p.id === PANE_ID)) {
+          await $.ui.close({ id: PANE_ID });
+          return {};
+        }
+        await act.reload();
+        if (model.state.kind === 'none') return { text: NOT_CODE_KIT };
+        const placed = await $.ui.open({
+          id: PANE_ID,
+          title: 'Lanes',
+          focus: true,
+          closeOnEscape: true,
+        });
+        // Opened but not drawn yet: it waits for room, and the reason says what seats it.
+        if (!placed.isPlaced) return { text: `The Lanes pane is waiting: ${placed.reason}` };
+        return {};
+      },
+      // ACT-1: the confirmation, prefilled from the request.
+      approve: async (line) => {
+        approving = { request: line.request, reason: prefilledReason(line.request), error: null };
+        await $.ui.open({ id: APPROVE_ID, title: 'Approve', focus: true, closeOnEscape: true });
+        $.ui.invalidate('ui.render');
+      },
+      confirmApproval: async (reason) => {
+        if (!approving) return;
+        if (!reason.trim()) {
+          approving = { ...approving, error: 'Give a reason: it goes in the approval log.' };
+          $.ui.invalidate('ui.render');
+          return;
+        }
+        const { request } = approving;
+        const ran = await $.process.run(
+          [
+            'node',
+            cli,
+            'approve',
+            ...request.names,
+            ...(request.lane ? ['--lane', request.lane] : []),
+            '--reason',
+            reason.trim(),
+            '--via',
+            'pane',
+          ],
+          { cwd },
+        );
+        if (ran.exitCode !== 0) {
+          const why = (ran.stderr || ran.stdout).trim().split('\n')[0];
+          notice = `Nothing was approved: ${why}`;
+          approving = { ...approving, error: notice };
+          $.ui.invalidate('ui.render');
+          return;
+        }
+        approving = null;
+        notice = null;
+        await $.ui.close({ id: APPROVE_ID });
+        await act.reload();
+      },
+      cancelApproval: async () => {
+        approving = null;
+        await $.ui.close({ id: APPROVE_ID });
+      },
+      // ACT-3: ask the lead, and show the story as being reviewed until its turn ends.
+      review: async (line) => {
+        reviewing.add(line.story.id);
+        reviewTurn = 'next';
+        $.ui.invalidate('ui.render');
+        await $.prompt.submit({
+          text: `Review ${line.story.id} (${line.story.title}): run /code-kit:review ${line.story.branch}.`,
+        });
+      },
+      // ACT-4: confirm, then verify and merge as the person; nothing merges unless verify passes.
+      merge: async (line) => {
+        const { branch } = line.story;
+        const into = model.base ?? 'the base branch';
+        const answer = await $.ui
+          .ask(
+            `Merge ${branch} into ${into}? code-kit verify runs first, checks included, and nothing merges unless it passes.`,
+            ['Merge', 'Cancel'],
+          )
+          .catch(() => 'Cancel');
+        if (answer !== 'Merge') return;
+        const ran = await $.process.run(['node', cli, 'merge', branch, '--person'], {
+          cwd,
+          timeoutMs: 600000,
+        });
+        result = {
+          ok: ran.exitCode === 0,
+          title: ran.exitCode === 0 ? `Merged ${branch}` : `Nothing merged: ${branch}`,
+          text: `${ran.stdout}${ran.stderr}`.trim(),
+        };
+        await $.ui.open({ id: RESULT_ID, title: 'Merge', focus: true, closeOnEscape: true });
+        await act.reload();
+      },
+      // CARD-2: no model call; the transcript shows it.
+      approvals: async () => {
+        await act.reload();
+        if (model.state.kind === 'none') return { text: NOT_CODE_KIT };
+        return { text: approvalsText(model.requests) };
+      },
+      // CARD-3: verify's own report, checks included.
+      verify: async () => {
+        if (model.state?.kind === 'none') return { text: NOT_CODE_KIT };
+        const ran = await $.process.run(['node', cli, 'verify'], { cwd, timeoutMs: 600000 });
+        return { text: `${ran.stdout}${ran.stderr}`.trim() };
+      },
+      dismiss: async () => {
+        notice = null;
+        $.ui.invalidate('ui.render');
+      },
+    };
+
+    // PANE-4 and BAND-3: within 2 seconds of a change. With nothing changed, the project is read
+    // again every 10 seconds while the pane is open, and every minute otherwise (approvals expire).
+    let seen = null;
+    let quiet = 0;
+    let busy = false;
+    $.clock.every(2000, async () => {
+      if (busy) return;
+      busy = true;
+      try {
+        const now = await act.fingerprint();
+        const paneOpen = (await $.ui.panes()).some((p) => p.id === PANE_ID);
+        quiet += 1;
+        if (now === seen && quiet < (paneOpen ? 5 : 30)) return;
+        quiet = 0;
+        await act.reload();
+        // Taken again: what it covers (the plan) can change with what was read.
+        seen = await act.fingerprint();
+      } finally {
+        busy = false;
+      }
+    });
+    return next(e);
+  });
+
+  const starting = (name) => ({
+    text: `code-kit is still starting; try /${name} again in a moment.`,
+  });
+  on('command.run', { command: 'lanes' }, async ($, e) => (act ? act.lanes() : starting('lanes')));
+  on('command.run', { command: 'approvals' }, async ($, e) =>
+    act ? act.approvals() : starting('approvals'),
+  );
+  on('command.run', { command: 'verify-branch' }, async ($, e) =>
+    act ? act.verify() : starting('verify-branch'),
+  );
+
+  // CARD-1: the text a code-kit hook refused a call with, kept for the call's result to draw as a card.
+  on('tool.call', async ($, e, next) => {
+    const res = await next(e);
+    const text = res?.deny ?? (res?.isError ? (res.text ?? String(res.result ?? '')) : null);
+    if (text && refusalCard(text)) {
+      refusals.set(e.tool_use_id, text);
+      if (refusals.size > REFUSALS_KEPT) refusals.delete(refusals.keys().next().value);
+    }
+    return res;
+  }).catch(($, e, next) => next(e)); // it only watches: whatever fails here, the call goes on as it would
+  // A refused call's text: kept from its tool.call, or the output its row carries (what the model read).
+  const refusalOf = (id, output) =>
+    refusalCard(refusals.get(id) ?? (typeof output === 'string' ? output : null));
+  // Shell calls fold into one line ("Ran 1 shell command"); a group holding a refusal unfolds, so
+  // the refused call's row can be drawn as its card.
+  on('ui.render', { component: 'ToolGroup' }, async ($, e, next) => {
+    const refused = e.props.calls.some((c) => c.tool_use_id && refusalOf(c.tool_use_id, c.output));
+    return refused && !e.props.isExpanded
+      ? next({ ...e, props: { ...e.props, isExpanded: true } })
+      : next(e);
+  });
+  // The card takes the call's row; the result block beneath a standalone row is then left empty.
+  on('ui.render', { component: 'ToolResult' }, async ($, e, next) => {
+    const card = refusalOf(e.props.tool_use_id, e.props.output);
+    if (!card || !act) return next(e);
+    return $.ui.resolve(e).Box({ children: [] });
+  });
+  on('ui.render', { component: 'ToolUse' }, async ($, e, next) => {
+    const id = e.props.tool_use_id;
+    const card = refusalOf(id, e.props.output);
+    if (!card || !act) return next(e);
+    return refusalView(card, expanded.has(id), $.ui.resolve(e), {
+      onApprove: () => act.approve({ request: card.request }),
+      onToggle: () => {
+        if (expanded.has(id)) expanded.delete(id);
+        else expanded.add(id);
+        $.ui.invalidate('ui.render');
+      },
+    });
+  });
+
+  on('turn.start', async ($, e, next) => {
+    if (reviewTurn === 'next') reviewTurn = e.turnId;
+    return next(e);
+  });
+  // The lead has reported on the review it was asked for.
+  on('turn.complete', async ($, e, next) => {
+    if (reviewTurn && reviewTurn === e.turnId) {
+      reviewing = new Set();
+      reviewTurn = null;
+      $.ui.invalidate('ui.render');
+    }
+    return next(e);
+  });
+
+  on('ui.render', { component: 'Pane', requestId: PANE_ID }, async ($, e) =>
+    lanesPane(model.state, $.ui.resolve(e)),
+  );
+
+  // BAND-2: absent when nothing waits. Its lines go above whatever else the band holds (another
+  // plugin's lines, such as Context Graph's, or Claude Code's own), which it keeps.
+  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
+    const lines = bandLines({ ...model, reviewing, notice });
+    if (!lines.length || !act) return next(e);
+    const ours = band(lines, $.ui.resolve(e), (id, line) => act[id](line));
+    const below = await next(e);
+    return below ? $.ui.resolve(e).Box({ flexDirection: 'column', children: [ours, below] }) : ours;
+  });
+
+  on('ui.render', { component: 'Pane', requestId: APPROVE_ID }, async ($, e) => {
+    if (!approving) return resultPane(null, $.ui.resolve(e));
+    return approvePane(approving, $.ui.resolve(e), {
+      onInput: (value) => {
+        approving = { ...approving, reason: value };
+        $.ui.invalidate('ui.render');
+      },
+      onSubmit: (value) => act.confirmApproval(value),
+      onCancel: () => act.cancelApproval(),
+    });
+  });
+
+  on('ui.render', { component: 'Pane', requestId: RESULT_ID }, async ($, e) =>
+    resultPane(result, $.ui.resolve(e)),
+  );
+}