claudecode-omc 5.11.0 → 5.13.0

package/bundled/upstream/ecc/skills/competitive-platform-analysis/SKILL.md

@@ -0,0 +1,214 @@
+---
+name: competitive-platform-analysis
+description: >-
+  Use when scoping a competitive landscape — identifying, categorising, and
+  score-filtering a competitor set before any benchmarking begins. Decides who
+  counts as a competitor, which tier they belong to, and which sources to mine.
+  First step in the three-skill competitive pipeline; precedes
+  benchmark-methodology.
+---
+
+# Competitive Platform Analysis
+
+Use this skill to decide **who to benchmark** and **where to find them** before
+any scoring begins. A competitive analysis is only as good as its frame: the
+wrong set makes the client look either unbeatable or doomed. The goal is a
+defensible, decision-relevant set — not an exhaustive census.
+
+## When to Activate
+
+- About to start a competitive benchmarking project and need to define the competitor set first.
+- Unsure which companies belong in Direct / Adjacent / Aspirational tiers.
+- Need a defensible, pruned scope for a market landscape report.
+- Has a positioning brief and wants to identify who contests that position.
+- First step before running benchmark-methodology.
+
+## Client positioning brief (establish first)
+
+Before scoping the set, establish the client's positioning brief. If you don't
+already have it, run a short brand-discovery interview to elicit it — do **not**
+invent one and do **not** scope the set blind. The brief supplies:
+
+- **Identity / aesthetic register** — what kind of studio or company this is and
+  how it presents itself.
+- **Offer** — what services or products it delivers.
+- **Target clients** — who it sells to.
+- **Differentiator** — the moat or positioning argument the client believes in.
+- **Scoping consequence** — the implication for how to weight competitors (e.g.,
+  prioritize by distinctiveness vs. capability overlap vs. price).
+- **Strategic tension** — the paired axes that define the client's white-space
+  (e.g., memorability × hireability).
+
+**Do not proceed without the positioning brief.** A competitor list scoped
+without the client's lens is noise, not intelligence. The scoping consequence in
+particular determines which competitors are *strong* rivals (those that contest
+the client's moat) vs. merely overlapping on service menu.
+
+## Selection criteria
+
+For each candidate, capture these axes — they decide both inclusion and tier:
+
+- **Size / model** — solo, micro-studio (2–8), boutique (sub-30), mid-size
+  agency. Match the client's own band; same-band studios are the realistic
+  head-to-head set.
+- **Niche / specialization** — how closely the candidate's focus overlaps with
+  the client's offer. Tighter overlap = more direct.
+- **Geography / market** — EU vs US vs global-remote; language; time-zone reach.
+  Note whether they win the same clients the client targets.
+- **Pricing & engagement model** — productized sprints, retainer, project,
+  day-rate; transparent vs "contact us". Signals positioning maturity.
+- **Portfolio style** — generic vs. opinionated/editorial vs. contrarian. Closer
+  to the client's aesthetic register = more they contest the client's
+  distinctiveness.
+- **Technical depth / craft maturity** — relevant if the client's credibility
+  story includes public process work, open tooling, or documented systems.
+- **Brand strength** — does the studio have an ownable verbal/visual identity, or
+  is it interchangeable? Weight this per the client's scoping consequence.
+
+## Player taxonomy — axes to populate across
+
+Don't sort competitors into niche-specific buckets; sort them along a few
+generic axes so the landscape isn't skewed toward one archetype. These axes
+apply to any creative-service market (design, motion, copywriting, branding,
+content, film, etc.). Aim for breadth across each axis first, then prune to the
+most instructive.
+
+1. **Positioning stance** — *brand-led / editorial* (competes on identity,
+   voice, POV) vs *capability-led* (competes on craft, throughput, outcomes).
+   Populate both poles; the client's closest mirror sits at its own end.
+2. **Specialization** — *specialist* (one tight discipline or vertical) vs
+   *generalist* (broad service menu). Tighter overlap with the client's focus =
+   more direct.
+3. **Size / model** — *solo / micro* vs *boutique* vs *mid-size* vs
+   *enterprise-scale*. Same-band players are the realistic head-to-head; larger
+   bands are the aspirational/commercial-maturity reference.
+4. **Engagement format** — *productized* (named sprints, audits, fixed packages)
+   vs *bespoke* (custom project / retainer). Signals positioning maturity.
+5. **Distinctiveness posture** — *conventional / safe* vs *contrarian /
+   manifesto-driven*. The opinionated end is key for distinctiveness
+   benchmarking in any niche.
+6. **Evidence / credibility model** — *outcome-led* (metrics, named clients,
+   case depth) vs *aesthetic-led* (portfolio, awards). Tells you how each player
+   earns trust.
+7. **Brand strength of the operator** — *interchangeable* vs *cult / ownable
+   identity* (including senior independents who prove the "memorable solo brand"
+   model).
+8. **Market / reach** — *local / regional* vs *global-remote*; note whether they
+   win the same clients the client targets.
+
+Plot each candidate on the relevant axes; a competitor is *direct* when it sits
+near the client on positioning, specialization, size, and market at once.
+
+## Competitive tiers (how the set resolves)
+
+Group the final set into three tiers — this structure carries through to the
+report:
+
+- **Direct** — same band, overlapping offer, same client targets. The realistic
+  head-to-head.
+- **Adjacent** — partial overlap (one capability, or a different client size)
+  that pressures at the edges.
+- **Aspirational** — players the client is not competing with today but whose
+  brand or commercial maturity sets the bar to aim at.
+- *(Watch also for substitutes: no-code/AI tools, in-house teams, generalist
+  freelancers — note as a threat vector, not a profiled competitor unless
+  materially relevant.)*
+
+## Data sources (where to look)
+
+Match the source to the dimension you need. The platform *types* below are
+generic; substitute the ones native to the client's niche (e.g. Dribbble/Behance
+for design, showreel/Vimeo for motion, writing samples/published work for copy):
+
+- **Portfolio / craft platforms** — craft quality, range, aesthetic register
+  (e.g. Dribbble, Behance, Vimeo, or the niche's equivalent showcase).
+- **Awards / curated showcases** — craft ambition and editorial recognition;
+  over-indexes on flashy, so cross-check commercial credibility (e.g. Awwwards,
+  industry award lists).
+- **Competitor's own site** — primary source for positioning, voice, offer
+  packaging, pricing posture, named clients, manifesto/POV.
+- **LinkedIn** — team size/model, founder narrative, post cadence, client logos,
+  geography.
+- **Review directories** — reviews, named clients, project sizes, engagement
+  models; strongest signal for commercial credibility and enterprise-readiness
+  (e.g. Clutch.co or the niche's equivalent).
+- **Open / public work** — process repos, published samples, open creative
+  output: depth and craft-transparency evidence.
+- **Conference talks / podcasts / newsletters** — thought-leadership depth and
+  POV ownership.
+
+Always **verify claims across at least two sources** before treating a competitor
+attribute as fact (self-reported site copy ≠ verified outcome). Carry an
+adversarial-verification discipline into every profile.
+
+## Scoring matrix template (selection stage)
+
+A lightweight pre-filter to decide who graduates into full benchmarking. Score
+1–5; keep candidates that score high on **either** distinctiveness **or**
+credibility — the client's strategic tension means both poles are instructive.
+
+| Candidate | Positioning stance | Specialization | Size band | Tier | Offer overlap (1–5) | Distinctiveness (1–5) | Commercial credibility (1–5) | Craft proximity (1–5) | Include? |
+|-----------|--------------------|----------------|-----------|------|---------------------|------------------------|------------------------------|------------------------|----------|
+
+Rules of thumb (apply per the client's scoping consequence in the positioning brief):
+
+- High distinctiveness **and** high credibility → must-profile (proves the
+  client's target tension is achievable).
+- High distinctiveness, low credibility → cautionary case (memorable but
+  un-hireable — a potential failure mode to learn from).
+- High credibility, low distinctiveness → "competent but forgettable" mass the
+  client defines itself against.
+- Low on both → drop unless needed for landscape breadth.
+
+## Output of this stage
+
+A scoped, tiered competitor set (typically 10–18 candidates → 8–12 profiled),
+each tagged with its axis positions, tier, and source links, ready to hand to
+`benchmark-methodology`.
+
+## Anti-Patterns
+
+- **Scoping without a positioning brief.** A competitor list built without the client's lens is noise. The brief determines what counts as a real rival.
+- **Listing every similar company.** The goal is a defensible 10–18 candidate set, not a census. Breadth without pruning makes benchmarking unmanageable.
+- **Blurring the Direct/Adjacent/Aspirational tiers.** These tiers serve different strategic purposes. Mixing them produces a flat list that can't drive decisions.
+- **Relying on a single source per competitor.** Self-reported site copy is marketing, not fact. Verify attributes across at least two sources.
+- **Jumping straight to scoring.** This skill scopes and tiers the set. Benchmark-methodology handles scoring. Don't conflate the two steps.
+
+## Examples
+
+**Scenario:** A boutique brand-identity studio (2-person, EU-remote, productized
+sprints, contrarian/manifesto-driven aesthetic) wants to scope its competitive
+set before benchmarking. The strategic tension from the positioning brief is
+*memorability × hireability*.
+
+**Step 1 — eight-axis population (sample candidates):**
+
+| Candidate | Positioning stance | Specialization | Size band | Engagement | Distinctiveness | Evidence model | Brand strength | Market |
+|---|---|---|---|---|---|---|---|---|
+| Studio A | brand-led / editorial | identity only | micro | productized | contrarian | aesthetic-led | cult | global-remote |
+| Studio B | capability-led | broad DS+motion | boutique | bespoke | conventional | outcome-led | interchangeable | US |
+| Agency C | capability-led | brand+digital | mid-size | retainer | conventional | outcome-led | interchangeable | EU |
+| Freelancer D | brand-led | brand voice only | solo | day-rate | editorial | aesthetic-led | ownable | global |
+| Studio E | brand-led | brand strategy | micro | productized | manifesto-driven | outcome-led | cult | EU-remote |
+
+**Step 2 — pre-filter scoring (client scoping consequence: weight distinctiveness
+because the client's moat is POV-first, not capability breadth):**
+
+| Candidate | Offer overlap (1–5) | Distinctiveness (1–5) | Commercial credibility (1–5) | Craft proximity (1–5) | Tier | Include? |
+|---|---|---|---|---|---|---|
+| Studio A | 5 | 5 | 3 | 5 | Direct | ✓ must-profile |
+| Studio B | 3 | 2 | 5 | 3 | Adjacent | ✓ credibility anchor |
+| Agency C | 2 | 1 | 5 | 2 | Aspirational | ✓ scale reference |
+| Freelancer D | 4 | 4 | 2 | 4 | Direct | ✓ cautionary case |
+| Studio E | 5 | 5 | 4 | 4 | Direct | ✓ must-profile |
+
+**Step 3 — output handed to `benchmark-methodology`:**
+Five candidates (3 Direct, 1 Adjacent, 1 Aspirational), each tagged with
+axis positions, tier, and source links. Studio A and Studio E are the
+sharpest head-to-head rivals; Freelancer D is the "memorable but
+un-hireable" cautionary case to learn from.
+
+## Related Skills
+
+- `brand-discovery` — use first to establish the positioning brief and strategic tension that scopes the competitor set.
+- `benchmark-methodology` — the next step; takes the tiered set and scores each competitor across nine dimensions.

package/bundled/upstream/ecc/skills/competitive-report-structure/SKILL.md

@@ -0,0 +1,162 @@
+---
+name: competitive-report-structure
+description: >-
+  Use after benchmark-methodology has produced scored competitor profile cards.
+  Assembles findings into a decision-grade report: landscape map, competitor
+  profiles, benchmarking matrix, white-space analysis, strategic recommendations,
+  and team alignment trigger questions. Final step in the three-skill competitive
+  pipeline.
+---
+
+# Competitive Report Structure
+
+Use this skill to assemble scored competitor cards into a decision-grade report.
+The report must answer three questions for the client: **who do we compete with,
+how do we compete, and where is our defensible white-space?** Every section
+earns its place by moving toward those answers — cut anything that doesn't.
+
+## When to Activate
+
+- All competitor profile cards from benchmark-methodology are complete and ready to assemble.
+- Need to present competitive findings to a founder, leadership team, or board.
+- The report must drive decisions (who to compete with, how, where the moat is) — not just document the landscape.
+- Preparing a client deliverable that must be auditable and defensible.
+
+## Client positioning brief (establish first)
+
+Before assembling the report, establish the client's positioning brief. It
+supplies:
+
+- **Strategic tension** — the paired axes (e.g., memorability × hireability)
+  that define the client's target white-space. All maps and synthesis resolve
+  back to this tension.
+- **Brand balance** — the intended proportional mix of the client's strategic
+  emphases (e.g., 60% strategy/evidence, 25% distinctiveness, 15% craft).
+  Every recommendation must be checked against this balance; flag any that
+  would shift it.
+- **Differentiator** — the framing principle for the executive summary and
+  white-space section.
+- **Target quadrant** — where the client intends to sit in the tension map;
+  confirming whether that quadrant is genuinely open is the report's central
+  empirical question.
+
+## Framing principle
+
+The whole report is organized around the client's strategic tension and
+recommendations resolve back to the client's deliberate brand balance.
+Recommendations that would break that balance must be flagged against it
+explicitly — "this move shifts the balance from X/Y/Z toward A/B/C; confirm
+intent."
+
+## Report sections
+
+### 1. Executive summary
+3–5 takeaways, decision-first. State the most important findings in plain
+language: where the client is strong, where it's exposed, who occupies its
+target white-space, and the top 2–3 moves. Written so a founder/PM reads only
+this and knows what to do. No methodology here.
+
+### 2. Market landscape & category framing
+Define the category and map it. Use a **multi-axis map** — at minimum a 2×2
+(e.g., *brand-led <-> capability-led* × *boutique <-> enterprise-scale*), and
+ideally the **client's tension plot** from `benchmark-methodology` as the
+headline map. Place every profiled competitor and the client. The map should
+make the client's intended position visually obvious and show how crowded (or
+empty) it is.
+
+### 3. Competitor tiers
+Organize the set into **Direct / Adjacent / Aspirational** (from
+`competitive-platform-analysis`). One short paragraph per tier explaining who's
+in it and why it matters to the client. This sets reader expectations before
+the detail.
+
+### 4. Benchmarking matrix
+The full **competitors × dimensions** table — the quantitative spine. Rows =
+competitors (grouped by tier), columns = the nine benchmark dimensions (note:
+dimension 9 — strategic tension — has two poles (e.g., Memorability and
+Hireability for a brand-studio client; substitute the client's own paired axes);
+represent them as two separate sub-columns rather than averaging them). Include
+the client's own honest self-assessment as a row for contrast. Use a **heatmap**
+(color or symbol scale) so strength/weakness patterns are scannable. Do **not**
+add a blended total column — report dimensions separately (per the bias
+controls). Call out the columns where the client leads and where it trails.
+
+### 5. Deep dives
+3–5 most instructive competitors in narrative form (from their profile cards).
+Choose for instruction, not ranking: the best exemplar of the target tension
+(high on both poles), the cautionary "one pole only" case, the "competent but
+forgettable" archetype the client defines against, plus any direct threat. Each
+deep dive: what they do, what the client should learn, what the client should
+avoid.
+
+### 6. White-space & threats
+The strategic heart. Two parts:
+
+- **White-space:** the position the client can own that rivals don't — argued
+  from the maps and matrix, not asserted. Confirm whether the target quadrant
+  (from the positioning brief) is genuinely open.
+- **Threats:** who/what pressures the client — a rival closing the gap,
+  substitutes (no-code/AI tools, in-house teams, generalist freelancers), or
+  category shifts. Be honest about the client's own risks (e.g., a bold identity
+  reading as un-serious to risk-averse buyers).
+
+### 7. Strategic recommendations
+Concrete, prioritized moves: who the client competes with, how it differentiates,
+and where to invest (offer packaging, evidence/case studies, thought leadership,
+brand sharpening). **Tie every recommendation back to the brand balance from the
+positioning brief** and flag any that would shift it. Sequence by impact ×
+effort.
+
+### 8. Sources / methodology appendix
+The dimensions, weights, rubrics, the scoped set with tiers, source links per
+competitor, and verification notes (asserted vs proven). This is what makes the
+report auditable and defensible — carry the adversarial citation discipline
+through.
+
+## How to present data
+
+- **2×2 / positioning maps** — for landscape and the tension plot. Lead with
+  these; they carry the argument faster than prose.
+- **Heatmap matrix** — for the competitors × dimensions comparison (section 4).
+- **Profile cards** — the source unit feeding deep dives (section 5).
+- **Quadrant callouts** — name who sits in each quadrant explicitly, especially
+  the client's target one.
+- Keep tables scannable; push raw evidence and links to the appendix.
+
+## Decision framework (the report must resolve these)
+
+- **Who do we compete with?** — Name the Direct tier specifically; that's the
+  real fight.
+- **How do we compete?** — State the client's differentiator in one sentence,
+  grounded in the matrix (which dimensions the client owns).
+- **Where are our differentiators defensible?** — Identify the
+  dimensions/quadrant rivals can't easily copy (the moat), vs. the ones that
+  are table-stakes.
+
+## Trigger questions for the team alignment session
+
+End with questions that force decisions, not admiration of the analysis:
+
+- Is the target quadrant truly open, or is a rival already moving in?
+- Which Direct competitor is the sharpest threat in the next 12 months, and
+  what's the counter?
+- Does the brand balance still hold given the landscape — should any emphasis
+  shift?
+- Which dimension where the client trails is worth closing, and which to
+  deliberately concede?
+- What's the one move that most widens distinctiveness *without* costing
+  hireability / credibility?
+
+## Anti-Patterns
+
+- **Leading with methodology.** The executive summary opens with the most important finding, not an explanation of how the benchmark was run. Methodology belongs in the appendix.
+- **Presenting scores without the tension plot.** The 2×2 tension map is the headline artefact. A table of numbers without the map buries the strategic insight.
+- **Omitting the decision framework.** The report must resolve the three questions (who to compete with, how, where the moat is). Leaving these unanswered turns the report into a literature review.
+- **Starting before all profile cards are complete.** Benchmark-methodology must finish before assembly begins. Partial data produces gaps that undermine the heatmap and white-space analysis.
+- **Adding a blended total column to the matrix.** Explicitly excluded — it creates a false composite that obscures the asymmetry the client needs to act on.
+
+## Related Skills
+
+- `benchmark-methodology` — the prerequisite; produces the scored competitor profile cards this skill assembles.
+- `competitive-platform-analysis` — provides the tier structure (Direct / Adjacent / Aspirational) used in Section 3.
+- `brand-discovery` — use to establish the client's positioning brief if it hasn't been defined.

package/bundled/upstream/ecc/skills/compose-multiplatform-patterns/SKILL.md

@@ -1,7 +1,8 @@
 ---
 name: compose-multiplatform-patterns
 description: Compose Multiplatform and Jetpack Compose patterns for KMP projects — state management, navigation, theming, performance, and platform-specific UI.
-origin: ECC
+metadata:
+  origin: ECC
 ---
 
 # Compose Multiplatform Patterns

package/bundled/upstream/ecc/skills/config-gc/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: config-gc
+description: Garbage collection for your Claude Code configuration. Periodically scans ~/.claude (skills, memory, hooks, permissions, MCP servers, caches) for redundant, stale, orphaned, or low-value items, then walks the user through a confirm-each-deletion cleanup. Use when the user says "clean up my config", "config GC", "too many skills", "audit my setup", "my .claude is bloated", or asks for a periodic config review.
+metadata:
+  origin: ECC
+---
+
+# Config GC — Garbage Collection for Claude Code Setups
+
+Borrowed from runtime garbage collection: periodically scan for objects that are no longer referenced, redundant, expired, or low-value, and reclaim the space. The critical difference: **here, collection requires a human in the loop. Never delete autonomously.**
+
+## When to Activate
+
+- The user asks to clean up, audit, or slim down their Claude Code configuration
+- The user complains about too many skills, noisy hooks, or slow session startup
+- A monthly/periodic config review is due
+- After installing a large skill pack (e.g. this repo), to reconcile overlaps with existing setup
+
+Do NOT activate for: cleaning project source code (that's refactoring), clearing chat history, or uninstalling Claude Code itself.
+
+## Design Philosophy
+
+1. **Append-only configs leak.** Skills, memory files, hooks, and permission entries only ever get added. Without periodic review they rot silently.
+2. **Regular audits beat one-time purges.** Scan every ~30 days, propose a small batch of candidates each time.
+3. **Per-channel strategies.** Each accumulation type (skills, hooks, permissions, ...) has its own staleness signals — don't apply one rule everywhere.
+4. **Soft-delete first.** Rename to `.disabled` > move to `~/.claude/_gc_trash/` > real deletion. Always keep an undo path.
+5. **Forced human-in-the-loop.** Every candidate gets its own `[y/n/skip]` confirmation. No "yes to all" shortcut.
+6. **Keep a log.** Every GC run appends to `~/.claude/gc_log.md`: what was touched, why, and how to undo it.
+
+## Scan Channels
+
+| # | Channel | Path | Staleness / redundancy signals |
+|---|---------|------|--------------------------------|
+| 1 | Skills | `~/.claude/skills/*/` | Heavily overlapping names; never triggered in recent transcripts; domain mismatch with the user's actual work; broken or empty SKILL.md |
+| 2 | Memory | `~/.claude/**/memory/*.md` + its index | Multiple index entries for one topic; contents contradicting newer entries; dates that have passed; orphan files missing from the index; sub-100-word fragments that should merge |
+| 3 | Hooks | `~/.claude/hooks/` + settings | Scripts present on disk but referenced by no hook config; old versions superseded by rewrites |
+| 4 | Permissions | `permissions.allow` in `settings.json` / `settings.local.json` | Duplicate entries; specific entries already covered by a wildcard (e.g. `Bash(git push)` when `Bash(*)` is allowed); one-off grants from past experiments |
+| 5 | MCP servers | `~/.claude.json` or project `.mcp.json` | Servers that fail to connect; functional duplicates; long-unused |
+| 6 | Scheduled reminders / jobs | wherever the user keeps them | Fired one-shots older than 30 days; jobs whose target scripts no longer exist |
+| 7 | Project history | `~/.claude/projects/*/` | Stale handoff snapshots; session records superseded by newer state |
+| 8 | Runtime caches | `cache/`, `file-history/`, `logs/`, `shell-snapshots/` | Sort by size and mtime; propose items >30 days old and large |
+
+## Workflow
+
+1. **Scan** all channels (or the subset the user names). Collect candidates with: path, channel, signal that flagged it, size, last-modified.
+2. **Rank** by confidence (broken/orphaned = high; merely old = low) and present as a numbered table. Cap each run at ~20 candidates — GC is periodic, not exhaustive.
+3. **Confirm one by one.** For each candidate show the evidence, then ask `[y/n/skip]`. The user can stop at any point.
+4. **Soft-delete confirmed items**: prefer `.disabled` rename for skills/hooks and `_gc_trash/<date>/` move for files. Permission entries live in JSON (no comments possible): back up the settings file, record each removed entry verbatim in `gc_log.md`, then remove it from the `allow` array with `jq`. Only hard-delete when the user explicitly asks.
+5. **Log** the run to `~/.claude/gc_log.md`: timestamp, items actioned, undo instructions.
+6. **Report**: reclaimed size, channels still healthy, suggested next review date.
+
+## Example Scan Commands
+
+Orphaned hook scripts (channel 3) — scripts on disk that no hook config references:
+
+```bash
+for f in ~/.claude/hooks/*; do
+  name=$(basename "$f")
+  grep -rq "$name" ~/.claude/settings.json ~/.claude/settings.local.json 2>/dev/null \
+    || echo "ORPHAN: $f"
+done
+```
+
+Redundant permission entries (channel 4) — duplicates, and specific grants shadowed by a wildcard:
+
+```bash
+jq -r '.permissions.allow[]' ~/.claude/settings.local.json | sort | uniq -d
+if jq -e '.permissions.allow | index("Bash(*)")' ~/.claude/settings.local.json >/dev/null; then
+  jq -r '.permissions.allow[]' ~/.claude/settings.local.json \
+    | grep '^Bash(' | grep -vF 'Bash(*)'
+fi
+```
+
+Largest stale caches (channel 8) — `du -k` instead of GNU-only `find -printf`, so it works on macOS/BSD too:
+
+```bash
+find ~/.claude/file-history ~/.claude/shell-snapshots -type f -mtime +30 \
+  -exec du -k {} + 2>/dev/null | sort -rn | head -20
+```
+
+Soft-delete with undo path (capture the date once so the log can't disagree with the directory):
+
+```bash
+gc_date=$(date +%Y-%m-%d)
+mkdir -p ~/.claude/_gc_trash/$gc_date
+mv ~/.claude/skills/dead-skill ~/.claude/_gc_trash/$gc_date/
+echo "$(date -Iseconds) moved skills/dead-skill -> _gc_trash/$gc_date/ (undo: mv back)" >> ~/.claude/gc_log.md
+```
+
+Removing a confirmed-redundant permission entry (JSON has no comments — back up, log, then edit):
+
+```bash
+cp ~/.claude/settings.local.json ~/.claude/settings.local.json.bak
+echo "$(date -Iseconds) removed permission entry: Bash(git push) (undo: restore from .bak or re-add)" >> ~/.claude/gc_log.md
+jq '.permissions.allow -= ["Bash(git push)"]' ~/.claude/settings.local.json.bak \
+  > ~/.claude/settings.local.json
+```
+
+## Anti-Patterns
+
+- **Bulk approval.** Asking "delete all 15? [y/n]" defeats the design. One item, one decision.
+- **Hard-deleting on first pass.** If there's no `_gc_trash/` copy or `.disabled` rename, you did it wrong.
+- **Treating "old" as "dead".** A skill untouched for 60 days may be seasonal (tax season, quarterly reviews). Age is a signal, not a verdict — that's why a human confirms.
+- **Cleaning memory by truncation.** Merging two contradicting memory files requires reading both and keeping the newer truth, not deleting the longer one.
+- **Touching anything outside `~/.claude`** (or the project's `.claude/`). Config GC never wanders into source trees.
+
+## Best Practices
+
+- Run after big additions, not just on a calendar: installing a 50-skill pack is exactly when overlap with existing skills appears.
+- When two skills overlap, prefer disabling the one with the weaker trigger description — it's the one that was probably never firing anyway.
+- Permission cleanup is the highest-value channel per minute spent: redundant allow-entries make security review harder.
+- Keep `gc_log.md` forever. It's tiny, and "when did I disable that hook and why" comes up more often than you'd think.
+
+## Related Skills
+
+- `skill-stocktake` — audits skill *quality*; config-gc audits skill *existence*. Run stocktake on what survives GC.
+- `workspace-surface-audit` — the additive counterpart: recommends what to install. config-gc is the subtractive half of the same lifecycle.
+- `configure-ecc` — after installing skills with it, run config-gc to reconcile overlaps with your pre-existing setup.
+- `continuous-learning` — produces the memory files this skill later audits.
+- `security-review` — pairs well with the permissions channel.

package/bundled/upstream/ecc/skills/configure-ecc/SKILL.md

@@ -1,7 +1,8 @@
 ---
 name: configure-ecc
 description: Interactive installer for Everything Claude Code — guides users through selecting and installing skills and rules to user-level or project-level directories, verifies paths, and optionally optimizes installed files.
-origin: ECC
+metadata:
+  origin: ECC
 ---
 
 # Configure Everything Claude Code (ECC)

package/bundled/upstream/ecc/skills/connections-optimizer/SKILL.md

@@ -1,7 +1,8 @@
 ---
 name: connections-optimizer
 description: Reorganize the user's X and LinkedIn network with review-first pruning, add/follow recommendations, and channel-specific warm outreach drafted in the user's real voice. Use when the user wants to clean up following lists, grow toward current priorities, or rebalance a social graph around higher-signal relationships.
-origin: ECC
+metadata:
+  origin: ECC
 ---
 
 # Connections Optimizer

package/bundled/upstream/ecc/skills/content-engine/SKILL.md

@@ -1,7 +1,8 @@
 ---
 name: content-engine
 description: Create platform-native content systems for X, LinkedIn, TikTok, YouTube, newsletters, and repurposed multi-platform campaigns. Use when the user wants social posts, threads, scripts, content calendars, or one source asset adapted cleanly across platforms.
-origin: ECC
+metadata:
+  origin: ECC
 ---
 
 # Content Engine

package/bundled/upstream/ecc/skills/content-hash-cache-pattern/SKILL.md

@@ -1,7 +1,8 @@
 ---
 name: content-hash-cache-pattern
 description: Cache expensive file processing results using SHA-256 content hashes — path-independent, auto-invalidating, with service layer separation.
-origin: ECC
+metadata:
+  origin: ECC
 ---
 
 # Content-Hash File Cache Pattern

package/bundled/upstream/ecc/skills/context-budget/SKILL.md

@@ -1,7 +1,8 @@
 ---
 name: context-budget
 description: Audits Claude Code context window consumption across agents, skills, MCP servers, and rules. Identifies bloat, redundant components, and produces prioritized token-savings recommendations.
-origin: ECC
+metadata:
+  origin: ECC
 ---
 
 # Context Budget

package/bundled/upstream/ecc/skills/continuous-agent-loop/SKILL.md

@@ -1,7 +1,8 @@
 ---
 name: continuous-agent-loop
 description: Patterns for continuous autonomous agent loops with quality gates, evals, and recovery controls.
-origin: ECC
+metadata:
+  origin: ECC
 ---
 
 # Continuous Agent Loop

package/bundled/upstream/ecc/skills/continuous-learning/SKILL.md

@@ -1,7 +1,8 @@
 ---
 name: continuous-learning
 description: "[DEPRECATED - use continuous-learning-v2] Legacy v1 stop-hook skill extractor. v2 is a strict superset with instinct-based, project-scoped, hook-reliable learning. Do not invoke v1; route continuous learning, session learning, and pattern extraction requests to continuous-learning-v2."
-origin: ECC
+metadata:
+  origin: ECC
 ---
 
 # Continuous Learning Skill - DEPRECATED

package/bundled/upstream/ecc/skills/continuous-learning-v2/SKILL.md

@@ -1,7 +1,8 @@
 ---
 name: continuous-learning-v2
 description: Instinct-based learning system that observes sessions via hooks, creates atomic instincts with confidence scoring, and evolves them into skills/commands/agents. v2.1 adds project-scoped instincts to prevent cross-project contamination.
-origin: ECC
+metadata:
+  origin: ECC
 version: 2.1.0
 ---
 

package/bundled/upstream/ecc/skills/continuous-learning-v2/agents/observer-loop.sh

@@ -205,9 +205,22 @@ PROMPT
   fi
 
   timeout_seconds="${ECC_OBSERVER_TIMEOUT_SECONDS:-120}"
-  max_turns="${ECC_OBSERVER_MAX_TURNS:-20}"
+  # Auto-scale max_turns proportional to analysis batch size when not explicitly set.
+  # The old hardcoded default of 20 is insufficient for the 500-line MAX_ANALYSIS_LINES
+  # default: Claude hits --max-turns before it can write all discovered instinct files.
+  # Formula: 1 turn per 10 analysis lines, floor 20, cap 100. (#2035)
+  if [ -n "${ECC_OBSERVER_MAX_TURNS:-}" ]; then
+    max_turns="${ECC_OBSERVER_MAX_TURNS}"
+  else
+    max_turns=$(( analysis_count / 10 ))
+    if [ "$max_turns" -lt 20 ]; then max_turns=20; fi
+    if [ "$max_turns" -gt 100 ]; then max_turns=100; fi
+  fi
   exit_code=0
 
+  # Sanitize max_turns. The auto-scaled path above always yields a valid value >=20,
+  # but an explicit ECC_OBSERVER_MAX_TURNS override may be non-numeric, empty, or too
+  # small, so guard here and fall back to the safe default of 20.
   case "$max_turns" in
     ''|*[!0-9]*)
       max_turns=20