@printpractical/cruze 0.0.4 → 0.0.5

package/README.md

@@ -10,7 +10,7 @@ It works with any agent that supports the [Agent Skills](https://agentskills.io)
 
 ## Status
 
-Version 0.0.4 is the fourth preview. It fixes what the first projects on 0.0.3 ran into: commands print one format on stdout and refuse options they don't take, overlap checks count only work in flight, and the feature map can be corrected when a feature's decisions change it. Early development. The CLI is complete for the V1 lifecycle. The document formats ship as the `cruze-formats` skill, the standards an agent designs and codes to ship as knowledge skills, and the whole workflow, from explore to land, ships as workflow skills. Claude Code is the agent tested so far.
+Version 0.0.5 is the fifth preview. It cuts the ceremony per change: reviews bring you only the findings that are yours to decide, plans are approved once their review closes, a rethink re-stamps the work it didn't change, and changes are sized to be worth their review and verify. Early development. The CLI is complete for the V1 lifecycle. The document formats ship as the `cruze-formats` skill, the standards an agent designs and codes to ship as knowledge skills, and the whole workflow, from explore to land, ships as workflow skills. Claude Code is the agent tested so far.
 
 ## Why
 
@@ -22,7 +22,7 @@ Spec-driven workflows tend to fail in the same few ways:
 - Everything is "fully specified", yet the result fails when a person actually uses it.
 - Review loops keep finding new things to change and never converge.
 
-Cruze answers each of these with a specific mechanism. A living `docs/architecture.md` is read at every step and updated by every change. Approvals are bound to document content, so stepping back is just editing. Every task names the file it touches, and `cruze check` enforces layer rules. Scenarios are traced to behavioural tests, and the system is actually run. Reviews use a closed rubric with a hard limit of two rounds.
+Cruze answers each of these with a specific mechanism. A living `docs/architecture.md` is read at every step and updated by every change. Approvals are bound to document content, so stepping back is just editing. Every task names the file it touches, and `cruze check` enforces layer rules. Scenarios are traced to behavioural tests, and the system is actually run. Reviews use a closed rubric with a hard limit of two rounds, and bring you only the findings that are yours to decide: changes to behaviour or to the designed contracts.
 
 ## Quick start
 
@@ -35,7 +35,7 @@ The skills run `cruze` commands, so the agent needs `cruze` on its path. Install
 From a GitHub Release, without npm. Each release attaches the packed package:
 
 ```sh
-npm install -g https://github.com/PrintPractical/cruze/releases/download/v0.0.4/printpractical-cruze-0.0.4.tgz
+npm install -g https://github.com/PrintPractical/cruze/releases/download/v0.0.5/printpractical-cruze-0.0.5.tgz
 ```
 
 From npm, once a version is published there:
@@ -47,7 +47,7 @@ npm install -g @printpractical/cruze
 From the git repository, at a tag or `#main`. This needs git and access to the repository. npm 11 needs `--install-links` for a global git install, and the first `cruze` command builds the CLI, which takes a moment:
 
 ```sh
-npm install -g --install-links github:PrintPractical/cruze#v0.0.4
+npm install -g --install-links github:PrintPractical/cruze#v0.0.5
 ```
 
 ### 2. Set up a repository
@@ -61,7 +61,7 @@ cruze init
 When you didn't install from npm, tell `init` where Cruze came from, so the CI it writes runs the same source instead of the npm package:
 
 ```sh
-cruze init --package https://github.com/PrintPractical/cruze/releases/download/v0.0.4/printpractical-cruze-0.0.4.tgz
+cruze init --package https://github.com/PrintPractical/cruze/releases/download/v0.0.5/printpractical-cruze-0.0.5.tgz
 ```
 
 `init` asks for the project name, and which coding agent you use: `claude` for Claude Code, or `other` for any agent that reads `AGENTS.md` and `.agents/skills/`, such as Codex or OpenCode. It doesn't ask when you pass `--agent claude` or `--agent other`, or when the repository already has `CLAUDE.md` or `.claude/`. With `--yes`, or without a terminal, it sets up Claude Code. Then it creates:
@@ -118,8 +118,8 @@ Skills call these at fixed points, and CI runs `check` and `trace` on every push
 
 | Command | What it does |
 | --- | --- |
-| `cruze validate` | Checks every document against the formats: IDs, elements, deltas, scope rules, task lines, test plans, roadmap and config |
-| `cruze approve <doc>` | Records an approval as a fingerprint: the document's design hash plus the hash of every upstream element it cites. `--replan` sets built elements a rethink changed back to planned; `--rebase` accepts living text a feature must now build on |
+| `cruze validate` | Checks every document against the formats: IDs, elements, deltas, scope rules, task lines, test plans, roadmap and config, and warns when a change falls outside the size band in `changes:` |
+| `cruze approve <doc>` | Records an approval as a fingerprint: the document's design hash plus the hash of every upstream element it cites. `--replan` sets built elements a rethink changed back to planned; `--rebase` accepts living text a feature must now build on. `--by-agent` approves a change for you once its plan review has closed, and `--restamp-unchanged` re-stamps work a rethink didn't change; both record that the agent gave the approval |
 | `cruze next` | Names the step to run next on this branch, and why, from computed status |
 | `cruze status` | Computes each document's state (approved, edited, upstream changed or unapproved) from content, never from stored state |
 | `cruze status --gate build` | Passes only when this branch's change, its feature and the architecture are approved and current |
@@ -149,7 +149,7 @@ Stepping back is editing: change an upstream document and every approval that ci
 | `cruze-envision` | The what: the project's vision, goals and feature map, or one feature's intent and requirements with scenarios |
 | `cruze-architect` | The how: the architecture, a feature's architecture delta and its changes, or a tweak; ends with a design review and a walkthrough for your approval |
 | `cruze-roadmap` | Orders the release into phases with blocking edges and goal coverage, and closes a release |
-| `cruze-plan` | Turns a change into a test plan and ordered tasks with file targets, reviewed in a fresh context |
+| `cruze-plan` | Turns a change into a test plan and ordered tasks with file targets, reviewed in a fresh context and approved once the review closes |
 | `cruze-build` | Builds the change task by task, each test-first, checked and committed, and stops to rethink when the design is wrong |
 | `cruze-verify` | Runs the checks, a fresh-context verifier that uses the real system, a two-lane code review and a manual test script, then asks you to accept |
 | `cruze-land` | Merges the change into the living docs and updates the changelog, README and `AGENTS.md`; also lands bug fixes |

package/dist/adapters/inbound/cli/cli_context.js

@@ -52,6 +52,8 @@
                 
                    
                    
+                   
+                            
                  
                    
                 

package/dist/adapters/inbound/cli/commands/documents.js

@@ -13,8 +13,12 @@ export async function runValidate(context            )                         {
 
 export async function runApprove(context            , args          , options         )                         {
   requireArgs(args, ["document"]);
-  const report = await approveArtifact(context, args[0] ?? "", { replan: options.replan, rebase: options.rebase });
+  if (options.byAgent && options.restampUnchanged) throw new UsageError("--by-agent and --restamp-unchanged are alternatives");
+  const agent = options.byAgent ? "plan-review" : options.restampUnchanged ? "rethink" : undefined;
+  const report = await approveArtifact(context, args[0] ?? "", { replan: options.replan, rebase: options.rebase, ...(agent === undefined ? {} : { agent }) });
   const lines = [`Approved ${report.artifact} (${report.hash.slice(0, 19)}), pinned to ${report.upstream.length} upstream element(s).`];
+  if (report.basis === "plan-review") lines.push("Approved for the user: its plan review closed with no blocker open.");
+  if (report.restamped !== undefined) lines.push(`Re-stamped for the user: its own design is unchanged, and only ${report.restamped.join(", ")} changed.`);
   if (report.stamped.length > 0) lines.push(`Marked ${report.stamped.length} element(s) planned.`);
   if (report.bound !== undefined) lines.push(`Bound the change to branch ${report.bound}.`);
   if (report.replanned.length > 0) lines.push(`Set back to planned: ${report.replanned.join(", ")}.`);

package/dist/adapters/inbound/cli/commands/status.js

@@ -35,8 +35,11 @@ export async function runStatus(context            , _args          , options
   return { json: report, human: lines.join("\n") };
 }
 
+const BASIS                         = { "plan-review": " (by the agent, after its plan review)", rethink: " (re-stamped by the agent after a rethink)" };
+
 function describe(label        , status                )         {
-  const detail = status.changed.length > 0 ? ` (${status.changed.join(", ")})` : status.unjournaled === true ? " (no journal entry)" : "";
+  const byAgent = status.state === "approved" ? BASIS[status.record?.basis ?? ""] ?? "" : "";
+  const detail = status.changed.length > 0 ? ` (${status.changed.join(", ")})` : status.unjournaled === true ? " (no journal entry)" : byAgent;
   return `${label}: ${status.state}${detail}`;
 }
 

package/dist/adapters/inbound/cli/commands.js

@@ -22,7 +22,11 @@ export const COMMANDS                          = {
   validate: { handler: runValidate, options: [], usage: "validate                                          check every document against the formats" },
   status: { handler: runStatus, options: ["gate", "override", "overlap", "change"], usage: "status [--gate build [--override <reason>]] [--overlap [--change <ref>]]" },
   next: { handler: runNext, options: [], usage: "next                                              the step to run next on this branch, and why" },
-  approve: { handler: runApprove, options: ["replan", "rebase"], usage: "approve <vision|architecture|roadmap|ref|path> [--replan <ID>...] [--rebase <ID>...]   record your approval of a document" },
+  approve: {
+    handler: runApprove,
+    options: ["replan", "rebase", "by-agent", "restamp-unchanged"],
+    usage: "approve <vision|architecture|roadmap|ref|path> [--replan <ID>...] [--rebase <ID>...] [--by-agent|--restamp-unchanged]   record an approval of a document",
+  },
   new: {
     handler: runNew,
     options: { vision: [], glossary: [], architecture: [], roadmap: [], feature: ["title", "roadmap"], change: ["title", "feature", "roadmap"], adr: ["title"], note: ["title"] },

package/dist/adapters/inbound/cli/parse_command.js

@@ -52,6 +52,8 @@ export function parseCommand(argv          )                {
         rebase: { type: "string", multiple: true, default: [] },
         base: { type: "string" },
         blockers: { type: "string" },
+        "by-agent": { type: "boolean", default: false },
+        "restamp-unchanged": { type: "boolean", default: false },
       },
     });
   } catch (error) {
@@ -74,6 +76,8 @@ export function parseCommand(argv          )                {
     full: values.full,
     replan: values.replan,
     rebase: values.rebase,
+    byAgent: values["by-agent"],
+    restampUnchanged: values["restamp-unchanged"],
     ...optional("name", values.name),
     ...optional("title", values.title),
     ...optional("feature", values.feature),

package/dist/app/use_cases/approve_artifact.js

@@ -1,3 +1,4 @@
+import { requirePlanReviewClosed, requireUnchangedSinceApproval,                 } from "../../domain/approvals/agent_approval.js";
 import { evaluateApproval } from "../../domain/approvals/evaluate.js";
 import { fingerprint, isApprovable } from "../../domain/approvals/fingerprint.js";
 import { latestApproval, serializeApprovals, withApproval,                     } from "../../domain/approvals/records.js";
@@ -29,6 +30,10 @@ import { appendJournal, loadView, withFiles,                  } from "../project
                       
                                                                                         
                     
+                                                                    
+                     
+                                                                        
+                       
  
 
                                  
@@ -36,6 +41,8 @@ import { appendJournal, loadView, withFiles,                  } from "../project
                     
                                                                                                                                      
                     
+                                                                                                   
+                     
  
 
 /**
@@ -53,6 +60,9 @@ export async function approveArtifact(deps             , ref        , options
   if (item !== undefined && item.kind !== "feature" && !isPlanned(item.doc)) {
     throw new CruzeError("not-planned", `${path} has no test plan or tasks yet; plan it before approving`);
   }
+  const before = evaluateApproval(view, path);
+  if (options.agent === "plan-review") requirePlanReviewClosed(view.journal, item ?? notWork(path));
+  if (options.agent === "rethink") requireUnchangedSinceApproval(view.journal, item, path, before);
 
   const edits = new Map                ();
   let text = view.snapshot.get(path) ?? "";
@@ -103,12 +113,23 @@ export async function approveArtifact(deps             , ref        , options
     upstream,
     approvedAt: deps.clock.now().toISOString(),
     by: (await deps.repository.userName()) ?? "unknown",
+    ...(options.agent === undefined ? {} : { basis: options.agent }),
   });
   for (const [changed, content] of edits) await deps.files.writeText(changed, content);
   await deps.files.writeText(approvalsPath(folder), serializeApprovals(approvals));
-  await appendJournal(deps, folder, "approve", { artifact: path, hash, ...(replanned.length > 0 ? { replanned } : {}), ...(rebased.length > 0 ? { rebased } : {}) });
+  const restamped = options.agent === "rethink" ? before.changed : undefined;
+  await appendJournal(deps, folder, "approve", {
+    artifact: path,
+    hash,
+    ...(replanned.length > 0 ? { replanned } : {}),
+    ...(rebased.length > 0 ? { rebased } : {}),
+    ...(options.agent === undefined ? {} : { basis: options.agent }),
+    ...(restamped === undefined ? {} : { restamped }),
+  });
   const report                = { artifact: path, hash, upstream: Object.keys(upstream), stamped, replanned, rebased };
   if (bound !== undefined) report.bound = bound;
+  if (options.agent !== undefined) report.basis = options.agent;
+  if (restamped !== undefined) report.restamped = restamped;
   return report;
 }
 
@@ -133,6 +154,10 @@ function requireRebased(view             , deltaIds             , previous
   }
 }
 
+function notWork(path        )        {
+  throw new CruzeError("needs-user", `${path} is a project document, so the user approves it`);
+}
+
 /** A change needs its feature approved; a feature or standalone change needs the architecture approved. */
 function requireUpstreamApproved(view             , path        )       {
   const item = view.items.find((i) => i.path === path);

package/dist/domain/approvals/agent_approval.js

@@ -0,0 +1,68 @@
+import { CruzeError } from "../cruze_error.js";
+                                                  
+                                                         
+                                                    
+
+/**
+ * Why an approval was given without the user: a plan whose review closed, or work that a
+ * rethink left unchanged while something it cites moved. The user can still object, and
+ * editing the document makes the approval stale as usual.
+ */
+                                                   
+
+const byTime = (a              , b              )         => a.at.localeCompare(b.at);
+
+/**
+ * A feature's change may be approved by the agent once its plan review has closed: a review
+ * recorded since the change was last approved, no blocker left open in its last round, and a
+ * disposition for every finding of its first round. The feature's design, and a standalone
+ * change's, stay the user's to approve.
+ */
+export function requirePlanReviewClosed(journal                , item          )       {
+  if (item.kind !== "change") {
+    throw new CruzeError("needs-user", `${item.ref} carries design, so the user approves it; only a feature's change can be approved after its plan review`);
+  }
+  const entries = journal.filter((e) => e["item"] === item.ref || e["artifact"] === item.path).sort(byTime);
+  const lastApproval = entries.filter((e) => e.event === "approve").at(-1);
+  const reviews = entries.filter((e) => e.event === "review" && e["review"] === "plan" && (lastApproval === undefined || e.at > lastApproval.at));
+  const last = reviews.at(-1);
+  if (last === undefined) {
+    const since = lastApproval === undefined ? "" : " since the change was last approved";
+    throw new CruzeError("plan-review-open", `no plan review is recorded for ${item.ref}${since}; run the plan review first`);
+  }
+  const blockers = Number(last["blockers"] ?? 0);
+  if (blockers > 0 && Number(last["round"]) === 1) {
+    throw new CruzeError("plan-review-open", `the plan review's round 1 found ${blockers} blocker(s); check their fixes in round 2`);
+  }
+  if (blockers > 0) {
+    throw new CruzeError("plan-review-open", `round 2 left ${blockers} blocker(s) open; the user decides them and approves the plan`);
+  }
+  const first = reviews.filter((e) => Number(e["round"]) === 1).at(-1) ?? last;
+  const findings = Number(first["blockers"] ?? 0) + Number(first["concerns"] ?? 0);
+  const decided = entries.filter((e) => e.event === "disposition" && e["review"] === "plan" && e.at > first.at).length;
+  if (decided < findings) {
+    throw new CruzeError("plan-review-open", `the plan review raised ${findings} finding(s) but ${decided} have a disposition; record one for each`);
+  }
+}
+
+/**
+ * A rethink may re-approve, for the user, a feature or change it didn't edit: one whose own
+ * design is unchanged and that is stale only because something it cites changed. A change
+ * with a task reopened since its approval goes back to the user.
+ */
+export function requireUnchangedSinceApproval(journal                , item                      , path        , status                )       {
+  if (item === undefined) {
+    throw new CruzeError("needs-user", `${path} is a project document, so the user re-approves it; a rethink re-stamps only features and changes`);
+  }
+  if (status.state === "edited") {
+    throw new CruzeError("needs-user", `${item.ref} itself changed since its approval, so the user re-approves it`);
+  }
+  if (status.state !== "upstream-changed") {
+    throw new CruzeError("not-stale", `${item.ref} is ${status.state}; only work whose upstream changed can be re-stamped`);
+  }
+  const approvedAt = journal.filter((e) => e.event === "approve" && e["artifact"] === path).sort(byTime).at(-1)?.at ?? "";
+  const reopened = journal.filter((e) => e.event === "reopen" && e["change"] === item.ref && e.at > approvedAt).map((e) => String(e["task"]));
+  if (reopened.length > 0) {
+    throw new CruzeError("needs-user", `${item.ref} had ${reopened.join(", ")} reopened since its approval, so the user re-approves it`);
+  }
+}

package/dist/domain/config.js

@@ -23,9 +23,25 @@ import { parse as parseYaml } from "yaml";
                                                                                           
                                                                                   
      
-                                 
+                                                       
+                                                                                         
+                        
+ 
+
+/** Which review findings the user decides: only the exceptions, or every one. */
+                                                
+
+                               
+                                                                                      
+                    
+                                                             
+                       
+                                                 
+                   
  
 
+export const DEFAULT_CHANGE_LIMITS               = { minBuilds: 3, maxScenarios: 30, maxTasks: 25 };
+
                         
                
                   
@@ -97,6 +113,14 @@ export function parseConfig(text        )               {
   const review = asRecord(root["review"]) ?? {};
   const reviewCommand = review["command"] === undefined ? undefined : stringList(review["command"], "review.command", problems);
   if (reviewCommand?.length === 0) problems.push("review.command needs at least the program to run");
+  const decide = review["decide"] ?? "exceptions";
+  if (decide !== "exceptions" && decide !== "all") problems.push("review.decide must be exceptions or all");
+  const limits = asRecord(root["changes"]) ?? {};
+  const changes               = {
+    minBuilds: positiveInt(limits["min_builds"], "changes.min_builds", problems) ?? DEFAULT_CHANGE_LIMITS.minBuilds,
+    maxScenarios: positiveInt(limits["max_scenarios"], "changes.max_scenarios", problems) ?? DEFAULT_CHANGE_LIMITS.maxScenarios,
+    maxTasks: positiveInt(limits["max_tasks"], "changes.max_tasks", problems) ?? DEFAULT_CHANGE_LIMITS.maxTasks,
+  };
 
   const config              = {
     version: 1,
@@ -109,7 +133,11 @@ export function parseConfig(text        )               {
     check: { maxLines: maxLines ?? 250, maxTypes: maxTypes ?? 5, exceptions },
     layers,
     commands,
-    review: reviewCommand === undefined || reviewCommand.length === 0 ? {} : { command: reviewCommand },
+    review: {
+      ...(reviewCommand === undefined || reviewCommand.length === 0 ? {} : { command: reviewCommand }),
+      decide: decide === "all" ? "all" : "exceptions",
+    },
+    changes,
   };
   return { config, problems };
 }

package/dist/domain/journal.js

@@ -21,6 +21,7 @@ export const RECORDED_EVENTS                           = {
 const OPTIONAL_FIELDS                           = {
   rethink: ["missed_by"],
   review: ["nits"],
+  disposition: ["decided"],
 };
 
 /** The workflow steps and checks that find or miss a problem, so a retro can count them. */
@@ -30,6 +31,7 @@ export const FIELD_VALUES                           = {
   level: ["task", "change", "feature", "architecture", "vision"],
   kind: ["defect", "discovery"],
   disposition: ["fixed", "waived", "deferred", "rejected"],
+  decided: ["agent", "user"],
   review: ["design", "plan", "code", "realign"],
   result: ["accepted", "sent-back"],
   found_by: STEPS,
@@ -77,6 +79,9 @@ export function recordedEventProblems(event        , fields
     if (allowed !== undefined && !allowed.includes(value)) problems.push(`${field} must be one of ${allowed.join(", ")}`);
     if (COUNT_FIELDS.includes(field) && !/^\d+$/.test(value)) problems.push(`${field} must be a whole number`);
   }
+  if (event === "disposition" && fields["decided"] === "agent" && fields["disposition"] !== "fixed") {
+    problems.push("the agent decides only fixes; the user waives, defers or rejects a finding (decided=user)");
+  }
   return problems;
 }
 

package/dist/domain/status/verification.js

@@ -4,13 +4,14 @@
 /**
  * Whether the user accepted a change at verify. The latest verification recorded for the change
  * counts. A later approval keeps it only when the change's own design is unchanged, as when it is
- * re-approved because something upstream moved; a changed plan means verifying again.
+ * re-approved because something upstream moved; a changed plan means verifying again. Land's
+ * re-stamps don't count, since they follow the merge; an approval the agent gave does.
  */
 export function isVerified(journal                , change          )          {
   const byTime = (a              , b              )         => a.at.localeCompare(b.at);
   const verification = journal.filter((e) => e.event === "verification" && e["item"] === change.ref).sort(byTime).at(-1);
   if (verification?.["result"] !== "accepted") return false;
-  const approvals = journal.filter((e) => e.event === "approve" && e["artifact"] === change.path && e["basis"] === undefined).sort(byTime);
+  const approvals = journal.filter((e) => e.event === "approve" && e["artifact"] === change.path && !String(e["basis"] ?? "").startsWith("land ")).sort(byTime);
   const verifiedHash = approvals.filter((e) => e.at < verification.at).at(-1)?.["hash"];
   return approvals.filter((e) => e.at > verification.at).every((e) => e["hash"] === verifiedHash);
 }

package/dist/domain/validation/plan_rules.js

@@ -7,6 +7,7 @@ import { findIds, kindOf } from "../ids.js";
 import { isPlanned, readScope, readTasks, readTestPlan,                       } from "../project/plan_parts.js";
                                                               
 import { error, warning,              } from "./problem.js";
+import { planSizeProblems } from "./size_rules.js";
 
 const TEST_KINDS = ["behaviour", "contract", "domain", "smoke"];
 
@@ -31,6 +32,7 @@ export function changePlanProblems(
     problems.push(error(path, line, "task-format", "task lines read: - T<n>: `<owner>` in `<path>`[, `<path>`], proves <ID>[, <ID>]"));
   }
   if (tasks.length === 0 && malformed.length === 0) problems.push(error(path, undefined, "missing-tasks", "the change has no tasks"));
+  problems.push(...planSizeProblems(view, path, tasks.length));
 
   const proved = new Set(tasks.flatMap((task) => task.proves));
   const taskPaths = tasks.flatMap((task) => task.paths);

package/dist/domain/validation/size_rules.js

@@ -0,0 +1,36 @@
+import { DEFAULT_CHANGE_LIMITS,                   } from "../config.js";
+import { kindOf } from "../ids.js";
+                                                          
+                                                              
+import { warning,              } from "./problem.js";
+
+/**
+ * Every change pays for its own plan review, code review, verifier run and land, so a change
+ * should carry enough work to be worth them, and no more than one review and one run can hold.
+ */
+export function changeLimits(view             )               {
+  return view.config?.config?.changes ?? DEFAULT_CHANGE_LIMITS;
+}
+
+/** A feature's changes not yet landed that fall outside the size band. A feature of one change has nothing to merge into. */
+export function changeRowSizeProblems(view             , path        , rows             , landed             )            {
+  const limits = changeLimits(view);
+  const problems            = [];
+  for (const row of rows.filter((r) => !landed.has(r.change))) {
+    if (rows.length > 1 && row.builds.length < limits.minBuilds) {
+      problems.push(warning(path, row.line, "change-too-small", `${row.change} builds ${row.builds.length} element(s), under ${limits.minBuilds}; merge it into the change it continues, since each change pays for its own plan, review and verify`));
+    }
+    const scenarios = row.delivers.filter((id) => kindOf(id) === "SCN").length;
+    if (scenarios > limits.maxScenarios) {
+      problems.push(warning(path, row.line, "change-too-large", `${row.change} delivers ${scenarios} scenarios, over ${limits.maxScenarios}; split it, since one verifier run has to go through them all`));
+    }
+  }
+  return problems;
+}
+
+/** A plan with more tasks than one code review and one verify can hold. */
+export function planSizeProblems(view             , path        , tasks        )            {
+  const { maxTasks } = changeLimits(view);
+  if (tasks <= maxTasks) return [];
+  return [warning(path, undefined, "plan-too-large", `the plan has ${tasks} tasks, over ${maxTasks}; split the change through rethink at feature level`)];
+}

package/dist/domain/validation/work_item_rules.js

@@ -11,6 +11,7 @@ import { deltaProblems } from "./delta_rules.js";
 import { malformedIdHeadings, lineOf } from "./living_rules.js";
 import { changePlanProblems } from "./plan_rules.js";
 import { error, warning,              } from "./problem.js";
+import { changeRowSizeProblems } from "./size_rules.js";
 
 const REQUIRED_SECTIONS                                     = {
   feature: ["Intent", "Spec delta", "Architecture delta", "Changes"],
@@ -71,6 +72,7 @@ function featureScopeProblems(view             , feature          , delta
   if (extra !== undefined) {
     problems.push(warning(feature.path, extra.line, "feature-size", `the feature has ${rows.length} changes, over ${MAX_CHANGES}; split it into features a single design review can hold`));
   }
+  problems.push(...changeRowSizeProblems(view, feature.path, rows, landedChanges));
   for (const row of rows) {
     if (!/^\d\d-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(row.change)) problems.push(error(feature.path, row.line, "change-name", `change "${row.change}" must be named NN-slug`));
     if (names.indexOf(row.change) !== names.lastIndexOf(row.change)) problems.push(error(feature.path, row.line, "change-name", `change ${row.change} is listed twice`));

package/dist/domain/versions/rule_versions.js

@@ -13,6 +13,9 @@ export const RULE_SINCE                         = {
   "validate:outside-module-map": "0.0.2",
   "validate:readme-overview": "0.0.2",
   "validate:feature-size": "0.0.2",
+  "validate:change-too-small": "0.0.5",
+  "validate:change-too-large": "0.0.5",
+  "validate:plan-too-large": "0.0.5",
 };
 
 /** Whether a rule arrived after the version the project's code meets, so it waits for `realign`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@printpractical/cruze",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Spec-driven development for coding agents: one living model of the system, small deltas, convergent review.",
   "license": "Apache-2.0",
   "author": "Chris Buchter",

package/skills/architect/feature.md

@@ -21,11 +21,16 @@ The result is a `feature.md` with a complete architecture delta and an ordered l
 
 ## Split it into changes
 
-9. **Slice vertically.** Each change delivers one or more scenarios end to end, through every layer they need, and can land on its own. The first change is the thinnest slice that proves the design, a tracer bullet. Later changes widen it.
+9. **Slice vertically.** Each change delivers scenarios end to end, through every layer they need, and can land on its own. Every change pays for its own plan review, code review, verifier run and land, so slice by what is worth that cost, not by the smallest piece that could land. The feature's first change proves the design end to end; later changes widen it in steps of real work.
 10. **Fill the Changes table.** Give each row a number and a slug, such as `01-local-serial`. List the scenario and requirement IDs it `Delivers`, the architecture IDs it `Builds`, any IDs it `Removes`, and the changes it `Depends on`.
     - A change builds an element only when its scenarios prove the whole element. Each delta element is built by exactly one change, so when an element's duties arrive in different changes, split it into elements that each arrive whole, such as frame limits split out of a concurrency rule.
     - `Depends on` names every earlier change that builds something this change's scenarios need.
 11. **Cover everything exactly once.** Every delta ID appears in exactly one change. A module the delta adds, or one still `planned` in the living docs, is built by the first change that writes a file in it. A module already `built` isn't listed. Done when `cruze validate` reports no errors for the feature, and no `not-designed` warning.
-12. **Size each change, and the feature.** A change that would need more than about 12 tasks, or touches more than one context's domain, splits in two. A feature of more than 6 changes is more than one design review can hold: split it into features that each serve part of its goals, and run `cruze features add` for the later ones. `cruze validate` warns `feature-size` until it is split.
+12. **Size each change, and the feature.** Aim for changes of about 8 to 25 tasks, each one a sitting's worth of review and verify:
+    - **Merge** a change that builds fewer than 3 elements into the change it continues, when they share adapters or screens, or form a chain where each depends on the one before. Several small changes to the same screens are one change. `cruze validate` warns `change-too-small`.
+    - **Split** a change that delivers more than 30 scenarios, or would need more than 25 tasks, or touches more than one context's domain. One verifier run and one code review can't hold more. `cruze validate` warns `change-too-large`, and `plan-too-large` once a plan passes 25 tasks.
+    - A feature of more than 6 changes is more than one design review can hold: split it into features that each serve part of its goals, and run `cruze features add` for the later ones. `cruze validate` warns `feature-size` until it is split.
+
+    The thresholds are the defaults under `changes:` in `.cruze/config.yaml`; a project can tune them.
 
 Then continue with the review and walkthrough steps of the skill. When the user approves, run `cruze approve <feature>` and quote its result. The command takes the feature's full ID, such as `2026-09-25-open-console`, or its slug when no other active item shares it.

package/skills/formats/SKILL.md

@@ -66,7 +66,7 @@ The CLI owns some content so that routine bookkeeping never changes a design:
 - A block between `<!-- cruze:managed -->` and `<!-- /cruze:managed -->` is written only by the CLI.
 - A `- Status: planned` or `- Status: built` item in an element body is written only by the CLI. Elements that have code (`ENT`, `UC`, `PORT`, `ADP`, `FLOW`, `MOD`) and scenarios (`SCN`) carry one.
 - Both are excluded from every hash. Read them freely; change them only through `cruze` commands:
-  - `cruze approve` adds missing statuses to the architecture, sets built elements back to planned with `--replan`, and binds a change to its branch.
+  - `cruze approve` adds missing statuses to the architecture, sets built elements back to planned with `--replan`, and binds a change to its branch. With `--by-agent` it approves a change whose plan review closed, and with `--restamp-unchanged` it re-stamps work a rethink left unchanged, recording that the agent gave the approval.
   - `cruze task` records progress, and `cruze features` edits the feature map.
   - `cruze land` merges work, marks it built and fills the Commands and Layout sections of `AGENTS.md`.
   - `cruze roadmap prune` and `cruze abandon` update the roadmap's status.

package/skills/formats/reference/config.md

@@ -27,6 +27,12 @@ commands:
 
 review:
   command: ["claude", "-p", "--allowedTools", "Read Grep Glob Bash(git diff:*) Bash(git log:*) Bash(git show:*) Bash(cruze:*) Bash(cargo:*)"]
+  decide: exceptions
+
+changes:
+  min_builds: 3
+  max_scenarios: 30
+  max_tasks: 25
 
 layers:
   - name: inventory-domain
@@ -52,6 +58,10 @@ layers:
 | `layers` | Each layer has a `name`, the `paths` it covers, and `may_import`, the layers it may depend on. |
 | `commands` | The project's commands by name, such as `test` or `run`. The walking-skeleton change fills them in, and `cruze land` copies them into the Commands section of `AGENTS.md`. |
 | `review.command` | The program and arguments `cruze review` runs to start an agent in a fresh context, with the prompt on standard input. Optional. `cruze init` sets it for Claude Code to run in print mode, allowed to read the project and run `git diff`, `git log`, `git show` and `cruze`. The verifier runs the system, so add the project's build and run commands. When it is unset, or its program isn't installed, `cruze review` hands the role's prompt back to the calling agent to run in a helper. |
+| `review.decide` | Which review findings the user decides. `exceptions`, the default: only findings whose fix changes behaviour, a designed port or contract, or another decision the user owns, and any the agent wouldn't simply fix as proposed. The agent fixes the rest and lists them. `all`: the user decides every finding. |
+| `changes.min_builds` | A feature's change that builds fewer elements than this gets a `change-too-small` warning: merge it into the change it continues. Default `3`. |
+| `changes.max_scenarios` | A change that delivers more scenarios than this gets a `change-too-large` warning: split it. Default `30`. |
+| `changes.max_tasks` | A plan with more tasks than this gets a `plan-too-large` warning. Default `25`. |
 
 Rules for layers:
 

package/skills/formats/reference/work-items.md

@@ -35,7 +35,7 @@ Templates: [../templates/feature.md](../templates/feature.md), [../templates/cha
 
 A standalone change adds `## Intent`, `## Adopt or build`, `## Spec delta` and `## Architecture delta` before its `## Scope`, in the same format as a feature's. Its scope covers every ID in its own deltas, plus any `planned` elements from the living docs that it builds.
 
-A feature is designed in two steps. Feature-scope `envision` writes the intent, settled decisions and spec delta, and leaves `## Architecture delta` as `None.` and the Changes table empty. `architect` writes the architecture delta and the changes. Until the Changes table has a row, `cruze validate` reports the feature as `not-designed` (a warning), skips the coverage rules, and `cruze approve` refuses it. A feature of more than 6 changes gets a `feature-size` warning: split it, because one design review can't hold it.
+A feature is designed in two steps. Feature-scope `envision` writes the intent, settled decisions and spec delta, and leaves `## Architecture delta` as `None.` and the Changes table empty. `architect` writes the architecture delta and the changes. Until the Changes table has a row, `cruze validate` reports the feature as `not-designed` (a warning), skips the coverage rules, and `cruze approve` refuses it. A feature of more than 6 changes gets a `feature-size` warning: split it, because one design review can't hold it. A change outside the size band in `changes:` of `.cruze/config.yaml` gets `change-too-small` (it builds fewer than 3 elements, in a feature of several changes) or `change-too-large` (it delivers more than 30 scenarios), and a plan of more than 25 tasks gets `plan-too-large`.
 
 `architect` writes a standalone change's design sections and its scope, and leaves the test plan table empty and the tasks section blank. Until `plan` fills them, `cruze validate` reports the change as `not-planned` (a warning), skips the task and test plan rules, and `cruze approve` refuses it.
 

package/skills/plan/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: cruze-plan
-description: Turns the next change into a test plan and ordered tasks with file targets, reviews the plan in a fresh context, and records your approval on the branch that will build it.
+description: Turns the next change into a test plan and ordered tasks with file targets, reviews the plan in a fresh context, and approves it on the branch that will build it once the review closes, leaving you to object or go straight to build.
 ---
 
 # Plan
@@ -26,7 +26,7 @@ Plan turns one designed change into work an implementer can do without guessing:
 10. **Record decisions and risks.** Put task-level choices you made under `## Settled decisions`. Under `## Risks`, name the riskiest task and how its test catches the failure. Remove every template guide.
 11. **Validate.** Run `cruze validate`. Done when it reports no errors for the change.
 12. **Review the plan.** Commit the plan, then run the review in `.agents/skills/cruze-roles/SKILL.md` with the design reviewer and its plan rubric, `review=plan`, and `--item <ref>`.
-13. **Approve.** Show the user the test plan table, the tasks in order and the risks. When they approve, run `cruze approve <ref>` on this branch and quote its result. The approval binds the change to the branch.
+13. **Approve.** Run `cruze approve <ref> --by-agent` on this branch and quote its result. The plan carries no design of its own, so once its review has closed, with no blocker open and a disposition for every finding, you approve it for the user. The approval binds the change to the branch. When it refuses with `plan-review-open`, do what it names. A blocker still open after round 2 goes to the user, and once they decide it, they approve the plan themselves with `cruze approve <ref>`.
 14. **Commit** with a message such as `docs: plan <change>`.
 
 ## When the plan needs design
@@ -49,4 +49,4 @@ The walking-skeleton change also makes CI and the project's tooling real. Its pl
 
 ## Next step
 
-`build`, on this branch.
+Show the user the test plan table, the tasks in order and the risks, and say the plan is approved. They can object, and you amend the plan, run its review on the diff, and approve again. Otherwise the next step is `build`, on this branch.

package/skills/realign/notes/0.0.5.md

@@ -0,0 +1,38 @@
+# Realign notes: 0.0.5
+
+## New work only
+
+### review-exceptions: The user decides only the review findings that are theirs
+- Applies to: new work only
+- Rule: `.agents/skills/cruze-roles/SKILL.md`, "Running a review", round 1, steps 3 to 5
+
+### plan-approved-by-agent: A plan is approved once its review closes, without stopping for the user
+- Applies to: new work only
+- Rule: `.agents/skills/cruze-plan/SKILL.md`, "Steps", step 13
+
+### rethink-restamps: A rethink re-stamps the work it didn't change
+- Applies to: new work only
+- Rule: `.agents/skills/cruze-rethink/SKILL.md`, "Steps", step 6
+
+### change-too-small: A feature's change builds at least 3 elements
+- Applies to: new work only
+- Rule: `.agents/skills/cruze-architect/feature.md`, step 12
+- Detect: validate:change-too-small
+
+### change-too-large: A change delivers at most 30 scenarios
+- Applies to: new work only
+- Rule: `.agents/skills/cruze-architect/feature.md`, step 12
+- Detect: validate:change-too-large
+
+### plan-too-large: A plan has at most 25 tasks
+- Applies to: new work only
+- Rule: `.agents/skills/cruze-architect/feature.md`, step 12
+- Detect: validate:plan-too-large
+
+### concerns-per-size: Reviewers list concerns in proportion to the work
+- Applies to: new work only
+- Rule: `.agents/skills/cruze-roles/code-reviewer.md`, "Findings"
+
+### reverify-changed-plan: A plan changed after verify needs verifying again, whoever approved it
+- Applies to: new work only
+- Rule: `.agents/skills/cruze-verify/SKILL.md`

package/skills/realign/notes.md

@@ -7,6 +7,7 @@ Each release that changes what Cruze expects of a project ships a notes file, `n
 - [0.0.2](notes/0.0.2.md)
 - [0.0.3](notes/0.0.3.md)
 - [0.0.4](notes/0.0.4.md)
+- [0.0.5](notes/0.0.5.md)
 
 ## Format
 

package/skills/rethink/SKILL.md

@@ -18,7 +18,11 @@ Finding a design flaw mid-build is information, not failure. Rethink amends the
 3. **Load the standards.** Read `.agents/skills/cruze-grilling/SKILL.md`. At feature or architecture level, also read `.agents/skills/cruze-hexagonal-design/SKILL.md`. Also read the format reference for the document you will amend: `.agents/skills/cruze-formats/reference/architecture.md`, `specs.md`, `work-items.md` or `durable-docs.md`.
 4. **Amend that level,** following the level's section in [levels.md](levels.md). Settle any decision the amendment needs with the user, and record it as that level records decisions.
 5. **Keep completed work.** A ticked task stays ticked unless the amendment changes its owner, its files, or what it proves. Reopen each task that changed with `cruze task reopen T<n> "<what changed>"`. Its commits stay in history, and build redoes the task.
-6. **Re-approve what went stale.** Run `cruze status` and work from the top down: the amended document first, then each document it lists as `upstream changed`. For each one, show the user the diff of the elements it names, and re-approve it with `cruze approve <ref>` once they agree. A change's verification carries over when its own design didn't change.
+6. **Re-approve what went stale.** Run `cruze status` and work from the top down. The amended document comes first, and the user approves it as its level says. Then take each feature or change it lists as `upstream changed`, whose own text you didn't edit:
+   - Read the diff of the elements it names, and check the work still holds against them. When it doesn't, amend it too, and the user approves it as an amended document.
+   - When it holds, re-stamp it with `cruze approve <ref> --restamp-unchanged`. The CLI refuses work whose own text changed, a project document, and a change with a task reopened since its approval; the user re-approves those.
+
+   Tell the user, in one line each, what you re-stamped and why it still holds. They can object, and that document goes to them. A change's verification carries over when its own design didn't change.
 7. **Record the rethink.** Draft the entry and show it to the user in one line. When they confirm, run:
 
    ```sh

package/skills/rethink/levels.md

@@ -5,14 +5,14 @@
 1. Edit the change's `## Test plan` or `## Tasks` so they are right. The scope doesn't change at this level; a scope change is a feature-level rethink.
 2. Run `cruze validate`. Done when it reports no errors for the change.
 3. Run the plan review from `.agents/skills/cruze-roles/SKILL.md` on the diff alone, with the design reviewer's plan rubric and `review=plan`.
-4. Re-approve with `cruze approve <change>`.
+4. Re-approve with `cruze approve <change> --by-agent` once the review has closed, as plan does.
 
 ## Feature
 
 1. Edit the feature's `## Spec delta`, `## Architecture delta` or `## Changes`. For a standalone change, edit its own deltas and scope. Write complete bodies, as `architect` does, and keep the scope rules.
 2. Run `cruze validate`. Done when it reports no errors for the feature or its changes.
 3. Run the design review from the roles skill on the diff alone, with `review=design`. Walk the user through the changed parts, following `.agents/skills/cruze-architect/walkthrough.md`.
-4. Re-approve the feature. For each of its changes that shows as stale, update the change's scope, test plan and tasks to match. Reopen touched tasks, and re-approve the change.
+4. Re-approve the feature. For each of its changes that shows as stale, check it against the diff. When the amendment touches the change's scope, test plan or tasks, update them to match, reopen touched tasks, run the plan review on the diff, and re-approve it with `cruze approve <change> --by-agent`. When it doesn't, re-stamp the change as the skill's step 6 describes.
 5. When a change hasn't been created yet, only the feature's Changes row changes; `plan` picks it up.
 
 ## Architecture
@@ -26,7 +26,7 @@
    - **A prefactor**, otherwise. From an up-to-date main, run `architect "<prefactor>"`, which designs it as a standalone change, then `plan`, `build`, `verify` and `land` it before the current change continues.
 6. Run `cruze status`. Every document citing a changed element shows `upstream changed`:
    - When the document's own delta changes that element, rewrite the delta so it keeps your amendment. `cruze approve` refuses it with `rebase-required` until you do. Then approve it with `--rebase <ID>`.
-   - Otherwise, show the user the element's diff, and re-approve the document as the skill's step 6 describes.
+   - Otherwise, check the document against the element's diff, and re-stamp it or amend it as the skill's step 6 describes.
 
 ## Vision
 

package/skills/roles/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: cruze-roles
-description: Prompts for Cruze's fresh-context roles (the design reviewer, code reviewer, verifier and researcher), how to run one, and how to take a review through its two rounds to a disposition for every finding. Use when a Cruze workflow step says to run a role, a review or research in a fresh context.
+description: Prompts for Cruze's fresh-context roles (the design reviewer, code reviewer, verifier and researcher), how to run one, and how to take a review through its two rounds to a disposition for every finding, with the user deciding only the exceptions. Use when a Cruze workflow step says to run a role, a review or research in a fresh context.
 ---
 
 # Roles
@@ -30,16 +30,26 @@ A review has at most two rounds. Only blockers can force the second one.
 
 1. Commit the documents under review (`docs: <artifact> for design review`), so the fixes in round 2 have a diff. Then run the reviewer on the complete artifact.
 2. Record the round: `cruze journal add review --set review=<design|plan|code> --set round=1 --set blockers=<n> --set concerns=<n> --set nits=<n>`, with the counts from the report's last line, adding `--item <ref>` for a feature or change.
-3. Present every finding to the user with your recommended disposition and why:
-   - `fixed`: you will change the design as the finding proposes.
+3. **Sort the findings.** A finding is an **exception**, which the user decides, when any of these holds:
+   - Its fix changes behaviour: it adds, removes or rewrites a requirement or scenario, or changes what a person sees or does beyond what the spec says. Making the code or the plan meet a scenario as written is not a change of behaviour.
+   - Its fix changes a port, a port's `Operations` or a public contract that the approved design names.
+   - Its fix changes another decision the grilling skill leaves to the user: a context, dependency direction or a dependency.
+   - You recommend anything but `fixed`: waiving, deferring or rejecting it, or a rethink because it needs a design change.
+   - You would fix it differently from the reviewer's proposed fix.
+
+   Every other finding is yours, blockers included: you fix it as the reviewer proposes. When `review.decide` in `.cruze/config.yaml` is `all`, every finding is an exception.
+4. **Present them in one message.** First each exception, with your recommended disposition and why:
+   - `fixed`: you will change the work as the finding proposes.
    - `waived`: the finding is right, but the user accepts the risk.
    - `deferred`: it belongs to later work. When it is future scope, add it with `cruze features add <slug> --summary <text> --goals <ids>`.
    - `rejected`: the finding is wrong, with the reason.
 
    A finding whose fix would change an approved element, such as one marked `Needs design change`, is never `deferred` or `waived`. Recommend `rethink` at that element's level now. Once the rethink is done and the code follows it, record the finding as `fixed`.
-4. The user decides each one. Record each decision: `cruze journal add disposition --set finding="<rubric item>: <summary>" --set disposition=<fixed|waived|deferred|rejected> --set reason="<reason>" --set review=<design|plan|code>`, with the same `--item`. A recorded disposition is never raised again.
-5. Apply every `fixed` change, then run `cruze validate`. Done when it reports no errors.
-6. When a finding could be caught by a tool, such as a layering, naming or size rule, tell the user which `cruze check` rule or linter setting would catch it next time.
+
+   Then one line for each finding you are fixing yourself. When there are no exceptions, say what you are fixing and carry on without waiting. The user can object to any line until the work is approved, and that finding becomes an exception: revert its fix and let them decide it.
+5. **Record every disposition:** `cruze journal add disposition --set finding="<rubric item>: <summary>" --set disposition=<fixed|waived|deferred|rejected> --set reason="<reason>" --set review=<design|plan|code> --set decided=<agent|user>`, with the same `--item`. Use `decided=user` for each exception, once the user decides it, and `decided=agent` for each finding you fixed yourself. The CLI refuses `decided=agent` for anything but `fixed`. A recorded disposition is never raised again.
+6. Apply every `fixed` change, then run `cruze validate`. Done when it reports no errors.
+7. When a finding could be caught by a tool, such as a layering, naming or size rule, tell the user which `cruze check` rule or linter setting would catch it next time.
 
 ### Round 2
 
@@ -49,7 +59,7 @@ Run round 2 only when a round-1 blocker was fixed.
 2. Record the round with `round=2`.
 3. Take any blocker still open to the user, who fixes it now, waives it or starts a rethink. There is no round 3.
 
-Done when every finding has a journaled disposition and no blocker is open without the user's decision.
+Done when every finding has a journaled disposition, and every exception, and every blocker left open in round 2, has the user's decision.
 
 ## The settled ledger
 

package/skills/roles/code-reviewer.md

@@ -46,7 +46,7 @@ Each finding has this shape:
 ```
 
 - A **blocker** means a scenario fails or is untested, a protected test was weakened, a layering rule is broken, an unapproved dependency was added, or an adapter can't honour its port's `Operations`. A finding that needs a design change is a blocker. Everything else is a **concern**.
-- List every blocker. List at most 5 concerns, the most important first. Count the rest as nits without listing them.
+- List every blocker. List at most 5 concerns, or one per 5 tasks of the change when that is more, the most important first. Count the rest as nits without listing them. Report only what would go wrong: no concerns is a valid report, and a small change usually has few.
 - Drop any finding that contradicts the settled ledger. The only exception is a blocker with new evidence, which you mark `New evidence:` and explain.
 - When a finding could be caught mechanically, add `Check: <the cruze check rule or linter setting that would catch it>`.
 - In round 2, report only whether each round-1 blocker is fixed, as `fixed` or `open` with the reason. Raise nothing new.

package/skills/roles/design-reviewer.md

@@ -29,7 +29,7 @@ Review against these items and nothing else. Each finding names one.
    - each use case's `Output` and `Errors` against the `FLOW`s that serve it and the `XC` rules that apply to it;
    - each adapter's duties against the port it implements and the `XC` rules it follows;
    - each guarantee, such as "always fits" or "never returns", against the limits and failures that bound it.
-9. **Slicing.** Each change is a vertical slice that delivers scenarios end to end and can land on its own. The order respects `Depends on`, and the first change is the thinnest useful tracer bullet. A change `Builds` an element only when its delivered scenarios prove the whole body; an element whose duties arrive in several changes is split into elements that each arrive whole. `Depends on` names every earlier change that builds something this change's scenarios need. At project scope, the roadmap starts with the walking skeleton, and every goal in the release is covered.
+9. **Slicing.** Each change is a vertical slice that delivers scenarios end to end and can land on its own. The order respects `Depends on`, and the first change proves the design end to end. Each change carries enough work to be worth its own plan review, code review and verify: changes that build one or two elements each on the same adapters or screens, in a chain, are one change split too fine. A change that one verifier run can't hold is split too coarse. A change `Builds` an element only when its delivered scenarios prove the whole body; an element whose duties arrive in several changes is split into elements that each arrive whole. `Depends on` names every earlier change that builds something this change's scenarios need. At project scope, the roadmap starts with the walking skeleton, and every goal in the release is covered.
 10. **Ambiguity.** Name each point where a fresh implementer could reasonably build something different from what the user expects.
 
 ## Plan rubric
@@ -56,7 +56,7 @@ Each finding has this shape:
 ```
 
 - A **blocker** means building from the design as written would produce wrong behaviour, a layering violation or an untestable scenario. Two elements that contradict each other are always a blocker, because an implementer has to pick one. Everything else is a **concern**.
-- List every blocker. List at most 5 concerns, the most important first. Count the rest as nits without listing them.
+- List every blocker. List at most 5 concerns, or for a plan one per 5 tasks when that is more, the most important first. Count the rest as nits without listing them. Report only what would go wrong: no concerns is a valid report, and a small artifact usually has few.
 - Drop any finding that contradicts the settled ledger. The only exception is a blocker with new evidence, which you mark `New evidence:` and explain.
 - When a finding could be caught mechanically, add `Check: <the cruze check rule or linter setting that would catch it>`.
 - In round 2, report only whether each round-1 blocker is fixed, as `fixed` or `open` with the reason. Raise nothing new.

package/skills/verify/SKILL.md

@@ -13,7 +13,7 @@ Verify answers one question: does this change work when someone uses it? Green t
 2. **Run the mechanical checks.** Run the project's format, lint, build and test commands from `commands:` in `.cruze/config.yaml`, then `cruze validate`, `cruze check --ci` and `cruze trace --change <ref>`. Quote each result. When one fails, fix the code in a commit and run them again. When a fix needs design, stop and offer `rethink`.
 3. **Check the dependencies.** Follow "Checking" in `.agents/skills/cruze-dependency-approval/SKILL.md` against the base commit. An unrecorded dependency is a blocker.
 4. **Run the verifier.** Run the verifier role from `.agents/skills/cruze-roles/SKILL.md` for the change. It must be able to build and run the system. When it runs through `cruze review`, check that `review.command` in `.cruze/config.yaml` allows the project's build and run commands, and add them with the user's agreement. Done when you have its report, with a result for every delivered scenario.
-5. **Review the code.** Run the review in the roles skill with the code reviewer, `review=code`, `--item <ref>` and the base commit. Fix each finding the user marks `fixed` in a commit, then check the fixes in round 2.
+5. **Review the code.** Run the review in the roles skill with the code reviewer, `review=code`, `--item <ref>` and the base commit. Fix each finding whose disposition is `fixed` in a commit, then check the fixes in round 2.
 6. **Write the manual test script** as `manual-test.md` in the change folder, following [manual-test.md](manual-test.md). Commit it.
 7. **Report.** Show the user four things:
    - The mechanical checks, one line each.

package/src/adapters/inbound/cli/cli_context.ts

@@ -52,6 +52,8 @@ export interface Options {
   full: boolean;
   replan: string[];
   rebase: string[];
+  byAgent: boolean;
+  restampUnchanged: boolean;
   round?: string;
   package?: string;
   base?: string;

package/src/adapters/inbound/cli/commands/documents.ts

@@ -13,8 +13,12 @@ export async function runValidate(context: CliContext): Promise<CommandResult> {
 
 export async function runApprove(context: CliContext, args: string[], options: Options): Promise<CommandResult> {
   requireArgs(args, ["document"]);
-  const report = await approveArtifact(context, args[0] ?? "", { replan: options.replan, rebase: options.rebase });
+  if (options.byAgent && options.restampUnchanged) throw new UsageError("--by-agent and --restamp-unchanged are alternatives");
+  const agent = options.byAgent ? "plan-review" : options.restampUnchanged ? "rethink" : undefined;
+  const report = await approveArtifact(context, args[0] ?? "", { replan: options.replan, rebase: options.rebase, ...(agent === undefined ? {} : { agent }) });
   const lines = [`Approved ${report.artifact} (${report.hash.slice(0, 19)}), pinned to ${report.upstream.length} upstream element(s).`];
+  if (report.basis === "plan-review") lines.push("Approved for the user: its plan review closed with no blocker open.");
+  if (report.restamped !== undefined) lines.push(`Re-stamped for the user: its own design is unchanged, and only ${report.restamped.join(", ")} changed.`);
   if (report.stamped.length > 0) lines.push(`Marked ${report.stamped.length} element(s) planned.`);
   if (report.bound !== undefined) lines.push(`Bound the change to branch ${report.bound}.`);
   if (report.replanned.length > 0) lines.push(`Set back to planned: ${report.replanned.join(", ")}.`);

package/src/adapters/inbound/cli/commands/status.ts

@@ -35,8 +35,11 @@ export async function runStatus(context: CliContext, _args: string[], options: O
   return { json: report, human: lines.join("\n") };
 }
 
+const BASIS: Record<string, string> = { "plan-review": " (by the agent, after its plan review)", rethink: " (re-stamped by the agent after a rethink)" };
+
 function describe(label: string, status: ApprovalStatus): string {
-  const detail = status.changed.length > 0 ? ` (${status.changed.join(", ")})` : status.unjournaled === true ? " (no journal entry)" : "";
+  const byAgent = status.state === "approved" ? BASIS[status.record?.basis ?? ""] ?? "" : "";
+  const detail = status.changed.length > 0 ? ` (${status.changed.join(", ")})` : status.unjournaled === true ? " (no journal entry)" : byAgent;
   return `${label}: ${status.state}${detail}`;
 }
 

package/src/adapters/inbound/cli/commands.ts

@@ -22,7 +22,11 @@ export const COMMANDS: Record<string, Command> = {
   validate: { handler: runValidate, options: [], usage: "validate                                          check every document against the formats" },
   status: { handler: runStatus, options: ["gate", "override", "overlap", "change"], usage: "status [--gate build [--override <reason>]] [--overlap [--change <ref>]]" },
   next: { handler: runNext, options: [], usage: "next                                              the step to run next on this branch, and why" },
-  approve: { handler: runApprove, options: ["replan", "rebase"], usage: "approve <vision|architecture|roadmap|ref|path> [--replan <ID>...] [--rebase <ID>...]   record your approval of a document" },
+  approve: {
+    handler: runApprove,
+    options: ["replan", "rebase", "by-agent", "restamp-unchanged"],
+    usage: "approve <vision|architecture|roadmap|ref|path> [--replan <ID>...] [--rebase <ID>...] [--by-agent|--restamp-unchanged]   record an approval of a document",
+  },
   new: {
     handler: runNew,
     options: { vision: [], glossary: [], architecture: [], roadmap: [], feature: ["title", "roadmap"], change: ["title", "feature", "roadmap"], adr: ["title"], note: ["title"] },

package/src/adapters/inbound/cli/parse_command.ts

@@ -52,6 +52,8 @@ export function parseCommand(argv: string[]): ParsedCommand {
         rebase: { type: "string", multiple: true, default: [] },
         base: { type: "string" },
         blockers: { type: "string" },
+        "by-agent": { type: "boolean", default: false },
+        "restamp-unchanged": { type: "boolean", default: false },
       },
     });
   } catch (error) {
@@ -74,6 +76,8 @@ export function parseCommand(argv: string[]): ParsedCommand {
     full: values.full,
     replan: values.replan,
     rebase: values.rebase,
+    byAgent: values["by-agent"],
+    restampUnchanged: values["restamp-unchanged"],
     ...optional("name", values.name),
     ...optional("title", values.title),
     ...optional("feature", values.feature),

package/src/app/use_cases/approve_artifact.ts

@@ -1,3 +1,4 @@
+import { requirePlanReviewClosed, requireUnchangedSinceApproval, type AgentBasis } from "../../domain/approvals/agent_approval.ts";
 import { evaluateApproval } from "../../domain/approvals/evaluate.ts";
 import { fingerprint, isApprovable } from "../../domain/approvals/fingerprint.ts";
 import { latestApproval, serializeApprovals, withApproval, type ApprovalRecord } from "../../domain/approvals/records.ts";
@@ -29,6 +30,10 @@ export interface ApproveReport {
   replanned: string[];
   /** Elements whose current living text this feature accepted after a land conflict. */
   rebased: string[];
+  /** Why the agent gave this approval for the user, when it did. */
+  basis?: AgentBasis;
+  /** For a re-stamp: the upstream IDs or documents that had changed. */
+  restamped?: string[];
 }
 
 export interface ApproveOptions {
@@ -36,6 +41,8 @@ export interface ApproveOptions {
   replan?: string[];
   /** Elements this work's delta changes whose living text changed since its last approval; the approval accepts the current text. */
   rebase?: string[];
+  /** Approve for the user: a change whose plan review closed, or work a rethink left unchanged. */
+  agent?: AgentBasis;
 }
 
 /**
@@ -53,6 +60,9 @@ export async function approveArtifact(deps: ProjectDeps, ref: string, options: A
   if (item !== undefined && item.kind !== "feature" && !isPlanned(item.doc)) {
     throw new CruzeError("not-planned", `${path} has no test plan or tasks yet; plan it before approving`);
   }
+  const before = evaluateApproval(view, path);
+  if (options.agent === "plan-review") requirePlanReviewClosed(view.journal, item ?? notWork(path));
+  if (options.agent === "rethink") requireUnchangedSinceApproval(view.journal, item, path, before);
 
   const edits = new Map<string, string>();
   let text = view.snapshot.get(path) ?? "";
@@ -103,12 +113,23 @@ export async function approveArtifact(deps: ProjectDeps, ref: string, options: A
     upstream,
     approvedAt: deps.clock.now().toISOString(),
     by: (await deps.repository.userName()) ?? "unknown",
+    ...(options.agent === undefined ? {} : { basis: options.agent }),
   });
   for (const [changed, content] of edits) await deps.files.writeText(changed, content);
   await deps.files.writeText(approvalsPath(folder), serializeApprovals(approvals));
-  await appendJournal(deps, folder, "approve", { artifact: path, hash, ...(replanned.length > 0 ? { replanned } : {}), ...(rebased.length > 0 ? { rebased } : {}) });
+  const restamped = options.agent === "rethink" ? before.changed : undefined;
+  await appendJournal(deps, folder, "approve", {
+    artifact: path,
+    hash,
+    ...(replanned.length > 0 ? { replanned } : {}),
+    ...(rebased.length > 0 ? { rebased } : {}),
+    ...(options.agent === undefined ? {} : { basis: options.agent }),
+    ...(restamped === undefined ? {} : { restamped }),
+  });
   const report: ApproveReport = { artifact: path, hash, upstream: Object.keys(upstream), stamped, replanned, rebased };
   if (bound !== undefined) report.bound = bound;
+  if (options.agent !== undefined) report.basis = options.agent;
+  if (restamped !== undefined) report.restamped = restamped;
   return report;
 }
 
@@ -133,6 +154,10 @@ function requireRebased(view: ProjectView, deltaIds: Set<string>, previous: Appr
   }
 }
 
+function notWork(path: string): never {
+  throw new CruzeError("needs-user", `${path} is a project document, so the user approves it`);
+}
+
 /** A change needs its feature approved; a feature or standalone change needs the architecture approved. */
 function requireUpstreamApproved(view: ProjectView, path: string): void {
   const item = view.items.find((i) => i.path === path);

package/src/domain/approvals/agent_approval.ts

@@ -0,0 +1,68 @@
+import { CruzeError } from "../cruze_error.ts";
+import type { JournalEntry } from "../journal.ts";
+import type { WorkItem } from "../project/work_items.ts";
+import type { ApprovalStatus } from "./evaluate.ts";
+
+/**
+ * Why an approval was given without the user: a plan whose review closed, or work that a
+ * rethink left unchanged while something it cites moved. The user can still object, and
+ * editing the document makes the approval stale as usual.
+ */
+export type AgentBasis = "plan-review" | "rethink";
+
+const byTime = (a: JournalEntry, b: JournalEntry): number => a.at.localeCompare(b.at);
+
+/**
+ * A feature's change may be approved by the agent once its plan review has closed: a review
+ * recorded since the change was last approved, no blocker left open in its last round, and a
+ * disposition for every finding of its first round. The feature's design, and a standalone
+ * change's, stay the user's to approve.
+ */
+export function requirePlanReviewClosed(journal: JournalEntry[], item: WorkItem): void {
+  if (item.kind !== "change") {
+    throw new CruzeError("needs-user", `${item.ref} carries design, so the user approves it; only a feature's change can be approved after its plan review`);
+  }
+  const entries = journal.filter((e) => e["item"] === item.ref || e["artifact"] === item.path).sort(byTime);
+  const lastApproval = entries.filter((e) => e.event === "approve").at(-1);
+  const reviews = entries.filter((e) => e.event === "review" && e["review"] === "plan" && (lastApproval === undefined || e.at > lastApproval.at));
+  const last = reviews.at(-1);
+  if (last === undefined) {
+    const since = lastApproval === undefined ? "" : " since the change was last approved";
+    throw new CruzeError("plan-review-open", `no plan review is recorded for ${item.ref}${since}; run the plan review first`);
+  }
+  const blockers = Number(last["blockers"] ?? 0);
+  if (blockers > 0 && Number(last["round"]) === 1) {
+    throw new CruzeError("plan-review-open", `the plan review's round 1 found ${blockers} blocker(s); check their fixes in round 2`);
+  }
+  if (blockers > 0) {
+    throw new CruzeError("plan-review-open", `round 2 left ${blockers} blocker(s) open; the user decides them and approves the plan`);
+  }
+  const first = reviews.filter((e) => Number(e["round"]) === 1).at(-1) ?? last;
+  const findings = Number(first["blockers"] ?? 0) + Number(first["concerns"] ?? 0);
+  const decided = entries.filter((e) => e.event === "disposition" && e["review"] === "plan" && e.at > first.at).length;
+  if (decided < findings) {
+    throw new CruzeError("plan-review-open", `the plan review raised ${findings} finding(s) but ${decided} have a disposition; record one for each`);
+  }
+}
+
+/**
+ * A rethink may re-approve, for the user, a feature or change it didn't edit: one whose own
+ * design is unchanged and that is stale only because something it cites changed. A change
+ * with a task reopened since its approval goes back to the user.
+ */
+export function requireUnchangedSinceApproval(journal: JournalEntry[], item: WorkItem | undefined, path: string, status: ApprovalStatus): void {
+  if (item === undefined) {
+    throw new CruzeError("needs-user", `${path} is a project document, so the user re-approves it; a rethink re-stamps only features and changes`);
+  }
+  if (status.state === "edited") {
+    throw new CruzeError("needs-user", `${item.ref} itself changed since its approval, so the user re-approves it`);
+  }
+  if (status.state !== "upstream-changed") {
+    throw new CruzeError("not-stale", `${item.ref} is ${status.state}; only work whose upstream changed can be re-stamped`);
+  }
+  const approvedAt = journal.filter((e) => e.event === "approve" && e["artifact"] === path).sort(byTime).at(-1)?.at ?? "";
+  const reopened = journal.filter((e) => e.event === "reopen" && e["change"] === item.ref && e.at > approvedAt).map((e) => String(e["task"]));
+  if (reopened.length > 0) {
+    throw new CruzeError("needs-user", `${item.ref} had ${reopened.join(", ")} reopened since its approval, so the user re-approves it`);
+  }
+}

package/src/domain/config.ts

@@ -23,9 +23,25 @@ export interface CruzeConfig {
    * How `cruze review` starts an agent in a fresh context: the program and its arguments.
    * Without one, the calling agent runs the role's prompt in a helper of its own.
    */
-  review: { command?: string[] };
+  review: { command?: string[]; decide: ReviewDecide };
+  /** The size band of a change, so each one is worth its own plan, review and verify. */
+  changes: ChangeLimits;
 }
 
+/** Which review findings the user decides: only the exceptions, or every one. */
+export type ReviewDecide = "exceptions" | "all";
+
+export interface ChangeLimits {
+  /** A feature's change building fewer elements than this merges into a neighbour. */
+  minBuilds: number;
+  /** A change delivering more scenarios than this splits. */
+  maxScenarios: number;
+  /** A plan with more tasks than this splits. */
+  maxTasks: number;
+}
+
+export const DEFAULT_CHANGE_LIMITS: ChangeLimits = { minBuilds: 3, maxScenarios: 30, maxTasks: 25 };
+
 export interface Layer {
   name: string;
   paths: string[];
@@ -97,6 +113,14 @@ export function parseConfig(text: string): ConfigResult {
   const review = asRecord(root["review"]) ?? {};
   const reviewCommand = review["command"] === undefined ? undefined : stringList(review["command"], "review.command", problems);
   if (reviewCommand?.length === 0) problems.push("review.command needs at least the program to run");
+  const decide = review["decide"] ?? "exceptions";
+  if (decide !== "exceptions" && decide !== "all") problems.push("review.decide must be exceptions or all");
+  const limits = asRecord(root["changes"]) ?? {};
+  const changes: ChangeLimits = {
+    minBuilds: positiveInt(limits["min_builds"], "changes.min_builds", problems) ?? DEFAULT_CHANGE_LIMITS.minBuilds,
+    maxScenarios: positiveInt(limits["max_scenarios"], "changes.max_scenarios", problems) ?? DEFAULT_CHANGE_LIMITS.maxScenarios,
+    maxTasks: positiveInt(limits["max_tasks"], "changes.max_tasks", problems) ?? DEFAULT_CHANGE_LIMITS.maxTasks,
+  };
 
   const config: CruzeConfig = {
     version: 1,
@@ -109,7 +133,11 @@ export function parseConfig(text: string): ConfigResult {
     check: { maxLines: maxLines ?? 250, maxTypes: maxTypes ?? 5, exceptions },
     layers,
     commands,
-    review: reviewCommand === undefined || reviewCommand.length === 0 ? {} : { command: reviewCommand },
+    review: {
+      ...(reviewCommand === undefined || reviewCommand.length === 0 ? {} : { command: reviewCommand }),
+      decide: decide === "all" ? "all" : "exceptions",
+    },
+    changes,
   };
   return { config, problems };
 }

package/src/domain/journal.ts

@@ -21,6 +21,7 @@ export const RECORDED_EVENTS: Record<string, string[]> = {
 const OPTIONAL_FIELDS: Record<string, string[]> = {
   rethink: ["missed_by"],
   review: ["nits"],
+  disposition: ["decided"],
 };
 
 /** The workflow steps and checks that find or miss a problem, so a retro can count them. */
@@ -30,6 +31,7 @@ export const FIELD_VALUES: Record<string, string[]> = {
   level: ["task", "change", "feature", "architecture", "vision"],
   kind: ["defect", "discovery"],
   disposition: ["fixed", "waived", "deferred", "rejected"],
+  decided: ["agent", "user"],
   review: ["design", "plan", "code", "realign"],
   result: ["accepted", "sent-back"],
   found_by: STEPS,
@@ -77,6 +79,9 @@ export function recordedEventProblems(event: string, fields: Record<string, stri
     if (allowed !== undefined && !allowed.includes(value)) problems.push(`${field} must be one of ${allowed.join(", ")}`);
     if (COUNT_FIELDS.includes(field) && !/^\d+$/.test(value)) problems.push(`${field} must be a whole number`);
   }
+  if (event === "disposition" && fields["decided"] === "agent" && fields["disposition"] !== "fixed") {
+    problems.push("the agent decides only fixes; the user waives, defers or rejects a finding (decided=user)");
+  }
   return problems;
 }
 

package/src/domain/status/verification.ts

@@ -4,13 +4,14 @@ import type { WorkItem } from "../project/work_items.ts";
 /**
  * Whether the user accepted a change at verify. The latest verification recorded for the change
  * counts. A later approval keeps it only when the change's own design is unchanged, as when it is
- * re-approved because something upstream moved; a changed plan means verifying again.
+ * re-approved because something upstream moved; a changed plan means verifying again. Land's
+ * re-stamps don't count, since they follow the merge; an approval the agent gave does.
  */
 export function isVerified(journal: JournalEntry[], change: WorkItem): boolean {
   const byTime = (a: JournalEntry, b: JournalEntry): number => a.at.localeCompare(b.at);
   const verification = journal.filter((e) => e.event === "verification" && e["item"] === change.ref).sort(byTime).at(-1);
   if (verification?.["result"] !== "accepted") return false;
-  const approvals = journal.filter((e) => e.event === "approve" && e["artifact"] === change.path && e["basis"] === undefined).sort(byTime);
+  const approvals = journal.filter((e) => e.event === "approve" && e["artifact"] === change.path && !String(e["basis"] ?? "").startsWith("land ")).sort(byTime);
   const verifiedHash = approvals.filter((e) => e.at < verification.at).at(-1)?.["hash"];
   return approvals.filter((e) => e.at > verification.at).every((e) => e["hash"] === verifiedHash);
 }

package/src/domain/validation/plan_rules.ts

@@ -7,6 +7,7 @@ import type { Delta } from "../project/deltas.ts";
 import { isPlanned, readScope, readTasks, readTestPlan, type Scope, type Task } from "../project/plan_parts.ts";
 import type { ProjectView } from "../project/project_view.ts";
 import { error, warning, type Problem } from "./problem.ts";
+import { planSizeProblems } from "./size_rules.ts";
 
 const TEST_KINDS = ["behaviour", "contract", "domain", "smoke"];
 
@@ -31,6 +32,7 @@ export function changePlanProblems(
     problems.push(error(path, line, "task-format", "task lines read: - T<n>: `<owner>` in `<path>`[, `<path>`], proves <ID>[, <ID>]"));
   }
   if (tasks.length === 0 && malformed.length === 0) problems.push(error(path, undefined, "missing-tasks", "the change has no tasks"));
+  problems.push(...planSizeProblems(view, path, tasks.length));
 
   const proved = new Set(tasks.flatMap((task) => task.proves));
   const taskPaths = tasks.flatMap((task) => task.paths);

package/src/domain/validation/size_rules.ts

@@ -0,0 +1,36 @@
+import { DEFAULT_CHANGE_LIMITS, type ChangeLimits } from "../config.ts";
+import { kindOf } from "../ids.ts";
+import type { ChangeRow } from "../project/plan_parts.ts";
+import type { ProjectView } from "../project/project_view.ts";
+import { warning, type Problem } from "./problem.ts";
+
+/**
+ * Every change pays for its own plan review, code review, verifier run and land, so a change
+ * should carry enough work to be worth them, and no more than one review and one run can hold.
+ */
+export function changeLimits(view: ProjectView): ChangeLimits {
+  return view.config?.config?.changes ?? DEFAULT_CHANGE_LIMITS;
+}
+
+/** A feature's changes not yet landed that fall outside the size band. A feature of one change has nothing to merge into. */
+export function changeRowSizeProblems(view: ProjectView, path: string, rows: ChangeRow[], landed: Set<string>): Problem[] {
+  const limits = changeLimits(view);
+  const problems: Problem[] = [];
+  for (const row of rows.filter((r) => !landed.has(r.change))) {
+    if (rows.length > 1 && row.builds.length < limits.minBuilds) {
+      problems.push(warning(path, row.line, "change-too-small", `${row.change} builds ${row.builds.length} element(s), under ${limits.minBuilds}; merge it into the change it continues, since each change pays for its own plan, review and verify`));
+    }
+    const scenarios = row.delivers.filter((id) => kindOf(id) === "SCN").length;
+    if (scenarios > limits.maxScenarios) {
+      problems.push(warning(path, row.line, "change-too-large", `${row.change} delivers ${scenarios} scenarios, over ${limits.maxScenarios}; split it, since one verifier run has to go through them all`));
+    }
+  }
+  return problems;
+}
+
+/** A plan with more tasks than one code review and one verify can hold. */
+export function planSizeProblems(view: ProjectView, path: string, tasks: number): Problem[] {
+  const { maxTasks } = changeLimits(view);
+  if (tasks <= maxTasks) return [];
+  return [warning(path, undefined, "plan-too-large", `the plan has ${tasks} tasks, over ${maxTasks}; split the change through rethink at feature level`)];
+}

package/src/domain/validation/work_item_rules.ts

@@ -11,6 +11,7 @@ import { deltaProblems } from "./delta_rules.ts";
 import { malformedIdHeadings, lineOf } from "./living_rules.ts";
 import { changePlanProblems } from "./plan_rules.ts";
 import { error, warning, type Problem } from "./problem.ts";
+import { changeRowSizeProblems } from "./size_rules.ts";
 
 const REQUIRED_SECTIONS: Record<WorkItem["kind"], string[]> = {
   feature: ["Intent", "Spec delta", "Architecture delta", "Changes"],
@@ -71,6 +72,7 @@ function featureScopeProblems(view: ProjectView, feature: WorkItem, delta: Delta
   if (extra !== undefined) {
     problems.push(warning(feature.path, extra.line, "feature-size", `the feature has ${rows.length} changes, over ${MAX_CHANGES}; split it into features a single design review can hold`));
   }
+  problems.push(...changeRowSizeProblems(view, feature.path, rows, landedChanges));
   for (const row of rows) {
     if (!/^\d\d-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(row.change)) problems.push(error(feature.path, row.line, "change-name", `change "${row.change}" must be named NN-slug`));
     if (names.indexOf(row.change) !== names.lastIndexOf(row.change)) problems.push(error(feature.path, row.line, "change-name", `change ${row.change} is listed twice`));

package/src/domain/versions/rule_versions.ts

@@ -13,6 +13,9 @@ export const RULE_SINCE: Record<string, string> = {
   "validate:outside-module-map": "0.0.2",
   "validate:readme-overview": "0.0.2",
   "validate:feature-size": "0.0.2",
+  "validate:change-too-small": "0.0.5",
+  "validate:change-too-large": "0.0.5",
+  "validate:plan-too-large": "0.0.5",
 };
 
 /** Whether a rule arrived after the version the project's code meets, so it waits for `realign`. */