arkaos 2.10.0 → 2.11.0

package/core/cognition/scheduler/daemon.py

@@ -8,6 +8,7 @@ import os
 import shutil
 import subprocess
 import sys
+import time as time_mod
 from dataclasses import dataclass, field
 from datetime import datetime, time
 from pathlib import Path
@@ -113,9 +114,34 @@ class ArkaScheduler:
             and current_time.minute == schedule.run_time.minute
         )
 
+    @staticmethod
+    def _resolve_claude_binary() -> str:
+        """Resolve the Claude CLI binary by checking known install locations.
+
+        In daemon context (launchd/systemd/schtasks), PATH is minimal and shell
+        aliases don't exist, so we check absolute paths first.
+        """
+        home = Path.home()
+        candidates = [
+            home / ".local" / "bin" / "claude",
+            home / ".arkaos" / "bin" / "arka-claude",
+        ]
+        for candidate in candidates:
+            if candidate.is_file() and os.access(candidate, os.X_OK):
+                return str(candidate)
+        # Fallback to PATH lookup (works in interactive shells)
+        found = shutil.which("claude") or shutil.which("arka-claude")
+        if found:
+            return found
+        raise FileNotFoundError(
+            "Claude CLI not found. Checked: "
+            + ", ".join(str(c) for c in candidates)
+            + " and PATH lookup."
+        )
+
     def _build_command(self, schedule: ScheduleConfig) -> list[str]:
         """Build the Claude CLI invocation for a schedule."""
-        claude_bin = shutil.which("claude") or "claude"
+        claude_bin = self._resolve_claude_binary()
         prompt_path = os.path.expanduser(schedule.prompt_file)
         prompt_content = Path(prompt_path).read_text(encoding="utf-8")
         return [claude_bin, "-p", prompt_content, "--dangerously-skip-permissions"]
@@ -131,33 +157,63 @@ class ArkaScheduler:
         log_dir.mkdir(parents=True, exist_ok=True)
         return log_dir / f"{today}.log"
 
+    @staticmethod
+    def _daemon_env() -> dict[str, str]:
+        """Build an environment with PATH that includes known Claude locations.
+
+        Daemons (launchd/systemd) inherit a minimal PATH. We extend it so that
+        any child processes spawned by Claude can also find common tools.
+        """
+        home = str(Path.home())
+        extra_paths = [
+            os.path.join(home, ".local", "bin"),
+            os.path.join(home, ".arkaos", "bin"),
+            "/usr/local/bin",
+        ]
+        env = os.environ.copy()
+        existing = env.get("PATH", "/usr/bin:/bin")
+        env["PATH"] = ":".join(extra_paths) + ":" + existing
+        return env
+
+    def _run_attempt(
+        self, cmd: list[str], log_file: Path, attempt: int, timeout: int,
+    ) -> bool:
+        """Run a single attempt of a scheduled command. Returns True on success."""
+        env = self._daemon_env()
+        with open(log_file, "a", encoding="utf-8") as lf:
+            lf.write(f"\n--- attempt {attempt} at {datetime.now().isoformat()} ---\n")
+            lf.write(f"cmd: {cmd[0]}\n")
+            try:
+                result = subprocess.run(
+                    cmd, stdout=lf, stderr=lf, timeout=timeout, env=env,
+                )
+                if result.returncode == 0:
+                    return True
+                lf.write(f"exit code: {result.returncode}\n")
+            except subprocess.TimeoutExpired:
+                lf.write("TIMEOUT\n")
+            except Exception as exc:  # noqa: BLE001
+                lf.write(f"ERROR: {exc}\n")
+        return False
+
     def execute(self, schedule: ScheduleConfig) -> bool:
-        """Run the scheduled command, writing output to a dated log file."""
+        """Run the scheduled command with retries and backoff."""
         log_file = self._log_path(schedule.command)
-        timeout_seconds = schedule.timeout_minutes * 60
-        attempts = 0
+        timeout = schedule.timeout_minutes * 60
         max_attempts = schedule.max_retries + 1 if schedule.retry_on_fail else 1
 
-        while attempts < max_attempts:
-            attempts += 1
+        try:
             cmd = self._build_command(schedule)
+        except FileNotFoundError as exc:
             with open(log_file, "a", encoding="utf-8") as lf:
-                lf.write(f"\n--- attempt {attempts} at {datetime.now().isoformat()} ---\n")
-                try:
-                    result = subprocess.run(
-                        cmd,
-                        stdout=lf,
-                        stderr=lf,
-                        timeout=timeout_seconds,
-                    )
-                    if result.returncode == 0:
-                        return True
-                    lf.write(f"exit code: {result.returncode}\n")
-                except subprocess.TimeoutExpired:
-                    lf.write("TIMEOUT\n")
-                except Exception as exc:  # noqa: BLE001
-                    lf.write(f"ERROR: {exc}\n")
+                lf.write(f"\n--- at {datetime.now().isoformat()} ---\nFATAL: {exc}\n")
+            return False
 
+        for attempt in range(1, max_attempts + 1):
+            if self._run_attempt(cmd, log_file, attempt, timeout):
+                return True
+            if attempt < max_attempts:
+                time_mod.sleep(30 * attempt)
         return False
 
     # ------------------------------------------------------------------

package/core/cognition/scheduler/platform.py

@@ -15,9 +15,30 @@ def _default_daemon_script() -> str:
 
 
 def _python_executable() -> str:
+    """Resolve Python, preferring the ArkaOS venv over random system pythons.
+
+    shutil.which("python3") in a daemon context may pick up a venv from an
+    unrelated project (e.g., ai-jarvis). We check the ArkaOS venv first.
+    """
+    home = Path.home()
+    # Check both common venv directory names
+    for venv_dir in ("venv", ".venv"):
+        arkaos_venv = home / ".arkaos" / venv_dir / "bin" / "python3"
+        if arkaos_venv.is_file():
+            return str(arkaos_venv)
+        # Windows venv layout
+        arkaos_venv_win = home / ".arkaos" / venv_dir / "Scripts" / "python.exe"
+        if arkaos_venv_win.is_file():
+            return str(arkaos_venv_win)
     return shutil.which("python3") or sys.executable
 
 
+def _daemon_path_value() -> str:
+    """Return a PATH string with known Claude CLI locations for daemon contexts."""
+    home = str(Path.home())
+    return f"{home}/.local/bin:{home}/.arkaos/bin:/usr/local/bin:/usr/bin:/bin"
+
+
 class PlatformAdapter(ABC):
     """Abstract base for OS-level service management."""
 
@@ -55,27 +76,35 @@ class MacOSAdapter(PlatformAdapter):
     def _plist_path(self) -> str:
         return str(Path(self._plist_dir) / f"{self._LABEL}.plist")
 
+    def _plist_env_block(self) -> str:
+        """Generate the EnvironmentVariables section of the plist."""
+        home = str(Path.home())
+        return (
+            "\t<key>EnvironmentVariables</key>\n\t<dict>\n"
+            f"\t\t<key>PATH</key>\n\t\t<string>{_daemon_path_value()}</string>\n"
+            f"\t\t<key>HOME</key>\n\t\t<string>{home}</string>\n"
+            "\t</dict>\n"
+        )
+
     def _generate_plist(self) -> str:
+        """Generate the launchd plist XML for the scheduler daemon."""
         python = _python_executable()
         log_dir = Path.home() / ".arkaos" / "logs"
-        stdout = str(log_dir / "scheduler-stdout.log")
-        stderr = str(log_dir / "scheduler-stderr.log")
         return (
             '<?xml version="1.0" encoding="UTF-8"?>\n'
             '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"'
             ' "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n'
-            '<plist version="1.0">\n'
-            "<dict>\n"
+            '<plist version="1.0">\n<dict>\n'
             f"\t<key>Label</key>\n\t<string>{self._LABEL}</string>\n"
-            f"\t<key>ProgramArguments</key>\n"
-            f"\t<array>\n\t\t<string>{python}</string>"
-            f"\n\t\t<string>{self._daemon_script}</string>\n\t</array>\n"
-            "\t<key>RunAtLoad</key>\n\t<true/>\n"
+            f"\t<key>ProgramArguments</key>\n\t<array>\n"
+            f"\t\t<string>{python}</string>\n"
+            f"\t\t<string>{self._daemon_script}</string>\n\t</array>\n"
+            + self._plist_env_block()
+            + "\t<key>RunAtLoad</key>\n\t<true/>\n"
             "\t<key>KeepAlive</key>\n\t<true/>\n"
-            f"\t<key>StandardOutPath</key>\n\t<string>{stdout}</string>\n"
-            f"\t<key>StandardErrorPath</key>\n\t<string>{stderr}</string>\n"
-            "</dict>\n"
-            "</plist>\n"
+            f"\t<key>StandardOutPath</key>\n\t<string>{log_dir / 'scheduler-stdout.log'}</string>\n"
+            f"\t<key>StandardErrorPath</key>\n\t<string>{log_dir / 'scheduler-stderr.log'}</string>\n"
+            "</dict>\n</plist>\n"
         )
 
     def install_service(self) -> bool:
@@ -143,6 +172,7 @@ class LinuxAdapter(PlatformAdapter):
         return str(Path(self._service_dir) / self._SERVICE_NAME)
 
     def _generate_unit(self) -> str:
+        """Generate the systemd unit file for the scheduler daemon."""
         python = _python_executable()
         return (
             "[Unit]\n"
@@ -150,6 +180,7 @@ class LinuxAdapter(PlatformAdapter):
             "After=network.target\n\n"
             "[Service]\n"
             "Type=simple\n"
+            f"Environment=PATH={_daemon_path_value()}\n"
             f"ExecStart={python} {self._daemon_script}\n"
             "Restart=on-failure\n"
             "RestartSec=60\n\n"

package/core/knowledge/vector_store.py

@@ -1,7 +1,7 @@
-"""Vector store — SQLite-VSS backed semantic search.
+"""Vector store — SQLite-vec backed semantic search.
 
 Stores document chunks with embeddings for fast similarity search.
-Graceful degradation: works without sqlite-vss (brute-force fallback).
+Graceful degradation: works without sqlite-vec (brute-force fallback).
 """
 
 import json
@@ -13,25 +13,25 @@ from typing import Any, Optional
 from core.knowledge.embedder import embed, embed_batch, EMBEDDING_DIMS
 
 
-def _load_vss(db: sqlite3.Connection) -> bool:
-    """Try to load sqlite-vss extension."""
+def _load_vec(db: sqlite3.Connection) -> bool:
+    """Try to load sqlite-vec extension."""
     try:
         db.enable_load_extension(True)
-        import sqlite_vss
-        sqlite_vss.load(db)
+        import sqlite_vec
+        sqlite_vec.load(db)
         return True
     except (ImportError, Exception):
         return False
 
 
 class VectorStore:
-    """SQLite-VSS backed vector store for knowledge retrieval."""
+    """SQLite-vec backed vector store for knowledge retrieval."""
 
     def __init__(self, db_path: str | Path = ":memory:") -> None:
         self._db_path = str(db_path)
         self._db = sqlite3.connect(self._db_path)
         self._db.row_factory = sqlite3.Row
-        self._vss_available = _load_vss(self._db)
+        self._vec_available = _load_vec(self._db)
         self._init_schema()
 
     def _init_schema(self) -> None:
@@ -50,15 +50,39 @@ class VectorStore:
             CREATE INDEX IF NOT EXISTS idx_chunks_source ON chunks(source);
             CREATE INDEX IF NOT EXISTS idx_chunks_hash ON chunks(file_hash);
         """)
-        if self._vss_available:
+        self._migrate_vss_to_vec()
+        if self._vec_available:
             try:
                 self._db.execute(
-                    f"CREATE VIRTUAL TABLE IF NOT EXISTS vss_chunks USING vss0(embedding({EMBEDDING_DIMS}))"
+                    f"CREATE VIRTUAL TABLE IF NOT EXISTS vec_chunks USING vec0(embedding float[{EMBEDDING_DIMS}])"
                 )
             except Exception:
-                self._vss_available = False
+                self._vec_available = False
         self._db.commit()
 
+    def _migrate_vss_to_vec(self) -> None:
+        """Drop legacy sqlite-vss tables if present.
+
+        The vss_chunks virtual table used a different schema and query
+        syntax that is incompatible with sqlite-vec. Dropping it forces a
+        clean re-index on the next /arka index invocation. The chunks
+        table (with raw embeddings) is preserved — only the virtual table
+        index is removed.
+        """
+        try:
+            tables = [
+                r[0]
+                for r in self._db.execute(
+                    "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'vss_%'"
+                ).fetchall()
+            ]
+            if tables:
+                for t in tables:
+                    self._db.execute(f"DROP TABLE IF EXISTS {t}")
+                self._db.commit()
+        except Exception:
+            pass
+
     def index_chunks(
         self,
         texts: list[str],
@@ -90,9 +114,9 @@ class VectorStore:
                 (text, heading, source, file_hash, meta_json, emb_blob),
             )
 
-            if self._vss_available and emb_blob:
+            if self._vec_available and emb_blob:
                 self._db.execute(
-                    "INSERT INTO vss_chunks (rowid, embedding) VALUES (?, ?)",
+                    "INSERT INTO vec_chunks (rowid, embedding) VALUES (?, ?)",
                     (cursor.lastrowid, emb_blob),
                 )
             count += 1
@@ -112,23 +136,24 @@ class VectorStore:
 
         query_emb = embed(query)
 
-        if query_emb and self._vss_available:
+        if query_emb and self._vec_available:
             try:
-                return self._vss_search(query_emb, top_k)
+                return self._vec_search(query_emb, top_k)
             except Exception:
                 return self._keyword_search(query, top_k)
 
         # Fallback: keyword search
         return self._keyword_search(query, top_k)
 
-    def _vss_search(self, query_emb: list[float], top_k: int) -> list[dict]:
-        """Vector similarity search via sqlite-vss."""
+    def _vec_search(self, query_emb: list[float], top_k: int) -> list[dict]:
+        """Vector similarity search via sqlite-vec."""
         query_blob = _vec_to_blob(query_emb)
         rows = self._db.execute("""
             SELECT c.text, c.heading, c.source, c.metadata, v.distance
-            FROM vss_chunks v
+            FROM vec_chunks v
             JOIN chunks c ON c.id = v.rowid
-            WHERE vss_search(v.embedding, vss_search_params(?, ?))
+            WHERE v.embedding MATCH ? AND k = ?
+            ORDER BY v.distance
         """, (query_blob, top_k)).fetchall()
 
         return [
@@ -136,7 +161,7 @@ class VectorStore:
                 "text": r["text"],
                 "heading": r["heading"],
                 "source": r["source"],
-                "score": 1.0 - r["distance"],  # Convert distance to similarity
+                "score": 1.0 / (1.0 + r["distance"]),  # Convert distance to similarity
                 "metadata": json.loads(r["metadata"]),
             }
             for r in rows
@@ -176,10 +201,10 @@ class VectorStore:
 
     def remove_file(self, source: str) -> int:
         """Remove all chunks from a source file."""
-        if self._vss_available:
+        if self._vec_available:
             rows = self._db.execute("SELECT id FROM chunks WHERE source = ?", (source,)).fetchall()
             for r in rows:
-                self._db.execute("DELETE FROM vss_chunks WHERE rowid = ?", (r["id"],))
+                self._db.execute("DELETE FROM vec_chunks WHERE rowid = ?", (r["id"],))
         deleted = self._db.execute("DELETE FROM chunks WHERE source = ?", (source,)).rowcount
         self._db.commit()
         return deleted
@@ -191,14 +216,14 @@ class VectorStore:
         return {
             "total_chunks": total,
             "total_files": sources,
-            "vss_available": self._vss_available,
+            "vec_available": self._vec_available,
             "db_path": self._db_path,
         }
 
     def clear(self) -> None:
         """Remove all data."""
-        if self._vss_available:
-            self._db.execute("DELETE FROM vss_chunks")
+        if self._vec_available:
+            self._db.execute("DELETE FROM vec_chunks")
         self._db.execute("DELETE FROM chunks")
         self._db.commit()
 

package/core/synapse/layers.py

@@ -133,7 +133,7 @@ DEPARTMENT_PATTERNS: dict[str, str] = {
     "marketing": r"\b(social|content|campaign|post|instagram|linkedin|twitter|tiktok|seo|marketing|ads|email.?campaign|growth|viral)\b",
     "finance": r"\b(budget|invoice|revenue|forecast|profit|loss|roi|margin|cash.?flow|financial|invest|valuation|pricing)\b",
     "ecom": r"\b(store|product|shop|shopify|ecommerce|catalog|inventory|cart|checkout|pricing|marketplace)\b",
-    "strategy": r"\b(strategy|brainstorm|market|swot|competitor|roadmap|pivot|growth|porter|blue.?ocean|positioning)\b",
+    "strategy": r"\b(strategy|brainstorm|market|swot|competitors?|roadmap|pivot|growth|porter|blue.?ocean|positioning)\b",
     "ops": r"\b(task|automate|meeting|workflow|process|schedule|sop|integration|zapier|n8n)\b",
     "kb": r"\b(learn|persona|knowledge|youtube|transcribe|article|research|zettelkasten|note)\b",
     "brand": r"\b(brand|logo|colors|palette|mockup|photoshoot|brand.?identity|brand.?guide|mood.?board|naming|visual.?design|motion|ux|ui|wireframe)\b",
@@ -143,7 +143,7 @@ DEPARTMENT_PATTERNS: dict[str, str] = {
     "content": r"\b(viral|hook|script|repurpose|youtube|tiktok|reels|shorts|newsletter|creator)\b",
     "pm": r"\b(sprint|backlog|standup|retro|scrum|kanban|story|estimate|roadmap|agile)\b",
     "lead": r"\b(leadership|delegation|1on1|feedback|culture|hiring|performance.?review|team.?build)\b",
-    "sales": r"\b(pipeline|proposal|discovery.?call|objection|negotiate|deal|close|prospect|spin|challenger)\b",
+    "sales": r"\b(pipeline|proposal|discovery.?call|objection|negotiate|deal|close|prospect|spin|challenger|cold.?email|outreach)\b",
     "org": r"\b(org.?design|hiring.?plan|onboarding|remote|meeting.?optimize|compensation|decision.?framework)\b",
 }
 

package/installer/adapters/claude-code.js

@@ -1,5 +1,55 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
+import { platform } from "node:os";
+
+const IS_WINDOWS = platform() === "win32";
+
+/**
+ * Build a complete inner hook-entry object for Claude Code's settings.json.
+ *
+ * On Unix we point `command` directly at the `.sh` script and rely on the
+ * shebang for interpreter selection; no `shell` field is needed because
+ * Claude Code's default is `bash`.
+ *
+ * On Windows we point `command` at the `.ps1` script and set the
+ * documented `shell: "powershell"` hook field so Claude Code spawns
+ * PowerShell directly and pipes the hook payload to the script's stdin
+ * natively. This is the pattern prescribed by the upstream hooks
+ * reference at https://code.claude.com/docs/en/hooks :
+ *
+ *     shell (no, optional): Shell to use for this hook. Accepts
+ *     "bash" (default) or "powershell". Setting "powershell" runs the
+ *     command via PowerShell on Windows. Does not require
+ *     CLAUDE_CODE_USE_POWERSHELL_TOOL since hooks spawn PowerShell
+ *     directly.
+ *
+ * Earlier versions of this adapter embedded the full
+ * `powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -File ...`
+ * command line in `command` without setting `shell`. Claude Code then
+ * defaulted to `shell: "bash"`, which on Windows routes through a
+ * compatibility layer that drops the stdin pipe before the PowerShell
+ * script reads it. `SessionStart` still appeared to work (it only
+ * writes stdout), but every other hook received a 0-byte stdin, hit
+ * the `IsNullOrWhiteSpace` guard at the top of each `.ps1`, and
+ * silently exited. This commit fixes that by emitting the canonical
+ * `shell: "powershell"` field and letting Claude Code handle the
+ * PowerShell invocation itself.
+ */
+function hookEntry(hooksDir, name, timeout) {
+  if (IS_WINDOWS) {
+    return {
+      type: "command",
+      command: join(hooksDir, `${name}.ps1`),
+      shell: "powershell",
+      timeout,
+    };
+  }
+  return {
+    type: "command",
+    command: join(hooksDir, `${name}.sh`),
+    timeout,
+  };
+}
 
 export default {
   configureHooks(config, installDir) {
@@ -29,70 +79,47 @@ export default {
     }
 
     // SessionStart — Branded greeting + version drift detection
+    // Timeout 15s: PowerShell cold-start on Windows VMs can exceed 5s.
     settings.hooks.SessionStart = [
-      {
-        hooks: [
-          {
-            type: "command",
-            command: join(hooksDir, "session-start.sh"),
-            timeout: 5,
-          },
-        ],
-      },
+      { hooks: [hookEntry(hooksDir, "session-start", 15)] },
     ];
 
     // UserPromptSubmit — Synapse v2 context injection
     settings.hooks.UserPromptSubmit = [
-      {
-        hooks: [
-          {
-            type: "command",
-            command: join(hooksDir, "user-prompt-submit.sh"),
-            timeout: 10,
-          },
-        ],
-      },
+      { hooks: [hookEntry(hooksDir, "user-prompt-submit", 10)] },
     ];
 
     // PostToolUse — Error tracking
     settings.hooks.PostToolUse = [
-      {
-        hooks: [
-          {
-            type: "command",
-            command: join(hooksDir, "post-tool-use.sh"),
-            timeout: 5,
-          },
-        ],
-      },
+      { hooks: [hookEntry(hooksDir, "post-tool-use", 5)] },
     ];
 
     // PreCompact — Session digest
     settings.hooks.PreCompact = [
-      {
-        hooks: [
-          {
-            type: "command",
-            command: join(hooksDir, "pre-compact.sh"),
-            timeout: 30,
-          },
-        ],
-      },
+      { hooks: [hookEntry(hooksDir, "pre-compact", 30)] },
     ];
 
     // CwdChanged — Project/ecosystem auto-detection
     settings.hooks.CwdChanged = [
-      {
-        hooks: [
-          {
-            type: "command",
-            command: join(hooksDir, "cwd-changed.sh"),
-            timeout: 5,
-          },
-        ],
-      },
+      { hooks: [hookEntry(hooksDir, "cwd-changed", 5)] },
     ];
 
+    // Statusline — ArkaOS branded status bar
+    const configDir = join(installDir, "config");
+    const statuslineFile = IS_WINDOWS ? "statusline.ps1" : "statusline.sh";
+    const statuslinePath = join(configDir, statuslineFile);
+    if (existsSync(statuslinePath)) {
+      if (IS_WINDOWS) {
+        settings.statusline = {
+          command: `powershell -NoProfile -ExecutionPolicy Bypass -File "${statuslinePath}"`,
+        };
+      } else {
+        settings.statusline = {
+          command: statuslinePath,
+        };
+      }
+    }
+
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
     console.log("         Claude Code hooks configured.");
   },

package/installer/cli.js

@@ -6,6 +6,8 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { install } from "./index.js";
 import { detectRuntime } from "./detect-runtime.js";
+import { IS_WINDOWS } from "./platform.js";
+import { getArkaosPython } from "./python-resolver.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8")).version;
@@ -108,9 +110,16 @@ async function main() {
 
     case "dashboard": {
       const { execSync: execDash } = await import("node:child_process");
-      const repoRootDash = dirname(fileURLToPath(import.meta.url)).replace(/\/installer$/, "");
+      // join(__dirname, "..") is cross-platform; the previous regex
+      // `/\/installer$/` used forward slashes and did not match the
+      // Windows backslash-separated path, leaving repoRootDash pointing
+      // at the installer directory instead of the repo root.
+      const repoRootDash = join(__dirname, "..");
+      const dashCmd = IS_WINDOWS
+        ? `powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "${join(repoRootDash, "scripts", "start-dashboard.ps1")}"`
+        : `bash "${repoRootDash}/scripts/start-dashboard.sh"`;
       try {
-        execDash(`bash "${repoRootDash}/scripts/start-dashboard.sh"`, {
+        execDash(dashCmd, {
           stdio: "inherit",
           env: { ...process.env, ARKAOS_ROOT: repoRootDash },
         });
@@ -121,9 +130,11 @@ async function main() {
     case "index": {
       const { execSync } = await import("node:child_process");
       const indexArgs = positionals.slice(1).join(" ");
-      const repoRoot = dirname(fileURLToPath(import.meta.url)).replace(/\/installer$/, "");
+      const repoRoot = join(__dirname, "..");
+      const pyIndex = getArkaosPython();
+      if (!pyIndex) { console.error("No Python found. Run: npx arkaos install"); process.exit(1); }
       try {
-        execSync(`python3 "${repoRoot}/scripts/knowledge-index.py" ${indexArgs || ""}`, {
+        execSync(`"${pyIndex}" "${join(repoRoot, "scripts", "knowledge-index.py")}" ${indexArgs || ""}`, {
           stdio: "inherit",
           env: { ...process.env, ARKAOS_ROOT: repoRoot },
         });
@@ -135,9 +146,11 @@ async function main() {
       const { execSync } = await import("node:child_process");
       const query = positionals.slice(1).join(" ");
       if (!query) { console.error("Usage: npx arkaos search \"your query\""); process.exit(1); }
-      const repoRoot2 = dirname(fileURLToPath(import.meta.url)).replace(/\/installer$/, "");
+      const repoRoot2 = join(__dirname, "..");
+      const pySearch = getArkaosPython();
+      if (!pySearch) { console.error("No Python found. Run: npx arkaos install"); process.exit(1); }
       try {
-        execSync(`python3 "${repoRoot2}/scripts/knowledge-index.py" --search "${query}"`, {
+        execSync(`"${pySearch}" "${join(repoRoot2, "scripts", "knowledge-index.py")}" --search "${query}"`, {
           stdio: "inherit",
           env: { ...process.env, ARKAOS_ROOT: repoRoot2 },
         });