@warren-dean/code-kit 0.11.0 → 0.11.1

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

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

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 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.11.1 (2026-10-12)
+
+The loop and the lead stop talking past each other, and approvals ask only what still needs you.
+
+- **The loop never asks for a story an agent is still on.** `code-kit next` reads only branches, so the loop kept asking the lead to review stories their lane agents were still building, or already being reviewed, and to dispatch stories started a moment ago. It now leaves out every story a running agent's task names ("ST-10 capture pipeline", "Review domain/st-78"), and when nothing's left it waits, saying for what, until an agent finishes.
+- **Approvals are counted as decisions.** "contract for the platform lane: 5 files" is one approval, not five; approving it covers them all.
+- **Only requests that still wait are shown.** A request closes once an approval is given after it, even if that approval has since lapsed or was used up, and once its file has been committed by someone who could. A read-only agent, such as the reviewer running a code generator, is never approved to write: it's told to put the file back, and you aren't asked.
+- **The history of approvals.** `/approvals` and `code-kit requests` list every approval given, newest first: when, what for, which lane, who gave it (you, or the lead within your delegated rules), the reason, and the files and branches it covered, merged or not.
+
 ## 0.11.0 (2026-10-12)
 
 Teams get their own pane and their own setup, and a hosted team provider can stand down to GitHub.

package/README.md

@@ -279,7 +279,7 @@ With Claude Code 2.1.287 or later, code-kit's mod shows the project in the sessi
 
 - **The band** sits above the prompt. While the build is moving (the lead mid-turn, an agent at work, the loop started) it opens with the mission: **goal**, the milestone being built and how many of its stories are done; **now**, what the lead is doing and the loop's state, with **Pause** or **Resume**; **next**, the step the loop takes next; and **agents**, a line per agent at work with its current tool and how long since. With Context Graph installed, a line says when a lane edited files without understanding them, and only then. Beneath, labelled **you**, what only you can decide, each with the story it's for ("for ST-4 Booking form (BOOK-1)"), and **d** ("Why, and what each choice does") opens it as a card in the Decisions tab; usage and the plan's pause are labelled **note**. In a team (`team` in the config), it also names what of the team needs you, and only that: your stale claim (Keep or Release), a claim of yours changing the same files as someone else's, an intent touching what you own or lease (every intent, with Agree and Drop, for the tech lead), and a pull request in a lane you own. While the loop runs, a lane's finished work is the lead's to review and merge, so it never waits here; with the loop off, Review and Merge are offered to you. With nothing happening and nothing waiting, the band is gone. It shows:
   - an agent's call held for you: installing a new package, writing or committing a protected file, or a lane changing the kit. Rather than stopping the agent, the call waits while the band asks ("web wants to install dayjs · 1:53"). **Approve** opens the confirmation and, once you confirm, the same call runs; **Refuse**, or no answer within `harness.hold.minutes` (2 unless set), refuses it as before. Under `autonomy: autonomous`, a call within `approvals.delegate` is approved as delegated without asking. Nothing is held under `claude -p` or the SDK, where nobody can answer;
-  - the lead loop, under `harness.autonomy`. `/code-kit:init` asks you how hands-off you want it. Until you've chosen, the loop's first step waits in the band ("code-kit can keep the build moving between your prompts") with **Keep going**, **Ask each time** and **Off**, and your answer is recorded as your setting. Once the lead has finished a turn, the loop keeps the build moving: with the lead idle and nothing typed in the prompt, it asks `code-kit next` and prompts the lead to dispatch the ready stories, review a finished one, or build its own, never the same step twice while nothing has changed. A step the lead was prompted with twice in a row and that is still next goes to you instead, in the band: "Merge lead/st-1: still next after 2 prompts. Ask the lead again?" with **Go**. **Pause** and **Resume** stop and start it. Under `propose`, each step waits in the band for **Go**; under `off`, the loop does nothing. A lane agent with no tool call for `harness.stall.nudgeMinutes` (5) is messaged, unless its work is done (it handed back, or its branch is in review or the merge queue); at `stall.restartMinutes` (10) the lead is asked to stop it and dispatch its story again, at most `stall.maxRestarts` (2) times, and then the band flags the lane. When every story is done, the band says so and the loop stops. With `harness.agents.reviewer.on`, a finished branch is first reviewed in the background by code-kit's reviewer agent, which the lead starts: it runs `verify` and the review checklist, read-only, and grades each finding blocker, concern or nit. The lead's review prompt then carries the findings, and a blocker means the branch is sent back. The pane shows each review, running with its clock or what it found. If the reviewer hasn't reported within 15 minutes, or the plan's 5-hour use is past `harness.background.pauseAtPercent`, the lead reviews without it. A branch the lead's review passes joins the merge queue (`code-kit queue`). Branches merge one at a time, in the order they passed, each verified against the base as it is then: the lead merges where `approvals.delegate.merge` is on under `autonomous`, otherwise the band shows the head with **Merge** for you. Who may merge is read from the config committed on the base, so a branch can't grant itself merges. There's no first merge for you: setting up commits the rules you approved straight onto the base, and in a project set up before that, the lead puts them there itself (`code-kit queue rules`) before its first merge. A merged lane's worktree is removed when it holds nothing uncommitted. A head that conflicts or fails verify goes back to its lane. The pane lists the queue, and lanes whose branch waits in it read `queued`;
+  - the lead loop, under `harness.autonomy`. `/code-kit:init` asks you how hands-off you want it. Until you've chosen, the loop's first step waits in the band ("code-kit can keep the build moving between your prompts") with **Keep going**, **Ask each time** and **Off**, and your answer is recorded as your setting. Once the lead has finished a turn, the loop keeps the build moving: with the lead idle and nothing typed in the prompt, it asks `code-kit next` and prompts the lead to dispatch the ready stories, review a finished one, or build its own, never the same step twice while nothing has changed, and never a story an agent is still on: one its lane agent is building, or a reviewer is reviewing, waits until that agent finishes ("waiting: ST-10 is still with its agent"). A step the lead was prompted with twice in a row and that is still next goes to you instead, in the band: "Merge lead/st-1: still next after 2 prompts. Ask the lead again?" with **Go**. **Pause** and **Resume** stop and start it. Under `propose`, each step waits in the band for **Go**; under `off`, the loop does nothing. A lane agent with no tool call for `harness.stall.nudgeMinutes` (5) is messaged, unless its work is done (it handed back, or its branch is in review or the merge queue); at `stall.restartMinutes` (10) the lead is asked to stop it and dispatch its story again, at most `stall.maxRestarts` (2) times, and then the band flags the lane. When every story is done, the band says so and the loop stops. With `harness.agents.reviewer.on`, a finished branch is first reviewed in the background by code-kit's reviewer agent, which the lead starts: it runs `verify` and the review checklist, read-only, and grades each finding blocker, concern or nit. The lead's review prompt then carries the findings, and a blocker means the branch is sent back. The pane shows each review, running with its clock or what it found. If the reviewer hasn't reported within 15 minutes, or the plan's 5-hour use is past `harness.background.pauseAtPercent`, the lead reviews without it. A branch the lead's review passes joins the merge queue (`code-kit queue`). Branches merge one at a time, in the order they passed, each verified against the base as it is then: the lead merges where `approvals.delegate.merge` is on under `autonomous`, otherwise the band shows the head with **Merge** for you. Who may merge is read from the config committed on the base, so a branch can't grant itself merges. There's no first merge for you: setting up commits the rules you approved straight onto the base, and in a project set up before that, the lead puts them there itself (`code-kit queue rules`) before its first merge. A merged lane's worktree is removed when it holds nothing uncommitted. A head that conflicts or fails verify goes back to its lane. The pane lists the queue, and lanes whose branch waits in it read `queued`;
   - approvals agents have asked for: **Approve…** opens a confirmation with a reason prefilled from the request, which you keep or rewrite;
   - stories finished and waiting for review: **Review** asks the lead to run `/code-kit:review` on the branch, and **Merge** runs `verify`, checks included, then merges if it passes;
   - a finish check failing in this session: **Lanes** opens the pane;
@@ -291,7 +291,7 @@ With Claude Code 2.1.287 or later, code-kit's mod shows the project in the sessi
 - **`/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.
 - **`/harness`** opens the harness settings: how the lead loop acts, how long a call waiting on your approval is held, when a stalled lane is nudged and restarted, the reviewer agent and its model, and the use at which background agents pause. Changing one asks your reason, writes `.claude/code-kit.json` and logs a `kit` approval. Lanes, paths and rules still change through `/code-kit:init`.
-- **`/approvals`** lists the requests waiting and the approvals in force, with minutes left. **`/verify-branch`** runs `code-kit verify` on this branch. Neither calls the model.
+- **`/approvals`** lists the approvals waiting (one per approval and lane, with every file it covers), the approvals in force with minutes left, and every approval given, newest first: who gave it (you, or the lead within your delegated rules), its reason, and the files and branches it covered, merged or not. A request stops waiting once an approval is given for it, or its file is committed by someone who could; a read-only agent such as the reviewer never asks. **`/verify-branch`** runs `code-kit verify` on this branch. Neither calls the model.
 
 Approving from the band records `(approved in the code-kit pane)` with your reason, and a merge from it says it was merged by the person from the pane. A settings change is logged as made in the pane. These happen only on your press: the hooks refuse `approve --via pane`, `merge --person` and `settings set` from every agent. Outside a project with `.claude/code-kit.json`, the mod draws nothing. Mods don't draw in the VS Code extension's chat panel, the Agent SDK or `claude -p`.
 
@@ -358,7 +358,7 @@ code-kit status [--base ref] [--json]  # stories and requirements against the sp
 code-kit next [--base ref] [--json]    # the step to take now, from the project's state
 code-kit trace <path>... [--json]      # what a file is for: requirements, lane, layer rules
 code-kit merge <branch> --delegated|--person [--into branch]  # merge a branch that passes verify: the lead where approvals.delegate.merge is on, or the person
-code-kit requests [--json]                                   # approval requests the hooks refused, still open, and the approvals in force
+code-kit requests [--json]                                   # approval requests still waiting, the approvals in force, and every approval given
 code-kit stops [--session id] [--json]                       # finish checks that refused an agent's last stop and still fail
 code-kit sent-back <branch> [--reason "…"]                    # record a review's send-back: status shows the story as sent back until the branch moves on
 code-kit settings [--json]                                   # the harness settings in force, with their defaults

package/bin/code-kit.mjs

@@ -80,6 +80,7 @@ import {
   approvalLifetime,
   currentBranch,
   PANE,
+  approvalHistory,
   approvalsInForce,
   delegatedMark,
   grantApprovals,
@@ -912,7 +913,9 @@ function requests() {
   load();
   const open = openRequests(resolve('.'));
   const granted = approvalsInForce(resolve('.'));
-  if (flag('--json')) return out(JSON.stringify({ open, inForce: granted }, null, 2));
+  // CARD-6: every approval given, newest first.
+  const history = approvalHistory(resolve('.')).slice(0, 100);
+  if (flag('--json')) return out(JSON.stringify({ open, inForce: granted, history }, null, 2));
   out(open.length ? `${open.length} approval request(s) open:` : 'No approval requests open.');
   for (const r of open)
     out(
@@ -923,6 +926,11 @@ function requests() {
     out(
       `  ${a.name} for ${a.lane ? `the ${a.lane} lane` : 'any agent'}, ${a.minutesLeft} min left: ${a.reason}`,
     );
+  out(history.length ? `\nApprovals given (newest first):` : '\nNo approvals given yet.');
+  for (const h of history.slice(0, 30))
+    out(
+      `  ${h.at.slice(0, 16).replace('T', ' ')}  ${h.name} for ${h.lane ? `the ${h.lane} lane` : 'any agent'}, by ${h.by}${h.files.length ? ` · ${h.files.length} file${h.files.length === 1 ? '' : 's'}${h.branches.length ? ` on ${h.branches.join(', ')}` : ''}` : ''}: ${h.reason}`,
+    );
 }
 
 /**

package/hooks/lib/rules.mjs

@@ -62,6 +62,8 @@ export const RELAYED = '(given in chat, recorded by the lead)';
 export const PANE = '(approved in the code-kit pane)';
 /** Refusals a person's approval would allow, for the mod's band and `code-kit requests`. */
 export const REQUESTS_FILE = '.claude/state/requests.jsonl';
+/** Every approval given through code-kit, and every one used up, kept for the history (CARD-6). */
+export const GIVEN_FILE = '.claude/state/approvals-given.jsonl';
 
 /** The command the lead runs to record approvals a person gave in chat. */
 /** Marks an approval the lead granted on its own, within `approvals.delegate`; `rule` names the rule. */
@@ -107,11 +109,52 @@ export function approvalHowTo(names, actor, root, allows = 'these edits', config
 export function grantApprovals(root, names, lane, reason, marks = {}) {
   const dir = lane ? join(approvalsDir(root), lane) : approvalsDir(root);
   mkdirSync(dir, { recursive: true });
-  return names.map((name) => {
+  const at = new Date().toISOString();
+  const files = names.map((name) => {
     const file = join(dir, name);
     writeFileSync(file, `${reason.trim()} ${marks[name] ?? RELAYED}\n`);
     return file;
   });
+  noteGiven(
+    root,
+    names.map((name) => ({
+      at,
+      name,
+      ...(lane ? { lane } : {}),
+      reason: `${reason.trim()} ${marks[name] ?? RELAYED}`,
+    })),
+  );
+  return files;
+}
+
+const givenFile = (root) => join(projectWorktrees(root)[0] ?? root, GIVEN_FILE);
+
+function noteGiven(root, entries) {
+  try {
+    const file = givenFile(root);
+    mkdirSync(dirname(file), { recursive: true });
+    appendFileSync(file, entries.map((e) => `${JSON.stringify(e)}\n`).join(''));
+  } catch {
+    // the approval stands; only its history misses it
+  }
+}
+
+/** The approvals given through code-kit (and those used up), oldest first. */
+export function approvalsGiven(root) {
+  try {
+    return readFileSync(givenFile(root), 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .flatMap((l) => {
+        try {
+          return [JSON.parse(l)];
+        } catch {
+          return [];
+        }
+      });
+  } catch {
+    return [];
+  }
 }
 
 /** `path` with symlinks resolved, even if it doesn't exist yet (macOS /var → /private/var). */
@@ -249,8 +292,21 @@ export function useApproval(root, name, actor) {
   for (const file of [
     ...(actor?.kind === 'lane' ? [join(dir, actor.lane, name)] : []),
     join(dir, name),
-  ])
-    if (inForce(file)) return rmSync(file, { force: true });
+  ]) {
+    const a = inForce(file);
+    if (!a) continue;
+    // Kept in the history, and as the answer to the request it was given for, once its file is gone.
+    noteGiven(root, [
+      {
+        at: a.grantedAt,
+        name,
+        ...(file !== join(dir, name) ? { lane: actor.lane } : {}),
+        reason: a.reason,
+        usedAt: new Date().toISOString(),
+      },
+    ]);
+    return rmSync(file, { force: true });
+  }
 }
 
 const requestsFile = (root) => join(projectWorktrees(root)[0] ?? root, REQUESTS_FILE);
@@ -283,6 +339,9 @@ export function readRequests(root) {
  * 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
+  // person as a request.
+  if (actor?.kind === 'readonly') return;
   try {
     const request = {
       at: new Date(now).toISOString(),
@@ -307,16 +366,161 @@ 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. */
 export function openRequests(root, now = Date.now()) {
   const open = [];
+  const given = approvalsGiven(root);
   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;
+    // 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' };
     if (r.names.every((n) => approval(root, n, actor))) continue;
+    // Answered already: approved after it was asked (since expired, or used up by the commit it
+    // 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;
     open.push(r);
   }
   return open;
 }
 
+/** Whether `name` was approved for the request's lane (or for everyone) at or after it was asked. */
+function grantedSince(root, given, name, r) {
+  const asked = Date.parse(r.at);
+  if (
+    given.some(
+      (g) => g.name === name && (!g.lane || g.lane === r.lane) && Date.parse(g.at) >= asked,
+    )
+  )
+    return true;
+  const dir = approvalsDir(root);
+  return [...(r.lane ? [join(dir, r.lane, name)] : []), join(dir, name)].some((file) => {
+    try {
+      return statSync(file).isFile() && statSync(file).mtimeMs >= asked;
+    } 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);
+  if (/\s/.test(path) || (!path.includes('/') && !path.includes('.'))) return false;
+  try {
+    const out = execFileSync(
+      'git',
+      [
+        '-C',
+        root,
+        'log',
+        '--all',
+        '-1',
+        '--format=%ct',
+        `--since=@${Math.floor(Date.parse(r.at) / 1000)}`,
+        '--',
+        path,
+      ],
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] },
+    );
+    return Boolean(out.trim());
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * CARD-6: every approval given, newest first: { at, name, lane, reason, by, files, branches, used,
+ * expired }. From the approvals given through code-kit, the approvals on disk (a person's own `!` echo
+ * included), and the audit log in every worktree, so an approval shows before its branch merges.
+ */
+export function approvalHistory(root, now = Date.now()) {
+  const grants = [];
+  const near = (a, b) => Math.abs(Date.parse(a) - Date.parse(b)) < 2000;
+  const add = (g) => {
+    const found = grants.find(
+      (x) => x.name === g.name && (x.lane ?? null) === (g.lane ?? null) && near(x.at, g.at),
+    );
+    if (found) {
+      if (g.usedAt) found.used = true;
+      return found;
+    }
+    const grant = {
+      at: g.at,
+      name: g.name,
+      lane: g.lane ?? null,
+      reason: g.reason ?? '',
+      files: [],
+      branches: [],
+      used: Boolean(g.usedAt),
+    };
+    grants.push(grant);
+    return grant;
+  };
+  for (const g of approvalsGiven(root)) add(g);
+  const dir = approvalsDir(root);
+  const look = (folder, lane) => {
+    let names = [];
+    try {
+      names = readdirSync(folder);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      const file = join(folder, name);
+      const st = statSync(file);
+      if (st.isDirectory()) {
+        if (!lane) look(file, name);
+        continue;
+      }
+      add({
+        at: new Date(st.mtimeMs).toISOString(),
+        name,
+        lane,
+        reason: readFileSync(file, 'utf8').trim(),
+      });
+    }
+  };
+  look(dir, null);
+  const seen = new Set();
+  for (const tree of projectWorktrees(root).length ? projectWorktrees(root) : [root]) {
+    let lines = [];
+    try {
+      lines = readFileSync(join(tree, APPROVAL_LOG), 'utf8').split('\n').filter(Boolean);
+    } catch {
+      continue;
+    }
+    for (const line of lines) {
+      if (seen.has(line)) continue;
+      seen.add(line);
+      let e;
+      try {
+        e = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!e.approval || e.approval === 'lead') continue;
+      const grant =
+        grants.find((x) => x.name === e.approval && near(x.at, e.grantedAt ?? e.at)) ??
+        add({ at: e.grantedAt ?? e.at, name: e.approval, reason: e.reason });
+      if (e.file && !grant.files.includes(e.file)) grant.files.push(e.file);
+      if (e.branch && !grant.branches.includes(e.branch)) grant.branches.push(e.branch);
+    }
+  }
+  return grants
+    .map((g) => ({
+      ...g,
+      by: /within the delegated rules/.test(g.reason)
+        ? 'the lead, within your delegated rules'
+        : /given in chat, recorded by the lead/.test(g.reason)
+          ? 'you, in chat'
+          : /in the [\w -]+ pane/.test(g.reason)
+            ? 'you, in the pane'
+            : 'you',
+      expired: g.used || now - Date.parse(g.at) >= approvalMinutes(g.name) * 60_000,
+    }))
+    .sort((a, b) => Date.parse(b.at) - Date.parse(a.at));
+}
+
 /** Approvals in force now: [{ name, lane?, reason, grantedAt, minutesLeft }]. */
 export function approvalsInForce(root, now = Date.now()) {
   const dir = approvalsDir(root);
@@ -434,6 +638,8 @@ export function writeProblem(actor, rel, root, config) {
   // A package a person approved may change the manifests and lockfiles its install rewrites.
   if (dependencyChange(actor, rel, root, config)) return null;
   const guarded = protectedEntry(rel, config);
+  if (actor.kind === 'readonly' && (guarded || !matchesAny(rel, config.anyActor)))
+    return readonlyProblem(actor, rel);
   // The lead writes protected files without an approval: the person reviews them in the pull request,
   // and every committed change is in the audit log. Anyone else needs a person's approval as well.
   if (guarded && actor.kind !== 'lead' && !approval(root, guarded.approval, actor)) {
@@ -441,12 +647,16 @@ export function writeProblem(actor, rel, root, config) {
     return `${rel} is ${guarded.why} and needs a person's approval. Ask the lead (a person) to run\n${approvalHowTo(guarded.approval, actor, root, undefined, config)}`;
   }
   if (matchesAny(rel, config.anyActor)) return null;
-  if (actor.kind === 'readonly') return `${actor.label} is read-only; it may not write ${rel}.`;
+  if (actor.kind === 'readonly') return readonlyProblem(actor, rel);
   if (!owns(actor, rel, config)) return ownershipProblem(actor, rel, config);
   const specs = actor.kind === 'lane' && config.docs?.specs;
   return (specs && specCheckProblem(rel, root)) || screenProblem(rel, root, config);
 }
 
+/** A read-only agent's write, refused, with how to undo one a command it ran made (a build, a generator). */
+const readonlyProblem = (actor, rel) =>
+  `${actor.label} is read-only; it may not write ${rel}. If a command you ran changed it (a build, a formatter or a code generator), put it back with git restore -- ${rel} (or delete it if it's new), and run such commands only in a throwaway worktree of the branch.`;
+
 function outsideAllowed(actor, rel, root, config) {
   if (actor.kind !== 'lead') return false;
   const target = resolve(root, rel);

package/hooks/mod/decisions.mjs

@@ -2,6 +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';
 
 /** The kinds of band line that are the person's to decide; the rest are notes. */
 export const DECISION_KINDS = new Set([
@@ -151,7 +152,7 @@ export function decisionCards(lines, context = {}) {
         })),
         doing:
           line.held?.command ??
-          line.request?.what ??
+          (line.request ? askWords(line.request, line.files ?? [line.request.what]) : 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(', ')})` : ''}`

package/hooks/mod/loop.mjs

@@ -14,6 +14,55 @@ const LEAD_STEPS = new Set([
   'update',
 ]);
 
+/** The steps that name stories, which an agent already at work on one shouldn't be asked to start again. */
+const STORY_STEPS = new Set(['dispatch', 'review', 'lead', 'design']);
+const AT_WORK = new Set(['pending', 'running', 'waiting']);
+
+/**
+ * LOOP-9: the stories agents are at work on now, by the task each was started with: a lane agent is
+ * started as "ST-12 booking form", a reviewer as "Review web/st-12". `code-kit next` reads only the
+ * branches, so it can't tell a branch still being built, or already under review, from one waiting.
+ */
+export function storiesInFlight(agents) {
+  const ids = new Set();
+  for (const a of agents ?? []) {
+    if (!AT_WORK.has(a.status)) continue;
+    const text = `${a.description ?? ''}`;
+    for (const m of text.matchAll(/\bST-(\d+)\b/gi)) ids.add(`ST-${m[1]}`);
+    for (const m of text.matchAll(/\b[\w-]+\/st-(\d+)\b/gi)) ids.add(`ST-${m[1]}`);
+  }
+  return ids;
+}
+
+/**
+ * LOOP-9: the step from `code-kit next`, without the stories already in flight. A step left with none
+ * gives way to the next one `next` listed; with nothing left, the loop waits, saying for what, until an
+ * agent finishes (which moves the project on).
+ */
+export function withoutInFlight(step, inFlight) {
+  if (!step || !inFlight?.size) return step;
+  const chain = [step, ...(step.then ?? [])].map(({ then: _then, ...s }) => s);
+  const kept = [];
+  const busy = [];
+  for (const s of chain) {
+    if (!STORY_STEPS.has(s.step)) {
+      kept.push(s);
+      continue;
+    }
+    const ids = (s.args ?? '').split(/\s+/).filter(Boolean);
+    const free = ids.filter((id) => !inFlight.has(id.toUpperCase()));
+    busy.push(...ids.filter((id) => inFlight.has(id.toUpperCase())));
+    if (free.length) kept.push({ ...s, args: free.join(' ') });
+  }
+  if (kept.length) return { ...kept[0], ...(kept.length > 1 ? { then: kept.slice(1) } : {}) };
+  const names = [...new Set(busy)];
+  return {
+    step: 'wait',
+    why: `${names.join(', ')} ${names.length === 1 ? 'is' : 'are'} still with ${names.length === 1 ? 'its agent' : 'their agents'}; the loop goes on when one finishes`,
+    inFlight: names,
+  };
+}
+
 /**
  * The prompt for a step from `code-kit next --json` (LOOP-1), or null when it isn't the lead's to
  * take. Every ready story is named: the dispatch skill decides how many lanes go (LOOP-2). A prompt

package/hooks/mod/register.mjs

@@ -45,7 +45,16 @@ import {
   sendBackPane,
   toolLine,
 } from './panes.mjs';
-import { leadPrompt, nudgeText, restartPrompt, stallDue, stepKey, stepLabel } from './loop.mjs';
+import {
+  leadPrompt,
+  nudgeText,
+  restartPrompt,
+  stallDue,
+  stepKey,
+  stepLabel,
+  storiesInFlight,
+  withoutInFlight,
+} from './loop.mjs';
 import { goalOf, nextText } from './mission.mjs';
 import { contextOf, decisionCards } from './decisions.mjs';
 import { DEFAULT_TEAM_UI, TEAM_ID, teamFrame } from './teamview.mjs';
@@ -790,7 +799,14 @@ export function register(on) {
           return act.submit(prompt, 'restart', story);
         }
         const ran = await $.process.run(['node', cli, 'next', '--json'], { cwd });
-        const step = ran.exitCode === 0 ? parseJson(ran.stdout) : null;
+        // LOOP-9: never a story an agent is already at work on, building or reviewing it.
+        const step =
+          ran.exitCode === 0
+            ? withoutInFlight(
+                parseJson(ran.stdout),
+                storiesInFlight(await $.agent.list().catch(() => [])),
+              )
+            : null;
         // MISSION-1: the band shows what the loop takes next.
         loop.nextStep = step;
         if (!step) {

package/hooks/mod/register.test.ts

@@ -1527,6 +1527,34 @@ test('LOOP-1 and LOOP-2 with the lead idle, the loop dispatches every ready stor
   await ui.unmount();
 });
 
+test('LOOP-9 the loop never asks for a story an agent is still on: it waits, and goes on once the agent finishes', async ($, on) => {
+  const w = project();
+  w.next = { step: 'dispatch', args: 'ST-9', then: [] };
+  const clock = await start($, on, w);
+  await leadTurn($);
+  await settle(clock);
+  expect(w.prompts).toEqual(['Dispatch ST-9: run /code-kit:dispatch ST-9.']);
+  // Dispatched, and ST-4 still being built: next (reading only branches) offers both again.
+  w.agents = [
+    { id: 'a1', type: 'web-engineer', status: 'running', description: 'ST-4 booking form' },
+    { id: 'a2', type: 'core-engineer', status: 'running', description: 'ST-9 pricing' },
+  ];
+  w.next = { step: 'review', args: 'ST-4', then: [{ step: 'dispatch', args: 'ST-9' }] };
+  await leadTurn($, 't-2');
+  await settle(clock);
+  expect(w.prompts).toHaveLength(1);
+  const band = await bandUi($);
+  expect(
+    await band.find({ type: 'Text', text: /waiting: ST-4, ST-9 are still with their agents/ }),
+  ).toBeDefined();
+  await band.unmount();
+  // The web agent finishes: ST-4 is reviewed; ST-9 is still being built, so it isn't dispatched again.
+  w.agents = [{ ...w.agents[0], status: 'completed' }, w.agents[1]];
+  await clock.advance(2000);
+  await settle(clock);
+  expect(w.prompts.slice(1)).toEqual(['Review ST-4: run /code-kit:review ST-4.']);
+});
+
 test('LOOP-1 nothing is submitted mid-turn, or while the person has a draft, or twice for the same step', async ($, on) => {
   const w = project();
   const clock = await start($, on, w);

package/hooks/mod/view.mjs

@@ -630,6 +630,31 @@ export const APPROVE_ID = 'code-kit-approve';
 export const RESULT_ID = 'code-kit-result';
 
 /** An approval name as a person reads it: a dependency approval by its package. */
+/**
+ * CARD-2: open requests as the decisions they are: one per approval and lane, with every file (or
+ * command) it was asked for, newest first. Approving it covers them all.
+ */
+export function approvalAsks(open) {
+  const asks = new Map();
+  for (const r of open ?? []) {
+    const key = `${[...r.names].sort().join(',')}|${r.lane ?? r.actor}`;
+    const ask = asks.get(key) ?? { request: r, files: [] };
+    if (!ask.files.includes(r.what)) ask.files.push(r.what);
+    asks.set(key, ask);
+  }
+  return [...asks.values()];
+}
+
+/** What an approval decision covers, in a line: "contract for the platform lane: a.ts, b.ts (2 files)". */
+export function askWords(request, files = [request?.what]) {
+  const who = request.lane ? `the ${request.lane} lane` : request.actor;
+  const list =
+    files.length > 4
+      ? `${files.slice(0, 4).join(', ')} and ${files.length - 4} more`
+      : files.join(', ');
+  return `${request.names.map(approvalLabel).join(', ')} for ${who}: ${list}${files.length > 1 ? ` (${files.length} files)` : ''}`;
+}
+
 export function approvalLabel(name) {
   return name.startsWith('dep-') ? name.slice(4).replaceAll('+', '/') : name;
 }
@@ -745,12 +770,14 @@ export function bandLines({
       actions: [{ id: 'go', label: 'Go' }],
     });
   // A held call's request is asked on its own line above, not again here.
-  const open = (requests?.open ?? []).filter((r) => !held.some((h) => sameAsk(h, r)));
-  if (open.length)
+  // CARD-2: counted as decisions, not files: one approval for a lane covers every file it was asked for.
+  const asks = approvalAsks((requests?.open ?? []).filter((r) => !held.some((h) => sameAsk(h, r))));
+  if (asks.length)
     lines.push({
       kind: 'approvals',
-      text: `${plural(open.length, 'approval', 'approvals')} waiting`,
-      request: open[0],
+      text: `${plural(asks.length, 'approval', 'approvals')} waiting`,
+      request: asks[0].request,
+      files: asks[0].files,
       actions: [{ id: 'approve', label: 'Approve…' }],
     });
   // DECIDE-1: reviewing a lane's work is the lead's. Only with the loop off, where the person runs the
@@ -1129,12 +1156,13 @@ export function refusalView(card, expanded, { Box, Text, Button }, { onApprove,
 export function approvalsText(requests) {
   const open = requests?.open ?? [];
   const inForce = requests?.inForce ?? [];
+  const history = requests?.history ?? [];
+  const asks = approvalAsks(open);
   const lines = [
-    open.length ? `${plural(open.length, 'request', 'requests')} waiting:` : 'No requests waiting.',
-    ...open.map(
-      (r) =>
-        `  ${r.names.map(approvalLabel).join(', ')} for ${r.lane ? `the ${r.lane} lane` : 'any agent'}: ${r.what}`,
-    ),
+    asks.length
+      ? `${plural(asks.length, 'approval', 'approvals')} waiting:`
+      : 'No requests waiting.',
+    ...asks.map((a) => `  ${askWords(a.request, a.files)}`),
     inForce.length
       ? `${plural(inForce.length, 'approval', 'approvals')} in force:`
       : 'No approvals in force.',
@@ -1142,6 +1170,14 @@ export function approvalsText(requests) {
       (a) =>
         `  ${approvalLabel(a.name)} for ${a.lane ? `the ${a.lane} lane` : 'any agent'}, ${a.minutesLeft} min left: ${a.reason}`,
     ),
+    // CARD-6: what was given, newest first, whether or not its branch has merged.
+    history.length ? 'Approvals given, newest first:' : 'No approvals given yet.',
+    ...history
+      .slice(0, 20)
+      .map(
+        (h) =>
+          `  ${new Date(h.at).toLocaleString('en-AU', { day: 'numeric', month: 'short', hour: '2-digit', minute: '2-digit' })}  ${approvalLabel(h.name)} for ${h.lane ? `the ${h.lane} lane` : 'any agent'}, by ${h.by}${h.files.length ? ` (${h.files.length} file${h.files.length === 1 ? '' : 's'})` : ''}: ${h.reason}`,
+      ),
   ];
   return lines.join('\n');
 }

package/package.json

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

package/skills/dispatch/SKILL.md

@@ -48,7 +48,7 @@ node "${CLAUDE_PLUGIN_ROOT}/bin/code-kit.mjs" team claim ST-<n> --lease "<glob>,
 
 The lease is the paths the story will create or change: its lane's folders for this feature, and any contract it changes. A claim someone else holds is refused with who holds it; pick another story or ask them. Stories in a lane another person owns are theirs to dispatch. Making the story's branch also claims it, and each commit on it adds what it changed to the lease; merging it ends the claim.
 
-Start each story with the Agent tool: `subagent_type` is the lane's agent, `isolation: "worktree"`, and run them in the background. Start every story in the batch in the same message so they run in parallel.
+Start each story with the Agent tool: `subagent_type` is the lane's agent, `isolation: "worktree"`, and run them in the background, with a `description` that starts with the story's id ("ST-12 booking form"): the loop reads it to know the story is in flight, and won't ask for it again while the agent works. Start every story in the batch in the same message so they run in parallel.
 
 The brief is the agent's whole context. Write it so the agent needs nothing else:
 

package/skills/review/SKILL.md

@@ -57,7 +57,7 @@ node "${CLAUDE_PLUGIN_ROOT}/bin/code-kit.mjs" security --base <base> --branch <b
 
 It does when the diff touches sign-in, permissions, input from outside, personal data, encryption, payments, secrets, or queries and commands built from strings, adds dependencies, or the story cites a security requirement; it says which, and where. When it does:
 
-- Run the `security-reviewer` agent (Agent tool, `subagent_type` `security-reviewer`) with the branch, the base, the story, its requirements, the spec files it touches (their `## Threat model` and `## Security requirements`) and the reasons `security` gave. It reads only, and ends with the same findings block as code-kit's reviewer: each finding graded blocker, concern or nit, with where, the attack and the fix.
+- Run the `security-reviewer` agent (Agent tool, `subagent_type` `security-reviewer`, its `description` naming the branch, such as "Security review web/st-12", so the loop knows the story is under review) with the branch, the base, the story, its requirements, the spec files it touches (their `## Threat model` and `## Security requirements`) and the reasons `security` gave. It reads only, and ends with the same findings block as code-kit's reviewer: each finding graded blocker, concern or nit, with where, the attack and the fix.
 - **A blocker fails the review**, like a failing test: the branch goes back to its lane with the finding (where, the attack, the fix). Concerns are yours to weigh: send back the ones the threat model says matter, and put the rest in the report. Nits go in the report.
 - No `security-reviewer` agent in the project: `security` says so. Review the diff yourself against the same list in `${CLAUDE_PLUGIN_ROOT}/templates/security-reviewer.md`, and tell the person that re-running `/code-kit:init` adds the agent.
 - A background reviewer can't start agents: it lists the security review as due, as a concern with the reasons, and the lead runs it.