@warren-dean/code-kit 0.29.0 → 0.30.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -9,7 +9,7 @@
9
9
  "name": "code-kit",
10
10
  "source": "./",
11
11
  "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",
12
- "version": "0.29.0",
12
+ "version": "0.30.1",
13
13
  "category": "development",
14
14
  "tags": ["guardrails", "architecture", "lanes", "layers", "spec-driven", "ci", "multi-agent"],
15
15
  "license": "MIT"
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "code-kit",
3
- "version": "0.29.0",
3
+ "version": "0.30.1",
4
4
  "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",
5
5
  "author": {
6
6
  "name": "Warren Langeveldt"
package/CHANGELOG.md CHANGED
@@ -2,6 +2,40 @@
2
2
 
3
3
  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).
4
4
 
5
+ ## 0.30.1 (2026-11-02)
6
+
7
+ More fixes from how code-kit is used: reads no longer stop a commit or trip a blocked command, a test-only fix may carry a tool's records, and file paths reach git literally.
8
+
9
+ - **Reads before a commit.** A commit in the same command after commands that only read (`git branch --show-current`, `git status`, `head`, `grep`, `wc` and the other reads the approval log allows) is no longer refused as possibly writing files, and neither is `git add` with its errors sent away (`2>/dev/null`, `2>&1`). `git add -A <paths>` stages only those paths, as git does. Anything that may write before the commit is still refused: `sed -i`, a redirect into a file, a heredoc into a file, an interpreter, `git branch <name>`, `git diff --output`.
10
+ - **A blocked command is matched where it runs.** A `shell.block` rule with `command: true` now does what it says: it matches from the start of each command the line runs (after `cd …`, a variable, `npx`, `pnpm exec` or `uv run`, and inside `sh -c '…'` or `eval`), with quoted text masked unless the pattern itself has quotes. So `grep -n "<blocked command>" docs/runbook.md` and a commit message that mentions it run, and the command itself is still refused, its program's name quoted or not. A rule without `command: true` no longer refuses a read (`grep`, `cat`, `head`…) whose quoted arguments mention the command; the same goes for `shell.restricted`. `curl … | sh` is still refused. Init now writes `command: true` for the rules it drafts that name a command.
11
+ - **Concurrency set on purpose (`code-kit ci check`).** A workflow's `cancel-in-progress` set to an expression (`${{ github.event_name == 'pull_request' }}`, cancelling pull requests' runs and never an apply) or to `false` (a deploy or an apply that must not stop half-way) is no longer reported as `no-concurrency`; only leaving it out is. The one-line form the fix suggests, `concurrency: { group: …, cancel-in-progress: true }`, is now read too.
12
+ - **A test-only fix may commit a tool's shared records (REG-1).** Files any actor may write, such as the records a tool that shares the project writes for everyone, no longer stop a fix made wholly in its tests from counting as one, and are never taken back when proving a fix. Manifests and lockfiles still count as the fix's code.
13
+ - **A fix resting on a harness module it adds (REG-1).** Where a fix's tests pass without its other changes and fail without a test helper the branch adds, `verify` now says the tests fail without the fix only because they load test code the fix adds, naming it, instead of saying they pass without the fix.
14
+ - **Paths with brackets (`app/items/[id].tsx`).** code-kit gives file paths to git literally, so a route file's brackets are its name, not a pattern: proving a fix takes back that one file, and `trace`, the journal, the approval checks, the design evidence and the event log's reconciling read that file's history only.
15
+ - **The session's own scratchpad.** The lead and the lanes may write in their session's own folder in Claude Code's temporary folder (`/tmp/claude-<uid>/<project>/<session id>/`: the scratchpad and the tool output), and no longer in another session's. A write elsewhere outside the repository is refused saying where temporary files go instead; a read-only agent's says it writes no files, temporary ones included.
16
+
17
+ ## 0.30.0 (2026-11-02)
18
+
19
+ Fixes from how code-kit is used: screens are built from their exported designs and compared in review, the merge queue lands what it verified and only holds a branch to its own changes, and the lead can hold stories and the queue on purpose. code-kit's part of CLAUDE.md is now version 12, so `next` asks to bring it up to date first.
20
+
21
+ - **A screen waits for its design as files (spec 24, HAND-6).** A register entry that names only an artboard in the design tool no longer lets a lane write the screen: the write is refused, saying the lead hands the design over with `/code-kit:design --hand-over` first. `code-kit next` doesn't dispatch a story that builds such a screen; its step is the hand-over (`design` with `handOver: true`), and the loop asks the lead for it.
22
+ - **The review's comparison is recorded (HAND-7).** The review records the screenshot of each built state it set beside the design: `code-kit designs evidence <story> <screen> <state> <screenshot.png>`, refused unless it's a PNG at the design's viewport. `verify`, and so the merge queue, report each approved state of a lane branch's screens with no screenshot since the screen last changed. In CI, where the review's records aren't, verify says it didn't check them.
23
+ - **Lanes can look at the design tool (HAND-8).** Where the architecture names a design tool with an MCP server, init gives the lanes that build screens, and the QA lane, its read-only tools, with a line saying the exported files in the register are what they build to.
24
+ - **A screen name means one screen (HAND-9).** A register entry's screen is matched only to the spec screen of exactly that name: a `###` or `####` heading, a `- **Name**` bullet, or a table row under `## Screens`, whose States column now counts. A name two screens share is reported as ambiguous, instead of one getting the other's states.
25
+ - **A design story stays in progress until its screens are designed (HAND-10).** Committing the first approved screen on `design/st-<n>` no longer sends the story to review: it's in progress while a screen it designs (its plan's `**Screens:**` line, or its specs' screens) isn't in the branch's register, or until the plan says `review`.
26
+ - **Merging the base into a branch (HAND-11).** The commit hook and `verify` hold a branch only to the register entries it adds or changes, so a lane merging the base isn't refused for the base's designs that are still only in the tool.
27
+ - **What counts as a test is one rule (spec 18).** Every check that asks now agrees: a file named as a test (`*.test.*`, `*.spec.*`, `*.smoke.*`, `test_*.py`, `*_test.go`, `*_test.py`) or in a test folder (`test/`, `tests/`, `__tests__/`, `e2e/`, `smoke/`), or your `tests` globs where the config has them. A fix whose tests are smoke scripts is no longer refused as bringing no test.
28
+ - **A fix's proof takes test helpers back too (REG-1).** Proving a fix keeps only the files named as tests and takes everything else back to the base, helpers and harness modules in test folders included, so a fix made in a test harness is no longer reported as "its tests pass without the fix". A helper the branch adds stays, for its tests to load. A fix made wholly in test files still passes as before.
29
+ - **The person's approval after the lead's commit (WHO-1).** Where the lead merges and the person approves a protected change the lead already committed, the lead no longer has to touch the file again. With their approval in force, the lead's next commit (`git commit -m "Record the person's <approval> approval for <file>"`, nothing staged) records the approval in the log for the file as the branch holds it, by its content's hash, and `verify` accepts it while the file is unchanged. `verify`'s refusal says exactly what to run.
30
+ - **Reading the approval log through the shell.** Read-only forms are allowed: a `cd` first, `2>&1` or a redirect into `/dev/null`, and `cat`, `head`, `tail`, `grep`, `wc`, `jq`, `cut`, `sort`, `uniq`, `awk` and `sed -n` printing lines, alone or piped from git's `diff`, `log`, `show` and `blame`. Anything that could write it is still refused: redirects into a file, `tee`, `sed -i`, `cp`, `mv`, editors, interpreters, a command's output in its arguments, and variables set before a command. The refusal lists the allowed forms.
31
+ - **A merge run from inside a lane's worktree is recorded.** Running `code-kit queue merge` from the worktree of the branch it merges used to remove that worktree, and with it the way back to the queue: the branch stayed queued, and the next `queue merge` verified it again against the base it was already in. Every queue command now finds the main checkout first, and the merge keeps the worktree it's run from (it goes at the next merge), saying so.
32
+ - **A queued branch the base already holds leaves the queue as merged.** It's never verified again, so a fix branch already merged is no longer sent back as "a fix that adds no test". `code-kit merge <branch>` says the same.
33
+ - **The merge queue checks with installs that match the merged tree.** It copies the base's checkout's installs (the main checkout's), not the branch worktree's, which could be far behind the base or have none. Where the merged tree's manifests or lockfiles differ from them, it installs in its own checkout first, with `regression.prepare` if set, else the install the lockfile calls for (pnpm, npm, yarn, bun or uv); an install that fails there keeps the branch in its place instead of sending it back. Where code-kit knows no install for what differs, the merge says which installs it used and that they may not match.
34
+ - **A tool pnpm can't find is named as not installed.** `pnpm exec` exits 254 with `Command "tsc" not found` after a stray `undefined` line; that's now read like a missing command (skipped and named, or failed where the check sets `"ifMissing": "fail"`), and the `undefined` line is left out of what a failed check shows.
35
+ - **A merge group's lane branch built on its lead partner's isn't blamed for the lead's files.** Each member of a `--with` group is held to its own lane's paths for its own changes, measured against the base merged with its partners.
36
+ - **A busy main checkout no longer fails a merge at the end.** Only uncommitted changes to files the merge changes stop it, and it looks before the verify as well as after; other tools' changes to other files there are carried as they are.
37
+ - **Holding on purpose.** `code-kit defer <story>… --reason "…" [--until <date or time>]` holds stories: `next`, the loop and the merge queue don't dispatch, review or merge them until then, or until `code-kit defer release <story>`, so the lead isn't asked about them every half hour. `code-kit queue pause --reason "…"` and `code-kit queue resume` hold the whole merge queue. `next` lists each hold with its reason, `queue` shows them, and the band shows them as notes with no Merge or Review. code-kit's part of CLAUDE.md tells the lead about both, so `code-kit next` asks for it to be brought up to date.
38
+
5
39
  ## 0.29.0 (2026-10-31)
6
40
 
7
41
  A team provider's drift findings can hold a merge, and what a project reports covers models, security reviews, intents' pull requests and claims (report version 6).
package/README.md CHANGED
@@ -54,7 +54,7 @@ code-kit catches each of these, most at the moment it would happen: the hook ref
54
54
  - **Layers:** each layer depends only on the layers it lists, and never on packages it's denied, for JavaScript and TypeScript imports. An edit that would add a violation is refused before it's written; the rules are checked again after each edit and before finishing, which is what catches a file a shell command wrote. In brownfield code, existing violations can be recorded in a baseline so only new ones block. Imports are found by pattern, not by parsing: see [the limits](#what-verify-proves-and-its-limits).
55
55
  - **Protected paths and the approval log:** every committed change to the kit, registers or contracts is appended to `.claude/approval-log.jsonl`, in the same commit. Only the lead writes these paths without an approval, and the person reviews them in the pull request. A lane needs an approval: the lead's for what `approvals.delegate` gives it, otherwise the person's.
56
56
  - **Spec-check before code:** when the project has specs, a lane can't write code on a branch until it has saved a spec-check report for that branch. The hook checks that the report exists; review checks what it says.
57
- - **Designs before screens** (optional): a screen file can't be written until the design register lists it.
57
+ - **Designs before screens** (optional): a screen file can't be written until the design register holds its approved design as files, every state exported from the design tool; the review records its screenshot of each built state beside the design, and verify checks it did.
58
58
  - **Shell rules**, matched against the command's text before it runs:
59
59
  - no force-push, pushing to or committing on protected branches, `--no-verify`, destructive deletes, or piping downloads into a shell;
60
60
  - no new dependency without an approval, for that package and that lane: the lead's, for a story it judged needs it, where dependencies are delegated, otherwise a person's; the approval also covers the manifest and lockfile changes the install makes;
@@ -335,6 +335,7 @@ The loop keeps the build moving between your prompts, under `harness.autonomy`.
335
335
  - **Each step.** Once the lead has finished a turn, with the lead idle and nothing typed in the prompt, the loop asks `code-kit next` and prompts the lead to dispatch the ready stories, review a finished one, or build its own. It never prompts 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").
336
336
  - **It reads the lead's reply first.** Before prompting again, the loop reads the lead's last reply with a side call over the lead's own conversation. A reply that waits on you (a question, a design to look at, an approval), or a turn you stopped, holds the loop until you answer or speak to the lead: the band says what the lead waits on, and its question is asked in Claude Code's own question dialog. A step the lead didn't take shows in the band as a note, with its reason and **Ask again**.
337
337
  - **Stories waiting on other work.** When the lead says a story isn't due yet because it waits on work still going (a paired story a lane is building, a rebuild, a check running), the loop parks that story and leaves it out of every step, so a step naming it with others prompts only the others. It wakes when its own branch or state moves, or when a story it waits on (one the lead named, or an unfinished one building on it) changes state; that story's commits along the way don't wake it, nor do other lanes'. A story the lead's turn left exactly where it stood is parked too, whatever the reply said. After 30 minutes with nothing moving, the lead is asked once more.
338
+ - **Holding on purpose.** A story the lead means to leave alone for a while (it waits on something outside the build, or on a date) is held with `code-kit defer <story> --reason "…" [--until <date>]`: `next`, the loop and the merge queue don't dispatch, review or merge it until then, or until `code-kit defer release <story>`, and it isn't asked about again in the meantime. `code-kit queue pause --reason "…"` holds the whole merge queue the same way, until `code-kit queue resume`. `next` lists each hold with its reason, and the band shows them as notes.
338
339
  - **A step that doesn't move.** One the lead was prompted with three times in a row that is still next shows as a note, not a decision: "Merge lead/st-1: still next after 3 prompts to the lead", with **Ask again** if you want it.
339
340
  - **A lean lead.** A lane writes its full report, with its commands and their output, to `.claude/state/reports/<branch>.md`, and hands the lead a few lines naming it; the stop hook won't let a lane on a story branch finish without it, or with a hand-back of more than ten lines, and the lead reads the file when it reviews. Lanes don't message the lead while they work. When a milestone finishes, the lead's context is compacted before the next one (`harness.compact.milestone`: you're asked by default, or it's done at once): the summary keeps what's in flight and what waits on you, and drops the finished stories' detail.
340
341
  - **Token use.** A long-lived agent rereads its whole context on every request, which is most of what a build costs. So each lane agent builds one story; one past `agents.lanes.contextLimit` is told to wrap up, and the lead carries its story on with a fresh agent that reads its report (`code-kit worktrees release` frees the branch). The lead's context is compacted between turns once it's past `compact.at`. The loop reads the lead's replies with Sonnet, and the reviewers run on Sonnet by default.
@@ -465,6 +466,7 @@ code-kit instructions [--write] [--json] | instructions show lead|lane [<lane>]
465
466
  code-kit standards [--json] [--for <path>...] # the project's standards with any its organisation's provider supplies, and what's wrong with them; --for keeps the ones for those files' layers
466
467
  code-kit trace <path>... [--json] # what a file is for: requirements, lane, layer rules
467
468
  code-kit designs [<story>] [--json] # the approved designs: a story's screens' files, every state, or each entry and what's wrong with it
469
+ code-kit designs evidence <story> <screen file or name> <state> <screenshot.png> # the review records its screenshot of a built state, at the design's viewport, beside its design
468
470
  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
469
471
  code-kit publish --delegated|--person # put what's merged into the base onto the remote's, as branches.publish says
470
472
  code-kit replay <story> [--json|--brief] # a story's state rebuilt from its event log: its phase, last commit, tests, what's left open
@@ -493,7 +495,10 @@ code-kit queue [--json] # the merge queue:
493
495
  code-kit queue add|drop <branch> # the lead queues a branch at the commit its review passed, or takes it out
494
496
  code-kit queue add <branch> --with <branch>[,<branch>] # a branch that only lands together with others: merged as a group once all are queued
495
497
  code-kit queue rules # the lead puts the approved rules onto a base that has none yet (a project set up before 0.8.0)
496
- code-kit queue merge --delegated|--person # merge the head at the commit its review passed, verified against the base as it is now; a conflict or failed verify sends it back to its lane, a branch that moved since its review leaves the queue to be reviewed again, and one a team provider's open drift finding holds waits in its place until the finding clears
498
+ code-kit queue merge --delegated|--person # merge the head at the commit its review passed, verified against the base as it is now; a conflict or failed verify sends it back to its lane, a branch that moved since its review leaves the queue to be reviewed again, one the base already holds leaves it as merged, and one a team provider's open drift finding holds waits in its place until the finding clears
499
+ code-kit queue pause --reason "…" | queue resume # the lead holds the whole queue on purpose: nothing merges and nothing offers a merge until it resumes; branches are still queued
500
+ code-kit defer <story>... --reason "…" [--until <date|time>] # the lead holds stories on purpose: next, the loop and the queue don't dispatch, review or merge them until the date or time, or until released
501
+ code-kit defer release <story>... | defer [--json] # let held stories go on; list the holds in force
497
502
  code-kit loop [--json] # whether the person paused the lead loop; other tools' background work pauses with it
498
503
  code-kit loop pause|resume # the person's act, as Pause and Resume in the band
499
504
  code-kit loop lead|release --session <id> [--take] # which session runs the loop: the mod's, and Lead from here in the band
@@ -534,18 +539,18 @@ code-kit approve <name>... --reason "…" [--lane name] [--delegated [--story ST
534
539
  | `docs.decisions` | no | Where agreed intents are recorded as numbered decision records (`code-kit intend record`); default `docs/decisions` |
535
540
  | `docs.standards` | no | The project's standards (spec 22), default `docs/standards.md`: each a `### <id> <title>` heading with `level` (required or recommended), `applied` (enforced, checked or advice), `layers`, `why`, `source` and, when enforced, `enforced by` naming the layer rule, protected path, check or shell rule that refuses a breach. The id's prefix is its category: `PRI-` principles, `PAT-` patterns, `ARC-` architecture, `CON-` conventions, `POL-` policies. Each lane agent is given the ones for its layers; a refusal from an enforcing rule names the standard; reviews check the checked ones. Protect the file with the `standards` approval: removing a standard, or weakening a required one, always needs the person's, whatever is delegated |
536
541
  | `lead.paths` | yes | What the main session writes. `.claude/**` and `.mcp.json` are always added. |
537
- | `lead.outside` | no | Paths outside the repository the lead may write, e.g. `../shared-lib/**`. Claude's memory and scratchpad are always included. |
542
+ | `lead.outside` | no | Paths outside the repository the lead may write, e.g. `../shared-lib/**`. Claude's memory is always included, and the session's own folder in Claude Code's temporary folder (`/tmp/claude-<uid>/<project>/<session id>/`: its scratchpad and tool output), which the lanes may write too; another session's isn't. |
538
543
  | `anyActor` | no | Paths every writer may change (e.g. the lockfile), read-only agents included. `.claude/state/**` is always included. An entry may be `{ "glob", "reviewer" }` to name the lane (or `"lead"`) that reviews changes to it; otherwise the lead reviews them, and `who` and `trace` say so. |
539
544
  | `lanes.<name>` | yes (may be `{}`) | `{ agent, paths, exclude?, owners?, label? }`: the agent name maps a subagent to its lane; `label` names what the lane delivers ("Screens", "API contract"; one line, at most 60 characters), for a team provider's report, and is otherwise taken from the lane's name; `owners` (GitHub handles) are the people whose sessions work it, in a team (needs `team`). A worktree with a `.lane` file holding the lane name makes the main session that lane. |
540
545
  | `protected[]` | no | `{ glob, approval, why }`: logged on every commit. Anyone but the lead needs an approval: the lead's where `approvals.delegate.protected` names it, otherwise a person's (see [Approvals](#approvals)). `.claude/**` is always protected as `kit`. |
541
- | `designGate` | no | `{ register, screens: [{ glob, not? }], howTo }`: screen files wait until the register (`{ "screens": [{ "file": … }] }`) lists them. Init sets it for every lane that owns screens; `/code-kit:design` adds approved designs |
546
+ | `designGate` | no | `{ register, screens: [{ glob, not? }], howTo }`: screen files wait until the register (`{ "screens": [{ "file": … }] }`) holds their exported designs; an entry naming only a design tool's artboard doesn't open the gate. Init sets it for every lane that owns screens; `/code-kit:design` adds approved designs |
542
547
  | `layers[]` | no | `{ name, paths, mayImport, denyPackages?, label? }`: the first layer whose paths match a file owns it. A layer may always import itself. `label` names what the layer delivers ("Data", "Service"; one line, at most 60 characters), for a team provider's report, and is otherwise taken from the layer's name. |
543
548
  | `importAliases` | no | `{ "@app/domain": "packages/domain/src" }`: resolves non-relative imports to repository paths |
544
- | `shell.block[]` | no | `{ pattern, why, person?, command? }`: never run. `person: true` marks a person's act, which the lead may do for them with `approvals.lead` on. `command: true` matches the pattern from the start of each command the line runs, so a heredoc or quoted text that mentions it isn't refused |
545
- | `shell.restricted[]` | no | `{ pattern, lanes, why }`: only the lead and these lanes |
549
+ | `shell.block[]` | no | `{ pattern, why, person?, command? }`: never run. `person: true` marks a person's act, which the lead may do for them with `approvals.lead` on. `command: true` matches the pattern from the start of each command the line runs (after a package runner such as `npx` or `pnpm exec`, and inside `sh -c` or `eval`), with quoted text masked unless the pattern has quotes, so a grep, a heredoc or a message that mentions it isn't refused. Without it the pattern reads the whole line, except a read's quoted arguments: `grep "<command>" docs` doesn't run it |
550
+ | `shell.restricted[]` | no | `{ pattern, lanes, why }`: only the lead and these lanes. A read's quoted arguments don't count, as for `shell.block` |
546
551
  | `postEdit[]` | no | `{ files, exclude?, run }`: after each edit of a matching file. `{file}` is the file. Exit 127 (tool not installed) is skipped. |
547
- | `tests[]` | no | Globs naming the test files, for the weakened-test and fix rules. Default: the usual conventions (`*.test.*`, `*.spec.*`, `__tests__/`, `test/`, `tests/`, `e2e/`, `*_test.go`, `test_*.py`). |
548
- | `regression.prepare` | no | A command run in a fresh checkout before a fix's tests run there without the fix, such as `npm ci`. The checkout's `node_modules` and virtualenvs are copied in first (a copy-on-write clone where the disk has one), so it can't change the checkout's own. |
552
+ | `tests[]` | no | Globs naming the test files, in place of the conventions, for every rule that asks what a test is: weakened tests, a fix's tests, the tests that name a requirement, the code map and the security review. Default: a file named as a test (`*.test.*`, `*.spec.*`, `*.smoke.*`, `test_*.py`, `*_test.go`, `*_test.py`) or in a test folder (`test/`, `tests/`, `__tests__/`, `e2e/`, `smoke/`). Proving a fix keeps the files named as tests and takes the rest back, test-folder helpers included; with `tests` set, the files it names are the ones kept. |
553
+ | `regression.prepare` | no | A command run in a fresh checkout before a fix's tests run there without the fix, such as `npm ci`. The checkout's `node_modules` and virtualenvs are copied in first (a copy-on-write clone where the disk has one), so it can't change the checkout's own. The merge queue runs it too, in the merged tree's checkout, when its manifests or lockfiles differ from the installs copied in; without it, the queue runs the install the lockfile calls for. |
549
554
  | `checks[]` | no | `{ name, files, exclude?, run[], each?, owners?, ifMissing?, timeoutSeconds? }`: before finishing, when matching files changed. `each` runs the commands in every changed folder matching that glob. `owners` limits who may change the files (the lead always may). `ifMissing: "fail"` makes a missing tool an error (the default is to skip the check, which `verify` and a merge list as not run). `timeoutSeconds` (240 unless set) is how long each command may run; one that runs out of time leaves its branch at the head of the merge queue rather than sending it back. |
550
555
  | `adapters` | no | `{ "<adapter>": false }` switches off an adapter that would otherwise be detected; `true` says the project wants that tool, so until it's set up here `next` gives its setup before any code. See [Adapters](#adapters). |
551
556
  | `approvals.lead` | no | `true` lets the lead act on what the person says in chat, for when `!` isn't available (on a phone, say): it records their approvals with `code-kit approve`, and runs `shell.block` commands marked `person`. Default `false`. See [Approvals](#approvals). |
@@ -617,7 +622,9 @@ code-kit approve pillow --lane api --delegated --story ST-138 --reason "MED-5 ne
617
622
  - **Who:** only the lead. With `"approvals": { "delegate": false }`, `--delegated` is refused, and every approval is yours.
618
623
  - **Weakened tests:** with `"tests": true` (the default), the lead approves a weakened test on a lane's branch for the story it reviewed, with `--lane` and `--story`; on its own branches it's yours.
619
624
  - **Merges:** with `"merge": true`, the lead merges a reviewed branch into a protected branch with `code-kit merge <branch> --delegated`.
620
- - It runs `code-kit verify` on the branch first, checks included, and merges only if it passes. The checks run where the branch is checked out; in a temporary worktree without the project's install, checks that need one fail rather than being skipped.
625
+ - It runs `code-kit verify` on the branch first, checks included, and merges only if it passes. The checks run on the branch merged with the base, in a fresh checkout with a copy of the base's checkout's installs (`node_modules`, virtualenvs). Where the merged tree's manifests or lockfiles differ from them, the install runs in that checkout first: `regression.prepare` if set, else the one its lockfile calls for (pnpm, npm, yarn, bun, uv). An install that fails there keeps the branch in its place in the queue; where code-kit knows no install, the merge says the installs it used may not match. A branch the base already holds is merged already: it leaves the queue as merged, never verified again.
626
+ - Only uncommitted changes to files the merge changes stop it, in the base's checkout; it checks before the verify and again after. Other changes there, such as a log another tool appends to each turn, are carried as they are.
627
+ - Run from inside the lane's worktree, the merge keeps that worktree (the shell is in it); it goes at the next merge.
621
628
  - The merge commit says it was verified and delegated.
622
629
  - Committing or merging on a protected branch with git stays blocked for every actor, the lead included, as does switching to one and committing in the same command.
623
630