@warren-dean/code-kit 0.11.1 → 0.12.1

package/hooks/mod/register.test.ts

@@ -157,6 +157,11 @@ function project() {
     journal: { events: [] as any[] }, // `code-kit journal --json`
     team: null as any, // `code-kit team --json`, for a team's project
     teamSince: { people: {} } as any, // `code-kit team since --json`
+    questions: [] as any[], // `code-kit ask --json`
+    reports: [] as any[], // `code-kit report --json`
+    fills: [] as string[], // what the mod put in the prompt
+    sideAsks: [] as any[], // side calls: { fork } or { model }, with their prompt
+    sideReply: { isAnswered: true, text: 'dayjs formats the booking dates.', usage: null } as any,
     holdWaits: false, // false: the hold ends at once, as if timed out (tests about cards, not hold)
     waiting: new Map<string, (answer: string) => void>(),
   };
@@ -186,7 +191,30 @@ function stub(on: any, w: World) {
         }),
       );
     if (sub === 'next') return ran(0, JSON.stringify(w.next));
+    if (sub === 'requests' && argv[3] === 'drop') {
+      w.acts.push([...argv.slice(2)]);
+      const drop = new Set(argv[4].split(',').map(Number));
+      w.requests = w.requests.filter((_, i) => !drop.has(i + 1));
+      return ran(0, 'Dropped.');
+    }
     if (sub === 'requests') return ran(0, JSON.stringify({ open: w.requests, inForce: w.inForce }));
+    if (sub === 'ask' && argv[3] === 'answer') {
+      w.acts.push([...argv.slice(2)]);
+      w.questions = w.questions.map((q) => (q.id === argv[4] ? { ...q, state: 'answered' } : q));
+      return ran(0, 'Recorded.');
+    }
+    if (sub === 'ask') return ran(0, JSON.stringify(w.questions));
+    if (sub === 'report' && ['send', 'discard'].includes(argv[3])) {
+      w.acts.push([...argv.slice(2)]);
+      w.reports = w.reports.map((r) =>
+        r.id === argv[4] ? { ...r, state: argv[3] === 'send' ? 'sent' : 'discarded' } : r,
+      );
+      return ran(
+        0,
+        argv[3] === 'send' ? 'Filed https://github.com/o/code-kit/issues/9' : 'Discarded.',
+      );
+    }
+    if (sub === 'report') return ran(0, JSON.stringify(w.reports));
     if (sub === 'verify')
       return ran(w.verifyExit, w.verifyExit ? '' : w.verifyOut, w.verifyExit ? w.verifyOut : '');
     if (sub === 'stops') return ran(0, JSON.stringify(w.stops));
@@ -321,6 +349,21 @@ function stub(on: any, w: World) {
     return { value: { agent: `code-kit:${e.name}` } };
   });
   on('prompt.read', () => ({ value: { text: w.draft, cursor: w.draft.length } }));
+  on('model.fork', ($: any, e: any) => {
+    w.sideAsks.push({ fork: true, prompt: e.prompt });
+    return { value: w.sideReply };
+  });
+  on('model.complete', ($: any, e: any) => {
+    w.sideAsks.push({ model: e.model, prompt: e.prompt });
+    return { value: { isAnswered: true, text: 'From the facts alone.', usage: null } };
+  });
+  // Claude Code's own settings hooks beneath: none answer a permission denial.
+  on('classic.PermissionDenied', () => ({}));
+  on('prompt.fill', ($: any, e: any) => {
+    w.fills.push(e.text);
+    w.draft = e.text;
+    return { isFilled: true };
+  });
   on('session.send', ($: any, e: any) => {
     w.sent.push({ to: e.to, text: e.text });
     return { isDelivered: true };
@@ -513,10 +556,10 @@ test('PANE-4 with nothing changed it reads the project every 10 seconds while th
   const before = w.runs;
   await clock.advance(8000); // four quiet ticks: git only
   expect(w.runs - before).toBe(4);
-  // The fifth reads it all (check, status, next, requests, stops, queue, timeline) between two looks
-  // at git.
+  // The fifth reads it all (check, status, next, requests, stops, queue, timeline, the lead's questions
+  // and the reports waiting) between two looks at git.
   await clock.advance(2000);
-  expect(w.runs - before).toBe(13);
+  expect(w.runs - before).toBe(15);
 });
 
 test('CARD-4 outside a code-kit project, /lanes says so, opens nothing, and there is no band', async ($, on) => {
@@ -611,6 +654,56 @@ test('ACT-1 the person may type their own reason, and an empty one is not accept
   await ui.unmount();
 });
 
+test("ACT-5 the person asks about an approval in its pane; the answer stays there, out of the lead's conversation", async ($, on) => {
+  const w = project();
+  w.requests = [dayjs];
+  await start($, on, w);
+  const ui = await bandUi($);
+  await press($, 'band-approve');
+  const confirm = await pane($, APPROVE);
+  await $.ui.input({
+    plugin: 'code-kit',
+    key: 'approve-ask',
+    text: 'Why does the booking form need this?',
+  });
+  expect(w.sideAsks).toHaveLength(1);
+  expect(w.sideAsks[0].fork).toBe(true);
+  expect(w.sideAsks[0].prompt).toMatch(/approvals asked for: dep-dayjs/);
+  expect(w.sideAsks[0].prompt).toMatch(/for: the web lane/);
+  expect(w.sideAsks[0].prompt).toMatch(/story: ST-4 Booking form/);
+  expect(w.sideAsks[0].prompt).toMatch(/Question: Why does the booking form need this\?$/);
+  expect(
+    await confirm.find({ type: 'Text', text: 'You: Why does the booking form need this?' }),
+  ).toBeDefined();
+  expect(JSON.stringify(await confirm.find({ key: 'aside-a-0' }))).toMatch(
+    /dayjs formats the booking dates/,
+  );
+  // A follow-up carries the aside so far; nothing went to the lead, and nothing was approved.
+  await $.ui.input({ plugin: 'code-kit', key: 'approve-ask', text: 'Is it maintained?' });
+  expect(w.sideAsks[1].prompt).toMatch(
+    /Q: Why does the booking form need this\?\nA: dayjs formats the booking dates\./,
+  );
+  expect(w.prompts).toEqual([]);
+  expect(w.acts).toEqual([]);
+  await confirm.unmount();
+  await ui.unmount();
+});
+
+test('ACT-5 before the lead has replied there is nothing to fork: it answers from the facts alone', async ($, on) => {
+  const w = project();
+  w.requests = [dayjs];
+  w.sideReply = { isAnswered: false, reason: 'nothing-to-fork' };
+  await start($, on, w);
+  const ui = await bandUi($);
+  await press($, 'band-approve');
+  const confirm = await pane($, APPROVE);
+  await $.ui.input({ plugin: 'code-kit', key: 'approve-ask', text: 'What is it?' });
+  expect(w.sideAsks.map((a) => a.model ?? 'fork')).toEqual(['fork', 'sonnet']);
+  expect(JSON.stringify(await confirm.find({ key: 'aside-a-0' }))).toMatch(/From the facts alone/);
+  await confirm.unmount();
+  await ui.unmount();
+});
+
 test('ACT-1 cancelling writes nothing', async ($, on) => {
   const w = project();
   w.requests = [dayjs];
@@ -1311,6 +1404,254 @@ test('DECIDE-3 notes are labelled note, not you, and need no decision', async ($
   await band.unmount();
 });
 
+const question = (extra: any = {}) => ({
+  id: 'Q-1',
+  at: '2026-10-12T05:59:00.000Z',
+  by: 'lead',
+  question: 'Which weather provider: the Bureau of Meteorology or a commercial service?',
+  why: null,
+  story: 'ST-4',
+  blocks: true,
+  options: [
+    { label: 'Bureau of Meteorology', effect: 'Free, Australian data; we credit the Bureau.' },
+    { label: 'Commercial', effect: 'A paid key; global coverage.' },
+  ],
+  state: 'open',
+  answer: null,
+  withdrawn: null,
+  ...extra,
+});
+
+test("ASK-2 the lead's question waits in the band and as a card; an option answers it and tells the lead", async ($, on) => {
+  const w = project();
+  w.questions = [
+    question(),
+    question({
+      id: 'Q-2',
+      question: 'May sessions show your city?',
+      story: null,
+      blocks: false,
+      options: [],
+    }),
+  ];
+  await start($, on, w);
+  const band = await bandUi($);
+  expect(
+    await band.find({ type: 'Text', text: /^2 questions from the lead: Which weather provider/ }),
+  ).toBeDefined();
+  await press($, 'band-openDecision');
+  await band.unmount();
+  const ui = await pane($, PANE);
+  // One card per question, not one for both.
+  expect(await ui.find({ key: 'decision-pick-0' })).toBeDefined();
+  expect(await ui.find({ key: 'decision-pick-1' })).toBeDefined();
+  expect(await ui.find({ type: 'Text', text: 'ST-4 waits on your answer.' })).toBeDefined();
+  expect(
+    await ui.find({ type: 'Text', text: 'Free, Australian data; we credit the Bureau.' }),
+  ).toBeDefined();
+  await press($, 'decide-answerWith-0', PANE);
+  expect(w.acts).toContainEqual(['ask', 'answer', 'Q-1', 'Bureau of Meteorology', '--via', 'pane']);
+  expect(w.prompts.at(-1)).toBe(
+    'The person answered Q-1 (Which weather provider: the Bureau of Meteorology or a commercial service?): Bureau of Meteorology. ST-4 no longer waits on them. Carry on with it.',
+  );
+  await ui.unmount();
+});
+
+test("ASK-2 a question with no options, or Something else…, is answered in the person's own words", async ($, on) => {
+  const w = project();
+  w.questions = [
+    question({
+      id: 'Q-2',
+      question: 'May sessions show your city?',
+      story: null,
+      blocks: false,
+      options: [],
+    }),
+  ];
+  await start($, on, w);
+  const band = await bandUi($);
+  await press($, 'band-openDecision');
+  await band.unmount();
+  const ui = await pane($, PANE);
+  await press($, 'decide-answer', PANE);
+  expect(w.opened).toContain('code-kit-answer');
+  const box = await pane($, 'code-kit-answer');
+  await $.ui.input({ plugin: 'code-kit', key: 'answer-text', text: '' });
+  expect(
+    await box.find({ type: 'Text', text: 'Type your answer: the lead builds on it.' }),
+  ).toBeDefined();
+  await $.ui.input({
+    plugin: 'code-kit',
+    key: 'answer-text',
+    text: 'Only the suburb, never the street',
+  });
+  expect(w.acts).toContainEqual([
+    'ask',
+    'answer',
+    'Q-2',
+    'Only the suburb, never the street',
+    '--via',
+    'pane',
+  ]);
+  expect(w.prompts.at(-1)).toBe(
+    'The person answered Q-2 (May sessions show your city?): Only the suburb, never the street. Carry on with it.',
+  );
+  expect(w.closed).toContain('code-kit-answer');
+  await box.unmount();
+  await ui.unmount();
+});
+
+test("ASK-4 the brief's open questions are the person's decisions: answered to the lead, or put off for the session", async ($, on) => {
+  const w = project();
+  w.next = {
+    ...w.next,
+    brief: [
+      { question: 'Accounts: AWS, Supabase, Fly', path: 'docs/brief.md' },
+      { question: 'The product domain', path: 'docs/brief.md' },
+    ],
+  };
+  await start($, on, w);
+  const band = await bandUi($);
+  expect(
+    await band.find({
+      type: 'Text',
+      text: '2 open questions in your brief: Accounts: AWS, Supabase, Fly',
+    }),
+  ).toBeDefined();
+  await press($, 'band-openDecision');
+  await band.unmount();
+  const ui = await pane($, PANE);
+  expect(
+    await ui.find({ type: 'Text', text: 'From your brief: Accounts: AWS, Supabase, Fly' }),
+  ).toBeDefined();
+  await press($, 'decide-laterBrief', PANE);
+  expect(
+    await ui.find({ type: 'Text', text: 'From your brief: The product domain' }),
+  ).toBeDefined();
+  await press($, 'decide-answerBrief', PANE);
+  const box = await pane($, 'code-kit-answer');
+  await $.ui.input({ plugin: 'code-kit', key: 'answer-text', text: 'myaila.com.au' });
+  await box.unmount();
+  expect(w.prompts.at(-1)).toBe(
+    'The person answered an open question in docs/brief.md, "The product domain": myaila.com.au. Record it in the brief\'s decision log, take it out of the open questions, and carry on with it.',
+  );
+  await ui.unmount();
+  const after = await bandUi($);
+  expect(await after.find({ type: 'Text', text: /in your brief/ })).toBeUndefined();
+  await after.unmount();
+});
+
+test("PERM-1 a call Claude Code's own permission check refused waits for the person, who runs it or says not now", async ($, on) => {
+  const w = project();
+  await start($, on, w);
+  await $.classic.PermissionDenied({
+    tool_name: 'Bash',
+    tool_input: { command: 'pnpm db:generate && pnpm db:migrate' },
+    tool_use_id: 'tu-1',
+    reason: 'Permission for this action was denied by the Claude Code auto mode classifier.',
+  });
+  const band = await bandUi($);
+  expect(
+    await band.find({ type: 'Text', text: "Claude Code refused the lead's `pnpm db:generate`" }),
+  ).toBeDefined();
+  await press($, 'band-runDenied');
+  expect(w.fills).toEqual(['! pnpm db:generate && pnpm db:migrate']);
+  await press($, 'band-decide');
+  await band.unmount();
+  const ui = await pane($, PANE);
+  expect(
+    await ui.find({
+      type: 'Text',
+      text: /^Claude Code's own permission check refused it \(Permission for this action/,
+    }),
+  ).toBeDefined();
+  await press($, 'decide-deniedDone', PANE);
+  expect(w.prompts.at(-1)).toMatch(
+    /^The person ran it themselves, or allowed it: pnpm db:generate && pnpm db:migrate/,
+  );
+  await ui.unmount();
+  const after = await bandUi($);
+  expect(await after.find({ type: 'Text', text: /Claude Code refused/ })).toBeUndefined();
+  await after.unmount();
+});
+
+test('CARD-8 two approvals waiting are two decisions, each approved or dropped on its own', async ($, on) => {
+  const w = project();
+  w.requests = [
+    dayjs,
+    {
+      ...dayjs,
+      at: '2026-10-06T00:05:00.000Z',
+      actor: 'api-engineer',
+      lane: 'api',
+      names: ['dep-zod'],
+      what: 'npm install zod',
+    },
+  ];
+  await start($, on, w);
+  const band = await bandUi($);
+  expect(await band.find({ type: 'Text', text: '2 approvals waiting' })).toBeDefined();
+  await press($, 'band-decide');
+  await band.unmount();
+  const ui = await pane($, PANE);
+  expect(await ui.find({ key: 'decision-pick-0' })).toBeDefined();
+  expect(await ui.find({ key: 'decision-pick-1' })).toBeDefined();
+  await press($, 'decision-pick-1', PANE);
+  await press($, 'decide-dropRequest', PANE);
+  expect(w.acts).toContainEqual(['requests', 'drop', '2', '--via', 'pane']);
+  await ui.unmount();
+});
+
+test('REPORT-3 a bug report an agent drafted waits for the person, who reads it and sends it, or discards it', async ($, on) => {
+  const w = project();
+  w.reports = [
+    {
+      id: 'R-1',
+      at: '2026-10-13T00:00:00Z',
+      by: 'lead',
+      title: 'Decisions tab misses a held call',
+      fingerprint: 'ck-1',
+      body: '**What happened:** the card never showed',
+      state: 'draft',
+      sent: null,
+    },
+  ];
+  await start($, on, w);
+  const band = await bandUi($);
+  expect(
+    await band.find({
+      type: 'Text',
+      text: 'A bug report for code-kit to send: Decisions tab misses a held call',
+    }),
+  ).toBeDefined();
+  await press($, 'band-openDecision');
+  await band.unmount();
+  const ui = await pane($, PANE);
+  expect(
+    await ui.find({ type: 'Text', text: '**What happened:** the card never showed' }),
+  ).toBeDefined();
+  await press($, 'decide-sendReport', PANE);
+  expect(w.acts).toContainEqual(['report', 'send', 'R-1']);
+  expect(w.opened).toContain('code-kit-result');
+  await ui.unmount();
+});
+
+test('ASK-3 a lane whose story waits on the person reads waiting on you', async ($, on) => {
+  const w = project();
+  w.stories = w.stories.map((s: any) =>
+    s.id === 'ST-4'
+      ? { ...s, state: 'waiting on you', waitingFor: { id: 'Q-1', question: 'x' } }
+      : s,
+  );
+  await start($, on, w);
+  await lanes($);
+  const ui = await pane($, PANE);
+  expect((await ui.findAll({ type: 'Text' })).some((t: any) => /waiting on you/.test(t.text))).toBe(
+    true,
+  );
+  await ui.unmount();
+});
+
 test('JOURNAL-1 the Journal tab tells the lineage, from the request to now, with the loop and your choices in it', async ($, on) => {
   const w = project();
   w.journal = {

package/hooks/mod/view.mjs

@@ -39,6 +39,7 @@ export function readyFrom(next) {
  *   building   a branch for the story and, if it has commits, the lane's agent still at work on it;
  *   in review  commits on the branch (status's `review`) and the agent no longer at work;
  *   sent back  a review sent the branch back, and the lane hasn't committed its fix yet;
+ *   waiting on you  the lane's story waits on the person's answer (ASK-3);
  *   blocked    the lane's next story waits on another;
  *   idle       none of these.
  * `status` can't tell a finished branch from one still being built, so the agent at work decides.
@@ -46,7 +47,11 @@ export function readyFrom(next) {
 function laneRow(name, agent, stories, atWork) {
   const own = stories.filter((s) => s.lane === name);
   const active = Boolean(agent && atWork.has(agent));
-  const story = own.find((s) => ['in progress', 'review', 'sent back'].includes(s.state));
+  const story = own.find((s) =>
+    ['in progress', 'review', 'sent back', 'waiting on you'].includes(s.state),
+  );
+  if (story?.state === 'waiting on you')
+    return { name, agent, active, story, branch: story.branch, state: 'waiting on you' };
   if (story?.state === 'sent back')
     return { name, agent, active, story, branch: story.branch, state: 'sent back' };
   if (story) {
@@ -107,6 +112,7 @@ export const STATE_COLOR = {
   orchestrating: 'yellow',
   'in review': 'yellow',
   'sent back': 'magenta',
+  'waiting on you': 'cyan',
   blocked: 'red',
   idle: undefined,
 };
@@ -357,6 +363,7 @@ const CARD_STATE = {
   review: { label: 'in review', color: 'yellow' },
   'in progress': { label: 'building', color: 'blue' },
   'sent back': { label: 'sent back', color: 'magenta' },
+  'waiting on you': { label: 'waiting on you', color: 'cyan' },
   blocked: { label: 'blocked', color: 'red' },
   ready: { label: 'ready', color: 'green' },
   todo: { label: 'to do', color: 'gray' },
@@ -715,6 +722,10 @@ export function bandLines({
   nextStep = null,
   combined = null,
   team = null,
+  questions = [],
+  brief = [],
+  denied = [],
+  reports = [],
 }) {
   const lines = [];
   // MISSION-1: the goal, now, next and the agents at work, above what needs the person.
@@ -725,18 +736,39 @@ export function bandLines({
   if (!state || state.kind !== 'ok') return lines;
   // HOLD-2: calls held for the person, oldest first, with the time left on the oldest.
   if (held.length) {
-    const [call] = [...held].sort((a, b) => a.since - b.since);
+    const calls = [...held].sort((a, b) => a.since - b.since);
+    const [call] = calls;
     const left = timeLeft(call.since + call.minutes * 60000 - now);
     lines.push({
       kind: 'held',
       text: `${held.length > 1 ? `${held.length} calls held: ` : ''}${call.who} wants to ${heldVerb(call)} · ${left}`,
       held: call,
+      // CARD-8: each held call is its own decision in the Decisions tab.
+      calls: calls.map((c) => ({
+        held: c,
+        text: `${c.who} wants to ${heldVerb(c)} · ${timeLeft(c.since + c.minutes * 60000 - now)}`,
+      })),
       actions: [
         { id: 'approveHeld', label: 'Approve' },
         { id: 'refuseHeld', label: 'Refuse' },
       ],
     });
   }
+  // PERM-1: Claude Code's own permission check refused a call only the person can let through.
+  if (denied.length) {
+    const [d] = denied;
+    lines.push({
+      kind: 'denied',
+      text: `${denied.length > 1 ? `${denied.length} calls refused by Claude Code: ` : 'Claude Code refused '}${d.who}'s ${d.what}`,
+      denial: d,
+      denials: denied,
+      actions: [
+        ...(d.command ? [{ id: 'runDenied', label: 'Put it in the prompt' }] : []),
+        { id: 'deniedDone', label: 'Done it' },
+        { id: 'deniedNo', label: 'Not now' },
+      ],
+    });
+  }
   // LOOP-3: a lane stalled past its restarts waits for the person.
   for (const f of loop?.flagged ?? [])
     lines.push({
@@ -778,8 +810,28 @@ export function bandLines({
       text: `${plural(asks.length, 'approval', 'approvals')} waiting`,
       request: asks[0].request,
       files: asks[0].files,
+      // CARD-8: each approval is its own decision in the Decisions tab.
+      asks,
       actions: [{ id: 'approve', label: 'Approve…' }],
     });
+  // ASK-2: what the lead asked the person and couldn't settle itself.
+  if (questions.length)
+    lines.push({
+      kind: 'question',
+      text: `${questions.length > 1 ? `${questions.length} questions from the lead: ` : 'The lead asks: '}${questions[0].question}`,
+      question: questions[0],
+      questions,
+      actions: [{ id: 'openDecision', label: 'Answer…' }],
+    });
+  // ASK-4: the brief's open questions, the person's to answer.
+  if (brief.length)
+    lines.push({
+      kind: 'brief',
+      text: `${plural(brief.length, 'open question', 'open questions')} in your brief: ${brief[0].question}`,
+      brief: brief[0],
+      briefs: brief,
+      actions: [{ id: 'openDecision', label: 'Answer…' }],
+    });
   // DECIDE-1: reviewing a lane's work is the lead's. Only with the loop off, where the person runs the
   // build themselves, does a finished story wait in the band for their Review or Merge; otherwise the
   // loop prompts the lead (or, under propose, offers the step with Go).
@@ -839,6 +891,18 @@ export function bandLines({
     });
   // TEAM-7, TEAM-9: what of the team needs this person.
   lines.push(...teamLines(team, check?.lanes ?? {}));
+  // REPORT-3: a bug report for code-kit an agent drafted, for the person to read and send, or not.
+  if (reports.length)
+    lines.push({
+      kind: 'report',
+      text: `${reports.length > 1 ? `${reports.length} bug reports for code-kit to send: ` : 'A bug report for code-kit to send: '}${reports[0].title}`,
+      report: reports[0],
+      reports,
+      actions: [
+        { id: 'openDecision', label: 'Read it' },
+        { id: 'discardReport', label: 'Discard' },
+      ],
+    });
   // LOOP-7: the milestone is done; LOOP-6: the loop's own state, with Pause or Resume.
   if (loop?.state === 'done')
     lines.push({
@@ -880,6 +944,10 @@ export function band(lines, { Box, Text, Button }, onAction) {
     usage: 'yellow',
     paused: 'yellow',
     facts: 'yellow',
+    question: 'cyan',
+    brief: 'cyan',
+    denied: 'red',
+    report: 'magenta',
   };
   const LIVE = { quiet: 'yellow', stalled: 'red' };
   const LABEL = 8;
@@ -989,10 +1057,11 @@ const NOTE_KINDS = new Set(['usage', 'paused', 'finish', 'done', 'teamDown']);
 /** The Approve… confirmation (ACT-1): what it grants, to whom, for how long, and the reason. */
 export function approvePane(
   approving,
-  { Box, Text, Input, Button },
-  { onInput, onSubmit, onCancel },
+  { Box, Text, Input, Button, Markdown },
+  { onInput, onSubmit, onCancel, onAskInput, onAsk },
 ) {
   const { request, reason, error } = approving;
+  const aside = approving.aside ?? { thread: [], draft: '' };
   return Box({
     flexDirection: 'column',
     rowGap: 1,
@@ -1003,6 +1072,30 @@ export function approvePane(
           `For ${request.lane ? `the ${request.lane} lane` : 'any agent'}, ${request.names.every((n) => n.startsWith('dep-')) ? 'until the install is committed (at most 7 days)' : 'for 60 minutes'}. Asked for: ${request.what}`,
         ],
       }),
+      // ACT-5: an aside about this approval, answered here and never in the lead's conversation.
+      ...aside.thread.flatMap((turn, i) => [
+        Text({ key: `aside-q-${i}`, color: 'cyan', children: [`You: ${turn.question}`] }),
+        turn.pending
+          ? Text({ key: `aside-a-${i}`, dimColor: true, children: ['Asking…'] })
+          : turn.error
+            ? Text({ key: `aside-a-${i}`, color: 'red', children: [turn.error] })
+            : Markdown
+              ? Markdown({ key: `aside-a-${i}`, text: turn.answer })
+              : Text({ key: `aside-a-${i}`, children: [turn.answer] }),
+      ]),
+      ...(onAsk
+        ? [
+            Input({
+              key: 'approve-ask',
+              label: 'Ask about it',
+              value: aside.draft,
+              placeholder: 'What is it for, and what does approving it let happen?',
+              submitLabel: 'Ask',
+              onInput: onAskInput,
+              onSubmit: onAsk,
+            }),
+          ]
+        : []),
       Input({
         key: 'approve-reason',
         label: 'Reason',
@@ -1025,6 +1118,88 @@ export function approvePane(
   });
 }
 
+/**
+ * ACT-5: the side call's prompt for a question about an approval: what code-kit knows of the request (the
+ * names, the lane, what was refused and why, its story, the limits it missed), the aside so far, and the
+ * question. It answers in the pane, never in the conversation, and acts on nothing.
+ */
+export function approvalAsidePrompt({
+  request,
+  story = null,
+  outside = null,
+  thread = [],
+  question,
+}) {
+  return [
+    "The person is deciding whether to approve something code-kit stopped, and asks you about it in code-kit's approval pane. Answer in a few short sentences, in plain words: what it is, why it's needed for the work, what approving it lets happen, and anything risky about it. Use what you know from this conversation and the facts below. If you don't know, say so; don't guess. This answer goes to that pane, not into the conversation: don't act on it, and don't change your plans because of it.",
+    '',
+    'The approval:',
+    `- approvals asked for: ${request.names.join(', ')}`,
+    `- for: ${request.lane ? `the ${request.lane} lane` : (request.actor ?? 'an agent')}`,
+    `- what was refused: ${request.what}`,
+    ...(request.why ? [`- why code-kit refused it: ${request.why}`] : []),
+    ...(story
+      ? [
+          `- story: ${story.id} ${story.title ?? ''}${story.requirements?.length ? ` (${story.requirements.join(', ')})` : ''}`,
+        ]
+      : []),
+    ...(outside ? [`- outside the limits the person set for the lead: ${outside}`] : []),
+    ...(thread.length
+      ? [
+          '',
+          'Asked so far:',
+          ...thread.flatMap((t) => [`Q: ${t.question}`, `A: ${t.answer ?? t.error ?? ''}`]),
+        ]
+      : []),
+    '',
+    `Question: ${question}`,
+  ].join('\n');
+}
+
+export const ANSWER_ID = 'code-kit-answer';
+
+/** ASK-2, ASK-4: the person's answer to the lead's question, or to one in their brief, typed. */
+export function answerPane(
+  answering,
+  { Box, Text, Input, Button },
+  { onInput, onSubmit, onCancel },
+) {
+  const { kind, question, text, error } = answering;
+  return Box({
+    flexDirection: 'column',
+    rowGap: 1,
+    children: [
+      Text({ bold: true, children: [question] }),
+      Text({
+        dimColor: true,
+        children: [
+          kind === 'brief'
+            ? `An open question in ${answering.path}. The lead records your answer in the brief's decisions and builds on it.`
+            : `${answering.id}, from the lead${answering.story ? `, for ${answering.story}` : ''}. Your answer is recorded and sent to the lead.`,
+        ],
+      }),
+      Input({
+        key: 'answer-text',
+        label: 'Answer',
+        value: text,
+        submitLabel: 'Answer',
+        autoFocus: true,
+        onInput,
+        onSubmit,
+      }),
+      ...(error ? [Text({ color: 'red', children: [error] })] : []),
+      Box({
+        flexDirection: 'row',
+        columnGap: 2,
+        children: [
+          Button({ key: 'answer-confirm', label: 'Answer', onPress: () => onSubmit(text) }),
+          Button({ key: 'answer-cancel', label: 'Cancel', onPress: onCancel }),
+        ],
+      }),
+    ],
+  });
+}
+
 /** What a merge (or another act run through the CLI) reported. */
 export function resultPane(result, { Box, Text }) {
   if (!result) return Text({ dimColor: true, children: ['Nothing to show.'] });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warren-dean/code-kit",
-  "version": "0.11.1",
+  "version": "0.12.1",
   "description": "Keeps AI coding agents inside your project's rules: lanes, layer rules, protected paths and proof before finish, enforced by Claude Code hooks and in CI",
   "license": "MIT",
   "author": "Warren Langeveldt",