continuous-improvement 1.0.0 → 2.1.0

package/package.json

@@ -1,23 +1,40 @@
 {
   "name": "continuous-improvement",
-  "version": "1.0.0",
-  "description": "Install structured self-improvement loops with instinct-based learning into Claude Code — research, plan, execute, verify, reflect, learn, iterate.",
+  "version": "2.1.0",
+  "description": "7-law discipline framework with auto-leveling instinct learning for AI agents — research, plan, execute, verify, reflect, learn, iterate",
+  "keywords": [
+    "ai-agent",
+    "claude-code",
+    "codex",
+    "openclaw",
+    "cursor",
+    "skill",
+    "continuous-improvement",
+    "workflow",
+    "productivity",
+    "mulahazah",
+    "instinct",
+    "learning",
+    "hooks"
+  ],
+  "author": "naimkatiman",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/naimkatiman/continuous-improvement"
+  },
+  "homepage": "https://github.com/naimkatiman/continuous-improvement#readme",
   "bin": {
-    "continuous-improvement": "scripts/install.js"
+    "continuous-improvement": "./bin/install.mjs"
   },
   "files": [
-    "scripts/",
-    "prompts/",
-    "skills/",
-    "hooks/",
-    "agents/",
-    "config.json",
+    "SKILL.md",
+    "QUICKSTART.md",
+    "CHANGELOG.md",
     "README.md",
-    "LICENSE",
-    "docs/"
+    "bin/",
+    "hooks/",
+    "commands/"
   ],
-  "engines": {
-    "node": ">=18"
-  }
+  "type": "module"
 }

package/agents/observer-loop.sh

@@ -1,282 +0,0 @@
-#!/usr/bin/env bash
-# observer-loop.sh — Mulahazah background observer loop
-# Periodically analyzes observation logs and generates instincts via Haiku.
-# Started by start-observer.sh. Should not be invoked directly.
-
-set -euo pipefail
-
-MULAHAZAH_DIR="${HOME}/.claude/mulahazah"
-CONFIG_FILE="${MULAHAZAH_DIR}/config.json"
-PROJECTS_DIR="${MULAHAZAH_DIR}/projects"
-INSTINCTS_DIR="${MULAHAZAH_DIR}/instincts"
-OBSERVER_PROMPT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/observer.md"
-LOG_FILE="${MULAHAZAH_DIR}/observer.log"
-
-# ---------------------------------------------------------------------------
-# Logging
-# ---------------------------------------------------------------------------
-log() {
-  local level="$1"; shift
-  printf '[%s] [%s] %s\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" "$level" "$*" >> "$LOG_FILE"
-}
-
-# ---------------------------------------------------------------------------
-# Read config values (with defaults)
-# ---------------------------------------------------------------------------
-read_config() {
-  local key="$1"
-  local default="$2"
-  if [[ -f "$CONFIG_FILE" ]]; then
-    local val
-    val="$(jq -r "${key} // empty" "$CONFIG_FILE" 2>/dev/null || true)"
-    if [[ -n "$val" && "$val" != "null" ]]; then
-      printf '%s' "$val"
-      return
-    fi
-  fi
-  printf '%s' "$default"
-}
-
-# ---------------------------------------------------------------------------
-# Signal handling
-# ---------------------------------------------------------------------------
-FORCE_RUN=false
-SHUTDOWN=false
-
-handle_sigterm() {
-  log INFO "Received SIGTERM — shutting down gracefully"
-  SHUTDOWN=true
-}
-
-handle_sigusr1() {
-  log INFO "Received SIGUSR1 — forcing immediate analysis run"
-  FORCE_RUN=true
-}
-
-trap handle_sigterm SIGTERM
-trap handle_sigusr1 SIGUSR1
-
-# ---------------------------------------------------------------------------
-# Analyze a single project directory
-# ---------------------------------------------------------------------------
-analyze_project() {
-  local project_dir="$1"
-  local obs_file="${project_dir}/observations.jsonl"
-  local project_json="${project_dir}/project.json"
-
-  [[ -f "$obs_file" ]] || return 0
-
-  local obs_count
-  obs_count="$(wc -l < "$obs_file" 2>/dev/null || echo 0)"
-
-  local min_obs
-  min_obs="$(read_config '.observer.min_observations_to_analyze' '20')"
-
-  if (( obs_count < min_obs )); then
-    log DEBUG "Skipping ${project_dir} — only ${obs_count} observations (min: ${min_obs})"
-    return 0
-  fi
-
-  local project_id project_name
-  project_id="$(basename "$project_dir")"
-  project_name="$(jq -r '.name // "unknown"' "$project_json" 2>/dev/null || echo "unknown")"
-
-  log INFO "Analyzing project '${project_name}' (${project_id}) — ${obs_count} observations"
-
-  # Build the prompt payload for claude
-  local prompt
-  prompt="$(cat <<PROMPT
-You are the Mulahazah observer agent. Analyze the following observation data and existing instincts.
-
-## Project
-ID: ${project_id}
-Name: ${project_name}
-
-## Observations (last 500 lines of observations.jsonl)
-$(tail -500 "$obs_file" 2>/dev/null || true)
-
-## Existing Instincts
-$(ls "${INSTINCTS_DIR}/${project_id}/"*.yaml 2>/dev/null | xargs -I{} cat {} 2>/dev/null || echo "(none)")
-
-## Global Instincts
-$(ls "${INSTINCTS_DIR}/global/"*.yaml 2>/dev/null | xargs -I{} cat {} 2>/dev/null || echo "(none)")
-
-Follow the instructions in your system prompt. Output only YAML instinct blocks.
-PROMPT
-)"
-
-  # Run claude with observer.md as the system prompt
-  local output
-  output="$(printf '%s' "$prompt" | \
-    claude --model haiku --print --system-prompt "$OBSERVER_PROMPT" 2>>"$LOG_FILE" || true)"
-
-  if [[ -z "$output" ]]; then
-    log WARN "No output from observer for project '${project_name}'"
-    return 0
-  fi
-
-  # Write instincts to disk
-  write_instincts "$output" "$project_id"
-}
-
-# ---------------------------------------------------------------------------
-# Analyze global observations
-# ---------------------------------------------------------------------------
-analyze_global() {
-  local global_dir="${PROJECTS_DIR}/global"
-  local obs_file="${global_dir}/observations.jsonl"
-
-  [[ -f "$obs_file" ]] || return 0
-
-  local obs_count
-  obs_count="$(wc -l < "$obs_file" 2>/dev/null || echo 0)"
-
-  local min_obs
-  min_obs="$(read_config '.observer.min_observations_to_analyze' '20')"
-
-  if (( obs_count < min_obs )); then
-    log DEBUG "Skipping global observations — only ${obs_count} lines (min: ${min_obs})"
-    return 0
-  fi
-
-  log INFO "Analyzing global observations — ${obs_count} lines"
-
-  local prompt
-  prompt="$(cat <<PROMPT
-You are the Mulahazah observer agent. Analyze the following global observation data.
-
-## Global Observations (last 500 lines)
-$(tail -500 "$obs_file" 2>/dev/null || true)
-
-## Existing Global Instincts
-$(ls "${INSTINCTS_DIR}/global/"*.yaml 2>/dev/null | xargs -I{} cat {} 2>/dev/null || echo "(none)")
-
-Follow the instructions in your system prompt. Output only YAML instinct blocks with scope: global.
-PROMPT
-)"
-
-  local output
-  output="$(printf '%s' "$prompt" | \
-    claude --model haiku --print --system-prompt "$OBSERVER_PROMPT" 2>>"$LOG_FILE" || true)"
-
-  if [[ -z "$output" ]]; then
-    log WARN "No output from observer for global observations"
-    return 0
-  fi
-
-  write_instincts "$output" "global"
-}
-
-# ---------------------------------------------------------------------------
-# Parse and write instinct YAML blocks to disk
-# ---------------------------------------------------------------------------
-write_instincts() {
-  local yaml_output="$1"
-  local project_id="$2"
-
-  # Split on --- separators and process each block
-  local instinct_dir="${INSTINCTS_DIR}/${project_id}"
-  mkdir -p "$instinct_dir"
-
-  # Write raw output to a temp file, then split by ---
-  local tmpfile
-  tmpfile="$(mktemp)"
-  printf '%s' "$yaml_output" > "$tmpfile"
-
-  # Use awk to split YAML documents on '---' separator
-  awk 'BEGIN{n=0; block=""} /^---$/{if(block!=""){print block > "/tmp/mulahazah_instinct_"n".yaml"; n++; block=""}} !/^---$/{block=block"\n"$0} END{if(block!=""){print block > "/tmp/mulahazah_instinct_"n".yaml"}}' "$tmpfile"
-
-  local written=0
-  for instinct_file in /tmp/mulahazah_instinct_*.yaml; do
-    [[ -f "$instinct_file" ]] || continue
-
-    # Extract the instinct id
-    local instinct_id
-    instinct_id="$(grep -m1 '^id:' "$instinct_file" | sed 's/^id: *//' | tr -d '"' | tr -d "'" | xargs 2>/dev/null || true)"
-
-    if [[ -z "$instinct_id" ]]; then
-      log WARN "Skipping instinct block with no id"
-      rm -f "$instinct_file"
-      continue
-    fi
-
-    local dest="${instinct_dir}/${instinct_id}.yaml"
-    mv "$instinct_file" "$dest"
-    log INFO "Wrote instinct '${instinct_id}' to ${dest}"
-    (( written++ )) || true
-  done
-
-  # Clean up any leftover temp files
-  rm -f /tmp/mulahazah_instinct_*.yaml "$tmpfile"
-
-  log INFO "Wrote ${written} instincts for project '${project_id}'"
-}
-
-# ---------------------------------------------------------------------------
-# Main loop
-# ---------------------------------------------------------------------------
-main() {
-  log INFO "Mulahazah observer loop started (PID $$)"
-
-  # Validate dependencies
-  command -v jq &>/dev/null || { log ERROR "jq not found — observer cannot run"; exit 1; }
-  command -v claude &>/dev/null || { log ERROR "claude CLI not found — observer cannot run"; exit 1; }
-  [[ -f "$OBSERVER_PROMPT" ]] || { log ERROR "observer.md not found at ${OBSERVER_PROMPT}"; exit 1; }
-
-  # Ensure instincts directory exists
-  mkdir -p "${INSTINCTS_DIR}/global"
-
-  while true; do
-    # Check if observer is enabled
-    local enabled
-    enabled="$(read_config '.observer.enabled' 'true')"
-    if [[ "$enabled" != "true" ]]; then
-      log INFO "Observer is disabled in config — sleeping"
-      sleep 60
-      [[ "$SHUTDOWN" == "true" ]] && break
-      continue
-    fi
-
-    if [[ "$FORCE_RUN" == "true" || "$SHUTDOWN" == "false" ]]; then
-      FORCE_RUN=false
-      log INFO "Starting analysis run"
-
-      # Analyze each project directory
-      if [[ -d "$PROJECTS_DIR" ]]; then
-        for project_dir in "${PROJECTS_DIR}"/*/; do
-          [[ -d "$project_dir" ]] || continue
-          [[ "$(basename "$project_dir")" == "global" ]] && continue
-          analyze_project "$project_dir" || log WARN "Analysis failed for ${project_dir}"
-          [[ "$SHUTDOWN" == "true" ]] && break
-        done
-      fi
-
-      # Analyze global observations
-      analyze_global || log WARN "Global analysis failed"
-
-      log INFO "Analysis run complete"
-    fi
-
-    [[ "$SHUTDOWN" == "true" ]] && break
-
-    # Sleep for the configured interval
-    local interval_minutes
-    interval_minutes="$(read_config '.observer.run_interval_minutes' '5')"
-    local interval_seconds=$(( interval_minutes * 60 ))
-
-    log DEBUG "Sleeping for ${interval_minutes} minutes"
-
-    # Sleep in 1-second chunks to remain responsive to signals
-    local elapsed=0
-    while (( elapsed < interval_seconds )); do
-      sleep 1
-      (( elapsed++ )) || true
-      [[ "$SHUTDOWN" == "true" ]] && break
-      [[ "$FORCE_RUN" == "true" ]] && break
-    done
-  done
-
-  log INFO "Mulahazah observer loop exiting"
-}
-
-main "$@"

package/agents/observer.md

@@ -1,145 +0,0 @@
----
-name: mulahazah-observer
-description: Background analysis agent that reads raw tool observations and distills them into actionable instincts. Runs on a Haiku model for cost efficiency. Identifies patterns, user preferences, and recurring workflows from JSONL observation logs.
-model: haiku
----
-
-# Mulahazah Observer — Background Analysis Agent
-
-You are the Mulahazah observer. Your job is to analyze raw tool-use observations recorded by the `observe.sh` hook and extract reusable instincts that improve future Claude Code sessions.
-
-You run in the background, periodically. You are cost-sensitive (Haiku model). Be concise and conservative.
-
----
-
-## Inputs
-
-You will be given:
-1. The path to `observations.jsonl` for a project (or global observations)
-2. The path to existing instincts (YAML files in `~/.claude/mulahazah/instincts/`)
-3. The project metadata from `project.json` (if available)
-
-Read these files and analyze the patterns within.
-
----
-
-## Pattern Detection Rules
-
-Scan observations for these signal types, in priority order:
-
-### 1. User Corrections (highest signal)
-- A tool call was made, then immediately followed by an Edit or Write that undoes or modifies what was just produced
-- The same tool is called with a different argument within the same session after an error
-- A `Bash` command fails (non-zero exit in output) and is retried with a modified form
-
-### 2. Error Resolutions
-- A tool produces an error, followed by a sequence of tools that resolves it
-- The resolution sequence is compact (3–7 tool calls) and clearly purposeful
-- Extract the resolution pattern as a workflow instinct
-
-### 3. Repeated Workflows
-- The same sequence of 3+ tool calls appears in 3+ sessions
-- Order matters — a repeated sequence is only a pattern if the tools appear in the same relative order
-- Common examples: `Bash(git status)` → `Bash(git diff)` → `Bash(git commit)`, or `Read` → `Edit` → `Bash(npm run build)`
-
-### 4. Tool Preferences
-- User consistently uses one tool over a functionally equivalent alternative
-- Example: always uses `Bash(rg ...)` via the Grep tool rather than raw `Bash(grep ...)`
-- Example: always uses `Edit` for single-file changes, never `Write` on existing files
-- Capture these as style or workflow instincts
-
-### 5. Rejected Suggestions
-- A tool call produces output, session ends shortly after without using the output
-- Or an Edit is immediately reverted in the next tool call
-- These indicate something to avoid — create a negative instinct (what not to do)
-
----
-
-## Scope Decision Guide
-
-Assign scope based on these rules:
-
-| Condition | Scope |
-|-----------|-------|
-| Pattern appears in only one project's observations | `project` |
-| Pattern appears in 3+ different projects | `global` |
-| Pattern involves language/framework-specific behavior | `project` (unless 3+ projects use same stack) |
-| Pattern involves user meta-habits (git, file editing, tool choice) | `global` |
-| Pattern involves project naming, directory structure, specific paths | `project` |
-| Uncertain | default to `project` |
-
----
-
-## Instinct YAML Format
-
-Output each new instinct as a YAML block. Do not wrap in markdown code fences — output raw YAML only, one instinct per file.
-
-```yaml
-id: <kebab-case-id>
-title: <short human-readable title, max 60 chars>
-scope: project | global
-project_id: <12-char hash if scope=project, omit if global>
-domain: <one of: code-style, testing, git, debugging, workflow, security, architecture>
-confidence: <float 0.0–0.85>
-observation_count: <number of observations supporting this instinct>
-last_seen: <ISO 8601 date>
-content: |
-  <The instinct text. Written as a direct instruction to Claude.
-  Max 5 sentences. No raw code snippets. No file paths unless abstract.
-  Use imperative voice. Example: "When editing TypeScript files, always
-  check for existing type aliases before creating new ones.">
-tags:
-  - <tag1>
-  - <tag2>
-```
-
----
-
-## Confidence Rules
-
-- **Never set confidence above 0.85** from observation data alone. Human review is required to reach 0.9.
-- **Confidence cap is 0.9** — no instinct may ever exceed this value.
-- Start new instincts at confidence 0.4–0.6 based on evidence strength:
-  - 3–5 supporting observations: 0.4
-  - 6–10 supporting observations: 0.55
-  - 11–20 supporting observations: 0.65
-  - 21+ supporting observations: 0.75
-  - Strong signal (user correction or error resolution): add 0.1 bonus, capped at 0.85
-- **Decay rules** — reduce confidence by 0.05 if:
-  - The instinct was not observed in the last 30 days
-  - The instinct was observed but then contradicted (a counter-example appeared)
-  - The session count for the project drops to zero for 60+ days
-
----
-
-## Domain Tags
-
-Use exactly one domain per instinct:
-
-| Domain | Covers |
-|--------|--------|
-| `code-style` | Formatting, naming, language idioms, linting preferences |
-| `testing` | Test frameworks, coverage, test file conventions |
-| `git` | Commit messages, branch naming, staging habits |
-| `debugging` | Error resolution sequences, diagnostic tool preferences |
-| `workflow` | Multi-step task sequences, tool ordering preferences |
-| `security` | Auth patterns, secret handling, input validation |
-| `architecture` | File structure, module boundaries, design patterns |
-
----
-
-## Observer Rules
-
-1. **Be conservative.** It is better to produce no instinct than a wrong instinct. Only emit an instinct if you have clear, repeated evidence.
-
-2. **Merge similar instincts.** If a new pattern is substantially similar to an existing instinct (same domain, same behavior), increase `observation_count` and update `confidence` on the existing instinct rather than creating a duplicate.
-
-3. **Default to project scope.** When in doubt about scope, use `project`. Promotion to global scope should only happen when the same pattern is confirmed across multiple distinct projects.
-
-4. **No raw code in instinct content.** Instinct content must be natural language instructions. Never embed shell commands, code snippets, or file paths in the `content` field. Use abstract descriptions instead.
-
-5. **No hallucinated patterns.** Only describe patterns you can trace to specific observation lines. If you cannot point to concrete evidence, do not emit the instinct.
-
-6. **Respect existing instincts.** Before creating a new instinct, check the existing instinct files. Do not duplicate, do not contradict without strong evidence.
-
-7. **Output only YAML.** Your output must be valid YAML instinct blocks (one per instinct) separated by `---`. Do not include explanatory text, markdown, or commentary in your output — only the YAML instincts ready to be written to disk.

package/agents/start-observer.sh

@@ -1,115 +0,0 @@
-#!/usr/bin/env bash
-# start-observer.sh — Start the Mulahazah background observer
-# Checks for an existing instance, cleans up stale PIDs, and launches observer-loop.sh.
-
-set -euo pipefail
-
-MULAHAZAH_DIR="${HOME}/.claude/mulahazah"
-PID_FILE="${MULAHAZAH_DIR}/observer.pid"
-LOG_FILE="${MULAHAZAH_DIR}/observer.log"
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-LOOP_SCRIPT="${SCRIPT_DIR}/observer-loop.sh"
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-print_status() {
-  local pid="$1"
-  echo "Mulahazah observer is running (PID ${pid})"
-  echo ""
-  echo "  Force immediate analysis:  kill -USR1 ${pid}"
-  echo "  Stop observer:             kill ${pid}"
-  echo "  View logs:                 tail -f ${LOG_FILE}"
-  echo "  PID file:                  ${PID_FILE}"
-}
-
-# ---------------------------------------------------------------------------
-# Validate dependencies
-# ---------------------------------------------------------------------------
-if ! command -v jq &>/dev/null; then
-  echo "Error: jq is required but not installed." >&2
-  exit 1
-fi
-
-if ! command -v claude &>/dev/null; then
-  echo "Error: claude CLI is required but not installed." >&2
-  exit 1
-fi
-
-if [[ ! -f "$LOOP_SCRIPT" ]]; then
-  echo "Error: observer-loop.sh not found at ${LOOP_SCRIPT}" >&2
-  exit 1
-fi
-
-# ---------------------------------------------------------------------------
-# Check for existing running instance
-# ---------------------------------------------------------------------------
-if [[ -f "$PID_FILE" ]]; then
-  EXISTING_PID="$(cat "$PID_FILE" 2>/dev/null || true)"
-
-  if [[ -n "$EXISTING_PID" ]] && kill -0 "$EXISTING_PID" 2>/dev/null; then
-    # Process is alive
-    echo "Mulahazah observer is already running."
-    echo ""
-    print_status "$EXISTING_PID"
-    exit 0
-  else
-    # Stale PID file — process is gone
-    echo "Cleaning up stale PID file (PID ${EXISTING_PID:-unknown} is no longer running)"
-    rm -f "$PID_FILE"
-  fi
-fi
-
-# ---------------------------------------------------------------------------
-# Ensure Mulahazah directory structure exists
-# ---------------------------------------------------------------------------
-mkdir -p "${MULAHAZAH_DIR}/projects"
-mkdir -p "${MULAHAZAH_DIR}/instincts/global"
-
-# ---------------------------------------------------------------------------
-# Initialize config.json if it doesn't exist
-# ---------------------------------------------------------------------------
-CONFIG_FILE="${MULAHAZAH_DIR}/config.json"
-if [[ ! -f "$CONFIG_FILE" ]]; then
-  # Check if a repo-level config exists next to this script's parent
-  REPO_CONFIG="$(dirname "$SCRIPT_DIR")/config.json"
-  if [[ -f "$REPO_CONFIG" ]]; then
-    cp "$REPO_CONFIG" "$CONFIG_FILE"
-    echo "Initialized config from ${REPO_CONFIG}"
-  else
-    cat > "$CONFIG_FILE" <<'EOF'
-{
-  "version": "2.0",
-  "observer": {
-    "enabled": true,
-    "run_interval_minutes": 5,
-    "min_observations_to_analyze": 20,
-    "model": "haiku"
-  }
-}
-EOF
-    echo "Created default config at ${CONFIG_FILE}"
-  fi
-fi
-
-# ---------------------------------------------------------------------------
-# Launch observer-loop.sh in background with nohup
-# ---------------------------------------------------------------------------
-nohup bash "$LOOP_SCRIPT" >> "$LOG_FILE" 2>&1 &
-OBSERVER_PID=$!
-
-# Write PID file
-printf '%d\n' "$OBSERVER_PID" > "$PID_FILE"
-
-# Brief pause to confirm the process started
-sleep 1
-if ! kill -0 "$OBSERVER_PID" 2>/dev/null; then
-  echo "Error: observer-loop.sh failed to start. Check logs:" >&2
-  echo "  ${LOG_FILE}" >&2
-  rm -f "$PID_FILE"
-  exit 1
-fi
-
-echo "Mulahazah observer started."
-echo ""
-print_status "$OBSERVER_PID"

package/config.json

@@ -1,9 +0,0 @@
-{
-  "version": "2.0",
-  "observer": {
-    "enabled": true,
-    "run_interval_minutes": 5,
-    "min_observations_to_analyze": 20,
-    "model": "haiku"
-  }
-}