@warren-dean/code-kit 0.3.6 → 0.3.7

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.3.6",
+      "version": "0.3.7",
       "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.3.6",
+  "version": "0.3.7",
   "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/README.md

@@ -309,6 +309,7 @@ code-kit verify [--base ref] [--branch name] [--no-checks]  # a branch's changes
 code-kit status [--base ref] [--json]  # stories and requirements against the spec
 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 approve <name>... --reason "…" [--lane name]  # record approvals a person gave in chat
 ```
 
 `verify` compares the branch with where it left `--base` (default `origin/main`, then `main`). A branch named `<lane>/…`, or given as `--branch`, is held to that lane. `--no-checks` leaves the project's checks to CI's own steps. `status` reads `docs.specs` and `docs.plan`.
@@ -330,11 +331,12 @@ code-kit trace <path>... [--json]      # what a file is for: requirements, lane,
 | `designGate`                   | no                | `{ register, screens: [{ glob, not? }], howTo }`: screen files wait until the register (`{ "screens": [{ "file": … }] }`) lists them                                                                                                                                                                                                             |
 | `layers[]`                     | no                | `{ name, paths, mayImport, denyPackages? }`: the first layer whose paths match a file owns it. A layer may always import itself.                                                                                                                                                                                                                 |
 | `importAliases`                | no                | `{ "@app/domain": "packages/domain/src" }`: resolves non-relative imports to repository paths                                                                                                                                                                                                                                                    |
-| `shell.block[]`                | no                | `{ pattern, why }`: never run                                                                                                                                                                                                                                                                                                                    |
+| `shell.block[]`                | no                | `{ pattern, why, person? }`: never run. `person: true` marks a person's act, which the lead may do for them with `approvals.lead` on                                                                                                                                                                                                             |
 | `shell.restricted[]`           | no                | `{ pattern, lanes, why }`: only the lead and these lanes                                                                                                                                                                                                                                                                                         |
 | `postEdit[]`                   | no                | `{ files, exclude?, run }`: after each edit of a matching file. `{file}` is the file. Exit 127 (tool not installed) is skipped.                                                                                                                                                                                                                  |
 | `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). |
 | `adapters`                     | no                | `{ "<adapter>": false }` switches off an adapter that would otherwise be detected. See [Adapters](#adapters).                                                                                                                                                                                                                                    |
+| `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).                                                                                     |
 | `branches.protected`           | no                | Default `["main", "master"]`                                                                                                                                                                                                                                                                                                                     |
 
 Add `.claude/approvals/`, `.claude/state/` and `.claude/code-kit.draft.json` to `.gitignore`, and `.claude/approval-log.jsonl merge=union` to `.gitattributes`, so merging branches that both logged changes keeps every entry. Commit `.claude/code-kit.baseline.json` if the project has one.
@@ -354,6 +356,20 @@ echo "Date formatting for ST-12" > .claude/approvals/web/dep-dayjs             #
 - **Worktrees:** approvals live in the main checkout, so a lane working in its own worktree sees the ones given at the lead's terminal.
 - **Lifetime:** 60 minutes. Agents can't create, edit or even mention approvals or the log.
 
+### From chat
+
+On a phone, or anywhere the `!` prefix arrives as plain text, a person can't run the command. With `"approvals": { "lead": true }` in the config (init asks), the person says what they approve in chat, and the lead records it:
+
+```bash
+code-kit approve dep-dayjs --lane web --reason "Yes, add dayjs for ST-12"
+```
+
+- It writes the same approval a `!` command would, for the same 60 minutes, with `(given in chat, recorded by the lead)` after the reason, so the log shows how it was given.
+- Only the lead may run it. A lane or read-only agent is refused, and so is the lead while the setting is off or the config is invalid.
+- With the setting on, refusals name this command alongside the `!` one.
+- The lead may also run `shell.block` commands marked `person: true`, such as Context Graph's ratification trailer.
+- It trusts the lead to act only on the person's own words. Leave it off when the lead runs without a person watching.
+
 ## Adapters
 
 Other tools share a project with code-kit and keep files of their own. An adapter tells code-kit about one such tool, without the core knowing its name. Each adapter lives in `hooks/lib/adapters/`, and declares:
@@ -364,9 +380,9 @@ Other tools share a project with code-kit and keep files of their own. An adapte
 
 While the tool is detected, its additions are merged into the effective config, like the kit's own defaults. Run `code-kit adapters` to see them, or switch one off with `"adapters": { "<name>": false }`.
 
-| Adapter         | Detected by | Adds                                                                                                                                                                                                                                                                                   |
-| --------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `context-graph` | `.ctx/`     | `.ctx/**` for the lead. `.ctx/decisions.ctx` and `.ctx/cards.ctx` for any actor, since every agent records decisions and file cards. `graph.ctx` and `config.toml` are protected (approval `ctx`). No Claude actor may write a `Ctx-Ratified-By` trailer: ratifying is a person's act. |
+| Adapter         | Detected by | Adds                                                                                                                                                                                                                                                                                                                                                                |
+| --------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `context-graph` | `.ctx/`     | `.ctx/**` for the lead. `.ctx/decisions.ctx` and `.ctx/cards.ctx` for any actor, since every agent records decisions and file cards. `graph.ctx` and `config.toml` are protected (approval `ctx`). No Claude actor may write a `Ctx-Ratified-By` trailer: ratifying is a person's act (with `approvals.lead`, the lead may add it when the person says so in chat). |
 
 Its setup:
 

package/bin/code-kit.mjs

@@ -14,6 +14,8 @@
 //   trace <path> [--json] what a file is for: the requirements it delivers, its lane, its layer rules
 //   next [--base ref] [--json]
 //                         the step to take now (spec-design, init, dispatch, review…), from the project's state
+//   approve <name>... --reason "…" [--lane name]
+//                         record approvals a person gave in chat (with approvals.lead on, the lead runs it)
 // --config <file> reads a draft (.claude/code-kit.draft.json) instead of .claude/code-kit.json.
 import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
@@ -26,7 +28,7 @@ import { ADAPTERS, activeAdapters } from '../hooks/lib/adapters/index.mjs';
 import { nextStep } from '../hooks/lib/next.mjs';
 import { traceFile } from '../hooks/lib/trace.mjs';
 import { buildStatus } from '../hooks/lib/plan.mjs';
-import { currentBranch, ownerOf } from '../hooks/lib/rules.mjs';
+import { APPROVAL_MINUTES, currentBranch, grantApprovals, ownerOf } from '../hooks/lib/rules.mjs';
 import { laneOfBranch, verifyBranch } from '../hooks/lib/verify.mjs';
 
 const out = (s) => process.stdout.write(`${s}\n`);
@@ -44,6 +46,8 @@ const file = option('--config') ?? CONFIG_FILE;
 const depth = Number(option('--depth') ?? 2);
 const baseRef = option('--base');
 const branchName = option('--branch');
+const reason = option('--reason');
+const laneName = option('--lane');
 const FLAGS = ['--write', '--no-checks', '--json'];
 const flag = (name) => args.includes(name);
 const writeBaseline = flag('--write');
@@ -375,8 +379,27 @@ function trace(paths) {
   }
 }
 
+// Each name is an approval a refusal named: a protected path's, `kit`, or `dep-<package>`.
+function approve(names) {
+  const { config } = load();
+  if (!reason?.trim()) die('approve needs --reason "<what the person approved, in their words>".');
+  if (laneName !== undefined && !config.lanes[laneName])
+    die(`There is no lane "${laneName}". Lanes: ${Object.keys(config.lanes).join(', ')}.`);
+  const bad = names.filter((n) => !/^[a-z0-9@][a-z0-9@+._-]*$/.test(n));
+  if (bad.length)
+    die(
+      `Not an approval name: ${bad.join(', ')}. Use the name the refusal gave, e.g. kit or dep-zod.`,
+    );
+  grantApprovals(resolve('.'), names, laneName, reason);
+  const whom = laneName ? `the ${laneName} lane` : 'any agent';
+  out(
+    `Approved ${names.join(', ')} for ${whom}, for ${APPROVAL_MINUTES} minutes: ${reason.trim()}`,
+  );
+}
+
 const commands = {
   check,
+  approve: () => (rest.length ? approve(rest) : usage()),
   trace: () => (rest.length ? trace(rest) : usage()),
   adapters,
   next,
@@ -392,7 +415,8 @@ function usage() {
   die(
     'Usage: code-kit check | who <path>... | unowned | diff | baseline [--write] | graph [--depth N]\n' +
       '              | verify [--base ref] [--branch name] [--no-checks] | status [--base ref] [--json]\n' +
-      '              | next [--base ref] [--json] | adapters | trace <path>... [--json]   [--config file]',
+      '              | next [--base ref] [--json] | adapters | trace <path>... [--json]\n' +
+      '              | approve <name>... --reason "…" [--lane name]   [--config file]',
   );
 }
 (commands[command] ?? usage)();

package/hooks/guard-bash.mjs

@@ -3,7 +3,8 @@
 // dependencies a person hasn't approved, approval forgery, kit edits through the shell by anyone but
 // the lead, the project's own blocked and lane-restricted commands; records protected files in the
 // approval log on commit and scans commits for secrets. Shell writes are also checked afterwards by
-// lane-audit.mjs.
+// lane-audit.mjs. With `approvals.lead` on, the lead may act for the person on what they say in chat:
+// record their approvals (`code-kit approve`) and run blocked commands marked `person`.
 import { appendFileSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { join, resolve } from 'node:path';
@@ -43,8 +44,10 @@ for (const [re, why] of ALWAYS) {
   if (re.test(cmd)) block(`Blocked: ${why}\nCommand: ${cmd}`);
 }
 const packages = addedPackages(cmd);
+const approves = /\bcode-kit(\.mjs)?["']?\s+approve\b/.test(cmd);
 if (error) {
   if (/\bgit\s+commit\b/.test(cmd)) block(`Blocked: ${error}\nFix the config before committing.`);
+  if (approves) block(`Blocked: ${error}\nApprovals wait until the config is valid.`);
   if (packages.length)
     block(`Blocked: ${error}\nNew dependencies wait until the config is valid.\nCommand: ${cmd}`);
   process.exit(0);
@@ -58,12 +61,29 @@ if (new RegExp(`\\bgit\\s+push\\b.*\\b(${branches})\\b`).test(cmd)) {
     `Blocked: push to your own branch; a person merges to ${config.branches.protected[0]} after review.\nCommand: ${cmd}`,
   );
 }
-for (const { pattern, why } of config.shell.block) {
-  if (new RegExp(pattern).test(cmd)) block(`Blocked: ${why}\nCommand: ${cmd}`);
-}
 
 const sessionIn = sessionRoot(input, project);
 const actor = actorFor(input, sessionIn ?? project, config);
+// The lead acts for the person only where the config says the person may approve from chat.
+const forPerson = actor.kind === 'lead' && config.approvals.lead;
+
+for (const { pattern, why, person } of config.shell.block) {
+  if (!new RegExp(pattern).test(cmd) || (person && forPerson)) continue;
+  const hint =
+    person && actor.kind === 'lead'
+      ? '\nTo let the lead run it when the person says so in chat, a person sets "approvals": { "lead": true } in the config.'
+      : '';
+  block(`Blocked: ${why}${hint}\nCommand: ${cmd}`);
+}
+
+if (approves && actor.kind !== 'lead')
+  block(
+    `Blocked: only the lead records an approval a person gives in chat. Write a short change request for the lead (what needs approving, and why), and stop.\nCommand: ${cmd}`,
+  );
+if (approves && !forPerson)
+  block(
+    `Blocked: this project doesn't let the lead record approvals ("approvals.lead" is off). Ask the person to run the \`!\` command from the refusal, or to turn "approvals": { "lead": true } on in the config.\nCommand: ${cmd}`,
+  );
 
 // Each new package needs a person's approval, for this actor; it also covers the manifest and lockfile
 // changes the install makes (lib/rules.mjs › dependencyChange).
@@ -84,6 +104,7 @@ if (packages.length) {
         actor,
         sessionIn ?? project,
         'installing it, and the manifest and lockfile changes that makes,',
+        config,
       )}\nCommand: ${cmd}`,
     );
   }
@@ -127,7 +148,7 @@ const writes =
   );
 if (touchesKit && writes && actor.kind !== 'lead' && !approval(root, 'kit', actor)) {
   block(
-    `Blocked: the .claude kit is changed only by the lead or with a person's approval. Ask the lead to run\n${approvalHowTo('kit', actor, root)}`,
+    `Blocked: the .claude kit is changed only by the lead or with a person's approval. Ask the lead to run\n${approvalHowTo('kit', actor, root, undefined, config)}`,
   );
 }
 
@@ -179,7 +200,7 @@ function recordApprovals() {
     const byDependency = actor.kind === 'lane' && dependencyChange(actor, file, root, config);
     if (entry && !granted && actor.kind !== 'lead' && !byDependency) {
       block(
-        `Blocked: ${file} is ${entry.why}; committing it needs a person's approval in force. Ask the lead to run\n${approvalHowTo(entry.approval, actor, root)}`,
+        `Blocked: ${file} is ${entry.why}; committing it needs a person's approval in force. Ask the lead to run\n${approvalHowTo(entry.approval, actor, root, undefined, config)}`,
       );
     }
     if (granted)

package/hooks/lib/adapters/context-graph.mjs

@@ -3,7 +3,8 @@
 // each file's card (its why) in cards.ctx. Every agent records decisions and cards for the files it
 // edits, so those two files are writable by any actor; the rules and settings
 // are the lead's, and changes to them go through the approval log. Ratifying a rule is a person's act,
-// signed with a commit trailer, so no Claude actor may write that trailer.
+// signed with a commit trailer, so no Claude actor may write that trailer, unless the project lets the
+// lead act on what the person says in chat (`approvals.lead`).
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 
@@ -23,6 +24,7 @@ export default {
       {
         pattern: 'Ctx-Ratified-By\\s*[:=]',
         why: "Ratifying a Context Graph rule is a person's act: they add the Ctx-Ratified-By trailer themselves, with a `!` git command.",
+        person: true,
       },
     ],
   },

package/hooks/lib/adapters/index.mjs

@@ -4,7 +4,8 @@
 //   name      the tool, and the key that switches it off in the config: "adapters": { "<name>": false }
 //   detect    (root) => true when the tool is in use in this project
 //   config    { lead?, anyActor?, protected? } merged into the effective config, like the kit's defaults
-//   shell     { block? } commands refused for every Claude actor, merged into shell.block
+//   shell     { block? } commands refused for every Claude actor, merged into shell.block; `person: true`
+//             marks a person's act the lead may do for them under approvals.lead
 //   setup     lines for init to apply or tell the person: ignore files, merge drivers, instructions
 //
 // The core only ever calls applyAdapters() and activeAdapters(); it never names a tool.

package/hooks/lib/config.mjs

@@ -47,6 +47,7 @@ export function withDefaults(c) {
     postEdit: c.postEdit ?? [],
     checks: c.checks ?? [],
     branches: { protected: c.branches?.protected ?? ['main', 'master'] },
+    approvals: { lead: c.approvals?.lead === true },
   };
 }
 
@@ -114,6 +115,11 @@ export function validate(c) {
         Object.entries(c.adapters).every(([k, v]) => known.includes(k) && typeof v === 'boolean')),
     `"adapters" must map adapter names (${known.join(', ')}) to true or false`,
   );
+  need(
+    c.approvals === undefined ||
+      (isObj(c.approvals) && [undefined, true, false].includes(c.approvals.lead)),
+    '"approvals.lead" must be true or false',
+  );
   need(
     c.branches === undefined || isList(c.branches?.protected),
     '"branches.protected" must be a list of branch names',
@@ -176,9 +182,10 @@ function validateLayers(c, need, each) {
 function validateShell(s, lanes, need) {
   if (!need(isObj(s), '"shell" must be an object')) return;
   const rule = (r) => isObj(r) && isRegExp(r.pattern) && isStr(r.why);
+  const blockRule = (r) => rule(r) && [undefined, true, false].includes(r.person);
   need(
-    s.block === undefined || (Array.isArray(s.block) && s.block.every(rule)),
-    '"shell.block" must be a list of { pattern, why }',
+    s.block === undefined || (Array.isArray(s.block) && s.block.every(blockRule)),
+    '"shell.block" must be a list of { pattern, why, person? }',
   );
   const restricted =
     s.restricted === undefined ||

package/hooks/lib/rules.mjs

@@ -10,11 +10,22 @@
 //
 // Approvals live in the project's main checkout, so a lane working in its own worktree sees the ones a
 // person gives at the lead's terminal. One for a lane (`<lane>/<name>`) serves that lane only; one
-// without a lane serves every actor.
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
+// without a lane serves every actor. A person gives one with a `!` shell command, or, where the config
+// sets `approvals.lead` (a person on a phone has no `!`), by saying so in chat for the lead to record
+// with `code-kit approve`.
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { DEPENDENCY_APPROVAL, isDependencyFile } from './dependencies.mjs';
 import { globToRegExp, matchesAny } from './glob.mjs';
 
@@ -24,12 +35,20 @@ export const APPROVAL_MINUTES = 60;
 // Marks a worktree as a lane's, for a person running that lane; the lead creates it, and it is never work.
 export const LANE_FILE = '.lane';
 const NEVER_WRITABLE = [`${APPROVALS_DIR}/**`, APPROVAL_LOG];
+export const CLI = fileURLToPath(new URL('../../bin/code-kit.mjs', import.meta.url));
+// Marks an approval the lead recorded from chat, so the log shows how it was given.
+export const RELAYED = '(given in chat, recorded by the lead)';
+
+/** The command the lead runs to record approvals a person gave in chat. */
+export const relayCommand = (names, lane) =>
+  `node "${CLI}" approve ${[names].flat().join(' ')}${lane ? ` --lane ${lane}` : ''} --reason "<the person's words>"`;
 
 /**
  * The commands a person runs to approve `names` for `actor`, and what that allows. For a lane the
- * approval is that lane's; the folder is created here so the command works as written.
+ * approval is that lane's; the folder is created here so the command works as written. With
+ * `approvals.lead` on, the lead may record it instead, once the person approves in chat.
  */
-export function approvalHowTo(names, actor, root, allows = 'these edits') {
+export function approvalHowTo(names, actor, root, allows = 'these edits', config) {
   const dir = approvalsDir(root);
   const scoped = actor?.kind === 'lane' ? join(dir, actor.lane) : dir;
   try {
@@ -41,12 +60,26 @@ export function approvalHowTo(names, actor, root, allows = 'these edits') {
   const where = shown.startsWith('..') ? scoped : shown;
   const lines = [names].flat().map((n) => `  ! echo "<what you are approving>" > ${where}/${n}`);
   const whom = actor?.kind === 'lane' ? `the ${actor.lane} lane` : 'any agent';
+  const relay = config?.approvals?.lead
+    ? `\nOr, if the person approves in chat (no \`!\` on a phone), the lead records their words:\n  ${relayCommand(names, actor?.kind === 'lane' ? actor.lane : undefined)}`
+    : '';
   return (
     `${lines.join('\n')}\n` +
-    `(a person runs it; the reason is recorded in ${APPROVAL_LOG}, and it allows ${allows} for ${whom}, for ${APPROVAL_MINUTES} minutes)`
+    `(a person runs it; the reason is recorded in ${APPROVAL_LOG}, and it allows ${allows} for ${whom}, for ${APPROVAL_MINUTES} minutes)${relay}`
   );
 }
 
+/** Records approvals a person gave in chat: the same files a `!` command writes, marked as relayed. */
+export function grantApprovals(root, names, lane, reason) {
+  const dir = lane ? join(approvalsDir(root), lane) : approvalsDir(root);
+  mkdirSync(dir, { recursive: true });
+  return names.map((name) => {
+    const file = join(dir, name);
+    writeFileSync(file, `${reason.trim()} ${RELAYED}\n`);
+    return file;
+  });
+}
+
 /** `path` with symlinks resolved, even if it doesn't exist yet (macOS /var → /private/var). */
 export function realPath(path) {
   let dir = resolve(path);
@@ -234,7 +267,7 @@ export function writeProblem(actor, rel, root, config) {
   // 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)) {
-    return `${rel} is ${guarded.why} and needs a person's approval. Ask the lead (a person) to run\n${approvalHowTo(guarded.approval, actor, root)}`;
+    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 (actor.kind === 'readonly') return `${actor.label} is read-only; it may not write ${rel}.`;
   if (matchesAny(rel, config.anyActor)) return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warren-dean/code-kit",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "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/init/SKILL.md

@@ -67,6 +67,7 @@ Write `.claude/code-kit.draft.json`. Follow `${CLAUDE_PLUGIN_ROOT}/README.md`
 - **`shell.restricted`:** commands that affect a shared local service, limited to the lanes that own it.
 - **`postEdit`:** the project's existing per-file linters and formatters, with `{file}`.
 - **`checks`:** the typecheck, test, architecture and database commands, each scoped by `files`. Only include commands that pass on the current code, or ones the person chose to keep.
+- **`approvals.lead`:** ask the person whether they'll ever approve from a phone or another chat-only client, where a `!` command arrives as plain text. If so, set it to `true`: the lead then records approvals they give in chat (`code-kit approve`), and runs the `shell.block` commands marked `person: true` when they say so. Mark a `shell.block` command `person: true` only if the person wants to be able to have the lead run it on their say-so. Leave the setting out if the lead will run unattended.
 
 Prove the draft:
 
@@ -102,6 +103,7 @@ Show the person:
 1. the layers and what each may depend on, and for brownfield the existing violations the baseline will record;
 2. the lanes, their agents and their paths;
 3. protected paths, blocked and restricted commands, and checks (including any left out because they fail today);
+   and whether the lead may record approvals given in chat (`approvals.lead`);
 4. the active adapters and what each adds, from `adapters`;
 5. every **question**: where the docs or the code are silent, ambiguous or contradictory. Don't guess; a wrong owner or layer blocks real work.
 

package/skills/next/SKILL.md

@@ -44,7 +44,7 @@ Run the named skill with the Skill tool: `code-kit:<step>`, with `args` (and the
 After a step finishes, run `next --json` again and carry on with the new step, without asking, as long as nothing needs the person. Stop and hand over when:
 
 - a skill asks the person questions (spec-design's rounds, spec-check's blocking questions, review's scope questions);
-- something needs the person's approval (init's draft, an approval for a protected path);
+- something needs the person's approval (init's draft, an approval for a protected path). If the config has `approvals.lead`, ask for it in chat: when they approve in their own message, record it with the `code-kit approve` command the refusal names (their words as the reason) and carry on;
 - a person has to act: merge a pull request to a protected branch, add a CI secret;
 - the step is `wait` or `done`;
 - the same step comes back twice in a row with nothing changed. Report what's stuck instead of looping.

package/templates/claude-md.md

@@ -7,6 +7,7 @@ The code-kit plugin enforces the rules in `.claude/code-kit.json` on every tool
 - spec-check before lane code{{; designs approved before screens}};
 - an audit log of every change to protected paths (`.claude/approval-log.jsonl`), which the person reviews in the pull request;
 - a person's approval for every new dependency, per package and per lane. When a lane asks for one, give the person the package, the reason and the approval command from the refusal, and resume the lane once they've run it;
+{{If approvals.lead is on: - approvals from chat. When the person approves in their own message (a `!` command doesn't work on a phone), record it with the `code-kit approve` command from the refusal, with their words as the reason. Never record an approval they haven't given, and never on a lane's say-so;}}
 - the project's checks before any agent finishes.
 
 If a hook blocks you, fix the cause; never work around it.