nexo-brain 2.3.0 → 2.3.2

package/src/hooks/capture-tool-logs.sh

@@ -41,8 +41,12 @@ record = {
 print(json.dumps(record))
 " >> "$LOG_FILE" 2>/dev/null
 
-# ── Layer 1: Auto-diary every 10 tool calls ─────────────────────────
-COUNTER_FILE="$NEXO_HOME/operations/.tool-call-count"
+# ── Layer 1: Auto-diary every 10 tool calls (session-scoped) ─────────
+# Extract session_id for per-session counters (prevents cross-terminal contamination)
+SESSION_ID=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('session_id','global'))" 2>/dev/null || echo "global")
+COUNTER_DIR="$NEXO_HOME/operations/counters"
+mkdir -p "$COUNTER_DIR"
+COUNTER_FILE="$COUNTER_DIR/.tool-call-count-${SESSION_ID}"
 NEXO_DB="$NEXO_HOME/data/nexo.db"
 
 # Increment counter (atomic: read+write in one step)
@@ -86,12 +90,25 @@ if not entries:
 
 tools_summary = ', '.join(entries[-10:])
 
-# Get current session and task from sessions table
+# Get session by claude session_id (scoped), fallback to most recent
+session_id = '$SESSION_ID'
 conn = sqlite3.connect(db_path, timeout=2)
 conn.row_factory = sqlite3.Row
-row = conn.execute(
-    'SELECT sid, task FROM sessions ORDER BY last_update_epoch DESC LIMIT 1'
-).fetchone()
+
+# Try to find NEXO SID mapped to this claude session_id
+row = None
+if session_id and session_id != 'global':
+    row = conn.execute(
+        'SELECT sid, task FROM sessions WHERE claude_session_id = ? LIMIT 1',
+        (session_id,)
+    ).fetchone()
+
+# Fallback: most recent active session
+if not row:
+    row = conn.execute(
+        'SELECT sid, task FROM sessions ORDER BY last_update_epoch DESC LIMIT 1'
+    ).fetchone()
+
 if not row:
     conn.close()
     sys.exit(0)

package/src/hooks/session-start.sh

@@ -92,10 +92,11 @@ try:
 
         try:
             rows = db.execute(
-                'SELECT sid, task, started FROM sessions '
-                'WHERE completed=0 AND (strftime(\"%s\",\"now\") - last_update) < 900'
+                'SELECT sid, task, started_epoch FROM sessions '
+                'WHERE (strftime(\"%s\",\"now\") - last_update_epoch) < 900'
             ).fetchall()
-            sessions = [{'sid': r['sid'], 'task': r['task'], 'started': r['started'][:16]} for r in rows]
+            from datetime import datetime as _dt
+            sessions = [{'sid': r['sid'], 'task': r['task'], 'started': _dt.fromtimestamp(r['started_epoch']).strftime('%Y-%m-%d %H:%M') if r['started_epoch'] else '?'} for r in rows]
         except Exception:
             pass
 

package/src/plugin_loader.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 """Dynamic plugin loader for NEXO MCP server."""
 
 import importlib

package/src/plugins/update.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 """Update plugin — pull latest code, backup DBs, run migrations, verify."""
 import json
 import os
@@ -12,19 +13,71 @@ from pathlib import Path
 _THIS_DIR = Path(__file__).resolve().parent
 REPO_DIR = _THIS_DIR.parent.parent
 PACKAGE_JSON = REPO_DIR / "package.json"
-SRC_DIR = REPO_DIR / "src"
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 DATA_DIR = NEXO_HOME / "data"
 BACKUP_BASE = NEXO_HOME / "backups"
 
+# In packaged installs, update.py lives at ~/.nexo/plugins/update.py
+# so REPO_DIR would be ~/ (wrong). Detect this and fix paths.
+_PACKAGED_INSTALL = not (REPO_DIR / ".git").exists() and not (REPO_DIR / ".git").is_file()
+
+if _PACKAGED_INSTALL:
+    # In packaged mode, core .py files live directly in NEXO_HOME
+    SRC_DIR = NEXO_HOME
+else:
+    SRC_DIR = REPO_DIR / "src"
+
+
+def _find_npm_pkg_src() -> Path | None:
+    """Locate the nexo-brain npm package's src/ directory for requirements.txt."""
+    try:
+        result = subprocess.run(
+            ["npm", "root", "-g"],
+            capture_output=True, text=True, timeout=10,
+        )
+        if result.returncode == 0:
+            npm_src = Path(result.stdout.strip()) / "nexo-brain" / "src"
+            if npm_src.is_dir():
+                return npm_src
+    except Exception:
+        pass
+    return None
+
+def _is_git_repo() -> bool:
+    """Check if REPO_DIR is a valid git repository."""
+    return (REPO_DIR / ".git").exists() or (REPO_DIR / ".git").is_file()
+
+
+def _refresh_installed_manifest():
+    """Copy source crons/ to NEXO_HOME/crons/ so catchup & watchdog stay current."""
+    try:
+        src_crons = SRC_DIR / "crons"
+        dst_crons = NEXO_HOME / "crons"
+        if src_crons.exists():
+            dst_crons.mkdir(parents=True, exist_ok=True)
+            for f in src_crons.iterdir():
+                if f.is_file():
+                    shutil.copy2(str(f), str(dst_crons / f.name))
+    except Exception:
+        pass
+
 
 def _read_version() -> str:
-    """Read version from package.json."""
+    """Read version from package.json or NEXO_HOME/version.json (packaged installs)."""
     try:
-        return json.loads(PACKAGE_JSON.read_text()).get("version", "unknown")
+        if PACKAGE_JSON.exists():
+            return json.loads(PACKAGE_JSON.read_text()).get("version", "unknown")
     except Exception:
-        return "unknown"
+        pass
+    # Packaged installs don't ship package.json — check version.json in NEXO_HOME
+    try:
+        version_file = NEXO_HOME / "version.json"
+        if version_file.exists():
+            return json.loads(version_file.read_text()).get("version", "unknown")
+    except Exception:
+        pass
+    return "unknown"
 
 
 def _git(*args, cwd=None) -> tuple[int, str, str]:
@@ -39,13 +92,28 @@ def _git(*args, cwd=None) -> tuple[int, str, str]:
     return result.returncode, result.stdout.strip(), result.stderr.strip()
 
 
+def _requirements_hash() -> str:
+    """Return a content hash of requirements.txt, or empty string if missing."""
+    import hashlib
+    req_file = SRC_DIR / "requirements.txt"
+    if not req_file.exists() and _PACKAGED_INSTALL:
+        npm_src = _find_npm_pkg_src()
+        if npm_src:
+            req_file = npm_src / "requirements.txt"
+    if req_file.exists():
+        return hashlib.sha256(req_file.read_bytes()).hexdigest()
+    return ""
+
+
 def _check_dirty() -> str | None:
-    """Return error message if src/ has uncommitted changes, else None."""
-    rc, out, _ = _git("status", "--porcelain", "--", "src/")
+    """Return error message if worktree has uncommitted changes, else None."""
+    if not _is_git_repo():
+        return None  # Not a git repo, skip dirty check
+    rc, out, _ = _git("status", "--porcelain")
     if rc != 0:
         return "Failed to check git status."
     if out:
-        return f"Uncommitted changes in src/:\n{out}\nCommit or stash before updating."
+        return f"Uncommitted changes:\n{out}\nCommit or stash before updating."
     return None
 
 
@@ -101,12 +169,51 @@ def _restore_databases(backup_dir: str):
                 break
 
 
+def _reinstall_pip_deps() -> str | None:
+    """Reinstall Python dependencies from requirements.txt into the managed venv."""
+    req_file = SRC_DIR / "requirements.txt"
+    if not req_file.exists() and _PACKAGED_INSTALL:
+        # In packaged mode, requirements.txt lives in the npm package's src/ dir
+        npm_src = _find_npm_pkg_src()
+        if npm_src:
+            req_file = npm_src / "requirements.txt"
+    if not req_file.exists():
+        return None  # No requirements file, skip
+    venv_pip = NEXO_HOME / ".venv" / "bin" / "pip"
+    if not venv_pip.exists():
+        venv_pip = NEXO_HOME / ".venv" / "bin" / "pip3"
+    if not venv_pip.exists():
+        # No venv, try system pip with --break-system-packages
+        try:
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "install", "--quiet", "-r", str(req_file), "--break-system-packages"],
+                capture_output=True, text=True, timeout=120,
+            )
+            if result.returncode != 0:
+                return f"pip install failed: {result.stderr or result.stdout}"
+        except Exception as e:
+            return f"pip install error: {e}"
+        return None
+    try:
+        result = subprocess.run(
+            [str(venv_pip), "install", "--quiet", "-r", str(req_file)],
+            capture_output=True, text=True, timeout=120,
+        )
+        if result.returncode != 0:
+            return f"pip install failed: {result.stderr or result.stdout}"
+    except Exception as e:
+        return f"pip install error: {e}"
+    return None
+
+
 def _run_migrations() -> str | None:
     """Run init_db() to apply pending migrations. Returns error or None."""
+    # In packaged mode, db/ lives in NEXO_HOME; in dev mode, in SRC_DIR
+    cwd = str(NEXO_HOME) if _PACKAGED_INSTALL else str(SRC_DIR)
     try:
         result = subprocess.run(
             [sys.executable, "-c", "import db; db.init_db()"],
-            cwd=str(SRC_DIR),
+            cwd=cwd,
             capture_output=True,
             text=True,
             timeout=30,
@@ -120,10 +227,12 @@ def _run_migrations() -> str | None:
 
 def _verify_import() -> str | None:
     """Verify server.py can be imported successfully."""
+    # In packaged mode, server.py lives in NEXO_HOME; in dev mode, in SRC_DIR
+    cwd = str(NEXO_HOME) if _PACKAGED_INSTALL else str(SRC_DIR)
     try:
         result = subprocess.run(
             [sys.executable, "-c", "import server"],
-            cwd=str(SRC_DIR),
+            cwd=cwd,
             capture_output=True,
             text=True,
             timeout=15,
@@ -135,27 +244,235 @@ def _verify_import() -> str | None:
     return None
 
 
+def _sync_hooks_to_home():
+    """Copy hook scripts from src/hooks/ to NEXO_HOME/hooks/ after update."""
+    import shutil
+    hooks_src = SRC_DIR / "hooks"
+    hooks_dest = NEXO_HOME / "hooks"
+    if not hooks_src.is_dir():
+        return
+    hooks_dest.mkdir(parents=True, exist_ok=True)
+    synced = 0
+    for f in hooks_src.iterdir():
+        if f.is_file() and f.suffix == ".sh":
+            dest = hooks_dest / f.name
+            shutil.copy2(str(f), str(dest))
+            os.chmod(str(dest), 0o755)
+            synced += 1
+    if synced:
+        print(f"[NEXO update] Synced {synced} hook(s) to {hooks_dest}", file=sys.stderr)
+
+
+def _backup_code_tree() -> tuple[str | None, str | None]:
+    """Snapshot NEXO_HOME code dirs before npm update. Returns (backup_dir, error)."""
+    timestamp = time.strftime("%Y-%m-%d-%H%M%S")
+    backup_dir = BACKUP_BASE / f"code-tree-{timestamp}"
+    # Directories and flat files that postinstall copies into NEXO_HOME
+    code_dirs = ["hooks", "plugins", "db", "cognitive", "dashboard", "rules", "crons", "scripts"]
+    code_files_glob = ["*.py", "requirements.txt"]
+    try:
+        backup_dir.mkdir(parents=True, exist_ok=True)
+        # Backup directories
+        for d in code_dirs:
+            src = NEXO_HOME / d
+            if src.is_dir():
+                shutil.copytree(src, backup_dir / d, dirs_exist_ok=True)
+        # Backup flat code files in NEXO_HOME root
+        for pattern in code_files_glob:
+            for f in NEXO_HOME.glob(pattern):
+                if f.is_file():
+                    shutil.copy2(f, backup_dir / f.name)
+        # Backup version.json
+        vf = NEXO_HOME / "version.json"
+        if vf.is_file():
+            shutil.copy2(vf, backup_dir / "version.json")
+    except Exception as e:
+        return None, f"Code tree backup failed: {e}"
+    return str(backup_dir), None
+
+
+def _restore_code_tree(backup_dir: str) -> str | None:
+    """Restore NEXO_HOME code dirs from a backup snapshot. Returns error or None."""
+    bdir = Path(backup_dir)
+    if not bdir.is_dir():
+        return f"Code tree backup dir not found: {backup_dir}"
+    try:
+        for item in bdir.iterdir():
+            dest = NEXO_HOME / item.name
+            if item.is_dir():
+                if dest.is_dir():
+                    shutil.rmtree(dest)
+                shutil.copytree(item, dest)
+            elif item.is_file():
+                shutil.copy2(item, dest)
+    except Exception as e:
+        return f"Code tree restore failed: {e}"
+    return None
+
+
+def _rollback_npm_package(target_version: str) -> str | None:
+    """Rollback nexo-brain npm package to a specific version.
+
+    Uses NEXO_SKIP_POSTINSTALL because we restore the code tree
+    from our own pre-update backup — no need for postinstall migration.
+    """
+    try:
+        result = subprocess.run(
+            ["npm", "install", "-g", f"nexo-brain@{target_version}"],
+            capture_output=True, text=True, timeout=120,
+            env={**os.environ, "NEXO_SKIP_POSTINSTALL": "1", "NEXO_HOME": str(NEXO_HOME)},
+        )
+        if result.returncode != 0:
+            return f"npm rollback failed: {result.stderr or result.stdout}"
+    except Exception as e:
+        return f"npm rollback error: {e}"
+    return None
+
+
+def _handle_packaged_update() -> str:
+    """Update a packaged (npm) install — no git repo available."""
+    old_version = _read_version()
+
+    # 1. Backup databases BEFORE any changes
+    backup_dir, backup_err = _backup_databases()
+    if backup_err:
+        return f"ABORTED at backup: {backup_err}"
+
+    # 2. Backup NEXO_HOME code tree BEFORE npm update
+    #    postinstall copies hooks/core/plugins/scripts into NEXO_HOME,
+    #    so we need a full snapshot to restore on failure.
+    code_backup_dir, code_err = _backup_code_tree()
+    if code_err:
+        return f"ABORTED at code tree backup: {code_err}"
+
+    # 3. Run npm update (postinstall.js will migrate NEXO_HOME in-place)
+    try:
+        result = subprocess.run(
+            ["npm", "update", "-g", "nexo-brain"],
+            capture_output=True, text=True, timeout=120,
+            env={**os.environ, "NEXO_HOME": str(NEXO_HOME)},
+        )
+        if result.returncode != 0:
+            # npm failed (including postinstall failures) — full rollback
+            if backup_dir:
+                _restore_databases(backup_dir)
+            if code_backup_dir:
+                _restore_code_tree(code_backup_dir)
+                # Reinstall pip deps from restored old requirements.txt
+                _reinstall_pip_deps()
+            rollback_err = _rollback_npm_package(old_version)
+            msg = f"ABORTED: npm update failed: {result.stderr or result.stdout}"
+            if rollback_err:
+                msg += f"\n  WARNING: npm rollback also failed: {rollback_err}"
+                msg += f"\n  Manual rollback: npm install -g nexo-brain@{old_version}"
+            return msg
+    except FileNotFoundError:
+        return "ABORTED: npm not found. Install Node.js to update packaged installs."
+    except Exception as e:
+        if backup_dir:
+            _restore_databases(backup_dir)
+        if code_backup_dir:
+            _restore_code_tree(code_backup_dir)
+            # Reinstall pip deps from restored old requirements.txt
+            _reinstall_pip_deps()
+        rollback_err = _rollback_npm_package(old_version)
+        msg = f"ABORTED: npm update error: {e}"
+        if rollback_err:
+            msg += f"\n  WARNING: npm rollback also failed: {rollback_err}"
+            msg += f"\n  Manual rollback: npm install -g nexo-brain@{old_version}"
+        return msg
+
+    new_version = _read_version()
+    if old_version == new_version:
+        return f"Already up to date (v{old_version}). No changes."
+
+    # 4. Post-npm verification steps
+    errors = []
+
+    # Reinstall pip deps for new version
+    pip_err = _reinstall_pip_deps()
+    if pip_err:
+        errors.append(f"pip deps: {pip_err}")
+
+    # Run migrations
+    mig_err = _run_migrations()
+    if mig_err:
+        errors.append(f"migrations: {mig_err}")
+
+    # Verify server can still import
+    verify_err = _verify_import()
+    if verify_err:
+        errors.append(f"verification: {verify_err}")
+
+    if errors:
+        # 5. Full rollback: restore code tree + DBs + pip deps + rollback npm package
+        if code_backup_dir:
+            tree_err = _restore_code_tree(code_backup_dir)
+        else:
+            tree_err = "no code tree backup available"
+        if backup_dir:
+            _restore_databases(backup_dir)
+        # Reinstall pip deps from the restored (old) requirements.txt
+        # so the venv matches the rolled-back code tree
+        pip_rollback_err = _reinstall_pip_deps() if not tree_err else None
+        rollback_err = _rollback_npm_package(old_version)
+        lines = [f"UPDATE FAILED (packaged install, v{old_version} -> v{new_version})"]
+        for err in errors:
+            lines.append(f"  ERROR: {err}")
+        lines.append(f"  Databases restored from: {backup_dir}")
+        if tree_err:
+            lines.append(f"  WARNING: code tree restore failed: {tree_err}")
+        else:
+            lines.append(f"  Code tree restored from: {code_backup_dir}")
+        if pip_rollback_err:
+            lines.append(f"  WARNING: pip deps rollback failed: {pip_rollback_err}")
+        elif not tree_err:
+            lines.append("  Python deps: reinstalled from old requirements.txt")
+        if rollback_err:
+            lines.append(f"  WARNING: npm rollback failed: {rollback_err}")
+            lines.append(f"  Manual rollback: npm install -g nexo-brain@{old_version}")
+        else:
+            lines.append(f"  npm package rolled back to v{old_version}")
+        lines.append("")
+        lines.append("Fix the errors above, then run nexo_update again.")
+        return "\n".join(lines)
+
+    lines = ["UPDATE SUCCESSFUL (packaged install)"]
+    lines.append(f"  Version: {old_version} -> {new_version}")
+    lines.append(f"  Backup: {backup_dir}")
+    lines.append("")
+    lines.append("MCP server restart needed to load new code.")
+    return "\n".join(lines)
+
+
 def handle_update(remote: str = "origin", branch: str = "main") -> str:
     """Pull latest NEXO code, backup databases, run migrations, and verify.
 
-    Full update flow:
-    1. Check for uncommitted changes in src/
+    Supports both git checkouts and packaged (npm) installs.
+
+    Full update flow (git):
+    1. Check for uncommitted changes in entire worktree
     2. Backup all .db files
     3. git pull
-    4. Run migrations if version changed
-    5. Verify server.py imports
-    6. Rollback on failure
+    4. Reinstall Python dependencies if version changed
+    5. Run migrations if version changed
+    6. Verify server.py imports
+    7. Rollback on failure (git reset --hard to saved commit)
 
     Args:
         remote: Git remote name (default: origin)
         branch: Git branch to pull (default: main)
     """
+    # Packaged install — no git repo
+    if not _is_git_repo():
+        return _handle_packaged_update()
+
     steps_done = []
     old_commit = None
     backup_dir = None
 
     try:
-        # Step 1: Check dirty
+        # Step 1: Check dirty (full worktree)
         dirty_err = _check_dirty()
         if dirty_err:
             return f"ABORTED: {dirty_err}"
@@ -163,6 +480,7 @@ def handle_update(remote: str = "origin", branch: str = "main") -> str:
 
         # Record current state
         old_version = _read_version()
+        old_req_hash = _requirements_hash()
         rc, old_commit, _ = _git("rev-parse", "HEAD")
         if rc != 0:
             return "ABORTED: Not a git repository or git not available."
@@ -179,39 +497,59 @@ def handle_update(remote: str = "origin", branch: str = "main") -> str:
             return f"ABORTED at git pull: {pull_err or pull_out}"
         steps_done.append("git-pull")
 
-        # Step 4: Check version change
+        # Step 4: Check version and dependency changes
         new_version = _read_version()
         version_changed = old_version != new_version
+        new_req_hash = _requirements_hash()
+        deps_changed = old_req_hash != new_req_hash
 
-        # Step 5: Run migrations if version changed
+        # Step 5: Reinstall pip dependencies if requirements.txt changed
+        if deps_changed or version_changed:
+            pip_err = _reinstall_pip_deps()
+            if pip_err:
+                raise RuntimeError(f"Pip install failed: {pip_err}")
+            steps_done.append("pip-deps")
+
+        # Step 6: Run migrations if version changed
         if version_changed:
             mig_err = _run_migrations()
             if mig_err:
                 raise RuntimeError(f"Migration failed: {mig_err}")
             steps_done.append("migrations")
 
-        # Step 6: Verify import
+        # Step 7: Verify import
         verify_err = _verify_import()
         if verify_err:
             raise RuntimeError(f"Verification failed: {verify_err}")
         steps_done.append("verify")
 
-        # Step 7: Sync crons with manifest
+        # Step 8: Sync crons with manifest
         cron_sync_result = ""
         try:
-            cron_sync_path = NEXO_CODE / "crons" / "sync.py"
+            cron_sync_path = SRC_DIR / "crons" / "sync.py"
             if cron_sync_path.exists():
-                import subprocess as _sp
-                r = _sp.run(
+                r = subprocess.run(
                     [sys.executable, str(cron_sync_path)],
                     capture_output=True, text=True, timeout=30,
-                    env={**os.environ, "NEXO_HOME": str(NEXO_HOME), "NEXO_CODE": str(NEXO_CODE)},
+                    env={**os.environ, "NEXO_HOME": str(NEXO_HOME), "NEXO_CODE": str(SRC_DIR)},
                 )
                 cron_sync_result = r.stdout.strip()
-                steps_done.append("cron-sync")
+                if r.returncode == 0:
+                    steps_done.append("cron-sync")
+                    # Refresh installed manifest only after successful sync
+                    _refresh_installed_manifest()
+                else:
+                    cron_sync_result = f"Cron sync failed (exit {r.returncode}): {r.stderr or r.stdout}"
         except Exception as e:
             cron_sync_result = f"Cron sync warning: {e}"
 
+        # Step 9: Sync hooks to NEXO_HOME
+        try:
+            _sync_hooks_to_home()
+            steps_done.append("hook-sync")
+        except Exception as e:
+            pass  # Non-critical, log in function
+
         # Build result
         if pull_out == "Already up to date.":
             return f"Already up to date (v{old_version}). No changes pulled."
@@ -223,22 +561,35 @@ def handle_update(remote: str = "origin", branch: str = "main") -> str:
             lines.append(f"  Version: {old_version} (unchanged)")
         lines.append(f"  Branch: {remote}/{branch}")
         lines.append(f"  Backup: {backup_dir}")
+        if "pip-deps" in steps_done:
+            lines.append("  Python deps: reinstalled")
         if version_changed:
             lines.append("  Migrations: applied")
         if "cron-sync" in steps_done:
             lines.append("  Crons: synced with manifest")
+        if "hook-sync" in steps_done:
+            lines.append("  Hooks: synced to NEXO_HOME")
         lines.append("")
         lines.append("MCP server restart needed to load new code.")
         return "\n".join(lines)
 
     except Exception as e:
-        # Rollback
+        # Rollback — use git checkout to saved commit (safer than reset --hard)
         rollback_lines = [f"UPDATE FAILED: {e}", "", "Rolling back..."]
 
         if old_commit and "git-pull" in steps_done:
+            # Full rollback: reset HEAD + index + worktree to old commit
             rc, _, err = _git("reset", "--hard", old_commit)
             if rc == 0:
-                rollback_lines.append(f"  Git: reset to {old_commit[:8]}")
+                rollback_lines.append(f"  Git: restored files to {old_commit[:8]}")
+                # Reinstall pip deps from the restored old requirements.txt
+                # so the venv matches the rolled-back code
+                if "pip-deps" in steps_done:
+                    pip_rb_err = _reinstall_pip_deps()
+                    if pip_rb_err:
+                        rollback_lines.append(f"  WARNING: pip deps rollback failed: {pip_rb_err}")
+                    else:
+                        rollback_lines.append("  Python deps: reinstalled from old requirements.txt")
             else:
                 rollback_lines.append(f"  Git rollback FAILED: {err}")
 

package/src/scripts/deep-sleep/apply_findings.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+from __future__ import annotations
 """
 Deep Sleep v2 -- Phase 4: Apply synthesized findings.
 

package/src/scripts/deep-sleep/collect.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+from __future__ import annotations
 """
 Deep Sleep v2 -- Phase 1: Collect all context for overnight analysis.
 

package/src/scripts/deep-sleep/extract.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+from __future__ import annotations
 """
 Deep Sleep v2 -- Phase 2: Extract findings from each session using Claude CLI.
 

package/src/scripts/deep-sleep/synthesize.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+from __future__ import annotations
 """
 Deep Sleep v2 -- Phase 3: Synthesize extractions into actionable findings.
 

package/src/scripts/nexo-catchup.py

@@ -18,10 +18,32 @@ import sys
 from datetime import datetime, timedelta
 from pathlib import Path
 
-CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
-
 HOME = Path.home()
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(HOME / ".nexo")))
+
+
+def _resolve_claude_cli() -> Path:
+    """Find claude CLI: saved path > PATH > common locations."""
+    saved = NEXO_HOME / "config" / "claude-cli-path"
+    if saved.exists():
+        p = Path(saved.read_text().strip())
+        if p.exists():
+            return p
+    import shutil
+    found = shutil.which("claude")
+    if found:
+        return Path(found)
+    for candidate in [
+        HOME / ".local" / "bin" / "claude",
+        HOME / ".npm-global" / "bin" / "claude",
+        Path("/usr/local/bin/claude"),
+    ]:
+        if candidate.exists():
+            return candidate
+    return HOME / ".local" / "bin" / "claude"  # last resort
+
+
+CLAUDE_CLI = _resolve_claude_cli()
 LOG_DIR = NEXO_HOME / "logs"
 LOG_DIR.mkdir(parents=True, exist_ok=True)
 LOG_FILE = LOG_DIR / "catchup.log"
@@ -47,7 +69,10 @@ def _resolve_python() -> str:
 
 NEXO_PYTHON = _resolve_python()
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent.parent)))
-MANIFEST = NEXO_CODE / "crons" / "manifest.json"
+# Look for manifest in NEXO_HOME first (packaged install), then NEXO_CODE (dev/repo)
+_manifest_home = NEXO_HOME / "crons" / "manifest.json"
+_manifest_code = NEXO_CODE / "crons" / "manifest.json"
+MANIFEST = _manifest_home if _manifest_home.exists() else _manifest_code
 
 
 def _load_tasks_from_manifest() -> list[tuple]: