arkaos 4.3.6 → 4.4.0

package/scripts/dashboard-api.py

@@ -20,6 +20,8 @@ from typing import Optional
 ARKAOS_ROOT = Path(os.environ.get("ARKAOS_ROOT", Path(__file__).resolve().parent.parent))
 sys.path.insert(0, str(ARKAOS_ROOT))
 
+from core.shared.temp_paths import arkaos_temp_dir
+
 from fastapi import FastAPI, Query, Request, WebSocket, WebSocketDisconnect
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, JSONResponse
@@ -158,10 +160,10 @@ def overview():
 
     skills_count = 0
     try:
-        skills_count = int(subprocess.run(
-            ["find", str(ARKAOS_ROOT / "departments"), "-name", "SKILL.md", "-path", "*/skills/*/SKILL.md"],
-            capture_output=True, text=True, timeout=5,
-        ).stdout.strip().count("\n")) + 1
+        skills_count = sum(
+            1 for p in (ARKAOS_ROOT / "departments").rglob("SKILL.md")
+            if "skills" in p.parts
+        )
     except Exception:
         skills_count = 250
 
@@ -1733,7 +1735,7 @@ def health():
           "npx arkaos install")
 
     try:
-        subprocess.run(["python3", "--version"], capture_output=True, timeout=2)
+        subprocess.run([sys.executable, "--version"], capture_output=True, timeout=2)
         check("python", True)
     except Exception:
         check("python", False, "Install Python 3.11+")
@@ -2794,6 +2796,18 @@ def _current_version() -> str:
         return "0.0.0"
 
 
+def _win_shim(cmd: list) -> list:
+    """Wrap npm/npx-style commands so Windows can execute them.
+
+    npm and npx are ``.cmd`` shims; ``subprocess`` (CreateProcess) cannot
+    run them directly ("%1 is not a valid Win32 application"), so route
+    through ``cmd /c`` on Windows. No-op on POSIX.
+    """
+    if os.name == "nt":
+        return ["cmd", "/c", *cmd]
+    return cmd
+
+
 def _npm_latest_version():
     import subprocess
     import time
@@ -2802,7 +2816,7 @@ def _npm_latest_version():
         return _npm_latest_cache["version"]
     try:
         out = subprocess.run(
-            ["npm", "view", "arkaos", "version"],
+            _win_shim(["npm", "view", "arkaos", "version"]),
             capture_output=True, text=True, timeout=20,
         )
         latest = (out.stdout or "").strip() or None
@@ -2829,7 +2843,7 @@ def _run_core_update() -> dict:
     import subprocess
     try:
         out = subprocess.run(
-            ["npx", "arkaos@latest", "update"],
+            _win_shim(["npx", "arkaos@latest", "update"]),
             capture_output=True, text=True, timeout=600,
         )
         tail = ((out.stdout or "") + (out.stderr or ""))[-2000:]
@@ -2994,30 +3008,49 @@ async def ws_terminal(ws: WebSocket, session_id: str, token: str = Query("")):
     # left it. Sent before the live reader is attached, so the historical
     # prefix always precedes any new output (no interleave, no dup — these
     # bytes were already consumed from the kernel buffer when first read).
-    replay = session.scrollback()
-    if replay:
-        try:
-            await ws.send_bytes(replay)
-        except Exception:
-            await ws.close(code=1011, reason="replay failed")
-            return
-
     loop = asyncio.get_event_loop()
     output_queue: asyncio.Queue = asyncio.Queue()
 
-    def _on_readable():
+    # POSIX exposes a pollable master fd (add_reader); the Windows ConPTY
+    # backend has none (master_fd == -1) and instead pushes output from its
+    # own reader thread into a registered listener.
+    use_fd_reader = getattr(session, "master_fd", -1) >= 0
+
+    if use_fd_reader:
+        replay = session.scrollback()
+        if replay:
+            try:
+                await ws.send_bytes(replay)
+            except Exception:
+                await ws.close(code=1011, reason="replay failed")
+                return
+
+        def _on_readable():
+            try:
+                data = session.read(8192)
+            except OSError:
+                data = b""
+            if data:
+                output_queue.put_nowait(data)
+
         try:
-            data = session.read(8192)
-        except OSError:
-            data = b""
-        if data:
-            output_queue.put_nowait(data)
+            loop.add_reader(session.master_fd, _on_readable)
+        except (ValueError, OSError):
+            await ws.close(code=1011, reason="pty unavailable")
+            return
+    else:
+        def _emit(data: bytes):
+            loop.call_soon_threadsafe(output_queue.put_nowait, data)
 
-    try:
-        loop.add_reader(session.master_fd, _on_readable)
-    except (ValueError, OSError):
-        await ws.close(code=1011, reason="pty unavailable")
-        return
+        # Atomic: snapshot scrollback and start the live feed with no gap.
+        replay = session.attach(_emit)
+        if replay:
+            try:
+                await ws.send_bytes(replay)
+            except Exception:
+                session.set_listener(None)
+                await ws.close(code=1011, reason="replay failed")
+                return
 
     async def pump_to_client():
         while True:
@@ -3060,13 +3093,16 @@ async def ws_terminal(ws: WebSocket, session_id: str, token: str = Query("")):
         pass
     finally:
         pump_task.cancel()
-        # Only the still-active connection owns the fd reader — a superseded
-        # connection tearing down must not remove its replacement's reader.
+        # Only the still-active connection owns the reader — a superseded
+        # connection tearing down must not detach its replacement's reader.
         if _terminal_conns.release(session_id, ws):
-            try:
-                loop.remove_reader(session.master_fd)
-            except (ValueError, OSError):
-                pass
+            if use_fd_reader:
+                try:
+                    loop.remove_reader(session.master_fd)
+                except (ValueError, OSError):
+                    pass
+            else:
+                session.set_listener(None)
 
 
 @app.on_event("startup")
@@ -4233,7 +4269,7 @@ def keys_delete(key_name: str):
 
 @app.get("/api/metrics")
 def metrics():
-    metrics_file = Path("/tmp/arkaos-context-cache/hook-metrics.jsonl")
+    metrics_file = arkaos_temp_dir("arkaos-context-cache", "hook-metrics.jsonl")
     if not metrics_file.exists():
         return {"entries": [], "avg_ms": 0}
     entries = []

package/scripts/knowledge-index.py

@@ -14,6 +14,12 @@ import os
 import sys
 from pathlib import Path
 
+# Windows consoles default to cp1252; progress lines with non-ASCII vault
+# names would raise UnicodeEncodeError and kill the index run silently.
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8")
+    sys.stderr.reconfigure(encoding="utf-8")
+
 ARKAOS_ROOT = Path(os.environ.get("ARKAOS_ROOT", Path(__file__).resolve().parent.parent))
 sys.path.insert(0, str(ARKAOS_ROOT))
 
@@ -77,13 +83,40 @@ def main() -> int:
     # Index mode
     directory = args.vault or args.dir
     if not directory:
-        # Auto-detect vault from config
+        # Auto-detect vault from config. vault_path may be a template like
+        # "${VAULT_PATH}" — resolve it through the canonical path resolver
+        # (ARKAOS_VAULT_PATH env / profile.json vaultPath) before testing.
         config_path = ARKAOS_ROOT / "knowledge" / "obsidian-config.json"
         if config_path.exists():
-            config = json.loads(config_path.read_text())
+            config = json.loads(config_path.read_text(encoding="utf-8"))
             vault = config.get("vault_path", "")
+            if vault and "${" in vault:
+                try:
+                    from core.runtime.path_resolver import resolve
+
+                    vault = resolve(vault)
+                except Exception:
+                    vault = ""
+            if vault and Path(vault).exists():
+                directory = vault
+                if not args.json_output:
+                    print(f"Vault from config: {directory}", file=sys.stderr)
+
+    if not directory:
+        # profile.json vaultPath — set by `npx arkaos install` and the
+        # authoritative answer to "where is the user's vault".
+        profile_path = Path.home() / ".arkaos" / "profile.json"
+        if profile_path.exists():
+            try:
+                vault = json.loads(
+                    profile_path.read_text(encoding="utf-8")
+                ).get("vaultPath", "")
+            except (json.JSONDecodeError, OSError):
+                vault = ""
             if vault and Path(vault).exists():
                 directory = vault
+                if not args.json_output:
+                    print(f"Vault from profile: {directory}", file=sys.stderr)
 
     if not directory:
         # Try common vault locations

package/scripts/start-dashboard.ps1

@@ -30,6 +30,7 @@ $arkaosHome   = Join-Path $env:USERPROFILE '.arkaos'
 $pidFile      = Join-Path $arkaosHome 'dashboard.pid'
 $portFile     = Join-Path $arkaosHome 'dashboard.ports'
 $apiLog       = Join-Path $arkaosHome 'api.log'
+$apiErrLog    = Join-Path $arkaosHome 'api.err.log'
 
 $null = New-Item -ItemType Directory -Force -Path $arkaosHome -ErrorAction SilentlyContinue
 
@@ -132,7 +133,7 @@ try {
         -ArgumentList @($dashboardApi, '--port', "$apiPort") `
         -WorkingDirectory $arkaosRoot `
         -RedirectStandardOutput $apiLog `
-        -RedirectStandardError  $apiLog `
+        -RedirectStandardError  $apiErrLog `
         -NoNewWindow `
         -PassThru
 } finally {
@@ -160,10 +161,10 @@ for ($i = 0; $i -lt 20; $i++) {
 if ($apiReady) {
     Write-Host "  API: http://localhost:$apiPort" -ForegroundColor Green
 } else {
-    Write-Host "  ! API may still be starting (check log: $apiLog)" -ForegroundColor Yellow
-    if (Test-Path -LiteralPath $apiLog) {
+    Write-Host "  ! API may still be starting (check log: $apiErrLog)" -ForegroundColor Yellow
+    if (Test-Path -LiteralPath $apiErrLog) {
         try {
-            $lastError = (Get-Content -LiteralPath $apiLog -Tail 3 -ErrorAction SilentlyContinue | Select-Object -First 1)
+            $lastError = (Get-Content -LiteralPath $apiErrLog -Tail 3 -ErrorAction SilentlyContinue | Select-Object -First 1)
             if ($lastError) {
                 Write-Host "  Last error: $lastError" -ForegroundColor DarkGray
             }
@@ -180,11 +181,23 @@ $nuxtServer = Join-Path $nuxtOutput 'server\index.mjs'
 
 function Start-NuxtDev {
     param([int]$Port, [int]$ApiPort, [string]$WorkingDir)
-    # `npx nuxt dev --port <n>` works from cmd.exe; PowerShell resolves npx
-    # via the npx.cmd shim installed with Node.js.
+    # Launch node directly against the Nuxt CLI entry. The 'npx' shim is a
+    # .cmd on Windows, which Start-Process -NoNewWindow cannot exec ("%1 is
+    # not a valid Win32 application"), and wrapping it in cmd.exe yields a
+    # process tree that dies with the launcher. A direct node.exe child
+    # detaches cleanly and survives, like the API process.
     $savedApi = $env:NUXT_PUBLIC_API_BASE
     $env:NUXT_PUBLIC_API_BASE = "http://localhost:$ApiPort"
     try {
+        $nuxtBin = Join-Path $WorkingDir 'node_modules\nuxt\bin\nuxt.mjs'
+        if (Test-Path -LiteralPath $nuxtBin) {
+            return Start-Process -FilePath 'node' `
+                -ArgumentList @($nuxtBin,'dev','--port',"$Port") `
+                -WorkingDirectory $WorkingDir `
+                -NoNewWindow `
+                -PassThru
+        }
+        # Fallback (non-Windows or missing local bin): the npx shim is fine.
         return Start-Process -FilePath 'npx' `
             -ArgumentList @('nuxt','dev','--port',"$Port") `
             -WorkingDirectory $WorkingDir `
@@ -215,18 +228,25 @@ if (Test-Path -LiteralPath $nuxtServer) {
     Write-Host "  Starting UI (dev) on :$uiPort..."
     $uiProc = Start-NuxtDev -Port $uiPort -ApiPort $apiPort -WorkingDir $dashboardDir
 } else {
-    # Auto-install and start
-    Write-Host '  Installing dashboard dependencies...'
-    $installer = if (Get-Command pnpm -ErrorAction SilentlyContinue) { 'pnpm' } else { 'npm' }
+    # Auto-install and start. The dashboard pins pnpm (package.json
+    # packageManager) — npm's flat node_modules layout breaks Nuxt 4's
+    # server-entry resolution ("No entry found in rollupOptions.input"), so
+    # install with the pinned pnpm via corepack (always shipped with Node).
+    # corepack/pnpm are .cmd shims that Start-Process -NoNewWindow cannot
+    # exec directly on Windows, so route through cmd.exe.
+    Write-Host '  Installing dashboard dependencies (pnpm via corepack)...'
+    $savedPrompt = $env:COREPACK_ENABLE_DOWNLOAD_PROMPT
+    $env:COREPACK_ENABLE_DOWNLOAD_PROMPT = '0'
     try {
-        Start-Process -FilePath $installer `
-            -ArgumentList @('install','--silent') `
+        Start-Process -FilePath $env:ComSpec `
+            -ArgumentList @('/c','corepack','pnpm','install') `
             -WorkingDirectory $dashboardDir `
             -NoNewWindow `
-            -Wait `
-            -PassThru | Out-Null
+            -Wait | Out-Null
     } catch {
-        Write-Host "  ! Dashboard install failed ($installer). API-only mode." -ForegroundColor Yellow
+        Write-Host "  ! Dashboard install failed. API-only mode." -ForegroundColor Yellow
+    } finally {
+        $env:COREPACK_ENABLE_DOWNLOAD_PROMPT = $savedPrompt
     }
     if (Test-Path -LiteralPath $nuxtNodeModules) {
         Write-Host "  Starting UI (dev) on :$uiPort..."

package/scripts/synapse-bridge.py

@@ -24,12 +24,14 @@ from typing import Any
 ARKAOS_ROOT = Path(os.environ.get("ARKAOS_ROOT", Path(__file__).resolve().parent.parent))
 sys.path.insert(0, str(ARKAOS_ROOT))
 
+from core.shared.temp_paths import arkaos_temp_dir  # noqa: E402
+
 # Layer tags carrying the actually-injected KB counts (ground truth for
 # reconciling the model's self-reported `[arka:meta] kb=N`). The optional
 # ` degraded=keyword` suffix (RAG honesty, PR-3 v4.1) must still count.
 _KB_CONTEXT_TAG_RE = re.compile(r"\[kb-context:(\d+)[^\]]*\]")
 _KNOWLEDGE_TAG_RE = re.compile(r"\[knowledge:(\d+) chunks?[^\]]*\]")
-_KB_INJECTED_DIR = Path("/tmp/arkaos-kb-injected")
+_KB_INJECTED_DIR = arkaos_temp_dir("arkaos-kb-injected")
 
 
 def _count_injected_kb(result: Any) -> tuple[int, int]: