continuous-improvement 1.0.0 → 2.1.0

package/bin/analyze.sh

@@ -0,0 +1,115 @@
+#!/usr/bin/env bash
+# analyze.sh — Read observations.jsonl, detect patterns, append rules to rules.md
+# This is the actual analysis pipeline. Runs via /continuous-improvement or observer-loop.
+# Uses claude CLI with Haiku for cost-efficient analysis.
+
+set -euo pipefail
+
+MULAHAZAH_DIR="${HOME}/.claude/mulahazah"
+RULES_FILE="${MULAHAZAH_DIR}/rules.md"
+GLOBAL_OBS="${MULAHAZAH_DIR}/observations.jsonl"
+
+# Detect project
+PROJECT_DIR=""
+PROJECT_OBS=""
+if REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null); then
+  PROJECT_HASH=$(printf '%s' "$REPO_ROOT" | sha256sum | cut -c1-12)
+  PROJECT_DIR="${MULAHAZAH_DIR}/projects/${PROJECT_HASH}"
+  PROJECT_OBS="${PROJECT_DIR}/observations.jsonl"
+fi
+
+# Find observations file
+OBS_FILE=""
+if [ -n "$PROJECT_OBS" ] && [ -f "$PROJECT_OBS" ]; then
+  OBS_FILE="$PROJECT_OBS"
+elif [ -f "$GLOBAL_OBS" ]; then
+  OBS_FILE="$GLOBAL_OBS"
+fi
+
+if [ -z "$OBS_FILE" ] || [ ! -s "$OBS_FILE" ]; then
+  echo "No observations found. Use Claude Code with hooks installed to generate observations."
+  exit 0
+fi
+
+OBS_COUNT=$(wc -l < "$OBS_FILE")
+echo "Found $OBS_COUNT observations in $OBS_FILE"
+
+if [ "$OBS_COUNT" -lt 5 ]; then
+  echo "Need at least 5 observations for meaningful analysis. Keep using Claude Code."
+  exit 0
+fi
+
+# Read existing rules to avoid duplicates
+EXISTING_RULES=""
+if [ -f "$RULES_FILE" ]; then
+  EXISTING_RULES=$(cat "$RULES_FILE")
+fi
+
+# Take last 200 observations (keep prompt size manageable)
+RECENT_OBS=$(tail -200 "$OBS_FILE")
+
+# Build analysis prompt
+ANALYSIS_PROMPT="Analyze these Claude Code session observations and extract behavioral patterns.
+
+OBSERVATIONS (JSONL — each line is a tool call):
+${RECENT_OBS}
+
+EXISTING RULES (already learned — do NOT duplicate these):
+${EXISTING_RULES}
+
+YOUR TASK:
+1. Look for REPEATED PATTERNS — same tool sequence used 3+ times
+2. Look for ERROR-THEN-FIX sequences — tool fails, next tools fix it
+3. Look for TOOL PREFERENCES — one tool consistently chosen over alternatives
+4. Look for WORKFLOW PATTERNS — consistent ordering of operations
+
+OUTPUT FORMAT — output ONLY new rules, one per line, as markdown list items:
+- Rule: [specific actionable rule based on observed pattern]
+
+Rules must be:
+- Specific and actionable (not vague advice)
+- Based on actual observed patterns (cite the tools/sequence you saw)
+- Different from existing rules listed above
+- Useful for future sessions
+
+If no new patterns are found, output exactly: NO_NEW_PATTERNS
+
+Output ONLY the rules list or NO_NEW_PATTERNS. No explanation, no preamble."
+
+# Run analysis with Haiku
+echo "Analyzing patterns with Haiku..."
+RESULT=$(echo "$ANALYSIS_PROMPT" | claude --model haiku --print -p - 2>/dev/null) || {
+  echo "Analysis failed — claude CLI error. Try running manually."
+  exit 1
+}
+
+if [ "$RESULT" = "NO_NEW_PATTERNS" ] || [ -z "$RESULT" ]; then
+  echo "No new patterns detected yet. Keep using Claude Code — patterns emerge over time."
+  exit 0
+fi
+
+# Append new rules to rules.md
+echo "" >> "$RULES_FILE" 2>/dev/null || true
+mkdir -p "$(dirname "$RULES_FILE")"
+{
+  if [ ! -f "$RULES_FILE" ]; then
+    echo "# Learned Rules"
+    echo ""
+    echo "Rules extracted from session observations by Mulahazah."
+    echo "Remove any rule that causes problems. Keep what helps."
+    echo ""
+    echo "---"
+    echo ""
+  fi
+  echo "## $(date +%Y-%m-%d) analysis"
+  echo ""
+  echo "$RESULT"
+  echo ""
+} >> "$RULES_FILE"
+
+# Count new rules
+NEW_COUNT=$(echo "$RESULT" | grep -c "^- " || true)
+echo ""
+echo "Added $NEW_COUNT new rules to $RULES_FILE"
+echo ""
+echo "$RESULT"

package/bin/install.mjs

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+
+/**
+ * continuous-improvement installer
+ *
+ * Usage:
+ *   npx continuous-improvement install                # auto-detect & install
+ *   npx continuous-improvement install --target claude # install to ~/.claude/skills/ + Mulahazah
+ *   npx continuous-improvement install --target openclaw # install to ~/.openclaw/skills/
+ *   npx continuous-improvement install --target cursor # install to ~/.cursor/skills/
+ *   npx continuous-improvement install --target all    # install to all detected targets
+ *   npx continuous-improvement install --uninstall     # remove from all targets
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  copyFileSync,
+  readFileSync,
+  writeFileSync,
+  rmSync,
+  chmodSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const SKILL_SOURCE = join(__dirname, "..", "SKILL.md");
+const SKILL_NAME = "continuous-improvement";
+const REPO_ROOT = join(__dirname, "..");
+
+const TARGETS = {
+  claude: {
+    label: "Claude Code",
+    dir: join(homedir(), ".claude", "skills", SKILL_NAME),
+  },
+  openclaw: {
+    label: "OpenClaw",
+    dir: join(homedir(), ".openclaw", "skills", SKILL_NAME),
+  },
+  cursor: {
+    label: "Cursor",
+    dir: join(homedir(), ".cursor", "skills", SKILL_NAME),
+  },
+  codex: {
+    label: "Codex",
+    dir: join(homedir(), ".codex", "skills", SKILL_NAME),
+  },
+};
+
+function detectTargets() {
+  const detected = [];
+  for (const [key, target] of Object.entries(TARGETS)) {
+    const parentDir = dirname(target.dir);
+    const configDir = dirname(parentDir);
+    if (existsSync(configDir)) {
+      detected.push(key);
+    }
+  }
+  return detected;
+}
+
+function installTo(key) {
+  const target = TARGETS[key];
+  if (!target) {
+    console.error(`  Unknown target: ${key}`);
+    return false;
+  }
+
+  try {
+    mkdirSync(target.dir, { recursive: true });
+    copyFileSync(SKILL_SOURCE, join(target.dir, "SKILL.md"));
+    console.log(`  ✓ ${target.label} → ${target.dir}/SKILL.md`);
+
+    if (key === "claude") {
+      setupMulahazah();
+    }
+
+    return true;
+  } catch (err) {
+    console.error(`  ✗ ${target.label}: ${err.message}`);
+    return false;
+  }
+}
+
+function setupMulahazah() {
+  const home = homedir();
+  const instinctsDir = join(home, ".claude", "instincts");
+  const globalDir = join(instinctsDir, "global");
+
+  // 1. Create directory structure
+  mkdirSync(globalDir, { recursive: true });
+  console.log(`  ✓ Instincts dir → ${instinctsDir}/`);
+
+  // 2. Copy observe.sh and make executable
+  const observeSrc = join(REPO_ROOT, "hooks", "observe.sh");
+  const observeDest = join(instinctsDir, "observe.sh");
+  if (existsSync(observeSrc)) {
+    copyFileSync(observeSrc, observeDest);
+    chmodSync(observeDest, 0o755);
+    console.log(`  ✓ observe.sh → ${observeDest}`);
+  }
+
+  // 3. Copy /continuous-improvement command
+  const commandsDir = join(home, ".claude", "commands");
+  mkdirSync(commandsDir, { recursive: true });
+  const cmdSrc = join(REPO_ROOT, "commands", "continuous-improvement.md");
+  const cmdDest = join(commandsDir, "continuous-improvement.md");
+  if (existsSync(cmdSrc)) {
+    copyFileSync(cmdSrc, cmdDest);
+    console.log(`  ✓ /continuous-improvement command → ${cmdDest}`);
+  }
+
+  // 4. Patch ~/.claude/settings.json with hooks
+  patchClaudeSettings(observeDest);
+}
+
+function patchClaudeSettings(observePath) {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+    } catch {
+      console.warn(`  ! Could not parse ${settingsPath} — skipping hook patch`);
+      return;
+    }
+  }
+
+  if (!settings.hooks) settings.hooks = {};
+
+  const hookEntry = {
+    matcher: "",
+    hooks: [
+      {
+        type: "command",
+        command: `bash "${observePath}"`,
+      },
+    ],
+  };
+
+  let changed = false;
+
+  for (const hookType of ["PreToolUse", "PostToolUse"]) {
+    if (!Array.isArray(settings.hooks[hookType])) {
+      settings.hooks[hookType] = [];
+    }
+    const alreadyPatched = settings.hooks[hookType].some(
+      (h) =>
+        Array.isArray(h.hooks) &&
+        h.hooks.some((hh) => hh.command && hh.command.includes("observe.sh"))
+    );
+    if (!alreadyPatched) {
+      settings.hooks[hookType].push(hookEntry);
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    console.log(`  ✓ Patched ~/.claude/settings.json with PreToolUse/PostToolUse hooks`);
+  } else {
+    console.log(`  ✓ settings.json already has observe.sh hooks — no change needed`);
+  }
+}
+
+function uninstallAll() {
+  console.log("\nUninstalling continuous-improvement skill...\n");
+  let removed = 0;
+  for (const [key, target] of Object.entries(TARGETS)) {
+    const skillFile = join(target.dir, "SKILL.md");
+    if (existsSync(skillFile)) {
+      try {
+        rmSync(target.dir, { recursive: true });
+        console.log(`  ✓ Removed from ${target.label}`);
+        removed++;
+      } catch (err) {
+        console.error(`  ✗ ${target.label}: ${err.message}`);
+      }
+    }
+  }
+  if (removed === 0) {
+    console.log("  No installations found.");
+  }
+  console.log();
+}
+
+function printUsage() {
+  console.log(`
+Usage: npx continuous-improvement install [options]
+
+Options:
+  --target <name>   Install to specific target (claude, openclaw, cursor, codex, all)
+  --uninstall       Remove from all targets
+  --help            Show this help
+
+Examples:
+  npx continuous-improvement install              # auto-detect & install
+  npx continuous-improvement install --target all  # install everywhere
+  npx continuous-improvement install --uninstall   # remove all
+`);
+}
+
+// --- Main ---
+
+const args = process.argv.slice(2);
+
+if (args.includes("--help") || args.includes("-h")) {
+  printUsage();
+  process.exit(0);
+}
+
+if (args.includes("--uninstall")) {
+  uninstallAll();
+  process.exit(0);
+}
+
+console.log(`
+continuous-improvement v2.1
+Research → Plan → Execute → Verify → Reflect → Learn → Iterate
+`);
+
+const targetIdx = args.indexOf("--target");
+let targets;
+
+if (targetIdx !== -1 && args[targetIdx + 1]) {
+  const requested = args[targetIdx + 1].toLowerCase();
+  if (requested === "all") {
+    targets = Object.keys(TARGETS);
+  } else if (TARGETS[requested]) {
+    targets = [requested];
+  } else {
+    console.error(`Unknown target: ${requested}`);
+    console.error(`Available: ${Object.keys(TARGETS).join(", ")}, all`);
+    process.exit(1);
+  }
+} else {
+  targets = detectTargets();
+  if (targets.length === 0) {
+    console.log("No supported agent configs detected. Installing to Claude Code by default.\n");
+    targets = ["claude"];
+  } else {
+    console.log(`Detected: ${targets.map((t) => TARGETS[t].label).join(", ")}\n`);
+  }
+}
+
+console.log("Installing...\n");
+
+let installed = 0;
+for (const t of targets) {
+  if (installTo(t)) installed++;
+}
+
+const hasClaude = targets.includes("claude");
+
+console.log(`
+${installed > 0 ? "Done." : "Failed."} Installed to ${installed}/${targets.length} target(s).
+${hasClaude ? "\nHooks are capturing. System auto-levels as you use it." : ""}
+Next steps:
+  1. Start a new Claude Code session
+  2. Say: "Use the continuous-improvement framework to [your task]"
+  3. After your first task, run: /continuous-improvement
+`);

package/commands/continuous-improvement.md

@@ -0,0 +1,74 @@
+---
+name: continuous-improvement
+description: "Reflect on the current session, analyze observations for patterns, and show instinct status. Run after finishing significant work."
+---
+
+# /continuous-improvement
+
+Run this after completing significant work. It does three things in order.
+
+## Step 1: Reflect
+
+Generate a reflection for this session based on what happened:
+
+```
+## Reflection — [Date]
+- What worked:
+- What failed:
+- What I'd do differently:
+- Rule to add:
+```
+
+If there's a "Rule to add", create an instinct YAML file with 0.6 starting confidence in the project's instinct directory.
+
+## Step 2: Analyze Observations
+
+Check `~/.claude/instincts/` for the current project (detect via git root → SHA-256 first 12 chars).
+
+Look at `~/.claude/instincts/<hash>/observations.jsonl`. If 20+ lines exist:
+
+1. Read the last 500 lines
+2. Read existing instinct `*.yaml` files (project + global)
+3. Detect patterns:
+   - User corrections → "don't do X" instincts
+   - Error→fix sequences → "when X fails, try Y"
+   - Repeated workflows (3+ times) → "for X, do A→B→C"
+   - Tool preferences → "use tool Y for task X"
+4. Create/update instinct YAML files
+5. Be conservative: only create instincts for 3+ observations of the same pattern
+
+If fewer than 20 observations, skip analysis and note the count.
+
+## Step 3: Show Status
+
+Display all instincts for the current project + global:
+
+```
+=== continuous-improvement ===
+
+## Level: [CAPTURE | ANALYZE | SUGGEST | AUTO-APPLY]
+
+## Session Reflection
+- What worked: [from this session]
+- What failed: [from this session]
+- What I'd do differently: [from this session]
+- Rule to add: [captured as instinct]
+
+## Learning
+  NEW  [instinct-id]        [domain]  [confidence]  (from reflection)
+   ↑   [instinct-id]        [domain]  [old]→[new]   (+N observations)
+
+## Instincts — [project-name] ([hash])
+  ● [0.85] instinct-id       domain   auto-apply
+  ◐ [0.60] instinct-id       domain   suggest
+  ○ [0.35] instinct-id       domain   silent
+
+## Instincts — global
+  ● [0.90] instinct-id       domain   auto-apply
+
+## Next
+- Keep working — hooks capture automatically
+- System auto-levels as instincts gain confidence
+```
+
+If no instincts or observations exist yet, explain this is expected — the system is in CAPTURE level and will create instincts after 20+ observations accumulate.

package/hooks/observe.sh

@@ -6,12 +6,7 @@
 # Always exit 0 — never block the Claude session
 trap 'exit 0' EXIT ERR INT TERM
 
-# Require jq — if unavailable, silently exit
-command -v jq &>/dev/null || exit 0
-
-MULAHAZAH_DIR="${HOME}/.claude/mulahazah"
-PROJECTS_DIR="${MULAHAZAH_DIR}/projects"
-GLOBAL_REGISTRY="${MULAHAZAH_DIR}/projects.json"
+INSTINCTS_DIR="${HOME}/.claude/instincts"
 
 # ---------------------------------------------------------------------------
 # Read stdin (hook payload) — single read for performance
@@ -20,17 +15,29 @@ INPUT="$(cat)"
 [[ -z "$INPUT" ]] && exit 0
 
 # ---------------------------------------------------------------------------
-# Parse hook payload in one jq call
+# Parse hook payload — use jq if available, otherwise basic extraction
 # ---------------------------------------------------------------------------
-read -r TOOL_NAME SESSION_ID HAS_OUTPUT INPUT_JSON OUTPUT_JSON <<< "$(
-  printf '%s' "$INPUT" | jq -r '
-    (.tool_name // ""),
-    (.session_id // ""),
-    (if has("tool_output") then "yes" else "no" end),
-    ((.tool_input // {} | tostring) | .[0:500]),
-    ((.tool_output // {} | tostring) | .[0:200])
-  ' | paste - - - - -
-)"
+if command -v jq &>/dev/null; then
+  read -r TOOL_NAME SESSION_ID HAS_OUTPUT INPUT_JSON OUTPUT_JSON <<< "$(
+    printf '%s' "$INPUT" | jq -r '
+      (.tool_name // ""),
+      (.session_id // ""),
+      (if has("tool_output") then "yes" else "no" end),
+      ((.tool_input // {} | tostring) | .[0:500]),
+      ((.tool_output // {} | tostring) | .[0:200])
+    ' | paste - - - - -
+  )"
+else
+  # Fallback: extract tool_name with basic pattern matching
+  TOOL_NAME="$(printf '%s' "$INPUT" | sed -n 's/.*"tool_name" *: *"\([^"]*\)".*/\1/p' | head -1)"
+  SESSION_ID="$(printf '%s' "$INPUT" | sed -n 's/.*"session_id" *: *"\([^"]*\)".*/\1/p' | head -1)"
+  HAS_OUTPUT="no"
+  printf '%s' "$INPUT" | grep -q '"tool_output"' && HAS_OUTPUT="yes"
+  INPUT_JSON="$(printf '%s' "$INPUT" | head -c 500)"
+  OUTPUT_JSON=""
+fi
+
+[[ -z "$TOOL_NAME" ]] && exit 0
 
 # Determine event type
 if [[ "$HAS_OUTPUT" == "yes" ]]; then
@@ -40,27 +47,24 @@ else
 fi
 
 # ---------------------------------------------------------------------------
-# Project detection (4 priority levels)
+# Project detection
 # ---------------------------------------------------------------------------
 PROJECT_ROOT=""
 
-# Priority 1: $CLAUDE_PROJECT_DIR env var
 if [[ -n "${CLAUDE_PROJECT_DIR:-}" && -d "${CLAUDE_PROJECT_DIR}" ]]; then
   PROJECT_ROOT="${CLAUDE_PROJECT_DIR}"
 fi
 
-# Priority 2+3: git repo root (covers both remote-url and root-hash priorities)
 if [[ -z "$PROJECT_ROOT" ]]; then
   PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
 fi
 
-# Priority 4: global fallback
 if [[ -z "$PROJECT_ROOT" ]]; then
   PROJECT_ROOT="global"
 fi
 
 # ---------------------------------------------------------------------------
-# Compute project hash and name (SHA-256 first 12 chars)
+# Compute project hash and name
 # ---------------------------------------------------------------------------
 PROJECT_HASH="$(printf '%s' "$PROJECT_ROOT" | sha256sum | cut -c1-12)"
 PROJECT_NAME="$(basename "${PROJECT_ROOT%.git}")"
@@ -68,20 +72,18 @@ PROJECT_NAME="$(basename "${PROJECT_ROOT%.git}")"
 # ---------------------------------------------------------------------------
 # Directory setup
 # ---------------------------------------------------------------------------
-PROJECT_OBS_DIR="${PROJECTS_DIR}/${PROJECT_HASH}"
-OBS_FILE="${PROJECT_OBS_DIR}/observations.jsonl"
+PROJECT_DIR="${INSTINCTS_DIR}/${PROJECT_HASH}"
+OBS_FILE="${PROJECT_DIR}/observations.jsonl"
 
-# Create dirs only if needed (fast no-op if already exists)
-[[ -d "$PROJECT_OBS_DIR" ]] || mkdir -p "${PROJECT_OBS_DIR}/observations.archive"
+[[ -d "$PROJECT_DIR" ]] || mkdir -p "$PROJECT_DIR"
 
 # ---------------------------------------------------------------------------
-# Rotate observations.jsonl if it exceeds 10,000 lines
+# Rotate observations.jsonl at 10,000 lines
 # ---------------------------------------------------------------------------
 if [[ -f "$OBS_FILE" ]]; then
   LINE_COUNT="$(wc -l < "$OBS_FILE")"
   if (( LINE_COUNT >= 10000 )); then
-    ARCHIVE_DATE="$(date -u +"%Y-%m-%d")"
-    mv "$OBS_FILE" "${PROJECT_OBS_DIR}/observations.archive/${ARCHIVE_DATE}.jsonl"
+    mv "$OBS_FILE" "${PROJECT_DIR}/observations.$(date -u +"%Y-%m-%d").jsonl"
   fi
 fi
 
@@ -90,44 +92,43 @@ fi
 # ---------------------------------------------------------------------------
 TS="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
 
-printf '%s\n' "$(jq -cn \
-  --arg ts "$TS" \
-  --arg event "$EVENT" \
-  --arg session "$SESSION_ID" \
-  --arg tool "$TOOL_NAME" \
-  --arg input_summary "$INPUT_JSON" \
-  --arg output_summary "$OUTPUT_JSON" \
-  --arg project_id "$PROJECT_HASH" \
-  --arg project_name "$PROJECT_NAME" \
-  '{ts:$ts,event:$event,session:$session,tool:$tool,input_summary:$input_summary,output_summary:$output_summary,project_id:$project_id,project_name:$project_name}')" \
-  >> "$OBS_FILE"
+if command -v jq &>/dev/null; then
+  printf '%s\n' "$(jq -cn \
+    --arg ts "$TS" \
+    --arg event "$EVENT" \
+    --arg session "$SESSION_ID" \
+    --arg tool "$TOOL_NAME" \
+    --arg input_summary "$INPUT_JSON" \
+    --arg output_summary "$OUTPUT_JSON" \
+    --arg project_id "$PROJECT_HASH" \
+    --arg project_name "$PROJECT_NAME" \
+    '{ts:$ts,event:$event,session:$session,tool:$tool,input_summary:$input_summary,output_summary:$output_summary,project_id:$project_id,project_name:$project_name}')" \
+    >> "$OBS_FILE"
+else
+  # Fallback: manual JSON construction
+  printf '{"ts":"%s","event":"%s","session":"%s","tool":"%s","project_id":"%s","project_name":"%s"}\n' \
+    "$TS" "$EVENT" "$SESSION_ID" "$TOOL_NAME" "$PROJECT_HASH" "$PROJECT_NAME" \
+    >> "$OBS_FILE"
+fi
 
 # ---------------------------------------------------------------------------
-# Write project.json and update registry (only if new — deferred to avoid
-# adding latency to every invocation)
+# Write project.json if new project
 # ---------------------------------------------------------------------------
-PROJECT_JSON="${PROJECT_OBS_DIR}/project.json"
+PROJECT_JSON="${PROJECT_DIR}/project.json"
 if [[ ! -f "$PROJECT_JSON" ]]; then
-  CREATED_AT="$TS"
-  jq -n \
-    --arg id "$PROJECT_HASH" \
-    --arg name "$PROJECT_NAME" \
-    --arg root "$PROJECT_ROOT" \
-    --arg created_at "$CREATED_AT" \
-    '{id:$id,name:$name,root:$root,created_at:$created_at}' \
-    > "$PROJECT_JSON"
-
-  # Update global projects.json registry
-  mkdir -p "$MULAHAZAH_DIR"
-  [[ -f "$GLOBAL_REGISTRY" ]] || printf '{}' > "$GLOBAL_REGISTRY"
-
-  TMP_REGISTRY="$(mktemp)"
-  jq --arg id "$PROJECT_HASH" \
-     --arg name "$PROJECT_NAME" \
-     --arg root "$PROJECT_ROOT" \
-     --arg created_at "$CREATED_AT" \
-     '.[$id] = {name:$name,root:$root,created_at:$created_at}' \
-     "$GLOBAL_REGISTRY" > "$TMP_REGISTRY" && mv "$TMP_REGISTRY" "$GLOBAL_REGISTRY"
+  if command -v jq &>/dev/null; then
+    jq -n \
+      --arg id "$PROJECT_HASH" \
+      --arg name "$PROJECT_NAME" \
+      --arg root "$PROJECT_ROOT" \
+      --arg created_at "$TS" \
+      '{id:$id,name:$name,root:$root,created_at:$created_at}' \
+      > "$PROJECT_JSON"
+  else
+    printf '{"id":"%s","name":"%s","root":"%s","created_at":"%s"}\n' \
+      "$PROJECT_HASH" "$PROJECT_NAME" "$PROJECT_ROOT" "$TS" \
+      > "$PROJECT_JSON"
+  fi
 fi
 
 exit 0