@delete101020/aidlc 4.0.39 → 4.0.42

package/dist/templates/ainative/artifacts/build-plan.md

@@ -27,6 +27,10 @@
 1. 
 2. 
 
+**Batches** — consecutive steps one fresh session can finish, tests passing.
+
+**Batch 1** — steps 1–2: 
+
 ## 4. Risks
 
 | Risk | Likelihood | What we do about it |

package/dist/templates/ainative/artifacts/implement.md

@@ -15,7 +15,16 @@
 | Branch |  |
 | PR |  |
 
-## 2. What was built
+## 2. Progress
+
+> *One row per batch. A session in a batched run reads this first; rows marked
+> done are not redone.*
+
+| Batch | Plan steps | Commits | Tests run | State |
+|---|---|---|---|---|
+| 1 |  |  |  | done |
+
+## 3. What was built
 
 > *Per plan step: what changed, in which files.*
 
@@ -23,7 +32,7 @@
 |---|---|---|
 | 1 |  |  |
 
-## 3. Proofs executed
+## 4. Proofs executed
 
 > *The real command and its real output, per acceptance criterion. Never a claim
 > without output.*
@@ -35,11 +44,11 @@ $ <command>
 <output>
 ```
 
-## 4. Deviations from the plan
+## 5. Deviations from the plan
 
 > *Anything done differently, and why. If nothing, say so explicitly.*
 
-## 5. Discovered work
+## 6. Discovered work
 
 > *Found but deliberately not done, and where it went — a plan amendment, a new
 > intent, an issue.*
@@ -48,8 +57,12 @@ $ <command>
 |---|---|
 |  |  |
 
-## 6. Known gaps
+## 7. Known gaps
 
 > *What a reviewer should look at hardest.*
 
 - 
+
+---
+
+Status: done

package/dist/templates/ainative/artifacts/review.md

@@ -10,9 +10,10 @@
 
 ## 1. Verdict
 
-> *One line. Any `blocker` row below makes the verdict a hold.*
+> *One line, exactly `Verdict: ship` or `Verdict: hold` — a validator reads it.
+> Any `blocker` row below makes the verdict a hold.*
 
-**Overall:** ship / hold
+Verdict: ship / hold
 
 ## 2. Scope reviewed
 

package/dist/templates/ainative/artifacts/verify.md

@@ -10,9 +10,10 @@
 
 ## 1. Verdict
 
-> *One line. Any `fail` or `untested` row below makes the overall verdict a fail.*
+> *One line, exactly `Verdict: pass` or `Verdict: fail` — a validator reads it.
+> Any `fail` or `untested` row below makes the overall verdict a fail.*
 
-**Overall:** pass / fail
+Verdict: pass / fail
 
 ## 2. Acceptance criteria
 

package/dist/templates/ainative/skills/native-build-plan.md

@@ -42,6 +42,15 @@ A table, not prose. Real paths.
 Numbered steps in dependency order, each one independently reviewable. Say what is
 true after each step that was not true before it.
 
+Then group the steps into **batches**: runs of consecutive steps that one fresh
+agent session can finish, with tests passing, in about half an hour. A run with
+`batches: true` on `implement` gives each batch its own session, so reviewing the
+plan is also reviewing where those sessions start and stop. Keep a batch to one
+area of the code, and end it where the tests pass. A small plan is one batch.
+
+    **Batch 1** — steps 1–2: <what is true when it ends>
+    **Batch 2** — steps 3–5: <what is true when it ends>
+
 ### Risks
 
 | Risk | Likelihood | What we do about it |

package/dist/templates/ainative/skills/native-implement.md

@@ -34,8 +34,30 @@ With no run state, default all three to true. Honour these flags throughout.
 7. Write `docs/epics/$0/artifacts/implement.md`.
 8. Push and open the PR per Step 0, linking the epic and the spec.
 
+## Batches
+
+When the run tells you this step **runs in batches**, you are one session of
+several, and the next session remembers nothing but what is on disk:
+
+- Do **one** batch — the one the run names, as the plan groups them. You may split
+  a batch smaller when it does not fit in your context; never do two in one
+  session, and never regroup the plan's batches otherwise.
+- Read the **Progress** table in `implement.md` first, if there is one. Rows marked
+  done are done: do not redo them.
+- Sent back for another revision? The first batch is the fixes the feedback asks
+  for. Keep the earlier revision's Progress rows and add the fix batch below them.
+- Before you stop, commit, then update `implement.md`: the Progress row for this
+  batch (steps, commits, tests run), and the rest of the report so far.
+- End `implement.md` with a line of its own: `Status: continue` when any of the
+  plan is left, `Status: done` when all of it is built and every proof executed.
+  Without that line the run stops with an error.
+
+Not batched, you build the whole plan in this session and end with `Status: done`.
+
 ## implement.md Contents
 
+- **Progress** — one row per batch: the plan steps it covered, its commits, the
+  tests it ran.
 - **Branch / PR** — branch name, PR link.
 - **What was built** — per plan step: what changed, in which files.
 - **Proofs executed** — the command and its real output, per `$0-ACnn`.
@@ -54,9 +76,11 @@ With no run state, default all three to true. Honour these flags throughout.
 - **Stay inside the plan.** Scope found mid-flight becomes a plan amendment or a new
   intent; it never lands silently in the diff.
 - **Small, ordered commits.** The reviewer reads the sequence, not just the endpoint.
+- **Sent back for another revision?** Continue on the same branch and PR. Add new
+  commits; never amend, rebase or force-push what is already there.
 - If a plan step turns out to be wrong, stop and amend `plan.md` before continuing.
 
 ## Output
 
-Write `docs/epics/$0/artifacts/implement.md`, with the branch pushed and the PR open
-unless Step 0 says otherwise.
+Write `docs/epics/$0/artifacts/implement.md`, ending in its `Status:` line, with the
+branch pushed and the PR open unless Step 0 says otherwise.

package/dist/templates/ainative/skills/native-review.md

@@ -77,6 +77,10 @@ broken rule, and stage 6 is where it gets fixed.
 
 ## Output
 
-Write `docs/epics/$0/artifacts/review.md`, ending with a one-line verdict —
-**ship** or **hold** — and, when it is a hold, the shortest list of changes that
-would turn it into a ship.
+Write `docs/epics/$0/artifacts/review.md`. State the verdict once, on a line of
+its own, exactly `Verdict: ship` or `Verdict: hold`. When it is a hold, list the
+shortest set of changes that would turn it into a ship under a
+`## Shortest path to ship` heading.
+
+A validator reads that line. A missing, misspelled or contradictory verdict counts as a
+hold, and the changes you list are what the engineer is handed next.

package/dist/templates/ainative/skills/native-verify.md

@@ -56,5 +56,10 @@ Every acceptance criterion gets exactly one row:
 
 ## Output
 
-Write `docs/epics/$0/artifacts/verify.md`, ending with a one-line overall verdict and,
-if it is a fail, the shortest list of things that would turn it into a pass.
+Write `docs/epics/$0/artifacts/verify.md`. State the overall verdict once, on a line
+of its own, exactly `Verdict: pass` or `Verdict: fail`. When it is a fail, list the
+shortest set of things that would turn it into a pass under a
+`## Shortest path to pass` heading.
+
+A validator reads that line. A missing, misspelled or contradictory verdict counts as a
+fail, and the changes you list are what the engineer is handed next.

package/dist/templates/ainative/validators/verdict.mjs

@@ -0,0 +1,109 @@
+/**
+ * Auto-review runner that reads the verdict a verify or review step wrote.
+ *
+ * The step's artifact (`verify.md`, `review.md`) carries one line
+ *
+ *   Verdict: pass | fail      (verify)
+ *   Verdict: ship | hold      (review)
+ *
+ * and this validator turns it into `{ decision, reason }`: `pass` / `ship`
+ * let the step through, `fail` / `hold` reject it. Bold and heading markup
+ * around the line is fine; a comment after a dash is fine
+ * (`Verdict: hold — two blockers`).
+ *
+ * It fails closed. No artifact, no verdict line, a word it does not know,
+ * a placeholder left unfilled (`Verdict: ship / hold`) or two lines that
+ * disagree all reject — a review nobody can read is not a ship.
+ *
+ * On a reject, the reason is the report's "Shortest path to …" section (or
+ * the lines under the verdict when there is none), so the step that gets the
+ * work back is told what to change, not just that it failed.
+ *
+ * Contract (see packages/core/src/runs/AutoReviewer.ts):
+ *   export default async ({ workspaceRoot, state, step, pipeline, paths }) =>
+ *     ({ decision: 'pass' | 'reject', reason: string })
+ */
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+
+const DECISIONS = { pass: 'pass', ship: 'pass', fail: 'reject', hold: 'reject' };
+
+// `Verdict: hold`, `**Verdict:** hold`, `## Verdict: **hold**`, `> Verdict: hold`
+const LINE = /^[\s>#*_-]*verdict[\s*_]*:[\s*_`]*([a-z]+)[*_`]*(.*)$/i;
+// What may follow the word: nothing, or a comment set off by a dash or a bracket.
+const TAIL = /^\s*(?:$|[—–-]\s|[(.,;])/;
+
+export function readVerdict(text, file = 'the report') {
+  const expected = /verify/i.test(file) ? '`Verdict: pass` or `Verdict: fail`' : '`Verdict: ship` or `Verdict: hold`';
+  const lines = text.split(/\r?\n/);
+  const found = [];
+  lines.forEach((line, i) => {
+    const m = LINE.exec(line);
+    if (m) { found.push({ i, word: m[1].toLowerCase(), tail: m[2] }); }
+  });
+
+  if (found.length === 0) {
+    return { decision: 'reject', reason: `${file} has no verdict line. Add one: ${expected}.` };
+  }
+  for (const f of found) {
+    if (!(f.word in DECISIONS) || !TAIL.test(f.tail)) {
+      return {
+        decision: 'reject',
+        reason: `${file} line ${f.i + 1}: unreadable verdict "${lines[f.i].trim()}". Expected ${expected}.`,
+      };
+    }
+  }
+  const decisions = new Set(found.map((f) => DECISIONS[f.word]));
+  if (decisions.size > 1) {
+    return {
+      decision: 'reject',
+      reason: `${file} gives conflicting verdicts (${found.map((f) => f.word).join(', ')}). Keep one.`,
+    };
+  }
+
+  const last = found[found.length - 1];
+  if (DECISIONS[last.word] === 'pass') {
+    return { decision: 'pass', reason: `Verdict: ${last.word}` };
+  }
+  const changes = shortestPath(lines) ?? body(lines, last.i + 1);
+  return {
+    decision: 'reject',
+    reason: changes
+      ? `Verdict: ${last.word}. Changes needed:\n${changes}`
+      : `Verdict: ${last.word}. ${file} lists no changes; read its findings.`,
+  };
+}
+
+/** Body of the "Shortest path to ship/pass" section, minus template hints. */
+function shortestPath(lines) {
+  const start = lines.findIndex((l) => /^#+\s.*shortest path/i.test(l));
+  return start < 0 ? null : body(lines, start + 1);
+}
+
+/** Lines from `from` up to the next heading or rule. */
+function body(lines, from) {
+  const out = [];
+  for (let i = from; i < lines.length; i++) {
+    const l = lines[i];
+    if (/^#+\s/.test(l) || /^---\s*$/.test(l)) { break; }
+    if (/^\s*>/.test(l)) { continue; }          // template hint
+    if (/^\s*(\d+\.|[-*])\s*$/.test(l)) { continue; } // empty list item
+    out.push(l);
+  }
+  const text = out.join('\n').trim();
+  return text || null;
+}
+
+export default async function verdict({ paths }) {
+  const file = paths.produces.find((p) => p.endsWith('.md'));
+  if (!file) {
+    return { decision: 'reject', reason: 'This step declares no .md artifact to read a verdict from.' };
+  }
+  let text;
+  try {
+    text = readFileSync(file, 'utf8');
+  } catch (err) {
+    return { decision: 'reject', reason: `Cannot read ${basename(file)}: ${err.message}` };
+  }
+  return readVerdict(text, basename(file));
+}

package/dist/templates/sdlc/validators/ci.mjs

@@ -9,7 +9,9 @@
  * Wire your project's CI into `CHECKS` below: each command runs in the
  * workspace root, and a non-zero exit maps to a `reject` verdict so the step
  * does not advance. With no checks configured it passes with a note, so the
- * pipeline still works out of the box.
+ * pipeline still works out of the box — but an `autopilot: true` run (the
+ * `native-autopilot` recipe) refuses to start while `CHECKS` is empty, and
+ * `aidlc doctor` says so: nobody reads the step, so this is its only gate.
  *
  * To turn auto-review off for this step instead, set `auto_review: false` on
  * the implement step in `.aidlc/workspace.yaml`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delete101020/aidlc",
-  "version": "4.0.39",
+  "version": "4.0.42",
   "description": "AIDLC Native CLI, a fork of AIDLC — drive Claude through the six-stage AI-Native SDLC Playbook: Plan → Design → Build → Test → Deploy → Maintain, with artifact gates, requirements traceability, an incident loop back to Plan, and Spec Kit support.",
   "license": "MIT",
   "repository": {