lacy 1.8.11 → 1.8.13

package/lib/core/spinner.sh

@@ -0,0 +1,174 @@
+#!/usr/bin/env bash
+
+# Spinner with shimmer text effect for Lacy Shell
+# Displays a braille spinner + "Thinking" with a sweeping brightness pulse
+# Shared across Bash 4+ and ZSH
+
+LACY_SPINNER_PID=""
+LACY_SPINNER_MONITOR_WAS_SET=""
+LACY_SPINNER_NOTIFY_WAS_SET=""
+
+lacy_start_spinner() {
+    # Signal to Bash interrupt handler that an agent/spinner is active.
+    # In ZSH this is unnecessary — TRAPINT checks $ZLE_STATE instead.
+    LACY_SHELL_AGENT_RUNNING=true
+
+    # Guard against double-start
+    if [[ -n "$LACY_SPINNER_PID" ]]; then
+        lacy_stop_spinner
+    fi
+
+    # Save and suppress job control messages (must persist until lacy_stop_spinner)
+    if [[ "$LACY_SHELL_TYPE" == "zsh" ]]; then
+        if [[ -o monitor ]]; then
+            LACY_SPINNER_MONITOR_WAS_SET=1
+            setopt NO_MONITOR
+        else
+            LACY_SPINNER_MONITOR_WAS_SET=""
+        fi
+        if [[ -o notify ]]; then
+            LACY_SPINNER_NOTIFY_WAS_SET=1
+            setopt NO_NOTIFY
+        else
+            LACY_SPINNER_NOTIFY_WAS_SET=""
+        fi
+    else
+        # Bash
+        LACY_SPINNER_MONITOR_WAS_SET=""
+        case "$-" in *m*) LACY_SPINNER_MONITOR_WAS_SET=1 ;; esac
+        set +m 2>/dev/null
+        LACY_SPINNER_NOTIFY_WAS_SET=""
+    fi
+
+    # Initialize animation frames (global array, inherited by forked subshell)
+    lacy_set_spinner_animation "${LACY_SPINNER_STYLE:-braille}"
+    # Guard: if animation failed to load, use hardcoded fallback
+    if [[ ${#LACY_SPINNER_ANIM[@]} -eq 0 ]]; then
+        LACY_SPINNER_ANIM=("⠋⠀⠀⠀" "⠙⠀⠀⠀" "⠹⠀⠀⠀" "⠸⠀⠀⠀" "⠼⠀⠀⠀" "⠴⠀⠀⠀" "⠦⠀⠀⠀" "⠧⠀⠀⠀" "⠇⠀⠀⠀" "⠏⠀⠀⠀")
+    fi
+
+    {
+        trap 'printf "\e[?25h" >&2' EXIT
+        trap 'exit 0' TERM INT HUP
+
+        # Hide cursor
+        printf '\e[?25l' >&2
+
+        local num_frames=${#LACY_SPINNER_ANIM[@]}
+
+        local text="$LACY_SPINNER_TEXT"
+        local text_len=${#text}
+        local frame_num=0
+        local -a shimmer_colors=("${LACY_COLOR_SHIMMER[@]}")
+        local num_colors=${#shimmer_colors[@]}
+        local arr_off=${_LACY_ARR_OFFSET:-0}
+        local spinner_idx spinner_char shimmer center i char dist color_idx color dots_phase dots
+
+        while true; do
+            if [[ "$LACY_SHELL_TYPE" == "zsh" ]]; then
+                spinner_idx=$(( (frame_num % num_frames) + 1 ))
+            else
+                spinner_idx=$(( frame_num % num_frames ))
+            fi
+            spinner_char="${LACY_SPINNER_ANIM[$spinner_idx]}"
+
+            # Build shimmer text
+            shimmer=""
+            center=$(( frame_num % (text_len + 4) ))
+
+            for (( i = 0; i < text_len; i++ )); do
+                if [[ "$LACY_SHELL_TYPE" == "zsh" ]]; then
+                    char="${text[$((i + 1))]}"
+                else
+                    char="${text:$i:1}"
+                fi
+                dist=$(( center - i ))
+                if (( dist < 0 )); then
+                    dist=$(( -dist ))
+                fi
+
+                if (( dist < num_colors )); then
+                    color_idx=$(( dist + arr_off ))
+                    color=${shimmer_colors[$color_idx]}
+                else
+                    color_idx=$(( num_colors - 1 + arr_off ))
+                    color=${shimmer_colors[$color_idx]}
+                fi
+
+                shimmer+="\e[38;5;${color}m${char}"
+            done
+            shimmer+="\e[0m"
+
+            # Cycling dots (change every 3 frames)
+            dots_phase=$(( (frame_num / 3) % 4 ))
+            dots=""
+            case $dots_phase in
+                0) dots="" ;;
+                1) dots="." ;;
+                2) dots=".." ;;
+                3) dots="..." ;;
+            esac
+
+            # Render: clear line, carriage return, draw
+            printf "\e[2K\r \e[38;5;${LACY_COLOR_AGENT}m%s\e[0m %b\e[38;5;${LACY_COLOR_NEUTRAL}m%s\e[0m" \
+                "$spinner_char" "$shimmer" "$dots" >&2
+
+            frame_num=$(( frame_num + 1 ))
+
+            sleep "$LACY_SPINNER_FRAME_DELAY"
+        done
+    } &
+
+    LACY_SPINNER_PID=$!
+
+    # In Bash, disown the spinner so it won't print "[N] Done ..." with
+    # the entire subshell body when the job exits.
+    if [[ "$LACY_SHELL_TYPE" != "zsh" ]]; then
+        disown "$LACY_SPINNER_PID" 2>/dev/null
+    fi
+}
+
+lacy_stop_spinner() {
+    # Unconditional terminal state restore
+    printf '\e[?25h' >&2   # Cursor visible
+    printf '\e[?7h' >&2    # Line wrapping enabled
+
+    if [[ -z "$LACY_SPINNER_PID" ]]; then
+        _lacy_spinner_restore_jobctl
+        return
+    fi
+
+    # Kill if still running
+    if kill -0 "$LACY_SPINNER_PID" 2>/dev/null; then
+        kill "$LACY_SPINNER_PID" 2>/dev/null
+        # In ZSH we can wait; in Bash the process is disowned so just sleep
+        if [[ "$LACY_SHELL_TYPE" == "zsh" ]]; then
+            wait "$LACY_SPINNER_PID" 2>/dev/null
+        fi
+        sleep "$LACY_TERMINAL_FLUSH_DELAY"
+        printf '\e[2K\r' >&2
+    fi
+
+    LACY_SPINNER_PID=""
+    LACY_SHELL_AGENT_RUNNING=false
+
+    _lacy_spinner_restore_jobctl
+}
+
+# Restore job control after spinner
+_lacy_spinner_restore_jobctl() {
+    if [[ -n "$LACY_SPINNER_MONITOR_WAS_SET" ]]; then
+        if [[ "$LACY_SHELL_TYPE" == "zsh" ]]; then
+            setopt MONITOR
+        else
+            set -m 2>/dev/null
+        fi
+        LACY_SPINNER_MONITOR_WAS_SET=""
+    fi
+    if [[ -n "$LACY_SPINNER_NOTIFY_WAS_SET" ]]; then
+        if [[ "$LACY_SHELL_TYPE" == "zsh" ]]; then
+            setopt NOTIFY
+        fi
+        LACY_SPINNER_NOTIFY_WAS_SET=""
+    fi
+}

package/lib/core/telemetry.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+
+# Lacy Shell Telemetry — lightweight, anonymous usage tracking via Umami
+# No PII collected. Respects DO_NOT_TRACK and LACY_NO_TELEMETRY.
+# See: https://umami.is
+
+readonly _LACY_UMAMI_URL="${LACY_UMAMI_URL:-https://analytics.lacy.sh}"
+readonly _LACY_UMAMI_WEBSITE_ID="${LACY_UMAMI_WEBSITE_ID:-577521d7-3db7-4a77-a45c-3c97f21b5322}"
+readonly _LACY_TELEMETRY_FLAG="${LACY_SHELL_HOME}/.telemetry_sent"
+
+# _lacy_json_escape_str is defined in constants.sh (shared helper).
+# Guard: define here only if not already available (e.g., standalone sourcing).
+if ! command -v _lacy_json_escape_str >/dev/null 2>&1; then
+    _lacy_json_escape_str() {
+        local s="$1"
+        s="${s//\\/\\\\}"; s="${s//\"/\\\"}"; s="${s//$'\n'/\\n}"; s="${s//$'\r'/\\r}"; s="${s//$'\t'/\\t}"
+        printf '%s' "$s"
+    }
+fi
+
+# Send a tracking event to Umami (background, fail-silent)
+_lacy_track_event() {
+    [[ "${DO_NOT_TRACK:-}" == "1" ]] && return
+    [[ "${LACY_NO_TELEMETRY:-}" == "1" ]] && return
+
+    local event_name="${1:-unknown}"
+    local method="${2:-unknown}"
+    local version=""
+
+    # Read version from package.json
+    local pkg_file="${LACY_SHELL_HOME}/package.json"
+    if [[ -f "$pkg_file" ]]; then
+        version=$(grep '"version"' "$pkg_file" 2>/dev/null | head -1 | sed 's/.*"version"[[:space:]]*:[[:space:]]*"//' | sed 's/".*//')
+    fi
+
+    local os_name
+    os_name="$(uname -s 2>/dev/null || echo unknown)"
+    local arch
+    arch="$(uname -m 2>/dev/null || echo unknown)"
+
+    # Escape all values for safe JSON interpolation
+    event_name=$(_lacy_json_escape_str "$event_name")
+    method=$(_lacy_json_escape_str "$method")
+    version=$(_lacy_json_escape_str "${version:-unknown}")
+    os_name=$(_lacy_json_escape_str "$os_name")
+    arch=$(_lacy_json_escape_str "$arch")
+    local shell_type
+    shell_type=$(_lacy_json_escape_str "${LACY_SHELL_TYPE:-unknown}")
+    local website_id
+    website_id=$(_lacy_json_escape_str "$_LACY_UMAMI_WEBSITE_ID")
+
+    (curl -sf --connect-timeout 3 --max-time 5 -X POST "${_LACY_UMAMI_URL}/api/send" \
+        -H "Content-Type: application/json" \
+        -H "User-Agent: lacy/${version}" \
+        -d "{
+            \"type\": \"event\",
+            \"payload\": {
+                \"hostname\": \"lacy.sh\",
+                \"language\": \"\",
+                \"referrer\": \"\",
+                \"screen\": \"\",
+                \"title\": \"Install\",
+                \"url\": \"/install/${method}\",
+                \"website\": \"${website_id}\",
+                \"name\": \"${event_name}\",
+                \"data\": {
+                    \"method\": \"${method}\",
+                    \"os\": \"${os_name}\",
+                    \"arch\": \"${arch}\",
+                    \"shell\": \"${shell_type}\",
+                    \"version\": \"${version}\"
+                }
+            }
+        }" >/dev/null 2>&1 &)
+}
+
+# One-time first-load tracking — detects install method and fires once
+_lacy_track_first_load() {
+    [[ "${DO_NOT_TRACK:-}" == "1" ]] && return
+    [[ "${LACY_NO_TELEMETRY:-}" == "1" ]] && return
+    [[ -f "$_LACY_TELEMETRY_FLAG" ]] && return
+
+    # Detect install method
+    local method="unknown"
+    if [[ -L "$LACY_SHELL_HOME" ]]; then
+        local link_target
+        link_target=$(readlink "$LACY_SHELL_HOME" 2>/dev/null || true)
+        if [[ "$link_target" == *"/Cellar/"* || "$link_target" == *"/homebrew/"* ]]; then
+            method="brew"
+        fi
+    elif [[ -d "$LACY_SHELL_HOME/.git" ]]; then
+        method="git"
+    fi
+
+    # Create flag file before sending (avoid duplicate sends)
+    touch "$_LACY_TELEMETRY_FLAG" 2>/dev/null
+
+    _lacy_track_event "first_load" "$method"
+}

package/lib/detection.zsh

@@ -0,0 +1,3 @@
+#!/usr/bin/env zsh
+# Backward-compat wrapper — sources from new location
+source "${0:A:h}/core/detection.sh"

package/lib/execute.zsh

@@ -0,0 +1,3 @@
+#!/usr/bin/env zsh
+# Backward-compat wrapper — sources from new location
+source "${0:A:h}/zsh/execute.zsh"

package/lib/fish/config.fish

@@ -0,0 +1,66 @@
+# Lacy Shell — Fish configuration loader
+
+# ============================================================================
+# Defaults
+# ============================================================================
+
+set -g LACY_SHELL_MODE auto         # shell | agent | auto
+set -g LACY_ACTIVE_TOOL ""          # empty = auto-detect
+set -g LACY_CUSTOM_TOOL_CMD ""
+set -g LACY_TOOL_LIST lash claude opencode gemini codex
+
+# Colors (256-color indices)
+set -g LACY_COLOR_SHELL 34          # green
+set -g LACY_COLOR_AGENT 200         # magenta
+set -g LACY_COLOR_AUTO 75           # blue
+set -g LACY_COLOR_NEUTRAL 238       # dark gray
+
+# ============================================================================
+# YAML config parser (reads ~/.lacy/config.yaml)
+# ============================================================================
+
+function _lacy_yaml_value --description "Read a key from ~/.lacy/config.yaml"
+    set -l file "$LACY_SHELL_HOME/config.yaml"
+    set -l key $argv[1]
+    test -f "$file" || return 1
+    grep "^[[:space:]]*$key:" "$file" 2>/dev/null | head -1 \
+        | sed 's/^[^:]*:[[:space:]]*//' | tr -d '"' | tr -d "'"
+end
+
+function _lacy_load_config --description "Load config.yaml into Fish globals"
+    set -l file "$LACY_SHELL_HOME/config.yaml"
+    test -f "$file" || return
+
+    # agent_tools section
+    set -l in_tools 0
+    while read -l line
+        if string match -qr '^agent_tools:' -- "$line"
+            set in_tools 1
+            continue
+        end
+        if test $in_tools -eq 1
+            if string match -qr '^\S' -- "$line"
+                set in_tools 0
+            end
+            set -l kv (string match -r '^\s+(\w+):\s*(.*)' -- "$line")
+            if set -q kv[1]
+                set -l k (string trim -- $kv[2])
+                set -l v (string trim -- $kv[3] | tr -d '"' | tr -d "'")
+                switch $k
+                    case active
+                        set -gx LACY_ACTIVE_TOOL $v
+                    case custom_command
+                        set -gx LACY_CUSTOM_TOOL_CMD $v
+                end
+            end
+        end
+    end < "$file"
+
+    # modes section
+    set -l default_mode (_lacy_yaml_value "default")
+    if test -n "$default_mode"
+        set -g LACY_SHELL_MODE $default_mode
+    end
+end
+
+_lacy_load_config

package/lib/fish/detection.fish

@@ -0,0 +1,90 @@
+# Lacy Shell — Fish input classification
+#
+# Ports the core detection logic from lib/core/detection.sh to Fish syntax.
+# Returns: "shell" | "agent" | "neutral"
+
+# Agent words: single words that always route to the AI agent.
+# Kept in sync with lib/core/constants.sh LACY_AGENT_WORDS.
+set -g LACY_AGENT_WORDS \
+    yes yeah yep yup sure ok okay alright \
+    absolutely definitely certainly indeed correct right exactly \
+    perfect agreed affirmative totally clearly obviously lgtm \
+    no nope nah never wrong disagree \
+    thanks thank thx ty cheers appreciated \
+    great good nice cool awesome amazing wonderful brilliant \
+    excellent fantastic sweet neat beautiful gorgeous impressive \
+    incredible outstanding superb marvelous magnificent stellar \
+    phenomenal terrific splendid fine solid dope sick fire lit rad legit \
+    hey hi hello howdy sup yo bye goodbye cya later \
+    please sorry pardon hmm huh wow whoa oops ugh yikes \
+    damn dang shoot welp well anyway anyways regardless \
+    meanwhile honestly basically literally actually really \
+    seriously obviously hopefully unfortunately apparently \
+    supposedly probably maybe perhaps possibly \
+    stop hold pause cancel abort skip continue proceed \
+    next again redo undo retry \
+    explain elaborate clarify summarize describe show tell \
+    why how what when where who which whom whose \
+    can could would should will shall may might must \
+    does did is are was were has have had \
+    refactor optimize scaffold
+
+# Shell reserved words that pass `command -v` but are never standalone commands.
+set -g LACY_SHELL_RESERVED_WORDS \
+    do done then else elif fi esac in select function
+
+# Classify a line of input.
+# Usage: set result (_lacy_classify_input "some input")
+# Returns: shell | agent | neutral
+function _lacy_classify_input --description "Classify input as shell/agent/neutral"
+    set -l input $argv[1]
+
+    # Empty input — return mode color signal
+    if test -z "$input"
+        switch $LACY_SHELL_MODE
+            case shell;  echo shell;  return
+            case agent;  echo agent;  return
+            case '*';    echo neutral; return
+        end
+    end
+
+    # Locked modes
+    switch $LACY_SHELL_MODE
+        case shell; echo shell; return
+        case agent; echo agent; return
+    end
+
+    # Emergency bypass: leading !
+    if string match -qr '^\!' -- "$input"
+        echo shell; return
+    end
+
+    # Split on first word
+    set -l first_word (string split -m1 ' ' -- (string trim -- "$input") | head -1)
+    set -l word_count (string split ' ' -- (string trim -- "$input") | count)
+
+    set -l lower_first (string lower -- "$first_word")
+
+    # Agent word check (single words that always route to agent)
+    if contains -- $lower_first $LACY_AGENT_WORDS
+        echo agent; return
+    end
+
+    # Shell reserved words that look like NL
+    if contains -- $lower_first $LACY_SHELL_RESERVED_WORDS
+        echo agent; return
+    end
+
+    # Valid command → shell
+    if command -q $first_word 2>/dev/null
+        echo shell; return
+    end
+
+    # Single unknown word → shell (let it fail naturally — typo)
+    if test $word_count -eq 1
+        echo shell; return
+    end
+
+    # Multi-word, first word not a command → agent (natural language)
+    echo agent
+end

package/lib/fish/execute.fish

@@ -0,0 +1,105 @@
+# Lacy Shell — Fish execution routing
+#
+# Intercepts Enter to route input to either the shell or the AI agent.
+
+# Resolve the active AI tool command string.
+function _lacy_tool_cmd --description "Return the command template for a tool"
+    switch $argv[1]
+        case lash;     echo "lash run -c"
+        case claude;   echo "claude -p"
+        case opencode; echo "opencode run -c"
+        case gemini;   echo "gemini -p"
+        case codex;    echo "codex exec resume --last"
+        case '*';      echo ""
+    end
+end
+
+# Auto-detect the first installed tool from LACY_TOOL_LIST.
+function _lacy_detect_tool --description "Return first installed AI tool"
+    if test -n "$LACY_ACTIVE_TOOL"; and test "$LACY_ACTIVE_TOOL" != auto
+        echo $LACY_ACTIVE_TOOL; return
+    end
+    for t in $LACY_TOOL_LIST
+        if command -q $t 2>/dev/null
+            echo $t; return
+        end
+    end
+    echo ""
+end
+
+# Send a query to the AI agent.
+function _lacy_query_agent --description "Route a query to the AI agent"
+    set -l query $argv[1]
+    set -l tool (_lacy_detect_tool)
+
+    if test -z "$tool"
+        printf '\n\e[38;5;196m  No AI tool detected.\e[0m Lacy needs an AI CLI to handle queries.\n\n'
+        printf '\e[1m  Supported tools:\e[0m\n\n'
+        printf '    \e[38;5;34m%-12s\e[0m %s\n' "lash"     "npm install -g lashcode        (recommended)"
+        printf '    \e[38;5;238m%-12s\e[0m %s\n' "claude"   "brew install claude"
+        printf '    \e[38;5;238m%-12s\e[0m %s\n' "opencode" "brew install opencode"
+        printf '    \e[38;5;238m%-12s\e[0m %s\n' "gemini"   "brew install gemini"
+        printf '    \e[38;5;238m%-12s\e[0m %s\n' "codex"    "npm install -g @openai/codex"
+        printf '    \e[38;5;238m%-12s\e[0m %s\n' "hermes"   "curl -fsSL .../install.sh | bash"
+        printf '    \e[38;5;238m%-12s\e[0m %s\n' "copilot"  "gh extension install github/gh-copilot"
+        printf '    \e[38;5;238m%-12s\e[0m %s\n' "goose"    "brew install goose"
+        printf '    \e[38;5;238m%-12s\e[0m %s\n' "amp"      "npm install -g @sourcegraph/amp"
+        printf '    \e[38;5;238m%-12s\e[0m %s\n' "aider"    "pipx install aider-chat"
+        printf '\n  \e[38;5;75mThen run:\e[0m  lacy setup\n'
+        printf '  \e[38;5;75mDocs:\e[0m      https://lacy.sh/docs\n\n'
+        return 1
+    end
+
+    set -l cmd_str (_lacy_tool_cmd $tool)
+    if test -z "$cmd_str"
+        echo "Error: unknown tool: $tool" >&2; return 1
+    end
+
+    # Log the query
+    _lacy_log_query $tool $query
+
+    printf '\n'
+    eval $cmd_str (string escape -- $query)
+    printf '\n'
+end
+
+# Append a query to the query log.
+function _lacy_log_query --description "Append query to ~/.lacy/logs/queries.log"
+    set -l tool $argv[1]
+    set -l query $argv[2]
+    set -l log_dir "$LACY_SHELL_HOME/logs"
+    set -l log_file "$log_dir/queries.log"
+
+    mkdir -p "$log_dir" 2>/dev/null
+    set -l ts (date '+%Y-%m-%dT%H:%M:%S' 2>/dev/null; or echo unknown)
+    set -l escaped_query (string replace -a \n '\\n' -- "$query")
+    printf '%s\t%s\t%s\n' "$ts" "$tool" "$escaped_query" >> "$log_file" 2>/dev/null
+
+    # Rotate if over 1 MB
+    if test -f "$log_file"
+        set -l size (wc -c < "$log_file" 2>/dev/null; or echo 0)
+        if test $size -gt 1048576
+            set -l tmp (mktemp)
+            tail -n 1000 "$log_file" > $tmp; and mv $tmp "$log_file" 2>/dev/null
+        end
+    end
+end
+
+# Custom Enter binding — classify input and route accordingly.
+function _lacy_accept_line --description "Classify and execute current commandline"
+    set -l buffer (commandline)
+
+    set -l route (_lacy_classify_input "$buffer")
+
+    switch $route
+        case agent
+            commandline -f repaint
+            set -l query $buffer
+            commandline ""
+            commandline -f execute
+            _lacy_query_agent $query
+        case '*'
+            # shell (or neutral) — normal execution
+            commandline -f execute
+    end
+end

package/lib/fish/keybindings.fish

@@ -0,0 +1,42 @@
+# Lacy Shell — Fish keybindings
+#
+# Registers key bindings after all other modules are loaded.
+# Uses fish_user_key_bindings so it coexists with other plugins.
+
+function _lacy_setup_bindings --description "Register Lacy keybindings"
+    # Override Enter to route through Lacy's classifier
+    bind \n _lacy_accept_line
+    bind \r _lacy_accept_line
+
+    # Ctrl+Space to cycle modes: auto → shell → agent → auto
+    bind \c@ _lacy_toggle_mode   # \c@ = Ctrl+Space in many terminals
+    bind \e\[32~ _lacy_toggle_mode  # fallback sequence for some terminals
+end
+
+function _lacy_toggle_mode --description "Cycle through shell/agent/auto modes"
+    switch $LACY_SHELL_MODE
+        case auto
+            set -g LACY_SHELL_MODE shell
+            printf '\n\e[38;5;34m  ▌ SHELL mode\e[0m\n'
+        case shell
+            set -g LACY_SHELL_MODE agent
+            printf '\n\e[38;5;200m  ▌ AGENT mode\e[0m\n'
+        case agent
+            set -g LACY_SHELL_MODE auto
+            printf '\n\e[38;5;75m  ▌ AUTO mode\e[0m\n'
+    end
+    commandline -f repaint
+end
+
+# Register after user bindings so we don't clobber them unless necessary.
+if functions -q fish_user_key_bindings
+    set -l _old_bindings (functions fish_user_key_bindings)
+    function fish_user_key_bindings
+        eval $_old_bindings
+        _lacy_setup_bindings
+    end
+else
+    function fish_user_key_bindings
+        _lacy_setup_bindings
+    end
+end

package/lib/fish/prompt.fish

@@ -0,0 +1,30 @@
+# Lacy Shell — Fish prompt indicator
+#
+# Appends a colored mode badge to the right prompt.
+# Note: real-time per-keystroke indicator is not available in Fish
+# without a custom event loop — the badge updates on each new prompt.
+
+function _lacy_mode_badge --description "Print Lacy mode badge"
+    switch $LACY_SHELL_MODE
+        case shell
+            printf '\e[38;5;34mSHELL\e[0m'
+        case agent
+            printf '\e[38;5;200mAGENT\e[0m'
+        case auto
+            printf '\e[38;5;75mAUTO\e[0m'
+    end
+end
+
+# If fish_right_prompt already exists (e.g. Tide, Starship, oh-my-fish),
+# copy it and wrap it so both the theme output and Lacy badge render.
+if functions -q fish_right_prompt
+    functions -c fish_right_prompt _lacy_original_right_prompt
+    function fish_right_prompt --description "fish_right_prompt with Lacy mode badge"
+        _lacy_original_right_prompt
+        _lacy_mode_badge
+    end
+else
+    function fish_right_prompt --description "Show Lacy mode badge in right prompt"
+        _lacy_mode_badge
+    end
+end

package/lib/keybindings.zsh

@@ -0,0 +1,3 @@
+#!/usr/bin/env zsh
+# Backward-compat wrapper — sources from new location
+source "${0:A:h}/zsh/keybindings.zsh"

package/lib/mcp.zsh

@@ -0,0 +1,3 @@
+#!/usr/bin/env zsh
+# Backward-compat wrapper — sources from new location
+source "${0:A:h}/core/mcp.sh"

package/lib/modes.zsh

@@ -0,0 +1,3 @@
+#!/usr/bin/env zsh
+# Backward-compat wrapper — sources from new location
+source "${0:A:h}/core/modes.sh"

package/lib/preheat.zsh

@@ -0,0 +1,3 @@
+#!/usr/bin/env zsh
+# Backward-compat wrapper — sources from new location
+source "${0:A:h}/core/preheat.sh"

package/lib/prompt.zsh

@@ -0,0 +1,3 @@
+#!/usr/bin/env zsh
+# Backward-compat wrapper — sources from new location
+source "${0:A:h}/zsh/prompt.zsh"

package/lib/spinner.zsh

@@ -0,0 +1,3 @@
+#!/usr/bin/env zsh
+# Backward-compat wrapper — sources from new location
+source "${0:A:h}/core/spinner.sh"