#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# Copyright 2025-2026 Just In Time AI INC
# JitNeuro Installer
# Usage: ./install.sh [workspace|project|user]
#
# workspace  Install to parent directory's .claude/ (covers all repos under it)
# project    Install to current directory's .claude/ (single repo)
# user       Install to ~/.claude/ (available on entire machine)

set -e

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
TEMPLATES="$SCRIPT_DIR/templates"

if [ ! -d "$TEMPLATES" ]; then
  echo "ERROR: templates/ directory not found at $TEMPLATES"
  echo "Run this script from the jitneuro repo root."
  exit 1
fi

# Read version from jitneuro.json
VERSION="unknown"
if [ -f "$TEMPLATES/jitneuro.json" ]; then
  VERSION=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$TEMPLATES/jitneuro.json" | head -1 | sed 's/.*"version"[[:space:]]*:[[:space:]]*"//;s/"$//')
fi

# --- Parse args: positional mode + optional flags ---
MODE=""
RECONFIGURE=0
for arg in "$@"; do
  case "$arg" in
    --reconfigure) RECONFIGURE=1 ;;
    workspace|project|user) MODE="$arg" ;;
    *) ;;
  esac
done
MODE="${MODE:-project}"

case "$MODE" in
  workspace)
    TARGET="$(dirname "$(pwd)")/.claude"
    echo "Installing JitNeuro v$VERSION at WORKSPACE level: $TARGET"
    echo "Commands will be available to all repos under $(dirname "$(pwd)")"
    WORKSPACE_ROOT="$(dirname "$(pwd)")"
    ;;
  project)
    TARGET="$(pwd)/.claude"
    echo "Installing JitNeuro v$VERSION at PROJECT level: $TARGET"
    echo "Commands will be available in this repo only."
    WORKSPACE_ROOT=""
    ;;
  user)
    TARGET="$HOME/.claude"
    echo "Installing JitNeuro v$VERSION at USER level: $TARGET"
    echo "Commands will be available in all projects on this machine."
    WORKSPACE_ROOT=""
    ;;
  *)
    echo "Usage: ./install.sh [workspace|project|user]"
    echo ""
    echo "  workspace  Parent directory .claude/ (all repos underneath)"
    echo "  project    Current directory .claude/ (single repo, default)"
    echo "  user       ~/.claude/ (global, all projects)"
    exit 1
    ;;
esac

echo ""

# --- Upgrade detection (US-007) ---
INSTALLED_CONFIG="$TARGET/jitneuro.json"
PREV_VERSION=""
if [ -f "$INSTALLED_CONFIG" ]; then
  PREV_VERSION=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$INSTALLED_CONFIG" | head -1 | sed 's/.*"version"[[:space:]]*:[[:space:]]*"//;s/"$//')
fi
if [ -n "$PREV_VERSION" ]; then
  if [ "$PREV_VERSION" = "$VERSION" ]; then
    echo "Re-installing JitNeuro v$VERSION (same version)"
  else
    echo "Upgrading JitNeuro: v$PREV_VERSION -> v$VERSION"
  fi
elif [ -d "$TARGET/commands" ] && [ -n "$(ls -A "$TARGET/commands/" 2>/dev/null)" ]; then
  echo "Upgrading from pre-versioned JitNeuro install"
else
  echo "Fresh install"
fi
echo ""

# --- Upgrade-safe framework manifest (separates framework files from user files) ---
# The manifest records every FRAMEWORK-owned file (path + sha256) installed this run.
# On upgrade we prune framework files the new version dropped and back up any framework
# file the user edited -- and we NEVER touch a file that is not in the manifest (= yours).
MANIFEST="$TARGET/.jitneuro-manifest.tsv"
OLD_MANIFEST=""
if [ -f "$MANIFEST" ]; then
  OLD_MANIFEST="$(mktemp 2>/dev/null || echo "$TARGET/.jitneuro-manifest.old.$$")"
  cp "$MANIFEST" "$OLD_MANIFEST"
fi
NEW_MANIFEST="$(mktemp 2>/dev/null || echo "$TARGET/.jitneuro-manifest.new.$$")"
: > "$NEW_MANIFEST"

_jn_sha() {
  if command -v sha256sum >/dev/null 2>&1; then sha256sum "$1" 2>/dev/null | cut -d' ' -f1
  else shasum -a 256 "$1" 2>/dev/null | cut -d' ' -f1; fi
}
# old recorded sha for a relpath (empty if none / fresh install)
_jn_oldsha() { [ -n "$OLD_MANIFEST" ] && awk -F'\t' -v p="$1" '$1==p{print $2; exit}' "$OLD_MANIFEST"; }
# record a framework file (by target-relative path) into the new manifest (set -e safe)
_jn_record() { local rel="$1"; if [ -f "$TARGET/$rel" ]; then printf '%s\t%s\n' "$rel" "$(_jn_sha "$TARGET/$rel")" >> "$NEW_MANIFEST"; fi; }

# Patch the installed jitneuro.json "knowledgeRoot" value (portable, no jq needed).
_jn_write_kr() {
  local v="$1"
  local esc; esc=$(printf '%s' "$v" | sed 's/[\\&|]/\\&/g')
  if [ -f "$TARGET/jitneuro.json" ]; then
    sed "s|\"knowledgeRoot\"[[:space:]]*:[[:space:]]*\"[^\"]*\"|\"knowledgeRoot\": \"$esc\"|" \
      "$TARGET/jitneuro.json" > "$TARGET/jitneuro.json.tmp.$$" \
      && mv "$TARGET/jitneuro.json.tmp.$$" "$TARGET/jitneuro.json"
  fi
}

# Default KNOWLEDGE_ROOT for this install mode. A LOCAL store is ALWAYS present:
#   project / workspace install -> in-repo ./.knowledge (relative to the .claude parent)
#   user install                -> ~/.claude/.knowledge (absolute)
# An external shared catalog (separate repo) is an OPTIONAL upgrade layered on top.
_jn_default_kr() {
  case "$MODE" in
    user) echo "$HOME/.claude/.knowledge" ;;
    *)    echo "./.knowledge" ;;
  esac
}

# Create the local KNOWLEDGE_ROOT store on disk and seed a minimal INDEX.md if absent.
# Always called so a usable store exists even when KNOWLEDGE_ROOT points elsewhere.
_jn_ensure_local_store() {
  local store
  case "$MODE" in
    user) store="$HOME/.claude/.knowledge" ;;
    *)    store="$(dirname "$TARGET")/.knowledge" ;;   # repo/workspace root + /.knowledge
  esac
  mkdir -p "$store" 2>/dev/null || true
  if [ ! -f "$store/INDEX.md" ]; then
    cat > "$store/INDEX.md" <<'KRINDEX'
# Knowledge Store -- INDEX

This is your local KNOWLEDGE_ROOT catalog. It is ALWAYS present; JitNeuro works
standalone with nothing external. Add routing entries, skills, charters, playbooks,
and references here as your project grows.

## Routing
<!-- map trigger phrases to bundles, e.g.:
- deploy / server / container  -> [infrastructure]
- api / endpoint / auth        -> [api-patterns]
-->

## Capabilities
<!-- list skills / charters / playbooks / references this store provides -->

## Upgrade (optional)
To share one catalog across many projects, point KNOWLEDGE_ROOT at a separate
catalog repo (env var, or jitneuro.json "knowledgeRoot"). This local store then
acts as the fallback when the shared catalog is unavailable.
KRINDEX
    echo "  Created local knowledge store: $store/INDEX.md"
  fi
  # staging dir for onboarding imports (see import_existing_knowledge)
  mkdir -p "$store/imports" 2>/dev/null || true
}

# Configure KNOWLEDGE_ROOT and persist the choice. NEVER unconfigured -- a local
# store is always created. Resolution at runtime: KNOWLEDGE_ROOT env -> url-resolver
# map (only when pointing at a separate catalog repo) -> this value -> local .knowledge.
configure_knowledge_root() {
  local kr="$PREV_KR"
  # A live env var always wins; record it as the persisted default too.
  if [ -n "${KNOWLEDGE_ROOT:-}" ]; then
    kr="$KNOWLEDGE_ROOT"
  fi
  # Already configured and not re-configuring: keep it, do not prompt.
  if [ -n "$kr" ] && [ "$RECONFIGURE" -eq 0 ]; then
    echo "KNOWLEDGE_ROOT: $kr (re-run with --reconfigure to change)"
    _jn_write_kr "$kr"
    _jn_ensure_local_store
    return
  fi
  # Non-interactive with nothing configured: auto-configure the local store. No prompt.
  if [ ! -t 0 ] && [ "$RECONFIGURE" -eq 0 ]; then
    kr="$(_jn_default_kr)"
    echo "KNOWLEDGE_ROOT: $kr (local store -- auto-configured). Set KNOWLEDGE_ROOT env or re-run with --reconfigure to point at a shared catalog."
    _jn_write_kr "$kr"
    _jn_ensure_local_store
    return
  fi
  echo ""
  echo "Where is your KNOWLEDGE_ROOT (the knowledge store for this install)?"
  echo "A local store is always created. Choose where it lives, or point at a shared catalog:"
  if [ "$MODE" = "user" ]; then
    echo "  1) Local store: ~/.claude/.knowledge (default -- recommended)"
  else
    echo "  1) Local store: ./.knowledge in this repo/workspace (default -- recommended)"
  fi
  echo "  2) A separate shared catalog repo / folder elsewhere (OPTIONAL upgrade)"
  printf "Choice [1-2, default 1]: "
  read -r choice || choice=1
  case "$choice" in
    2)
      printf "Absolute path to the shared catalog repo/folder: "; read -r kr || kr=""
      if [ -z "$kr" ]; then
        kr="$(_jn_default_kr)"
        echo "No path given -- using the local store instead: $kr"
      fi
      ;;
    *) kr="$(_jn_default_kr)" ;;
  esac
  _jn_write_kr "$kr"
  _jn_ensure_local_store
  echo "KNOWLEDGE_ROOT set to: $kr"
  echo "Tip: export KNOWLEDGE_ROOT=\"$kr\" to override per-machine without editing config."
}

# Resolve the local KNOWLEDGE_ROOT store path on disk (mirrors _jn_ensure_local_store).
_jn_store_path() {
  case "$MODE" in
    user) echo "$HOME/.claude/.knowledge" ;;
    *)    echo "$(dirname "$TARGET")/.knowledge" ;;
  esac
}

# Resolve the onboarding scan root (where the adopter's existing repo content lives).
_jn_scan_root() {
  case "$MODE" in
    user)      echo "$HOME" ;;
    workspace) echo "$(dirname "$TARGET")" ;;     # parent of .claude = workspace root
    *)         echo "$(pwd)" ;;                    # project root
  esac
}

# US: ONBOARDING IMPORT -- detect existing AI knowledge sources in the target and,
# on user yes, write a staging manifest into the KNOWLEDGE_ROOT store. SAFETY:
# surface-and-catalog (never blind-merge), never ingest secrets (.env / keys).
import_existing_knowledge() {
  local scan_root store staging found
  scan_root="$(_jn_scan_root)"
  store="$(_jn_store_path)"

  # Candidate existing AI-knowledge sources (paths relative to scan_root).
  # We catalog these; we do NOT read or copy their contents here.
  local candidates
  candidates="
CLAUDE.md
AGENTS.md
.github/copilot-instructions.md
.claude
"
  # .cursor/rules/*.mdc enumerated separately (glob).

  found=""
  local c
  for c in $candidates; do
    if [ -e "$scan_root/$c" ]; then
      found="${found}${c}\n"
    fi
  done
  # Cursor rule files
  for f in "$scan_root"/.cursor/rules/*.mdc; do
    [ -e "$f" ] || continue
    found="${found}.cursor/rules/$(basename "$f")\n"
  done
  # Existing agent / charter files (common locations), 2 levels deep, capped.
  local af afn=0
  for af in "$scan_root"/.claude/agents/*/CHARTER.md "$scan_root"/agents/*/CHARTER.md "$scan_root"/.claude/agents/*.md; do
    [ -e "$af" ] || continue
    found="${found}${af#$scan_root/}\n"
    afn=$((afn + 1)); [ "$afn" -ge 20 ] && break
  done

  if [ -z "$found" ]; then
    return
  fi

  echo ""
  echo "Found existing AI knowledge sources in $scan_root:"
  printf "$found" | sed 's/^/  - /'
  local ans=""
  if [ -t 0 ] && [ "${JN_IMPORT:-}" = "" ]; then
    printf "Import existing knowledge into JitNeuro? (recommended) [Y/n]: "
    read -r ans || ans="y"
  else
    # Non-interactive: honor JN_IMPORT=yes|no; default to cataloging (safe -- no merge).
    ans="${JN_IMPORT:-yes}"
  fi
  case "$ans" in
    n|N|no|NO|No) echo "Skipped onboarding import. Run /onboard later to import."; return ;;
  esac

  mkdir -p "$store/imports" 2>/dev/null || true
  staging="$store/imports/onboarding-staging.md"
  {
    echo "# Onboarding Import -- Staging Manifest"
    echo ""
    echo "Generated by the JitNeuro installer. SAFETY: this is a SURFACE-AND-CATALOG"
    echo "manifest, not a merge. Nothing was ingested. The /onboard flow reads this"
    echo "manifest and routes each source to its correct home (engram = per-project"
    echo "context, rules = behavioral standard, knowledge store otherwise). Secrets"
    echo "(.env, keys) are never listed or ingested."
    echo ""
    echo "- scan_root: $scan_root"
    echo "- store (KNOWLEDGE_ROOT local): $store"
    echo "- install_mode: $MODE"
    echo ""
    echo "## Detected sources (route via /onboard)"
    echo ""
    echo "| Source | Suggested home | Notes |"
    echo "|--------|----------------|-------|"
    printf "$found" | while IFS= read -r line; do
      [ -n "$line" ] || continue
      case "$line" in
        AGENTS.md)                    echo "| $line | rules / standard | canonical instruction surface -- reconcile with JitNeuro AGENTS.md |" ;;
        CLAUDE.md)                    echo "| $line | rules / standard | tool instructions -- fold into AGENTS.md, keep CLAUDE.md thin |" ;;
        .github/copilot-instructions.md) echo "| $line | rules / standard | Copilot rules -- map to .claude/rules/ |" ;;
        .cursor/rules/*)              echo "| $line | rules / standard | Cursor rule -- map intents to .claude/rules/ |" ;;
        *CHARTER.md|*agents/*)        echo "| $line | knowledge store | agent/charter -- catalog under KNOWLEDGE_ROOT |" ;;
        .claude)                      echo "| $line | (review) | existing .claude content -- reconcile, do not overwrite |" ;;
        *)                            echo "| $line | (review) | classify during /onboard |" ;;
      esac
    done
    echo ""
    echo "## Reconcile during /onboard"
    echo "- Conflicts (e.g., existing CLAUDE.md vs JitNeuro thin importer) are listed, not auto-resolved."
    echo "- Run /onboard to read this manifest, import each source into the right home, and produce a summary."
  } > "$staging"
  echo "Staged onboarding manifest: $staging"
  echo "Run /onboard to import the detected sources into their correct homes."
}

# Create directories
mkdir -p "$TARGET/commands"
mkdir -p "$TARGET/bundles"
mkdir -p "$TARGET/engrams"
mkdir -p "$TARGET/session-state"
mkdir -p "$TARGET/session-state/heartbeats"
mkdir -p "$TARGET/rules"
mkdir -p "$TARGET/hooks"
mkdir -p "$TARGET/cognition/decisions"
mkdir -p "$TARGET/scripts"
mkdir -p "$TARGET/dashboard/runs"

# --- Backup existing commands before overwrite (US-002) ---
BACKUP_COUNT=0
BACKUP_DIR="$TARGET/commands/.backup"
for cmd_file in "$TEMPLATES/commands/"*.md; do
  [ -f "$cmd_file" ] || continue
  cmd_name="$(basename "$cmd_file")"
  existing="$TARGET/commands/$cmd_name"
  if [ -f "$existing" ]; then
    if ! diff -q "$cmd_file" "$existing" >/dev/null 2>&1; then
      mkdir -p "$BACKUP_DIR"
      cp "$existing" "$BACKUP_DIR/$cmd_name"
      BACKUP_COUNT=$((BACKUP_COUNT + 1))
    fi
  fi
done
if [ "$BACKUP_COUNT" -gt 0 ]; then
  echo "Backed up $BACKUP_COUNT existing commands to commands/.backup/"
fi

# --- Install commands (dynamic scan) ---
echo "Installing commands..."
CMD_COUNT=0
for cmd_file in "$TEMPLATES/commands/"*.md; do
  [ -f "$cmd_file" ] || continue
  cmd_name="$(basename "$cmd_file" .md)"
  cp "$cmd_file" "$TARGET/commands/$(basename "$cmd_file")"
  echo "  /$cmd_name"
  CMD_COUNT=$((CMD_COUNT + 1))
done
echo "  ($CMD_COUNT commands installed)"

# --- Install /help data file (the /help command reads $TARGET/help.md) ---
# Without this copy, /help is broken: the command exists but its data file is missing.
if [ -f "$TEMPLATES/help.md" ]; then
  cp "$TEMPLATES/help.md" "$TARGET/help.md"
  echo "  help.md (data for /help)"
fi

# Routing lives in your configured knowledge catalog's INDEX.md (when one is configured)
# -- do NOT seed context-manifest.md with routing tables.
# If a stale context-manifest.md exists from a prior install, leave it untouched (do not overwrite or delete).
if [ -f "$TARGET/context-manifest.md" ]; then
  echo "NOTE: Legacy context-manifest.md found at $TARGET/context-manifest.md"
  echo "      Routing now lives in your knowledge catalog's INDEX.md. You may retire context-manifest.md."
fi

# Scaffold url-resolver.md in user home .claude (machine-specific, gitignored)
USER_CLAUDE="$HOME/.claude"
URL_RESOLVER="$USER_CLAUDE/url-resolver.md"
if [ ! -f "$URL_RESOLVER" ]; then
  mkdir -p "$USER_CLAUDE"
  cp "$TEMPLATES/url-resolver.md" "$URL_RESOLVER"
  echo "Created ~/.claude/url-resolver.md -- map your repo names to local paths (optional)"
else
  echo "Skipped url-resolver.md (already exists)"
fi

# Copy example bundle if bundles dir is empty
if [ -z "$(ls -A "$TARGET/bundles/" 2>/dev/null)" ]; then
  cp "$TEMPLATES/bundles/example.md" "$TARGET/bundles/example.md"
  echo "Created bundles/example.md (template)"
else
  echo "Skipped bundles/ (already has files)"
fi

# Copy example engram if engrams dir is empty
if [ -z "$(ls -A "$TARGET/engrams/" 2>/dev/null)" ]; then
  cp "$TEMPLATES/engrams/example.md" "$TARGET/engrams/example.md"
  cp "$TEMPLATES/engrams/README.md" "$TARGET/engrams/README.md"
  echo "Created engrams/example.md (template)"
else
  echo "Skipped engrams/ (already has files)"
fi

# Copy session-state README
if [ ! -f "$TARGET/session-state/README.md" ]; then
  cp "$TEMPLATES/session-state/README.md" "$TARGET/session-state/README.md"
  echo "Created session-state/README.md"
fi

# Install rule templates (respect DISABLED marker)
echo "Installing rule templates..."
RULE_COUNT=0
RULE_SKIP=0
for rule_file in "$TEMPLATES/rules/"*.md; do
  [ -f "$rule_file" ] || continue
  rule_name="$(basename "$rule_file")"
  target_rule="$TARGET/rules/$rule_name"
  if [ -f "$target_rule" ]; then
    if head -1 "$target_rule" | grep -q "(DISABLED)" 2>/dev/null; then
      echo "  SKIP: $rule_name (disabled by user)"
      RULE_SKIP=$((RULE_SKIP + 1))
      continue
    fi
    if ! diff -q "$rule_file" "$target_rule" >/dev/null 2>&1; then
      # If the user edited this framework rule since last install, preserve their copy.
      old_sha="$(_jn_oldsha "rules/$rule_name")"
      if [ -n "$old_sha" ] && [ "$old_sha" != "$(_jn_sha "$target_rule")" ]; then
        mkdir -p "$TARGET/.jitneuro-backup/rules"
        cp "$target_rule" "$TARGET/.jitneuro-backup/rules/$rule_name"
        echo "  BACKUP: rules/$rule_name (your edit saved to .jitneuro-backup/rules/)"
      fi
      cp "$rule_file" "$target_rule"
      echo "  UPDATED: $rule_name"
      RULE_COUNT=$((RULE_COUNT + 1))
    fi
  else
    cp "$rule_file" "$target_rule"
    echo "  $rule_name"
    RULE_COUNT=$((RULE_COUNT + 1))
  fi
done
echo "  ($RULE_COUNT rules installed, $RULE_SKIP disabled/skipped)"

# Install horizon templates (strategic-context placeholders).
# Seed ONLY if empty -- never overwrite an adopter's filled-in horizon on re-run.
mkdir -p "$TARGET/horizon"
if [ -z "$(ls -A "$TARGET/horizon/" 2>/dev/null)" ]; then
  cp "$TEMPLATES/horizon/"*.md "$TARGET/horizon/" 2>/dev/null
  HORIZON_N=$(ls -1 "$TARGET/horizon/"*.md 2>/dev/null | wc -l)
  echo "Installing horizon templates..."
  echo "  horizon/ ($HORIZON_N placeholders -- fill in via horizon/POPULATE-HORIZON.md)"
else
  echo "Skipped horizon/ (already has files)"
fi

# Install cognition layer (Phase 2)
echo "Installing cognition layer..."
# User-ACCUMULATED cognition files (anti-patterns.md, written by /learn) are seeded only
# if absent and NEVER overwritten. Framework cognition files update like rules: a user
# edit is backed up to .jitneuro-backup/cognition/ before the new version lands.
_jn_install_cog() {  # $1=src  $2=rel (e.g. cognition/foo.md)  $3=dest
  if [ -f "$3" ]; then
    if ! diff -q "$1" "$3" >/dev/null 2>&1; then
      local old_sha; old_sha="$(_jn_oldsha "$2")"
      if [ -n "$old_sha" ] && [ "$old_sha" != "$(_jn_sha "$3")" ]; then
        mkdir -p "$TARGET/.jitneuro-backup/cognition"
        cp "$3" "$TARGET/.jitneuro-backup/cognition/$(basename "$3")"
        echo "  BACKUP: $2 (your edit saved to .jitneuro-backup/cognition/)"
      fi
      cp "$1" "$3"
    fi
  else
    cp "$1" "$3"
  fi
}
for cog_file in "$TEMPLATES/cognition/"*.md; do
  [ -f "$cog_file" ] || continue
  cog_name="$(basename "$cog_file")"
  if [ "$cog_name" = "anti-patterns.md" ]; then
    if [ -f "$TARGET/cognition/$cog_name" ]; then
      echo "  Preserved cognition/$cog_name (your accumulated knowledge)"
    else
      cp "$cog_file" "$TARGET/cognition/$cog_name"
      echo "  cognition/$cog_name (seeded -- yours to accumulate via /learn)"
    fi
  else
    _jn_install_cog "$cog_file" "cognition/$cog_name" "$TARGET/cognition/$cog_name"
  fi
done
for dec_file in "$TEMPLATES/cognition/decisions/"*.md; do
  [ -f "$dec_file" ] || continue
  dec_name="$(basename "$dec_file")"
  _jn_install_cog "$dec_file" "cognition/decisions/$dec_name" "$TARGET/cognition/decisions/$dec_name"
done
echo "  cognition/ (framework updated; your edits backed up, accumulated knowledge preserved)"
# Create owner-persona from example if it doesn't exist
if [ ! -f "$TARGET/cognition/owner-persona.md" ]; then
  cp "$TEMPLATES/cognition/owner-persona.example.md" "$TARGET/cognition/owner-persona.md"
  echo "  cognition/owner-persona.md (created from template -- customize this)"
else
  echo "  Skipped owner-persona.md (already exists)"
fi

# Install scripts
echo "Installing scripts..."
for script_file in "$TEMPLATES/scripts/"*.sh; do
  [ -f "$script_file" ] || continue
  script_name="$(basename "$script_file")"
  cp "$script_file" "$TARGET/scripts/$script_name"
  echo "  scripts/$script_name"
done

# Install dashboard
echo "Installing dashboard..."
for dash_file in "$TEMPLATES/dashboard/"*.html "$TEMPLATES/dashboard/"*.js; do
  [ -f "$dash_file" ] || continue
  dash_name="$(basename "$dash_file")"
  cp "$dash_file" "$TARGET/dashboard/$dash_name"
  echo "  dashboard/$dash_name"
done
if [ -d "$TEMPLATES/dashboard/bin" ]; then
  mkdir -p "$TARGET/dashboard/bin"
  for bin_file in "$TEMPLATES/dashboard/bin/"*; do
    [ -f "$bin_file" ] || continue
    cp "$bin_file" "$TARGET/dashboard/bin/$(basename "$bin_file")"
  done
  echo "  dashboard/bin/ (launcher scripts)"
fi

# Install hooks
echo "Installing hooks..."
for hook_file in "$TEMPLATES/hooks/"*.sh; do
  [ -f "$hook_file" ] || continue
  hook_name="$(basename "$hook_file")"
  # -f so a re-install can overwrite a previously chmod-locked (read-only) hook
  cp -f "$hook_file" "$TARGET/hooks/$hook_name"
  echo "  hooks/$hook_name"
done

# Set permissions (Linux/Mac only). Skip on Windows (MSYS/MinGW/Cygwin): POSIX perms
# do not apply there, and chmod 500 makes hooks read-only, breaking the NEXT install's
# copy. (The old `[ ... != "MINGW"* ]` test never matched -- [ ] does not glob.)
case "$(uname -s)" in
  MINGW*|MSYS*|CYGWIN*) : ;;
  *)
    chmod 700 "$TARGET/hooks" 2>/dev/null || true
    chmod 500 "$TARGET/hooks/"*.sh 2>/dev/null || true
    ;;
esac

# --- Install jitneuro.json config (preserve the user's settings on re-install) ---
# Fresh install copies the template. A re-install PRESERVES the user's jitneuro.json in
# full (scheduledAgents, team config, knowledgeRoot, any custom keys) and only bumps the
# version field -- never clobbering user config with template defaults.
PREV_KR=""
if [ -f "$TARGET/jitneuro.json" ]; then
  PREV_KR=$(grep -o '"knowledgeRoot"[[:space:]]*:[[:space:]]*"[^"]*"' "$TARGET/jitneuro.json" | head -1 | sed 's/.*"knowledgeRoot"[[:space:]]*:[[:space:]]*"//;s/"$//')
  _jn_jtmp="$(mktemp 2>/dev/null || echo "$TARGET/jitneuro.json.tmp.$$")"
  sed -E "s/(\"version\"[[:space:]]*:[[:space:]]*\")[^\"]*\"/\1$VERSION\"/" "$TARGET/jitneuro.json" > "$_jn_jtmp" && mv "$_jn_jtmp" "$TARGET/jitneuro.json"
  echo "Preserved your jitneuro.json (version -> v$VERSION; your settings kept)"
else
  cp "$TEMPLATES/jitneuro.json" "$TARGET/jitneuro.json"
  echo "Installed jitneuro.json (v$VERSION)"
fi

# --- Configure KNOWLEDGE_ROOT (always present; local store auto-created) ---
configure_knowledge_root

# --- Onboarding import: detect existing AI knowledge sources, stage for /onboard ---
import_existing_knowledge

# --- Auto-configure hooks in settings.local.json (US-001) ---
echo ""
echo "Configuring hooks..."
SETTINGS_FILE="$TARGET/settings.local.json"
HOOKS_PATH="$TARGET/hooks"

# Build hooks JSON using jitneuro.json hookEvents
# Use forward slashes for all paths (Claude Code expects this)
HOOKS_PATH_FWD=$(echo "$HOOKS_PATH" | sed 's|\\|/|g')

# ============================================================================
# HOW TO WRITE A HOOK COMMAND -- read before editing the entries below
# ----------------------------------------------------------------------------
# Claude Code runs each hook `command` through its OWN shell. The `command`
# value MUST be a bare script path and nothing else, for example:
#       "command": "${HOOKS_PATH_FWD}/heartbeat.sh"
#
# NEVER prefix it with `bash`, `bash.exe`, or any shell binary. A prefix makes
# the shell try to run bash as bash's own script argument, so EVERY hook then
# fails at runtime with:
#       bash.exe: bash.exe: cannot execute binary file
#
# When adding or changing a hook below, look at the other hook entries in this
# same block and match their format exactly -- each `command` is just a path.
# Full rule: rules/claude-code-hook-deployment.md (installed with JitNeuro)
# ============================================================================
build_hooks_json() {
  cat <<HOOKJSON
{
  "hooks": {
    "Stop": [{ "matcher": "", "hooks": [{ "type": "command", "command": "${HOOKS_PATH_FWD}/stop-continue-queue.sh", "timeout": 10 }] }],
    "PreCompact": [{ "matcher": "", "hooks": [{ "type": "command", "command": "${HOOKS_PATH_FWD}/pre-compact-save.sh", "timeout": 10 }] }],
    "SessionStart": [
      { "matcher": "", "hooks": [{ "type": "command", "command": "${HOOKS_PATH_FWD}/session-start-identity.sh", "timeout": 10 }] },
      { "matcher": "", "hooks": [{ "type": "command", "command": "${HOOKS_PATH_FWD}/session-start-write-id.sh", "timeout": 10 }] },
      { "matcher": "", "hooks": [{ "type": "command", "command": "${HOOKS_PATH_FWD}/session-start-post-clear.sh", "timeout": 10 }] },
      { "matcher": "compact", "hooks": [{ "type": "command", "command": "${HOOKS_PATH_FWD}/session-start-recovery.sh", "timeout": 10 }] }
    ],
    "PreToolUse": [
      { "matcher": "Bash", "hooks": [{ "type": "command", "command": "${HOOKS_PATH_FWD}/branch-protection.sh", "timeout": 10 }] },
      { "matcher": "Agent", "hooks": [{ "type": "command", "command": "${HOOKS_PATH_FWD}/pre-agent-register.sh", "timeout": 5 }] }
    ],
    "PostToolUse": [
      { "matcher": "", "hooks": [{ "type": "command", "command": "${HOOKS_PATH_FWD}/heartbeat.sh", "timeout": 5 }] },
      { "matcher": "Agent", "hooks": [{ "type": "command", "command": "${HOOKS_PATH_FWD}/post-agent-complete.sh", "timeout": 5 }] }
    ],
    "SessionEnd": [{ "matcher": "", "hooks": [{ "type": "command", "command": "${HOOKS_PATH_FWD}/session-end-autosave.sh", "timeout": 10 }] }]
  }
}
HOOKJSON
}

if [ -f "$SETTINGS_FILE" ]; then
  # Existing settings -- try to merge with jq
  if command -v jq >/dev/null 2>&1; then
    HOOKS_JSON=$(build_hooks_json)
    TEMP_FILE="$SETTINGS_FILE.tmp.$$"
    # Per-event merge: preserve user-added hooks, replace/dedup jitneuro's own
    # (entries whose command path starts with this install's hooks dir). Other
    # top-level settings keys are preserved via the base object merge.
    jq -s --arg hp "$HOOKS_PATH_FWD" '
      (.[0]) as $cur | (.[1]) as $new |
      ($cur * $new) |
      .hooks = (
        reduce ($new.hooks | keys_unsorted[]) as $e
          ( ($cur.hooks // {}) ;
            .[$e] = ( ( ($cur.hooks[$e] // [])
                        | map(select( any(.hooks[]?; .command | startswith($hp)) | not )) )
                      + $new.hooks[$e] )
          )
      )
    ' "$SETTINGS_FILE" <(echo "$HOOKS_JSON") > "$TEMP_FILE" 2>/dev/null
    if [ $? -eq 0 ] && [ -s "$TEMP_FILE" ]; then
      mv "$TEMP_FILE" "$SETTINGS_FILE"
      echo "  Merged hooks into existing settings.local.json"
    else
      rm -f "$TEMP_FILE"
      echo "  WARNING: jq merge failed. Existing settings.local.json left UNTOUCHED."
      echo "  You must manually add hooks config. See $TARGET/jitneuro.json for reference."
    fi
  else
    echo "  WARNING: jq not found and settings.local.json already exists."
    echo "  Existing file left UNTOUCHED to prevent data loss."
    echo "  Install jq and re-run, or manually add hooks config."
    echo "  See $TARGET/jitneuro.json for the hooks configuration."
  fi
else
  # No existing settings -- create hooks-only file (atomic write)
  TEMP_FILE="$SETTINGS_FILE.tmp.$$"
  build_hooks_json > "$TEMP_FILE"
  mv "$TEMP_FILE" "$SETTINGS_FILE"
  echo "  Created settings.local.json with hooks config"
fi

# --- Post-install workspace repo scan (US-003) ---
if [ "$MODE" = "workspace" ] && [ -n "$WORKSPACE_ROOT" ]; then
  echo ""
  echo "Scanning workspace for repos..."
  echo ""
  printf "  %-20s %-10s %-10s %-10s\n" "REPO" "CLAUDE.md" "BRAINSTEM" "ENGRAM"
  printf "  %-20s %-10s %-10s %-10s\n" "----" "---------" "---------" "------"
  REPO_COUNT=0
  NEEDS_ONBOARD=0
  for dir in "$WORKSPACE_ROOT"/*/; do
    [ -d "$dir/.git" ] || continue
    repo_name="$(basename "$dir")"
    # Skip .claude and jitneuro directories
    [ "$repo_name" = ".claude" ] && continue
    [ "$repo_name" = "jitneuro" ] && continue

    # Truncate long names
    display_name="$repo_name"
    if [ ${#display_name} -gt 20 ]; then
      display_name="${display_name:0:17}..."
    fi

    has_claude="--"
    has_brainstem="--"
    has_engram="--"

    [ -f "$dir/CLAUDE.md" ] && has_claude="YES"
    [ -f "$dir/.claude/CLAUDE.md" ] && has_brainstem="YES"
    [ -f "$WORKSPACE_ROOT/.knowledge/engrams/${repo_name}-context.md" ] && has_engram="YES"

    if [ "$has_claude" = "--" ] || [ "$has_brainstem" = "--" ] || [ "$has_engram" = "--" ]; then
      NEEDS_ONBOARD=$((NEEDS_ONBOARD + 1))
    fi

    printf "  %-20s %-10s %-10s %-10s\n" "$display_name" "$has_claude" "$has_brainstem" "$has_engram"
    REPO_COUNT=$((REPO_COUNT + 1))

    # Cap at 30 repos
    if [ "$REPO_COUNT" -ge 30 ]; then
      echo "  ... ($REPO_COUNT+ repos, showing first 30)"
      break
    fi
  done
  echo ""
  echo "  $REPO_COUNT repos found, $NEEDS_ONBOARD need onboarding"
  if [ "$NEEDS_ONBOARD" -gt 0 ]; then
    echo "  Run /onboard <repo> to set up context for missing repos"
  fi
  # US-004: Git sync tip
  echo "  Tip: /onboard checks if repos are behind their remote"
fi

# --- Add *.backup to .gitignore ---
GITIGNORE="$TARGET/../.gitignore"
if [ -f "$GITIGNORE" ]; then
  if ! grep -q '\.backup' "$GITIGNORE" 2>/dev/null; then
    echo "" >> "$GITIGNORE"
    echo "# JitNeuro command backups" >> "$GITIGNORE"
    echo ".claude/commands/.backup/" >> "$GITIGNORE"
  fi
fi

# --- Record framework manifest + prune framework files dropped since last install ---
echo ""
echo "Recording framework manifest..."
for t in "$TEMPLATES/commands/"*.md;   do [ -f "$t" ] || continue; _jn_record "commands/$(basename "$t")"; done
for t in "$TEMPLATES/rules/"*.md;      do [ -f "$t" ] || continue; _jn_record "rules/$(basename "$t")"; done
for t in "$TEMPLATES/cognition/"*.md;  do
  [ -f "$t" ] || continue
  b="$(basename "$t")"
  [ "$b" = "owner-persona.example.md" ] && continue   # owner-persona is user-owned after seeding
  _jn_record "cognition/$b"
done
for t in "$TEMPLATES/cognition/decisions/"*.md; do [ -f "$t" ] || continue; _jn_record "cognition/decisions/$(basename "$t")"; done
for t in "$TEMPLATES/scripts/"*.sh;    do [ -f "$t" ] || continue; _jn_record "scripts/$(basename "$t")"; done
for t in "$TEMPLATES/dashboard/"*.html "$TEMPLATES/dashboard/"*.js; do [ -f "$t" ] || continue; _jn_record "dashboard/$(basename "$t")"; done
if [ -d "$TEMPLATES/dashboard/bin" ]; then
  for t in "$TEMPLATES/dashboard/bin/"*; do [ -f "$t" ] || continue; _jn_record "dashboard/bin/$(basename "$t")"; done
fi
for t in "$TEMPLATES/hooks/"*.sh;      do [ -f "$t" ] || continue; _jn_record "hooks/$(basename "$t")"; done
_jn_record "jitneuro.json"
_jn_record "help.md"

# Prune framework files present at last install but no longer shipped (sha-guarded).
if [ -n "$OLD_MANIFEST" ]; then
  PRUNED=0
  while IFS=$'\t' read -r rel oldsha; do
    [ -n "$rel" ] || continue
    case "$rel" in \#*) continue;; esac
    if ! awk -F'\t' -v p="$rel" '$1==p{f=1} END{exit !f}' "$NEW_MANIFEST"; then
      f="$TARGET/$rel"
      if [ -f "$f" ]; then
        if [ "$(_jn_sha "$f")" = "$oldsha" ]; then
          rm -f "$f"; echo "  REMOVED (dropped by framework): $rel"; PRUNED=$((PRUNED+1))
        else
          echo "  KEPT (you edited a now-removed framework file): $rel"
        fi
      fi
    fi
  done < "$OLD_MANIFEST"
  [ "$PRUNED" -gt 0 ] && echo "  ($PRUNED stale framework file(s) removed)"
fi

# Write the manifest (sorted, version-stamped). Files NOT listed here = yours; never touched.
{ echo "# jitneuro-manifest v$VERSION"; LC_ALL=C sort "$NEW_MANIFEST"; } > "$MANIFEST"
MF_COUNT=$(grep -cv '^#' "$MANIFEST" 2>/dev/null || echo 0)
rm -f "$NEW_MANIFEST" "$OLD_MANIFEST" 2>/dev/null || true
echo "  .jitneuro-manifest.tsv ($MF_COUNT framework files tracked)"

# --- Summary ---
echo ""
echo "---"
echo "JitNeuro v$VERSION installed to: $TARGET"
echo ""
echo "Next steps:"
echo "  1. CLOSE AND REOPEN your AI tool (Claude Code loads commands/hooks at session start)"
echo "  2. Run /verify to confirm everything is working (Claude Code)"
echo "  3. AGENTS.md is the canonical standard for every tool (Cursor/Codex/Claude/others)."
echo "     CLAUDE.md is a thin importer of it. Run /onboard to generate them for a repo."
echo "  4. Run /onboard to import any staged knowledge sources into their correct homes"
echo "  5. Populate your horizon: tell Claude \"populate my horizon files\" (or open"
echo "     $TARGET/horizon/POPULATE-HORIZON.md) to capture your vision, goals, and profile"
echo "  6. Create bundles for your domains in $TARGET/bundles/"
echo "  7. (optional) Point KNOWLEDGE_ROOT at a shared catalog repo to share one catalog"
echo "     across projects; your local .knowledge store stays as the fallback"
echo ""
echo "*** You MUST restart Claude Code for slash commands to take effect. ***"
echo ""
echo "Docs: $SCRIPT_DIR/docs/setup-guide.md"