npm - @cregis-dev/cckit - Versions diffs - 0.4.0 → 0.5.0 - Mend

@cregis-dev/cckit 0.4.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (798) hide show

package/templates/ecc/skills/configure-ecc/SKILL.md DELETED Viewed

@@ -1,326 +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.
-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 everything-claude-code` — 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 27 skills organized into 4 categories. Use `AskUserQuestion` with `multiSelect: true`:
-```
-Question: "Which skill categories do you want to install?"
-Options:
-  - "Framework & Language" — "Django, Spring Boot, Go, Python, Java, Frontend, Backend patterns"
-  - "Database" — "PostgreSQL, ClickHouse, JPA/Hibernate patterns"
-  - "Workflow & Quality" — "TDD, verification, learning, security review, compaction"
-  - "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 (17 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 |
-| `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: naming, immutability, Optional, streams |
-| `python-patterns` | Pythonic idioms, PEP 8, type hints, best practices |
-| `python-testing` | Python testing with pytest, TDD, fixtures, mocking, parametrization |
-| `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` | Auto-extract reusable patterns from sessions as learned skills |
-| `continuous-learning-v2` | Instinct-based learning with confidence scoring, evolves into skills/commands/agents |
-| `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 |
-**Standalone**
-| Skill | Description |
-|-------|-------------|
-| `project-guidelines-example` | Template for creating project-specific skills |
-### 2d: Execute Installation
-For each selected skill, copy the entire skill directory:
-```bash
-cp -r $ECC_ROOT/skills/<skill-name> $TARGET/skills/
-```
-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 (flat copy into rules/)
-cp -r $ECC_ROOT/rules/common/* $TARGET/rules/
-# Language-specific rules (flat copy into rules/)
-cp -r $ECC_ROOT/rules/typescript/* $TARGET/rules/   # if selected
-cp -r $ECC_ROOT/rules/python/* $TARGET/rules/        # if selected
-cp -r $ECC_ROOT/rules/golang/* $TARGET/rules/        # 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`
-- `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`
-- 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.

package/templates/ecc/skills/content-engine/SKILL.md DELETED Viewed

@@ -1,88 +0,0 @@
----
-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
----
-# Content Engine
-Turn one idea into strong, platform-native content instead of posting the same thing everywhere.
-## When to Activate
-- writing X posts or threads
-- drafting LinkedIn posts or launch updates
-- scripting short-form video or YouTube explainers
-- repurposing articles, podcasts, demos, or docs into social content
-- building a lightweight content plan around a launch, milestone, or theme
-## First Questions
-Clarify:
-- source asset: what are we adapting from
-- audience: builders, investors, customers, operators, or general audience
-- platform: X, LinkedIn, TikTok, YouTube, newsletter, or multi-platform
-- goal: awareness, conversion, recruiting, authority, launch support, or engagement
-## Core Rules
-1. Adapt for the platform. Do not cross-post the same copy.
-2. Hooks matter more than summaries.
-3. Every post should carry one clear idea.
-4. Use specifics over slogans.
-5. Keep the ask small and clear.
-## Platform Guidance
-### X
-- open fast
-- one idea per post or per tweet in a thread
-- keep links out of the main body unless necessary
-- avoid hashtag spam
-### LinkedIn
-- strong first line
-- short paragraphs
-- more explicit framing around lessons, results, and takeaways
-### TikTok / Short Video
-- first 3 seconds must interrupt attention
-- script around visuals, not just narration
-- one demo, one claim, one CTA
-### YouTube
-- show the result early
-- structure by chapter
-- refresh the visual every 20-30 seconds
-### Newsletter
-- deliver one clear lens, not a bundle of unrelated items
-- make section titles skimmable
-- keep the opening paragraph doing real work
-## Repurposing Flow
-Default cascade:
-1. anchor asset: article, video, demo, memo, or launch doc
-2. extract 3-7 atomic ideas
-3. write platform-native variants
-4. trim repetition across outputs
-5. align CTAs with platform intent
-## Deliverables
-When asked for a campaign, return:
-- the core angle
-- platform-specific drafts
-- optional posting order
-- optional CTA variants
-- any missing inputs needed before publishing
-## Quality Gate
-Before delivering:
-- each draft reads natively for its platform
-- hooks are strong and specific
-- no generic hype language
-- no duplicated copy across platforms unless requested
-- the CTA matches the content and audience

package/templates/ecc/skills/content-hash-cache-pattern/SKILL.md DELETED Viewed

@@ -1,161 +0,0 @@
----
-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
----
-# Content-Hash File Cache Pattern
-Cache expensive file processing results (PDF parsing, text extraction, image analysis) using SHA-256 content hashes as cache keys. Unlike path-based caching, this approach survives file moves/renames and auto-invalidates when content changes.
-## When to Activate
-- Building file processing pipelines (PDF, images, text extraction)
-- Processing cost is high and same files are processed repeatedly
-- Need a `--cache/--no-cache` CLI option
-- Want to add caching to existing pure functions without modifying them
-## Core Pattern
-### 1. Content-Hash Based Cache Key
-Use file content (not path) as the cache key:
-```python
-import hashlib
-from pathlib import Path
-_HASH_CHUNK_SIZE = 65536  # 64KB chunks for large files
-def compute_file_hash(path: Path) -> str:
-    """SHA-256 of file contents (chunked for large files)."""
-    if not path.is_file():
-        raise FileNotFoundError(f"File not found: {path}")
-    sha256 = hashlib.sha256()
-    with open(path, "rb") as f:
-        while True:
-            chunk = f.read(_HASH_CHUNK_SIZE)
-            if not chunk:
-                break
-            sha256.update(chunk)
-    return sha256.hexdigest()
-```
-**Why content hash?** File rename/move = cache hit. Content change = automatic invalidation. No index file needed.
-### 2. Frozen Dataclass for Cache Entry
-```python
-from dataclasses import dataclass
-@dataclass(frozen=True, slots=True)
-class CacheEntry:
-    file_hash: str
-    source_path: str
-    document: ExtractedDocument  # The cached result
-```
-### 3. File-Based Cache Storage
-Each cache entry is stored as `{hash}.json` — O(1) lookup by hash, no index file required.
-```python
-import json
-from typing import Any
-def write_cache(cache_dir: Path, entry: CacheEntry) -> None:
-    cache_dir.mkdir(parents=True, exist_ok=True)
-    cache_file = cache_dir / f"{entry.file_hash}.json"
-    data = serialize_entry(entry)
-    cache_file.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
-def read_cache(cache_dir: Path, file_hash: str) -> CacheEntry | None:
-    cache_file = cache_dir / f"{file_hash}.json"
-    if not cache_file.is_file():
-        return None
-    try:
-        raw = cache_file.read_text(encoding="utf-8")
-        data = json.loads(raw)
-        return deserialize_entry(data)
-    except (json.JSONDecodeError, ValueError, KeyError):
-        return None  # Treat corruption as cache miss
-```
-### 4. Service Layer Wrapper (SRP)
-Keep the processing function pure. Add caching as a separate service layer.
-```python
-def extract_with_cache(
-    file_path: Path,
-    *,
-    cache_enabled: bool = True,
-    cache_dir: Path = Path(".cache"),
-) -> ExtractedDocument:
-    """Service layer: cache check -> extraction -> cache write."""
-    if not cache_enabled:
-        return extract_text(file_path)  # Pure function, no cache knowledge
-    file_hash = compute_file_hash(file_path)
-    # Check cache
-    cached = read_cache(cache_dir, file_hash)
-    if cached is not None:
-        logger.info("Cache hit: %s (hash=%s)", file_path.name, file_hash[:12])
-        return cached.document
-    # Cache miss -> extract -> store
-    logger.info("Cache miss: %s (hash=%s)", file_path.name, file_hash[:12])
-    doc = extract_text(file_path)
-    entry = CacheEntry(file_hash=file_hash, source_path=str(file_path), document=doc)
-    write_cache(cache_dir, entry)
-    return doc
-```
-## Key Design Decisions
-| Decision | Rationale |
-|----------|-----------|
-| SHA-256 content hash | Path-independent, auto-invalidates on content change |
-| `{hash}.json` file naming | O(1) lookup, no index file needed |
-| Service layer wrapper | SRP: extraction stays pure, cache is a separate concern |
-| Manual JSON serialization | Full control over frozen dataclass serialization |
-| Corruption returns `None` | Graceful degradation, re-processes on next run |
-| `cache_dir.mkdir(parents=True)` | Lazy directory creation on first write |
-## Best Practices
-- **Hash content, not paths** — paths change, content identity doesn't
-- **Chunk large files** when hashing — avoid loading entire files into memory
-- **Keep processing functions pure** — they should know nothing about caching
-- **Log cache hit/miss** with truncated hashes for debugging
-- **Handle corruption gracefully** — treat invalid cache entries as misses, never crash
-## Anti-Patterns to Avoid
-```python
-# BAD: Path-based caching (breaks on file move/rename)
-cache = {"/path/to/file.pdf": result}
-# BAD: Adding cache logic inside the processing function (SRP violation)
-def extract_text(path, *, cache_enabled=False, cache_dir=None):
-    if cache_enabled:  # Now this function has two responsibilities
-        ...
-# BAD: Using dataclasses.asdict() with nested frozen dataclasses
-# (can cause issues with complex nested types)
-data = dataclasses.asdict(entry)  # Use manual serialization instead
-```
-## When to Use
-- File processing pipelines (PDF parsing, OCR, text extraction, image analysis)
-- CLI tools that benefit from `--cache/--no-cache` options
-- Batch processing where the same files appear across runs
-- Adding caching to existing pure functions without modifying them
-## When NOT to Use
-- Data that must always be fresh (real-time feeds)
-- Cache entries that would be extremely large (consider streaming instead)
-- Results that depend on parameters beyond file content (e.g., different extraction configs)

package/templates/ecc/skills/continuous-learning/SKILL.md DELETED Viewed

@@ -1,119 +0,0 @@
----
-name: continuous-learning
-description: Automatically extract reusable patterns from Claude Code sessions and save them as learned skills for future use.
-origin: ECC
----
-# Continuous Learning Skill
-Automatically evaluates Claude Code sessions on end to extract reusable patterns that can be saved as learned skills.
-## When to Activate
-- Setting up automatic pattern extraction from Claude Code sessions
-- Configuring the Stop hook for session evaluation
-- Reviewing or curating learned skills in `~/.claude/skills/learned/`
-- Adjusting extraction thresholds or pattern categories
-- Comparing v1 (this) vs v2 (instinct-based) approaches
-## How It Works
-This skill runs as a **Stop hook** at the end of each session:
-1. **Session Evaluation**: Checks if session has enough messages (default: 10+)
-2. **Pattern Detection**: Identifies extractable patterns from the session
-3. **Skill Extraction**: Saves useful patterns to `~/.claude/skills/learned/`
-## Configuration
-Edit `config.json` to customize:
-```json
-{
-  "min_session_length": 10,
-  "extraction_threshold": "medium",
-  "auto_approve": false,
-  "learned_skills_path": "~/.claude/skills/learned/",
-  "patterns_to_detect": [
-    "error_resolution",
-    "user_corrections",
-    "workarounds",
-    "debugging_techniques",
-    "project_specific"
-  ],
-  "ignore_patterns": [
-    "simple_typos",
-    "one_time_fixes",
-    "external_api_issues"
-  ]
-}
-```
-## Pattern Types
-| Pattern | Description |
-|---------|-------------|
-| `error_resolution` | How specific errors were resolved |
-| `user_corrections` | Patterns from user corrections |
-| `workarounds` | Solutions to framework/library quirks |
-| `debugging_techniques` | Effective debugging approaches |
-| `project_specific` | Project-specific conventions |
-## Hook Setup
-Add to your `~/.claude/settings.json`:
-```json
-{
-  "hooks": {
-    "Stop": [{
-      "matcher": "*",
-      "hooks": [{
-        "type": "command",
-        "command": "~/.claude/skills/continuous-learning/evaluate-session.sh"
-      }]
-    }]
-  }
-}
-```
-## Why Stop Hook?
-- **Lightweight**: Runs once at session end
-- **Non-blocking**: Doesn't add latency to every message
-- **Complete context**: Has access to full session transcript
-## Related
-- [The Longform Guide](https://x.com/affaanmustafa/status/2014040193557471352) - Section on continuous learning
-- `/learn` command - Manual pattern extraction mid-session
----
-## Comparison Notes (Research: Jan 2025)
-### vs Homunculus
-Homunculus v2 takes a more sophisticated approach:
-| Feature | Our Approach | Homunculus v2 |
-|---------|--------------|---------------|
-| Observation | Stop hook (end of session) | PreToolUse/PostToolUse hooks (100% reliable) |
-| Analysis | Main context | Background agent (Haiku) |
-| Granularity | Full skills | Atomic "instincts" |
-| Confidence | None | 0.3-0.9 weighted |
-| Evolution | Direct to skill | Instincts → cluster → skill/command/agent |
-| Sharing | None | Export/import instincts |
-**Key insight from homunculus:**
-> "v1 relied on skills to observe. Skills are probabilistic—they fire ~50-80% of the time. v2 uses hooks for observation (100% reliable) and instincts as the atomic unit of learned behavior."
-### Potential v2 Enhancements
-1. **Instinct-based learning** - Smaller, atomic behaviors with confidence scoring
-2. **Background observer** - Haiku agent analyzing in parallel
-3. **Confidence decay** - Instincts lose confidence if contradicted
-4. **Domain tagging** - code-style, testing, git, debugging, etc.
-5. **Evolution path** - Cluster related instincts into skills/commands
-See: `/Users/affoon/Documents/tasks/12-continuous-learning-v2.md` for full spec.