kodelyth-ecc 2.17.0 → 2.19.0

package/.kimi/commands/immune.md

@@ -0,0 +1,89 @@
+---
+description: Scan any codebase for the bug classes the arena has actually confirmed — executable detectors, each pinned to the commit that proves it.
+argument-hint: "[path]"
+---
+
+# /immune — the arena's findings, made executable
+
+The arena finds bugs one repository at a time and remembers them as prose. Prose
+does not scan a codebase. `/immune` turns each **confirmed** class into a
+detector that runs, so a bug proven here can be found anywhere — including in
+repositories that never ran the arena.
+
+```bash
+kodelythecc immune              # scan the current directory
+kodelythecc immune scripts/     # scan a subtree
+kodelythecc immune --json       # machine-readable
+kodelythecc immune --tests      # include test files (normally skipped)
+```
+
+Exits non-zero when anything **high** is found, so it drops straight into CI.
+
+## What it looks for
+
+Every detector below encodes a class that was reproduced with a real repro
+during an arena run. Nothing here is hypothetical.
+
+| Detector | Confirmed | What it catches |
+|---|---|---|
+| `lexical-containment` | 5× | `startsWith(root)` with no `realpath` — a symlink inside the root passes while pointing anywhere on disk |
+| `prototype-key-map` | 1× | `map['constructor']` is truthy, so `if (!map[k])` never fires |
+| `truncate-then-write` | 3× | `writeFileSync` on durable state truncates to zero before writing |
+| `predictable-temp-name` | 1× | a pid-derived temp path can be pre-planted with a symlink |
+
+## How each detector earns its place
+
+A detector ships only if it does **both**:
+
+1. **FIRES** on the exact source the arena found the bug in
+2. Goes **SILENT** on the source after the fix
+
+Both halves matter. A detector that misses the real bug is decoration; one that
+still fires after the fix is a false positive. The fixtures in
+`tests/immune/detectors.test.js` are real code quoted from this repository at
+v2.7.0 — the last release before any arena fix landed.
+
+## Two classes were deliberately NOT shipped
+
+This matters more than the four that were.
+
+**ReDoS.** The class is real: an unbounded quantifier cost 7.6 s on 293 KB. But
+arena run #1 *measured* five structurally identical regexes in one file — the
+fenced-code, inline-code, bare-URL and file-path patterns were all linear, and
+only the link-target pattern was quadratic. The difference is whether the
+closing delimiter is commonly absent in real input: a property of the data, not
+the pattern, and invisible to a scanner. A detector would have flagged all five
+and been wrong about four.
+
+**Unbounded input.** Also real — 4.9 MB allocated ~417 MB and OOMed under a
+256 MB heap. But the detectable shape is "this module reads a file", which
+described 57 of 165 files here. The actual bug is reading *untrusted* input
+without a cap, and a scanner cannot tell which reads are untrusted.
+
+Both stay where they were actually caught: measurement under `/arena`, and human
+review under `security-reviewer`.
+
+> A scanner that is wrong four times out of five gets muted, and a muted scanner
+> protects nothing. Precision over recall, deliberately.
+
+## What a clean result means
+
+```
+Clean. 165 files scanned, none matched a known class.
+```
+
+That is **not** proof of correctness. It means none of the specific classes the
+arena has confirmed are present. New classes are found by running `/arena`, and
+each new confirmation is a candidate for a new detector.
+
+## The loop this closes
+
+```
+/arena  ──▶  confirmed findings  ──▶  memories  ──▶  detectors  ──▶  /immune
+   ▲                                                                     │
+   └──────────────  new classes found in new code  ◀────────────────────┘
+```
+
+`/arena` is expensive and thorough — agents, rounds, real repros. `/immune` is
+instant and narrow. Use the arena to *discover* a class; use immune to make sure
+it never comes back, anywhere.

package/.kimi/commands/instinct-export.md

@@ -0,0 +1,66 @@
+---
+name: instinct-export
+description: Export instincts from project/global scope to a file
+command: /instinct-export
+---
+
+# Instinct Export Command
+
+Exports instincts to a shareable format. Perfect for:
+- Sharing with teammates
+- Transferring to a new machine
+- Contributing to project conventions
+
+## Usage
+
+```
+/instinct-export                           # Export all personal instincts
+/instinct-export --domain testing          # Export only testing instincts
+/instinct-export --min-confidence 0.7      # Only export high-confidence instincts
+/instinct-export --output team-instincts.yaml
+/instinct-export --scope project --output project-instincts.yaml
+```
+
+## What to Do
+
+1. Detect current project context
+2. Load instincts by selected scope:
+   - `project`: current project only
+   - `global`: global only
+   - `all`: project + global merged (default)
+3. Apply filters (`--domain`, `--min-confidence`)
+4. Write YAML-style export to file (or stdout if no output path provided)
+
+## Output Format
+
+Creates a YAML file:
+
+```yaml
+# Instincts Export
+# Generated: 2025-01-22
+# Source: personal
+# Count: 12 instincts
+
+---
+id: prefer-functional-style
+trigger: "when writing new functions"
+confidence: 0.8
+domain: code-style
+source: session-observation
+scope: project
+project_id: a1b2c3d4e5f6
+project_name: my-app
+---
+
+# Prefer Functional Style
+
+## Action
+Use functional patterns over classes.
+```
+
+## Flags
+
+- `--domain <name>`: Export only specified domain
+- `--min-confidence <n>`: Minimum confidence threshold
+- `--output <file>`: Output file path (prints to stdout when omitted)
+- `--scope <project|global|all>`: Export scope (default: `all`)

package/.kimi/commands/instinct-import.md

@@ -0,0 +1,114 @@
+---
+name: instinct-import
+description: Import instincts from file or URL into project/global scope
+command: true
+---
+
+# Instinct Import Command
+
+## Implementation
+
+Run the instinct CLI using the plugin root path:
+
+```bash
+python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" import <file-or-url> [--dry-run] [--force] [--min-confidence 0.7] [--scope project|global]
+```
+
+Or if `CLAUDE_PLUGIN_ROOT` is not set (manual installation):
+
+```bash
+python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py import <file-or-url>
+```
+
+Import instincts from local file paths or HTTP(S) URLs.
+
+## Usage
+
+```
+/instinct-import team-instincts.yaml
+/instinct-import https://github.com/org/repo/instincts.yaml
+/instinct-import team-instincts.yaml --dry-run
+/instinct-import team-instincts.yaml --scope global --force
+```
+
+## What to Do
+
+1. Fetch the instinct file (local path or URL)
+2. Parse and validate the format
+3. Check for duplicates with existing instincts
+4. Merge or add new instincts
+5. Save to inherited instincts directory:
+   - Project scope: `~/.claude/homunculus/projects/<project-id>/instincts/inherited/`
+   - Global scope: `~/.claude/homunculus/instincts/inherited/`
+
+## Import Process
+
+```
+ Importing instincts from: team-instincts.yaml
+================================================
+
+Found 12 instincts to import.
+
+Analyzing conflicts...
+
+## New Instincts (8)
+These will be added:
+  ✓ use-zod-validation (confidence: 0.7)
+  ✓ prefer-named-exports (confidence: 0.65)
+  ✓ test-async-functions (confidence: 0.8)
+  ...
+
+## Duplicate Instincts (3)
+Already have similar instincts:
+  WARNING: prefer-functional-style
+     Local: 0.8 confidence, 12 observations
+     Import: 0.7 confidence
+     → Keep local (higher confidence)
+
+  WARNING: test-first-workflow
+     Local: 0.75 confidence
+     Import: 0.9 confidence
+     → Update to import (higher confidence)
+
+Import 8 new, update 1?
+```
+
+## Merge Behavior
+
+When importing an instinct with an existing ID:
+- Higher-confidence import becomes an update candidate
+- Equal/lower-confidence import is skipped
+- User confirms unless `--force` is used
+
+## Source Tracking
+
+Imported instincts are marked with:
+```yaml
+source: inherited
+scope: project
+imported_from: "team-instincts.yaml"
+project_id: "a1b2c3d4e5f6"
+project_name: "my-project"
+```
+
+## Flags
+
+- `--dry-run`: Preview without importing
+- `--force`: Skip confirmation prompt
+- `--min-confidence <n>`: Only import instincts above threshold
+- `--scope <project|global>`: Select target scope (default: `project`)
+
+## Output
+
+After import:
+```
+PASS: Import complete!
+
+Added: 8 instincts
+Updated: 1 instinct
+Skipped: 3 instincts (equal/higher confidence already exists)
+
+New instincts saved to: ~/.claude/homunculus/instincts/inherited/
+
+Run /instinct-status to see all instincts.
+```

package/.kimi/commands/instinct-status.md

@@ -0,0 +1,59 @@
+---
+name: instinct-status
+description: Show learned instincts (project + global) with confidence
+command: true
+---
+
+# Instinct Status Command
+
+Shows learned instincts for the current project plus global instincts, grouped by domain.
+
+## Implementation
+
+Run the instinct CLI using the plugin root path:
+
+```bash
+python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" status
+```
+
+Or if `CLAUDE_PLUGIN_ROOT` is not set (manual installation), use:
+
+```bash
+python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py status
+```
+
+## Usage
+
+```
+/instinct-status
+```
+
+## What to Do
+
+1. Detect current project context (git remote/path hash)
+2. Read project instincts from `~/.claude/homunculus/projects/<project-id>/instincts/`
+3. Read global instincts from `~/.claude/homunculus/instincts/`
+4. Merge with precedence rules (project overrides global when IDs collide)
+5. Display grouped by domain with confidence bars and observation stats
+
+## Output Format
+
+```
+============================================================
+  INSTINCT STATUS - 12 total
+============================================================
+
+  Project: my-app (a1b2c3d4e5f6)
+  Project instincts: 8
+  Global instincts:  4
+
+## PROJECT-SCOPED (my-app)
+  ### WORKFLOW (3)
+    ███████░░░  70%  grep-before-edit [project]
+              trigger: when modifying code
+
+## GLOBAL (apply to all projects)
+  ### SECURITY (2)
+    █████████░  85%  validate-user-input [global]
+              trigger: when handling user input
+```

package/.kimi/commands/jira.md

@@ -0,0 +1,106 @@
+---
+description: Retrieve a Jira ticket, analyze requirements, update status, or add comments. Uses the jira-integration skill and MCP or REST API.
+---
+
+# Jira Command
+
+Interact with Jira tickets directly from your workflow — fetch tickets, analyze requirements, add comments, and transition status.
+
+## Usage
+
+```
+/jira get <TICKET-KEY>          # Fetch and analyze a ticket
+/jira comment <TICKET-KEY>      # Add a progress comment
+/jira transition <TICKET-KEY>   # Change ticket status
+/jira search <JQL>              # Search issues with JQL
+```
+
+## What This Command Does
+
+1. **Get & Analyze** — Fetch a Jira ticket and extract requirements, acceptance criteria, test scenarios, and dependencies
+2. **Comment** — Add structured progress updates to a ticket
+3. **Transition** — Move a ticket through workflow states (To Do → In Progress → Done)
+4. **Search** — Find issues using JQL queries
+
+## How It Works
+
+### `/jira get <TICKET-KEY>`
+
+1. Fetch the ticket from Jira (via MCP `jira_get_issue` or REST API)
+2. Extract all fields: summary, description, acceptance criteria, priority, labels, linked issues
+3. Optionally fetch comments for additional context
+4. Produce a structured analysis:
+
+```
+Ticket: PROJ-1234
+Summary: [title]
+Status: [status]
+Priority: [priority]
+Type: [Story/Bug/Task]
+
+Requirements:
+1. [extracted requirement]
+2. [extracted requirement]
+
+Acceptance Criteria:
+- [ ] [criterion from ticket]
+
+Test Scenarios:
+- Happy Path: [description]
+- Error Case: [description]
+- Edge Case: [description]
+
+Dependencies:
+- [linked issues, APIs, services]
+
+Recommended Next Steps:
+- /plan to create implementation plan
+- /tdd to implement with tests first
+```
+
+### `/jira comment <TICKET-KEY>`
+
+1. Summarize current session progress (what was built, tested, committed)
+2. Format as a structured comment
+3. Post to the Jira ticket
+
+### `/jira transition <TICKET-KEY>`
+
+1. Fetch available transitions for the ticket
+2. Show options to user
+3. Execute the selected transition
+
+### `/jira search <JQL>`
+
+1. Execute the JQL query against Jira
+2. Return a summary table of matching issues
+
+## Prerequisites
+
+This command requires Jira credentials. Choose one:
+
+**Option A — MCP Server (recommended):**
+Add `jira` to your `mcpServers` config (see `mcp-configs/mcp-servers.json` for the template).
+
+**Option B — Environment variables:**
+```bash
+export JIRA_URL="https://yourorg.atlassian.net"
+export JIRA_EMAIL="your.email@example.com"
+export JIRA_API_TOKEN="your-api-token"
+```
+
+If credentials are missing, stop and direct the user to set them up.
+
+## Integration with Other Commands
+
+After analyzing a ticket:
+- Use `/plan` to create an implementation plan from the requirements
+- Use `/tdd` to implement with test-driven development
+- Use `/code-review` after implementation
+- Use `/jira comment` to post progress back to the ticket
+- Use `/jira transition` to move the ticket when work is complete
+
+## Related
+
+- **Skill:** `skills/jira-integration/`
+- **MCP config:** `mcp-configs/mcp-servers.json` → `jira`

package/.kimi/commands/kotlin-build.md

@@ -0,0 +1,174 @@
+---
+description: Fix Kotlin/Gradle build errors, compiler warnings, and dependency issues incrementally. Invokes the kotlin-build-resolver agent for minimal, surgical fixes.
+---
+
+# Kotlin Build and Fix
+
+This command invokes the **kotlin-build-resolver** agent to incrementally fix Kotlin build errors with minimal changes.
+
+## What This Command Does
+
+1. **Run Diagnostics**: Execute `./gradlew build`, `detekt`, `ktlintCheck`
+2. **Parse Errors**: Group by file and sort by severity
+3. **Fix Incrementally**: One error at a time
+4. **Verify Each Fix**: Re-run build after each change
+5. **Report Summary**: Show what was fixed and what remains
+
+## When to Use
+
+Use `/kotlin-build` when:
+- `./gradlew build` fails with errors
+- Kotlin compiler reports errors
+- `./gradlew detekt` reports violations
+- Gradle dependency resolution fails
+- After pulling changes that break the build
+
+## Diagnostic Commands Run
+
+```bash
+# Primary build check
+./gradlew build 2>&1
+
+# Static analysis
+./gradlew detekt 2>&1 || echo "detekt not configured"
+./gradlew ktlintCheck 2>&1 || echo "ktlint not configured"
+
+# Dependency issues
+./gradlew dependencies --configuration runtimeClasspath 2>&1 | head -100
+
+# Optional deep refresh when caches or dependency metadata are suspect
+./gradlew build --refresh-dependencies
+```
+
+## Example Session
+
+````text
+User: /kotlin-build
+
+Agent:
+# Kotlin Build Resolution
+
+## Initial Diagnostics
+
+```bash
+$ ./gradlew build
+e: src/main/kotlin/com/example/service/UserService.kt:25:15 Unresolved reference: UserRepository
+e: src/main/kotlin/com/example/routes/UserRoutes.kt:42:9 Type mismatch: inferred type is String but Int was expected
+e: src/main/kotlin/com/example/routes/UserRoutes.kt:58:5 'when' expression must be exhaustive
+```
+
+Errors found: 3
+
+## Fix 1: Unresolved Reference
+
+File: src/main/kotlin/com/example/service/UserService.kt:25
+Error: Unresolved reference: UserRepository
+Cause: Missing import
+
+```kotlin
+// Added import
+import com.example.repository.UserRepository
+```
+
+```bash
+$ ./gradlew build
+# 2 errors remaining
+```
+
+## Fix 2: Type Mismatch
+
+File: src/main/kotlin/com/example/routes/UserRoutes.kt:42
+Error: Type mismatch: inferred type is String but Int was expected
+
+```kotlin
+// Changed
+val count = call.parameters["count"]
+// To
+val count = call.parameters["count"]?.toIntOrNull()
+    ?: return@get call.respond(HttpStatusCode.BadRequest, "Invalid count")
+```
+
+```bash
+$ ./gradlew build
+# 1 error remaining
+```
+
+## Fix 3: Non-Exhaustive When
+
+File: src/main/kotlin/com/example/routes/UserRoutes.kt:58
+Error: 'when' expression must be exhaustive
+
+```kotlin
+// Added missing branch
+when (user.role) {
+    Role.ADMIN -> handleAdmin(user)
+    Role.USER -> handleUser(user)
+    Role.MODERATOR -> handleModerator(user) // Added
+}
+```
+
+```bash
+$ ./gradlew build
+# Build successful!
+```
+
+## Final Verification
+
+```bash
+$ ./gradlew detekt
+# No issues
+
+$ ./gradlew test
+# All tests passed
+```
+
+## Summary
+
+| Metric | Count |
+|--------|-------|
+| Build errors fixed | 3 |
+| Detekt issues fixed | 0 |
+| Files modified | 2 |
+| Remaining issues | 0 |
+
+Build Status: PASS: SUCCESS
+````
+
+## Common Errors Fixed
+
+| Error | Typical Fix |
+|-------|-------------|
+| `Unresolved reference: X` | Add import or dependency |
+| `Type mismatch` | Fix type conversion or assignment |
+| `'when' must be exhaustive` | Add missing sealed class branches |
+| `Suspend function can only be called from coroutine` | Add `suspend` modifier |
+| `Smart cast impossible` | Use local `val` or `let` |
+| `None of the following candidates is applicable` | Fix argument types |
+| `Could not resolve dependency` | Fix version or add repository |
+
+## Fix Strategy
+
+1. **Build errors first** - Code must compile
+2. **Detekt violations second** - Fix code quality issues
+3. **ktlint warnings third** - Fix formatting
+4. **One fix at a time** - Verify each change
+5. **Minimal changes** - Don't refactor, just fix
+
+## Stop Conditions
+
+The agent will stop and report if:
+- Same error persists after 3 attempts
+- Fix introduces more errors
+- Requires architectural changes
+- Missing external dependencies
+
+## Related Commands
+
+- `/kotlin-test` - Run tests after build succeeds
+- `/kotlin-review` - Review code quality
+- `/verify` - Full verification loop
+
+## Related
+
+- Agent: `agents/kotlin-build-resolver.md`
+- Skill: `skills/kotlin-patterns/`