@ludecker/aaac 1.0.0 → 1.1.0

package/templates/cursor/agents/fix-repro.md

@@ -0,0 +1,29 @@
+# Agent: fix-repro
+
+**Readonly.** Do not edit files.
+
+## Role
+
+Confirm the reported symptom and produce deterministic reproduction steps.
+
+## Inputs (from parent)
+
+- Intent (symptom + expected behavior)
+- Domain slug and inventory path when available
+- Route, URL, error message, or CLI output if provided
+
+## Procedure
+
+1. Restate **Issue**, **Symptoms**, **Expected** in one line each
+2. Find the smallest path to reproduce (route, component, query, migration, CLI command)
+3. List **repro steps** numbered (max 8 steps)
+4. Note **environment** (local dev, production, browser, auth state)
+5. Mark **repro_confirmed**: yes | partial | no — with evidence
+
+## Return
+
+- Findings (bullets, product language in summary)
+- Evidence (`path:line`, log snippet, test name — no secrets)
+- Gaps (what could not be reproduced)
+- `repro_confirmed`: yes | partial | no
+- Confidence: high | medium | low

package/templates/cursor/agents/fix-runtime-evidence.md

@@ -0,0 +1,22 @@
+# Agent: fix-runtime-evidence
+
+**Readonly.** Do not edit files.
+
+## Role
+
+Gather runtime evidence — logs, CI, MCP, browser errors — for the symptom.
+
+## Procedure
+
+1. If intent mentions CI or deploy → use `ci-investigator` subagent pattern or read recent workflow logs
+2. If database/RLS → Supabase MCP `get_logs`, `get_advisors` (project `anseivwusnyiwopihnqu`)
+3. If Render deploy → check deployment status via Render MCP when available
+4. If error message pasted → search codebase for matching string
+5. Never log secrets or tokens
+
+## Return
+
+- Runtime signals (errors, status codes, advisor findings)
+- Evidence sources (CI run, log type, MCP tool)
+- Whether symptom is **production-only** or **local-only**
+- Confidence: high | medium | low

package/templates/cursor/agents/fix-test-failures.md

@@ -0,0 +1,23 @@
+# Agent: fix-test-failures
+
+**Readonly.** Do not edit files unless running tests is required — prefer read-only test discovery.
+
+## Role
+
+Find existing tests, failures, and coverage gaps related to the symptom.
+
+## Procedure
+
+1. Search domain inventory for test paths and vitest config
+2. Run targeted tests only when necessary (`pnpm test` scoped to relevant package)
+3. List **failing tests** with assertion message and file
+4. List **missing coverage** — behavior with no test near suspect code
+5. Propose **minimal test** that would catch regression (describe only — do not implement)
+
+## Return
+
+- Existing tests covering symptom area
+- Failures (name, file, message)
+- Coverage gaps
+- Suggested regression test (one sentence)
+- Confidence: high | medium | low

package/templates/cursor/agents/playwright-check-run.md

@@ -0,0 +1,44 @@
+# Agent: playwright-check-run
+
+## Role
+
+Run AAAC verb contract Playwright checks and optional public-site smoke during verify.
+
+## When
+
+**Verify phase** for commands whose verb is `create`, `update`, or `fix` (including aliases such as `fix-module`, `create-component`, `update-module`).
+
+**Report phase** for commands whose verb is `check` (including `check-module`, `check-component`, …) — readonly; contract checks only.
+
+Contract checks always run. Browser smoke runs only when `PLAYWRIGHT_BASE_URL` is set.
+
+## Commands
+
+From repo root:
+
+```bash
+pnpm --filter @ludecker/aaac test:e2e
+```
+
+Optional website smoke (dev server or deployed URL):
+
+```bash
+PLAYWRIGHT_BASE_URL=http://localhost:3000 pnpm --filter @ludecker/aaac test:e2e
+```
+
+Interactive debugging:
+
+```bash
+pnpm --filter @ludecker/aaac test:e2e:ui
+```
+
+## What passes
+
+- `runtime-registry.json` command entries match `graph.yaml` `verb_runtime` for the command verb
+- Fix verb includes `investigate_swarm` and `root_cause` before `plan`
+- Check verb has no `execute` or `plan` — pending matches `verb_runtime.check`
+- Skipped browser tests when `PLAYWRIGHT_BASE_URL` is unset (CI default)
+
+## Return
+
+Exit code, failing spec file names, contract mismatch details (command vs `verb_runtime`), browser smoke failures with route and status.

package/templates/cursor/hooks/aaac-before-submit.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+exec node .cursor/aaac/scripts/run-engine/init-run.mjs

package/templates/cursor/hooks/aaac-pre-tool.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# AAAC: block code edits until execute phase. failClosed in hooks.json.
+set -euo pipefail
+exec node .cursor/aaac/scripts/run-engine/gate-write.mjs

package/templates/cursor/hooks/aaac-stop.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+exec node .cursor/aaac/scripts/run-engine/stop-check.mjs

package/templates/cursor/hooks/aaac-subagent-start.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+exec node .cursor/aaac/scripts/run-engine/record-task.mjs

package/templates/cursor/hooks.json

@@ -0,0 +1,30 @@
+{
+  "version": 1,
+  "hooks": {
+    "beforeSubmitPrompt": [
+      {
+        "command": ".cursor/hooks/aaac-before-submit.sh",
+        "matcher": "UserPromptSubmit"
+      }
+    ],
+    "preToolUse": [
+      {
+        "command": ".cursor/hooks/aaac-pre-tool.sh",
+        "matcher": "Write|StrReplace|Delete|EditNotebook|ApplyPatch",
+        "failClosed": true
+      }
+    ],
+    "subagentStart": [
+      {
+        "command": ".cursor/hooks/aaac-subagent-start.sh",
+        "failClosed": false
+      }
+    ],
+    "stop": [
+      {
+        "command": ".cursor/hooks/aaac-stop.sh",
+        "loop_limit": 5
+      }
+    ]
+  }
+}

package/templates/cursor/policies/minimal-complexity.md

@@ -0,0 +1,101 @@
+# Policy: Minimal complexity
+
+**SSOT:** [.cursor/aaac/complexity.yaml](../aaac/complexity.yaml)
+
+**Applies to:** `create`, `update`, `fix` commands (and domain orchestrators in those modes).
+
+**Loaded with:** master-rules, implementation, mcp-and-deploy — before plan phase on mutating verbs.
+
+## Optimization target
+
+```text
+User request
+  → Simplest solution that satisfies all stated requirements
+  → NOT the most elegant or future-proof architecture
+```
+
+Optimize **capability / complexity**, not capability alone.
+
+## Strategy priority (mandatory)
+
+Before proposing new artifacts, search and document in the plan:
+
+```text
+1. Reuse existing function / component / module
+2. Extend existing (minimal additive change)
+3. Modify existing in place
+4. Create new — only when 1–3 cannot satisfy a stated requirement
+```
+
+**Default verb bias:** prefer `update` over `create` when intent is ambiguous.
+
+## YAGNI
+
+Future requirements **do not exist** unless the user explicitly stated them.
+
+Reject plan items justified only by:
+
+- maybe later / might need
+- future-proofing / scalability / extensibility
+- generic framework / plugin system / event bus “for flexibility”
+
+If the user did state a future requirement, cite their exact words in `requirement_map`.
+
+## Complexity score
+
+Sum weights from [complexity.yaml](../aaac/complexity.yaml) for each **net-new** artifact in the plan.
+
+| Verb | Max score (block above) |
+|------|-------------------------|
+| fix | 5 |
+| update | 8 |
+| create | 12 |
+
+Lower score wins when comparing alternatives. Document rejected higher-score options in `rejected_alternatives`.
+
+## Plan artifact (required)
+
+Before `validate` gate on create/update/fix, write to Run `artifacts.plan`:
+
+```yaml
+requirement_map:
+  - requirement: "User can export CSV"
+    satisfies_with: ["ExportButton", "GET /api/export"]
+complexity_score: 2
+complexity_breakdown:
+  new_component: 0
+  new_api_endpoint: 1
+  modify: 1
+reuse:
+  - "ExportButton pattern from packages/ui"
+modify:
+  - "apps/website/app/api/export/route.ts (extend existing export handler)"
+create:
+  - artifact: "GET /api/export/csv"
+    kind: new_api_endpoint
+    requirement_ref: "User can export CSV"
+    why_not_reuse: "No existing CSV export route"
+rejected_alternatives:
+  - option: "Event bus + background queue + retry framework"
+    complexity_score: 14
+    rejected_because: "No requirement for async or retries"
+```
+
+## Gate enforcement
+
+| Gate | Check |
+|------|-------|
+| **validate** | Plan fields present; no unjustified create; YAGNI |
+| **fitness_functions** | `minimal_complexity` pass; score ≤ threshold |
+
+On fail → Run `blocked`, `awaiting_approval: true` — same as other gates.
+
+## Fix verb
+
+Fix plans must be **minimal correct change** — smallest diff that resolves root cause. Prefer modify over create. Score threshold is strictest (5).
+
+## Pruning mindset
+
+On create/update, ask: **what existing code can this replace or extend?**
+
+Deletion and simplification are in scope for `update`/`fix` when they reduce complexity without breaking requirements.

package/templates/cursor/rules/aaac-enforcement.mdc

@@ -0,0 +1,42 @@
+---
+description: AAAC pipeline enforcement — hooks block edits until Run reaches execute phase. Applies to ALL slash commands.
+alwaysApply: true
+---
+
+# AAAC enforcement (mandatory)
+
+**Runtime SSOT:** [.cursor/hooks.json](../hooks.json), [.cursor/aaac/enforcement.json](../aaac/enforcement.json)
+
+Every AAAC slash command (`/fix-module`, `/update-module`, `/write-article`, …) **must** execute inside a **Run**. This is not optional.
+
+## Prerequisites
+
+1. **Cursor Hooks enabled** — Settings → Hooks; restart Cursor after `.cursor/hooks.json` changes
+2. **Registry current** — `node .cursor/aaac/generate-graph.mjs`
+
+## Hook behavior (automatic)
+
+| Hook | Effect |
+|------|--------|
+| `beforeSubmitPrompt` | Detects `/command` → creates Run scoped to **`conversation_id`** (this chat only) |
+| `preToolUse` | **Denies** Write/StrReplace/Delete for **this chat only** until execute phase |
+| `subagentStart` | Counts Task launches for swarm phase validation |
+| `stop` | Follow-up if Run not `completed` |
+
+## Agent obligations
+
+1. **First action** after AAAC command: confirm Run exists for **this chat** (`.cursor/aaac/state/active-runs/{conversation_id}.json`). If missing, the `beforeSubmitPrompt` hook creates it automatically.
+2. **Never skip phases.** Complete swarms, write Run artifacts, then advance:
+   ```bash
+   node .cursor/aaac/scripts/run-engine/advance-phase.mjs <run_id> <phase>
+   ```
+3. **Swarm minimums** (enforced by advance-phase):
+   - `discover`: 4 Task agents
+   - `investigate_swarm`: 7 Task agents
+   - `research_swarm`: 6 Task agents
+4. **Code edits only in `execute`** (hook-enforced). Before execute: artifacts only under `.cursor/aaac/state/runs/`.
+5. **Complete the Run** — advance through `report`, set status completed.
+
+## If edit is denied
+
+Continue the pipeline — do not work around hooks. Full dispatch: [.cursor/aaac/dispatch.md](../aaac/dispatch.md)

package/templates/cursor/skills/shared/execution/SKILL.md

@@ -21,7 +21,7 @@ Orchestrator phase `execute` after approved plan.
 ## Actions
 
 - Edit files per plan and implementation skill
-- `apply_migration` for new/changed `supabase/migrations/` (project `hjadkzfemzuvhpwbixbt`)
+- `apply_migration` for new/changed `supabase/migrations/` (project `anseivwusnyiwopihnqu` — see [supabase-mcp.mdc](../../../rules/supabase-mcp.mdc))
 - `track()` for user-facing mutations
 - Structured logging on server async paths
 

package/templates/cursor/skills/shared/fitness-functions/SKILL.md

@@ -2,7 +2,7 @@
 name: shared-fitness-functions
 description: >-
   Score architecture fitness functions before execute; re-check in verify.
-  Not user-facing.
+  Includes minimal_complexity for create/update/fix. Not user-facing.
 disable-model-invocation: true
 ---
 
@@ -12,13 +12,28 @@ disable-model-invocation: true
 
 ## SSOT
 
-[fitness-functions.yaml](../../../aaac/fitness-functions.yaml)
+[fitness-functions.yaml](../../../aaac/fitness-functions.yaml)  
+Complexity config: [complexity.yaml](../../../aaac/complexity.yaml)
 
 ## Procedure
 
 1. Filter `functions` where command `object` ∈ `applies_to`
-2. Load linked skill per function (e.g. `ludecker-api-first`, `ludecker-design-system`)
-3. Score each: `pass` | `warning` | `fail` against planned changes
+2. For **create / update / fix**, always score `minimal_complexity` (see `applies_to_verbs`)
+3. Load linked skill or policy per function
+4. Score each: `pass` | `warning` | `fail` against planned changes in Run `artifacts.plan`
+
+## minimal_complexity (mutating verbs)
+
+Policy: [minimal-complexity.md](../../../policies/minimal-complexity.md)
+
+| Check | fail |
+|-------|------|
+| `complexity_score` ≤ verb threshold | score above threshold |
+| Reuse-first documented | create without `why_not_reuse` |
+| YAGNI | speculative architecture in plan |
+| fix minimalism | fix plan score > 5 or large create list |
+
+**Blocking** — same as `security` and `layer_boundaries`.
 
 ## Output
 
@@ -30,13 +45,14 @@ score:
   security: pass | warning | fail
   layer_boundaries: pass | warning | fail
   performance: pass | warning | fail
+  minimal_complexity: pass | warning | fail
 blocking_failures: [function names — empty if none]
 ```
 
+Store on Run `artifacts.fitness` and `gates.results.fitness_functions`.
+
 ## Gates
 
-- Any **fail** on `security` or `layer_boundaries` → **STOP** before execute
+- Any **fail** on `security`, `layer_boundaries`, or **`minimal_complexity`** → **STOP** before execute
 - **warning** → document in report; may proceed if validation passed
 - Re-run abbreviated score in [verification](../verification/SKILL.md) after execute
-
-Turns "read architecture.md" into enforceable checks.

package/templates/cursor/skills/shared/investigation/SKILL.md

@@ -1,46 +1,119 @@
 ---
 name: shared-investigation
 description: >-
-  Deep investigation for fix paths and review-incident. Not user-facing.
+  Deep fix investigation swarm — mandatory parallel subagents for fix paths.
+  Incident subset for review-incident. Not user-facing.
 disable-model-invocation: true
 ---
 
 # Shared investigation (deep)
 
-**When:** fix verb lifecycle, `fix_mode` domain orchestrators, `review-incident`.
+**When:** fix verb lifecycle, `fix_mode` domain orchestrators, optional deep path on `review-incident`.
 
 For create/update use [investigation-lite](../investigation-lite/SKILL.md) instead.
 
-Adapted from legacy swarm-check. **Default: readonly.**
+**Default: readonly.** Artifacts stored on Run under `artifacts.investigation`.
 
-## Frame
+Contract: [investigation.yaml](../../../aaac/contracts/skills/investigation.yaml)
 
+## Frame (parent — before swarm)
+
+```yaml
+issue: one line
+symptoms: user-visible
+expected: if known
+scope: files/features/routes
+questions: 3–5 open questions
+domain: cms | ui | database | aaac | unknown
 ```
-Issue:     one line
-Symptoms:  user-visible
-Expected:  if known
-Scope:     files/features
-Questions: 3–5
+
+Create Run artifact stub at `state/runs/{run_id}/artifacts/investigation-frame.yaml`.
+
+---
+
+## Mode A — Fix path (mandatory)
+
+**Applies to:** `fix`, `fix_mode`, `/fix-module`, `/fix-bug`, resolver paths `*-fix-bug`, generic `verb-fix`.
+
+### Phase 0 — Discovery swarm (prerequisite)
+
+Run [discovery](../discovery/SKILL.md) first — **4–6 parallel** agents in one message. Do not start fix swarm until discovery brief exists on Run.
+
+### Phase 1 — Fix investigation swarm (mandatory)
+
+Launch **7 parallel** `Task` subagents in **one message**. `readonly: true` unless agent spec allows test runs.
+
+| # | Agent spec | `subagent_type` | Angle |
+|---|------------|-----------------|-------|
+| 1 | [fix-repro.md](../../../agents/fix-repro.md) | `explore` | Repro steps + confirmation |
+| 2 | [fix-code-path.md](../../../agents/fix-code-path.md) | `explore` | Execution trace + suspects |
+| 3 | [fix-recent-changes.md](../../../agents/fix-recent-changes.md) | `shell` | Git log/blame on suspect paths |
+| 4 | [fix-test-failures.md](../../../agents/fix-test-failures.md) | `shell` | Tests + failures + gaps |
+| 5 | [fix-regression-scope.md](../../../agents/fix-regression-scope.md) | `explore` | Blast radius + dependents |
+| 6 | [fix-runtime-evidence.md](../../../agents/fix-runtime-evidence.md) | `generalPurpose` | CI/logs/MCP evidence |
+| 7 | [fix-inventory-confirm.md](../../../agents/fix-inventory-confirm.md) | `explore` | Inventory scope + constraints |
+
+**Parent prompt must include:** intent, domain, inventory path, discovery brief summary, frame fields.
+
+**Anti-patterns (hard fail):**
+
+- Skipping swarm because "issue looks simple"
+- Launching agents sequentially
+- Planning or executing before swarm merge
+- Fewer than 7 agents without documented gap + second wave
+
+**Second wave (optional, max 2):** when any agent returns `confidence: low` — target the gap only.
+
+### Parent merge (mandatory)
+
+Write `state/runs/{run_id}/artifacts/investigation.md`:
+
+```yaml
+repro_steps: [numbered]
+repro_confirmed: yes | partial | no
+suspect_files: [path:line]
+candidate_commits: [{ hash, likelihood, summary }]
+test_failures: []
+coverage_gaps: []
+blast_radius: low | medium | high
+runtime_evidence: [bullets]
+constraints: [from inventory]
+findings: [merged bullets]
+risks: [bullets]
+recommendations: [bullets]
+confidence:
+  architecture: 0.0–1.0
+  requirements: 0.0–1.0
+  scope: 0.0–1.0
 ```
 
-## Swarm
+Pass to [validation](../validation/SKILL.md) and [root-cause](../root-cause/SKILL.md).
+
+---
 
-3–6 parallel readonly agents: code path, recent changes, tests, CI (`ci-investigator` if `--ci`), logs, state flow.
+## Mode B — Incident path (review-incident)
 
-Use [discovery](../discovery/SKILL.md) agent specs where overlapping.
+**Applies to:** `/review-incident`, `swarm-check` alias — investigation only unless `--fix`.
 
-## Confidence output
+Launch **4 parallel** `Task` subagents in one message:
 
-Include `confidence.architecture`, `confidence.requirements`, `confidence.scope` for [validation](../validation/SKILL.md).
+| Agent | Spec |
+|-------|------|
+| Repro | [fix-repro.md](../../../agents/fix-repro.md) |
+| Code path | [fix-code-path.md](../../../agents/fix-code-path.md) |
+| Runtime | [fix-runtime-evidence.md](../../../agents/fix-runtime-evidence.md) |
+| Recent changes | [fix-recent-changes.md](../../../agents/fix-recent-changes.md) |
 
-## Report
+Layman report via [reporting](../reporting/SKILL.md) — <250 words unless user asked for detail.
 
-[reporting](../reporting/SKILL.md) — layman first, <250 words unless user asked for detail.
+If intent includes `--fix` or explicit fix request → continue full **Mode A** swarm + fix lifecycle after report approval.
+
+---
 
 ## Next phase (fix only)
 
-Hand off to [root-cause](../root-cause/SKILL.md) before planning.
+Hand off to [root-cause](../root-cause/SKILL.md) before planning. Do not skip even when root cause seems obvious.
 
 ## Fix path execution
 
-If intent includes fix or `fix-bug` command: after full lifecycle gates pass, orchestrator invokes `execution` + `testing` + `verification`.
+After full lifecycle gates pass, orchestrator invokes `execution` + [testing](../testing/SKILL.md) (fix verify swarm) + [verification](../verification/SKILL.md).

package/templates/cursor/skills/shared/investigation/orchestrator/SKILL.md

@@ -15,8 +15,16 @@ disable-model-invocation: true
 
 ## Phases
 
-1. [investigation](../SKILL.md) — layman report
-2. If fix requested: discovery → planning → execution → testing → verification
-3. [reporting](../reporting/SKILL.md)
+1. **discover** (optional, 2 agents max) when domain unknown
+2. [investigation](../SKILL.md) **Mode B** — **4 parallel** agents in one message (repro, code-path, runtime, recent-changes)
+3. [reporting](../../reporting/SKILL.md) — layman first; set Run `status: completed` unless fix path active
 
-Stop after report unless fix path active.
+## Fix escalation
+
+If intent includes `--fix`, explicit "fix this", or user approves after report:
+
+1. Switch command workflow to `fix-module` / `fix-bug` lifecycle on same Run
+2. Run investigation **Mode A** (full 7-agent swarm) if not already done
+3. Continue: root_cause → plan → gates → execute → verify (fix verify swarm) → report
+
+Do not execute code changes on incident path without explicit fix request or approval.

package/templates/cursor/skills/shared/planning/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: shared-planning
 description: >-
-  Plans AAAC changes: SSOT, layers, size budgets, state machines. Readonly until
-  orchestrator approves. Invoked by graph — not user-facing.
+  Plans AAAC changes: SSOT, layers, size budgets, complexity score, requirement map.
+  Readonly until orchestrator approves. Mutating verbs only.
 disable-model-invocation: true
 ---
 
@@ -10,7 +10,16 @@ disable-model-invocation: true
 
 ## When
 
-After `discovery_swarm`. **Does not edit files.**
+After `discover` / `investigate*` on **`create`, `update`, `fix`** commands. **Does not edit files.**
+
+Other verbs: lightweight plan only (no complexity artifact).
+
+## Policies (mutating verbs)
+
+Read before planning:
+
+- [minimal-complexity.md](../../../policies/minimal-complexity.md)
+- [complexity.yaml](../../../aaac/complexity.yaml) — weights and thresholds
 
 ## Agents
 
@@ -19,12 +28,69 @@ Optional parallel readonly:
 - [plan-layer-map.md](../../../agents/plan-layer-map.md)
 - [plan-state-machines.md](../../../agents/plan-state-machines.md)
 
-## Plan document (internal)
+## Strategy (mandatory for create / update / fix)
+
+Search codebase first. Document in plan **before** proposing new artifacts:
+
+```text
+1. reuse_existing
+2. extend_existing
+3. modify_existing
+4. create_new  ← last resort; each entry needs requirement_ref + why_not_reuse
+```
+
+Prefer **lower complexity score** when multiple options satisfy requirements.
+
+## Plan artifact (store on Run `artifacts.plan`)
+
+Contract: [contracts/skills/planning.yaml](../../../aaac/contracts/skills/planning.yaml)
+
+```yaml
+requirement_map:
+  - requirement: "<from user intent — quoted if possible>"
+    satisfies_with: ["<artifact ids>"]
+complexity_score: <sum of weights for net-new items>
+complexity_breakdown:
+  new_file: 0
+  new_api_endpoint: 0
+  # … per complexity.yaml weights
+reuse: ["<existing paths or symbols>"]
+modify: ["<existing paths to edit>"]
+create:
+  - artifact: "<name>"
+    kind: <weight key from complexity.yaml>
+    requirement_ref: "<requirement text>"
+    why_not_reuse: "<one line>"
+rejected_alternatives:
+  - option: "<heavier approach>"
+    complexity_score: <number>
+    rejected_because: "<no requirement / reuse suffices>"
+paths_to_touch: ["<concrete file paths>"]
+rollback_notes: "<when protected/critical object>"
+```
+
+Also include:
 
-- User intent → concrete paths (from domain inventory)
 - SSOT owner for new state
 - Extract before add if any file ≥80% budget
-- Named machine states/events if async coordination added
-- Migration + schema steps if DB changes
+- Named machine states/events **only** if user requirement demands async coordination
+
+## Complexity score
+
+Sum `complexity.yaml` weights for each net-new artifact in `create`. **Edits to existing files do not add weight** (count under `modify`).
+
+Compare to verb threshold:
+
+| Verb | Max |
+|------|-----|
+| fix | 5 |
+| update | 8 |
+| create | 12 |
+
+If over threshold: revise plan toward reuse/modify or document in `rejected_alternatives` and stop for gate — do not proceed to execute silently.
+
+## YAGNI
+
+Do not plan for unstated future needs. See [minimal-complexity.md](../../../policies/minimal-complexity.md).
 
-Orchestrator gates `execute` — no implementation until plan respects domain constraints.
+Orchestrator gates `execute` — no implementation until plan passes **validate** and **fitness_functions** (`minimal_complexity`).

package/templates/cursor/skills/shared/reporting/SKILL.md

@@ -21,7 +21,8 @@ disable-model-invocation: true
 - Tests: …
 - Intent: …
 - Confidence: architecture / requirements / scope
-- Fitness: pass/warning/fail summary
+- Complexity: score / threshold / pass (create/update/fix only)
+- Fitness: pass/warning/fail summary (include minimal_complexity)
 - Impact: blast_radius, affected domains
 
 ### Rollback (if applicable)