continuous-improvement 2.2.0 → 3.1.0

package/commands/dashboard.md

@@ -0,0 +1,56 @@
+---
+name: dashboard
+description: Visual dashboard showing instinct health, observation stats, and learning progress
+---
+
+# Instinct Dashboard
+
+Generate a visual dashboard for this project's continuous-improvement status.
+
+## Instructions
+
+1. **Find project hash:** Run `git rev-parse --show-toplevel 2>/dev/null`, then SHA-256 first 12 chars
+2. **Read observations:** Count lines in `~/.claude/instincts/<hash>/observations.jsonl`
+3. **Read instincts:** Load all `*.yaml` files from project dir + `global/`
+4. **Read instinct packs:** Check if any packs from `instinct-packs/` have been loaded
+
+## Display Format
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║              continuous-improvement Dashboard                ║
+╠══════════════════════════════════════════════════════════════╣
+║                                                              ║
+║  Project: <name>              Level: <CAPTURE|ANALYZE|...>   ║
+║  Sessions: ~<obs/10>          Mode: <beginner|expert>        ║
+║                                                              ║
+║  ┌─ Observations ────────────────────────────────────────┐   ║
+║  │  Total: <n>    Unprocessed: <n>    Last: <date>       │   ║
+║  └───────────────────────────────────────────────────────┘   ║
+║                                                              ║
+║  ┌─ Instincts ───────────────────────────────────────────┐   ║
+║  │  Total: <n>                                           │   ║
+║  │  ████████░░ Auto-apply (0.7+): <n>                    │   ║
+║  │  █████░░░░░ Suggest (0.5-0.69): <n>                   │   ║
+║  │  ██░░░░░░░░ Silent (< 0.5): <n>                       │   ║
+║  │  Global: <n>    Project: <n>                          │   ║
+║  └───────────────────────────────────────────────────────┘   ║
+║                                                              ║
+║  ┌─ Top Instincts ───────────────────────────────────────┐   ║
+║  │  <list top 5 instincts by confidence with bars>       │   ║
+║  └───────────────────────────────────────────────────────┘   ║
+║                                                              ║
+║  ┌─ Health ──────────────────────────────────────────────┐   ║
+║  │  Stale (30+ days): <n>    Decaying: <n>               │   ║
+║  │  Recently reinforced: <n>                             │   ║
+║  └───────────────────────────────────────────────────────┘   ║
+║                                                              ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+## After Display
+
+- If stale instincts > 0: suggest reviewing them
+- If unprocessed observations > 20: suggest running analysis
+- If no instincts exist: explain the auto-leveling timeline
+- Show available instinct packs that haven't been loaded yet

package/commands/discipline.md

@@ -0,0 +1,37 @@
+---
+name: discipline
+description: Quick reference card for the 7 Laws of AI Agent Discipline
+---
+
+# The 7 Laws — Quick Reference
+
+Print this card and check yourself against each law.
+
+## The Laws
+
+| # | Law | Check | Red Flag |
+|---|-----|-------|----------|
+| 1 | **Research Before Executing** | Did I search for existing solutions? | "I'll just quickly..." |
+| 2 | **Plan Is Sacred** | Did I state WILL / WILL NOT / VERIFY? | "Let me also add..." |
+| 3 | **One Thing at a Time** | Am I finishing before starting? | "While I'm here..." |
+| 4 | **Verify Before Reporting** | Did I check the ACTUAL output? | "This should work..." |
+| 5 | **Reflect After Sessions** | Did I note what worked/failed? | "I'll remember..." |
+| 6 | **Iterate One Change** | Am I changing one thing at a time? | "And also..." |
+| 7 | **Learn From Every Session** | Did I capture this as an instinct? | "Next time I'll..." |
+
+## The Loop
+
+```
+Research → Plan → Execute (one thing) → Verify → Reflect → Learn → Iterate
+```
+
+## Self-Check
+
+Before saying "Done", verify ALL:
+- [ ] Code runs without errors
+- [ ] Output matches expected result
+- [ ] I checked the **actual** result (not assumed)
+- [ ] Build passes
+- [ ] I can explain the change in one sentence
+
+If you're skipping a step, that's the step you need most.

package/hooks/session.sh

@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+# session.sh — SessionStart/SessionEnd hook for continuous-improvement
+# SessionStart: loads instincts and prints status
+# SessionEnd: prompts reflection
+# Always exits 0 — never blocks the session
+trap 'exit 0' EXIT ERR INT TERM
+
+INSTINCTS_DIR="${HOME}/.claude/instincts"
+
+# Read stdin
+INPUT="$(cat)"
+[[ -z "$INPUT" ]] && exit 0
+
+# ---------------------------------------------------------------------------
+# Detect event type from hook context
+# ---------------------------------------------------------------------------
+# SessionStart hooks receive no tool_name, SessionEnd hooks may vary.
+# We detect based on the hook_type field or the calling context.
+EVENT_TYPE=""
+if command -v jq &>/dev/null; then
+  EVENT_TYPE="$(printf '%s' "$INPUT" | jq -r '.hook_type // .event_type // "unknown"' 2>/dev/null)"
+else
+  if printf '%s' "$INPUT" | grep -q '"SessionStart"'; then
+    EVENT_TYPE="SessionStart"
+  elif printf '%s' "$INPUT" | grep -q '"SessionEnd"'; then
+    EVENT_TYPE="SessionEnd"
+  fi
+fi
+
+# ---------------------------------------------------------------------------
+# Project detection (same as observe.sh)
+# ---------------------------------------------------------------------------
+PROJECT_ROOT=""
+if [[ -n "${CLAUDE_PROJECT_DIR:-}" && -d "${CLAUDE_PROJECT_DIR}" ]]; then
+  PROJECT_ROOT="${CLAUDE_PROJECT_DIR}"
+fi
+if [[ -z "$PROJECT_ROOT" ]]; then
+  PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+fi
+if [[ -z "$PROJECT_ROOT" ]]; then
+  PROJECT_ROOT="global"
+fi
+
+PROJECT_HASH="$(printf '%s' "$PROJECT_ROOT" | sha256sum | cut -c1-12)"
+PROJECT_DIR="${INSTINCTS_DIR}/${PROJECT_HASH}"
+
+# ---------------------------------------------------------------------------
+# SessionStart: count observations and instincts, print brief status
+# ---------------------------------------------------------------------------
+if [[ "$EVENT_TYPE" == "SessionStart" || "$EVENT_TYPE" == "unknown" ]]; then
+  OBS_COUNT=0
+  INSTINCT_COUNT=0
+
+  OBS_FILE="${PROJECT_DIR}/observations.jsonl"
+  if [[ -f "$OBS_FILE" ]]; then
+    OBS_COUNT="$(wc -l < "$OBS_FILE" 2>/dev/null || echo 0)"
+  fi
+
+  # Count yaml files in project + global
+  for dir in "$PROJECT_DIR" "${INSTINCTS_DIR}/global"; do
+    if [[ -d "$dir" ]]; then
+      count="$(find "$dir" -maxdepth 1 -name '*.yaml' 2>/dev/null | wc -l)"
+      INSTINCT_COUNT=$((INSTINCT_COUNT + count))
+    fi
+  done
+
+  # Determine level
+  LEVEL="CAPTURE"
+  if (( OBS_COUNT >= 20 )) || (( INSTINCT_COUNT > 0 )); then
+    LEVEL="ANALYZE"
+  fi
+
+  # Check for high-confidence instincts
+  if (( INSTINCT_COUNT > 0 )); then
+    for dir in "$PROJECT_DIR" "${INSTINCTS_DIR}/global"; do
+      if [[ -d "$dir" ]]; then
+        for f in "$dir"/*.yaml; do
+          [[ -f "$f" ]] || continue
+          conf="$(grep '^confidence:' "$f" 2>/dev/null | head -1 | sed 's/confidence: *//')"
+          if [[ -n "$conf" ]]; then
+            # Compare as integer (multiply by 100)
+            int_conf="$(printf '%.0f' "$(echo "$conf * 100" | bc 2>/dev/null || echo 0)")"
+            if (( int_conf >= 70 )); then
+              LEVEL="AUTO-APPLY"
+              break 2
+            elif (( int_conf >= 50 )); then
+              LEVEL="SUGGEST"
+            fi
+          fi
+        done
+      fi
+    done
+  fi
+
+  # Write status to stderr (visible in hook output, not blocking)
+  echo "[continuous-improvement] Level: ${LEVEL} | Observations: ${OBS_COUNT} | Instincts: ${INSTINCT_COUNT}" >&2
+fi
+
+# ---------------------------------------------------------------------------
+# SessionEnd: remind to reflect
+# ---------------------------------------------------------------------------
+if [[ "$EVENT_TYPE" == "SessionEnd" ]]; then
+  echo "[continuous-improvement] Session ending. Run /continuous-improvement to reflect and capture learnings." >&2
+fi
+
+exit 0

package/instinct-packs/go.json

@@ -0,0 +1,58 @@
+[
+  {
+    "id": "go-error-handling",
+    "trigger": "when calling functions that return errors",
+    "body": "Always check returned errors immediately. Never use _ to discard errors unless you've explicitly decided it's safe and documented why.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "go-defer-cleanup",
+    "trigger": "when opening files, connections, or acquiring locks",
+    "body": "Use defer immediately after acquiring a resource for cleanup. Place defer right after the error check for the acquisition.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "go-interface-consumer",
+    "trigger": "when defining Go interfaces",
+    "body": "Define interfaces at the consumer side, not the producer side. Keep interfaces small (1-3 methods). Accept interfaces, return structs.",
+    "confidence": 0.65,
+    "domain": "patterns"
+  },
+  {
+    "id": "go-table-driven-tests",
+    "trigger": "when writing Go tests",
+    "body": "Use table-driven tests with subtests (t.Run) for functions with multiple input/output cases. Name test cases descriptively.",
+    "confidence": 0.7,
+    "domain": "testing"
+  },
+  {
+    "id": "go-context-propagation",
+    "trigger": "when writing HTTP handlers or long-running operations",
+    "body": "Accept context.Context as the first parameter. Propagate it to all downstream calls. Use it for cancellation and timeouts.",
+    "confidence": 0.65,
+    "domain": "patterns"
+  },
+  {
+    "id": "go-goroutine-lifecycle",
+    "trigger": "when spawning goroutines",
+    "body": "Always ensure goroutines have a way to exit (context cancellation, done channel, or WaitGroup). Never fire-and-forget goroutines without cleanup.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "go-struct-zero-values",
+    "trigger": "when designing Go structs",
+    "body": "Design structs so their zero value is useful. Use pointer fields only when nil is a meaningful distinct state from zero value.",
+    "confidence": 0.6,
+    "domain": "patterns"
+  },
+  {
+    "id": "go-mod-tidy",
+    "trigger": "when adding or removing dependencies",
+    "body": "Run 'go mod tidy' after adding or removing imports to keep go.mod and go.sum clean.",
+    "confidence": 0.65,
+    "domain": "workflow"
+  }
+]

package/instinct-packs/python.json

@@ -0,0 +1,58 @@
+[
+  {
+    "id": "python-virtual-env",
+    "trigger": "when starting work on a Python project",
+    "body": "Check for virtual environment (venv, .venv, conda) before installing packages. Never install to system Python.",
+    "confidence": 0.7,
+    "domain": "workflow"
+  },
+  {
+    "id": "python-type-hints",
+    "trigger": "when writing Python functions",
+    "body": "Add type hints to function parameters and return values. Use Optional[], list[], dict[] (Python 3.10+) or typing module for older versions.",
+    "confidence": 0.6,
+    "domain": "code-style"
+  },
+  {
+    "id": "python-pathlib",
+    "trigger": "when working with file paths in Python",
+    "body": "Use pathlib.Path instead of os.path for file operations. It's more readable and cross-platform.",
+    "confidence": 0.65,
+    "domain": "patterns"
+  },
+  {
+    "id": "python-context-managers",
+    "trigger": "when opening files or database connections",
+    "body": "Always use context managers (with statement) for files, database connections, and locks. Never rely on manual .close() calls.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "python-list-comprehension",
+    "trigger": "when writing simple for loops that build lists",
+    "body": "Prefer list comprehensions for simple transformations. Use regular for loops when the logic is complex or has side effects.",
+    "confidence": 0.6,
+    "domain": "code-style"
+  },
+  {
+    "id": "python-requirements-check",
+    "trigger": "when adding a new import",
+    "body": "Check if the package is already in requirements.txt, pyproject.toml, or Pipfile before adding. Search for existing usage in the codebase.",
+    "confidence": 0.65,
+    "domain": "workflow"
+  },
+  {
+    "id": "python-pytest-fixtures",
+    "trigger": "when writing Python tests",
+    "body": "Use pytest fixtures for test setup/teardown instead of unittest setUp/tearDown. Use conftest.py for shared fixtures.",
+    "confidence": 0.6,
+    "domain": "testing"
+  },
+  {
+    "id": "python-dataclass",
+    "trigger": "when creating classes that primarily hold data",
+    "body": "Use @dataclass or Pydantic BaseModel instead of plain classes for data containers. They provide __init__, __repr__, and comparison for free.",
+    "confidence": 0.65,
+    "domain": "patterns"
+  }
+]

package/instinct-packs/react.json

@@ -0,0 +1,58 @@
+[
+  {
+    "id": "react-check-existing-components",
+    "trigger": "when creating a new React component",
+    "body": "Search the codebase for existing components that solve the same problem before creating new ones. Check shared/, components/, and ui/ directories.",
+    "confidence": 0.65,
+    "domain": "workflow"
+  },
+  {
+    "id": "react-prefer-server-components",
+    "trigger": "when creating components in Next.js App Router",
+    "body": "Default to Server Components. Only add 'use client' when the component needs useState, useEffect, event handlers, or browser APIs.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "react-key-prop-lists",
+    "trigger": "when rendering lists with .map()",
+    "body": "Always use a stable, unique key prop. Never use array index as key unless the list is static and never reordered.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "react-effect-cleanup",
+    "trigger": "when writing useEffect with subscriptions or timers",
+    "body": "Always return a cleanup function from useEffect when setting up subscriptions, event listeners, or timers to prevent memory leaks.",
+    "confidence": 0.7,
+    "domain": "patterns"
+  },
+  {
+    "id": "react-memo-expensive",
+    "trigger": "when a component re-renders with expensive calculations",
+    "body": "Use useMemo for expensive computations and React.memo for components that receive the same props frequently. Don't memo everything — only what's measurably slow.",
+    "confidence": 0.6,
+    "domain": "patterns"
+  },
+  {
+    "id": "react-form-validation",
+    "trigger": "when building forms",
+    "body": "Check if react-hook-form or zod is already in the project before building custom form validation. Prefer library solutions over hand-rolled validation.",
+    "confidence": 0.65,
+    "domain": "tooling"
+  },
+  {
+    "id": "react-error-boundary",
+    "trigger": "when adding a new page or route",
+    "body": "Ensure error boundaries exist around new pages/routes. In Next.js App Router, add error.tsx. In other React apps, wrap with ErrorBoundary component.",
+    "confidence": 0.6,
+    "domain": "patterns"
+  },
+  {
+    "id": "react-test-user-behavior",
+    "trigger": "when writing React component tests",
+    "body": "Test user behavior, not implementation details. Use @testing-library/react. Query by role, label, or text — not by class name or test ID.",
+    "confidence": 0.65,
+    "domain": "testing"
+  }
+]

package/llms.txt

@@ -0,0 +1,43 @@
+# continuous-improvement
+
+> The 7 Laws of AI Agent Discipline — stop your agent from skipping steps, guessing, and declaring "done" without verifying.
+
+## What This Is
+
+A discipline framework for AI coding agents. It teaches agents structured thinking through 7 laws and builds behavioral instincts over time via the Mulahazah learning system.
+
+## Install
+
+```bash
+npx continuous-improvement install
+```
+
+## The 7 Laws
+
+1. Research Before Executing — search before writing
+2. Plan Is Sacred — state WILL/WILL NOT/VERIFY before acting
+3. One Thing at a Time — complete and verify one task before the next
+4. Verify Before Reporting — "done" requires actual proof
+5. Reflect After Sessions — capture what worked and what failed
+6. Iterate One Change — one change, verify, then next
+7. Learn From Every Session — patterns become instincts
+
+## Key Concepts
+
+- **Mulahazah** — auto-leveling learning system that captures tool usage patterns
+- **Instincts** — YAML-based behavioral rules with confidence scoring (0.0-0.9)
+- **Auto-leveling** — CAPTURE → ANALYZE → SUGGEST → AUTO-APPLY (no config needed)
+- **Project-scoped** — instincts are per-project, promoted to global when seen in 2+ projects
+
+## Works With
+
+- Claude Code (full support: skill + hooks + MCP server)
+- Cursor, Zed, Windsurf, VS Code (MCP server)
+- Codex, Gemini CLI, OpenClaw (skill only)
+- Any LLM (paste SKILL.md into system prompt)
+
+## Links
+
+- GitHub: https://github.com/naimkatiman/continuous-improvement
+- npm: https://www.npmjs.com/package/continuous-improvement
+- Skill file: https://raw.githubusercontent.com/naimkatiman/continuous-improvement/main/SKILL.md

package/package.json

@@ -1,40 +1,63 @@
 {
   "name": "continuous-improvement",
-  "version": "2.2.0",
-  "description": "7-law discipline framework with auto-leveling instinct learning for AI agents — research, plan, execute, verify, reflect, learn, iterate",
+  "version": "3.1.0",
+  "description": "The 7 Laws of AI Agent Discipline — stop your agent from skipping steps, guessing, and declaring 'done' without verifying. Auto-leveling instinct learning with MCP server, GitHub Action transcript linter, and starter instinct packs for Claude Code, Cursor, Codex, Gemini CLI.",
   "keywords": [
-    "ai-agent",
     "claude-code",
+    "claude-code-skill",
+    "ai-agent",
+    "agent-skill",
     "codex",
-    "openclaw",
     "cursor",
-    "skill",
-    "continuous-improvement",
+    "gemini-cli",
+    "ai-discipline",
     "workflow",
     "productivity",
     "mulahazah",
     "instinct",
     "learning",
-    "hooks"
+    "hooks",
+    "continuous-improvement",
+    "mcp",
+    "mcp-server",
+    "plugin",
+    "github-action",
+    "transcript-linter",
+    "agent-discipline",
+    "developer-tools",
+    "anthropic",
+    "llm"
   ],
   "author": "naimkatiman",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/naimkatiman/continuous-improvement"
+    "url": "git+https://github.com/naimkatiman/continuous-improvement.git"
   },
   "homepage": "https://github.com/naimkatiman/continuous-improvement#readme",
+  "bugs": {
+    "url": "https://github.com/naimkatiman/continuous-improvement/issues"
+  },
   "bin": {
-    "continuous-improvement": "./bin/install.mjs"
+    "continuous-improvement": "bin/install.mjs",
+    "ci-lint-transcript": "bin/lint-transcript.mjs"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "lint": "node bin/lint-transcript.mjs --help"
   },
   "files": [
     "SKILL.md",
     "QUICKSTART.md",
     "CHANGELOG.md",
     "README.md",
+    "llms.txt",
+    "action.yml",
     "bin/",
     "hooks/",
-    "commands/"
+    "commands/",
+    "plugins/",
+    "instinct-packs/"
   ],
   "type": "module"
 }

package/plugins/beginner.json

@@ -0,0 +1,42 @@
+{
+  "name": "continuous-improvement",
+  "version": "3.1.0",
+  "mode": "beginner",
+  "description": "3 simple tools: check status, view instincts, reflect on sessions. No config needed.",
+  "tools": [
+    {
+      "name": "ci_status",
+      "what": "See what the system has learned about your project"
+    },
+    {
+      "name": "ci_instincts",
+      "what": "List all learned behaviors with confidence levels"
+    },
+    {
+      "name": "ci_reflect",
+      "what": "Reflect on what you did this session"
+    }
+  ],
+  "setup": {
+    "claude_desktop": {
+      "mcpServers": {
+        "continuous-improvement": {
+          "command": "node",
+          "args": ["<install-path>/bin/mcp-server.mjs", "--mode", "beginner"]
+        }
+      }
+    },
+    "claude_code": {
+      "mcpServers": {
+        "continuous-improvement": {
+          "command": "node",
+          "args": ["<install-path>/bin/mcp-server.mjs", "--mode", "beginner"]
+        }
+      }
+    }
+  },
+  "hooks": {
+    "included": ["PreToolUse", "PostToolUse"],
+    "description": "Silently captures every tool call as observations. <50ms, never blocks."
+  }
+}

package/plugins/expert.json

@@ -0,0 +1,70 @@
+{
+  "name": "continuous-improvement",
+  "version": "3.1.0",
+  "mode": "expert",
+  "description": "Full plugin: 10 tools including instinct management, import/export, observation viewer, dashboard, and instinct packs.",
+  "tools": [
+    {
+      "name": "ci_status",
+      "what": "See what the system has learned about your project"
+    },
+    {
+      "name": "ci_instincts",
+      "what": "List all learned behaviors with confidence levels"
+    },
+    {
+      "name": "ci_reflect",
+      "what": "Reflect on what you did this session"
+    },
+    {
+      "name": "ci_reinforce",
+      "what": "Accept or reject instinct suggestions to tune confidence"
+    },
+    {
+      "name": "ci_create_instinct",
+      "what": "Manually create instincts with custom triggers and confidence"
+    },
+    {
+      "name": "ci_observations",
+      "what": "View raw tool call observations captured by hooks"
+    },
+    {
+      "name": "ci_export",
+      "what": "Export instincts as JSON for sharing or backup"
+    },
+    {
+      "name": "ci_import",
+      "what": "Import instincts from JSON (skip duplicates)"
+    },
+    {
+      "name": "ci_dashboard",
+      "what": "Visual dashboard showing instinct health, confidence distribution, and learning progress"
+    },
+    {
+      "name": "ci_load_pack",
+      "what": "Load starter instinct packs (react, python, go) into the current project"
+    }
+  ],
+  "setup": {
+    "claude_desktop": {
+      "mcpServers": {
+        "continuous-improvement": {
+          "command": "node",
+          "args": ["<install-path>/bin/mcp-server.mjs", "--mode", "expert"]
+        }
+      }
+    },
+    "claude_code": {
+      "mcpServers": {
+        "continuous-improvement": {
+          "command": "node",
+          "args": ["<install-path>/bin/mcp-server.mjs", "--mode", "expert"]
+        }
+      }
+    }
+  },
+  "hooks": {
+    "included": ["PreToolUse", "PostToolUse", "SessionStart", "SessionEnd"],
+    "description": "Full hook suite: observation capture + session-level instinct loading and auto-reflection."
+  }
+}