@warren-dean/code-kit 0.12.1 → 0.12.2

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.12.1",
+      "version": "0.12.2",
       "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.12.1",
+  "version": "0.12.2",
   "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,13 @@
 
 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.12.2 (2026-10-13)
+
+The Decisions tab is readable, and old package requests stop waiting.
+
+- **Decisions as short cards.** The tab says how many of each kind wait ("10 approvals · 2 questions"), then lists each as a card: its kind, a one-line headline ("Approve fastify, jose, drizzle-orm and 4 more") and who it's for, with commands cut at their first pipe instead of whole scripts. Five show at a time; **j** and **k** move, and the selected one opens in full below.
+- **Package requests close once installed.** A request for a package closes once the package is in a committed `package.json`, whoever installed it, so installs already done no longer wait for you.
+
 ## 0.12.1 (2026-10-13)
 
 Ask about an approval before you give it.

package/README.md

@@ -290,7 +290,7 @@ With Claude Code 2.1.287 or later, code-kit's mod shows the project in the sessi
   - a story using more than three times the median of the stories finished this session (once three have finished): **Lanes** opens the pane;
   - background agents paused, once the plan’s 5-hour use passes `harness.background.pauseAtPercent` (80% unless set).
 
-  Each button has a digit: type it in an empty prompt to press it. The band keeps one line per kind ("2 approvals waiting"); the Decisions tab has a card for each decision.
+  Each button has a digit: type it in an empty prompt to press it. The band keeps one line per kind ("2 approvals waiting"); the Decisions tab says how many of each kind, then lists a short card for each decision, five at a time (**j** and **k** move), with the selected one in full below.
 
 - **`/lanes`** opens the Lanes pane. Its first line counts the stories by state (building, in review, queued, sent back, blocked, ready, merged), with the loop's state and the plan's 5-hour use; press a count to show only those lanes. Beneath it, whatever needs you (held calls, approvals, reviews, merges, stalled lanes, outliers) is pinned with its key. Tabs on **1** to **7**: **Lanes** opens on the loop as a card: its mode, the steps it took, the one running and the next. Then each lane on fixed columns: its name, state and story, its agent's current or last tool call with the time since beneath (amber once quiet, red when stalled), and its tokens; the lead reads orchestrating while its turn runs. A selected lane shows its stories as cards (state, requirements, what each waits on or its branch), then its agent and the paths it owns. **Decisions**, each decision that needs you as a card: what you asked for, the story and its requirements, what was happening, what's already settled, why the lead couldn't settle it, and each option with what it does; **Journal**, the build from your request to now in plain sentences, by day: the request and the decisions in the brief, the specification, each story handed out, sent back and merged, each approval and who gave it, each milestone finished, and the loop's steps this session, yours in yellow. Each lane has its own small pixel character, tinted in the lane's colour, whose pose shows its state: working (animated while its agent works), waiting on you, quiet, stalled, done or resting; the lead's wears a crown. Under each lane, its story's timeline on a shared time axis: building, then in review, with send-backs (↩), approvals (◆) and the merge (✓) marked where they fell; **Code map**, the whole project's folders by layer when no story is at work, or a story's files in a column per layer with the imports between them: a file fills with a lane's colour while that lane reads or edits it, and says whether its why (its Context Graph card) is written, out of date or not written yet; **j**/**k** select a file to see its card and what it imports and what imports it, and **o** opens it in Context Graph (box-drawing text in the terminal, an SVG on Desktop); **Trail**, every requirement in the specs as a cell by spec, its glyph and colour saying whether it's done and tested, done but untested, in progress, todo, without a story or removed, with a legend counting each. **h**/**l** and **j**/**k** move between cells and specs (or pick one from the list), showing the requirement's stories, their branches, the code they changed and the tests that name it; beneath the cells, the spec's trail drawn as a flow, each requirement to its stories, code and tests, with a missing link dashed in red; **Queue**, the merge queue; and **Usage**. **j** and **k** move between lanes, and the selected lane's acts are on **a** (approve), **r** (review), **s** (send back, with your reason), **m** (merge), **n** (nudge its agent) and **x** (stop it); **p** pauses or resumes the loop, and **f** filters the lanes by name, agent or story. **Enter** (or **o**) opens the selected lane's story: its requirements beside its spec-check report, the reviewer's findings by severity (each a way into the diff), `verify`'s problems, its usage and loop steps, and its diff against the base, file by file, with the acts its state allows. **b** or Escape goes back to the lanes. Inline (when the terminal can't dock it beside the transcript), it shows the counts, what needs you and a line per lane. 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.

package/hooks/lib/rules.mjs

@@ -415,6 +415,7 @@ export function openRequests(root, now = Date.now()) {
     // allowed), or the file it named was committed since by someone who could.
     if (r.names.every((n) => grantedSince(root, given, n, r))) continue;
     if (committedSince(root, r)) continue;
+    if (installedSince(root, r)) continue;
     open.push(r);
   }
   return open;
@@ -439,6 +440,39 @@ function grantedSince(root, given, name, r) {
   });
 }
 
+/**
+ * CARD-7: whether every package a dependency request named has since been added to a committed
+ * manifest, on any branch: the install happened (approved, or run by the person themselves), so it no
+ * longer waits.
+ */
+function installedSince(root, r) {
+  if (!r.names.length || !r.names.every((n) => n.startsWith(DEPENDENCY_APPROVAL))) return false;
+  return r.names.every((name) => {
+    const pkg = name.slice(DEPENDENCY_APPROVAL.length).replaceAll('+', '/');
+    try {
+      const out = execFileSync(
+        'git',
+        [
+          '-C',
+          root,
+          'log',
+          '--all',
+          '-1',
+          '--format=%ct',
+          `--since=@${Math.floor(Date.parse(r.at) / 1000)}`,
+          `-S"${pkg}"`,
+          '--',
+          ':(glob)**/package.json',
+        ],
+        { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] },
+      );
+      return Boolean(out.trim());
+    } catch {
+      return false;
+    }
+  });
+}
+
 /** Whether the file a request named has been committed, on any branch, since it was asked. */
 function committedSince(root, r) {
   const path = String(r.what);

package/hooks/mod/decisions.mjs

@@ -2,7 +2,7 @@
 // the person, each with its lineage. The band's "you" lines say what needs them; a decision card says why:
 // what they asked for, the story and requirements it belongs to, what the agent was doing, what was already
 // settled, why the lead couldn't settle this itself, and each option with what happens next.
-import { askWords } from './view.mjs';
+import { approvalLabel, askWords, commandItself } from './view.mjs';
 
 /** The kinds of band line that are the person's to decide; the rest are notes. */
 export const DECISION_KINDS = new Set([
@@ -136,6 +136,70 @@ function optionsOf(line) {
   return line.actions;
 }
 
+/** A kind of decision as its card's tag says it. */
+const TAG = {
+  held: 'held call',
+  approvals: 'approval',
+  stalled: 'stalled',
+  proposal: 'next step',
+  queue: 'merge',
+  review: 'review',
+  notice: 'notice',
+  question: 'question',
+  brief: 'your brief',
+  denied: 'refused',
+  report: 'bug report',
+};
+
+/** At most `n` characters on one line, cut with an ellipsis. */
+const clip = (text, n) => {
+  const one = String(text ?? '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return one.length > n ? `${one.slice(0, n - 1)}…` : one;
+};
+
+/** Names as a person reads them, at most three, then how many more. */
+const someNames = (names) => {
+  const shown = names.slice(0, 3).map(approvalLabel).join(', ');
+  return names.length > 3 ? `${shown} and ${names.length - 3} more` : shown;
+};
+
+/**
+ * CARD-9: a decision's headline and the line under it, short enough for a card in a list:
+ * { tag, headline, sub }.
+ */
+function headlineOf(line, story) {
+  const forStory = story ? ` · ${story.id}` : '';
+  if (line.kind === 'approvals') {
+    const who = line.request.lane ? `the ${line.request.lane} lane` : line.request.actor;
+    return {
+      headline: `Approve ${someNames(line.request.names)}`,
+      sub: `for ${who}${forStory} · ${clip(commandItself(line.files?.[0] ?? line.request.what), 70)}`,
+    };
+  }
+  if (line.kind === 'held')
+    return {
+      headline: `${line.held.who} wants to ${line.text.replace(/^.*? wants to /, '').replace(/ · \d+:\d+$/, '')}`,
+      sub: `held${forStory} · ${line.text.match(/\d+:\d+$/)?.[0] ?? ''} left`,
+    };
+  if (line.kind === 'question')
+    return {
+      headline: line.question.question,
+      sub: `from the lead${forStory}${line.question.blocks ? ', which waits on it' : ''}`,
+    };
+  if (line.kind === 'brief')
+    return { headline: line.brief.question, sub: `open in ${line.brief.path}` };
+  if (line.kind === 'denied')
+    return {
+      headline: `Claude Code refused ${line.denial.who}'s call`,
+      sub: clip(line.denial.command ?? line.denial.what, 80),
+    };
+  if (line.kind === 'report')
+    return { headline: line.report.title, sub: "drafted by an agent, for code-kit's GitHub" };
+  return { headline: line.text, sub: story ? `${story.id} ${story.title ?? ''}` : '' };
+}
+
 /** Why a line needs the person, when the line itself doesn't say. */
 function whyOf(line, check) {
   if (line.kind === 'held') {
@@ -243,9 +307,13 @@ export function decisionCards(lines, context = {}) {
               `${a.name} is approved${a.lane ? ` for the ${a.lane} lane` : ''}${a.reason ? `: ${a.reason}` : ''}`,
           ),
       ].slice(-5);
+      const { headline, sub } = headlineOf(line, story);
       return {
         id: `${line.kind}-${i}`,
         kind: line.kind,
+        tag: TAG[line.kind] ?? 'decision',
+        headline: clip(headline, 100),
+        sub,
         line,
         // The band line it came from: one line can stand for several decisions (CARD-8).
         source,
@@ -260,14 +328,22 @@ export function decisionCards(lines, context = {}) {
         })),
         doing:
           line.held?.command ??
-          (line.request ? askWords(line.request, line.files ?? [line.request.what]) : null) ??
+          (line.request
+            ? clip(
+                askWords(
+                  line.request,
+                  (line.files ?? [line.request.what]).map((f) => commandItself(f)),
+                ),
+                300,
+              )
+            : null) ??
           (line.proposal?.label ? `Next step: ${line.proposal.label}` : null) ??
           (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.question?.blocks ? `${line.question.story} waits on your answer.` : null) ??
-          (line.denial ? (line.denial.command ?? line.denial.what) : null) ??
+          (line.denial ? clip(line.denial.command ?? line.denial.what, 400) : null) ??
           (line.report ? line.report.body : null),
         settled,
         why: whyOf(line, check),

package/hooks/mod/panes.mjs

@@ -1257,10 +1257,15 @@ export function codeTab(view, { Box, Text, Button, Svg }, on) {
   return [picker, drawing, legend, detail, keys];
 }
 
+/** CARD-9: how many decision cards the list shows at once, around the selected one. */
+const CARDS_SHOWN = 5;
+
 /**
- * DECIDE-3: the Decisions tab: each decision that needs the person, the selected one as a card with its
- * lineage (what they asked for, the story and requirements, what was happening, what's settled, why it
- * needs them) and its options, each saying what it does. `on`: onDecision(i), onNeed(id, line).
+ * DECIDE-3, CARD-9: the Decisions tab: how many decisions need the person, by kind; then each as a short
+ * card (its kind, a one-line headline, and who or what it's for), a few at a time around the selected
+ * one, with j and k to move; then the selected one in full, with its lineage (what they asked for, the
+ * story and requirements, what was happening, what's settled, why it needs them) and its options, each
+ * saying what it does. `on`: onDecision(i), onNeed(id, line).
  */
 export function decisionsTab(cards, ui, { Box, Text, Button }, on) {
   const text = (value, style = {}) => Text({ ...style, children: [value] });
@@ -1277,27 +1282,82 @@ export function decisionsTab(cards, ui, { Box, Text, Button }, on) {
         text(value, { wrap: 'wrap', ...style }),
       ],
     });
+  const kinds = new Map();
+  for (const c of cards) kinds.set(c.tag, (kinds.get(c.tag) ?? 0) + 1);
+  const from = Math.max(0, Math.min(at - Math.floor(CARDS_SHOWN / 2), cards.length - CARDS_SHOWN));
+  const shown = cards.slice(from, from + CARDS_SHOWN);
   const list = Box({
     key: 'decision-list',
     flexDirection: 'column',
-    children: cards.map((c, i) =>
+    children: [
+      ...(from > 0 ? [text(`  ↑ ${from} more`, { key: 'decision-above', dimColor: true })] : []),
+      ...shown.map((c, n) => {
+        const i = from + n;
+        return Box({
+          key: `decision-item-${i}`,
+          flexDirection: 'column',
+          borderStyle: 'round',
+          borderColor: i === at ? 'yellow' : 'gray',
+          paddingX: 1,
+          children: [
+            Box({
+              flexDirection: 'row',
+              columnGap: 1,
+              children: [
+                text(c.tag.toUpperCase(), { color: i === at ? 'yellow' : 'cyan', bold: true }),
+                Button({
+                  key: `decision-pick-${i}`,
+                  label: c.headline,
+                  plain: true,
+                  onPress: () => on.onDecision(i),
+                }),
+              ],
+            }),
+            ...(c.sub ? [text(c.sub, { dimColor: true, wrap: 'truncate-end' })] : []),
+          ],
+        });
+      }),
+      ...(from + CARDS_SHOWN < cards.length
+        ? [
+            text(`  ↓ ${cards.length - from - CARDS_SHOWN} more`, {
+              key: 'decision-below',
+              dimColor: true,
+            }),
+          ]
+        : []),
+    ],
+  });
+  const keys = Box({
+    key: 'decision-keys',
+    flexDirection: 'row',
+    columnGap: 2,
+    children: [
       Button({
-        key: `decision-pick-${i}`,
-        label: `${i === at ? '›' : ' '} ${c.title}`,
+        key: 'decision-next',
+        label: 'Next',
+        hotkey: 'j',
         plain: true,
-        onPress: () => on.onDecision(i),
+        onPress: () => on.onDecision(Math.min(at + 1, cards.length - 1)),
       }),
-    ),
+      Button({
+        key: 'decision-prev',
+        label: 'Previous',
+        hotkey: 'k',
+        plain: true,
+        onPress: () => on.onDecision(Math.max(at - 1, 0)),
+      }),
+      text(`${at + 1} of ${cards.length}`, { dimColor: true }),
+    ],
   });
   const detail = Box({
     key: 'decision-card',
     flexDirection: 'column',
-    borderStyle: 'round',
+    borderStyle: 'double',
     borderColor: 'yellow',
     paddingX: 1,
     rowGap: 0,
     children: [
-      text(card.title, { bold: true }),
+      text(card.headline, { bold: true, wrap: 'wrap' }),
       ...(card.asked ? [row('You asked for', card.asked)] : []),
       ...(card.story
         ? [
@@ -1353,7 +1413,18 @@ export function decisionsTab(cards, ui, { Box, Text, Button }, on) {
       `${cards.length} decision${cards.length === 1 ? '' : 's'} need${cards.length === 1 ? 's' : ''} you. Everything else is the lead's.`,
       { bold: true },
     ),
-    ...(cards.length > 1 ? [list] : []),
+    Box({
+      key: 'decision-kinds',
+      children: [
+        text(
+          [...kinds]
+            .map(([tag, n]) => `${n} ${tag}${n === 1 || tag.endsWith('brief') ? '' : 's'}`)
+            .join(' · '),
+          { dimColor: true },
+        ),
+      ],
+    }),
+    ...(cards.length > 1 ? [list, keys] : []),
     detail,
   ];
 }

package/hooks/mod/register.test.ts

@@ -1521,13 +1521,10 @@ test("ASK-4 the brief's open questions are the person's decisions: answered to t
   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();
+  expect(await ui.find({ type: 'Text', text: 'Accounts: AWS, Supabase, Fly' })).toBeDefined();
+  expect(await ui.find({ type: 'Text', text: 'open in docs/brief.md' })).toBeDefined();
   await press($, 'decide-laterBrief', PANE);
-  expect(
-    await ui.find({ type: 'Text', text: 'From your brief: The product domain' }),
-  ).toBeDefined();
+  expect(await ui.find({ type: 'Text', text: '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' });
@@ -1602,6 +1599,45 @@ test('CARD-8 two approvals waiting are two decisions, each approved or dropped o
   await ui.unmount();
 });
 
+test('CARD-9 many decisions read as short cards, a few at a time, with the selected one in full', async ($, on) => {
+  const w = project();
+  w.requests = Array.from({ length: 8 }, (_, i) => ({
+    ...dayjs,
+    at: `2026-10-06T00:0${i}:00.000Z`,
+    names: [`dep-pkg${i}`, 'dep-a', 'dep-b', 'dep-c'],
+    what: `pnpm --filter @app/web add pkg${i} a b c 2>&1 | tail -20 && cat > tsconfig.json <<'EOF'\n{ "x": 1 }\nEOF`,
+  }));
+  w.questions = [question()];
+  await start($, on, w);
+  const band = await bandUi($);
+  await press($, 'band-decide');
+  await band.unmount();
+  const ui = await pane($, PANE);
+  expect((await ui.find({ key: 'decision-kinds' }))?.text).toBe('8 approvals · 1 question');
+  // Five cards at a time, each a headline and a line under it; the command cut at its pipe, on one line.
+  expect(await ui.find({ key: 'decision-item-4' })).toBeDefined();
+  expect(await ui.find({ key: 'decision-item-5' })).toBeUndefined();
+  expect(await ui.find({ type: 'Text', text: '  ↓ 4 more' })).toBeDefined();
+  expect((await ui.find({ key: 'decision-pick-0' }))?.props.label).toBe(
+    'Approve pkg0, a, b and 1 more',
+  );
+  expect(
+    await ui.find({
+      type: 'Text',
+      text: 'for the web lane · ST-4 · pnpm --filter @app/web add pkg0 a b c',
+    }),
+  ).toBeDefined();
+  expect((await ui.findAll({ type: 'Text' })).some((t: any) => /tsconfig|EOF/.test(t.text))).toBe(
+    false,
+  );
+  await press($, 'decision-next', PANE);
+  await press($, 'decision-next', PANE);
+  await press($, 'decision-next', PANE);
+  expect(await ui.find({ type: 'Text', text: /↑ \d+ more/ })).toBeDefined();
+  expect((await ui.findAll({ type: 'Text' })).some((t: any) => t.text === '4 of 9')).toBe(true);
+  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 = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warren-dean/code-kit",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "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",