@rubix0270/arboris 1.0.1 → 1.0.3

package/prisma/skills/config-gc/SKILL.md

@@ -1,120 +0,0 @@
----
-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

@@ -1,385 +0,0 @@
----
-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.