@ngockhoale/ukit 2.0.6 → 2.0.7

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to UKit are documented here.
 
+## 2.0.7 - 2026-08-15
+
+### Added
+
+- **`/ukit:handoff-create` and `/ukit:handoff-fullstack` gain a P2.5 independent plan review gate.** After the planner writes `PLAN.md` and before it's committed, a separate `code-reviewer` agent invocation (`REVIEW_TARGET_TYPE=plan`, fresh context — not the planner reviewing its own work) checks Completeness/Consistency/Clarity/Scope/YAGNI. `Issues Found` routes back to the planner to revise and resubmit; `Approved` unlocks the commit. Each round is logged to PLAN.md's new `## Plan Review Log` section, and the loop is capped at 3 `Issues Found` rounds — past that it escalates to the human instead of looping indefinitely.
+- **Same-wave file-conflict precheck in Phase 3.** Before spawning any implementation wave, `handoff-implement.md`/`handoff-fullstack.md` now compare `Target Files` across every task in that wave; any overlap stops the wave and marks both tasks `needs_breakdown` instead of risking a mid-wave merge conflict. Code-level backstop for the planner's existing "no shared files in one wave" scope constraint.
+- **TDD RED-state now requires real evidence.** The Executor Report template adds a mandatory `RED_OUTPUT` field — the actual failing-test output pasted before implementation, not a bare "confirmed" claim. `code-reviewer` checks this field during Test Plan adherence review and requests changes if it's missing or vague.
+- **`handoff.plan.requireLintOrTypecheckInVerification`** (default `true`): when the project has a lint/typecheck script, task Verification Commands must run it, not just tests; the planner must state an explicit N/A if the project has none. Enforced by `code-reviewer` as review-order step 0.
+
+### Changed
+
+- **`handoff.maxParallelAgents`**: 3 → 10, raising the default cap on concurrent background agents per wave (config comments still warn against exceeding ~10-15 — each agent's report gets injected back into the orchestrator's own context on completion).
+- **Phase 4 (Review) is now parallelized**, batched by `maxParallelAgents` the same way Phase 3 (Implement) already was — reviewer agents only read a diff and append a verdict to their own task file, so parallel review carries none of Phase 3's shared-worktree conflict risk.
+- **`handoff.plan.minTestsEdgeCase`**: 1 → 2, and the two edge cases must now be of different kinds (e.g. null/empty **and** boundary/concurrent) — two near-duplicate cases no longer satisfy the requirement. Wired through `handoff-planner`, `code-reviewer`, `feature-implementer`'s inline-test-plan fallback, `RULES.md`, and both handoff pipeline commands.
+
 ## 2.0.6 - 2026-08-12
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "Install/update an index-first AI workspace for Claude Code, Antigravity, OpenAI Codex, and OpenCode.",
   "license": "MIT",
   "type": "module",

package/templates/.claude/agents/code-reviewer.md

@@ -27,7 +27,8 @@ If any input is missing, return `CHANGES-REQUESTED` with reason "incomplete hand
 
 ### Review order
 
-1. **Test Plan adherence** — Were all tests in §4 actually implemented? Run them yourself: `<task Verification Commands>`. Fresh PASS required, no trusting executor's output blindly.
+0. **Verification package completeness** — Check whether the project has a lint or typecheck script (`package.json` scripts, or the stack's equivalent). If it does and the task's Verification Commands don't run it, that is `CHANGES-REQUESTED`: "verification commands missing lint/typecheck — re-run planner or add the command and re-verify" — do this before anything else below.
+1. **Test Plan adherence** — Were all tests in §4 actually implemented, including the ≥2 edge cases required by `handoff.plan.minTestsEdgeCase`? Check the Executor Report's `RED_OUTPUT` field: it must contain actual failing-test output (assertion failure, stack trace, non-zero exit), not a bare claim like "confirmed" or "yes". Missing or vague `RED_OUTPUT` → `CHANGES-REQUESTED`: "no evidence tests were RED before implementation — re-run TDD cycle and paste real output". Then run the tests yourself: `<task Verification Commands>`. Fresh PASS required, no trusting executor's output blindly.
 2. **Correctness** — Does the diff implement the requested behavior? Any obvious wrong assumptions, stale refs, missing cases?
 3. **Regression risk** — What existing behavior could this break? Are shared paths/tests/contracts still aligned? Run the wider test suite if shared code was touched.
 4. **Safety / security / data loss** — Destructive actions, auth/permission, path handling, unsafe shell/DB/file ops.
@@ -112,7 +113,10 @@ Only flag issues that would cause real problems during implementation planning.
 
 ### Output
 
+Append (do NOT overwrite) this block to the end of the reviewed document under a `## Plan Review Log` section — create the section if it doesn't exist yet, keep all prior round entries:
+
 ```
+### Round <N> — <YYYY-MM-DD> · <your model>
 Status: Approved | Issues Found
 
 COMPLETENESS:
@@ -128,3 +132,5 @@ YAGNI:
 
 NOTES: [1-2 sentences if needed]
 ```
+
+`<N>` = 1 + however many `### Round` entries already exist in the log (1 if this is the first review).

package/templates/.claude/agents/feature-implementer.md

@@ -30,7 +30,7 @@ If unsure, ask the user. Don't apply Handoff mode rules to a quick one-off fix.
 ### 2. Plan Approach (< 1 minute)
 
 - List files to create/modify (max diff).
-- **Handoff mode only:** if no Test Plan exists in the task file and task is not `trivial`, write one inline before implementing (happy + ≥1 edge case; regression test if fixing a bug). In daily mode, skip this step.
+- **Handoff mode only:** if no Test Plan exists in the task file and task is not `trivial`, write one inline before implementing (happy + ≥2 edge cases of different kinds; regression test if fixing a bug). In daily mode, skip this step.
 
 ### 3. Test First (RED) — Handoff mode
 

package/templates/.claude/agents/handoff-planner.md

@@ -37,9 +37,15 @@ Write all 7 sections to `docs/AI_HANDOFF/PLAN.md`:
                   CONSTRAINT: tasks in the same wave must not modify the same file.
                   If two tasks need the same file → make one depend on the other.
 §3 Approach     — technical solution, trade-offs, alternatives rejected
-§4 Test Plan    — happy path × N + ≥1 edge case + regression (if bugfix)
+§4 Test Plan    — happy path × N + ≥2 edge cases of DIFFERENT kinds (e.g. null/empty AND
+                  boundary/concurrent — two near-duplicate cases do not satisfy this) +
+                  regression (if bugfix)
                   table: | Type | Test Name | Expected |
-§5 Verification — exact shell commands executor will run
+§5 Verification — exact shell commands executor will run. If the project has a lint or
+                  typecheck script (check package.json `scripts`, or the equivalent for
+                  the project's stack), it MUST be included here, not just the test
+                  command. If the project genuinely has none, state that explicitly —
+                  do not omit silently.
 §6 Acceptance   — checklist of done criteria (prefer verifiable/command-based criteria)
 §7 Global Constraints — one line each: version floors, dependency limits, naming/copy
                   rules, platform requirements. Every TASK-xxx.md inherits this section
@@ -55,6 +61,8 @@ Append this footer to `PLAN.md` — mandatory, checked by a hook before the writ
 PLANNER_MODEL: <your exact model ID — e.g. claude-opus-5>
 ```
 
+Your output does not go straight to implementation: an independent `code-reviewer` pass (`REVIEW_TARGET_TYPE=plan`) reviews `PLAN.md` next. If it returns `Issues Found`, you'll be re-invoked to revise and resubmit — write §1-§7 tight enough to pass on the first pass.
+
 ## Phase 2 — Split into TASK-xxx.md
 
 **Right-sizing rule:** A task is the smallest unit that carries its own test cycle and is worth a fresh reviewer's gate. Split only where a reviewer could meaningfully approve one task while rejecting its neighbor. Each task ends with an independently testable deliverable.
@@ -67,9 +75,9 @@ Use `_TEMPLATE.md` structure (from pre-read context or file).
 |-------|------|
 | Target Files | Exact paths — no two tasks in same wave share a file |
 | Dependencies | `TASK-xxx` or `none` — wave order is inferred from this |
-| Test Cases | Type \| Test Name \| Expected — ≥1 happy + ≥1 edge case |
+| Test Cases | Type \| Test Name \| Expected — ≥1 happy + ≥2 edge cases of different kinds |
 | Test Files | Exact test file paths to create/modify |
-| Verification Commands | Runnable shell commands |
+| Verification Commands | Runnable shell commands — MUST include the project's lint/typecheck command if one exists (see §5 rule above) |
 | Acceptance Criteria | Verifiable checklist |
 
 Missing any field → `needs_breakdown`. Never mark incomplete tasks `ready`.

package/templates/.claude/commands/ukit/handoff-create.md

@@ -48,7 +48,7 @@ The planner agent does the following (use Step 1 summary — do NOT re-read file
    - §1 Intent — problem + success definition
    - §2 Scope — in / out of scope. **Add a constraint**: same-wave tasks must not modify the same file (prevents merge conflicts). If two tasks need the same file, make one depend on the other.
    - §3 Approach — solution, trade-offs, alternatives rejected
-   - §4 Test Plan — happy path + ≥1 edge case + regression if bugfix (non-negotiable)
+   - §4 Test Plan — happy path + ≥2 edge cases of different kinds + regression if bugfix (non-negotiable)
    - §5 Verification — exact shell commands executor will run
    - §6 Acceptance — done checklist (prefer verifiable criteria with commands)
 
@@ -62,7 +62,7 @@ The planner agent does the following (use Step 1 summary — do NOT re-read file
    Every task MUST have:
    - Target Files (exact paths — no two tasks in same wave share a file)
    - Dependencies (`TASK-xxx` or `none` — wave structure inferred from this, not stored separately)
-   - Test Cases (Type | Name | Expected — ≥1 happy + ≥1 edge case)
+   - Test Cases (Type | Name | Expected — ≥1 happy + ≥2 edge cases of different kinds)
    - Test Files (exact paths)
    - Verification Commands (runnable shell commands)
    - Acceptance Criteria (verifiable checklist)
@@ -85,4 +85,18 @@ The planner agent does the following (use Step 1 summary — do NOT re-read file
 
 ---
 
+## Step 2.5 — Independent plan review (strong model, separate agent)
+
+**Loop cap — check first:** count `### Round` entries in PLAN.md's `## Plan Review Log` (0 if the section doesn't exist yet). If count ≥ 3 (3 prior rounds already returned `Issues Found`), do NOT invoke the reviewer again — STOP and escalate to the human: show the accumulated findings from all 3 rounds, ask them to manually revise PLAN.md, narrow scope, or explicitly approve an override. Otherwise, proceed below.
+
+**Claude Code — MANDATORY, do this before anything else:** call the Agent tool with `subagent_type: "code-reviewer"`, passing `REVIEW_TARGET_TYPE=plan` and the path to `docs/AI_HANDOFF/PLAN.md`. This MUST be a separate agent invocation from Step 2's `handoff-planner` call (fresh context) — same-session self-review defeats the purpose of an independent gate.
+
+1. Reviewer reads `PLAN.md` only (no diff, no task files, no executor report), checks Completeness / Consistency / Clarity / Scope / YAGNI — see `.claude/agents/code-reviewer.md` → Spec/Plan Review — and appends its verdict to PLAN.md's `## Plan Review Log` (new round entry, prior rounds kept).
+2. `Issues Found` → route back to Step 2: planner revises `PLAN.md` and the affected `TASK-xxx.md` files to address every finding, then re-submit for another Step 2.5 review (this becomes the next round). Do NOT commit or hand off to executor on `Issues Found`.
+3. `Approved` → append `PLAN_REVIEW: Approved by <reviewer model>` to PLAN.md's `## Planner Report` footer, then proceed.
+
+> Other tools without subagent support: manually switch to the strong model in a **separate** chat/session from Step 2, paste PLAN.md, review using the Spec/Plan Review checklist in `.claude/agents/code-reviewer.md`.
+
+---
+
 **Next:** switch to code model → `/ukit:handoff-implement`

package/templates/.claude/commands/ukit/handoff-fullstack.md

@@ -57,7 +57,7 @@ The planner agent does the following (use P1 summary — do NOT re-read files):
    - §1 Intent — problem + success definition
    - §2 Scope — in / out of scope; same-wave tasks must not modify the same file (prevents merge conflicts)
    - §3 Approach — solution, trade-offs, alternatives rejected
-   - §4 Test Plan — happy path + ≥1 edge case + regression if bugfix (non-negotiable)
+   - §4 Test Plan — happy path + ≥2 edge cases of different kinds + regression if bugfix (non-negotiable)
    - §5 Verification — exact shell commands executor will run
    - §6 Acceptance — done checklist (prefer verifiable criteria with commands)
 
@@ -71,7 +71,7 @@ The planner agent does the following (use P1 summary — do NOT re-read files):
    Every task MUST have:
    - Target Files (exact paths — no two tasks in same wave share a file)
    - Dependencies (`TASK-xxx` or `none` — wave structure inferred from this)
-   - Test Cases (Type | Name | Expected — ≥1 happy + ≥1 edge case)
+   - Test Cases (Type | Name | Expected — ≥1 happy + ≥2 edge cases of different kinds)
    - Test Files (exact paths)
    - Verification Commands (runnable shell commands)
    - Acceptance Criteria (verifiable checklist)
@@ -89,6 +89,18 @@ The planner agent does the following (use P1 summary — do NOT re-read files):
 
 7. **Report:** task IDs, dependency graph, any `needs_breakdown` tasks + reason.
 
+### P2.5 — Independent plan review (strong model, separate agent)
+
+**Loop cap — check first:** count `### Round` entries in PLAN.md's `## Plan Review Log` (0 if the section doesn't exist yet). If count ≥ 3 (3 prior rounds already returned `Issues Found`), do NOT invoke the reviewer again — STOP and escalate to the human: show the accumulated findings from all 3 rounds, ask them to manually revise PLAN.md, narrow scope, or explicitly approve an override. Otherwise, proceed below.
+
+**Claude Code — MANDATORY, do this before anything else in P2.5:** call the Agent tool with `subagent_type: "code-reviewer"`, passing `REVIEW_TARGET_TYPE=plan` and the path to `docs/AI_HANDOFF/PLAN.md`. This MUST be a separate agent invocation from P2's `handoff-planner` call (fresh context) — same-session self-review defeats the purpose of an independent gate.
+
+1. Reviewer reads `PLAN.md` only (no diff, no task files, no executor report), checks Completeness / Consistency / Clarity / Scope / YAGNI — see `.claude/agents/code-reviewer.md` → Spec/Plan Review — and appends its verdict to PLAN.md's `## Plan Review Log` (new round entry, prior rounds kept).
+2. `Issues Found` → route back to P2: `handoff-planner` revises `PLAN.md` and the affected `TASK-xxx.md` files to address every finding, then re-submit for another P2.5 review (this becomes the next round). Do NOT proceed to P3 on `Issues Found`.
+3. `Approved` → append `PLAN_REVIEW: Approved by <reviewer model>` to PLAN.md's `## Planner Report` footer, then proceed to P3.
+
+> Other tools without subagent support: manually switch to the strong model in a **separate** chat/session from P2, paste PLAN.md, review using the Spec/Plan Review checklist in `.claude/agents/code-reviewer.md`.
+
 ### P3 — Commit the plan (lite model)
 
 **Claude Code — MANDATORY:** call the Agent tool with `subagent_type: "ukit-small-task-maintainer"` for this commit step (lite tier — haiku/unic-lite). Run:
@@ -127,8 +139,16 @@ Read each `docs/AI_HANDOFF/tasks/TASK-xxx.md` for `Dependencies` field:
 - Chain A→B→C = 3 waves of 1 task each (sequential)
 - Independent A, B, C = 1 wave of 3 tasks (parallel)
 
+**Conflict check — mandatory, before spawning any wave.** For every pair of tasks landing
+in the same wave, compare their `Target Files` lists. If any file path appears in both,
+STOP — do not spawn that wave. This is the code-level safety net for the planner's own §2
+Scope constraint (same-wave tasks must not share a file) in case it slipped through
+review. Mark both conflicting tasks `needs_breakdown` in `INDEX.md` and report the
+conflicting file(s) to the human; do not resolve it yourself by reordering or guessing a
+dependency.
+
 **Batch each wave — mandatory.** Read `handoff.maxParallelAgents` from
-`.ukit/storage/config.json` (default **3**). A wave with more tasks than that is split
+`.ukit/storage/config.json` (default **10**). A wave with more tasks than that is split
 into consecutive batches of at most that many; finish one batch completely (including 3c
 copy-back and worktree deletion) before starting the next.
 
@@ -139,7 +159,7 @@ leaves worktrees behind. Batching only ever narrows a wave, never reorders acros
 
 ### I3 — Execute wave by wave (code model agents)
 
-**Claude Code — MANDATORY, do this before anything else in I3:** for each wave, call the Agent tool once per task **in the current batch** (in parallel, at most `handoff.maxParallelAgents` — default 3), each with `subagent_type: "feature-implementer"`. Do NOT implement the tasks yourself in the current session — this step is contracted to the code tier (sonnet/unic-code), which only the spawned agent's frontmatter model guarantees.
+**Claude Code — MANDATORY, do this before anything else in I3:** for each wave, call the Agent tool once per task **in the current batch** (in parallel, at most `handoff.maxParallelAgents` — default 10), each with `subagent_type: "feature-implementer"`. Do NOT implement the tasks yourself in the current session — this step is contracted to the code tier (sonnet/unic-code), which only the spawned agent's frontmatter model guarantees.
 
 For each wave:
 
@@ -156,7 +176,8 @@ Read docs/AI_HANDOFF/tasks/TASK-xxx.md
 TDD — mandatory:
   1. Write tests from §Test Cases
      cd .worktrees/task-xxx && <test command>
-     Confirm RED (immediately GREEN → test is wrong — flag this)
+     Confirm RED — paste the actual failing output, don't just assert it happened
+     (immediately GREEN → test is wrong — flag this)
   2. Implement → run → confirm GREEN
   3. Run §Verification Commands inside the worktree:
      cd .worktrees/task-xxx && <each verification command>
@@ -169,6 +190,8 @@ Executor Report (append to task file — do NOT touch INDEX.md):
   EXECUTOR_TOOL: <tool>
   EXECUTOR_MODEL: <exact model ID — mandatory>
   EXECUTOR_SUBAGENT: <name or "-">
+  RED_OUTPUT: <paste the actual failing-test output from step 1 — a claim like
+               "confirmed" without pasted output is not acceptable>
   Verification Output: <paste full output>
   Status: PASS | FAIL
   Note: <issues or "none">
@@ -250,7 +273,9 @@ If `git diff` is empty and `git status` is clean → implement was not completed
 
 ### R2 — Model isolation check (strong model, always first)
 
-**Claude Code — MANDATORY, do this before anything else in R2–R4:** for each `pending_review` task, call the Agent tool with `subagent_type: "code-reviewer"`. Do NOT review the diff yourself in the current session — this step is contracted to the strong tier (opus/unic-smart) and MUST differ from the executor's model, which only the spawned agent's frontmatter model guarantees.
+**Batch the review set — mandatory.** Read `handoff.maxParallelAgents` from `.ukit/storage/config.json` (default **10**). If more `pending_review` tasks exist than that, split into consecutive batches of at most that many; finish one batch's verdicts (R2–R4, appended to each task file) before starting the next.
+
+**Claude Code — MANDATORY, do this before anything else in R2–R4:** for each batch, call the Agent tool once per `pending_review` task **in parallel** (at most `handoff.maxParallelAgents`), each with `subagent_type: "code-reviewer"`. Reviewer agents only read the diff and append a verdict to their own task file — no worktree, no shared write target — so running them in parallel carries none of Phase 3's file-conflict risk. Do NOT review the diff yourself in the current session — this step is contracted to the strong tier (opus/unic-smart) and MUST differ from the executor's model, which only the spawned agent's frontmatter model guarantees.
 
 The spawned reviewer agent reads `EXECUTOR_MODEL` from each task file `## Executor Report`:
 

package/templates/.claude/commands/ukit/handoff-implement.md

@@ -33,9 +33,18 @@ Read each `tasks/TASK-xxx.md` for `Dependencies` field:
 - Chain A→B→C = 3 waves of 1 task each (sequential, no parallel)
 - Independent A, B, C = 1 wave of 3 tasks (parallel)
 
+### Conflict check — mandatory, before spawning any wave
+
+For every pair of tasks landing in the same wave, compare their `Target Files` lists. If
+any file path appears in both, STOP — do not spawn that wave. This is the code-level
+safety net for the planner's own §2 Scope constraint (same-wave tasks must not share a
+file) in case it slipped through review. Mark both conflicting tasks `needs_breakdown` in
+`INDEX.md` and report the conflicting file(s) to the human; do not resolve it yourself by
+reordering or guessing a dependency.
+
 ### Batch each wave — mandatory
 
-Read `handoff.maxParallelAgents` from `.ukit/storage/config.json` (default **3**). A wave
+Read `handoff.maxParallelAgents` from `.ukit/storage/config.json` (default **10**). A wave
 with more tasks than that is split into consecutive batches of at most that many; finish
 one batch completely (including 3c copy-back and worktree deletion) before starting the
 next.
@@ -68,7 +77,8 @@ Read docs/AI_HANDOFF/tasks/TASK-xxx.md
 TDD — mandatory:
   1. Write tests from §Test Cases
      cd .worktrees/task-xxx && <test command>
-     Confirm RED (immediately GREEN → test is wrong — flag this)
+     Confirm RED — paste the actual failing output, don't just assert it happened
+     (immediately GREEN → test is wrong — flag this)
   2. Implement → run → confirm GREEN
   3. Run §Verification Commands inside the worktree:
      cd .worktrees/task-xxx && <each verification command>
@@ -81,6 +91,8 @@ Executor Report (append to task file — do NOT touch INDEX.md):
   EXECUTOR_TOOL: <tool>
   EXECUTOR_MODEL: <exact model ID — mandatory>
   EXECUTOR_SUBAGENT: <name or "-">
+  RED_OUTPUT: <paste the actual failing-test output from step 1 — a claim like
+               "confirmed" without pasted output is not acceptable>
   Verification Output: <paste>
   Status: PASS | FAIL
   Note: <issues or "none">

package/templates/.claude/commands/ukit/handoff-review.md

@@ -28,7 +28,9 @@ If `git diff` is empty and `git status` is clean → handoff-implement was not c
 
 ## Step 2 — Review the diff
 
-**Claude Code — MANDATORY, do this before anything else:** for each `pending_review` task, call the Agent tool with `subagent_type: "code-reviewer"`. Do NOT review the diff yourself in the current session — this step is contracted to the strong tier (opus/unic-smart) and MUST differ from the executor's model, which only the spawned agent's frontmatter model guarantees. Pass each agent: the task file path, the executor's report, and the diff.
+**Batch the review set — mandatory.** Read `handoff.maxParallelAgents` from `.ukit/storage/config.json` (default **10**). If more `pending_review` tasks exist than that, split into consecutive batches of at most that many; finish one batch's verdicts (2a–2d, appended to each task file) before starting the next.
+
+**Claude Code — MANDATORY, do this before anything else:** for each batch, call the Agent tool once per `pending_review` task **in parallel** (at most `handoff.maxParallelAgents`), each with `subagent_type: "code-reviewer"`. Reviewer agents only read the diff and append a verdict to their own task file — no worktree, no shared write target — so running them in parallel carries none of Phase 3's file-conflict risk. Do NOT review the diff yourself in the current session — this step is contracted to the strong tier (opus/unic-smart) and MUST differ from the executor's model, which only the spawned agent's frontmatter model guarantees. Pass each agent: the task file path, the executor's report, and the diff.
 
 The spawned reviewer agent performs 2a–2d below per task:
 
@@ -115,4 +117,4 @@ Review summary:
 - Has fixes → executor re-runs `/ukit:handoff-implement TASK-xxx`
 
 > Orchestrator (this session) handles Step 1, 2e, and 3 directly — those are not delegated.
-> Other tools without subagent support: manually switch to the strong model, run 2a–2d sequentially per task.
+> Other tools without subagent support: manually switch to the strong model, run 2a–2d per task (one session at a time).

package/templates/docs/AI_HANDOFF/RULES.md

@@ -77,9 +77,9 @@ pending_review ──[reviewer]──▶ approved | approved_minor ──▶ don
 **Phase 2 — Create Tasks (TDD-embedded, MANDATORY)** (smart/reasoning model, thường cùng phase 1)
 - Human approve plan → AI split `PLAN.md §7` sang nhiều `tasks/TASK-xxx.md`.
 - **Mỗi TASK file BẮT BUỘC có Test Plan của riêng nó**, không chỉ trỏ về PLAN.md. Cụ thể:
-  - `§ Test Cases`: bảng test (loại, tên test, expected) cho phần task này — happy + ≥1 edge case + regression (nếu fix bug).
+  - `§ Test Cases`: bảng test (loại, tên test, expected) cho phần task này — happy + ≥2 edge case KHÁC loại nhau (vd null/empty + boundary/concurrent, không tính 2 case gần giống nhau) + regression (nếu fix bug).
   - `§ Test Files`: đường dẫn cụ thể file test sẽ tạo/sửa (ví dụ `tests/auth/login.test.js`).
-  - `§ Verification Commands`: lệnh executor sẽ chạy để xác nhận PASS.
+  - `§ Verification Commands`: lệnh executor sẽ chạy để xác nhận PASS. Nếu project có sẵn lint/typecheck script → BẮT BUỘC liệt kê ở đây, không chỉ lệnh test. Project không có thì ghi rõ N/A, không được bỏ qua im lặng.
   - `§ Acceptance Criteria`: checklist.
 - Nếu split mà task nào không kèm được Test Cases + Test Files cụ thể → task đó chưa đủ `ready`, đánh `needs_breakdown`.
 - Update `INDEX.md`: thêm row mỗi task với status `ready`.
@@ -88,7 +88,7 @@ pending_review ──[reviewer]──▶ approved | approved_minor ──▶ don
 
 **Phase 3 — Implement + Test** (cheap-smart/code model)
 - User: "execute next task" / "làm TASK-001" / "implement task 1".
-- Executor đọc `INDEX.md` → pick `ready` task → đổi `in_progress` → **viết test trước → RED → implement → GREEN** → chạy Verification Commands fresh trong turn → append `## Executor Report` (gồm `EXECUTOR_TOOL`/`EXECUTOR_MODEL`/`EXECUTOR_SUBAGENT` + verification output) vào cuối task file → đổi status `pending_review`.
+- Executor đọc `INDEX.md` → pick `ready` task → đổi `in_progress` → **viết test trước → RED (paste output failing thật, không chỉ khai đã confirm) → implement → GREEN** → chạy Verification Commands fresh trong turn → append `## Executor Report` (gồm `EXECUTOR_TOOL`/`EXECUTOR_MODEL`/`EXECUTOR_SUBAGENT`/`RED_OUTPUT` + verification output) vào cuối task file → đổi status `pending_review`.
 - KHÔNG được claim DONE nếu chưa có PASS fresh.
 
 **Phase 4 — Review + Test** (reviewer model — KHÁC model executor)
@@ -108,8 +108,8 @@ A task is `ready` only when it has:
 - Dependencies stated
 - **Interfaces** — Consumes/Produces với chữ ký thật (function/endpoint/type), không placeholder;
   `(none)` hợp lệ nếu task không có input/output liên task
-- **Test Plan** (PLAN.md §4) — happy path + ≥1 edge case (+ regression test nếu fix bug); hoặc `N/A` kèm lý do
-- Verification command (lệnh executor sẽ chạy)
+- **Test Plan** (PLAN.md §4) — happy path + ≥2 edge case khác loại (+ regression test nếu fix bug); hoặc `N/A` kèm lý do
+- Verification command (lệnh executor sẽ chạy) — PHẢI gồm lint/typecheck nếu project có sẵn
 - Acceptance criteria
 
 Missing any → `needs_breakdown`, `blocked`, or `needs_human`.

package/templates/ukit/storage/config.json

@@ -186,11 +186,12 @@
   "handoff": {
     "enabled": true,
     "crossTool": true,
-    "maxParallelAgents": 3,
+    "maxParallelAgents": 10,
     "plan": {
       "requireTestPlan": true,
       "minTestsHappyPath": 1,
-      "minTestsEdgeCase": 1,
+      "minTestsEdgeCase": 2,
+      "requireLintOrTypecheckInVerification": true,
       "regressionTestRequiredForBugfix": true,
       "smartModelHint": "claude-opus-5"
     },
@@ -479,11 +480,12 @@
     "handoff": {
       "enabled": "Bật Quality Gate cho handoff: plan có Test Plan, executor test-first, reviewer model khác. Tắt = quay về flow cũ (dễ lọt lỗi vặt).",
       "crossTool": "true nghĩa là handoff truyền qua file (PLAN/INDEX/tasks) chứ không qua in-process subagent — cho phép plan ở Claude Code, execute ở Kilo Code, review ở Claude Code khác model.",
-      "maxParallelAgents": "Số agent chạy song song TỐI ĐA trong một wave (mặc định 3). Một wave có nhiều task hơn số này sẽ được chia thành nhiều batch chạy lần lượt. Lý do: mỗi agent nền có context window riêng, và report của agent khi xong sẽ được inject ngược vào session chính — chạy quá nhiều cùng lúc là cách nhanh nhất làm session chính vượt context window. Hạ xuống 2 nếu task nặng; không nên vượt 3.",
+      "maxParallelAgents": "Số agent chạy song song TỐI ĐA trong một wave (mặc định 10, tăng từ 3 để giảm thời gian chờ khi có nhiều task độc lập). Một wave có nhiều task hơn số này sẽ được chia thành nhiều batch chạy lần lượt — áp dụng cho cả Phase 3 Implement và Phase 4 Review. Lý do giới hạn vẫn còn: mỗi agent nền có context window riêng, và report của agent khi xong sẽ được inject ngược vào session chính — chạy quá nhiều cùng lúc (vd 20+) vẫn có thể làm session chính vượt context window và bỏ lại worktree rác. Hạ xuống 3-5 nếu task nặng (verification output dài) hoặc thấy compact bị trigger liên tục; tránh vượt quá ~10-15.",
       "plan": {
         "requireTestPlan": "Bắt buộc PLAN.md §4 phải có Test Plan trước khi task chuyển ready.",
         "minTestsHappyPath": "Tối thiểu test cho happy path.",
-        "minTestsEdgeCase": "Tối thiểu test cho edge case (null/empty/boundary/concurrent…).",
+        "minTestsEdgeCase": "Tối thiểu test cho edge case (mặc định 2, tăng từ 1 — phải khác loại nhau, vd null/empty + boundary/concurrent, không tính 2 test gần giống nhau là đủ).",
+        "requireLintOrTypecheckInVerification": "Nếu project có sẵn lint/typecheck script (package.json hoặc tương đương), Verification Commands của mỗi task BẮT BUỘC phải gồm lệnh đó — không chỉ chạy test. Project không có lint/typecheck thì planner phải ghi rõ lý do N/A thay vì bỏ qua im lặng.",
         "regressionTestRequiredForBugfix": "Bug fix phải có regression test fail-trước-fix.",
         "smartModelHint": "Gợi ý model mạnh nhất cho phase plan (ví dụ claude-opus-5). UKit không tự ép, chỉ ghi hint vào task."
       },