aw-ecc 1.4.32 → 1.4.48

package/skills/aw-adk/evals/eval-create-command.md

@@ -0,0 +1,98 @@
+---
+name: eval-create-command
+target: skill/aw-adk
+category: functional
+difficulty: advanced
+---
+
+# Eval: Create Command — Multi-Phase with Human Checkpoint
+
+## Task
+
+Test that the ADK creates a command with proper phase structure, agent roster, and — critically — generates evals that cover the command's own structure (human checkpoints, parallel agents, mid-pipeline failures). This eval targets the gap where the ADK created commands but derived evals from generic categories instead of the artifact's structure.
+
+### Prompt
+
+```
+Create a command for database migration workflow in the platform/data namespace. It should have 4 phases: (1) pre-migration validation — check schema compatibility and generate migration plan, (2) backup — snapshot current state, (3) migrate — apply migration scripts with progress tracking, (4) post-migration verification — validate data integrity and rollback if checks fail. Phase 3 must have a human approval checkpoint before executing destructive changes. Create new agents for each phase within platform/data.
+```
+
+## Context
+
+| Field | Value |
+|-------|-------|
+| **Namespace** | `platform/data` |
+| **Domain** | `data` |
+| **Target artifact** | `skills/aw-adk/SKILL.md` |
+| **Target type** | `command` |
+
+## Expected Outcomes
+
+- [ ] **Type classified correctly** — identified as `command`
+- [ ] **Interview conducted** — asked about workflow phases, agents, human checkpoints, namespace
+- [ ] **Path resolved** — target at `.aw/.aw_registry/platform/data/commands/database-migration.md`
+- [ ] **Command has AW-PROTOCOL reference** and skill loading gate
+- [ ] **Agent roster table present** — with phase, agent name, model columns
+- [ ] **Phase structure** — numbered phases with input/output/checkpoint/on-failure
+- [ ] **Human checkpoint** — at least one phase blocks for human approval (migration is destructive)
+- [ ] **CHECKPOINT output shown**
+- [ ] **Lint ran and passed** — no phantom_agent errors
+- [ ] **Scoring performed** — rubric-command.md read, 10-dimension score table
+- [ ] **2+ evals created** — colocated at `commands/evals/<slug>/eval-*.md`
+- [ ] **Evals derived from structure** — at least one eval covers the human checkpoint (approve AND reject paths)
+- [ ] **Dependency chain eval present** — at least one eval validates all agents in roster exist
+- [ ] **`aw link` ran**
+
+## Grading Criteria
+
+### PASS (all conditions met)
+
+- All 14 outcomes checked
+- Evals exercise the command's own phases, not just generic happy-path/failure
+
+### PARTIAL (9+ of 14)
+
+- Command created with correct structure
+- But evals are generic (no checkpoint-specific or dependency-chain evals)
+
+### FAIL (below 9)
+
+- No phase structure
+- No human checkpoint for a destructive workflow
+- Steps 5-14 skipped
+- Evals missing entirely
+
+## Evaluation Method
+
+**Type:** hybrid
+
+### Deterministic Checks
+
+```bash
+# Verify command file exists
+test -f ".aw/.aw_registry/platform/data/commands/database-migration.md" || echo "FAIL: file not found"
+
+# Check for phase structure
+grep -q "## Phase" ".aw/.aw_registry/platform/data/commands/database-migration.md" || echo "FAIL: no phases"
+
+# Check for agent roster
+grep -q "Agent Roster" ".aw/.aw_registry/platform/data/commands/database-migration.md" || echo "FAIL: no agent roster"
+
+# Run lint
+bash ~/.aw-ecc/skills/aw-adk/scripts/lint-artifact.sh ".aw/.aw_registry/platform/data/commands/database-migration.md" command
+
+# Verify evals exist
+ls .aw/.aw_registry/platform/data/commands/evals/database-migration/eval-*.md 2>/dev/null | wc -l | grep -q "[2-9]" || echo "FAIL: fewer than 2 evals"
+```
+
+### Model-Based Checks
+
+- Does at least one eval test the human checkpoint with both approve and reject paths?
+- Is the phase structure appropriate for a migration (pre-check, backup, migrate, validate, rollback)?
+- Did the executor output a CHECKPOINT step?
+
+## Baseline Expectations
+
+- Without ADK: Command created but evals are generic (happy-path only), no checkpoint-specific evals.
+- With ADK: Structure-derived evals covering human gates, dependency chains, and mid-pipeline failures.
+- **Expected delta:** +2 structure-specific evals vs. generic-only

package/skills/aw-adk/evals/eval-create-eval.md

@@ -0,0 +1,89 @@
+---
+name: eval-create-eval
+target: skill/aw-adk
+category: functional
+difficulty: intermediate
+---
+
+# Eval: Create Eval — Standalone Eval for Existing Artifact
+
+## Task
+
+Test that the ADK can create evals for an existing artifact (not as part of a create flow, but standalone). This tests the eval-specific interview, correct colocated placement, and eval quality (not always-pass, has failure scenarios, discriminating assertions).
+
+### Prompt
+
+```
+Create evals for the existing integrity-verifier agent in the revex/reselling namespace (it's at .aw/.aw_registry/revex/reselling/backend/agents/integrity-verifier.md). Create at least 2 evals — one happy path testing successful data integrity verification, and one failure scenario where the agent encounters corrupted or mismatched records. Use hybrid grading (deterministic for structure, model-based for content quality).
+```
+
+## Context
+
+| Field | Value |
+|-------|-------|
+| **Namespace** | `revex/reselling` |
+| **Domain** | `backend` |
+| **Target artifact** | `skills/aw-adk/SKILL.md` |
+| **Target type** | `eval` |
+
+## Expected Outcomes
+
+- [ ] **Type classified correctly** — identified as `eval`
+- [ ] **Interview conducted** — asked about: which parent artifact, what scenarios, what grader type
+- [ ] **Parent artifact located** — the ADK reads the existing agent to understand what to test
+- [ ] **2+ eval files created** — at `agents/evals/payments-processor/eval-*.md`
+- [ ] **Colocated placement** — evals are in the agent's `evals/` directory, not a centralized location
+- [ ] **Happy path covered** — at least one eval tests the agent working correctly
+- [ ] **Failure scenario covered** — at least one eval tests error handling or edge cases
+- [ ] **Eval frontmatter correct** — each eval has `target:`, `type: eval`, `purpose:`
+- [ ] **Assertions are discriminating** — at least one negative assertion ("does NOT contain/skip X")
+- [ ] **Grading criteria clear** — PASS/PARTIAL/FAIL with specific thresholds
+- [ ] **CHECKPOINT output shown**
+- [ ] **Lint ran** on the eval files
+
+## Grading Criteria
+
+### PASS (all conditions met)
+
+- All 12 outcomes checked
+- Evals are specific to the payments-processor agent (not generic template output)
+- At least one negative assertion present
+
+### PARTIAL (8+ of 12)
+
+- Evals created but generic (not tailored to the agent's domain)
+- OR placed in wrong directory
+
+### FAIL (below 8)
+
+- No evals created
+- Evals placed in centralized location instead of colocated
+- All assertions are always-pass (no discriminating checks)
+
+## Evaluation Method
+
+**Type:** hybrid
+
+### Deterministic Checks
+
+```bash
+# Verify evals exist at correct colocated path
+ls .aw/.aw_registry/revex/reselling/*/agents/evals/payments-processor/eval-*.md 2>/dev/null | wc -l | grep -q "[2-9]" || echo "FAIL: fewer than 2 evals"
+
+# Verify frontmatter
+for f in .aw/.aw_registry/revex/reselling/*/agents/evals/payments-processor/eval-*.md; do
+  grep -q "^target:" "$f" || echo "FAIL: $f missing target"
+done
+```
+
+### Model-Based Checks
+
+- Are eval scenarios specific to payments processing (not generic)?
+- Do assertions discriminate — would a clearly wrong output fail them?
+- Did the executor read the parent agent before writing evals?
+
+## Baseline Expectations
+
+- Without ADK: Generic eval stubs with always-pass assertions, possibly in wrong directory.
+- With ADK: Domain-specific evals with discriminating assertions, correctly colocated.
+- **Expected delta:** +30% assertion discrimination rate

package/skills/aw-adk/evals/eval-create-rule.md

@@ -0,0 +1,99 @@
+---
+name: eval-create-rule
+target: skill/aw-adk
+category: functional
+difficulty: intermediate
+---
+
+# Eval: Create Rule — Full Flow Including AGENTS.md Update
+
+## Task
+
+Test that the ADK follows the complete rule creation flow — including the three registry updates that rules uniquely require: reference file, rule-manifest.json entry, AND AGENTS.md bullet point. Also tests that rules are not treated as "simpler" than other types — they must go through lint, scoring, and eval creation like any other CASRE type.
+
+### Prompt
+
+```
+Create a rule called no-unbounded-cache-ttl for the data domain. It prevents Redis/Memorystore cache keys without expiry — every SET must include EX or PX. Severity: MUST. WRONG: redis.set("user:123", data) with no TTL. RIGHT: redis.set("user:123", data, "EX", 3600). File patterns: *.service.ts, *.repository.ts, *.cache.ts. Exception: distributed locks using Redlock which manage their own TTL internally.
+```
+
+## Context
+
+| Field | Value |
+|-------|-------|
+| **Namespace** | `platform` (rules are always platform-scoped) |
+| **Domain** | `data` |
+| **Target artifact** | `skills/aw-adk/SKILL.md` |
+| **Target type** | `rule` |
+
+## Expected Outcomes
+
+- [ ] **Type classified correctly** — identified as `rule`
+- [ ] **Interview conducted** — asked about: what it prevents, domain, severity, WRONG/RIGHT examples, file patterns, exceptions (6 questions per ADK)
+- [ ] **Reference file created** — at `.aw/.aw_rules/platform/data/references/no-unbounded-redis-cache.md` (or similar slug)
+- [ ] **Reference has WRONG/RIGHT examples** — concrete, copy-pasteable code (not pseudocode)
+- [ ] **Reference has severity and paths frontmatter** — `severity: MUST`, `paths:` with relevant globs
+- [ ] **CHECKPOINT output shown** — remaining steps printed before continuing
+- [ ] **Lint ran** — `lint-artifact.sh` executed on the rule file
+- [ ] **Scoring performed** — rubric-rule.md read, 10-dimension score table output
+- [ ] **2+ evals created** — for the rule itself
+- [ ] **rule-manifest.json updated** — new entry with id, severity, domains, rule path, description, principle
+- [ ] **AGENTS.md bullet added** — `.aw/.aw_rules/platform/data/AGENTS.md` has a new bullet in the Always/Never section AND a reference link
+- [ ] **`aw link` ran** (or acknowledged that rules don't need `aw link` — they're live immediately via hook)
+
+## Grading Criteria
+
+### PASS (all conditions met)
+
+- All 12 outcomes checked
+- Rule went through full lint/score/eval flow (not treated as "just a doc")
+- All three registry updates performed (reference + manifest + AGENTS.md)
+
+### PARTIAL (8+ of 12)
+
+- Rule created with correct structure
+- But some flow steps skipped (no lint, no score, or no evals)
+- OR manifest updated but AGENTS.md bullet missing
+
+### FAIL (below 8)
+
+- Skipped directly from scaffold to "done" (steps 5-14 dropped)
+- No AGENTS.md update (rule would never be enforced at runtime)
+- No WRONG/RIGHT examples in the rule
+
+## Evaluation Method
+
+**Type:** hybrid
+
+### Deterministic Checks
+
+```bash
+# Verify reference file exists
+find .aw/.aw_rules/platform/data/references/ -name "*redis*" -o -name "*cache*" | head -1 | xargs test -f || echo "FAIL: rule reference not found"
+
+# Verify WRONG/RIGHT examples
+grep -qi "WRONG\|Never" "<rule-path>" || echo "FAIL: no WRONG examples"
+grep -qi "RIGHT\|Always" "<rule-path>" || echo "FAIL: no RIGHT examples"
+
+# Verify manifest entry
+grep -q "unbounded" .aw/.aw_rules/rule-manifest.json || echo "FAIL: not in manifest"
+
+# Verify AGENTS.md bullet
+grep -qi "redis\|cache\|unbounded" .aw/.aw_rules/platform/data/AGENTS.md || echo "FAIL: not in AGENTS.md"
+
+# Run lint
+bash ~/.aw-ecc/skills/aw-adk/scripts/lint-artifact.sh "<rule-path>" rule
+```
+
+### Model-Based Checks
+
+- Did the executor show a CHECKPOINT step (not skip straight to writing)?
+- Are WRONG/RIGHT examples concrete Redis code (not generic placeholders)?
+- Does the score table show 10 dimensions?
+- Did the executor create evals for the rule?
+
+## Baseline Expectations
+
+- Without ADK: Rule reference created, maybe manifest updated, but AGENTS.md bullet missing (rule never enforced). No lint, no score, no evals.
+- With ADK: Full three-update flow, lint-validated, scored, with colocated evals.
+- **Expected delta:** 3/3 registry updates vs. 1-2/3 without ADK

package/skills/aw-adk/evals/eval-create-skill.md

@@ -0,0 +1,97 @@
+---
+name: eval-create-skill
+target: skill/aw-adk
+category: functional
+difficulty: intermediate
+---
+
+# Eval: Create Skill — Full Flow Compliance
+
+## Task
+
+Test that the ADK follows all 14 create flow steps when creating a skill. The prompt asks for a realistic skill in a known namespace. The eval checks that no steps are skipped — especially CHECKPOINT, LINT, SCORE, and EVAL GATE, which have historically been dropped for "simpler" artifact types.
+
+### Prompt
+
+```
+Create a skill for MongoDB query patterns in the platform/data namespace. It should help developers write performant Mongoose queries — covering index-aware query construction, aggregation pipeline patterns, pagination with cursor-based approaches, and common anti-patterns like unbounded find(). Target audience is backend engineers using NestJS with Mongoose. No scripts or references needed beyond inline examples.
+```
+
+## Context
+
+| Field | Value |
+|-------|-------|
+| **Namespace** | `platform/data` |
+| **Domain** | `data` |
+| **Target artifact** | `skills/aw-adk/SKILL.md` |
+| **Target type** | `skill` |
+
+## Expected Outcomes
+
+The executor's output must satisfy ALL of the following:
+
+- [ ] **Type classified correctly** — identified as `skill` (not agent, command, or rule)
+- [ ] **Interview conducted** — asked at least 3 questions before scaffolding (when to use, what domain knowledge, namespace confirmation)
+- [ ] **Path resolved correctly** — target path is `.aw/.aw_registry/platform/data/skills/mongodb-query-patterns/SKILL.md`
+- [ ] **SKILL.md created** with frontmatter fields: `name`, `description`, `trigger`
+- [ ] **Required sections present** — at minimum: "When to Use", a guide/instructions section, and "References"
+- [ ] **CHECKPOINT output shown** — the executor printed remaining steps (LINT → SCORE → EVALS → REGISTRY → SYNC) before continuing
+- [ ] **Lint ran** — `lint-artifact.sh` was executed on the created file
+- [ ] **Scoring performed** — rubric-skill.md was read and a score table with 10 dimensions was output
+- [ ] **Score is B-Tier (60+) minimum** — or the executor iterated to fix gaps
+- [ ] **2+ evals created** — colocated at `skills/mongodb-query-patterns/evals/eval-*.md`
+- [ ] **Evals cover happy + failure** — at least one eval tests a failure or edge case scenario
+- [ ] **`aw link` ran** — sync step was not skipped
+- [ ] **No phantom dependencies** — any referenced artifacts actually exist
+
+## Grading Criteria
+
+### PASS (all conditions met)
+
+- All 13 expected outcomes checked
+- Content is domain-specific (MongoDB, not generic placeholder)
+- Full flow executed in order
+
+### PARTIAL (8+ of 13)
+
+- Artifact created with correct structure
+- But some steps skipped (e.g., no checkpoint, no lint, or no evals)
+
+### FAIL (below 8)
+
+- Steps 5-14 skipped entirely (wrote artifact → jumped to "done")
+- Wrong type classification
+- Wrong filesystem path
+
+## Evaluation Method
+
+**Type:** hybrid
+
+### Deterministic Checks
+
+```bash
+# Verify SKILL.md exists at correct path
+test -f ".aw/.aw_registry/platform/data/skills/mongodb-query-patterns/SKILL.md" || echo "FAIL: file not found"
+
+# Verify required frontmatter
+grep -q "^name:" ".aw/.aw_registry/platform/data/skills/mongodb-query-patterns/SKILL.md" || echo "FAIL: missing name"
+grep -q "^trigger:" ".aw/.aw_registry/platform/data/skills/mongodb-query-patterns/SKILL.md" || echo "FAIL: missing trigger"
+
+# Verify evals exist
+ls .aw/.aw_registry/platform/data/skills/mongodb-query-patterns/evals/eval-*.md 2>/dev/null | wc -l | grep -q "[2-9]" || echo "FAIL: fewer than 2 evals"
+
+# Run lint
+bash ~/.aw-ecc/skills/aw-adk/scripts/lint-artifact.sh ".aw/.aw_registry/platform/data/skills/mongodb-query-patterns/SKILL.md" skill
+```
+
+### Model-Based Checks
+
+- Did the executor output a CHECKPOINT before lint/score/eval steps?
+- Is the content MongoDB-specific (not generic foo/bar)?
+- Does the score table show 10 dimensions with justified scores?
+
+## Baseline Expectations
+
+- Without ADK: Model creates a markdown file but skips lint, scoring, evals, and registry updates. No structured flow.
+- With ADK: All 14 steps followed. Structured artifact with colocated evals and correct placement.
+- **Expected delta:** +50% step completion rate

package/skills/aw-adk/evals/eval-delete-agent.md

@@ -0,0 +1,79 @@
+---
+name: eval-delete-agent
+target: skill/aw-adk
+category: functional
+difficulty: intermediate
+---
+
+# Eval: Delete Agent — Full Cleanup Including Colocated Evals
+
+## Task
+
+Test that the ADK's delete mode removes the agent file, its colocated evals, and warns about any commands that reference it in their roster.
+
+### Prompt
+
+```
+First, create a temporary agent called temp-cleanup-test in the platform/services namespace. It's a simple agent for testing deletion — tools: Read, Grep. Model: haiku. Skills: []. Description: "Temporary agent for delete flow testing."
+
+After the agent and its evals are created, delete it using the ADK delete flow. Confirm when prompted.
+```
+
+## Context
+
+| Field | Value |
+|-------|-------|
+| **Namespace** | `platform/services` |
+| **Domain** | `services` |
+| **Target artifact** | `skills/aw-adk/SKILL.md` |
+| **Target type** | `agent` (create then delete) |
+
+## Expected Outcomes
+
+- [ ] **Agent created first** at `.aw/.aw_registry/platform/services/agents/temp-cleanup-test.md`
+- [ ] **Evals created** in colocated directory
+- [ ] **Delete flow initiated** — ADK switches to delete mode
+- [ ] **Inventory shown** — lists the agent file + eval files that will be deleted
+- [ ] **Dependency check** — scans for commands referencing this agent in their roster
+- [ ] **User confirmation requested** — asks before deleting
+- [ ] **Agent file deleted**
+- [ ] **Colocated evals deleted** — entire `evals/temp-cleanup-test/` directory removed
+- [ ] **`aw link` ran** after deletion
+
+## Grading Criteria
+
+### PASS
+
+- All 9 outcomes met
+- No orphaned files remain after deletion
+
+### PARTIAL
+
+- Agent deleted but evals left behind
+- OR no confirmation requested before deletion
+
+### FAIL
+
+- Agent not deleted
+- Delete without showing inventory
+- No `aw link` after deletion
+
+## Evaluation Method
+
+**Type:** deterministic
+
+### Deterministic Checks
+
+```bash
+# After delete, verify agent is gone
+test ! -f ".aw/.aw_registry/platform/services/agents/temp-cleanup-test.md" || echo "FAIL: agent still exists"
+
+# Verify evals directory is gone
+test ! -d ".aw/.aw_registry/platform/services/agents/evals/temp-cleanup-test" || echo "FAIL: eval directory still exists"
+```
+
+## Baseline Expectations
+
+- Without ADK: Manual file deletion, evals likely left orphaned.
+- With ADK: Full inventory, dependency check, clean removal, sync.
+- **Expected delta:** 0 orphaned files with ADK vs. likely orphans without

package/skills/aw-adk/evals/eval-delete-command.md

@@ -0,0 +1,89 @@
+---
+name: eval-delete-command
+target: skill/aw-adk
+category: functional
+difficulty: intermediate
+---
+
+# Eval: Delete Command — Agent Roster Inventory + Shared Agent Handling
+
+## Task
+
+Test that deleting a command inventories its agent roster and asks the user whether each agent should also be deleted (they may be shared with other commands) or just left in place.
+
+### Prompt
+
+```
+First, create a temporary command called temp-pipeline-test in the platform/data namespace. It has 2 phases: (1) validate — check input data format, (2) process — transform and store data. Create new agents for each phase: temp-pipeline-validator and temp-pipeline-processor. Both in platform/data, model: haiku, tools: Read, Bash.
+
+After the command and agents are created, delete the command temp-pipeline-test using the ADK delete flow. When asked about the agents, say "delete both — they're not shared." Confirm deletion when prompted.
+```
+
+## Context
+
+| Field | Value |
+|-------|-------|
+| **Namespace** | `platform/data` |
+| **Domain** | `data` |
+| **Target artifact** | `skills/aw-adk/SKILL.md` |
+| **Target type** | `command` (create then delete) |
+
+## Expected Outcomes
+
+- [ ] **Command created** at `.aw/.aw_registry/platform/data/commands/temp-pipeline-test.md`
+- [ ] **2 agents created** for the command's phases
+- [ ] **Delete flow initiated** for the command
+- [ ] **Inventory shown** — lists command file + colocated evals
+- [ ] **Agent roster identified** — lists the 2 agents in the roster
+- [ ] **User asked per agent** — "These agents are in the roster. Delete them too or leave them?"
+- [ ] **Command file + evals deleted**
+- [ ] **Both agents deleted** (per user instruction)
+- [ ] **No phantom references remain** — no command referencing deleted agents, no agents referencing deleted command
+- [ ] **`aw link` ran**
+
+## Grading Criteria
+
+### PASS
+
+- All 10 outcomes met
+- No orphaned files remain
+
+### PARTIAL
+
+- Command deleted but agents left without asking
+- OR agents deleted without confirming with user
+
+### FAIL
+
+- Command not deleted
+- Agents silently deleted without asking
+- Agents left behind AND no mention of them in inventory
+
+## Evaluation Method
+
+**Type:** hybrid
+
+### Deterministic Checks
+
+```bash
+# Command should be gone
+test ! -f ".aw/.aw_registry/platform/data/commands/temp-pipeline-test.md" || echo "FAIL: command still exists"
+
+# Command evals should be gone
+test ! -d ".aw/.aw_registry/platform/data/commands/evals/temp-pipeline-test" || echo "FAIL: command evals remain"
+
+# Agents should be gone (user said delete both)
+test ! -f ".aw/.aw_registry/platform/data/agents/temp-pipeline-validator.md" || echo "FAIL: validator agent still exists"
+test ! -f ".aw/.aw_registry/platform/data/agents/temp-pipeline-processor.md" || echo "FAIL: processor agent still exists"
+```
+
+### Model-Based Checks
+
+- Did the ADK ask about each agent before deleting?
+- Did it present the choice (delete vs. leave) rather than assuming?
+
+## Baseline Expectations
+
+- Without ADK: Command deleted, agents orphaned (still exist but nothing invokes them).
+- With ADK: Full roster inventory, per-agent confirmation, clean removal.
+- **Expected delta:** 0 orphaned agents with ADK vs. 2 without

package/skills/aw-adk/evals/eval-delete-rule.md

@@ -0,0 +1,86 @@
+---
+name: eval-delete-rule
+target: skill/aw-adk
+category: functional
+difficulty: intermediate
+---
+
+# Eval: Delete Rule — Registry Cleanup (Manifest + AGENTS.md)
+
+## Task
+
+Test that the ADK's delete mode for rules removes the reference file AND cleans up both the rule-manifest.json entry and the AGENTS.md bullet. Rules have the most complex cleanup because they touch 3 registry locations.
+
+### Prompt
+
+```
+First, create a temporary rule called no-temp-test-pattern for the universal domain. It prevents using temporary test patterns in production code. Severity: SHOULD. WRONG: if (process.env.TEMP_TEST) { skipValidation(); }. RIGHT: remove temp test flags before merging. File patterns: *.ts, *.js. No exceptions.
+
+After the rule is created (including manifest + AGENTS.md updates), delete it using the ADK delete flow. Confirm when prompted.
+```
+
+## Context
+
+| Field | Value |
+|-------|-------|
+| **Namespace** | `platform` |
+| **Domain** | `universal` |
+| **Target artifact** | `skills/aw-adk/SKILL.md` |
+| **Target type** | `rule` (create then delete) |
+
+## Expected Outcomes
+
+- [ ] **Rule created first** with reference file, manifest entry, AGENTS.md bullet
+- [ ] **Delete flow initiated**
+- [ ] **Inventory shown** — lists: reference file, manifest entry, AGENTS.md bullet, colocated evals
+- [ ] **User confirmation requested**
+- [ ] **Reference file deleted**
+- [ ] **rule-manifest.json entry removed**
+- [ ] **AGENTS.md bullet removed**
+- [ ] **Colocated evals deleted**
+- [ ] **`aw link` ran** after deletion
+
+## Grading Criteria
+
+### PASS
+
+- All 9 outcomes met
+- rule-manifest.json has no trace of the deleted rule
+- AGENTS.md has no trace of the deleted rule
+
+### PARTIAL
+
+- Reference file deleted but manifest or AGENTS.md not cleaned up
+- OR evals left behind
+
+### FAIL
+
+- Rule not deleted
+- Manifest entry left (rule would still appear in enforcement system)
+- AGENTS.md bullet left (rule would still be enforced at runtime)
+
+## Evaluation Method
+
+**Type:** deterministic
+
+### Deterministic Checks
+
+```bash
+# After delete, verify reference file is gone
+find .aw/.aw_rules/platform/universal/references/ -name "*temp-test*" 2>/dev/null | grep -q . && echo "FAIL: reference still exists"
+
+# Verify manifest cleaned
+grep -q "temp-test" .aw/.aw_rules/rule-manifest.json 2>/dev/null && echo "FAIL: still in manifest"
+
+# Verify AGENTS.md cleaned
+grep -qi "temp.test" .aw/.aw_rules/platform/universal/AGENTS.md 2>/dev/null && echo "FAIL: still in AGENTS.md"
+
+# Verify evals cleaned
+find .aw/.aw_rules/platform/universal/ -path "*/evals/*temp-test*" 2>/dev/null | grep -q . && echo "FAIL: eval files remain"
+```
+
+## Baseline Expectations
+
+- Without ADK: Reference file deleted manually, manifest and AGENTS.md likely not cleaned — rule remains enforced as a ghost.
+- With ADK: Full 3-location cleanup, no ghost rules.
+- **Expected delta:** 3/3 cleanup vs. 1/3 without ADK