arboris-cli 1.0.0 → 1.1.1

package/prisma/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/prisma/skills/configure-ecc/SKILL.md

@@ -0,0 +1,385 @@
+---
+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.
+metadata:
+  origin: ECC
+---
+
+# Configure Everything Claude Code (ECC)
+
+An interactive, step-by-step installation wizard for the Everything Claude Code project. Uses `AskUserQuestion` to guide users through selective installation of skills and rules, then verifies correctness and offers optimization.
+
+## When to Activate
+
+- User says "configure ecc", "install ecc", "setup everything claude code", or similar
+- User wants to selectively install skills or rules from this project
+- User wants to verify or fix an existing ECC installation
+- User wants to optimize installed skills or rules for their project
+
+## Prerequisites
+
+This skill must be accessible to Claude Code before activation. Two ways to bootstrap:
+1. **Via Plugin**: `/plugin install ecc@ecc` — the plugin loads this skill automatically
+2. **Manual**: Copy only this skill to `~/.claude/skills/configure-ecc/SKILL.md`, then activate by saying "configure ecc"
+
+---
+
+## Step 0: Clone ECC Repository
+
+Before any installation, clone the latest ECC source to `/tmp`:
+
+```bash
+rm -rf /tmp/everything-claude-code
+git clone https://github.com/affaan-m/everything-claude-code.git /tmp/everything-claude-code
+```
+
+Set `ECC_ROOT=/tmp/everything-claude-code` as the source for all subsequent copy operations.
+
+If the clone fails (network issues, etc.), use `AskUserQuestion` to ask the user to provide a local path to an existing ECC clone.
+
+---
+
+## Step 1: Choose Installation Level
+
+Use `AskUserQuestion` to ask the user where to install:
+
+```
+Question: "Where should ECC components be installed?"
+Options:
+  - "User-level (~/.claude/)" — "Applies to all your Claude Code projects"
+  - "Project-level (.claude/)" — "Applies only to the current project"
+  - "Both" — "Common/shared items user-level, project-specific items project-level"
+```
+
+Store the choice as `INSTALL_LEVEL`. Set the target directory:
+- User-level: `TARGET=~/.claude`
+- Project-level: `TARGET=.claude` (relative to current project root)
+- Both: `TARGET_USER=~/.claude`, `TARGET_PROJECT=.claude`
+
+Create the target directories if they don't exist:
+```bash
+mkdir -p $TARGET/skills $TARGET/rules
+```
+
+---
+
+## Step 2: Select & Install Skills
+
+### 2a: Choose Scope (Core vs Niche)
+
+Default to **Core (recommended for new users)** — copy `.agents/skills/*` plus `skills/search-first/` for research-first workflows. This bundle covers engineering, evals, verification, security, strategic compaction, frontend design, and Anthropic cross-functional skills (article-writing, content-engine, market-research, frontend-slides).
+
+Use `AskUserQuestion` (single select):
+```
+Question: "Install core skills only, or include niche/framework packs?"
+Options:
+  - "Core only (recommended)" — "tdd, e2e, evals, verification, research-first, security, frontend patterns, compacting, cross-functional Anthropic skills"
+  - "Core + selected niche" — "Add framework/domain-specific skills after core"
+  - "Niche only" — "Skip core, install specific framework/domain skills"
+Default: Core only
+```
+
+If the user chooses niche or core + niche, continue to category selection below and only include those niche skills they pick.
+
+### 2b: Choose Skill Categories
+
+There are 7 selectable category groups below. The detailed confirmation lists that follow cover 45 skills across 8 categories, plus 1 standalone template. Use `AskUserQuestion` with `multiSelect: true`:
+
+```
+Question: "Which skill categories do you want to install?"
+Options:
+  - "Framework & Language" — "Django, Laravel, Spring Boot, Quarkus, Go, Python, Java, Frontend, Backend patterns"
+  - "Database" — "PostgreSQL, ClickHouse, JPA/Hibernate patterns"
+  - "Workflow & Quality" — "TDD, verification, learning, security review, compaction"
+  - "Research & APIs" — "Deep research, Exa search, Claude API patterns"
+  - "Social & Content Distribution" — "X/Twitter API, crossposting alongside content-engine"
+  - "Media Generation" — "fal.ai image/video/audio alongside VideoDB"
+  - "Orchestration" — "dmux multi-agent workflows"
+  - "All skills" — "Install every available skill"
+```
+
+### 2c: Confirm Individual Skills
+
+For each selected category, print the full list of skills below and ask the user to confirm or deselect specific ones. If the list exceeds 4 items, print the list as text and use `AskUserQuestion` with an "Install all listed" option plus "Other" for the user to paste specific names.
+
+**Category: Framework & Language (25 skills)**
+
+| Skill | Description |
+|-------|-------------|
+| `backend-patterns` | Backend architecture, API design, server-side best practices for Node.js/Express/Next.js |
+| `coding-standards` | Universal coding standards for TypeScript, JavaScript, React, Node.js |
+| `django-patterns` | Django architecture, REST API with DRF, ORM, caching, signals, middleware |
+| `django-security` | Django security: auth, CSRF, SQL injection, XSS prevention |
+| `django-tdd` | Django testing with pytest-django, factory_boy, mocking, coverage |
+| `django-verification` | Django verification loop: migrations, linting, tests, security scans |
+| `laravel-patterns` | Laravel architecture patterns: routing, controllers, Eloquent, queues, caching |
+| `laravel-security` | Laravel security: auth, policies, CSRF, mass assignment, rate limiting |
+| `laravel-tdd` | Laravel testing with PHPUnit and Pest, factories, fakes, coverage |
+| `laravel-verification` | Laravel verification: linting, static analysis, tests, security scans |
+| `frontend-patterns` | React, Next.js, state management, performance, UI patterns |
+| `frontend-slides` | Zero-dependency HTML presentations, style previews, and PPTX-to-web conversion |
+| `golang-patterns` | Idiomatic Go patterns, conventions for robust Go applications |
+| `golang-testing` | Go testing: table-driven tests, subtests, benchmarks, fuzzing |
+| `java-coding-standards` | Java coding standards for Spring Boot and Quarkus: naming, immutability, Optional, streams, CDI |
+| `python-patterns` | Pythonic idioms, PEP 8, type hints, best practices |
+| `python-testing` | Python testing with pytest, TDD, fixtures, mocking, parametrization |
+| `quarkus-patterns` | Quarkus architecture, Camel messaging, CDI services, Panache data access |
+| `quarkus-security` | Quarkus security: JWT/OIDC, RBAC, input validation, secrets management |
+| `quarkus-tdd` | Quarkus TDD with JUnit 5, Mockito, REST Assured, Camel testing |
+| `quarkus-verification` | Quarkus verification: build, static analysis, tests, native compilation |
+| `springboot-patterns` | Spring Boot architecture, REST API, layered services, caching, async |
+| `springboot-security` | Spring Security: authn/authz, validation, CSRF, secrets, rate limiting |
+| `springboot-tdd` | Spring Boot TDD with JUnit 5, Mockito, MockMvc, Testcontainers |
+| `springboot-verification` | Spring Boot verification: build, static analysis, tests, security scans |
+
+**Category: Database (3 skills)**
+
+| Skill | Description |
+|-------|-------------|
+| `clickhouse-io` | ClickHouse patterns, query optimization, analytics, data engineering |
+| `jpa-patterns` | JPA/Hibernate entity design, relationships, query optimization, transactions |
+| `postgres-patterns` | PostgreSQL query optimization, schema design, indexing, security |
+
+**Category: Workflow & Quality (8 skills)**
+
+| Skill | Description |
+|-------|-------------|
+| `continuous-learning` | Legacy v1 Stop-hook session pattern extraction; prefer `continuous-learning-v2` for new installs |
+| `continuous-learning-v2` | Instinct-based learning with confidence scoring, evolves into skills, agents, and optional legacy command shims |
+| `eval-harness` | Formal evaluation framework for eval-driven development (EDD) |
+| `iterative-retrieval` | Progressive context refinement for subagent context problem |
+| `security-review` | Security checklist: auth, input, secrets, API, payment features |
+| `strategic-compact` | Suggests manual context compaction at logical intervals |
+| `tdd-workflow` | Enforces TDD with 80%+ coverage: unit, integration, E2E |
+| `verification-loop` | Verification and quality loop patterns |
+
+**Category: Business & Content (5 skills)**
+
+| Skill | Description |
+|-------|-------------|
+| `article-writing` | Long-form writing in a supplied voice using notes, examples, or source docs |
+| `content-engine` | Multi-platform social content, scripts, and repurposing workflows |
+| `market-research` | Source-attributed market, competitor, fund, and technology research |
+| `investor-materials` | Pitch decks, one-pagers, investor memos, and financial models |
+| `investor-outreach` | Personalized investor cold emails, warm intros, and follow-ups |
+
+**Category: Research & APIs (2 skills)**
+
+| Skill | Description |
+|-------|-------------|
+| `deep-research` | Multi-source deep research using firecrawl and exa MCPs with cited reports |
+| `exa-search` | Neural search via Exa MCP for web, code, company, and people research |
+
+`claude-api` is an Anthropic canonical skill. Install it from [`anthropics/skills`](https://github.com/anthropics/skills) when you want the official Claude API workflow instead of an ECC-bundled copy.
+
+**Category: Social & Content Distribution (2 skills)**
+
+| Skill | Description |
+|-------|-------------|
+| `x-api` | X/Twitter API integration for posting, threads, search, and analytics |
+| `crosspost` | Multi-platform content distribution with platform-native adaptation |
+
+**Category: Media Generation (2 skills)**
+
+| Skill | Description |
+|-------|-------------|
+| `fal-ai-media` | Unified AI media generation (image, video, audio) via fal.ai MCP |
+| `video-editing` | AI-assisted video editing for cutting, structuring, and augmenting real footage |
+
+**Category: Orchestration (1 skill)**
+
+| Skill | Description |
+|-------|-------------|
+| `dmux-workflows` | Multi-agent orchestration using dmux for parallel agent sessions |
+
+**Standalone**
+
+| Skill | Description |
+|-------|-------------|
+| `docs/examples/project-guidelines-template.md` | Template for creating project-specific skills |
+
+### 2d: Execute Installation
+
+For each selected skill, copy the entire skill directory from the correct source root:
+
+```bash
+# Core skills live under .agents/skills/
+cp -R "$ECC_ROOT/.agents/skills/<skill-name>" "$TARGET/skills/"
+
+# Niche skills live under skills/
+cp -R "$ECC_ROOT/skills/<skill-name>" "$TARGET/skills/"
+```
+
+When iterating over globbed source directories, never pass a trailing-slash source directly to `cp`. Use the directory path as the destination name explicitly:
+
+```bash
+cp -R "${src%/}" "$TARGET/skills/$(basename "${src%/}")"
+```
+
+Note: `continuous-learning` and `continuous-learning-v2` have extra files (config.json, hooks, scripts) — ensure the entire directory is copied, not just SKILL.md.
+
+---
+
+## Step 3: Select & Install Rules
+
+Use `AskUserQuestion` with `multiSelect: true`:
+
+```
+Question: "Which rule sets do you want to install?"
+Options:
+  - "Common rules (Recommended)" — "Language-agnostic principles: coding style, git workflow, testing, security, etc. (8 files)"
+  - "TypeScript/JavaScript" — "TS/JS patterns, hooks, testing with Playwright (5 files)"
+  - "Python" — "Python patterns, pytest, black/ruff formatting (5 files)"
+  - "Go" — "Go patterns, table-driven tests, gofmt/staticcheck (5 files)"
+```
+
+Execute installation:
+```bash
+# Common rules
+cp -r $ECC_ROOT/rules/common $TARGET/rules/common
+
+# Language-specific rules (preserve per-language directories)
+cp -r $ECC_ROOT/rules/typescript $TARGET/rules/typescript   # if selected
+cp -r $ECC_ROOT/rules/python $TARGET/rules/python            # if selected
+cp -r $ECC_ROOT/rules/golang $TARGET/rules/golang            # if selected
+```
+
+**Important**: If the user selects any language-specific rules but NOT common rules, warn them:
+> "Language-specific rules extend the common rules. Installing without common rules may result in incomplete coverage. Install common rules too?"
+
+---
+
+## Step 4: Post-Installation Verification
+
+After installation, perform these automated checks:
+
+### 4a: Verify File Existence
+
+List all installed files and confirm they exist at the target location:
+```bash
+ls -la $TARGET/skills/
+ls -la $TARGET/rules/
+```
+
+### 4b: Check Path References
+
+Scan all installed `.md` files for path references:
+```bash
+grep -rn "~/.claude/" $TARGET/skills/ $TARGET/rules/
+grep -rn "../common/" $TARGET/rules/
+grep -rn "skills/" $TARGET/skills/
+```
+
+**For project-level installs**, flag any references to `~/.claude/` paths:
+- If a skill references `~/.claude/settings.json` — this is usually fine (settings are always user-level)
+- If a skill references `~/.claude/skills/` or `~/.claude/rules/` — this may be broken if installed only at project level
+- If a skill references another skill by name — check that the referenced skill was also installed
+
+### 4c: Check Cross-References Between Skills
+
+Some skills reference others. Verify these dependencies:
+- `django-tdd` may reference `django-patterns`
+- `laravel-tdd` may reference `laravel-patterns`
+- `quarkus-tdd` may reference `quarkus-patterns`
+- `springboot-tdd` may reference `springboot-patterns`
+- `continuous-learning-v2` references `~/.claude/homunculus/` directory
+- `python-testing` may reference `python-patterns`
+- `golang-testing` may reference `golang-patterns`
+- `crosspost` references `content-engine` and `x-api`
+- `deep-research` references `exa-search` (complementary MCP tools)
+- `fal-ai-media` references `videodb` (complementary media skill)
+- `x-api` references `content-engine` and `crosspost`
+- Language-specific rules reference `common/` counterparts
+
+### 4d: Report Issues
+
+For each issue found, report:
+1. **File**: The file containing the problematic reference
+2. **Line**: The line number
+3. **Issue**: What's wrong (e.g., "references ~/.claude/skills/python-patterns but python-patterns was not installed")
+4. **Suggested fix**: What to do (e.g., "install python-patterns skill" or "update path to .claude/skills/")
+
+---
+
+## Step 5: Optimize Installed Files (Optional)
+
+Use `AskUserQuestion`:
+
+```
+Question: "Would you like to optimize the installed files for your project?"
+Options:
+  - "Optimize skills" — "Remove irrelevant sections, adjust paths, tailor to your tech stack"
+  - "Optimize rules" — "Adjust coverage targets, add project-specific patterns, customize tool configs"
+  - "Optimize both" — "Full optimization of all installed files"
+  - "Skip" — "Keep everything as-is"
+```
+
+### If optimizing skills:
+1. Read each installed SKILL.md
+2. Ask the user what their project's tech stack is (if not already known)
+3. For each skill, suggest removals of irrelevant sections
+4. Edit the SKILL.md files in-place at the installation target (NOT the source repo)
+5. Fix any path issues found in Step 4
+
+### If optimizing rules:
+1. Read each installed rule .md file
+2. Ask the user about their preferences:
+   - Test coverage target (default 80%)
+   - Preferred formatting tools
+   - Git workflow conventions
+   - Security requirements
+3. Edit the rule files in-place at the installation target
+
+**Critical**: Only modify files in the installation target (`$TARGET/`), NEVER modify files in the source ECC repository (`$ECC_ROOT/`).
+
+---
+
+## Step 6: Installation Summary
+
+Clean up the cloned repository from `/tmp`:
+
+```bash
+rm -rf /tmp/everything-claude-code
+```
+
+Then print a summary report:
+
+```
+## ECC Installation Complete
+
+### Installation Target
+- Level: [user-level / project-level / both]
+- Path: [target path]
+
+### Skills Installed ([count])
+- skill-1, skill-2, skill-3, ...
+
+### Rules Installed ([count])
+- common (8 files)
+- typescript (5 files)
+- ...
+
+### Verification Results
+- [count] issues found, [count] fixed
+- [list any remaining issues]
+
+### Optimizations Applied
+- [list changes made, or "None"]
+```
+
+---
+
+## Troubleshooting
+
+### "Skills not being picked up by Claude Code"
+- Verify the skill directory contains a `SKILL.md` file (not just loose .md files)
+- For user-level: check `~/.claude/skills/<skill-name>/SKILL.md` exists
+- For project-level: check `.claude/skills/<skill-name>/SKILL.md` exists
+
+### "Rules not working"
+- Rules are flat files, not in subdirectories: `$TARGET/rules/coding-style.md` (correct) vs `$TARGET/rules/common/coding-style.md` (incorrect for flat install)
+- Restart Claude Code after installing rules
+
+### "Path reference errors after project-level install"
+- Some skills assume `~/.claude/` paths. Run Step 4 verification to find and fix these.
+- For `continuous-learning-v2`, the `~/.claude/homunculus/` directory is always user-level — this is expected and not an error.