codeply-cli 0.5.5 → 0.6.0

package/skills/ecc-recipes/SKILL.md

@@ -1,149 +1,149 @@
----
-name: ecc-recipes
-description: "Map a described workflow to the right ECC command-GROUP with run-order and stop condition, and browse all command-group recipe families. Adds a family-grouping + run-order + when-to-stop layer on top of the flat command catalog. Advisory only. TRIGGER when the user says which commands for X, what command group runs X, show ECC recipes, list ECC pipelines, or how do I run a workflow with ECC. DO NOT TRIGGER when the user wants the task executed directly, wants a single-command deep doc (use ecc-guide), or wants a draft prompt rewritten (use prompt-optimizer)."
-argument-hint: <workflow description | empty=list all>
-origin: community
-author: KyawZinLatt
-version: "1.0.0"
----
-
-# ECC Recipes
-
-One entry point for "which group of ECC slash-commands runs my workflow, in what
-order, and when do I stop." Also browses every command-group recipe family.
-
-Fills the gap between two existing skills:
-
-- `ecc-guide` — lists commands and where to read docs, but as a flat catalog.
-- `prompt-optimizer` — matches a task to components, but outputs a single prompt,
-  not a multi-command group with run-order and stop condition.
-
-This skill adds: **family grouping + run-order + stop condition.**
-
-## When to Activate
-
-- "Which command group do I run for <workflow>?"
-- "What's the command sequence to build an MVP / fix a defect / refactor?"
-- "Show me all ECC command-group recipes" (catalog mode)
-- "How many workflow pipelines does ECC have?"
-- User invokes `/ecc-recipes` with or without a description.
-
-### Do Not Use When
-
-- User wants the task done now — route to the actual command, don't describe it.
-- User wants deep docs for ONE command — use `ecc-guide`.
-- User wants a draft prompt rewritten — use `prompt-optimizer`.
-
-## Core Principle
-
-**Answer from current files, not memory.** The command set changes; never
-hardcode counts or member lists. Read the live `commands/` directory each run,
-then classify into families.
-
-### Live reads
-
-Resolve the commands directory (first that exists), then list names:
-
-```bash
-for D in \
-  "$HOME"/.claude/plugins/marketplaces/ecc/commands \
-  "$HOME"/.claude/plugins/cache/ecc/ecc/*/commands \
-  ./commands \
-  ./.claude/commands \
-  "$HOME"/.claude/commands; do
-  [ -d "$D" ] && CMD_DIR="$D" && break
-done
-[ -z "${CMD_DIR:-}" ] && { echo "No ECC commands directory found."; return 1; }
-find "$CMD_DIR" -maxdepth 1 -name '*.md' -exec basename {} .md \; | sort
-```
-
-Optionally read `manifests/install-*.json` if present for richer grouping. Use
-the smallest set of reads needed.
-
-## Family Classification (by prefix)
-
-Group command names by leading prefix; map known singletons by hand. Families are
-derived live — the table below is the *classification rule*, not a frozen list.
-
-| Family prefix | Recipe meaning | Typical run-order |
-|---|---|---|
-| `orch-*` | gated Research, Plan, TDD, Review, Commit per task type | pick one orch-* by task kind; it runs its own internal phases |
-| `multi-*` | multi-model workflow | `multi-plan` then `multi-execute` then review (or `multi-workflow` end-to-end) |
-| `prp-*` | PRD to plan to implement to PR pipeline | `prp-prd` then `prp-plan` then `prp-implement` then `prp-commit` then `prp-pr` |
-| `epic-*` | large multi-unit epic, parallel | `epic-decompose` then `epic-claim` then `epic-validate` then `epic-review` then `epic-unblock` then `epic-sync` then `epic-publish` |
-| `loop-*` | managed autonomous loop and monitor | `loop-start <pattern>` then watch with `loop-status` |
-| `gan-*` | generator and evaluator loop | `gan-build` (code) or `gan-design` (UI); self-looping |
-| `*-build` / `*-review` / `*-test` | per-language CI triad | `<lang>-test` (TDD) then `<lang>-build` (fix) then `<lang>-review` |
-| `hookify-*` | behavior-hook management | `hookify` then `hookify-list` then `hookify-configure` |
-| `learn` / `instinct-*` / `evolve` / `promote` / `prune` | continuous-learning | `learn` then `instinct-status` then `evolve` then `promote` |
-| singletons | `santa-loop`, `plan`, `plan-prd`, `pr`, `code-review`, `checkpoint`, etc. | standalone or glue between groups |
-
-Any command not matching a prefix rule → list it under **singletons** with its
-one-line description.
-
-## How It Works
-
-```
-1. Live-read command names from CMD_DIR.
-2. Classify into families by prefix and a singleton map.
-3. If a workflow description was given -> MATCH MODE.
-   If none -> CATALOG MODE.
-4. Advisory only: print the plan. Never run the matched commands.
-```
-
-### Catalog mode (no description)
-
-Output the family table: each family, member count, members, one-line meaning,
-typical run-order. End with the total command count and a prompt to describe a
-workflow for a matched recipe.
-
-### Match mode (description given)
-
-1. Restate the workflow in one sentence.
-2. Pick the best 1-2 families; say WHY in one line each.
-3. **Run-order block** — exact command sequence for the matched family.
-4. **Stop condition** — always explicit (max-runs, completion-signal,
-   review-passes, or single-shot). For autonomous loops, warn about subscription
-   burn and recommend a backstop bound.
-5. **Where to read** — the `commands/<name>.md` path plus `/ecc-guide <name>`.
-
-## Output Template (match mode)
-
-```
-Workflow: <one-sentence restatement>
-
-Best fit: <family> — <why>
-(Alt: <family> — <why>)
-
-Run-order:
-  /<cmd1>   # job
-  /<cmd2>   # job
-  /<cmd3>   # job
-  STOP when: <condition>
-  WARNING (autonomous loops only): an unbounded loop burns subscription/credits —
-  add a max-iteration or max-cost backstop alongside the completion signal.
-
-Read full docs:
-  commands/<cmd1>.md   (or: /ecc-guide <cmd1>)
-```
-
-## Examples
-
-**Catalog:** `/ecc-recipes` → prints the family table and total count.
-
-**Match:** `/ecc-recipes plan a whole app upfront then auto-build with adversarial
-review until done` → Best fit: `loop-*` (autonomous) wrapping `gan-*` or
-`santa-loop` (adversarial). Run-order: `plan-prd` then
-`loop-start rfc-dag --mode safe` then monitor `loop-status`; STOP when all units
-pass review N consecutive times (add a max-iteration backstop to bound burn).
-
-**Match:** `/ecc-recipes fix a bug in my Go service` → Best fit: `orch-fix-defect`
-(reproduce, fix, review, commit). Alt: `go-test` then `go-build` then
-`go-review`. STOP: regression test green and review pass.
-
-## Non-Goals
-
-- Not an executor — advisory only.
-- Not per-command deep docs — that's `ecc-guide`.
-- Not prompt rewriting — that's `prompt-optimizer`.
-- Never hardcode command counts or member lists — always live-read.
+---
+name: ecc-recipes
+description: "Map a described workflow to the right ECC command-GROUP with run-order and stop condition, and browse all command-group recipe families. Adds a family-grouping + run-order + when-to-stop layer on top of the flat command catalog. Advisory only. TRIGGER when the user says which commands for X, what command group runs X, show ECC recipes, list ECC pipelines, or how do I run a workflow with ECC. DO NOT TRIGGER when the user wants the task executed directly, wants a single-command deep doc (use ecc-guide), or wants a draft prompt rewritten (use prompt-optimizer)."
+argument-hint: <workflow description | empty=list all>
+origin: community
+author: KyawZinLatt
+version: "1.0.0"
+---
+
+# ECC Recipes
+
+One entry point for "which group of ECC slash-commands runs my workflow, in what
+order, and when do I stop." Also browses every command-group recipe family.
+
+Fills the gap between two existing skills:
+
+- `ecc-guide` — lists commands and where to read docs, but as a flat catalog.
+- `prompt-optimizer` — matches a task to components, but outputs a single prompt,
+  not a multi-command group with run-order and stop condition.
+
+This skill adds: **family grouping + run-order + stop condition.**
+
+## When to Activate
+
+- "Which command group do I run for <workflow>?"
+- "What's the command sequence to build an MVP / fix a defect / refactor?"
+- "Show me all ECC command-group recipes" (catalog mode)
+- "How many workflow pipelines does ECC have?"
+- User invokes `/ecc-recipes` with or without a description.
+
+### Do Not Use When
+
+- User wants the task done now — route to the actual command, don't describe it.
+- User wants deep docs for ONE command — use `ecc-guide`.
+- User wants a draft prompt rewritten — use `prompt-optimizer`.
+
+## Core Principle
+
+**Answer from current files, not memory.** The command set changes; never
+hardcode counts or member lists. Read the live `commands/` directory each run,
+then classify into families.
+
+### Live reads
+
+Resolve the commands directory (first that exists), then list names:
+
+```bash
+for D in \
+  "$HOME"/.claude/plugins/marketplaces/ecc/commands \
+  "$HOME"/.claude/plugins/cache/ecc/ecc/*/commands \
+  ./commands \
+  ./.claude/commands \
+  "$HOME"/.claude/commands; do
+  [ -d "$D" ] && CMD_DIR="$D" && break
+done
+[ -z "${CMD_DIR:-}" ] && { echo "No ECC commands directory found."; return 1; }
+find "$CMD_DIR" -maxdepth 1 -name '*.md' -exec basename {} .md \; | sort
+```
+
+Optionally read `manifests/install-*.json` if present for richer grouping. Use
+the smallest set of reads needed.
+
+## Family Classification (by prefix)
+
+Group command names by leading prefix; map known singletons by hand. Families are
+derived live — the table below is the *classification rule*, not a frozen list.
+
+| Family prefix | Recipe meaning | Typical run-order |
+|---|---|---|
+| `orch-*` | gated Research, Plan, TDD, Review, Commit per task type | pick one orch-* by task kind; it runs its own internal phases |
+| `multi-*` | multi-model workflow | `multi-plan` then `multi-execute` then review (or `multi-workflow` end-to-end) |
+| `prp-*` | PRD to plan to implement to PR pipeline | `prp-prd` then `prp-plan` then `prp-implement` then `prp-commit` then `prp-pr` |
+| `epic-*` | large multi-unit epic, parallel | `epic-decompose` then `epic-claim` then `epic-validate` then `epic-review` then `epic-unblock` then `epic-sync` then `epic-publish` |
+| `loop-*` | managed autonomous loop and monitor | `loop-start <pattern>` then watch with `loop-status` |
+| `gan-*` | generator and evaluator loop | `gan-build` (code) or `gan-design` (UI); self-looping |
+| `*-build` / `*-review` / `*-test` | per-language CI triad | `<lang>-test` (TDD) then `<lang>-build` (fix) then `<lang>-review` |
+| `hookify-*` | behavior-hook management | `hookify` then `hookify-list` then `hookify-configure` |
+| `learn` / `instinct-*` / `evolve` / `promote` / `prune` | continuous-learning | `learn` then `instinct-status` then `evolve` then `promote` |
+| singletons | `santa-loop`, `plan`, `plan-prd`, `pr`, `code-review`, `checkpoint`, etc. | standalone or glue between groups |
+
+Any command not matching a prefix rule → list it under **singletons** with its
+one-line description.
+
+## How It Works
+
+```
+1. Live-read command names from CMD_DIR.
+2. Classify into families by prefix and a singleton map.
+3. If a workflow description was given -> MATCH MODE.
+   If none -> CATALOG MODE.
+4. Advisory only: print the plan. Never run the matched commands.
+```
+
+### Catalog mode (no description)
+
+Output the family table: each family, member count, members, one-line meaning,
+typical run-order. End with the total command count and a prompt to describe a
+workflow for a matched recipe.
+
+### Match mode (description given)
+
+1. Restate the workflow in one sentence.
+2. Pick the best 1-2 families; say WHY in one line each.
+3. **Run-order block** — exact command sequence for the matched family.
+4. **Stop condition** — always explicit (max-runs, completion-signal,
+   review-passes, or single-shot). For autonomous loops, warn about subscription
+   burn and recommend a backstop bound.
+5. **Where to read** — the `commands/<name>.md` path plus `/ecc-guide <name>`.
+
+## Output Template (match mode)
+
+```
+Workflow: <one-sentence restatement>
+
+Best fit: <family> — <why>
+(Alt: <family> — <why>)
+
+Run-order:
+  /<cmd1>   # job
+  /<cmd2>   # job
+  /<cmd3>   # job
+  STOP when: <condition>
+  WARNING (autonomous loops only): an unbounded loop burns subscription/credits —
+  add a max-iteration or max-cost backstop alongside the completion signal.
+
+Read full docs:
+  commands/<cmd1>.md   (or: /ecc-guide <cmd1>)
+```
+
+## Examples
+
+**Catalog:** `/ecc-recipes` → prints the family table and total count.
+
+**Match:** `/ecc-recipes plan a whole app upfront then auto-build with adversarial
+review until done` → Best fit: `loop-*` (autonomous) wrapping `gan-*` or
+`santa-loop` (adversarial). Run-order: `plan-prd` then
+`loop-start rfc-dag --mode safe` then monitor `loop-status`; STOP when all units
+pass review N consecutive times (add a max-iteration backstop to bound burn).
+
+**Match:** `/ecc-recipes fix a bug in my Go service` → Best fit: `orch-fix-defect`
+(reproduce, fix, review, commit). Alt: `go-test` then `go-build` then
+`go-review`. STOP: regression test green and review pass.
+
+## Non-Goals
+
+- Not an executor — advisory only.
+- Not per-command deep docs — that's `ecc-guide`.
+- Not prompt rewriting — that's `prompt-optimizer`.
+- Never hardcode command counts or member lists — always live-read.

package/skills/ecc-tools-cost-audit/SKILL.md

@@ -1,161 +1,161 @@
----
-name: ecc-tools-cost-audit
-description: Evidence-first ECC Tools burn and billing audit workflow. Use when investigating runaway PR creation, quota bypass, premium-model leakage, duplicate jobs, or GitHub App cost spikes in the ECC Tools repo.
-metadata:
-  origin: ECC
----
-
-# ECC Tools Cost Audit
-
-Use this skill when the user suspects the ECC Tools GitHub App is burning cost, over-creating PRs, bypassing usage limits, or routing free users into premium analysis paths.
-
-This is a focused operator workflow for the sibling [ECC-Tools](../../ECC-Tools) repo. It is not a generic billing skill and it is not a repo-wide code review pass.
-
-## Skill Stack
-
-Pull these ECC-native skills into the workflow when relevant:
-
-- `autonomous-loops` for bounded multi-step audits that cross webhooks, queues, billing, and retries
-- `agentic-engineering` for tracing the request path into discrete, provable units
-- `customer-billing-ops` when repo behavior and customer-impact math must be separated cleanly
-- `search-first` before inventing helpers or re-implementing repo-local utilities
-- `security-review` when auth, usage gates, entitlements, or secrets are touched
-- `verification-loop` for proving rerun safety and exact post-fix state
-- `tdd-workflow` when the fix needs regression coverage in the worker, router, or billing paths
-
-## When To Use
-
-- user says ECC Tools burn rate, PR recursion, over-created PRs, usage-limit bypass, or premium-model leakage
-- the task is in the sibling `ECC-Tools` repo and depends on webhook handlers, queue workers, usage reservation, PR creation logic, or paid-gate enforcement
-- a customer report says the app created too many PRs, billed incorrectly, or analyzed code without producing a usable result
-
-## Scope Guardrails
-
-- work in the sibling `ECC-Tools` repo, not in `everything-claude-code`
-- start read-only unless the user clearly asked for a fix
-- do not mutate unrelated billing, checkout, or UI flows while tracing analysis burn
-- treat app-generated branches and app-generated PRs as red-flag recursion paths until proved otherwise
-- separate three things explicitly:
-  - repo-side burn root cause
-  - customer-facing billing impact
-  - product or entitlement gaps that need backlog follow-up
-
-## Workflow
-
-### 1. Freeze repo scope
-
-- switch into the sibling `ECC-Tools` repo
-- check branch and local diff first
-- identify the exact surface under audit:
-  - webhook router
-  - queue producer
-  - queue consumer
-  - PR creation path
-  - usage reservation / billing path
-  - model routing path
-
-### 2. Trace ingress before theorizing
-
-- inspect `src/index.*` or the main entrypoint first
-- map every enqueue path before suggesting a fix
-- confirm which GitHub events share a queue type
-- confirm whether push, pull_request, synchronize, comment, or manual re-run events can converge on the same expensive path
-
-### 3. Trace the worker and side effects
-
-- inspect the queue consumer or scheduled worker that handles analysis
-- confirm whether a queued analysis always ends in:
-  - PR creation
-  - branch creation
-  - file updates
-  - premium model calls
-  - usage increments
-- if analysis can spend tokens and then fail before output is persisted, classify it as burn-with-broken-output
-
-### 4. Audit the high-signal burn paths
-
-#### PR multiplication
-
-- inspect PR helpers and branch naming
-- check dedupe, synchronize-event handling, and existing-PR reuse
-- if app-generated branches can re-enter analysis, treat that as a priority-0 recursion risk
-
-#### Quota bypass
-
-- inspect where quota is checked versus where usage is reserved or incremented
-- if quota is checked before enqueue but usage is charged only inside the worker, treat concurrent front-door passes as a real race
-
-#### Premium-model leakage
-
-- inspect model selection, tier branching, and provider routing
-- verify whether free or capped users can still hit premium analyzers when premium keys are present
-
-#### Retry burn
-
-- inspect retry loops, duplicate queue jobs, and deterministic failure reruns
-- if the same non-transient error can spend analysis repeatedly, fix that before quality improvements
-
-### 5. Fix in burn order
-
-If the user asked for code changes, prioritize fixes in this order:
-
-1. stop automatic PR multiplication
-2. stop quota bypass
-3. stop premium leakage
-4. stop duplicate-job fanout and pointless retries
-5. close rerun/update safety gaps
-
-Keep the pass bounded to one to three direct fixes unless the same root cause clearly spans multiple files.
-
-### 6. Verify with the smallest proving steps
-
-- rerun only the targeted tests or integration slices that cover the changed path
-- verify whether the burn path is now:
-  - blocked
-  - deduped
-  - downgraded to cheaper analysis
-  - or rejected early
-- state the final status exactly:
-  - changed locally
-  - verified locally
-  - pushed
-  - deployed
-  - still blocked
-
-## High-Signal Failure Patterns
-
-### 1. One queue type for all triggers
-
-If pushes, PR syncs, and manual audits all enqueue the same job and the worker always creates a PR, analysis equals PR spam.
-
-### 2. Post-enqueue usage reservation
-
-If usage is checked at the front door but only incremented in the worker, concurrent requests can all pass the gate and exceed quota.
-
-### 3. Free tier on premium path
-
-If free queued jobs can still route into Anthropic or another premium provider when keys exist, that is real spend leakage even if the user never sees the premium result.
-
-### 4. App-generated branches re-enter the webhook
-
-If `pull_request.synchronize`, branch pushes, or comment-triggered runs fire on app-owned branches, the app can recursively analyze its own output.
-
-### 5. Expensive work before persistence safety
-
-If the system can spend tokens and then fail on PR creation, file update, or branch collision, it is burning cost without shipping value.
-
-## Pitfalls
-
-- do not begin with broad repo wandering; settle webhook -> queue -> worker first
-- do not mix customer billing inference with code-backed product truth
-- do not fix lower-value quality issues before the highest-burn path is contained
-- do not claim burn is fixed until the narrow proving step was rerun
-- do not push or deploy unless the user asked
-- do not touch unrelated repo-local changes if they are already in progress
-
-## Verification
-
-- root causes cite exact file paths and code areas
-- fixes are ordered by burn impact, not code neatness
-- proving commands are named
-- final status distinguishes local change, verification, push, and deployment
+---
+name: ecc-tools-cost-audit
+description: Evidence-first ECC Tools burn and billing audit workflow. Use when investigating runaway PR creation, quota bypass, premium-model leakage, duplicate jobs, or GitHub App cost spikes in the ECC Tools repo.
+metadata:
+  origin: ECC
+---
+
+# ECC Tools Cost Audit
+
+Use this skill when the user suspects the ECC Tools GitHub App is burning cost, over-creating PRs, bypassing usage limits, or routing free users into premium analysis paths.
+
+This is a focused operator workflow for the sibling [ECC-Tools](../../ECC-Tools) repo. It is not a generic billing skill and it is not a repo-wide code review pass.
+
+## Skill Stack
+
+Pull these ECC-native skills into the workflow when relevant:
+
+- `autonomous-loops` for bounded multi-step audits that cross webhooks, queues, billing, and retries
+- `agentic-engineering` for tracing the request path into discrete, provable units
+- `customer-billing-ops` when repo behavior and customer-impact math must be separated cleanly
+- `search-first` before inventing helpers or re-implementing repo-local utilities
+- `security-review` when auth, usage gates, entitlements, or secrets are touched
+- `verification-loop` for proving rerun safety and exact post-fix state
+- `tdd-workflow` when the fix needs regression coverage in the worker, router, or billing paths
+
+## When To Use
+
+- user says ECC Tools burn rate, PR recursion, over-created PRs, usage-limit bypass, or premium-model leakage
+- the task is in the sibling `ECC-Tools` repo and depends on webhook handlers, queue workers, usage reservation, PR creation logic, or paid-gate enforcement
+- a customer report says the app created too many PRs, billed incorrectly, or analyzed code without producing a usable result
+
+## Scope Guardrails
+
+- work in the sibling `ECC-Tools` repo, not in `everything-claude-code`
+- start read-only unless the user clearly asked for a fix
+- do not mutate unrelated billing, checkout, or UI flows while tracing analysis burn
+- treat app-generated branches and app-generated PRs as red-flag recursion paths until proved otherwise
+- separate three things explicitly:
+  - repo-side burn root cause
+  - customer-facing billing impact
+  - product or entitlement gaps that need backlog follow-up
+
+## Workflow
+
+### 1. Freeze repo scope
+
+- switch into the sibling `ECC-Tools` repo
+- check branch and local diff first
+- identify the exact surface under audit:
+  - webhook router
+  - queue producer
+  - queue consumer
+  - PR creation path
+  - usage reservation / billing path
+  - model routing path
+
+### 2. Trace ingress before theorizing
+
+- inspect `src/index.*` or the main entrypoint first
+- map every enqueue path before suggesting a fix
+- confirm which GitHub events share a queue type
+- confirm whether push, pull_request, synchronize, comment, or manual re-run events can converge on the same expensive path
+
+### 3. Trace the worker and side effects
+
+- inspect the queue consumer or scheduled worker that handles analysis
+- confirm whether a queued analysis always ends in:
+  - PR creation
+  - branch creation
+  - file updates
+  - premium model calls
+  - usage increments
+- if analysis can spend tokens and then fail before output is persisted, classify it as burn-with-broken-output
+
+### 4. Audit the high-signal burn paths
+
+#### PR multiplication
+
+- inspect PR helpers and branch naming
+- check dedupe, synchronize-event handling, and existing-PR reuse
+- if app-generated branches can re-enter analysis, treat that as a priority-0 recursion risk
+
+#### Quota bypass
+
+- inspect where quota is checked versus where usage is reserved or incremented
+- if quota is checked before enqueue but usage is charged only inside the worker, treat concurrent front-door passes as a real race
+
+#### Premium-model leakage
+
+- inspect model selection, tier branching, and provider routing
+- verify whether free or capped users can still hit premium analyzers when premium keys are present
+
+#### Retry burn
+
+- inspect retry loops, duplicate queue jobs, and deterministic failure reruns
+- if the same non-transient error can spend analysis repeatedly, fix that before quality improvements
+
+### 5. Fix in burn order
+
+If the user asked for code changes, prioritize fixes in this order:
+
+1. stop automatic PR multiplication
+2. stop quota bypass
+3. stop premium leakage
+4. stop duplicate-job fanout and pointless retries
+5. close rerun/update safety gaps
+
+Keep the pass bounded to one to three direct fixes unless the same root cause clearly spans multiple files.
+
+### 6. Verify with the smallest proving steps
+
+- rerun only the targeted tests or integration slices that cover the changed path
+- verify whether the burn path is now:
+  - blocked
+  - deduped
+  - downgraded to cheaper analysis
+  - or rejected early
+- state the final status exactly:
+  - changed locally
+  - verified locally
+  - pushed
+  - deployed
+  - still blocked
+
+## High-Signal Failure Patterns
+
+### 1. One queue type for all triggers
+
+If pushes, PR syncs, and manual audits all enqueue the same job and the worker always creates a PR, analysis equals PR spam.
+
+### 2. Post-enqueue usage reservation
+
+If usage is checked at the front door but only incremented in the worker, concurrent requests can all pass the gate and exceed quota.
+
+### 3. Free tier on premium path
+
+If free queued jobs can still route into Anthropic or another premium provider when keys exist, that is real spend leakage even if the user never sees the premium result.
+
+### 4. App-generated branches re-enter the webhook
+
+If `pull_request.synchronize`, branch pushes, or comment-triggered runs fire on app-owned branches, the app can recursively analyze its own output.
+
+### 5. Expensive work before persistence safety
+
+If the system can spend tokens and then fail on PR creation, file update, or branch collision, it is burning cost without shipping value.
+
+## Pitfalls
+
+- do not begin with broad repo wandering; settle webhook -> queue -> worker first
+- do not mix customer billing inference with code-backed product truth
+- do not fix lower-value quality issues before the highest-burn path is contained
+- do not claim burn is fixed until the narrow proving step was rerun
+- do not push or deploy unless the user asked
+- do not touch unrelated repo-local changes if they are already in progress
+
+## Verification
+
+- root causes cite exact file paths and code areas
+- fixes are ordered by burn impact, not code neatness
+- proving commands are named
+- final status distinguishes local change, verification, push, and deployment