lore.sh

#!/usr/bin/env bash
# lore.sh - Memory that compounds
#
# A system for AI agents to build persistent, searchable memory across sessions.

set -euo pipefail

_lore_source="${BASH_SOURCE[0]}"
[[ -L "$_lore_source" ]] && _lore_source="$(readlink -f "$_lore_source")"
LORE_DIR="${LORE_DIR:-$(cd "$(dirname "$_lore_source")" && pwd)}"
unset _lore_source
source "${LORE_DIR}/lib/paths.sh"

# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
BOLD='\033[1m'
DIM='\033[2m'
NC='\033[0m'

# --- Bridge helpers (lazy-sourced, fail-silent) ---
# Each helper sources bridge.sh on demand so it's not loaded on every lore invocation.

_bridge_sync_last_decision() {
    source "$LORE_DIR/lib/bridge.sh" || return 0
    local record
    record=$(tail -1 "$LORE_DECISIONS_FILE") || return 0
    sync_single_decision "$record"
}

_bridge_sync_last_pattern() {
    source "$LORE_DIR/lib/bridge.sh" || return 0
    command -v yq &>/dev/null || return 0
    local idx id name problem solution
    idx=$(yq '.patterns | length - 1' "$LORE_PATTERNS_FILE" 2>/dev/null) || return 0
    [[ "$idx" -lt 0 ]] && return 0
    id=$(yq -r ".patterns[$idx].id // \"\"" "$LORE_PATTERNS_FILE" 2>/dev/null) || return 0
    name=$(yq -r ".patterns[$idx].name // \"\"" "$LORE_PATTERNS_FILE" 2>/dev/null) || return 0
    problem=$(yq -r ".patterns[$idx].problem // \"\"" "$LORE_PATTERNS_FILE" 2>/dev/null) || return 0
    solution=$(yq -r ".patterns[$idx].solution // \"\"" "$LORE_PATTERNS_FILE" 2>/dev/null) || return 0
    sync_single_pattern "$id" "$name" "$problem" "$solution"
}

_bridge_retract_shadow() {
    source "$LORE_DIR/lib/bridge.sh" || return 0
    retract_shadow "$1"
}

_bridge_health_check() {
    source "$LORE_DIR/lib/bridge.sh" || return 0
    shadow_health_check
}

# Infer capture type from command-line flags
# Returns: "decision", "pattern", "failure", "evidence", or "signal"
infer_capture_type() {
    local has_decision_flags=false
    local has_pattern_flags=false
    local has_failure_flags=false
    local explicit_type=""

    while [[ $# -gt 0 ]]; do
        case "$1" in
            # Explicit type overrides
            --decision) explicit_type="decision"; shift ;;
            --pattern) explicit_type="pattern"; shift ;;
            --failure) explicit_type="failure"; shift ;;
            --observation|--signal) explicit_type="signal"; shift ;;
            --evidence) explicit_type="evidence"; shift ;;
            --concept) explicit_type="concept"; shift ;;

            # Decision-specific flags
            --rationale|-r|--alternatives|-a|--outcome|--type|-f|--files)
                has_decision_flags=true
                shift 2 ;;

            # Pattern-specific flags
            --solution|--problem|--context|--category|--confidence|--origin)
                has_pattern_flags=true
                shift 2 ;;

            # Failure-specific flags
            --error-type|--tool|--step)
                has_failure_flags=true
                shift 2 ;;

            # Concept flags (value-bearing, skip arg)
            --definition) shift 2 ;;

            # Skip other args
            *) shift ;;
        esac
    done

    # Explicit type wins
    [[ -n "$explicit_type" ]] && { echo "$explicit_type"; return; }

    # Infer from flags (failure > pattern > decision > signal default)
    if [[ "$has_failure_flags" == true ]]; then
        echo "failure"
    elif [[ "$has_pattern_flags" == true ]]; then
        echo "pattern"
    elif [[ "$has_decision_flags" == true ]]; then
        echo "decision"
    else
        echo "signal"
    fi
}

# Minimal help - fits on one screen
show_help() {
    cat << 'EOF'
Lore - Memory That Compounds

Usage: lore <command> [options]

Session:
  resume              Load context from previous session
  capture <text>      Record knowledge (type inferred from flags)
  handoff <message>   Capture context for next session
  status              Show current session state

Capture flags:
  (none)              → signal (inbox)
  --rationale "why"   → decision (journal)
  --solution "what"   → pattern (patterns)
  --error-type Type   → failure (failures)
  --evidence          → evidence (with --confidence level)

Query:
  recall <query>        Read from memory (mode inferred from flags)
  search <query>        Search all components
  review                Review pending decisions
  brief <topic>         Assemble topic-specific context

Run 'lore help' for all commands.
Run 'lore help <topic>' for: capture, recall, search, intent, registry, components
EOF
}

# Full help - all commands
show_help_full() {
    cat << 'EOF'
Lore - Memory That Compounds

Usage: lore <command> [options]

SESSION LIFECYCLE
  resume [session]        Load context from previous session (forks new session)
  handoff <message>       Capture context for next session
  status                  Show current session state
  entire-resume <branch>  Resume Entire branch with Lore context injection

CAPTURE
  capture <text>          Universal write — type inferred from flags:
    (no flags)            → signal (inbox)
    --rationale, -r       → decision (journal)
    --solution            → pattern (patterns)
    --error-type          → failure (failures)
    --decision            Explicit decision override
    --pattern             Explicit pattern override
    --failure             Explicit failure override
    --signal              Explicit signal override
    --evidence            Explicit evidence (with --confidence)
    --concept             Explicit concept (with --definition)
    --confidence          Evidence confidence (preliminary|confirmed|contested|superseded)
    --definition          Concept definition (used with --concept)
    --tags, -t            Tags for categorization (all types)
  remember <text>         Record a decision (shortcut for capture --decision)
  fail <type> <message>   Log a failure
  observe <text>          Capture signal (shortcut for capture --signal)

EVIDENCE
  evidence list [--confidence X]  List evidence, optional confidence filter
  evidence get <id>               Get single evidence record
  evidence stats                  Count evidence by confidence level

RECALL
  recall <query>          Universal read — mode inferred from flags:
    (no flags)            → search across all components
    --routed              → smart routing across Lore and Engram
    --project <name>      → full project context assembly
    --patterns [context]  → suggest relevant patterns
    --failures [--type T] → list failures
    --triggers [N]        → recurring failure types (Rule of Three)
    --concepts [query]    → search or list concepts
    --brief <topic>       → topic-specific context briefing
    --graph-depth N       → follow graph edges during search (0-3)
    --compact             → machine-readable output
  search <query>          Search (shortcut for recall)
  overlay <query>         Generate compact context bundle for agent priming
    --query, -q           Search query (required)
    --project, -p         Boost results from this project
    --limit, -l           Max results (default 10)
    --json                Structured JSON output for automation
  context <project>       Project context (shortcut for recall --project)
  suggest <context>       Pattern suggestions (shortcut for recall --patterns)
  failures [--type T]     List failures (shortcut for recall --failures)
  triggers [N]            Recurring failures (shortcut for recall --triggers)
  review                  List pending decisions older than 3 days
    --auto                Compact output for programmatic use
    --resolve <id>        Resolve a decision's outcome
      --outcome <value>   successful|revised|abandoned
      --lesson "text"     Optional lesson learned
  brief <topic>           Topic context (shortcut for recall --brief)
  promote-failure [type]  Promote recurring failures to anti-patterns

INTENT (Goals)
  goal create <name>      Create a goal
  goal list [--status S]  List goals
  goal show <id>          Show goal details

REGISTRY
  registry show <proj>    Show project details
  registry list           List all projects
  registry validate       Check consistency

MAINTENANCE
  learn <text>            Capture a pattern (shortcut, prefer: capture --solution)
  index                   Build/rebuild search index
  validate                Run comprehensive checks
  ingest <p> <t> <file>   Bulk import from external formats
  consolidate             Group similar decisions and create summaries
    --write               Actually create summaries (default: dry-run)
    --promote             Also create concepts from clusters
    --threshold N         Jaccard similarity % (default: 50)
  sync                    Project Lore shadows into Engram
    --since T             Time window (2h, 8h, 7d, 2024-01-01; default: 8h)
    --type T              Limit to: decisions, patterns, failures, sessions
    --dry-run             Print what would be synced without writing
  promote                 Promote high-value Engram memories to Lore
    --limit N             Max candidates to review (default: 10)
    --auto                Auto-classify and skip prompt (dry-run)

JOURNAL
  journal add             Add structured journal entry (--type, --project, --title, --body)

COMPONENTS (direct access)
  journal <cmd>           Decision journal
  patterns <cmd>          Patterns and anti-patterns
  transfer <cmd>          Session management
  inbox <cmd>             Signal staging
  intent <cmd>            Goals and specs

Run 'lore help <topic>' for detailed help on:
  capture, recall, search, intent, registry, components
EOF
}

# Topic-specific help
show_help_capture() {
    cat << 'EOF'
CAPTURE COMMANDS

Record knowledge with a single verb. Importance is earned via flags, not assumed.

  lore capture "X"                              → signal (inbox)
  lore capture "X" --rationale "why"            → decision (journal)
  lore capture "X" --solution "how"             → pattern (patterns)
  lore capture "X" --error-type ToolError       → failure (failures)

Bare capture creates a signal — a low-friction note that can be promoted
to evidence or a decision later. Add flags to indicate importance.

DECISIONS (remember)
  lore remember "Use PostgreSQL" --rationale "Need ACID, team knows it"
  lore remember "REST over GraphQL" -r "Simpler" -a "GraphQL, gRPC"

  Options:
    --rationale, -r <why>       Why this decision was made
    --alternatives, -a <list>   Comma-separated alternatives considered
    --tags, -t <list>           Comma-separated tags
    --type <type>               architecture, implementation, naming, etc.
    --files, -f <list>          Files affected
    --force                     Skip duplicate check

PATTERNS (learn)
  lore learn "Retry with backoff" --context "External APIs" --solution "100ms * 2^n"

  Options:
    --context <when>            When this pattern applies
    --solution <what>           The approach or technique
    --problem <what>            What problem this solves
    --category <cat>            Category (or "anti-pattern")
    --confidence <0-1>          How confident in this pattern

FAILURES (fail)
  lore fail ToolError "Permission denied on /etc/hosts"
  lore fail Timeout "API call exceeded 30s"

  Error types:
    Timeout       Operation exceeded time limit
    NonZeroExit   Command returned non-zero
    UserDeny      User rejected proposed action
    ToolError     Tool execution failed
    LogicError    Logical/validation error

  Options:
    --tool <name>               Tool that failed
    --step <desc>               Step in workflow

SIGNALS (observe)
  lore observe "Users frequently ask about retry logic"

  Raw signals go to inbox for later triage.

CONCEPTS (capture --concept)
  lore capture "Fail-silent wrappers" --concept --definition "Library calls that catch errors"

  Options:
    --definition <text>     What this concept means
EOF
}

show_help_recall() {
    cat << 'EOF'
RECALL COMMANDS

Read from memory with a single verb. Flags select the read mode.

  lore recall "authentication"              → search (default)
  lore recall --routed "authentication"    → smart Lore + Engram routing
  lore recall --project council             → full project context
  lore recall --patterns "API design"       → relevant patterns
  lore recall --failures --type Timeout     → filtered failure list
  lore recall --triggers                    → recurring failure analysis
  lore recall --concepts "fail-silent"      → concept search
  lore recall --brief "graph"               → topic-scoped briefing

The default (bare recall with a query) performs a ranked search across all
components. Add flags to request specific read modes.

SEARCH (default)
  lore recall "query"
  lore recall "query" --graph-depth 2       Follow graph edges
  lore recall "query" --compact             Machine-readable output

PROJECT CONTEXT
  lore recall --project <name>              Registry, decisions, patterns, graph

PATTERNS
  lore recall --patterns                    All patterns
  lore recall --patterns "deployment"       Ranked search via FTS5

FAILURES
  lore recall --failures                    All failures
  lore recall --failures "permission"       Ranked search via FTS5
  lore recall --failures --type Timeout     Filter by error type

CONCEPTS
  lore recall --concepts                    List all concepts
  lore recall --concepts "deployment"       Ranked search via FTS5

TRIGGERS
  lore recall --triggers                    Types with 3+ occurrences
  lore recall --triggers 5                  Custom threshold

BRIEFING
  lore recall --brief "topic"              Cross-component topic summary
EOF
}

show_help_search() {
    cat << 'EOF'
SEARCH COMMANDS

Find knowledge across all Lore components.

BASIC SEARCH
  lore search "authentication"
  lore search "retry logic"

  Searches: journal, patterns, sessions, graph, inbox

  Uses FTS5 ranked search with 5-factor scoring:
    BM25 * recency * frequency * importance * project_boost

  Falls back to grep when no search index exists.

GRAPH TRAVERSAL
  --graph-depth N     Follow knowledge graph edges (0-3, default 0)

  lore search "auth" --graph-depth 2

  Depth 0: Direct matches only
  Depth 1: Include directly connected concepts
  Depth 2: Two hops from matches
  Depth 3: Maximum traversal

OTHER QUERIES
  lore context <project>    Assemble full context for a project
  lore suggest <text>       Get pattern suggestions for context
  lore failures             List recorded failures
  lore triggers             Show recurring failure patterns (3+ occurrences)
  lore promote-failure T   Promote error type T to anti-pattern (--fix, --threshold)

BUILDING THE INDEX
  lore index                Build/rebuild FTS5 search index

  Run after bulk imports or if search seems stale.
EOF
}

show_help_intent() {
    cat << 'EOF'
INTENT COMMANDS

Goals define what you're trying to achieve.

GOALS
  lore goal create "Implement user authentication"
  lore goal list
  lore goal list --status active
  lore goal show <goal-id>

  Status values: draft, active, blocked, completed, cancelled

SPEC MANAGEMENT (SDD Integration)
  lore spec list                    List specs by status
  lore spec context <goal-id>       Full context for a spec
  lore spec assign <goal-id>        Assign spec to current session
  lore spec progress <goal-id>      Update phase (specify/plan/tasks/implement)
  lore spec complete <goal-id>      Mark spec complete with outcome

Specs track work through the specify → plan → tasks → implement lifecycle.
Lore captures the durable knowledge; specs are ephemeral in feature branches.
EOF
}

show_help_registry() {
    cat << 'EOF'
REGISTRY COMMANDS

Project metadata and cross-project relationships.

QUERY
  lore registry list                List all registered projects
  lore registry show <project>      Show project details with context
  lore registry context <project>   Alias for 'show' (deprecated)

VALIDATION
  lore registry validate            Check registry consistency
  lore validate                     Comprehensive validation (all components)

DIRECT ACCESS
  lore registry <subcommand>        Pass through to registry.sh

Registry data lives in:
  registry/data/metadata.yaml       Project metadata
  registry/data/clusters.yaml       Project groupings
  registry/data/relationships.yaml  Cross-project dependencies
  registry/data/contracts.yaml      Interface contracts
EOF
}

show_help_components() {
    cat << 'EOF'
COMPONENTS

Lore has eight components. Each answers one question.

  journal/    "Why did we choose this?"     Decision capture with rationale
  patterns/   "What did we learn?"          Patterns and anti-patterns
  transfer/   "What's next?"                Session handoff and resume
  graph/      "What relates to this?"       Knowledge graph
  inbox/      "What did we notice?"         Raw signal staging
  intent/     "What are we trying to do?"   Goals and specs
  failures/   "What went wrong?"            Failure reports
  registry/   "What exists?"                Project metadata

DIRECT ACCESS
  lore journal <command>            Decision journal commands
  lore patterns <command>           Pattern commands
  lore transfer <command>           Session management
  lore graph <command>              Knowledge graph
  lore inbox <command>              Inbox management
  lore intent <command>             Goals and specs

Run 'lore <component> --help' for component-specific help.

DATA FORMATS
  JSONL    journal, inbox, failures (append-only logs)
  JSON     graph, sessions (structured documents)
  YAML     patterns, goals, registry (human-editable)
EOF
}

# Help command router
cmd_help() {
    local topic="${1:-}"

    case "$topic" in
        "")
            show_help_full
            ;;
        capture|remember|learn|fail|observe)
            show_help_capture
            ;;
        recall)
            show_help_recall
            ;;
        search|query|find)
            show_help_search
            ;;
        intent|goal|goals|spec)
            show_help_intent
            ;;
        registry|project|projects)
            show_help_registry
            ;;
        components|component|journal|patterns|graph|transfer|inbox|failures)
            show_help_components
            ;;
        *)
            echo "Unknown help topic: $topic"
            echo ""
            echo "Available topics:"
            echo "  capture     Decisions, patterns, failures, signals"
            echo "  recall      Read modes and flags"
            echo "  search      Search modes and options"
            echo "  intent      Goals, specs"
            echo "  registry    Project metadata"
            echo "  components  Direct component access"
            return 1
            ;;
    esac
}

# Quick commands that span components
cmd_remember() {
    # Dedup check now lives in journal/journal.sh cmd_record (--force passes through)
    "$LORE_DIR/journal/journal.sh" record "$@"

    # Sync decision to graph (background, fail-silent)
    "$LORE_DIR/graph/sync.sh" &>/dev/null &

    # Write-through to search index (background, fail-silent)
    local last_json
    last_json=$(tail -1 "$LORE_DECISIONS_FILE" 2>/dev/null)
    [[ -n "$last_json" ]] && bash "$LORE_DIR/lib/search-index.sh" index-one decision "$last_json" &>/dev/null &

    # Write-through to Engram (background, fail-silent)
    _bridge_sync_last_decision &>/dev/null &
}

cmd_learn() {
    # Dedup check now lives in patterns/patterns.sh cmd_capture (--force passes through)
    "$LORE_DIR/patterns/patterns.sh" capture "$@"

    # Write-through to search index (background, fail-silent)
    # Patterns are YAML — get the last entry as JSON
    local last_pattern
    last_pattern=$(yq -o=json '.patterns[-1]' "$LORE_PATTERNS_FILE" 2>/dev/null)
    [[ -n "$last_pattern" ]] && bash "$LORE_DIR/lib/search-index.sh" index-one pattern "$last_pattern" &>/dev/null &

    # Write-through to Engram (background, fail-silent)
    _bridge_sync_last_pattern &>/dev/null &
}

# Unified capture command — routes to remember/learn/fail based on flags
cmd_capture() {
    # --- JSON flag detection ---
    local _json_in=false _json_out=false
    for arg in "$@"; do
        case "$arg" in
            --json) _json_in=true; _json_out=true ;;
            --json-in) _json_in=true ;;
            --json-out) _json_out=true ;;
        esac
    done

    if [[ "$_json_in" == true || "$_json_out" == true ]]; then
        source "$LORE_DIR/lib/json-io.sh"
    fi

    # --- Input handling: JSON or traditional ---
    local stdin_text=""
    local capture_type=""
    local args=()
    local has_force=false

    if [[ "$_json_in" == true ]]; then
        # JSON input mode: read stdin, extract fields with jq, build args
        local _json_raw
        _json_raw=$(cat)

        if [[ -z "$_json_raw" ]]; then
            if [[ "$_json_out" == true ]]; then
                _json_error "Empty JSON input"
            else
                echo -e "${RED}Error: Empty JSON input${NC}" >&2
            fi
            return 1
        fi

        if ! echo "$_json_raw" | jq empty 2>/dev/null; then
            if [[ "$_json_out" == true ]]; then
                _json_error "Invalid JSON"
            else
                echo -e "${RED}Error: Invalid JSON${NC}" >&2
            fi
            return 1
        fi

        # Infer type from JSON keys
        capture_type=$(_infer_type_from_json "$_json_raw")

        # Extract fields and build args array (mirrors CLI flag format)
        local v
        case "$capture_type" in
            decision)
                v=$(_jq_str "$_json_raw" "decision"); [[ -n "$v" ]] && args+=("$v")
                v=$(_jq_str "$_json_raw" "rationale"); [[ -n "$v" ]] && args+=(--rationale "$v")
                v=$(_jq_csv "$_json_raw" "alternatives"); [[ -n "$v" ]] && args+=(--alternatives "$v")
                v=$(_jq_csv "$_json_raw" "tags"); [[ -n "$v" ]] && args+=(--tags "$v")
                v=$(_jq_str "$_json_raw" "decision_type"); [[ -n "$v" ]] && args+=(--type "$v")
                v=$(_jq_csv "$_json_raw" "files"); [[ -n "$v" ]] && args+=(--files "$v")
                v=$(_jq_str "$_json_raw" "valid_at"); [[ -n "$v" ]] && args+=(--valid-at "$v")
                ;;
            pattern)
                v=$(_jq_str "$_json_raw" "name")
                [[ -z "$v" ]] && v=$(_jq_str "$_json_raw" "pattern")
                [[ -n "$v" ]] && args+=("$v")
                v=$(_jq_str "$_json_raw" "context"); [[ -n "$v" ]] && args+=(--context "$v")
                v=$(_jq_str "$_json_raw" "solution"); [[ -n "$v" ]] && args+=(--solution "$v")
                v=$(_jq_str "$_json_raw" "problem"); [[ -n "$v" ]] && args+=(--problem "$v")
                v=$(_jq_str "$_json_raw" "category"); [[ -n "$v" ]] && args+=(--category "$v")
                v=$(_jq_str "$_json_raw" "origin"); [[ -n "$v" ]] && args+=(--origin "$v")
                v=$(_jq_str "$_json_raw" "example_bad"); [[ -n "$v" ]] && args+=(--example-bad "$v")
                v=$(_jq_str "$_json_raw" "example_good"); [[ -n "$v" ]] && args+=(--example-good "$v")
                ;;
            failure)
                v=$(_jq_str "$_json_raw" "error_type"); [[ -n "$v" ]] && args+=(--error-type "$v")
                v=$(_jq_str "$_json_raw" "message"); [[ -n "$v" ]] && args+=("$v")
                v=$(_jq_str "$_json_raw" "tool"); [[ -n "$v" ]] && args+=(--tool "$v")
                v=$(_jq_str "$_json_raw" "step"); [[ -n "$v" ]] && args+=(--step "$v")
                ;;
            signal)
                v=$(_jq_str "$_json_raw" "content")
                [[ -z "$v" ]] && v=$(_jq_str "$_json_raw" "text")
                [[ -n "$v" ]] && args+=("$v")
                v=$(_jq_str "$_json_raw" "source"); [[ -n "$v" ]] && args+=(--source "$v")
                v=$(_jq_csv "$_json_raw" "tags"); [[ -n "$v" ]] && args+=(--tags "$v")
                ;;
            evidence)
                v=$(_jq_str "$_json_raw" "content")
                [[ -z "$v" ]] && v=$(_jq_str "$_json_raw" "text")
                [[ -n "$v" ]] && args+=("$v")
                v=$(_jq_str "$_json_raw" "confidence"); [[ -n "$v" ]] && args+=(--confidence "$v")
                v=$(_jq_csv "$_json_raw" "tags"); [[ -n "$v" ]] && args+=(--tags "$v")
                v=$(_jq_str "$_json_raw" "source"); [[ -n "$v" ]] && args+=(--source "$v")
                v=$(_jq_str "$_json_raw" "provenance"); [[ -n "$v" ]] && args+=(--provenance "$v")
                ;;
            concept)
                v=$(_jq_str "$_json_raw" "name"); [[ -n "$v" ]] && args+=("$v")
                v=$(_jq_str "$_json_raw" "definition"); [[ -n "$v" ]] && args+=(--definition "$v")
                ;;
        esac

        # Check for force flag in JSON
        v=$(echo "$_json_raw" | jq -r '.force // empty' 2>/dev/null) || true
        [[ "$v" == "true" ]] && { has_force=true; args+=(--force); }
    else
        # Traditional input mode: read from stdin if piped
        if [[ ! -t 0 ]]; then
            stdin_text=$(cat)
        fi

        capture_type=$(infer_capture_type "$@")

        # Strip explicit type flags, --force, and JSON flags
        local end_of_opts=false
        for arg in "$@"; do
            if [[ "$end_of_opts" == true ]]; then
                args+=("$arg")
                continue
            fi
            case "$arg" in
                --) end_of_opts=true ;;
                --decision|--pattern|--failure|--observation|--signal|--evidence|--concept) continue ;;
                --json|--json-in|--json-out) continue ;;
                --force) has_force=true; args+=("$arg") ;;
                *) args+=("$arg") ;;
            esac
        done

        # Prepend stdin text if no positional text was given
        if [[ -n "$stdin_text" ]]; then
            local has_positional=false
            local skip_next=false
            for arg in "${args[@]}"; do
                if [[ "$skip_next" == true ]]; then
                    skip_next=false
                    continue
                fi
                case "$arg" in
                    --rationale|--solution|--error-type|--tags|-t|--source|-s|--confidence|--provenance|--context|--tool|--step|--definition)
                        skip_next=true ;;
                    -*) ;;
                    *) has_positional=true; break ;;
                esac
            done
            if [[ "$has_positional" == false ]]; then
                args=("$stdin_text" "${args[@]}")
            fi
        fi
    fi

    # --- JSON-out dedup: run at this level, force downstream ---
    local _dup_id=""
    if [[ "$_json_out" == true && "$has_force" == false ]]; then
        if [[ "$capture_type" == "decision" || "$capture_type" == "pattern" ]]; then
            source "$LORE_DIR/lib/conflict.sh" 2>/dev/null || true
            # Extract the text to check from args (first non-flag argument)
            local _dedup_text=""
            local _skip_next=false
            for arg in "${args[@]}"; do
                if [[ "$_skip_next" == true ]]; then
                    _skip_next=false
                    continue
                fi
                case "$arg" in
                    --*) _skip_next=true ;;
                    *) _dedup_text="$arg"; break ;;
                esac
            done
            if [[ -n "$_dedup_text" ]]; then
                _dup_id=$(lore_check_duplicate "$capture_type" "$_dedup_text" 2>/dev/null) || true
                if [[ -n "$_dup_id" ]]; then
                    _json_error "Duplicate detected" "$_dup_id"
                    return 1
                fi
            fi
            # Force downstream to skip redundant dedup
            args+=(--force)
        fi
    fi

    # --- Route to component handlers ---
    local _rc=0
    case "$capture_type" in
        signal)
            # Strip --force before passing to cmd_observe (it has no dedup check)
            local sig_args=()
            for arg in "${args[@]}"; do
                [[ "$arg" == "--force" ]] && continue
                sig_args+=("$arg")
            done
            if [[ "$_json_out" == true ]]; then
                cmd_observe "${sig_args[@]}" >/dev/null || _rc=$?
            else
                cmd_observe "${sig_args[@]}"
                return
            fi
            ;;
        decision)
            if [[ "$_json_out" == true ]]; then
                cmd_remember "${args[@]}" >/dev/null || _rc=$?
            else
                cmd_remember "${args[@]}"
            fi
            ;;
        pattern)
            if [[ "$_json_out" == true ]]; then
                cmd_learn "${args[@]}" >/dev/null || _rc=$?
            else
                cmd_learn "${args[@]}"
            fi
            ;;
        failure)
            # cmd_fail expects: <error_type> <message> [--tool T] [--step S]
            # capture uses --error-type <type> as a named flag, so convert it to positional
            # Strip --force (failures have no dedup)
            local fail_args=()
            local error_type=""
            local skip_next=false
            for arg in "${args[@]}"; do
                if [[ "$skip_next" == true ]]; then
                    skip_next=false
                    error_type="$arg"
                    continue
                fi
                if [[ "$arg" == "--error-type" ]]; then
                    skip_next=true
                    continue
                fi
                [[ "$arg" == "--force" ]] && continue
                fail_args+=("$arg")
            done
            if [[ "$_json_out" == true ]]; then
                if [[ -n "$error_type" ]]; then
                    cmd_fail "$error_type" "${fail_args[@]}" >/dev/null || _rc=$?
                else
                    cmd_fail "${fail_args[@]}" >/dev/null || _rc=$?
                fi
            else
                if [[ -n "$error_type" ]]; then
                    cmd_fail "$error_type" "${fail_args[@]}"
                else
                    cmd_fail "${fail_args[@]}"
                fi
            fi
            ;;
        evidence)
            source "$LORE_DIR/evidence/lib/evidence.sh"
            local evi_text="" evi_confidence="preliminary" evi_tags="" evi_source="manual" evi_provenance=""
            local skip_next=false
            for ((i=0; i<${#args[@]}; i++)); do
                if [[ "$skip_next" == true ]]; then
                    skip_next=false
                    continue
                fi
                case "${args[$i]}" in
                    --confidence)
                        evi_confidence="${args[$((i+1))]}"
                        skip_next=true ;;
                    --tags|-t)
                        evi_tags="${args[$((i+1))]}"
                        skip_next=true ;;
                    --source)
                        evi_source="${args[$((i+1))]}"
                        skip_next=true ;;
                    --provenance)
                        evi_provenance="${args[$((i+1))]}"
                        skip_next=true ;;
                    --force) ;;
                    --*) skip_next=true ;;
                    *)
                        [[ -z "$evi_text" ]] && evi_text="${args[$i]}" ;;
                esac
            done
            if [[ -z "$evi_text" ]]; then
                if [[ "$_json_out" == true ]]; then
                    _json_error "Evidence content required"
                else
                    echo -e "${RED}Error: Evidence content required${NC}" >&2
                    echo "Usage: lore capture \"text\" --evidence [--confidence preliminary|confirmed|contested|superseded]" >&2
                fi
                return 1
            fi
            local evi_id
            evi_id=$(evidence_append "$evi_text" "$evi_source" "$evi_tags" "$evi_confidence" "$evi_provenance")
            if [[ "$_json_out" != true ]]; then
                echo -e "${GREEN}Recorded evidence:${NC} ${BOLD}${evi_id}${NC}"
                echo -e "  ${CYAN}Confidence:${NC} $evi_confidence"
                echo -e "  ${CYAN}Content:${NC} ${evi_text:0:70}$([ ${#evi_text} -gt 70 ] && echo '...')"
            fi
            ;;
        concept)
            local definition=""
            local text=""
            local skip_next=false
            for ((i=0; i<${#args[@]}; i++)); do
                if [[ "$skip_next" == true ]]; then
                    skip_next=false
                    continue
                fi
                if [[ "${args[$i]}" == "--definition" && $((i+1)) -lt ${#args[@]} ]]; then
                    definition="${args[$((i+1))]}"
                    skip_next=true
                elif [[ "${args[$i]}" != --* ]]; then
                    text="${args[$i]}"
                fi
            done
            if [[ -z "$text" ]]; then
                if [[ "$_json_out" == true ]]; then
                    _json_error "Concept name required"
                else
                    echo -e "${RED}Error: Concept name required${NC}" >&2
                    echo "Usage: lore capture \"name\" --concept [--definition \"what it means\"]" >&2
                fi
                return 1
            fi
            local concept_id
            concept_id=$(write_concept "$(generate_concept_id)" "$text" "$definition" "manual")
            if [[ "$_json_out" != true ]]; then
                echo -e "${GREEN}Created concept:${NC} ${BOLD}${concept_id}${NC}"
                echo -e "  ${CYAN}Name:${NC} $text"
                [[ -n "$definition" ]] && echo -e "  ${CYAN}Definition:${NC} $definition"
            fi
            ;;
        *)
            if [[ "$_json_out" == true ]]; then
                _json_error "Unknown capture type: $capture_type"
            else
                echo -e "${RED}Error: Unknown capture type: $capture_type${NC}" >&2
            fi
            return 1
            ;;
    esac

    # --- JSON-out response: extract ID from storage and emit ---
    if [[ "$_json_out" == true ]]; then
        if [[ $_rc -ne 0 ]]; then
            _json_error "Capture failed"
            return $_rc
        fi

        local _out_id="" _out_ts=""
        case "$capture_type" in
            decision)
                _out_id=$(tail -1 "$LORE_DECISIONS_FILE" 2>/dev/null | jq -r '.id // empty' 2>/dev/null) || true
                _out_ts=$(tail -1 "$LORE_DECISIONS_FILE" 2>/dev/null | jq -r '.timestamp // empty' 2>/dev/null) || true
                ;;
            pattern)
                _out_id=$(yq -r '.patterns[-1].id // ""' "$LORE_PATTERNS_FILE" 2>/dev/null) || true
                _out_ts=$(yq -r '.patterns[-1].created_at // ""' "$LORE_PATTERNS_FILE" 2>/dev/null) || true
                ;;
            failure)
                _out_id=$(tail -1 "${LORE_FAILURES_DATA}/failures.jsonl" 2>/dev/null | jq -r '.id // empty' 2>/dev/null) || true
                _out_ts=$(tail -1 "${LORE_FAILURES_DATA}/failures.jsonl" 2>/dev/null | jq -r '.timestamp // empty' 2>/dev/null) || true
                ;;
            signal)
                _out_id=$(tail -1 "$LORE_SIGNALS_FILE" 2>/dev/null | jq -r '.id // empty' 2>/dev/null) || true
                _out_ts=$(tail -1 "$LORE_SIGNALS_FILE" 2>/dev/null | jq -r '.timestamp // empty' 2>/dev/null) || true
                ;;
            evidence)
                _out_id="${evi_id:-}"
                _out_ts=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
                ;;
            concept)
                _out_id="${concept_id:-}"
                _out_ts=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
                ;;
        esac

        if [[ -n "$_out_id" ]]; then
            _json_response "$_out_id" "$capture_type" "${_out_ts:-$(date -u +"%Y-%m-%dT%H:%M:%SZ")}"
        else
            _json_error "Write succeeded but ID extraction failed"
        fi
    fi
}

cmd_handoff() {
    "$LORE_DIR/transfer/transfer.sh" handoff "$@"
}

cmd_resume() {
    "$LORE_DIR/transfer/transfer.sh" resume "$@"

    # Check shadow sync health (advisory, fail-silent)
    _bridge_health_check 2>/dev/null || true
}

SEARCH_DB="${LORE_SEARCH_DB}"

# Derive current project from cwd
_derive_project() {
    local workspace_root
    workspace_root="$(dirname "$LORE_DIR")"
    local cwd
    cwd="$(pwd)"
    local project="${cwd#"$workspace_root/"}"
    [[ "$project" == "$cwd" ]] && { echo ""; return; }
    project="${project%%/*}"
    echo "$project"
}

# Log access for reinforcement scoring
_log_access() {
    local db="$1" type="$2" id="$3"
    sqlite3 "$db" \
        "INSERT OR IGNORE INTO access_log (record_type, record_id, accessed_at) VALUES ('$(echo "$type" | sed "s/'/''/g")', '$(echo "$id" | sed "s/'/''/g")', datetime('now'));" \
        2>/dev/null || true
}

# FTS5-based ranked search
_search_fts5() {
    local query="$1"
    local project="$2"
    local limit="${3:-10}"
    local graph_depth="${4:-0}"
    local compact="${5:-false}"
    local type_filter="${6:-}"

    # Escape for FTS5: quote each term to prevent operator interpretation,
    # then escape single quotes for SQL embedding
    local safe_query
    safe_query=$(echo "$query" | sed 's/"/""/g; s/[^ ][^ ]*/"&"/g')
    safe_query="${safe_query//\'/\'\'}"
    local safe_project="${project//\'/\'\'}"

    # Build SQL dynamically based on type filter
    local decision_sql="SELECT 'decision' as type, id, decision as content, project, timestamp, importance, rank * -1 as bm25_score FROM decisions WHERE decisions MATCH '${safe_query}'"
    local pattern_sql="SELECT 'pattern' as type, id, name || ': ' || solution as content, 'lore' as project, timestamp, CAST(confidence * 5 AS INT) as importance, rank * -1 as bm25_score FROM patterns WHERE patterns MATCH '${safe_query}'"
    local transfer_sql="SELECT 'transfer' as type, session_id as id, handoff as content, project, timestamp, 3 as importance, rank * -1 as bm25_score FROM transfers WHERE transfers MATCH '${safe_query}'"
    local failure_sql="SELECT 'failure' as type, id, error_type || ': ' || error_message as content, '' as project, timestamp, 3 as importance, rank * -1 as bm25_score FROM failures WHERE failures MATCH '${safe_query}'"
    local signal_sql="SELECT 'signal' as type, id, content as content, '' as project, timestamp, 2 as importance, rank * -1 as bm25_score FROM observations WHERE observations MATCH '${safe_query}'"
    local concept_sql="SELECT 'concept' as type, id, name || ': ' || definition as content, '' as project, timestamp, 4 as importance, rank * -1 as bm25_score FROM concepts WHERE concepts MATCH '${safe_query}'"

    local sql_parts=()
    case "$type_filter" in
        decision)    sql_parts=("$decision_sql") ;;
        pattern)     sql_parts=("$pattern_sql") ;;
        transfer)    sql_parts=("$transfer_sql") ;;
        failure)     sql_parts=("$failure_sql") ;;
        signal)      sql_parts=("$signal_sql") ;;
        concept)     sql_parts=("$concept_sql") ;;
        *)           sql_parts=("$decision_sql" "$pattern_sql" "$transfer_sql" "$failure_sql" "$signal_sql" "$concept_sql") ;;
    esac

    local union_sql
    union_sql=$(printf ' UNION ALL %s' "${sql_parts[@]}")
    union_sql="${union_sql# UNION ALL }"

    local results
    results=$(sqlite3 -separator $'\t' "$SEARCH_DB" <<SQL 2>/dev/null
WITH ranked AS (
    ${union_sql}
),
frequency AS (
    SELECT
        record_type,
        record_id,
        COUNT(*) as access_count,
        MAX(accessed_at) as last_access
    FROM access_log
    GROUP BY record_type, record_id
)
SELECT
    r.type,
    r.id,
    SUBSTR(r.content, 1, 200),
    r.project,
    SUBSTR(r.timestamp, 1, 10),
    ROUND(
        r.bm25_score
        * (1.0 / (1 + (julianday('now') - julianday(r.timestamp)) / 30))
        * COALESCE(1.0 + (LOG(1 + f.access_count) * 0.15), 1.0)
        * (1.0 + (r.importance / 5.0 * 0.2))
        * COALESCE(1.0 + (0.1 * EXP(-(julianday('now') - julianday(f.last_access)) / 30)), 1.0)
        * CASE WHEN r.project = '${safe_project}' THEN 1.5 ELSE 1.0 END
    , 2) as final_score
FROM ranked r
LEFT JOIN frequency f ON r.type = f.record_type AND r.id = f.record_id
ORDER BY final_score DESC
LIMIT ${limit};
SQL
    ) || true

    if [[ -z "$results" ]]; then
        [[ "$compact" != true ]] && echo -e "  ${DIM}(no results)${NC}"
        return
    fi

    if [[ "$compact" == true ]]; then
        while IFS=$'\t' read -r type id content proj date score; do
            local title="${content:0:80}"
            printf "  [%-8s] %-16s | %-80s | %-8s | %s | %s\n" \
                "$type" "$id" "$title" "$proj" "$date" "$score"
            _log_access "$SEARCH_DB" "$type" "$id"
        done <<< "$results"
        return
    fi

    if [[ "$graph_depth" -ge 1 ]]; then
        source "$LORE_DIR/lib/graph-traverse.sh"
    fi

    while IFS=$'\t' read -r type id content proj date score; do
        echo -e "  ${GREEN}[${type}]${NC} ${DIM}${id}:${NC} ${content} ${DIM}(score: ${score}, proj: ${proj}, date: ${date})${NC}"
        _log_access "$SEARCH_DB" "$type" "$id"

        # Graph traversal for this result
        if [[ "$graph_depth" -ge 1 ]]; then
            local node_id
            node_id=$(resolve_to_graph_id "$type" "$id" "$content" "$proj") || true
            if [[ -n "$node_id" ]]; then
                local graph_output
                graph_output=$(graph_traverse "$node_id" "$graph_depth") || true
                if [[ -n "$graph_output" ]]; then
                    echo -e "    ${DIM}Graph:${NC}"
                    while IFS= read -r gline; do
                        echo -e "      ${CYAN}${gline}${NC}"
                    done <<< "$graph_output"
                fi
            fi
        fi
    done <<< "$results"
}

# Grep-based fallback search (original behavior)
_search_grep() {
    local query="$1"

    echo -e "${CYAN}Journal:${NC}"
    "$LORE_DIR/journal/journal.sh" query "$query" 2>/dev/null || echo "  (no results)"
    echo ""

    echo -e "${CYAN}Graph:${NC}"
    "$LORE_DIR/graph/graph.sh" query "$query" 2>/dev/null || echo "  (no results)"
    echo ""

    echo -e "${CYAN}Patterns:${NC}"
    "$LORE_DIR/patterns/patterns.sh" list 2>/dev/null | grep -i "$query" || echo "  (no results)"
    echo ""

    echo -e "${CYAN}Failures:${NC}"
    local failures_file="${LORE_FAILURES_DATA}/failures.jsonl"
    if [[ -f "$failures_file" ]]; then
        grep -i "$query" "$failures_file" 2>/dev/null \
            | jq -s 'sort_by(.timestamp) | reverse | .[]' -c 2>/dev/null \
            | jq -r '"  \(.id) [\(.error_type)] \(.error_message[0:80])"' 2>/dev/null \
            || echo "  (no results)"
    else
        echo "  (no results)"
    fi
    echo ""

    echo -e "${CYAN}Inbox:${NC}"
    local inbox_file="${LORE_SIGNALS_FILE}"
    if [[ -f "$inbox_file" ]]; then
        grep -i "$query" "$inbox_file" 2>/dev/null \
            | jq -r '"  \(.id) [\(.status)] \(.content[0:80])"' 2>/dev/null \
            || echo "  (no results)"
    else
        echo "  (no results)"
    fi
    echo ""

    echo -e "${CYAN}Goals:${NC}"
    local goals_dir="${LORE_INTENT_DATA}/goals"
    if [[ -d "$goals_dir" ]] && ls "$goals_dir"/*.yaml &>/dev/null; then
        grep -li "$query" "$goals_dir"/*.yaml 2>/dev/null \
            | while read -r f; do
                local name
                name=$(basename "$f" .yaml)
                echo "  $name"
            done
        [[ ${PIPESTATUS[0]} -ne 0 ]] && echo "  (no results)"
    else
        echo "  (no results)"
    fi
    echo ""

    echo -e "${CYAN}Registry:${NC}"
    local found_registry=false
    for reg_file in "${LORE_REGISTRY_DATA}"/*.yaml; do
        [[ -f "$reg_file" ]] || continue
        if grep -qi "$query" "$reg_file" 2>/dev/null; then
            echo "  $(basename "$reg_file"): $(grep -ci "$query" "$reg_file" 2>/dev/null) match(es)"
            found_registry=true
        fi
    done
    [[ "$found_registry" == false ]] && echo "  (no results)"
}

cmd_search() {
    local query=""
    local graph_depth=0
    local compact=false

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --graph-depth)
                graph_depth="$2"
                if [[ "$graph_depth" -lt 0 || "$graph_depth" -gt 3 ]]; then
                    echo -e "${RED}Error: --graph-depth must be 0-3${NC}" >&2
                    return 1
                fi
                shift 2
                ;;
            --compact)
                compact=true
                shift
                ;;
            -*)
                echo -e "${RED}Unknown option: $1${NC}" >&2
                echo "Usage: lore search <query> [--compact] [--graph-depth 0-3]" >&2
                return 1
                ;;
            *)
                query="$1"
                shift
                ;;
        esac
    done

    if [[ -z "$query" ]]; then
        echo -e "${RED}Error: Search query required${NC}" >&2
        echo "Usage: lore search <query> [--compact] [--graph-depth 0-3]" >&2
        return 1
    fi

    local project
    project=$(_derive_project)

    if [[ -f "$SEARCH_DB" ]]; then
        if [[ "$compact" != true ]]; then
            echo -e "${BOLD}Searching Lore...${NC}"
            [[ -n "$project" ]] && echo -e "${DIM}Project boost: ${project}${NC}"
            [[ "$graph_depth" -ge 1 ]] && echo -e "${DIM}Graph depth: ${graph_depth}${NC}"
            echo ""
        fi

        _search_fts5 "$query" "$project" 10 "$graph_depth" "$compact"
    else
        echo -e "${BOLD}Searching Lore (grep fallback — run 'lore index' to enable ranked search)...${NC}"
        echo ""
        _search_grep "$query"
    fi
}

cmd_recall() {
    local mode=""
    local project=""
    local brief_topic=""
    local pass_through=()
    local query=""
    local compact=false

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --routed)
                mode="routed"
                shift
                ;;
            --project)
                mode="project"
                project="${2:-}"
                if [[ -z "$project" ]]; then
                    echo -e "${RED}Error: --project requires a name${NC}" >&2
                    return 1
                fi
                shift 2
                ;;
            --patterns)
                mode="patterns"
                shift
                # Remaining args are context for suggest
                while [[ $# -gt 0 && "$1" != --* ]]; do
                    pass_through+=("$1")
                    shift
                done
                ;;
            --concepts)
                mode="concepts"
                shift
                while [[ $# -gt 0 && "$1" != --* ]]; do
                    pass_through+=("$1")
                    shift
                done
                ;;
            --failures)
                mode="failures"
                shift
                # Pass through --type if present
                while [[ $# -gt 0 ]]; do
                    pass_through+=("$1")
                    shift
                done
                ;;
            --triggers)
                mode="triggers"
                shift
                # Pass through threshold if present
                if [[ $# -gt 0 && "$1" != --* ]]; then
                    pass_through+=("$1")
                    shift
                fi
                ;;
            --brief)
                mode="brief"
                brief_topic="${2:-}"
                if [[ -z "$brief_topic" ]]; then
                    echo -e "${RED}Error: --brief requires a topic${NC}" >&2
                    return 1
                fi
                shift 2
                ;;
            --graph-depth|--compact)
                # Search flags — pass through to cmd_search
                pass_through+=("$1")
                [[ "$1" == "--compact" ]] && compact=true
                if [[ "$1" == "--graph-depth" ]]; then
                    pass_through+=("${2:-}")
                    shift
                fi
                shift
                ;;
            -*)
                echo -e "${RED}Unknown option: $1${NC}" >&2
                echo "Run 'lore help recall' for usage." >&2
                return 1
                ;;
            *)
                query="$1"
                shift
                ;;
        esac
    done

    case "$mode" in
        routed)
            if [[ -z "$query" ]]; then
                echo -e "${RED}Error: Query required for --routed${NC}" >&2
                echo "Usage: lore recall --routed <query> [--compact] [--graph-depth N]" >&2
                return 1
            fi

            # Extract graph_depth from pass_through if present
            local graph_depth=0
            for i in "${!pass_through[@]}"; do
                if [[ "${pass_through[$i]}" == "--graph-depth" ]]; then
                    graph_depth="${pass_through[$i+1]}"
                    break
                fi
            done

            source "$LORE_DIR/lib/recall-router.sh"
            routed_recall "$query" "$compact" 10 "$graph_depth"
            ;;
        project)
            cmd_context "$project"
            ;;
        patterns)
            if [[ -f "$LORE_SEARCH_DB" && ${#pass_through[@]} -gt 0 ]]; then
                _search_fts5 "${pass_through[*]}" "$(_derive_project)" 10 0 false "pattern"
            else
                cmd_suggest "${pass_through[@]}"
            fi
            ;;
        failures)
            if [[ -f "$LORE_SEARCH_DB" && ${#pass_through[@]} -gt 0 ]]; then
                # --type is a filter op, not search — delegate to cmd_failures
                local has_type_flag=false
                for arg in "${pass_through[@]}"; do
                    [[ "$arg" == "--type" ]] && has_type_flag=true
                done
                if [[ "$has_type_flag" == true ]]; then
                    cmd_failures "${pass_through[@]}"
                else
                    _search_fts5 "${pass_through[*]}" "" 10 0 false "failure"
                fi
            else
                cmd_failures "${pass_through[@]}"
            fi
            ;;
        triggers)
            cmd_triggers "${pass_through[@]}"
            ;;
        concepts)
            if [[ -f "$LORE_SEARCH_DB" && ${#pass_through[@]} -gt 0 ]]; then
                _search_fts5 "${pass_through[*]}" "$(_derive_project)" 10 0 false "concept"
            else
                local cf="${LORE_CONCEPTS_FILE}"
                if [[ -f "$cf" ]] && command -v yq &>/dev/null; then
                    local count
                    count=$(yq '.concepts | length' "$cf" 2>/dev/null) || count=0
                    if [[ "$count" -eq 0 ]]; then
                        echo -e "${YELLOW}No concepts found${NC}"
                    else
                        echo -e "${GREEN}Concepts (${count}):${NC}"
                        echo ""
                        yq -r '.concepts[] | "  " + .id + "  " + .name + "\n    " + (.definition // "-")' "$cf"
                    fi
                else
                    echo -e "${YELLOW}No concepts found${NC}"
                fi
            fi
            ;;
        brief)
            source "$LORE_DIR/lib/brief.sh"
            cmd_brief "$brief_topic"
            ;;
        "")
            if [[ -z "$query" ]]; then
                echo -e "${RED}Error: Query or flag required${NC}" >&2
                echo "Usage: lore recall <query> | --project <name> | --patterns | --failures | --triggers | --concepts | --brief <topic>" >&2
                echo "Run 'lore help recall' for details." >&2
                return 1
            fi
            cmd_search "$query" "${pass_through[@]}"
            ;;
    esac
}

cmd_status() {
    "$LORE_DIR/transfer/transfer.sh" status
}

cmd_suggest() {
    "$LORE_DIR/patterns/patterns.sh" suggest "$@"
}

cmd_context() {
    local project="${1:-}"

    if [[ -z "$project" ]]; then
        echo -e "${RED}Error: Project name required${NC}" >&2
        echo "Usage: lore context <project>" >&2
        return 1
    fi

    # Registry metadata (basics, deps, cluster, entry point)
    # Outputs markdown format; errors suppressed if project not in mani
    if "$LORE_DIR/registry/registry.sh" context "$project" 2>/dev/null; then
        echo ""
    else
        # Fallback header if registry unavailable
        echo -e "# ${project}"
        echo ""
    fi

    # Recent decisions
    echo "## Recent Decisions"
    echo ""
    local decisions
    decisions=$("$LORE_DIR/journal/journal.sh" query "$project" --project "$project" 2>/dev/null) || true
    if [[ -n "$decisions" ]]; then
        echo "$decisions"
    else
        echo "(none)"
    fi
    echo ""

    # Relevant patterns
    echo "## Patterns"
    echo ""
    local patterns
    patterns=$("$LORE_DIR/patterns/patterns.sh" suggest "$project" 2>/dev/null) || true
    if [[ -n "$patterns" ]]; then
        echo "$patterns"
    else
        echo "(none)"
    fi
    echo ""

    # Graph relationships
    echo "## Related Concepts"
    echo ""
    local node_id
    node_id=$("$LORE_DIR/graph/graph.sh" list project 2>/dev/null \
        | awk -v p="$project" '{gsub(/\033\[[0-9;]*m/,"")} tolower($3) == tolower(p) { print $1 }')

    if [[ -n "$node_id" ]]; then
        "$LORE_DIR/graph/graph.sh" related "$node_id" --hops 2 2>/dev/null || echo "(no neighbors)"
    else
        echo "(project not in graph)"
    fi
}

cmd_fail() {
    source "$LORE_DIR/failures/lib/failures.sh"

    local error_type=""
    local message=""
    local tool=""
    local step=""

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --tool|-t)
                tool="$2"
                shift 2
                ;;
            --step|-s)
                step="$2"
                shift 2
                ;;
            -*)
                echo -e "${RED}Unknown option: $1${NC}" >&2
                return 1
                ;;
            *)
                if [[ -z "$error_type" ]]; then
                    error_type="$1"
                elif [[ -z "$message" ]]; then
                    message="$1"
                else
                    message="$message $1"
                fi
                shift
                ;;
        esac
    done

    if [[ -z "$error_type" || -z "$message" ]]; then
        echo -e "${RED}Error: error_type and message required${NC}" >&2
        echo "Usage: lore fail <error_type> <message> [--tool T] [--step S]" >&2
        echo "Types: UserDeny HardDeny NonZeroExit Timeout ToolError LogicError" >&2
        return 1
    fi

    local id
    id=$(failures_append "$error_type" "$message" "$tool" "$step")

    echo -e "${GREEN}Logged:${NC} ${BOLD}$id${NC}"
    echo -e "  ${CYAN}Type:${NC} $error_type"
    echo -e "  ${CYAN}Message:${NC} $message"
    [[ -n "$tool" ]] && echo -e "  ${CYAN}Tool:${NC} $tool"

    # Write-through to search index (background, fail-silent)
    local last_json
    last_json=$(tail -1 "${LORE_FAILURES_DATA}/failures.jsonl" 2>/dev/null)
    [[ -n "$last_json" ]] && bash "$LORE_DIR/lib/search-index.sh" index-one failure "$last_json" &>/dev/null &

    # Auto-suggest promotion if this error type now has 3+ occurrences
    local type_count
    type_count=$(jq -s --arg t "$error_type" \
        '[.[] | select(.error_type == $t)] | length' \
        "${LORE_FAILURES_DATA}/failures.jsonl" 2>/dev/null) || true
    if [[ -n "$type_count" && "$type_count" -ge 3 ]]; then
        echo "" >&2
        echo -e "${YELLOW}This error type has occurred ${type_count} times.${NC}" >&2
        echo -e "${YELLOW}Run \`lore promote-failure ${error_type}\` to create an anti-pattern.${NC}" >&2
    fi
}

cmd_failures() {
    source "$LORE_DIR/failures/lib/failures.sh"

    local filter_type=""

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --type)
                filter_type="$2"
                shift 2
                ;;
            -*)
                echo -e "${RED}Unknown option: $1${NC}" >&2
                return 1
                ;;
            *)
                echo -e "${RED}Unknown argument: $1${NC}" >&2
                return 1
                ;;
        esac
    done

    local results
    results=$(failures_list "$filter_type")

    local count
    count=$(echo "$results" | jq 'length')

    if [[ "$count" -eq 0 ]]; then
        echo -e "${YELLOW}No failures found${NC}"
        return 0
    fi

    echo -e "${GREEN}Failures ($count):${NC}"
    echo

    echo "$results" | jq -r '.[] | "  \(.id) [\(.error_type)] \(.timestamp[0:16])\n    \(.error_message[0:70])\(.error_message | if length > 70 then "..." else "" end)\n"'
}

cmd_triggers() {
    source "$LORE_DIR/failures/lib/failures.sh"

    local threshold="${1:-3}"

    local results
    results=$(failures_triggers "$threshold")

    local count
    count=$(echo "$results" | jq 'length')

    if [[ "$count" -eq 0 ]]; then
        echo -e "${YELLOW}No recurring failure types (threshold: ${threshold})${NC}"
        return 0
    fi

    echo -e "${GREEN}Recurring Failures (>= ${threshold} occurrences):${NC}"
    echo

    echo "$results" | jq -r '.[] | "  \(.error_type): \(.count) occurrences (latest: \(.latest[0:16]))\n    Sample: \(.sample_message[0:70])\n"'
}

cmd_promote_failure() {
    source "$LORE_DIR/failures/lib/failures.sh"

    local error_type=""
    local fix=""
    local threshold=3

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --fix)
                fix="$2"
                shift 2
                ;;
            --threshold)
                threshold="$2"
                shift 2
                ;;
            -*)
                echo -e "${RED}Unknown option: $1${NC}" >&2
                echo "Usage: lore promote-failure [error_type] [--fix \"how to fix\"] [--threshold N]" >&2
                return 1
                ;;
            *)
                if [[ -z "$error_type" ]]; then
                    error_type="$1"
                fi
                shift
                ;;
        esac
    done

    # Get recurring failure types
    local triggers
    triggers=$(failures_triggers "$threshold")

    local trigger_count
    trigger_count=$(echo "$triggers" | jq 'length')

    if [[ "$trigger_count" -eq 0 ]]; then
        echo -e "${YELLOW}No recurring failure types (threshold: ${threshold})${NC}"
        return 0
    fi

    # If a specific type was given, filter to that type
    if [[ -n "$error_type" ]]; then
        local filtered
        filtered=$(echo "$triggers" | jq --arg t "$error_type" '[.[] | select(.error_type == $t)]')
        local filtered_count
        filtered_count=$(echo "$filtered" | jq 'length')

        if [[ "$filtered_count" -eq 0 ]]; then
            echo -e "${RED}Error type '${error_type}' has fewer than ${threshold} occurrences${NC}" >&2
            return 1
        fi
        triggers="$filtered"
    fi

    # Process each qualifying failure type
    echo "$triggers" | jq -c '.[]' | while IFS= read -r trigger; do
        local etype ecount sample_msg
        etype=$(echo "$trigger" | jq -r '.error_type')
        ecount=$(echo "$trigger" | jq -r '.count')
        sample_msg=$(echo "$trigger" | jq -r '.sample_message')

        # Gather all messages of this type for a richer symptom
        local all_messages
        all_messages=$(jq -s --arg t "$etype" \
            '[.[] | select(.error_type == $t) | .error_message] | unique | .[0:5] | join("; ")' \
            "${LORE_FAILURES_DATA}/failures.jsonl" 2>/dev/null) || true
        # Strip surrounding quotes from jq output
        all_messages="${all_messages%\"}"
        all_messages="${all_messages#\"}"

        local name="PITFALL: ${etype}"
        local symptom="${all_messages:-$sample_msg}"
        local risk="Recurring failure (${ecount} occurrences)"
        local severity="medium"
        local category="general"

        # Increase severity for high-count failures
        if [[ "$ecount" -ge 10 ]]; then
            severity="high"
        elif [[ "$ecount" -ge 5 ]]; then
            severity="medium"
        fi

        # Detect category from error type
        case "$etype" in
            ToolError)  category="general" ;;
            Timeout)    category="performance" ;;
            *)          category="general" ;;
        esac

        echo -e "${BOLD}Promoting ${etype} (${ecount} occurrences) to anti-pattern...${NC}"

        "$LORE_DIR/patterns/patterns.sh" warn "$name" \
            --symptom "$symptom" \
            --fix "${fix:-}" \
            --risk "$risk" \
            --severity "$severity" \
            --category "$category"

        echo ""
    done
}

journal_add() {
    local entry_type="" project="" title="" body="" tags=""

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --type)     entry_type="$2"; shift 2 ;;
            --project)  project="$2"; shift 2 ;;
            --title)    title="$2"; shift 2 ;;
            --body)     body="$2"; shift 2 ;;
            --tags)     tags="$2"; shift 2 ;;
            --force)    local force=true; shift ;;
            -*)
                echo -e "${RED}Unknown option: $1${NC}" >&2
                echo "Usage: lore journal add --type <type> --project <project> --title <title> --body <body> [--tags <tags>]" >&2
                return 1
                ;;
            *)
                echo -e "${RED}Unexpected argument: $1${NC}" >&2
                return 1
                ;;
        esac
    done

    # Validate required fields
    if [[ -z "$entry_type" ]]; then
        echo -e "${RED}Error: --type required (decision, discovery, session, incident)${NC}" >&2
        return 1
    fi
    if [[ -z "$project" ]]; then
        echo -e "${RED}Error: --project required${NC}" >&2
        return 1
    fi
    if [[ -z "$title" ]]; then
        echo -e "${RED}Error: --title required${NC}" >&2
        return 1
    fi
    if [[ -z "$body" ]]; then
        echo -e "${RED}Error: --body required${NC}" >&2
        return 1
    fi

    # Validate type
    case "$entry_type" in
        decision|discovery|session|incident) ;;
        *)
            echo -e "${RED}Error: --type must be one of: decision, discovery, session, incident${NC}" >&2
            return 1
            ;;
    esac

    # Validate project exists in mani.yaml
    local workspace_root
    workspace_root="$(cd "$LORE_DIR/.." && pwd)"
    local mani_file="${MANI_FILE:-$workspace_root/mani.yaml}"
    if ! grep -q "^  ${project}:" "$mani_file" 2>/dev/null; then
        echo -e "${RED}Error: Project '${project}' not found in mani.yaml${NC}" >&2
        return 1
    fi

    # Validate title length
    if [[ ${#title} -gt 120 ]]; then
        echo -e "${RED}Error: Title exceeds 120 characters (${#title})${NC}" >&2
        return 1
    fi

    # Dedup guard
    if [[ "${force:-false}" == false ]]; then
        local _conflict_lib="$LORE_DIR/lib/conflict.sh"
        if [[ -f "$_conflict_lib" ]]; then
            local _check_text="${title} ${body}"
            if source "$_conflict_lib" 2>/dev/null; then
                if ! lore_check_duplicate "decision" "$_check_text"; then
                    return 1
                fi
            fi
        fi
    fi

    # Contradiction check: warn if new entry conflicts with existing active decisions
    if [[ "${force:-false}" == false ]]; then
        local _conflict_lib="$LORE_DIR/lib/conflict.sh"
        if [[ -f "$_conflict_lib" ]]; then
            local _contra_text="${title} ${body}"
            if source "$_conflict_lib" 2>/dev/null; then
                lore_check_contradiction "$_contra_text" || true
            fi
        fi
    fi

    # Generate slug from title
    local slug
    slug=$(echo "$title" | tr '[:upper:]' '[:lower:]' | tr ' ' '-' | tr -cd '[:alnum:]-' | head -c 60)

    # Generate filename
    local datestamp
    datestamp=$(date +%Y-%m-%d)
    local entries_dir="${LORE_JOURNAL_DATA}/entries"
    mkdir -p "$entries_dir"
    local filename="${datestamp}_${slug}.md"

    # Build tags array for YAML front matter
    local tags_yaml="[]"
    if [[ -n "$tags" ]]; then
        tags_yaml="[$(echo "$tags" | sed 's/,/, /g')]"
    fi

    # Write markdown file with YAML front matter
    local created
    created=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
    cat > "$entries_dir/$filename" <<FRONTMATTER
---
type: ${entry_type}
project: ${project}
title: ${title}
tags: ${tags_yaml}
created: ${created}
---

${body}
FRONTMATTER

    # Backward compat: also record to JSONL via journal.sh
    local record_args=("$title" --rationale "$body" --tags "${project}${tags:+,$tags}" --type "$entry_type")
    if [[ "${force:-false}" == true ]]; then
        record_args+=(--force)
    fi
    "$LORE_DIR/journal/journal.sh" record "${record_args[@]}" >/dev/null 2>&1 || true

    # Sync to graph (background, fail-silent)
    "$LORE_DIR/graph/sync.sh" &>/dev/null &

    echo -e "${GREEN}Created:${NC} ${BOLD}journal/data/entries/${filename}${NC}"
    echo -e "  ${CYAN}Type:${NC} $entry_type"
    echo -e "  ${CYAN}Project:${NC} $project"
    echo -e "  ${CYAN}Title:${NC} $title"
    [[ -n "$tags" ]] && echo -e "  ${CYAN}Tags:${NC} $tags"
}

cmd_observe() {
    source "$LORE_DIR/inbox/lib/inbox.sh"

    local content=""
    local source="manual"
    local tags=""

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --)
                shift
                # Remaining args are all content
                while [[ $# -gt 0 ]]; do
                    content="${content:+$content }$1"
                    shift
                done
                break
                ;;
            --source|-s)
                source="$2"
                shift 2
                ;;
            --tags|-t)
                tags="$2"
                shift 2
                ;;
            -*)
                echo -e "${RED}Unknown option: $1${NC}" >&2
                return 1
                ;;
            *)
                if [[ -z "$content" ]]; then
                    content="$1"
                else
                    content="$content $1"
                fi
                shift
                ;;
        esac
    done

    # Read from stdin if no positional text and stdin is piped
    if [[ -z "$content" ]] && [[ ! -t 0 ]]; then
        content=$(cat)
    fi

    if [[ -z "$content" ]]; then
        echo -e "${RED}Error: Signal text required${NC}" >&2
        echo "Usage: lore observe <text> [--source <source>] [--tags <tags>]" >&2
        return 1
    fi

    local id
    id=$(signal_append "$content" "$source" "$tags")

    echo -e "${GREEN}Signal:${NC} ${BOLD}$id${NC}"
    echo -e "  ${CYAN}Content:${NC} $content"
    if [[ "$source" != "manual" ]]; then
        echo -e "  ${CYAN}Source:${NC} $source"
    fi

    # Sync signals to graph (background, fail-silent)
    "$LORE_DIR/graph/sync-observations.sh" &>/dev/null &

    # Write-through to search index (background, fail-silent)
    local last_json
    last_json=$(tail -1 "$LORE_SIGNALS_FILE" 2>/dev/null)
    [[ -n "$last_json" ]] && bash "$LORE_DIR/lib/search-index.sh" index-one signal "$last_json" &>/dev/null &
}

cmd_inbox() {
    source "$LORE_DIR/inbox/lib/inbox.sh"

    local filter_status=""

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --status)
                filter_status="$2"
                shift 2
                ;;
            -*)
                echo -e "${RED}Unknown option: $1${NC}" >&2
                return 1
                ;;
            *)
                echo -e "${RED}Unknown argument: $1${NC}" >&2
                return 1
                ;;
        esac
    done

    local results
    results=$(signal_list "$filter_status")

    local count
    count=$(echo "$results" | jq 'length')

    if [[ "$count" -eq 0 ]]; then
        echo -e "${YELLOW}No signals found${NC}"
        return 0
    fi

    echo -e "${GREEN}Signals ($count):${NC}"
    echo

    echo "$results" | jq -r '.[] | "  \(.id) [\(.status)] \(.timestamp[0:16])\n    \(.content[0:70])\(.content | if length > 70 then "..." else "" end)\n"'
}


cmd_evidence() {
    source "$LORE_DIR/evidence/lib/evidence.sh"

    local subcmd="${1:-list}"
    shift 2>/dev/null || true

    case "$subcmd" in
        list)
            local filter_confidence=""
            while [[ $# -gt 0 ]]; do
                case "$1" in
                    --confidence) filter_confidence="$2"; shift 2 ;;
                    *) echo -e "${RED}Unknown option: $1${NC}" >&2; return 1 ;;
                esac
            done

            local results
            results=$(evidence_list "$filter_confidence")

            local count
            count=$(echo "$results" | jq 'length')

            if [[ "$count" -eq 0 ]]; then
                echo -e "${YELLOW}No evidence found${NC}"
                return 0
            fi

            echo -e "${GREEN}Evidence ($count):${NC}"
            echo

            echo "$results" | jq -r '.[] | "  \(.id) [\(.confidence)] \(.timestamp[0:16])\n    \(.content[0:70])\(.content | if length > 70 then "..." else "" end)\n"'
            ;;
        get)
            local evi_id="${1:-}"
            if [[ -z "$evi_id" ]]; then
                echo -e "${RED}Error: Evidence ID required${NC}" >&2
                echo "Usage: lore evidence get <id>" >&2
                return 1
            fi

            local record
            record=$(evidence_get "$evi_id")

            if [[ -z "$record" ]]; then
                echo -e "${RED}Error: Evidence $evi_id not found${NC}" >&2
                return 1
            fi

            echo "$record" | jq .
            ;;
        stats)
            evidence_stats | jq .
            ;;
        *)
            echo -e "${RED}Unknown evidence command: $subcmd${NC}" >&2
            echo "Usage: lore evidence <list|get|stats>" >&2
            return 1
            ;;
    esac
}

generate_concept_id() {
    echo "concept-$(od -An -tx1 -N4 /dev/urandom | tr -d ' \n')"
}

# Write a concept to concepts.yaml
# Usage: write_concept <id> <name> <definition> <source> [grounded_by_id ...]
write_concept() {
    local id="$1" name="$2" definition="$3" source="$4"
    shift 4
    local grounded_by=("$@")

    local concepts_file="${LORE_CONCEPTS_FILE}"
    if [[ ! -f "$concepts_file" ]]; then
        mkdir -p "$(dirname "$concepts_file")"
        echo "concepts: []" > "$concepts_file"
    fi

    local timestamp
    timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")

    # Build the concept entry using yq
    local tmp
    tmp=$(mktemp)
    cat > "$tmp" <<YAML
id: "$id"
name: "$name"
definition: "$definition"
grounded_by: []
created_at: "$timestamp"
source: "$source"
YAML

    # Add grounded_by entries
    for gid in "${grounded_by[@]}"; do
        yq -i ".grounded_by += [\"$gid\"]" "$tmp"
    done

    # Append to concepts array
    yq -i ".concepts += [load(\"$tmp\")]" "$concepts_file"
    rm -f "$tmp"

    echo "$id"
}

cmd_consolidate() {
    local dry_run=true
    local threshold=50
    local promote=false

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --write)
                dry_run=false
                shift
                ;;
            --dry-run)
                dry_run=true
                shift
                ;;
            --promote)
                promote=true
                shift
                ;;
            --threshold)
                threshold="$2"
                shift 2
                ;;
            -*)
                echo -e "${RED}Unknown option: $1${NC}" >&2
                echo "Usage: lore consolidate [--write] [--promote] [--threshold N]" >&2
                return 1
                ;;
            *)
                echo -e "${RED}Unexpected argument: $1${NC}" >&2
                return 1
                ;;
        esac
    done

    source "${LORE_DIR}/lib/conflict.sh"

    local decisions_file="${LORE_DECISIONS_FILE}"
    if [[ ! -f "$decisions_file" ]]; then
        echo -e "${YELLOW}No decisions file found.${NC}"
        return 0
    fi

    # Load active decisions (latest version of each ID)
    local decisions
    decisions=$(jq -s '
        group_by(.id) | map(.[-1])
        | map(select((.status // "active") == "active"))
        | map({id, decision, rationale})
    ' "$decisions_file" 2>/dev/null) || {
        echo -e "${RED}Failed to parse decisions file.${NC}" >&2
        return 1
    }

    local count
    count=$(echo "$decisions" | jq 'length' 2>/dev/null) || return 1

    if [[ "$count" -lt 3 ]]; then
        echo -e "${YELLOW}Fewer than 3 active decisions -- nothing to consolidate.${NC}"
        return 0
    fi

    # Greedy single-linkage clustering by Jaccard similarity
    local clusters=""
    local assigned=()
    local cluster_count=0
    local total_consolidated=0

    # Precompute word sets for all decisions (single jq pass + one tr/sort per item)
    local -a word_sets
    local tmpdir
    tmpdir=$(mktemp -d)
    trap "rm -rf '$tmpdir'" RETURN

    echo "$decisions" | jq -r '.[] | (.decision // "") + " " + (.rationale // "")' \
        | while IFS= read -r text; do
            echo "$text" | tr '[:upper:]' '[:lower:]' | tr -cs '[:alnum:]' '\n' | sort -u
            echo "---LORE_SEP---"
        done > "$tmpdir/all_words"

    # Split precomputed word sets into per-index files
    local idx=0
    local current_file="$tmpdir/words_0"
    while IFS= read -r line; do
        if [[ "$line" == "---LORE_SEP---" ]]; then
            idx=$((idx + 1))
            current_file="$tmpdir/words_${idx}"
        else
            echo "$line" >> "$current_file"
        fi
    done < "$tmpdir/all_words"

    for ((i=0; i<count; i++)); do
        # Skip if already assigned
        local skip=false
        for a in "${assigned[@]+"${assigned[@]}"}"; do
            [[ "$a" == "$i" ]] && { skip=true; break; }
        done
        [[ "$skip" == true ]] && continue

        local cluster_members=("$i")

        for ((j=i+1; j<count; j++)); do
            skip=false
            for a in "${assigned[@]+"${assigned[@]}"}"; do
                [[ "$a" == "$j" ]] && { skip=true; break; }
            done
            [[ "$skip" == true ]] && continue

            local intersection union
            intersection=$(comm -12 "$tmpdir/words_${i}" "$tmpdir/words_${j}" 2>/dev/null | wc -l | tr -d ' ')
            union=$(comm "$tmpdir/words_${i}" "$tmpdir/words_${j}" 2>/dev/null | sort -u | wc -l | tr -d ' ')

            if [[ "$union" -gt 0 ]]; then
                local sim=$(( intersection * 100 / union ))
                if [[ "$sim" -ge "$threshold" ]]; then
                    cluster_members+=("$j")
                    assigned+=("$j")
                fi
            fi
        done

        assigned+=("$i")

        if [[ ${#cluster_members[@]} -ge 3 ]]; then
            cluster_count=$((cluster_count + 1))
            total_consolidated=$((total_consolidated + ${#cluster_members[@]}))

            # Collect member IDs and find shortest decision text
            local member_ids=()
            local shortest_text=""
            local shortest_len=999999
            for idx in "${cluster_members[@]}"; do
                local mid mtext
                mid=$(echo "$decisions" | jq -r ".[$idx].id")
                mtext=$(echo "$decisions" | jq -r ".[$idx].decision")
                member_ids+=("$mid")
                local mlen=${#mtext}
                if [[ "$mlen" -lt "$shortest_len" ]]; then
                    shortest_len="$mlen"
                    shortest_text="$mtext"
                fi
            done

            if [[ "$dry_run" == true ]]; then
                echo -e "${BOLD}Cluster ${cluster_count}${NC} (${#cluster_members[@]} decisions):"
                for idx in "${cluster_members[@]}"; do
                    local cid ctext
                    cid=$(echo "$decisions" | jq -r ".[$idx].id")
                    ctext=$(echo "$decisions" | jq -r ".[$idx].decision[0:60]")
                    echo -e "  ${DIM}${cid}${NC}  ${ctext}"
                done
                echo ""
            else
                # Create summary decision
                local ids_csv
                ids_csv=$(printf '%s' "${member_ids[0]}")
                for ((k=1; k<${#member_ids[@]}; k++)); do
                    ids_csv="${ids_csv}, ${member_ids[$k]}"
                done

                local summary_text="Consolidated: ${shortest_text}"
                local summary_rationale="Synthesizes ${#member_ids[@]} similar decisions: ${ids_csv}"

                echo -e "${BOLD}Creating summary for cluster ${cluster_count}...${NC}"
                local record_output
                record_output=$("$LORE_DIR/journal/journal.sh" record "$summary_text" \
                    --rationale "$summary_rationale" \
                    --tags "consolidation" \
                    --force 2>&1) || true
                echo "$record_output"

                # Extract the summary decision ID from the record output
                local summary_id
                summary_id=$(echo "$record_output" | grep -oE 'dec-[a-f0-9]+' | head -1) || true

                if [[ -n "$summary_id" ]]; then
                    # Create summarized_by edges from each original to the summary
                    for mid in "${member_ids[@]}"; do
                        "$LORE_DIR/graph/graph.sh" connect "$mid" "$summary_id" summarized_by 2>/dev/null || true
                    done
                    echo -e "  ${GREEN}Linked ${#member_ids[@]} decisions to ${summary_id}${NC}"
                else
                    echo -e "  ${YELLOW}Could not extract summary ID; skipping graph edges.${NC}"
                fi

                # Promote cluster to concept if requested
                if [[ "$promote" == true && -n "$summary_id" ]]; then
                    local all_texts=""
                    for idx in "${cluster_members[@]}"; do
                        local mtext
                        mtext=$(echo "$decisions" | jq -r ".[$idx].decision")
                        all_texts="$all_texts $mtext"
                    done
                    # Extract top 3 non-stopword terms as concept name
                    local concept_name
                    concept_name=$(echo "$all_texts" | tr '[:upper:]' '[:lower:]' | tr -cs '[:alnum:]' '\n' \
                        | grep -vE '^(the|a|an|is|are|was|were|be|been|being|have|has|had|do|does|did|will|would|could|should|may|might|shall|can|to|of|in|for|on|with|at|by|from|as|into|through|during|before|after|above|below|between|out|up|down|off|over|under|again|further|then|once|and|but|or|nor|not|so|yet|both|either|neither|each|every|all|any|few|more|most|other|some|such|no|only|own|same|than|too|very|just|because|use|used|using)$' \
                        | sort | uniq -c | sort -rn | head -3 | awk '{print $2}' | paste -s -d ' ' -) || true

                    if [[ -n "$concept_name" ]]; then
                        local concept_id
                        concept_id=$(write_concept "$(generate_concept_id)" "$concept_name" "$shortest_text" "consolidation" "${member_ids[@]}")
                        echo -e "  ${GREEN}Promoted to concept:${NC} ${BOLD}${concept_id}${NC} (${concept_name})"

                        # Sync concept to graph
                        if [[ -x "$LORE_DIR/graph/sync-concepts.sh" ]]; then
                            bash "$LORE_DIR/graph/sync-concepts.sh" &>/dev/null &
                        fi
                    fi
                fi

                echo ""
            fi
        fi
    done

    # Print stats
    echo -e "${BOLD}---${NC}"
    if [[ "$dry_run" == true ]]; then
        echo -e "Clusters found: ${BOLD}${cluster_count}${NC}"
        echo -e "Decisions to consolidate: ${BOLD}${total_consolidated}${NC}"
        if [[ "$cluster_count" -gt 0 ]]; then
            echo -e "${DIM}Run with --write to create summary records.${NC}"
        fi
    else
        echo -e "Clusters consolidated: ${BOLD}${cluster_count}${NC}"
        echo -e "Decisions consolidated: ${BOLD}${total_consolidated}${NC}"
    fi
}

cmd_promote() {
    source "$LORE_DIR/lib/promote.sh"

    local limit=10
    local auto_mode=false

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --limit)
                limit="$2"
                shift 2
                ;;
            --auto)
                auto_mode=true
                shift
                ;;
            -*)
                echo -e "${RED}Unknown option: $1${NC}" >&2
                echo "Usage: lore promote [--limit N] [--auto]" >&2
                return 1
                ;;
            *)
                echo -e "${RED}Unexpected argument: $1${NC}" >&2
                return 1
                ;;
        esac
    done

    # Check if Engram DB exists
    if [[ ! -f "$CLAUDE_MEMORY_DB" ]]; then
        echo -e "${YELLOW}Engram database not found: ${CLAUDE_MEMORY_DB}${NC}"
        echo -e "${DIM}No memories to promote.${NC}"
        return 0
    fi

    # Count candidates
    local total_candidates
    total_candidates=$(count_promotion_candidates)

    if [[ "$total_candidates" -eq 0 ]]; then
        echo -e "${GREEN}No promotion candidates found.${NC}"
        echo -e "${DIM}(Looking for importance >= 4 or accessCount >= 3, non-shadow memories)${NC}"
        return 0
    fi

    echo -e "${BOLD}Promotion Pipeline: Engram → Lore${NC}"
    echo -e "${DIM}Found ${total_candidates} candidates (showing top ${limit})${NC}"
    echo ""

    # Query candidates
    local candidates
    candidates=$(query_promotion_candidates "$limit")
    [[ -z "$candidates" || "$candidates" == "[]" ]] && return 0

    local promoted_count=0
    local skipped_count=0
    local candidate_count
    candidate_count=$(echo "$candidates" | jq 'length')

    # Iterate through candidates with jq
    for i in $(seq 0 $((candidate_count - 1))); do
        local engram_id content topic source importance access_count project
        engram_id=$(echo "$candidates" | jq -r ".[$i].id")
        content=$(echo "$candidates" | jq -r ".[$i].content")
        topic=$(echo "$candidates" | jq -r ".[$i].topic")
        source=$(echo "$candidates" | jq -r ".[$i].source")
        importance=$(echo "$candidates" | jq -r ".[$i].importance")
        access_count=$(echo "$candidates" | jq -r ".[$i].accessCount")
        project=$(echo "$candidates" | jq -r ".[$i].project")

        local candidate_num=$((i + 1))

        echo -e "${BOLD}Candidate ${candidate_num}/${candidate_count}${NC} ${DIM}(id: ${engram_id})${NC}"
        echo -e "${CYAN}Content:${NC} $content"
        echo -e "${DIM}Topic: ${topic}  Project: ${project}  Source: ${source}${NC}"
        echo -e "${DIM}Importance: ${importance}  Access count: ${access_count}${NC}"

        # Classify
        local suggested_type
        suggested_type=$(classify_candidate "$content")
        echo -e "${DIM}Suggested type: ${suggested_type}${NC}"

        if [[ "$auto_mode" == true ]]; then
            echo -e "${YELLOW}[auto mode: skipping]${NC}"
            echo ""
            continue
        fi

        # Interactive prompt
        echo -n "[a]pprove  [e]dit  [s]kip  [q]uit: "
        read -r action

        case "$action" in
            a|A)
                # Promote with suggested type
                echo -e "${DIM}Promoting as ${suggested_type}...${NC}"
                local lore_id
                lore_id=$(promote_to_lore "$engram_id" "$suggested_type")

                if [[ -n "$lore_id" ]]; then
                    mark_as_promoted "$engram_id" "$lore_id"
                    echo -e "${GREEN}✓ Promoted to Lore:${NC} ${BOLD}${lore_id}${NC}"
                    promoted_count=$((promoted_count + 1))
                else
                    echo -e "${RED}✗ Promotion failed${NC}"
                fi
                ;;
            e|E)
                # Edit content before promoting
                echo -n "Enter edited content (or Ctrl-C to cancel): "
                read -r edited_content
                [[ -z "$edited_content" ]] && { echo -e "${YELLOW}Skipped (empty content)${NC}"; skipped_count=$((skipped_count + 1)); echo ""; continue; }

                echo -e "${DIM}Promoting as ${suggested_type}...${NC}"
                local lore_id
                lore_id=$(promote_to_lore "$engram_id" "$suggested_type" "$edited_content")

                if [[ -n "$lore_id" ]]; then
                    mark_as_promoted "$engram_id" "$lore_id"
                    echo -e "${GREEN}✓ Promoted to Lore:${NC} ${BOLD}${lore_id}${NC}"
                    promoted_count=$((promoted_count + 1))
                else
                    echo -e "${RED}✗ Promotion failed${NC}"
                fi
                ;;
            s|S)
                echo -e "${YELLOW}Skipped${NC}"
                skipped_count=$((skipped_count + 1))
                ;;
            q|Q)
                echo -e "${YELLOW}Quit${NC}"
                break
                ;;
            *)
                echo -e "${YELLOW}Unknown action, skipping${NC}"
                skipped_count=$((skipped_count + 1))
                ;;
        esac

        echo ""
    done

    # Print summary
    echo -e "${BOLD}---${NC}"
    echo -e "Promoted: ${BOLD}${promoted_count}${NC}"
    echo -e "Skipped: ${skipped_count}"
    [[ $((candidate_num)) -lt "$total_candidates" ]] && \
        echo -e "${DIM}${total_candidates} candidates remain. Run again to review more.${NC}"
}

cmd_review() {
    source "$LORE_DIR/journal/lib/store.sh"

    local mode="default"
    local resolve_id=""
    local outcome=""
    local lesson=""
    local age_days=3

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --auto)
                mode="auto"
                shift
                ;;
            --days)
                age_days="$2"
                shift 2
                ;;
            --resolve)
                mode="resolve"
                resolve_id="$2"
                shift 2
                ;;
            --outcome)
                outcome="$2"
                shift 2
                ;;
            --lesson)
                lesson="$2"
                shift 2
                ;;
            -*)
                echo -e "${RED}Unknown option: $1${NC}" >&2
                echo "Usage: lore review [--auto] [--resolve <id> --outcome <value> [--lesson \"text\"]]" >&2
                return 1
                ;;
            *)
                echo -e "${RED}Unexpected argument: $1${NC}" >&2
                return 1
                ;;
        esac
    done

    if [[ "$mode" == "resolve" ]]; then
        if [[ -z "$resolve_id" || -z "$outcome" ]]; then
            echo -e "${RED}Error: --resolve requires --outcome${NC}" >&2
            echo "Usage: lore review --resolve <id> --outcome successful|revised|abandoned [--lesson \"text\"]" >&2
            return 1
        fi

        # Update the decision outcome
        journal_update_outcome "$resolve_id" "$outcome" "$lesson"
        echo -e "${GREEN}Resolved:${NC} ${BOLD}${resolve_id}${NC} → ${outcome}"
        [[ -n "$lesson" ]] && echo -e "  ${CYAN}Lesson:${NC} $lesson"

        # Invalidate shadow in Engram (background, fail-silent)
        if [[ "$outcome" == "revised" || "$outcome" == "abandoned" ]]; then
            _bridge_retract_shadow "$resolve_id" &>/dev/null &
        fi

        # Side effects based on outcome
        if [[ "$outcome" == "successful" ]]; then
            # Boost confidence of patterns with overlapping tags
            local decision_tags
            decision_tags=$(get_decision "$resolve_id" | jq -r '.tags[]?' 2>/dev/null) || true

            if [[ -n "$decision_tags" && -f "$LORE_PATTERNS_FILE" ]]; then
                local boosted=0
                while IFS= read -r tag; do
                    [[ -z "$tag" ]] && continue
                    # Find patterns matching this tag and boost confidence by 0.1 (cap at 1.0)
                    local match_count
                    export LORE_TAG="$tag"
                    match_count=$(yq -r \
                        '[.patterns[] | select(.tags[]? == strenv(LORE_TAG))] | length' \
                        "$LORE_PATTERNS_FILE" 2>/dev/null) || continue
                    if [[ "$match_count" -gt 0 ]]; then
                        yq -i \
                            '(.patterns[] | select(.tags[]? == strenv(LORE_TAG)) | .confidence) |= ([. + 0.1, 1.0] | min)' \
                            "$LORE_PATTERNS_FILE" 2>/dev/null || true
                        boosted=$((boosted + match_count))
                    fi
                done <<< "$decision_tags"
                [[ "$boosted" -gt 0 ]] && echo -e "  ${GREEN}Boosted confidence on ${boosted} matching pattern(s)${NC}"
            fi
        elif [[ "$outcome" == "abandoned" ]]; then
            # Log as a failure
            local decision_text
            decision_text=$(get_decision "$resolve_id" | jq -r '.decision' 2>/dev/null) || true
            if [[ -n "$decision_text" ]]; then
                cmd_fail "LogicError" "Abandoned decision: ${decision_text}" 2>/dev/null || true
            fi
        fi
        return 0
    fi

    # List mode: find pending decisions older than 3 days
    if [[ ! -f "$LORE_DECISIONS_FILE" ]]; then
        echo -e "${YELLOW}No decisions file found.${NC}"
        return 0
    fi

    local cutoff_ts
    if [[ "$age_days" -eq 0 ]]; then
        # Show all pending decisions regardless of age
        cutoff_ts=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
    else
        cutoff_ts=$(date -u -v-${age_days}d +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null) || \
            cutoff_ts=$(date -u -d "${age_days} days ago" +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null) || \
            cutoff_ts="1970-01-01T00:00:00Z"
    fi

    local pending
    pending=$(jq -s --arg cutoff "$cutoff_ts" '
        group_by(.id) | map(.[-1])
        | map(select(
            ((.outcome // "pending") == "pending")
            and ((.status // "active") == "active")
            and (.timestamp < $cutoff)
        ))
        | sort_by(.timestamp)
    ' "$LORE_DECISIONS_FILE" 2>/dev/null) || {
        echo -e "${RED}Failed to parse decisions file.${NC}" >&2
        return 1
    }

    local count
    count=$(echo "$pending" | jq 'length')

    if [[ "$count" -eq 0 ]]; then
        echo -e "${GREEN}No decisions pending review.${NC}"
        return 0
    fi

    if [[ "$mode" == "auto" ]]; then
        # Compact one-line-per-decision output
        echo "$pending" | jq -r '.[] |
            "\(.id) | \(.timestamp[0:10]) | \(.decision[0:60])"'
        echo -e "${BOLD}${count} decision(s) pending review${NC}"
        return 0
    fi

    # Default mode: full display
    local now_epoch
    now_epoch=$(date +%s)

    echo -e "${BOLD}Decisions Pending Review${NC}"
    echo ""

    echo "$pending" | jq -c '.[]' | while IFS= read -r row; do
        local did dtimestamp ddecision drationale dquality
        did=$(echo "$row" | jq -r '.id')
        dtimestamp=$(echo "$row" | jq -r '.timestamp')
        ddecision=$(echo "$row" | jq -r '.decision')
        drationale=$(echo "$row" | jq -r '.rationale // "(none)"')
        dquality=$(echo "$row" | jq -r '.spec_quality // "(unscored)"')

        # Calculate age in days
        local dec_epoch age_days
        dec_epoch=$(date -jf "%Y-%m-%dT%H:%M:%SZ" "$dtimestamp" +%s 2>/dev/null) || \
            dec_epoch=$(date -d "$dtimestamp" +%s 2>/dev/null) || \
            dec_epoch=0
        if [[ "$dec_epoch" -gt 0 ]]; then
            age_days=$(( (now_epoch - dec_epoch) / 86400 ))
        else
            age_days="?"
        fi

        echo -e "  ${GREEN}${did}${NC}  ${DIM}(${age_days}d old)${NC}"
        echo -e "    ${BOLD}${ddecision}${NC}"
        echo -e "    ${DIM}Rationale: ${drationale:0:80}${NC}"
        echo -e "    ${DIM}Quality: ${dquality}${NC}"
        echo ""
    done

    echo -e "${BOLD}${count} decision(s) pending review${NC}"
    echo -e "${DIM}Resolve with: lore review --resolve <id> --outcome successful|revised|abandoned${NC}"
}

cmd_init() {
    echo -e "${BOLD}Initializing Lore data directory: ${LORE_DATA_DIR}${NC}"

    # Create component directories
    mkdir -p "${LORE_JOURNAL_DATA}/entries"
    mkdir -p "${LORE_JOURNAL_DATA}/index"
    mkdir -p "${LORE_PATTERNS_DATA}"
    mkdir -p "${LORE_FAILURES_DATA}"
    mkdir -p "${LORE_INBOX_DATA}"
    mkdir -p "${LORE_TRANSFER_DATA}/sessions"
    mkdir -p "${LORE_GRAPH_DATA}"
    mkdir -p "${LORE_INTENT_DATA}/goals"
    mkdir -p "${LORE_REGISTRY_DATA}"
    mkdir -p "${LORE_EVIDENCE_DATA}"

    # Seed registry YAML files (only if missing)
    if [[ ! -f "${LORE_REGISTRY_DATA}/metadata.yaml" ]]; then
        cat > "${LORE_REGISTRY_DATA}/metadata.yaml" <<'YAML'
version: "1.0"
metadata: {}
YAML
    fi
    if [[ ! -f "${LORE_REGISTRY_DATA}/clusters.yaml" ]]; then
        cat > "${LORE_REGISTRY_DATA}/clusters.yaml" <<'YAML'
version: "1.0"
clusters: {}
YAML
    fi
    if [[ ! -f "${LORE_REGISTRY_DATA}/relationships.yaml" ]]; then
        cat > "${LORE_REGISTRY_DATA}/relationships.yaml" <<'YAML'
version: "1.0"
dependencies: {}
shared: {}
integrations: {}
pattern_sharing: []
YAML
    fi
    if [[ ! -f "${LORE_REGISTRY_DATA}/contracts.yaml" ]]; then
        cat > "${LORE_REGISTRY_DATA}/contracts.yaml" <<'YAML'
version: "1.0"
contracts: {}
YAML
    fi

    # Seed files (only if missing)
    [[ -f "${LORE_DECISIONS_FILE}" ]] || touch "${LORE_DECISIONS_FILE}"
    [[ -f "${LORE_FAILURES_DATA}/failures.jsonl" ]] || touch "${LORE_FAILURES_DATA}/failures.jsonl"
    [[ -f "${LORE_INBOX_DATA}/observations.jsonl" ]] || touch "${LORE_INBOX_DATA}/observations.jsonl"
    [[ -f "${LORE_SIGNALS_FILE}" ]] || touch "${LORE_SIGNALS_FILE}"
    [[ -f "${LORE_EVIDENCE_FILE}" ]] || touch "${LORE_EVIDENCE_FILE}"

    if [[ ! -f "${LORE_PATTERNS_FILE}" ]]; then
        cat > "${LORE_PATTERNS_FILE}" <<'YAML'
# Pattern Learner Database
patterns: []
anti_patterns: []
YAML
    fi

    if [[ ! -f "${LORE_CONCEPTS_FILE}" ]]; then
        cat > "${LORE_CONCEPTS_FILE}" <<'YAML'
# Concept Database
concepts: []
YAML
    fi

    if [[ ! -f "${LORE_GRAPH_FILE}" ]]; then
        echo '{"nodes":{},"edges":[]}' > "${LORE_GRAPH_FILE}"
    fi

    echo -e "${GREEN}Done. Data directory ready at ${LORE_DATA_DIR}${NC}"
}

cmd_overlay() {
    local query=""
    local project=""
    local limit=10
    local json=false

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --query|-q)  query="$2"; shift 2 ;;
            --project|-p) project="$2"; shift 2 ;;
            --limit|-l)  limit="$2"; shift 2 ;;
            --json)      json=true; shift ;;
            -*)
                echo -e "${RED}Unknown option: $1${NC}" >&2
                echo "Usage: lore overlay --query <query> [--project <name>] [--limit N] [--json]" >&2
                return 1
                ;;
            *)
                # Bare positional arg treated as query
                [[ -z "$query" ]] && query="$1"
                shift
                ;;
        esac
    done

    if [[ -z "$query" ]]; then
        echo -e "${RED}Error: --query is required${NC}" >&2
        echo "Usage: lore overlay --query <query> [--project <name>] [--limit N] [--json]" >&2
        return 1
    fi

    if [[ ! -f "$SEARCH_DB" ]]; then
        echo -e "${RED}Error: Search index not found. Run 'lore index' first.${NC}" >&2
        return 1
    fi

    # Derive project from cwd if not specified
    [[ -z "$project" ]] && project=$(_derive_project)

    if [[ "$json" == true ]]; then
        # Structured JSON output — query FTS5 directly for clean data
        local safe_query="${query//\'/\'\'}"
        local safe_project="${project//\'/\'\'}"
        local json_results
        json_results=$(sqlite3 -json "$SEARCH_DB" <<SQL 2>/dev/null
WITH ranked AS (
    SELECT 'decision' as type, id, decision as content, project, timestamp, importance, rank * -1 as bm25_score FROM decisions WHERE decisions MATCH '${safe_query}'
    UNION ALL
    SELECT 'pattern' as type, id, name || ': ' || solution as content, 'lore' as project, timestamp, CAST(confidence * 5 AS INT) as importance, rank * -1 as bm25_score FROM patterns WHERE patterns MATCH '${safe_query}'
    UNION ALL
    SELECT 'transfer' as type, session_id as id, handoff as content, project, timestamp, 3 as importance, rank * -1 as bm25_score FROM transfers WHERE transfers MATCH '${safe_query}'
    UNION ALL
    SELECT 'failure' as type, id, error_type || ': ' || error_message as content, '' as project, timestamp, 3 as importance, rank * -1 as bm25_score FROM failures WHERE failures MATCH '${safe_query}'
    UNION ALL
    SELECT 'signal' as type, id, content as content, '' as project, timestamp, 2 as importance, rank * -1 as bm25_score FROM observations WHERE observations MATCH '${safe_query}'
    UNION ALL
    SELECT 'concept' as type, id, name || ': ' || definition as content, '' as project, timestamp, 4 as importance, rank * -1 as bm25_score FROM concepts WHERE concepts MATCH '${safe_query}'
),
frequency AS (
    SELECT record_type, record_id, COUNT(*) as access_count, MAX(accessed_at) as last_access
    FROM access_log GROUP BY record_type, record_id
)
SELECT
    r.type,
    r.id,
    SUBSTR(r.content, 1, 80) as title,
    ROUND(
        r.bm25_score
        * (1.0 / (1 + (julianday('now') - julianday(r.timestamp)) / 30))
        * COALESCE(1.0 + (LOG(1 + f.access_count) * 0.15), 1.0)
        * (1.0 + (r.importance / 5.0 * 0.2))
        * COALESCE(1.0 + (0.1 * EXP(-(julianday('now') - julianday(f.last_access)) / 30)), 1.0)
        * CASE WHEN r.project = '${safe_project}' THEN 1.5 ELSE 1.0 END
    , 2) as score
FROM ranked r
LEFT JOIN frequency f ON r.type = f.record_type AND r.id = f.record_id
ORDER BY score DESC
LIMIT ${limit};
SQL
        ) || true

        # Wrap in envelope with query metadata
        if [[ -z "$json_results" || "$json_results" == "[]" ]]; then
            json_results="[]"
        fi
        jq -n \
            --arg query "$query" \
            --arg project "$project" \
            --argjson items "$json_results" \
            '{query: $query, project: $project, items: $items}'
    else
        # Human-readable overlay — reuse _search_fts5 compact mode
        local results
        results=$(_search_fts5 "$query" "$project" "$limit" 0 true) || true

        echo -e "${BOLD}--- Lore Context Overlay ---${NC}"
        echo -e "${DIM}query: ${query}  project: ${project:-any}  limit: ${limit}${NC}"
        echo ""
        if [[ -n "$results" ]]; then
            echo "$results"
        else
            echo -e "  ${DIM}(no results)${NC}"
        fi
        echo ""
        echo -e "${DIM}Use 'lore context <id>' for full details on any item.${NC}"
    fi
}

main() {
    [[ $# -eq 0 ]] && { show_help; exit 0; }

    case "$1" in
        # Quick commands
        capture)    shift; cmd_capture "$@" ;;
        recall)     shift; cmd_recall "$@" ;;
        remember)   shift; cmd_remember "$@" ;;
        learn)      shift; cmd_learn "$@" ;;
        handoff)    shift; cmd_handoff "$@" ;;
        resume)     shift; cmd_resume "$@" ;;
        entire-resume) shift; "$LORE_DIR/scripts/entire-resume-with-context.sh" "$@" ;;
        search)     shift; cmd_search "$@" ;;
        overlay)    shift; cmd_overlay "$@" ;;
        suggest)    shift; cmd_suggest "$@" ;;
        context)    shift; cmd_context "$@" ;;
        status)     shift; cmd_status "$@" ;;
        observe)    shift; cmd_observe "$@" ;;
        inbox)      shift; cmd_inbox "$@" ;;
        evidence)   shift; cmd_evidence "$@" ;;
        fail)       shift; cmd_fail "$@" ;;
        failures)   shift; cmd_failures "$@" ;;
        triggers)   shift; cmd_triggers "$@" ;;
        promote-failure) shift; cmd_promote_failure "$@" ;;
        review)     shift; cmd_review "$@" ;;
        brief)      shift; source "$LORE_DIR/lib/brief.sh"; cmd_brief "$@" ;;

        # Top-level commands
        init)       shift; cmd_init "$@" ;;
        validate)   shift; source "$LORE_DIR/lib/validate.sh"; cmd_validate "$@" ;;
        ingest)     shift; source "$LORE_DIR/lib/ingest.sh"; cmd_ingest "$@" ;;
        index)      shift; bash "$LORE_DIR/lib/search-index.sh" "$@" ;;
        consolidate) shift; cmd_consolidate "$@" ;;
        sync)       shift; source "$LORE_DIR/lib/bridge.sh"; sync_to_claude_memory "$@" ;;
        promote)    shift; cmd_promote "$@" ;;

        # Component dispatch
        journal)    shift
                    case "${1:-}" in
                        add) shift; journal_add "$@" ;;
                        *) "$LORE_DIR/journal/journal.sh" "$@" ;;
                    esac
                    ;;
        graph)      shift; "$LORE_DIR/graph/graph.sh" "$@" ;;
        patterns)   shift; "$LORE_DIR/patterns/patterns.sh" "$@" ;;
        transfer)   shift; "$LORE_DIR/transfer/transfer.sh" "$@" ;;

        # Intent (goals)
        goal)       shift; source "$LORE_DIR/intent/lib/intent.sh"; intent_goal_main "$@"
                    # Sync goals to graph (background, fail-silent)
                    "$LORE_DIR/graph/sync-goals.sh" &>/dev/null &
                    ;;
        intent)     shift; source "$LORE_DIR/intent/lib/intent.sh"
                    case "${1:-}" in
                        export) shift; intent_export_main "$@" ;;
                        *)      echo -e "${RED}Unknown intent command: ${1:-}${NC}" >&2
                                echo "Usage: lore intent export <goal-id> [--format yaml|markdown]" >&2
                                return 1 ;;
                    esac ;;

        # Spec management (SDD integration)
        spec)       shift; source "$LORE_DIR/intent/lib/spec.sh"; spec_main "$@" ;;

        # Registry (project metadata)
        registry)   shift; source "$LORE_DIR/registry/lib/registry.sh"; registry_main "$@" ;;

        # Help
        -h|--help)  show_help ;;
        help)       shift; cmd_help "$@" ;;

        *)
            echo -e "${RED}Unknown command: $1${NC}" >&2
            show_help >&2
            exit 1
            ;;
    esac
}

main "$@"