claude-smart 0.2.44 → 0.2.46

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/scripts/_lib.sh

@@ -0,0 +1,371 @@
+# shellcheck shell=bash
+# Shared helpers for openclaw-smart plugin scripts. Source, do not execute.
+
+# openClaw hooks run with a minimal non-interactive PATH that often omits
+# nvm/asdf/brew shims where `npm`, `uv`, etc. live. Pull the user's login-shell
+# PATH the same way claude-mem does so hook-spawned scripts find them without
+# the user having to mutate their global PATH. Best-effort — failures silent.
+openclaw_smart_source_login_path() {
+  local _SHELL_PATH
+  if [ -n "${SHELL:-}" ] && [ -x "$SHELL" ]; then
+    if _SHELL_PATH="$("$SHELL" -lc 'printf %s "$PATH"' 2>/dev/null)"; then
+      [ -n "$_SHELL_PATH" ] && export PATH="$_SHELL_PATH:$PATH"
+    fi
+  fi
+}
+
+# Prepend the astral.sh installer's default bin directories to PATH so a
+# freshly-installed `uv` is reachable before the user re-sources their
+# shell rc. Prepend (not append) so the just-installed binary wins over
+# any stale copy earlier in PATH. Literals only — no subshell, so safe
+# under `set -u`.
+openclaw_smart_prepend_astral_bins() {
+  export PATH="$HOME/.local/bin:$HOME/.cargo/bin:$PATH"
+}
+
+# Prepend openclaw-smart's private Node.js install, if present. The Setup
+# hook installs Node here when the user does not already have a suitable
+# node/npm on PATH, so later hook-spawned dashboard scripts can run without
+# requiring nvm/brew/global npm to be visible from openClaw's shell.
+openclaw_smart_prepend_node_bins() {
+  local _OC_NODE_ROOT
+  _OC_NODE_ROOT="$HOME/.openclaw-smart/node/current"
+  export PATH="$_OC_NODE_ROOT/bin:$_OC_NODE_ROOT:$PATH"
+}
+
+openclaw_smart_is_internal_invocation_env() {
+  if [ "${OPENCLAW_SMART_INTERNAL:-}" = "1" ]; then
+    return 0
+  fi
+  return 1
+}
+
+openclaw_smart_dashboard_unavailable_marker() {
+  printf '%s\n' "$HOME/.openclaw-smart/dashboard-unavailable"
+}
+
+openclaw_smart_node_recovery_hint() {
+  cat <<'EOF'
+Recovery:
+  1. Restart openClaw to let openclaw-smart retry its private Node.js install.
+  2. If the retry is blocked by your network or OS policy, install Node.js 20.9+ manually:
+EOF
+  if openclaw_smart_is_windows; then
+    cat <<'EOF'
+     - winget install OpenJS.NodeJS.LTS
+     - or download the LTS installer from https://nodejs.org/
+EOF
+  elif [ "$(uname -s 2>/dev/null)" = "Darwin" ]; then
+    cat <<'EOF'
+     - brew install node
+     - or download the LTS installer from https://nodejs.org/
+EOF
+  else
+    cat <<'EOF'
+     - use your distro package manager for nodejs/npm
+     - or download the LTS archive from https://nodejs.org/
+EOF
+  fi
+  cat <<'EOF'
+  3. Run /openclaw-smart:restart, then /openclaw-smart:dashboard.
+EOF
+}
+
+openclaw_smart_write_dashboard_unavailable() {
+  local reason marker
+  reason="$1"
+  marker="$(openclaw_smart_dashboard_unavailable_marker)"
+  mkdir -p "$(dirname "$marker")"
+  {
+    printf 'openclaw-smart dashboard is unavailable: %s\n\n' "$reason"
+    printf 'The learning backend and hooks can still work; only the dashboard UI is affected.\n\n'
+    printf 'Private Node.js location: %s\n\n' "$HOME/.openclaw-smart/node/current"
+    openclaw_smart_node_recovery_hint
+  } > "$marker"
+}
+
+openclaw_smart_clear_dashboard_unavailable() {
+  rm -f "$(openclaw_smart_dashboard_unavailable_marker)"
+}
+
+# Return 0 (true) if running under a Windows-flavoured bash (Git Bash,
+# MSYS, Cygwin). Used to gate POSIX-only primitives (setsid, process
+# groups) and route around Windows-specific potholes (the python3 App
+# Execution Alias stub at WindowsApps\python3.exe).
+openclaw_smart_is_windows() {
+  case "$(uname -s 2>/dev/null)" in
+    MINGW*|MSYS*|CYGWIN*) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+# Print the absolute path of a working python interpreter, or nothing
+# (and return non-zero) if none is usable. On Windows, `python3` is
+# usually the Microsoft Store "App Execution Alias" stub at
+# %LocalAppData%\Microsoft\WindowsApps\python3.exe — `command -v python3`
+# returns truthy but invoking it just prints a "Python was not found"
+# message and exits non-zero. We probe with `-V` to filter the stub out
+# and prefer `python` (the real interpreter when one is installed).
+openclaw_smart_resolve_python() {
+  if openclaw_smart_is_windows; then
+    for cand in python python3; do
+      if command -v "$cand" >/dev/null 2>&1 && "$cand" -V >/dev/null 2>&1; then
+        command -v "$cand"
+        return 0
+      fi
+    done
+    return 1
+  fi
+  for cand in python3 python; do
+    if command -v "$cand" >/dev/null 2>&1 && "$cand" -V >/dev/null 2>&1; then
+      command -v "$cand"
+      return 0
+    fi
+  done
+  return 1
+}
+
+openclaw_smart_download() {
+  local url dest src _OC_PY
+  url="$1"
+  dest="$2"
+  mkdir -p "$(dirname "$dest")"
+  case "$url" in
+    file://*)
+      src="${url#file://}"
+      cp "$src" "$dest"
+      return $?
+      ;;
+  esac
+  if command -v curl >/dev/null 2>&1; then
+    curl -fsSL "$url" -o "$dest"
+    return $?
+  fi
+  if command -v wget >/dev/null 2>&1; then
+    wget -q -O "$dest" "$url"
+    return $?
+  fi
+  if command -v powershell >/dev/null 2>&1; then
+    URL="$url" DEST="$dest" powershell -NoProfile -ExecutionPolicy Bypass -Command \
+      '$ProgressPreference="SilentlyContinue"; Invoke-WebRequest -Uri $env:URL -OutFile $env:DEST'
+    return $?
+  fi
+  if command -v pwsh >/dev/null 2>&1; then
+    URL="$url" DEST="$dest" pwsh -NoProfile -Command \
+      '$ProgressPreference="SilentlyContinue"; Invoke-WebRequest -Uri $env:URL -OutFile $env:DEST'
+    return $?
+  fi
+  _OC_PY=$(openclaw_smart_resolve_python || true)
+  if [ -n "$_OC_PY" ]; then
+    "$_OC_PY" - "$url" "$dest" <<'PY'
+import sys
+import urllib.request
+
+url, dest = sys.argv[1], sys.argv[2]
+with urllib.request.urlopen(url, timeout=60) as response:
+    data = response.read()
+with open(dest, "wb") as fh:
+    fh.write(data)
+PY
+    return $?
+  fi
+  return 1
+}
+
+openclaw_smart_sha256_file() {
+  local path _OC_PY
+  path="$1"
+  if command -v sha256sum >/dev/null 2>&1; then
+    sha256sum "$path" | awk '{print $1}'
+    return "${PIPESTATUS[0]}"
+  fi
+  if command -v shasum >/dev/null 2>&1; then
+    shasum -a 256 "$path" | awk '{print $1}'
+    return "${PIPESTATUS[0]}"
+  fi
+  if command -v openssl >/dev/null 2>&1; then
+    openssl dgst -sha256 "$path" | awk '{print $NF}'
+    return "${PIPESTATUS[0]}"
+  fi
+  _OC_PY=$(openclaw_smart_resolve_python || true)
+  if [ -n "$_OC_PY" ]; then
+    "$_OC_PY" - "$path" <<'PY'
+import hashlib
+import sys
+
+h = hashlib.sha256()
+with open(sys.argv[1], "rb") as fh:
+    for chunk in iter(lambda: fh.read(1024 * 1024), b""):
+        h.update(chunk)
+print(h.hexdigest())
+PY
+    return $?
+  fi
+  return 1
+}
+
+# Return 0 if `node` exists and satisfies the minimum major/minor pair.
+# Patch versions are intentionally ignored because our requirement is a
+# floor, not an exact runtime pin.
+openclaw_smart_node_satisfies() {
+  local min_major min_minor version major minor
+  min_major="$1"
+  min_minor="$2"
+  command -v node >/dev/null 2>&1 || return 1
+  version=$(node -v 2>/dev/null | sed 's/^v//') || return 1
+  major=$(printf '%s' "$version" | awk -F. '{print $1}')
+  minor=$(printf '%s' "$version" | awk -F. '{print $2}')
+  [ -n "$major" ] && [ -n "$minor" ] || return 1
+  case "$major:$minor" in
+    *[!0-9:]*|:*|*:) return 1 ;;
+  esac
+  [ "$major" -gt "$min_major" ] && return 0
+  [ "$major" -eq "$min_major" ] && [ "$minor" -ge "$min_minor" ]
+}
+
+openclaw_smart_resolve_npm() {
+  local cand
+  for cand in npm npm.cmd; do
+    if command -v "$cand" >/dev/null 2>&1; then
+      command -v "$cand"
+      return 0
+    fi
+  done
+  return 1
+}
+
+openclaw_smart_npm_available() {
+  local npm_bin
+  npm_bin=$(openclaw_smart_resolve_npm || true)
+  [ -n "$npm_bin" ] || return 1
+  "$npm_bin" --version >/dev/null 2>&1
+}
+
+openclaw_smart_log_max_bytes() {
+  printf '%s\n' "10000000"
+}
+
+openclaw_smart_trim_log_file() {
+  local file max_bytes size tmp
+  file="$1"
+  max_bytes="${2:-$(openclaw_smart_log_max_bytes)}"
+  case "$max_bytes" in
+    ''|*[!0-9]*) return 0 ;;
+  esac
+  [ -f "$file" ] || return 0
+  size=$(wc -c < "$file" 2>/dev/null | tr -d '[:space:]') || return 0
+  case "$size" in
+    ''|*[!0-9]*) return 0 ;;
+  esac
+  [ "$size" -le "$max_bytes" ] && return 0
+
+  tmp="${file}.trim.$$"
+  if tail -c "$max_bytes" "$file" > "$tmp" 2>/dev/null; then
+    # Rewrite the existing path instead of replacing it, so a process with
+    # this file already open in append mode keeps writing to the capped file.
+    cat "$tmp" > "$file"
+  fi
+  rm -f "$tmp"
+}
+
+openclaw_smart_append_capped_log() {
+  local file max_bytes
+  file="$1"
+  max_bytes="${2:-$(openclaw_smart_log_max_bytes)}"
+  shift 2
+  mkdir -p "$(dirname "$file")"
+  openclaw_smart_trim_log_file "$file" "$max_bytes"
+  printf '%s\n' "$*" >> "$file"
+  openclaw_smart_trim_log_file "$file" "$max_bytes"
+}
+
+# Spawn a command fully detached from the current shell so a hook timeout
+# (openClaw's install/SessionStart budget) cannot kill it mid-flight.
+# POSIX: setsid → python3 os.setsid → nohup (in that order of strength).
+# Windows: nohup alone — Git Bash has no setsid, no process groups, and
+# `os.setsid()` is POSIX-only; nohup ignores SIGHUP which is enough to
+# survive the parent console closing. The python3 fallback is gated on a
+# real-interpreter probe (-V) so the Windows App Execution Alias stub
+# doesn't get invoked. Caller is responsible for redirecting stdout/stderr;
+# we do not impose a log destination here. Stdin is closed so the child
+# cannot inherit a tty. Use `$!` after this call to capture the pid.
+openclaw_smart_spawn_detached() {
+  if openclaw_smart_is_windows; then
+    nohup "$@" < /dev/null &
+    return 0
+  fi
+  if command -v setsid >/dev/null 2>&1; then
+    setsid nohup "$@" < /dev/null &
+  elif _OC_PY=$(openclaw_smart_resolve_python) && [ -n "$_OC_PY" ]; then
+    "$_OC_PY" -c 'import os,sys; os.setsid(); os.execvp(sys.argv[1], sys.argv[1:])' \
+      "$@" < /dev/null &
+  else
+    nohup "$@" < /dev/null &
+  fi
+}
+
+# Terminate a process and (on POSIX) its whole process group, escalating
+# from TERM to KILL after a short grace period. On Windows there are no
+# POSIX process groups, so we use `taskkill /T /F /PID` which walks the
+# child-process tree via the Windows job-object/parent-pid relationships
+# — the closest equivalent to a group kill.
+#
+# Windows-specific subtlety: in Git Bash / MSYS, `$!` for a backgrounded
+# job returns the MSYS pid (an internal counter), NOT the native Windows
+# pid that taskkill needs. `ps -W` (or `-o winpid=`) exposes the WINPID
+# column for the translation. If the lookup fails we fall back to
+# treating the input as a native pid, so callers can pass either an MSYS
+# pid (recorded via $!) or a Windows pid (from tasklist) interchangeably.
+# The `//T //F //PID` syntax escapes Git Bash's MSYS path-mangling of
+# arguments that begin with `/`.
+openclaw_smart_kill_tree() {
+  pid="$1"
+  [ -z "$pid" ] && return 0
+  if openclaw_smart_is_windows; then
+    # Git Bash's `ps` is the procps fork, not BSD/Linux ps; it has no
+    # -o option but its default header is `PID PPID PGID WINPID TTY ...`,
+    # so column 4 of the data row is the Windows pid. awk extracts it
+    # without depending on -o support.
+    target=""
+    if command -v ps >/dev/null 2>&1; then
+      target=$(ps -p "$pid" 2>/dev/null | awk 'NR==2 {print $4}' | tr -d ' \r\n' || true)
+    fi
+    [ -z "$target" ] && target="$pid"
+    if command -v taskkill >/dev/null 2>&1; then
+      taskkill //T //F //PID "$target" >/dev/null 2>&1 || true
+    else
+      kill -TERM "$pid" 2>/dev/null || true
+      sleep 0.5
+      kill -KILL "$pid" 2>/dev/null || true
+    fi
+    return 0
+  fi
+  current_pgid=""
+  if command -v ps >/dev/null 2>&1; then
+    current_pgid=$(ps -o pgid= -p "$$" 2>/dev/null | tr -d ' ')
+  fi
+  if [ -n "$current_pgid" ] && [ "$pid" = "$current_pgid" ]; then
+    return 0
+  fi
+  if ! kill -TERM -- "-$pid" 2>/dev/null; then
+    kill -TERM "$pid" 2>/dev/null || true
+    sleep 0.5
+    kill -KILL "$pid" 2>/dev/null || true
+    return 0
+  fi
+  for _ in 1 2 3 4 5; do
+    kill -0 -- "-$pid" 2>/dev/null || return 0
+    sleep 0.2
+  done
+  kill -KILL -- "-$pid" 2>/dev/null || true
+}
+
+# Return 0 (true) if $1 names a pid file whose pid is currently alive.
+# Silent on missing/empty/stale files.
+openclaw_smart_pid_alive_file() {
+  pid_file="$1"
+  [ -f "$pid_file" ] || return 1
+  pid=$(cat "$pid_file" 2>/dev/null || echo "")
+  [ -n "$pid" ] || return 1
+  kill -0 "$pid" 2>/dev/null
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/scripts/backend-log-runner.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# Run the backend command and stream its stdout/stderr into a capped log file.
+set -eu
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=_lib.sh
+. "$HERE/_lib.sh"
+
+if [ "$#" -lt 4 ] || [ "$3" != "--" ]; then
+  exit 2
+fi
+
+LOG_FILE="$1"
+MAX_BYTES="$2"
+shift 3
+
+mkdir -p "$(dirname "$LOG_FILE")"
+openclaw_smart_trim_log_file "$LOG_FILE" "$MAX_BYTES"
+
+STATUS_FILE="${TMPDIR:-/tmp}/openclaw-smart-backend-log-runner.$$.status"
+rm -f "$STATUS_FILE"
+
+(
+  set +e
+  "$@" 2>&1
+  printf '%s\n' "$?" > "$STATUS_FILE"
+) | while IFS= read -r line || [ -n "$line" ]; do
+  openclaw_smart_append_capped_log "$LOG_FILE" "$MAX_BYTES" "$line"
+done
+
+status=$(cat "$STATUS_FILE" 2>/dev/null || printf '1')
+rm -f "$STATUS_FILE"
+exit "$status"

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/scripts/backend-service.sh

@@ -0,0 +1,271 @@
+#!/usr/bin/env bash
+# Auto-start the reflexio FastAPI backend (port 8071) if it's not already
+# running. Detached spawn, returns immediately so the SessionStart hook
+# doesn't block the session.
+#
+# Port choice: openclaw-smart shares 8071/8072 with the sibling claude-smart
+# plugin so the two plugins coexist on a single shared backend (one SQLite
+# store, one extractor process) — not reflexio's 8061 default, which is
+# reserved for a developer's own local reflexio instance.
+#
+# Subcommands:
+#   start         probe /health; if nothing we recognize is on the port,
+#                 spawn `uv run reflexio services start --only backend
+#                 --no-reload` detached. Polls /health briefly so first
+#                 use after session start lands on a warm server, then
+#                 returns empty stdout regardless.
+#   stop          SIGTERM the recorded process group, escalating to
+#                 SIGKILL after a short grace period.
+#   session-end   no-op by default; only stops the backend if
+#                 OPENCLAW_SMART_BACKEND_STOP_ON_END=1 (opt-in — the
+#                 backend is intended to be long-lived across sessions).
+#   status        print "running on http://localhost:PORT" or "not running".
+set -eu
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=_lib.sh
+. "$HERE/_lib.sh"
+openclaw_smart_source_login_path
+openclaw_smart_prepend_astral_bins
+
+CMD="${1:-start}"
+PORT=8071
+EMBEDDING_PORT="${EMBEDDING_PORT:-8072}"
+# Pass through to `reflexio services start/stop` so the spawned backend
+# binds to PORT.
+export BACKEND_PORT="$PORT"
+export EMBEDDING_PORT
+
+# Default: route extraction through the active host CLI + ONNX embedder
+# so openclaw-smart works without any LLM API key. Users can opt out by
+# pre-exporting these to 0.
+export OPENCLAW_SMART_USE_LOCAL_CLI="${OPENCLAW_SMART_USE_LOCAL_CLI:-1}"
+export OPENCLAW_SMART_USE_LOCAL_EMBEDDING="${OPENCLAW_SMART_USE_LOCAL_EMBEDDING:-1}"
+if [ "${OPENCLAW_SMART_USE_LOCAL_EMBEDDING:-}" = "1" ]; then
+  export REFLEXIO_EMBEDDING_PROVIDER="${REFLEXIO_EMBEDDING_PROVIDER:-local_service}"
+  export REFLEXIO_EMBEDDING_SERVICE_URL="${REFLEXIO_EMBEDDING_SERVICE_URL:-http://127.0.0.1:$EMBEDDING_PORT}"
+fi
+PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
+
+# Pin the openclaw CLI explicitly so the reflexio backend's openclaw_provider
+# can find it from a hook context whose PATH lacks the user's normal CLI dir.
+if [ -z "${OPENCLAW_BIN:-}" ]; then
+  if _oc_cli_path=$(command -v openclaw 2>/dev/null) && [ -n "$_oc_cli_path" ]; then
+    export OPENCLAW_BIN="$_oc_cli_path"
+  elif [ -x "$HOME/.local/bin/openclaw" ]; then
+    export OPENCLAW_BIN="$HOME/.local/bin/openclaw"
+  fi
+  unset _oc_cli_path
+fi
+
+STATE_DIR="$HOME/.openclaw-smart"
+PID_FILE="$STATE_DIR/backend.pid"
+LOG_FILE="$STATE_DIR/backend.log"
+LOG_MAX_BYTES="$(openclaw_smart_log_max_bytes)"
+mkdir -p "$STATE_DIR"
+openclaw_smart_trim_log_file "$LOG_FILE" "$LOG_MAX_BYTES"
+
+emit_ok() { echo ''; }
+
+emit_start_failure() {
+  reason="$1"
+  if py=$(openclaw_smart_resolve_python 2>/dev/null); then
+    "$py" - "$reason" <<'PY'
+import json
+import sys
+
+reason = sys.argv[1].strip()
+message = (
+    "> **openclaw-smart learning backend is not running.** "
+    "Interactions are being buffered locally, but learning will not publish "
+    "until the backend starts.\n"
+)
+if reason:
+    message += f">\n> Last startup error: `{reason}`\n"
+message += (
+    ">\n> Make sure the openclaw CLI is on PATH so the local model provider "
+    "can be reached. Then run `/openclaw-smart:restart`."
+)
+print(json.dumps({"prependContext": message}))
+PY
+  else
+    emit_ok
+  fi
+}
+
+# Tree-kill the recorded process.
+kill_group() {
+  openclaw_smart_kill_tree "$1"
+}
+
+# True if /health returns 200. Reflexio's /health is a plain GET with no
+# marker header, so we can't distinguish our backend from someone else's
+# reflexio on the same port — if you run two reflexio instances on $PORT
+# you'll get collision regardless of what we do here.
+backend_healthy() {
+  command -v curl >/dev/null 2>&1 || return 1
+  curl -sf -o /dev/null "http://127.0.0.1:$PORT/health" 2>/dev/null
+}
+
+# True only if the recorded PID is alive AND /health responds. A stale
+# PID file from a crashed backend is not enough — we must see the port
+# actually answer, so next hook retries cleanly.
+is_our_backend_running() {
+  if [ -f "$PID_FILE" ]; then
+    pid=$(cat "$PID_FILE" 2>/dev/null || echo "")
+    if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+      backend_healthy && return 0
+    fi
+  fi
+  # Recover from a missing PID file if a foreign-but-functional reflexio
+  # is already serving — no need to start a second one.
+  backend_healthy && return 0
+  return 1
+}
+
+# True if *anything* is listening on the port (even non-HTTP). Used to
+# avoid stomping on a foreign listener with a failed-to-start uvicorn.
+port_occupied() {
+  (echo >"/dev/tcp/127.0.0.1/$PORT") 2>/dev/null
+}
+
+# Reap any reflexio/uvicorn listener still holding $PORT after the PID
+# file kill. Filters by cmdline so we don't knock over an unrelated
+# service a user has bound to $PORT — symmetric with start's refusal to
+# stomp on a foreign listener. Silent on failure.
+reap_port_listeners() {
+  command -v lsof >/dev/null 2>&1 || return 0
+  candidates=$(lsof -ti:"$PORT" 2>/dev/null) || candidates=""
+  [ -z "$candidates" ] && return 0
+  ours=""
+  for pid in $candidates; do
+    cmdline=$(ps -p "$pid" -o command= 2>/dev/null || true)
+    case "$cmdline" in
+      *reflexio*|*uvicorn*) ours="$ours $pid" ;;
+    esac
+  done
+  [ -z "$ours" ] && return 0
+  # shellcheck disable=SC2086
+  kill -TERM $ours 2>/dev/null || true
+  sleep 1
+  remaining=""
+  for pid in $ours; do
+    kill -0 "$pid" 2>/dev/null && remaining="$remaining $pid"
+  done
+  [ -z "$remaining" ] && return 0
+  # shellcheck disable=SC2086
+  kill -KILL $remaining 2>/dev/null || true
+}
+
+# Full shutdown: kill the recorded process group (if any) then sweep the
+# port for surviving reflexio listeners. Used by both `stop` and the
+# opt-in `session-end` path so a stale/missing PID file doesn't produce
+# a silent no-op.
+full_stop() {
+  if [ -f "$PID_FILE" ]; then
+    kill_group "$(cat "$PID_FILE" 2>/dev/null)"
+    rm -f "$PID_FILE"
+  fi
+  reap_port_listeners
+}
+
+case "$CMD" in
+  start)
+    if openclaw_smart_is_internal_invocation_env; then
+      emit_ok; exit 0
+    fi
+    # Opt-out: users who don't want the backend managed by the hook can
+    # set OPENCLAW_SMART_BACKEND_AUTOSTART=0.
+    if [ "${OPENCLAW_SMART_BACKEND_AUTOSTART:-1}" = "0" ]; then
+      emit_ok; exit 0
+    fi
+    if is_our_backend_running; then emit_ok; exit 0; fi
+    if port_occupied; then
+      # Something answered the TCP probe but /health didn't — don't
+      # start a second uvicorn on top of it.
+      openclaw_smart_append_capped_log "$LOG_FILE" "$LOG_MAX_BYTES" "[openclaw-smart] backend: port $PORT held by another process; skipping"
+      emit_ok; exit 0
+    fi
+    if ! command -v uv >/dev/null 2>&1; then
+      if [ "${OPENCLAW_SMART_BOOTSTRAPPING:-}" != "1" ] && [ -x "$PLUGIN_ROOT/scripts/smart-install.sh" ]; then
+        openclaw_smart_append_capped_log "$LOG_FILE" "$LOG_MAX_BYTES" "[openclaw-smart] backend: uv not on PATH; running installer"
+        OPENCLAW_SMART_BOOTSTRAPPING=1 bash "$PLUGIN_ROOT/scripts/smart-install.sh" >>"$STATE_DIR/install.log" 2>&1 || true
+        openclaw_smart_source_login_path
+        openclaw_smart_prepend_astral_bins
+      fi
+      if ! command -v uv >/dev/null 2>&1; then
+        openclaw_smart_append_capped_log "$LOG_FILE" "$LOG_MAX_BYTES" "[openclaw-smart] backend: uv not on PATH after installer; skipping"
+        emit_ok; exit 0
+      fi
+    fi
+    # The reflexio project root lives four levels above the plugin dir:
+    # plugin/ -> integrations/openclaw -> reflexio/integrations -> reflexio -> open_source/reflexio
+    REFLEXIO_PROJECT="$(cd "$PLUGIN_ROOT/../../../.." && pwd)"
+    cd "$REFLEXIO_PROJECT"
+
+    # Cap local interaction history to keep the SQLite store small for
+    # openclaw-smart users. Reflexio's library defaults are much higher
+    # (250k/50k) for server deployments; here we override only in the
+    # openclaw-smart plugin context. Users can still override via env.
+    export INTERACTION_CLEANUP_THRESHOLD="${INTERACTION_CLEANUP_THRESHOLD:-500}"
+    export INTERACTION_CLEANUP_DELETE_COUNT="${INTERACTION_CLEANUP_DELETE_COUNT:-200}"
+
+    # backend-log-runner.sh owns stdout/stderr capture so process output
+    # cannot grow backend.log past its cap.
+    #
+    # --workers: reflexio defaults to 2 (zero-downtime worker recycling
+    # for server deployments). For a single-user openClaw plugin that's
+    # pure overhead: ~1.1 GB extra RSS, periodic 5–10 s spawn hiccups
+    # during worker rotation, and SQLite can't accept concurrent writers
+    # anyway. Default to 1 here; opt in to N via
+    # OPENCLAW_SMART_BACKEND_WORKERS for power users running concurrent
+    # openClaw sessions or wanting zero-downtime recycling.
+    workers="${OPENCLAW_SMART_BACKEND_WORKERS:-1}"
+    openclaw_smart_spawn_detached bash "$HERE/backend-log-runner.sh" \
+      "$LOG_FILE" "$LOG_MAX_BYTES" -- \
+      uv run --project "$REFLEXIO_PROJECT" --quiet \
+      reflexio services start --only backend --no-reload --workers "$workers"
+    svc_pid=$!
+    # Record the spawned pid, not a pgid sampled with ps. On POSIX,
+    # setsid/python os.setsid make this pid the new process group leader;
+    # sampling immediately can race and capture the caller's pgid instead.
+    echo "$svc_pid" > "$PID_FILE"
+
+    # Give uvicorn up to ~10s to answer /health. The very first boot
+    # after a fresh checkout may be slower (LiteLLM import, chromadb
+    # warmup). We always return ok; the backend catches up in background
+    # if it needs to.
+    for _ in 1 2 3 4 5 6 7 8 9 10; do
+      backend_healthy && break
+      sleep 1
+    done
+    if ! backend_healthy; then
+      pid=$(cat "$PID_FILE" 2>/dev/null || echo "")
+      if [ -n "$pid" ] && ! kill -0 "$pid" 2>/dev/null; then
+        reason=$(tail -n 120 "$LOG_FILE" 2>/dev/null | grep -E "No LLM provider available|No generation-capable LLM provider available|CLI not found|skipping provider registration|Application startup failed" | tail -n 1 | sed 's/^[[:space:]]*//')
+        emit_start_failure "$reason"
+        exit 0
+      fi
+    fi
+    emit_ok
+    ;;
+  stop)
+    full_stop
+    emit_ok
+    ;;
+  session-end)
+    # Default: leave the backend running so learning keeps flowing
+    # between sessions. Opt in to teardown with
+    # OPENCLAW_SMART_BACKEND_STOP_ON_END=1.
+    if [ "${OPENCLAW_SMART_BACKEND_STOP_ON_END:-0}" = "1" ]; then
+      full_stop
+    fi
+    emit_ok
+    ;;
+  status)
+    if is_our_backend_running; then echo "running on http://localhost:$PORT"; else echo "not running"; fi
+    ;;
+  *)
+    emit_ok
+    ;;
+esac