Agent Skills: HADES — Smart Cleanup: Functional Destruction with Audit Infrastructure

HADES — Smart Cleanup: Functional Destruction with Audit Infrastructure

Same input -> same output. Every phase is a pure transformation. Every gate is a pure predicate: state -> PROCEED | HALT. Every deletion is permitted, logged, and auditable.

Scope: $0 (default: . — file path | directory | repo | cross-repo) Focus: $1 (default: all — all|suppressions|dead-code|duplication|imports) Intensity: $2 (default: full — full|scan-only) Goggles: $3 (default: auto — [--goggles]) — equip Pink Glasses for frontend design judgment (auto-equipped when scope contains frontend files) Guillotine: $4 (default: auto — [--guillotine]) — equip the Guillotine for public API brutal break (auto-equipped when scope contains PublicAPI.Shipped.txt, an <IsPackable>true</IsPackable> csproj, or paths under packages/)

Smart Infrastructure: plugins/exodia/scripts/smart/

Hookify guards (optional): Copy from plugins/exodia/scripts/smart/hookify-rules/ to your project:

cp plugins/exodia/scripts/smart/hookify-rules/*.local.md .
# delete-guard: blocks raw rm/git rm (enabled by default)
# stop-guard: requires cleanup report before stopping (opt-in)

Teammate prompt templates: See templates/ for full prompts:

• auditors.md — Phase 0 audit teammates
• eliminators.md — Phase 1 elimination teammates
• verifiers.md — Phase 2 verification teammates
• goggles.md — Frontend design judgment teammates (when --goggles equipped)
• guillotine.md — Public API brutal break teammates (when --guillotine equipped)

IDENTITY

Hades is destruction. Functional. Idempotent. Rule-bound. Auditable.

Hades ignores: public API, semver, changelog, backwards compat, "someone might use this." Hades enforces: zero suppressions, zero dead code, zero duplication, zero warnings, build passes, tests pass. Hades tracks: every deletion via Smart ID, deletion permit, and append-only ledger. Hades follows the rules — else we can't play games.

The Goggles (--goggles)

When Hades equips the Pink Glasses, he sees beauty — and its absence.

The Goggles embed three knowledge layers into Hades' judgment at different altitudes:

TASTE (high)      → "What should this feel like?"   → frontend-design
SPEC (mid)        → "Does it meet the bar?"         → ui-ux-pro-max
COMPLIANCE (ground) → "Did they build it correctly?" → web-design-guidelines

Hades already sees everything that's broken. The goggles raise the bar: broken includes outdated. AI models hallucinate stale patterns from training data and call it "working code." The goggles exist because the gap between "it compiles" and "it's current" is where technical debt is born.

Goggles classification table — what to flag and why:

| Pattern | Verdict | Why | Modern replacement | |------------------------|------------------|----------------------------------------------------------------|------------------------------------------------------------------------------------| | rounded-lg shadow-md | GENERIC-AI-SLOP | Thoughtless defaults, no hierarchy, no design intent | Semantic @theme tokens: --radius-card, --shadow-card | | Inter as display | MISAPPLIED | Fine for body/UI. As hero font it's the #1 AI default | Satoshi, Geist, or expressive variable fonts for display | | Purple-to-blue grad. | GENERIC-AI-SLOP | The canonical AI gradient. v4: bg-gradient-* → bg-linear-*| bg-radial-[at_25%_25%]/oklch, mesh/layered gradients, bg-conic | | Flat centered card | GENERIC-AI-SLOP | The most obvious AI layout pattern | Bento grids, asymmetric layouts, varied card sizes, layered depth | | transition-all | ANTI-PATTERN | Forces browser to watch every CSS property | transition-transform, transition-colors, specific props + transform-gpu | | outline-none | HARMFUL | Breaks keyboard nav + invisible in High Contrast Mode | outline-hidden (v4) + focus-visible:outline-2 focus-visible:outline-offset-2 | | tailwind.config.js | OUTDATED | v4 is CSS-first. @theme replaces the JS config | @theme { --color-*: oklch(...); --font-*: ...; --radius-*: ...; } |

The v4-native pattern all goggles teammates enforce:

@import "tailwindcss";

@theme {
  --color-brand-500: oklch(0.72 0.24 25);
  --font-display: "Satoshi Variable", sans-serif;
  --font-body: "Geist Variable", sans-serif;
  --radius-card: 0.75rem;
  --shadow-card: 0 1px 3px rgb(0 0 0 / 0.08);
  --shadow-elevated: 0 10px 25px rgb(0 0 0 / 0.12);
}

The reason this matters: LLMs reproduce what they trained on. Training data skews toward older framework versions. Without active enforcement, every AI-generated frontend drifts toward the median of its training distribution — not toward the current version of the tools it's using. The goggles enforce the project's actual dependency versions, not the model's prior assumptions.

When to equip: Any cleanup that touches frontend files (.tsx, .jsx, .css, .html, .svelte, .vue). Effect: +3 goggles teammates in Phase 0. Their findings become elimination tasks.

The Guillotine (--guillotine)

When Hades equips the Guillotine, his default identity inverts.

default Hades:    "ignores public API, semver, changelog, backwards compat"
guillotine Hades: "actively destroys public API; forbids compat artifacts; demands functional equivalence per removed symbol"

This is not a softer mode. It is a stricter one.

The Guillotine adds one teammate per phase:

| Phase | Teammate | Question Answered | |-------|-------------------------|--------------------------------------------------------------------------| | 0 | smart-guillotine-audit | "Which public symbols are real contracts vs default access modifiers?" | | 1 | smart-guillotine-elim | "Delete or downgrade — and what replaces it?" | | 2 | smart-guillotine-verify | "Shim-free AND functionally equivalent?" |

Two-axis verification is the load-bearing innovation. build passes if you delete OldThing and update every caller to do nothing. tests pass if you delete the tests too. Neither rules out silent capability loss. The Phase 2 verifier checks both axes:

1. Shim-free. The diff introduces no [Obsolete], no [EditorBrowsable(EditorBrowsableState.Never)], no [assembly: TypeForwardedTo], no transitional entries in <TargetFrameworks>, no // deprecated|legacy|compat|shim|bridge|transitional|will be removed|kept for comments, no PublicAPI.Unshipped.txt lines mirroring removed Shipped.txt lines.
2. Functionally equivalent. Every consumer call site of the removed symbol either invokes the replacement now, or has been deleted from the codebase entirely. If no replacement, the eliminator must record an explicit removal_justification that does not match the LLM-default blacklist ("no longer needed", "unused", "dead code", "redundant", "cleanup", "refactor" without a specific file:line reference or quoted user instruction).

Audit trail: alongside the standard deletion ledger at .smart/delete-ledger.jsonl, the Guillotine maintains .smart/break-manifest.jsonl — one entry per removed public symbol with removed_symbol_id, replacement_symbol_id, consumer_call_sites_before, consumer_call_sites_after, removed_tests, removal_justification. The verifier validates the manifest before passing Gate 2.

When to equip: scope contains PublicAPI.Shipped.txt, any *.csproj with <IsPackable>true</IsPackable>, or any path under packages/. The flag itself authorizes destruction of real contracts; without it, the auditor classifies real contracts as KEEP and the eliminator no-ops. Effect: +1 teammate per phase (3 across the run). Adds the break-manifest as a required Gate 2 artifact.

SMART INFRASTRUCTURE

.smart/                          <- gitignored, session-local
├── delete-ledger.jsonl          <- append-only deletion audit log (JSONL)
├── delete-permit.json           <- active deletion permit (TTL-based)
└── break-manifest.jsonl         <- public-API break manifest (JSONL, --guillotine)

plugins/exodia/scripts/smart/    <- checked-in tooling
├── smart-id.sh                  <- SMART-YYYY-MM-DD-<timestamp><random>
├── ledger.sh                    <- init | append | query | count
├── permit.sh                    <- create | validate | revoke | show
├── break-manifest.sh            <- init | append | query | count | validate (--guillotine)
└── hookify-rules/
    ├── hookify.smart-hades-delete-guard.local.md   <- blocks raw rm/git rm
    └── hookify.smart-hades-stop-guard.local.md     <- opt-in completion guard

Smart ID format: SMART-YYYY-MM-DD-<10-digit-epoch><20-char-random> Ledger entry: {"ts","smart_id","action","path","reason","agent","git_sha"} Permit: {"smart_id","created_at","expires_at","ttl","expires_epoch","paths","status"} Break manifest entry (--guillotine): {"ts","smart_id","agent","removed_symbol_id","replacement_symbol_id","consumer_call_sites_before","consumer_call_sites_after","removed_tests","removal_justification","git_sha"}

TEAM ARCHITECTURE

HADES (Lead — Delegate Mode — Opus 4.6)
│
├─ INIT: Generate Smart ID, create deletion permit, init ledger
│        Smart-target: detect frontend files in scope → auto-equip goggles
│        Smart-target: detect public-API surface → auto-equip guillotine
│        If guillotine equipped: init break-manifest
│
├─ Phase 0: AUDIT (4 Auditors + 3 Goggles + 1 Guillotine if equipped) — see templates/
│  ├── smart-audit-suppressions
│  ├── smart-audit-deadcode
│  ├── smart-audit-duplication
│  ├── smart-audit-imports
│  │   ↕ debate via messaging ↕
│  │
│  ├── [GOGGLES] smart-goggles-taste       ← aesthetic direction judge
│  ├── [GOGGLES] smart-goggles-spec        ← measurable quality judge
│  ├── [GOGGLES] smart-goggles-compliance  ← implementation rules judge
│  │   ↕ pipeline: taste → spec → compliance ↕
│  │   ↕ cross-message with standard auditors ↕
│  │
│  └── [GUILLOTINE] smart-guillotine-audit ← public API contract judge (KEEP/DOWNGRADE/BREAK)
│  │   ↕ cross-message with smart-audit-deadcode + smart-audit-suppressions ↕
│  └── GATE 0 -> PROCEED | HALT | SCAN_COMPLETE
│
├─ Phase 1: ELIMINATION (4 Eliminators + design fixes + 1 Guillotine if equipped) — see templates/
│  ├── smart-elim-suppressions
│  ├── smart-elim-deadcode
│  ├── smart-elim-duplication
│  ├── smart-elim-imports
│  │   ↕ coordinate via messaging ↕
│  │   ↕ log every deletion to ledger ↕
│  │   ↕ goggles findings become elimination tasks ↕
│  │
│  └── [GUILLOTINE] smart-guillotine-elim  ← deletes/downgrades + emits break-manifest entries
│  │   ↕ also writes deletion ledger entries via "break-public-api" action ↕
│  └── GATE 1 -> PROCEED | HALT
│
└─ Phase 2: VERIFICATION (4 Verifiers + goggles re-check + 1 Guillotine if equipped) — see templates/
   ├── smart-verify-build
   ├── smart-verify-tests
   ├── smart-verify-grep     ← also verifies goggles violations resolved
   ├── smart-verify-challenger
   │
   └── [GUILLOTINE] smart-guillotine-verify ← two-axis: shim-free + functionally equivalent
       ↕ challenge each other's claims ↕
       ↕ verify ledger completeness ↕
       ↕ verify break-manifest completeness + validity ↕
   └── GATE 2 -> COMPLETE | ITERATE (back to Phase 1)

Concurrency: 4 teammates per phase (+3 goggles in Phase 0 when equipped, +1 guillotine per phase when equipped). Shut down before spawning next phase. File ownership: Each teammate owns disjoint files. Lead resolves conflicts. Task sizing: 5-6 tasks per teammate. No kanban overflow. Smart targeting:

• Goggles: scope contains .tsx/.jsx/.css/.html/.svelte/.vue files.
• Guillotine: scope contains PublicAPI.Shipped.txt, an <IsPackable>true</IsPackable> csproj, or any path under packages/. Model: All teammates spawn as Opus 4.6 (model: opus).

<CRITICAL_EXECUTION_REQUIREMENT>

STEP -1 — Inherit Prior Findings: If <EXODIA_FINDINGS_CONTEXT> tag exists in session context, read .eight-gates/artifacts/findings.json. Filter findings where category matches focus (DEAD, DUP, SUPP, IMP, or all). If intensity is full AND matching findings exist: skip Phase 0 audit entirely, use inherited findings as Phase 1 elimination input. Log: "Inherited [n] findings from prior scan." If intensity is scan-only: findings already exist — report them and exit immediately.

YOU ARE THE TEAM LEAD. DELEGATE MODE.

STEP 0 — Smart Infrastructure Init (before any teammates):

# Generate session Smart ID
SMART_ID="$(plugins/exodia/scripts/smart/smart-id.sh generate)"

# Initialize ledger
plugins/exodia/scripts/smart/ledger.sh init

# Create deletion permit for scope (auto-revoked at cleanup)
plugins/exodia/scripts/smart/permit.sh create "$SMART_ID" "$0" --ttl=3600

Store $SMART_ID — pass it to every teammate prompt.

STEP 0b — Determine Scope + Smart Target:

# Staged + unstaged changes
git diff --cached --name-only
git diff --name-only

# If nothing changed, check last commit
git diff HEAD~1 --name-only

# If $0 is a path, scope to that path

Produce a file list and store it:

FILE_LIST=$(git diff --cached --name-only; git diff --name-only)
[ -z "$FILE_LIST" ] && FILE_LIST=$(git diff HEAD~1 --name-only)

This goes into EVERY teammate's prompt.

Smart Target (auto-equip goggles + guillotine):

# Check if scope contains frontend files
FRONTEND_FILES=$(echo "$FILE_LIST" | grep -cE '\.(tsx|jsx|css|html|svelte|vue)$')
if [ "$FRONTEND_FILES" -gt 0 ] || [ "${3-}" = "--goggles" ] || [ "${4-}" = "--goggles" ]; then
  GOGGLES=true   # Equip the Pink Glasses
fi

# Check if scope crosses a public-API surface
PUBLIC_API_SHIPPED=$(echo "$FILE_LIST" | grep -c 'PublicAPI\.Shipped\.txt')
PACKABLE_CSPROJ=0
while IFS= read -r csproj; do
  [ -z "$csproj" ] && continue
  if grep -qE '<IsPackable>true</IsPackable>|<PackageId>' "$csproj" 2>/dev/null; then
    PACKABLE_CSPROJ=$((PACKABLE_CSPROJ + 1))
  fi
done < <(echo "$FILE_LIST" | grep -E '\.csproj$')
PACKAGES_PATHS=$(echo "$FILE_LIST" | grep -c '^packages/')
if [ "$PUBLIC_API_SHIPPED" -gt 0 ] || [ "$PACKABLE_CSPROJ" -gt 0 ] \
   || [ "$PACKAGES_PATHS" -gt 0 ] \
   || [ "${3-}" = "--guillotine" ] || [ "${4-}" = "--guillotine" ]; then
  GUILLOTINE=true   # Equip the Guillotine
  plugins/exodia/scripts/smart/break-manifest.sh init
fi

If $3 or $4 = --goggles OR scope contains frontend files → equip goggles automatically. If $3 or $4 = --guillotine OR scope crosses a public-API surface (PublicAPI.Shipped.txt, packable csproj, or packages/) → equip the Guillotine automatically and initialize the break manifest. Hades is smart enough to know when he needs his glasses — and his guillotine.

STEP 1 — Create Team:

TeamCreate: team_name = "hades-cleanup", description = "Hades cleanup: [scope]"

You are the team lead. You orchestrate — you NEVER implement. Teammates do all code work.

STEP 2 — Create Phase 0 Tasks:

Use TaskCreate for each audit domain. These go into the shared task list that all teammates can see.

TaskCreate: team_name = "hades-cleanup", title = "Audit suppressions in [scope]", description = "..."
TaskCreate: team_name = "hades-cleanup", title = "Audit dead code in [scope]", description = "..."
TaskCreate: team_name = "hades-cleanup", title = "Audit duplication in [scope]", description = "..."
TaskCreate: team_name = "hades-cleanup", title = "Audit imports in [scope]", description = "..."

If GOGGLES equipped, also create goggles tasks (taste, spec, compliance). If GUILLOTINE equipped, also create a guillotine audit task (public-API surface classification).

STEP 3 — Spawn Phase 0 Teammates (ALL in ONE message):

Use Task tool with team_name="hades-cleanup" for each. Prompts from templates/auditors.md:

Task: name="smart-audit-suppressions", team_name="hades-cleanup", subagent_type="general-purpose", model="opus"
Task: name="smart-audit-deadcode", team_name="hades-cleanup", subagent_type="general-purpose", model="opus"
Task: name="smart-audit-duplication", team_name="hades-cleanup", subagent_type="general-purpose", model="opus"
Task: name="smart-audit-imports", team_name="hades-cleanup", subagent_type="general-purpose", model="opus"

If GOGGLES: +3 goggles teammates from templates/goggles.md (all Opus 4.6, same team_name). If GUILLOTINE: +1 teammate smart-guillotine-audit from templates/guillotine.md (Opus 4.6, same team_name).

Teammates use SendMessage to debate findings with each other. Teammates use TaskCreate/TaskUpdate for the shared task list. Messages are automatically delivered — do not poll.

STEP 4 — Evaluate GATE 0:

When debate converges (teammates go idle with no new messages), evaluate Gate 0. Use TaskList to review completed audit tasks and findings.

STEP 5 — Phase Transition (Phase 0 -> Phase 1):

Shut down each Phase 0 teammate:

SendMessage: type="shutdown_request", recipient="smart-audit-suppressions"
SendMessage: type="shutdown_request", recipient="smart-audit-deadcode"
SendMessage: type="shutdown_request", recipient="smart-audit-duplication"
SendMessage: type="shutdown_request", recipient="smart-audit-imports"
(+ goggles teammates if equipped)

Wait for all shutdown_response messages. Then spawn Phase 1 eliminators (same pattern: Task with team_name="hades-cleanup", 4 teammates from templates/eliminators.md). Goggles findings become elimination tasks alongside standard findings. If GUILLOTINE: also spawn smart-guillotine-elim from templates/guillotine.md (Opus 4.6, same team_name) — it claims guillotine tasks, deletes/downgrades symbols, and emits one break-manifest.jsonl entry per BREAK task.

STEP 6 — Evaluate GATE 1:

When all elimination tasks are complete (check via TaskList), evaluate Gate 1.

STEP 7 — Phase Transition (Phase 1 -> Phase 2):

Shut down Phase 1 teammates (SendMessage type="shutdown_request" to each). Wait for all shutdown_responses. Spawn Phase 2 verifiers (4 teammates from templates/verifiers.md, same team_name). smart-verify-grep also checks goggles violations were resolved. If GUILLOTINE: also spawn smart-guillotine-verify from templates/guillotine.md (Opus 4.6, same team_name) — it runs the two-axis verification (shim-free + functionally equivalent) against .smart/break-manifest.jsonl and runs break-manifest.sh validate.

STEP 8 — Evaluate GATE 2:

If COMPLETE -> proceed to cleanup. If ITERATE -> shut down verifiers, respawn eliminators targeting remaining items.

STEP 9 — Cleanup (after COMPLETE):

# Revoke deletion permit
plugins/exodia/scripts/smart/permit.sh revoke

# Show ledger summary
plugins/exodia/scripts/smart/ledger.sh count

Shut down all remaining teammates (SendMessage type="shutdown_request"). Wait for all shutdown_responses, then delete the team:

TeamDelete: team_name = "hades-cleanup"

YOUR NEXT ACTION: Run Step -1 check, then Step 0 (Smart Init), then Step 1 (TeamCreate) and spawn Phase 0.

</CRITICAL_EXECUTION_REQUIREMENT>

GATE 0: Audit Complete

GATE 0: AUDIT -> [status]
SMART_ID: [value]
GOGGLES: [EQUIPPED | OFF]

+------------------------------------------------------------+
| Suppressions: [count] (fix: [n], false-positive: [n], upstream: [n])
| Dead Code:    [count] items ([lines] lines)
| Duplication:  [count] clusters
| Imports:      [count] issues
+------------------------------------------------------------+
| GOGGLES (if equipped):                                     |
|   Taste:      [n] findings (REDESIGN: [n], REFINE: [n])   |
|   Spec:       [n] violations (P1: [n], P2: [n], P3+: [n]) |
|   Compliance: [n] issues (CRITICAL: [n], WARNING: [n])     |
+------------------------------------------------------------+
| GUILLOTINE (if equipped):                                  |
|   Public symbols audited: [n]                              |
|     KEEP:      [n]   (real contracts, scope keeps them)    |
|     DOWNGRADE: [n]   (fake contracts → internal)           |
|     BREAK:     [n]   (real contracts → delete)             |
+------------------------------------------------------------+
| Cross-teammate messages: [count]
| Challenges resolved:     [count]
| Ownership conflicts:     [count] (resolved by lead)
+------------------------------------------------------------+
| Permit: ACTIVE (expires: [time])
| Ledger: [count] entries
+------------------------------------------------------------+
| VERDICT: PROCEED | HALT | SCAN_COMPLETE
+------------------------------------------------------------+

• $2 = scan-only -> SCAN_COMPLETE. Write findings to .eight-gates/artifacts/findings.json (enables auto-inherit). Present report. Revoke permit. Shut down. Done.
• Zero findings -> HALT. Nothing to clean. Revoke permit. Shut down. Done.
• Findings exist -> PROCEED. Write findings to .eight-gates/artifacts/findings.json. Shut down Phase 0. Spawn Phase 1.

GATE 1: Elimination Complete

GATE 1: ELIMINATION -> [status]
SMART_ID: [value]

+------------------------------------------------------------+
| Suppressions eliminated:  [n]/[total]
| Dead code deleted:        [n] items ([lines] lines)
| Duplication consolidated: [n] clusters
| Imports fixed:            [n] issues
| Public APIs broken:       [n] (--guillotine: downgrades + deletions)
+------------------------------------------------------------+
| Ledger entries:           [count] (verify == total actions taken)
| Break-manifest entries:   [count] (--guillotine, == BREAK tasks completed)
| Build: PASS | FAIL
| Tests: PASS | FAIL
+------------------------------------------------------------+
| VERDICT: PROCEED | HALT
+------------------------------------------------------------+

• Build/tests fail -> HALT. Lead diagnoses. Spawn targeted fix teammate.
• Tasks incomplete -> Wait or reassign.
• Guillotine BREAK task completed without a corresponding break-manifest entry -> HALT. Manifest is mandatory.
• All complete + build + tests pass + (if guillotine) manifest count == BREAK count -> PROCEED. Shut down Phase 1. Spawn Phase 2.

GATE 2: Verification Complete

GATE 2: VERIFICATION -> [status]
SMART_ID: [value]

+------------------------------------------------------------+
| Build:           CLEAN | WARNINGS ([count])
| Tests:           PASS ([n]) | FAIL ([n]) | SKIP ([n])
| Suppressions:    [count] remaining
| Ledger:          [count] entries (expected: [n])
| Challenger:      [n] claims confirmed, [n] challenged
+------------------------------------------------------------+
| GUILLOTINE (if equipped):                                  |
|   Axis 1 (shim-free):           PASS | FAIL ([n] hits)    |
|   Axis 2 (functionally equiv.): PASS | FAIL ([n] entries) |
|   Manifest validate:            PASS | FAIL                |
|   Break-manifest entries:       [n] (== Phase 1 BREAK count)
+------------------------------------------------------------+
| VERDICT: COMPLETE | ITERATE
+------------------------------------------------------------+

• Any remaining suppressions > 0 -> ITERATE. Back to Phase 1 targeting remaining items.
• Build warnings > 0 -> ITERATE.
• Ledger incomplete -> ITERATE. Log missing entries.
• Challenged claims unresolved -> ITERATE with targeted teammates.
• Guillotine Axis 1 fail (shim found in diff) -> ITERATE. Eliminator removes the shim.
• Guillotine Axis 2 fail (consumer call site not rewired and not deleted, or replacement test missing) -> ITERATE. Eliminator either rewires or deletes; cannot leave the gap.
• break-manifest.sh validate fail (entry has neither replacement nor justification) -> ITERATE. Eliminator fills the missing field.
• All zeros + all confirmed + ledger complete + (if guillotine) both axes pass + manifest valid -> COMPLETE.

CLEANUP

1. Shut down all remaining teammates: SendMessage type="shutdown_request" to each
2. Wait for all shutdown_responses
3. If guillotine equipped: plugins/exodia/scripts/smart/break-manifest.sh validate (must exit 0)
4. Revoke deletion permit: plugins/exodia/scripts/smart/permit.sh revoke
5. Delete team: TeamDelete: team_name = "hades-cleanup"
6. Present final report

If Connectors Available

• ~~github~~ Open a cleanup PR from Gate 1 output and block merge until Gate 2 passes
• ~~sonarqube~~ Push post-cleanup metrics for suppression count, duplication ratio, and coverage
• ~~slack~~ Post the final HADES CLEANUP REPORT summary to a team channel
• ~~linear~~ Auto-close suppression and dead-code issues resolved by the elimination phase

FINAL REPORT

+====================================================================+
|                    HADES CLEANUP REPORT                            |
+====================================================================+
| Smart ID: [SMART-YYYY-MM-DD-...]                                   |
| Scope: $0                                                          |
| Intensity: $2                                                      |
| Goggles: [EQUIPPED | OFF]                                          |
| Guillotine: [EQUIPPED | OFF]                                       |
| Phases: 12 base + 3 (goggles, P0) + 3 (guillotine) = 12..18 total  |
+====================================================================+
|                   BEFORE -> AFTER                                  |
|  Suppressions:    [n] -> 0                                         |
|  Dead code lines: [n] -> 0                                         |
|  Duplication:     [n] clusters -> 0                                |
|  Import issues:   [n] -> 0                                         |
|  Build warnings:  [n] -> 0                                         |
|  Public APIs:     [n] -> [n - broken]  (--guillotine)              |
+====================================================================+
|                   GOGGLES (if equipped)                             |
|  Taste violations:      [n] -> 0  (REDESIGN: [n], REFINE: [n])    |
|  Spec violations:       [n] -> 0  (P1: [n], P2: [n], P3+: [n])   |
|  Compliance violations: [n] -> 0  (CRITICAL: [n], WARNING: [n])   |
|  Pipeline flow: taste → spec → compliance                          |
+====================================================================+
|                   GUILLOTINE (if equipped)                          |
|  Public symbols audited:    [n]                                     |
|    KEEP:                    [n]                                     |
|    DOWNGRADE -> internal:   [n]                                     |
|    BREAK -> deleted:        [n]                                     |
|  Break-manifest entries:    [n]                                     |
|  Axis 1 (shim-free):        PASS                                    |
|  Axis 2 (functionally eq.): PASS                                    |
|  Manifest validated:        PASS                                    |
|  Pure removals:             [n] (with explicit justification)       |
|  Replacements wired:        [n] (with consumer rewire)              |
+====================================================================+
|                   SMART INFRASTRUCTURE                             |
|  Ledger entries:           [n]                                     |
|  Break-manifest entries:   [n] (--guillotine)                      |
|  Permit lifecycle:         created -> active -> revoked            |
|  Permit TTL:               [n]s (used [n]s)                        |
+====================================================================+
|                   DEBATE METRICS                                   |
|  Cross-teammate messages: [n]                                      |
|  Challenges raised: [n]                                            |
|  Challenges resolved: [n]                                          |
|  Ownership conflicts: [n]                                          |
+====================================================================+
|                   VERIFICATION                                     |
|  Build: PASS (zero warnings)                                       |
|  Tests: PASS ([n] passed, 0 skipped)                               |
|  Iterations: [n]                                                   |
|  Challenger confirmations: [n]/[n]                                 |
+====================================================================+

| Category | Before | After | Ledger Entries | Manifest Entries | Debate Messages | |------------------------|------------|-------|----------------|------------------|-----------------| | Suppressions | X | 0 | [n] | -- | [n] | | Dead code | X lines | 0 | [n] | -- | [n] | | Duplication | X clusters | 0 | [n] | -- | [n] | | Imports | X issues | 0 | [n] | -- | [n] | | Build warnings | X | 0 | -- | -- | -- | | Taste (goggles) | X | 0 | [n] | -- | [n] | | Spec (goggles) | X | 0 | [n] | -- | [n] | | Compliance (goggles) | X | 0 | [n] | -- | [n] | | Public-API (guillotine)| X | [n] | [n] | [n] | [n] |