@warren-dean/code-kit 0.11.1 → 0.12.1

package/hooks/lib/questions.mjs

@@ -0,0 +1,140 @@
+// Questions for the person (docs/specs/15-decisions-and-journal.md, ASK-1 to ASK-4): what the lead can't
+// settle itself (a product choice, an account only the person can create, wording only they can sign off),
+// asked through code-kit so it waits in the Decisions tab instead of scrolling away in the chat. A question
+// may hold its story ("waiting on you") until it's answered. Kept in the main checkout, so every lane's
+// worktree sees the same questions.
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { projectWorktrees } from './rules.mjs';
+
+export const QUESTIONS_FILE = '.claude/state/questions.jsonl';
+
+const fileOf = (root) => join(projectWorktrees(root)[0] ?? root, QUESTIONS_FILE);
+
+function records(root) {
+  try {
+    return readFileSync(fileOf(root), 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .flatMap((l) => {
+        try {
+          return [JSON.parse(l)];
+        } catch {
+          return [];
+        }
+      });
+  } catch {
+    return [];
+  }
+}
+
+function append(root, record) {
+  const file = fileOf(root);
+  mkdirSync(dirname(file), { recursive: true });
+  appendFileSync(file, `${JSON.stringify(record)}\n`);
+}
+
+/**
+ * Every question, oldest first: { id, at, by, question, why, story, blocks, options: [{ label, effect }],
+ * state: 'open' | 'answered' | 'withdrawn', answer: { text, at, by, via } | null, withdrawn: { at, reason } | null }.
+ */
+export function readQuestions(root) {
+  const byId = new Map();
+  for (const r of records(root)) {
+    if (r.kind === 'ask')
+      byId.set(r.id, { ...r, kind: undefined, state: 'open', answer: null, withdrawn: null });
+    const q = byId.get(r.id);
+    if (!q || q.state !== 'open') continue;
+    if (r.kind === 'answer') {
+      q.state = 'answered';
+      q.answer = { text: r.answer, at: r.at, by: r.by, via: r.via };
+    }
+    if (r.kind === 'withdraw') {
+      q.state = 'withdrawn';
+      q.withdrawn = { at: r.at, reason: r.reason ?? null };
+    }
+  }
+  return [...byId.values()].map(({ kind, ...q }) => q);
+}
+
+export const openQuestions = (root) => readQuestions(root).filter((q) => q.state === 'open');
+
+/** "Label: what it does" as an option; a label alone has no effect said. */
+export function parseOption(text) {
+  const at = String(text).indexOf(':');
+  return at > 0
+    ? { label: text.slice(0, at).trim(), effect: text.slice(at + 1).trim() || null }
+    : { label: String(text).trim(), effect: null };
+}
+
+/**
+ * ASK-1: records a question for the person; the same question still open is asked once, and returned.
+ * `blocks` holds its story until it's answered (ASK-3).
+ */
+export function askQuestion(
+  root,
+  { by, question, why = null, story = null, blocks = false, options = [] },
+  now = Date.now(),
+) {
+  const text = String(question).trim();
+  const open = openQuestions(root).find(
+    (q) => q.question === text && (q.story ?? null) === (story ?? null),
+  );
+  if (open) return { question: open, existed: true };
+  const n = readQuestions(root).length + 1;
+  const record = {
+    kind: 'ask',
+    id: `Q-${n}`,
+    at: new Date(now).toISOString(),
+    by,
+    question: text,
+    why: why?.trim() || null,
+    story: story ?? null,
+    blocks: Boolean(blocks && story),
+    options: options
+      .map((o) => (typeof o === 'string' ? parseOption(o) : o))
+      .filter((o) => o.label),
+  };
+  append(root, record);
+  return { question: readQuestions(root).find((q) => q.id === record.id), existed: false };
+}
+
+/** ASK-2: the person's answer, given in the pane (`via: 'pane'`) or in chat and recorded by the lead (`via: 'chat'`). */
+export function answerQuestion(root, id, { answer, by, via }, now = Date.now()) {
+  const q = readQuestions(root).find((x) => x.id === id);
+  if (!q) return { ok: false, why: `There's no question ${id}. code-kit ask lists the open ones.` };
+  if (q.state !== 'open') return { ok: false, why: `${id} isn't open: it was ${q.state} already.` };
+  if (!String(answer ?? '').trim())
+    return { ok: false, why: 'Give the answer: the lead builds on it.' };
+  append(root, {
+    kind: 'answer',
+    id,
+    at: new Date(now).toISOString(),
+    answer: String(answer).trim(),
+    by,
+    via,
+  });
+  return { ok: true, question: readQuestions(root).find((x) => x.id === id) };
+}
+
+/** The lead takes a question back once it no longer needs the person (it was settled another way). */
+export function withdrawQuestion(root, id, reason, now = Date.now()) {
+  const q = readQuestions(root).find((x) => x.id === id);
+  if (!q) return { ok: false, why: `There's no question ${id}.` };
+  if (q.state !== 'open') return { ok: false, why: `${id} isn't open: it was ${q.state} already.` };
+  append(root, {
+    kind: 'withdraw',
+    id,
+    at: new Date(now).toISOString(),
+    reason: reason?.trim() || null,
+  });
+  return { ok: true };
+}
+
+/** ASK-3: the stories an open question holds: Map(story id → the question). */
+export function waitingStories(root) {
+  const out = new Map();
+  for (const q of openQuestions(root))
+    if (q.blocks && q.story && !out.has(q.story)) out.set(q.story, q);
+  return out;
+}

package/hooks/lib/report.mjs

@@ -0,0 +1,246 @@
+// Bug reports for code-kit itself (docs/specs/15-decisions-and-journal.md, REPORT-1 to REPORT-3). With
+// `harness.report.on`, an agent that code-kit got in the way of (a refusal that's wrong, a crash, a pane
+// showing the wrong thing) drafts a report. The draft carries code-kit's own facts only (its version, the
+// rule, the refusal, the command, what was expected), with the project's paths, home folder and email
+// addresses taken out, and waits for the person: they read the exact text and send it, or discard it.
+// Sending files a GitHub issue on code-kit's repository through their own `gh`, or, without it, gives
+// them the new-issue link to open; a report someone already filed gets a comment instead of a second issue.
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { appendFileSync, mkdirSync, readFileSync, realpathSync } from 'node:fs';
+import { homedir, platform, release } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { projectWorktrees } from './rules.mjs';
+
+export const REPORTS_FILE = '.claude/state/reports.jsonl';
+const PLUGIN = JSON.parse(
+  readFileSync(fileURLToPath(new URL('../../.claude-plugin/plugin.json', import.meta.url)), 'utf8'),
+);
+/** code-kit's own repository, where reports go: `owner/name`. */
+export const REPO = PLUGIN.repository.replace(/^https:\/\/github\.com\//, '').replace(/\.git$/, '');
+
+const fileOf = (root) => join(projectWorktrees(root)[0] ?? root, REPORTS_FILE);
+
+function records(root) {
+  try {
+    return readFileSync(fileOf(root), 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .flatMap((l) => {
+        try {
+          return [JSON.parse(l)];
+        } catch {
+          return [];
+        }
+      });
+  } catch {
+    return [];
+  }
+}
+
+const append = (root, record) => {
+  const file = fileOf(root);
+  mkdirSync(dirname(file), { recursive: true });
+  appendFileSync(file, `${JSON.stringify(record)}\n`);
+};
+
+/**
+ * REPORT-2: text as it may leave the machine: the project's folders, the home folder and email
+ * addresses replaced, and cut to `max` characters.
+ */
+export function scrub(text, roots = [], max = 1500) {
+  let out = String(text ?? '');
+  const home = homedir();
+  for (const r of [...roots].filter(Boolean).sort((a, b) => b.length - a.length))
+    out = out.split(r).join('<project>');
+  if (home) out = out.split(home).join('~');
+  out = out.replace(/[\w.+-]+@[\w-]+(\.[\w-]+)+/g, '<email>');
+  return out.length > max ? `${out.slice(0, max)}…` : out;
+}
+
+/** REPORT-3: what makes two reports the same bug: the title's words and the rule, as a short hash. */
+export const fingerprint = (title, rule) =>
+  `ck-${createHash('sha1')
+    .update(
+      `${String(title)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ' ')
+        .trim()}|${rule ?? ''}`,
+    )
+    .digest('hex')
+    .slice(0, 8)}`;
+
+/** The issue's body, as the person will read it before it's sent. */
+function bodyOf(r) {
+  return [
+    `**What happened:** ${r.what}`,
+    ...(r.expected ? [`**Expected:** ${r.expected}`] : []),
+    ...(r.command ? ['**Command or call:**', '```', r.command, '```'] : []),
+    ...(r.refusal ? ['**What code-kit said:**', '```', r.refusal, '```'] : []),
+    ...(r.rule ? [`**Rule:** ${r.rule}`] : []),
+    `**code-kit:** ${r.version} · Node ${r.node} · ${r.os}`,
+    '',
+    `<sub>Drafted by a code-kit agent, read and sent by a person. Fingerprint: ${r.fingerprint}</sub>`,
+  ].join('\n');
+}
+
+/**
+ * Every report, oldest first: { id, at, by, title, body, fingerprint, state: 'draft' | 'sent' | 'discarded',
+ * sent: { at, url, comment } | null }.
+ */
+export function readReports(root) {
+  const byId = new Map();
+  for (const r of records(root)) {
+    if (r.kind === 'draft') byId.set(r.id, { ...r, state: 'draft', sent: null });
+    const d = byId.get(r.id);
+    if (!d || d.state !== 'draft') continue;
+    if (r.kind === 'sent')
+      Object.assign(d, {
+        state: 'sent',
+        sent: { at: r.at, url: r.url, comment: Boolean(r.comment) },
+      });
+    if (r.kind === 'discarded') d.state = 'discarded';
+  }
+  return [...byId.values()].map(({ kind, ...r }) => r);
+}
+
+export const draftReports = (root) => readReports(root).filter((r) => r.state === 'draft');
+
+/**
+ * REPORT-1: a draft from an agent: { title, what, expected, command, refusal, rule }. The same bug still
+ * waiting as a draft is drafted once.
+ */
+export function draftReport(root, input, { by = 'lead', now = Date.now() } = {}) {
+  // Each checkout as written and as the system resolves it (/var and /private/var on macOS).
+  const roots = [
+    ...new Set(
+      [...projectWorktrees(root), root].flatMap((r) => {
+        let real = r;
+        try {
+          real = realpathSync(r);
+        } catch {
+          // gone: as written
+        }
+        return [r, real, real.replace(/^\/private(?=\/)/, '')];
+      }),
+    ),
+  ];
+  const clean = (v, max) => (v ? scrub(v, roots, max) : null);
+  const title = clean(input.title, 120);
+  if (!title?.trim())
+    return { ok: false, why: 'Give the report a title: what went wrong, in a few words.' };
+  if (!input.what?.trim()) return { ok: false, why: 'Say what happened, with --what "…".' };
+  const fp = fingerprint(title, input.rule);
+  const existing = draftReports(root).find((r) => r.fingerprint === fp);
+  if (existing) return { ok: true, report: existing, existed: true };
+  const r = {
+    title: title.trim(),
+    what: clean(input.what, 1500),
+    expected: clean(input.expected, 600),
+    command: clean(input.command, 600),
+    refusal: clean(input.refusal, 1500),
+    rule: clean(input.rule, 120),
+    version: PLUGIN.version,
+    node: process.version,
+    os: `${platform()} ${release()}`,
+    fingerprint: fp,
+  };
+  const record = {
+    kind: 'draft',
+    id: `R-${readReports(root).length + 1}`,
+    at: new Date(now).toISOString(),
+    by,
+    title: r.title,
+    fingerprint: fp,
+    body: bodyOf(r),
+  };
+  append(root, record);
+  return { ok: true, report: readReports(root).find((x) => x.id === record.id), existed: false };
+}
+
+/** The new-issue link, for someone without `gh`: the draft filled in, for them to submit. */
+export const issueLink = (r) =>
+  `https://github.com/${REPO}/issues/new?title=${encodeURIComponent(r.title)}&body=${encodeURIComponent(r.body)}`;
+
+const gh = (args) =>
+  execFileSync('gh', args, {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 60000,
+  }).trim();
+
+/**
+ * REPORT-3: the person sends a draft: a comment on the open issue with its fingerprint, if someone filed
+ * it already, otherwise a new issue; without a working `gh`, nothing is sent and the link is returned.
+ */
+export function sendReport(root, id, now = Date.now()) {
+  const r = readReports(root).find((x) => x.id === id);
+  if (!r) return { ok: false, why: `There's no report ${id}.` };
+  if (r.state !== 'draft') return { ok: false, why: `${id} was ${r.state} already.` };
+  let url;
+  let comment = false;
+  try {
+    gh(['auth', 'status']);
+  } catch {
+    return {
+      ok: false,
+      link: issueLink(r),
+      why: "gh isn't installed or signed in, so nothing was sent.",
+    };
+  }
+  try {
+    const found = JSON.parse(
+      gh([
+        'issue',
+        'list',
+        '--repo',
+        REPO,
+        '--state',
+        'open',
+        '--search',
+        `${r.fingerprint} in:body`,
+        '--json',
+        'number,url',
+        '--limit',
+        '1',
+      ]) || '[]',
+    );
+    if (found.length) {
+      gh([
+        'issue',
+        'comment',
+        String(found[0].number),
+        '--repo',
+        REPO,
+        '--body',
+        `Seen again, on code-kit ${PLUGIN.version}.\n\n${r.body}`,
+      ]);
+      url = found[0].url;
+      comment = true;
+    } else
+      url = gh(['issue', 'create', '--repo', REPO, '--title', r.title, '--body', r.body])
+        .split('\n')
+        .at(-1);
+  } catch (err) {
+    return {
+      ok: false,
+      link: issueLink(r),
+      why: `GitHub didn't take it (${
+        String(err.stderr || err.message)
+          .trim()
+          .split('\n')[0]
+      }).`,
+    };
+  }
+  append(root, { kind: 'sent', id, at: new Date(now).toISOString(), url, comment });
+  return { ok: true, url, comment };
+}
+
+export function discardReport(root, id, now = Date.now()) {
+  const r = readReports(root).find((x) => x.id === id);
+  if (!r) return { ok: false, why: `There's no report ${id}.` };
+  if (r.state !== 'draft') return { ok: false, why: `${id} was ${r.state} already.` };
+  append(root, { kind: 'discarded', id, at: new Date(now).toISOString() });
+  return { ok: true };
+}

package/hooks/lib/rules.mjs

@@ -35,6 +35,8 @@ import { globToRegExp, matchesAny } from './glob.mjs';
 export const APPROVAL_LOG = '.claude/approval-log.jsonl';
 export const APPROVALS_DIR = '.claude/approvals';
 export const APPROVAL_MINUTES = 60;
+// CARD-7: a request waits until it's answered or dropped, and at most a week, so a forgotten one doesn't linger.
+export const REQUEST_DAYS = 7;
 // A dependency approval lasts until the lane commits the install it allows (the story may resume
 // hours later), and at most a week, so a forgotten one doesn't linger.
 export const DEPENDENCY_APPROVAL_DAYS = 7;
@@ -315,8 +317,8 @@ const sameRequest = (a, b) =>
   a.what === b.what &&
   [...a.names].sort().join() === [...b.names].sort().join();
 
-/** Every request recorded, oldest first; unreadable lines are skipped. */
-export function readRequests(root) {
+/** Every line of the requests file: the requests, and the drops (`{ drop: true, of }`). */
+function requestRecords(root) {
   try {
     return readFileSync(requestsFile(root), 'utf8')
       .split('\n')
@@ -333,10 +335,40 @@ export function readRequests(root) {
   }
 }
 
+/** Every request recorded, oldest first; unreadable lines are skipped. */
+export const readRequests = (root) => requestRecords(root).filter((r) => !r.drop);
+
+/** CARD-7: whether a request was dropped (the person dismissed it, or the lead said it's no longer needed). */
+const droppedIn = (drops, r) => drops.some((d) => d.of === r.at && sameRequest(d, r));
+
+/**
+ * CARD-7: drops open requests: `which` is a request's number in `openRequests`' order (1 is the
+ * newest), or 'all'. By the person (`by: 'person'`, from the pane) or the lead, once nobody needs it.
+ */
+export function dropRequests(root, which, { by, reason = null }, now = Date.now()) {
+  const open = openRequests(root, now);
+  const picked = which === 'all' ? open : [open[Number(which) - 1]].filter(Boolean);
+  if (!picked.length)
+    return {
+      ok: false,
+      why: open.length
+        ? `There's no open request ${which}: there are ${open.length} (code-kit requests lists them, newest first).`
+        : 'No approval requests are open.',
+    };
+  const file = requestsFile(root);
+  mkdirSync(dirname(file), { recursive: true });
+  for (const r of picked)
+    appendFileSync(
+      file,
+      `${JSON.stringify({ drop: true, of: r.at, actor: r.actor, names: r.names, what: r.what, by, reason, at: new Date(now).toISOString() })}\n`,
+    );
+  return { ok: true, dropped: picked };
+}
+
 /**
  * Records that `actor` was refused something the approvals `names` would allow, once: the same
- * actor, names and command or file within the approval lifetime count as one request. Recording
- * never changes the refusal, so any failure here is ignored.
+ * actor, names and command or file while one is still open count as one request. Recording never
+ * changes the refusal, so any failure here is ignored.
  */
 export function recordRequest(root, actor, names, what, why, now = Date.now()) {
   // A read-only agent (a reviewer) is never approved to write: what it changed goes back, not to the
@@ -351,10 +383,7 @@ export function recordRequest(root, actor, names, what, why, now = Date.now()) {
       what: String(what).slice(0, 200),
       why: String(why).slice(0, 300),
     };
-    const fresh = readRequests(root).filter(
-      (r) => now - Date.parse(r.at) < APPROVAL_MINUTES * 60_000,
-    );
-    if (fresh.some((r) => sameRequest(r, request))) return;
+    if (openRequests(root, now).some((r) => sameRequest(r, request))) return;
     const file = requestsFile(root);
     mkdirSync(dirname(file), { recursive: true });
     appendFileSync(file, `${JSON.stringify(request)}\n`);
@@ -363,13 +392,21 @@ export function recordRequest(root, actor, names, what, why, now = Date.now()) {
   }
 }
 
-/** Requests from the last 60 minutes that an approval in force doesn't yet answer, newest first. */
+/**
+ * CARD-7: requests nobody has answered yet, newest first: each waits until an approval answers it, its
+ * file is committed by someone who could, or it's dropped, and at most REQUEST_DAYS.
+ */
 export function openRequests(root, now = Date.now()) {
   const open = [];
   const given = approvalsGiven(root);
+  const drops = requestRecords(root).filter((r) => r.drop);
+  // The newest of the same request speaks for it: an older copy doesn't come back once that's dropped.
+  const seen = [];
   for (const r of readRequests(root).reverse()) {
-    if (now - Date.parse(r.at) >= APPROVAL_MINUTES * 60_000) continue;
-    if (open.some((o) => sameRequest(o, r))) continue;
+    if (now - Date.parse(r.at) >= REQUEST_DAYS * 24 * 60 * 60_000) continue;
+    if (seen.some((o) => sameRequest(o, r))) continue;
+    seen.push(r);
+    if (droppedIn(drops, r)) continue;
     // From before read-only agents stopped asking: only the lead and the lanes are ever approved.
     if (!r.lane && r.actor !== 'lead session') continue;
     const actor = r.lane ? { kind: 'lane', lane: r.lane } : { kind: 'lead' };

package/hooks/mod/art.mjs

@@ -107,7 +107,7 @@ export function spriteSvg(pose, tint, { lead = false } = {}) {
 
 /**
  * A lane's pose (VIEW-3): stalled when flagged or quiet past the restart time, waiting while a call
- * of its is held or its request is open, working while its agent is at work, quiet when it has
+ * of its is held, its request is open or its story waits on the person's answer, working while its agent is at work, quiet when it has
  * gone quiet, done once its branch is finished, idle otherwise.
  */
 export function poseOf(
@@ -115,7 +115,7 @@ export function poseOf(
   { live = null, waiting = false, flagged = false, shown = lane.state } = {},
 ) {
   if (flagged || live?.level === 'stalled') return 'stalled';
-  if (waiting) return 'waiting';
+  if (waiting || shown === 'waiting on you') return 'waiting';
   if (live?.level === 'quiet') return 'quiet';
   if (lane.active) return 'working';
   if (['in review', 'queued'].includes(shown)) return 'done';

package/hooks/mod/decisions.mjs

@@ -18,6 +18,10 @@ export const DECISION_KINDS = new Set([
   'teamIntent',
   'teamReview',
   'teamDrift',
+  'question',
+  'brief',
+  'denied',
+  'report',
 ]);
 
 /** What each answer does, in the person's words. */
@@ -41,8 +45,97 @@ const EFFECT = {
     'The issue closes as agreed, with your words; then put it in the specs or decisions so every agent builds on it.',
   dropIntent: 'The issue closes as dropped, and the team carries on as agreed before.',
   team: 'Opens the Team tab: who is building what, and what changed since you last looked.',
+  openDecision: 'Opens it here, with what each answer does.',
+  dropRequest: "Nobody needs it any more: it stops waiting, and nothing's approved.",
+  answer: 'Type your answer; the lead is told it and carries on.',
+  answerBrief: "Type your answer; the lead records it in the brief's decisions and builds on it.",
+  laterBrief: 'It waits; it comes back next session.',
+  runDenied:
+    'Puts it in your prompt after !, so you run it yourself; press Enter to run it, then Done it.',
+  deniedDone: 'The lead is told you ran it, or allowed it, and carries on.',
+  deniedNo: "The lead is told you won't run it now, and carries on with other work.",
+  sendReport:
+    "Files it on code-kit's GitHub under your account (a comment instead, if it's filed already).",
+  discardReport: "It's not sent, and goes.",
 };
 
+/**
+ * CARD-8: one card per decision. A band line can stand for several (approvals waiting, held calls, the
+ * lead's questions, the brief's, Claude Code's refusals, reports); each becomes its own line here, with
+ * the decision it's about, so each card's options answer that one.
+ */
+function eachDecision(line) {
+  if (line.kind === 'approvals' && line.asks?.length > 1)
+    return line.asks.map((a) => ({
+      ...line,
+      text: `Approve ${askWords(a.request, a.files)}`,
+      request: a.request,
+      files: a.files,
+    }));
+  if (line.kind === 'approvals')
+    return [{ ...line, text: `Approve ${askWords(line.request, line.files)}` }];
+  if (line.kind === 'held' && line.calls?.length > 1)
+    return line.calls.map((c) => ({ ...line, text: c.text, held: c.held }));
+  if (line.kind === 'question')
+    return (line.questions ?? [line.question]).map((q) => ({
+      ...line,
+      text: q.question,
+      question: q,
+    }));
+  if (line.kind === 'brief')
+    return (line.briefs ?? [line.brief]).map((b) => ({
+      ...line,
+      text: `From your brief: ${b.question}`,
+      brief: b,
+    }));
+  if (line.kind === 'denied')
+    return (line.denials ?? [line.denial]).map((d) => ({
+      ...line,
+      text: `Claude Code refused ${d.who}'s ${d.what}`,
+      denial: d,
+      actions: [
+        ...(d.command ? [{ id: 'runDenied', label: 'Put it in the prompt' }] : []),
+        { id: 'deniedDone', label: 'Done it' },
+        { id: 'deniedNo', label: 'Not now' },
+      ],
+    }));
+  if (line.kind === 'report')
+    return (line.reports ?? [line.report]).map((r) => ({ ...line, text: r.title, report: r }));
+  return [line];
+}
+
+/** A card's options: the line's own actions, or, for the kinds a card answers differently, its own. */
+function optionsOf(line) {
+  if (line.kind === 'approvals')
+    return [
+      { id: 'approve', label: 'Approve…' },
+      { id: 'dropRequest', label: 'Not needed' },
+    ];
+  // ASK-2: each of the lead's options answers it at once; any answer can be typed instead.
+  if (line.kind === 'question')
+    return [
+      ...line.question.options.map((o, i) => ({
+        id: `answerWith-${i}`,
+        act: 'answerWith',
+        label: o.label,
+        effect: o.effect,
+        line: { ...line, choice: o.label },
+      })),
+      { id: 'answer', label: line.question.options.length ? 'Something else…' : 'Answer…' },
+    ];
+  if (line.kind === 'brief')
+    return [
+      { id: 'answerBrief', label: 'Answer…' },
+      { id: 'laterBrief', label: 'Later' },
+    ];
+  if (line.kind === 'report')
+    return [
+      { id: 'sendReport', label: 'Send' },
+      { id: 'discardReport', label: 'Discard' },
+    ];
+  return line.actions;
+}
+
 /** Why a line needs the person, when the line itself doesn't say. */
 function whyOf(line, check) {
   if (line.kind === 'held') {
@@ -76,6 +169,17 @@ function whyOf(line, check) {
   if (line.kind === 'teamReview') return "It's in a lane you own, so its review is yours.";
   if (line.kind === 'teamDrift')
     return "The team's drift check found your work building on something that has since changed, or heading into someone else's: settle it before it merges.";
+  if (line.kind === 'question')
+    return (
+      line.question.why ??
+      "The lead can't settle this itself: it's yours to decide, and the lead builds on your answer."
+    );
+  if (line.kind === 'brief')
+    return `It's an open question in ${line.brief.path}: what gets built depends on your answer.`;
+  if (line.kind === 'denied')
+    return `Claude Code's own permission check refused it${line.denial.reason ? ` (${line.denial.reason})` : ''}, which code-kit can't approve past: only you can run it or allow it.`;
+  if (line.kind === 'report')
+    return "code-kit got in an agent's way. It's sent under your GitHub account to a public repository, so read what it says first.";
   return null;
 }
 
@@ -103,6 +207,7 @@ export function limitsWhy(outside) {
 function storyOf(line, state) {
   const stories = state?.stories ?? [];
   const lane = line.held?.lane ?? line.request?.lane ?? line.stall?.lane ?? null;
+  if (line.question?.story) return stories.find((s) => s.id === line.question.story) ?? null;
   if (line.story) return stories.find((s) => s.id === line.story.id) ?? line.story;
   if (line.stall?.story) return stories.find((s) => s.id === line.stall.story) ?? null;
   if (line.branch) return stories.find((s) => s.branch === line.branch) ?? null;
@@ -124,7 +229,8 @@ export function decisionCards(lines, context = {}) {
   const titles = new Map((status?.requirements ?? []).map((r) => [r.id, r.title]));
   return lines
     .filter((l) => DECISION_KINDS.has(l.kind) && !l.mission)
-    .map((line, i) => {
+    .flatMap((source) => eachDecision(source).map((line) => ({ source, line })))
+    .map(({ source, line }, i) => {
       const story = storyOf(line, state);
       const lane = line.held?.lane ?? line.request?.lane ?? line.stall?.lane ?? story?.lane ?? null;
       const settled = [
@@ -141,6 +247,8 @@ export function decisionCards(lines, context = {}) {
         id: `${line.kind}-${i}`,
         kind: line.kind,
         line,
+        // The band line it came from: one line can stand for several decisions (CARD-8).
+        source,
         title: line.text,
         asked: [request, goal].filter(Boolean).join(' · ') || null,
         story: story
@@ -157,10 +265,16 @@ export function decisionCards(lines, context = {}) {
           (line.intent
             ? `Intent #${line.intent.id}: ${line.intent.about}${line.intent.touches.length ? ` (touches ${line.intent.touches.join(', ')})` : ''}`
             : null) ??
-          (line.pull ? `Pull request #${line.pull.number} on ${line.pull.branch}` : null),
+          (line.pull ? `Pull request #${line.pull.number} on ${line.pull.branch}` : null) ??
+          (line.question?.blocks ? `${line.question.story} waits on your answer.` : null) ??
+          (line.denial ? (line.denial.command ?? line.denial.what) : null) ??
+          (line.report ? line.report.body : null),
         settled,
         why: whyOf(line, check),
-        options: line.actions.map((a) => ({ ...a, effect: EFFECT[a.id] ?? null })),
+        options: optionsOf(line).map((a) => ({
+          ...a,
+          effect: a.effect ?? EFFECT[a.act ?? a.id] ?? null,
+        })),
       };
     });
 }