@warren-dean/code-kit 0.3.15 → 0.5.0

package/hooks/lib/shell.mjs

@@ -0,0 +1,94 @@
+// What a shell command runs, as distinct from the text it carries. Heredoc bodies and quoted strings
+// are data: a commit message, a card's --text, a grep pattern. So rules that recognise a command
+// (`git commit`, `code-kit merge`) look only at the simple commands it runs, each from its own start.
+// Rules about text the command carries (a commit trailer, a path in a redirect) still read it whole.
+
+/** The command with each heredoc's body taken out: the lines after `<<WORD` up to the line `WORD`. */
+export function withoutHeredocs(cmd) {
+  const out = [];
+  let until = null;
+  for (const line of String(cmd).split('\n')) {
+    if (until) {
+      if (line.trim() === until) until = null;
+      continue;
+    }
+    out.push(line);
+    // `<<WORD`, `<<-WORD`, `<<'WORD'` or `<<"WORD"`; not a `<<<` here-string, whose text is on the line.
+    const m = line.match(/(?<!<)<<-?\s*(['"]?)([\w.-]+)\1(?!<)/);
+    if (m && !line.includes('<<<')) until = m[2];
+  }
+  return out.join('\n');
+}
+
+/** `text` with every quoted character replaced by `_`, the quotes kept: same length, nothing inside to match. */
+export function maskQuotes(text) {
+  let out = '';
+  let quote = null;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (quote) {
+      if (c === '\\' && quote === '"' && i + 1 < text.length) {
+        out += '__';
+        i++;
+      } else if (c === quote) {
+        quote = null;
+        out += c;
+      } else out += c === '\n' ? '\n' : '_';
+    } else if (c === '\\' && i + 1 < text.length) {
+      out += '__';
+      i++;
+    } else {
+      if (c === '"' || c === "'") quote = c;
+      out += c;
+    }
+  }
+  return out;
+}
+
+const SEPARATOR = /[;&|\n()`]/;
+const LEADING =
+  /^(?:(?:[A-Za-z_]\w*=(?:"[^"]*"|'[^']*'|\S*)\s+)|(?:sudo|exec|time|command|nohup|env)\s+|!\s+)+/;
+
+/**
+ * The simple commands `cmd` runs, in order: split at `;`, `&`, `|`, newlines, parentheses and
+ * backticks outside quotes, heredoc bodies left out, each without leading `VAR=value` assignments.
+ * Each is `{ text, code }`: `text` as written, `code` with its quoted text masked.
+ */
+export function commandsOf(cmd) {
+  const text = withoutHeredocs(cmd);
+  const mask = maskQuotes(text);
+  const found = [];
+  let start = 0;
+  const take = (end) => {
+    const raw = text.slice(start, end);
+    const lead = raw.length - raw.trimStart().length;
+    const body = raw.trim();
+    const skip = body.match(LEADING)?.[0].length ?? 0;
+    const from = start + lead + skip;
+    const piece = text.slice(from, start + lead + body.length);
+    if (piece) found.push({ text: piece, code: mask.slice(from, from + piece.length) });
+  };
+  for (let i = 0; i < mask.length; i++)
+    if (SEPARATOR.test(mask[i])) {
+      take(i);
+      start = i + 1;
+    }
+  take(mask.length);
+  return found;
+}
+
+/** Whether `cmd` runs a command matching `pattern`, which is anchored at the command's start. */
+export function runs(cmd, pattern, { quoted = true } = {}) {
+  return commandsOf(cmd).some((c) => pattern.test(quoted ? c.text : c.code));
+}
+
+/** The whole command with heredoc bodies out and quoted text masked: for rules that span commands (`curl … | sh`). */
+export function codeOf(cmd) {
+  return maskQuotes(withoutHeredocs(cmd));
+}
+
+/** `git`, with any `-C dir` and `-c key=value` before its subcommand. */
+export const GIT = String.raw`git\s+(?:-[Cc]\s+(?:"[^"]*"|'[^']*'|\S+)\s+)*`;
+
+/** code-kit's command line however it's run: installed, through node (its path quoted or not), or npx. */
+export const CODE_KIT = String.raw`(?:code-kit|node\s+(?:"[^"]*code-kit(?:\.mjs)?"|'[^']*code-kit(?:\.mjs)?'|\S*code-kit(?:\.mjs)?)|npx\s+(?:--yes\s+|-y\s+)?@warren-dean\/code-kit(?:@\S+)?)`;

package/hooks/lib/trace.mjs

@@ -6,7 +6,7 @@ import { execFileSync } from 'node:child_process';
 import { matchesAny } from './glob.mjs';
 import { layerOf } from './layers.mjs';
 import { readRequirements, readStories } from './plan.mjs';
-import { ownerOf } from './rules.mjs';
+import { ownerOf, reviewerOf } from './rules.mjs';
 
 const git = (root, ...args) => {
   try {
@@ -30,7 +30,7 @@ export function storiesOf(root, rel) {
   return [...ids];
 }
 
-/** { path, owner, lane, layer, requirements: [{ id, title, spec, stories }] } for one repository path. */
+/** { path, owner, reviewer, lane, layer, requirements: [{ id, title, spec, stories }] } for one repository path. */
 export function traceFile(root, rel, config) {
   const laneName = Object.keys(config.lanes).find((l) => {
     const { paths, exclude } = config.lanes[l];
@@ -40,6 +40,8 @@ export function traceFile(root, rel, config) {
   const out = {
     path: rel,
     owner: ownerOf(rel, config),
+    // For a file any agent may write: who reviews changes to it.
+    reviewer: reviewerOf(rel, config),
     lane: laneName ? { name: laneName, agent: config.lanes[laneName].agent } : null,
     layer: layer
       ? { name: layer.name, mayImport: layer.mayImport, denyPackages: layer.denyPackages ?? [] }

package/hooks/lib/verify.mjs

@@ -1,7 +1,7 @@
 // The rules for a branch's changes as a whole, for CI and the lead's review: the hooks only see work
 // done in Claude Code sessions, so a person's commits or another tool would otherwise go unchecked.
 // Everything is judged from git (base...HEAD), except the checks, which run in the checkout.
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { BASELINE_FILE, loadBaseline, newProblems } from './baseline.mjs';
@@ -10,7 +10,15 @@ import { CONFIG_FILE } from './config.mjs';
 import { isDependencyFile } from './dependencies.mjs';
 import { matchesAny } from './glob.mjs';
 import { layerProblems } from './layers.mjs';
-import { APPROVAL_LOG, SECRETS, laneOf, ownerOf, protectedEntry, screenProblem } from './rules.mjs';
+import {
+  APPROVAL_LOG,
+  SECRETS,
+  laneOf,
+  ownerOf,
+  owns,
+  protectedEntry,
+  screenProblem,
+} from './rules.mjs';
 
 const git = (root, ...args) =>
   execFileSync('git', ['-C', root, ...args], {
@@ -31,9 +39,30 @@ function showAt(root, ref, rel) {
 /** The lane a branch belongs to by its name (`<lane>/<story>`), or null. */
 export function laneOfBranch(branch, config) {
   const lane = branch?.split('/')[0];
+  if (lane === 'lead') return 'lead';
   return lane && config.lanes[lane] ? lane : null;
 }
 
+/** What verify holds a branch to, in words: a lane's paths, or the lead's. */
+export const heldTo = (lane) => (lane === 'lead' ? "the lead's paths" : `the ${lane} lane`);
+
+/**
+ * Files changed by commits made on the branch itself (first parents, merges left out): on the lead's
+ * branch, what the lead wrote, as distinct from lane work it merged in after review.
+ */
+function directChanges(root, from) {
+  const out = git(
+    root,
+    'log',
+    '--first-parent',
+    '--no-merges',
+    '--format=',
+    '--name-only',
+    `${from}..HEAD`,
+  );
+  return new Set(out.split('\n').filter(Boolean));
+}
+
 /** Files changed on this branch since it left `base`. */
 export function branchChanges(root, base) {
   return git(root, 'diff', '--name-only', '--no-renames', `${base}...HEAD`)
@@ -96,6 +125,33 @@ function signedByPerson(root, from, file, signedBy) {
   return messages.length > 0 && messages.every((m) => line.test(m));
 }
 
+/**
+ * Secrets anywhere in the branch's history, not only in the files as they end up: a secret committed
+ * and then deleted is still in the commits that merge. Names that look like secret files, from every
+ * commit; and, where gitleaks is installed, what it finds in the commits' content.
+ */
+function historySecrets(root, from, changed) {
+  const problems = [];
+  const touched = git(root, 'log', '--format=', '--name-only', `${from}..HEAD`)
+    .split('\n')
+    .filter(Boolean);
+  for (const f of new Set(touched))
+    if (SECRETS(f) && !changed.includes(f))
+      problems.push(
+        `${f} may hold secrets, and it's in this branch's history even though it's gone now. Rewrite the history without it before it merges.`,
+      );
+  const scan = spawnSync(
+    'gitleaks',
+    ['detect', '--source', root, `--log-opts=${from}..HEAD`, '--redact', '--no-banner'],
+    { encoding: 'utf8' },
+  );
+  if (scan.error?.code !== 'ENOENT' && scan.status === 1)
+    problems.push(
+      `gitleaks found possible secrets in this branch's commits:\n${`${scan.stdout}${scan.stderr}`.trim()}`,
+    );
+  return problems;
+}
+
 /**
  * Every problem with the branch, grouped: { ownership, protected, layers, baseline, design, checks }.
  * `lane` holds the branch to that lane's paths; `checks: false` leaves the project's checks to CI's
@@ -110,7 +166,9 @@ export function verifyBranch({ root, base, config, lane = null, checks = true })
   const { entries, problems: logProblems } = logEntries(root, from);
   found.protected.push(...logProblems);
   const logged = new Map(entries.map((e) => [e.file, e]));
+  const direct = lane === 'lead' ? directChanges(root, from) : null;
 
+  found.ownership.push(...historySecrets(root, from, changed));
   for (const f of changed) {
     if (SECRETS(f))
       found.ownership.push(`${f} may hold secrets; secrets never go in the repository.`);
@@ -122,7 +180,20 @@ export function verifyBranch({ root, base, config, lane = null, checks = true })
         `${f} is ${guarded.why}, but no approval-log entry records this change. Protected files are committed through Claude Code with code-kit, which logs them.`,
       );
     if (matchesAny(f, config.anyActor)) continue;
-    if (lane) {
+    if (lane === 'lead') {
+      // The lead's branch is held to the lead's paths for what it changes itself; lane work reaches it
+      // by merging the lane's branch, which verify held to that lane.
+      if (!direct.has(f)) continue;
+      const entry = logged.get(f);
+      const approved =
+        (guarded && entry?.approval === guarded.approval) ||
+        signed ||
+        (isDependencyFile(f) && entry?.approval === 'dependency');
+      if (!owns({ kind: 'lead' }, f, config) && !approved)
+        found.ownership.push(
+          `${f}: changed by a commit on the lead's branch, but the lead doesn't own it (owner: ${ownerOf(f, config) ?? 'nobody'}). Lane work comes in by merging the lane's reviewed branch.`,
+        );
+    } else if (lane) {
       const { paths, exclude } = config.lanes[lane];
       const own = matchesAny(f, paths) && !matchesAny(f, exclude);
       const entry = logged.get(f);

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)),
+  );
+}