arkaos 2.2.1 → 2.3.0

package/VERSION

@@ -1 +1 @@
-2.2.1
+2.3.0

package/arka/SKILL.md

@@ -1,16 +1,16 @@
 ---
 name: arka
 description: >
-  ArkaOS v2 main orchestrator. Routes commands to 16 departments, resolves natural language
-  to slash commands, runs standups, system monitoring, and cross-department coordination.
-  The entry point for every user interaction.
+  ArkaOS v2 main orchestrator. Routes commands to 17 departments, resolves natural language
+  to slash commands, runs standups, system monitoring, dashboard, knowledge base, personas,
+  and cross-department coordination. The entry point for every user interaction.
 allowed-tools: [Read, Write, Edit, Bash, Grep, Glob, Agent, WebFetch, WebSearch]
 ---
 
 # ArkaOS v2 — Main Orchestrator
 
 > **The Operating System for AI Agent Teams**
-> 56 agents. 16 departments. ~180 commands. Multi-runtime.
+> 65 agents. 17 departments. 244+ skills. Multi-runtime. Dashboard. Knowledge RAG.
 
 ## System Commands
 
@@ -23,6 +23,11 @@ allowed-tools: [Read, Write, Edit, Bash, Grep, Glob, Agent, WebFetch, WebSearch]
 | `/arka help` | List all department commands |
 | `/arka setup` | Interactive profile setup (name, company, role, objectives) |
 | `/arka conclave` | Activate personal AI advisory board (The Conclave) |
+| `/arka dashboard` | Open monitoring dashboard (localhost:3333) |
+| `/arka index` | Index Obsidian vault into knowledge base |
+| `/arka search <query>` | Semantic search in knowledge base |
+| `/arka keys` | Manage API keys (OpenAI, Google, fal.ai) |
+| `/arka personas` | Manage AI personas (create, clone to agent) |
 | `/do <description>` | Universal routing — natural language to department command |
 
 ## Universal Orchestrator (/do)
@@ -99,8 +104,9 @@ Every workflow includes a Quality Gate phase before delivery:
 | Tier | Role | Count | Authority |
 |------|------|-------|-----------|
 | 0 | C-Suite | 6 | Veto power, strategic decisions |
-| 1 | Squad Leads | 15 | Orchestrate department, domain decisions |
-| 2 | Specialists | 35 | Execute within domain expertise |
+| 1 | Squad Leads | 16 | Orchestrate department, domain decisions |
+| 2 | Specialists | 40 | Execute within domain expertise |
+| 3 | Support | 3 | Research, documentation, data collection |
 
 ## Cross-Department Collaboration
 

package/core/jobs/__init__.py

@@ -0,0 +1,5 @@
+"""Job queue — SQLite-based persistent job tracking."""
+
+from core.jobs.manager import JobManager, Job
+
+__all__ = ["JobManager", "Job"]

package/core/jobs/manager.py

@@ -0,0 +1,172 @@
+"""SQLite-based job queue for persistent task tracking.
+
+Cross-platform (Mac, Linux, Windows). Thread-safe. Survives restarts.
+"""
+
+import sqlite3
+import uuid
+from dataclasses import dataclass, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class Job:
+    id: str
+    type: str = ""            # youtube, pdf, audio, web, markdown, kb_index
+    source: str = ""          # URL or file path
+    title: str = ""
+    status: str = "queued"    # queued, processing, downloading, transcribing, embedding, completed, failed, cancelled
+    progress: int = 0         # 0-100
+    message: str = ""         # Current step description
+    chunks_created: int = 0
+    media_path: str = ""      # Path to downloaded media file
+    error: str = ""
+    created_at: str = ""
+    started_at: str = ""
+    completed_at: str = ""
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+class JobManager:
+    """SQLite-backed job queue. Thread-safe for concurrent reads."""
+
+    def __init__(self, db_path: str | Path = ""):
+        self._db_path = str(db_path) if db_path else str(Path.home() / ".arkaos" / "jobs.db")
+        Path(self._db_path).parent.mkdir(parents=True, exist_ok=True)
+        self._init_db()
+
+    def _conn(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self._db_path)
+        conn.row_factory = sqlite3.Row
+        conn.execute("PRAGMA journal_mode=WAL")  # Better concurrency
+        return conn
+
+    def _init_db(self) -> None:
+        with self._conn() as conn:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS jobs (
+                    id TEXT PRIMARY KEY,
+                    type TEXT DEFAULT '',
+                    source TEXT DEFAULT '',
+                    title TEXT DEFAULT '',
+                    status TEXT DEFAULT 'queued',
+                    progress INTEGER DEFAULT 0,
+                    message TEXT DEFAULT '',
+                    chunks_created INTEGER DEFAULT 0,
+                    media_path TEXT DEFAULT '',
+                    error TEXT DEFAULT '',
+                    created_at TEXT DEFAULT '',
+                    started_at TEXT DEFAULT '',
+                    completed_at TEXT DEFAULT ''
+                )
+            """)
+
+    def create(self, source: str, source_type: str, title: str = "") -> Job:
+        job = Job(
+            id=f"job-{uuid.uuid4().hex[:8]}",
+            type=source_type,
+            source=source,
+            title=title or f"{source_type}: {source[:60]}",
+            status="queued",
+            created_at=datetime.now().isoformat(),
+        )
+        with self._conn() as conn:
+            conn.execute(
+                "INSERT INTO jobs (id, type, source, title, status, progress, message, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+                (job.id, job.type, job.source, job.title, job.status, 0, "Queued", job.created_at),
+            )
+        return job
+
+    def get(self, job_id: str) -> Optional[Job]:
+        with self._conn() as conn:
+            row = conn.execute("SELECT * FROM jobs WHERE id = ?", (job_id,)).fetchone()
+            if not row:
+                return None
+            return Job(**dict(row))
+
+    def update_progress(self, job_id: str, progress: int, message: str, status: str = "processing") -> None:
+        with self._conn() as conn:
+            conn.execute(
+                "UPDATE jobs SET progress = ?, message = ?, status = ? WHERE id = ?",
+                (progress, message, status, job_id),
+            )
+
+    def start(self, job_id: str) -> None:
+        with self._conn() as conn:
+            conn.execute(
+                "UPDATE jobs SET status = 'processing', started_at = ? WHERE id = ?",
+                (datetime.now().isoformat(), job_id),
+            )
+
+    def complete(self, job_id: str, chunks_created: int = 0, media_path: str = "") -> None:
+        with self._conn() as conn:
+            conn.execute(
+                "UPDATE jobs SET status = 'completed', progress = 100, message = 'Done', chunks_created = ?, media_path = ?, completed_at = ? WHERE id = ?",
+                (chunks_created, media_path, datetime.now().isoformat(), job_id),
+            )
+
+    def fail(self, job_id: str, error: str) -> None:
+        with self._conn() as conn:
+            conn.execute(
+                "UPDATE jobs SET status = 'failed', error = ?, completed_at = ? WHERE id = ?",
+                (error, datetime.now().isoformat(), job_id),
+            )
+
+    def cancel(self, job_id: str) -> bool:
+        with self._conn() as conn:
+            result = conn.execute(
+                "UPDATE jobs SET status = 'cancelled', completed_at = ? WHERE id = ? AND status = 'queued'",
+                (datetime.now().isoformat(), job_id),
+            )
+            return result.rowcount > 0
+
+    def list_all(self, limit: int = 50) -> list[Job]:
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM jobs ORDER BY created_at DESC LIMIT ?", (limit,)
+            ).fetchall()
+            return [Job(**dict(r)) for r in rows]
+
+    def list_active(self) -> list[Job]:
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM jobs WHERE status IN ('queued', 'processing', 'downloading', 'transcribing', 'embedding') ORDER BY created_at ASC"
+            ).fetchall()
+            return [Job(**dict(r)) for r in rows]
+
+    def list_by_status(self, status: str, limit: int = 50) -> list[Job]:
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM jobs WHERE status = ? ORDER BY created_at DESC LIMIT ?", (status, limit)
+            ).fetchall()
+            return [Job(**dict(r)) for r in rows]
+
+    def summary(self) -> dict:
+        with self._conn() as conn:
+            total = conn.execute("SELECT COUNT(*) FROM jobs").fetchone()[0]
+            active = conn.execute("SELECT COUNT(*) FROM jobs WHERE status IN ('queued', 'processing', 'downloading', 'transcribing', 'embedding')").fetchone()[0]
+            completed = conn.execute("SELECT COUNT(*) FROM jobs WHERE status = 'completed'").fetchone()[0]
+            failed = conn.execute("SELECT COUNT(*) FROM jobs WHERE status = 'failed'").fetchone()[0]
+            total_chunks = conn.execute("SELECT COALESCE(SUM(chunks_created), 0) FROM jobs WHERE status = 'completed'").fetchone()[0]
+            return {
+                "total": total,
+                "active": active,
+                "completed": completed,
+                "failed": failed,
+                "total_chunks": total_chunks,
+            }
+
+    def clear_completed(self, keep_last: int = 20) -> int:
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT id FROM jobs WHERE status IN ('completed', 'failed', 'cancelled') ORDER BY completed_at DESC"
+            ).fetchall()
+            to_delete = [r["id"] for r in rows[keep_last:]]
+            if to_delete:
+                placeholders = ",".join("?" * len(to_delete))
+                conn.execute(f"DELETE FROM jobs WHERE id IN ({placeholders})", to_delete)
+            return len(to_delete)

package/core/knowledge/ingest.py

@@ -159,15 +159,33 @@ class IngestEngine:
         )
 
     def _process_youtube(self, url: str, progress: ProgressCallback) -> tuple[str, str]:
-        """Download YouTube video and transcribe audio."""
+        """Download YouTube video and transcribe audio.
+
+        5 distinct phases with clear progress:
+        Phase 1: Fetch video info (0-5%)
+        Phase 2: Download video (5-25%)
+        Phase 3: Extract audio (25-35%)
+        Phase 4: Transcribe audio (35-65%)
+        Phase 5: Return text for chunking/indexing (handled by caller, 75-100%)
+        """
         try:
             import yt_dlp
         except ImportError:
             raise RuntimeError("yt-dlp not installed. Run: pip install yt-dlp")
 
-        progress(5, "Fetching video info...")
+        # === Phase 1: Fetch video info ===
+        progress(2, "Phase 1/4 — Fetching video info...")
+        try:
+            with yt_dlp.YoutubeDL({"quiet": True, "no_warnings": True}) as ydl:
+                info = ydl.extract_info(url, download=False)
+                title = info.get("title", "YouTube Video")
+                duration = info.get("duration", 0)
+                progress(5, f"Phase 1/4 — Found: {title} ({duration}s)")
+        except Exception as e:
+            raise RuntimeError(f"YouTube access failed: {str(e)[:200]}")
 
-        # Download audio only
+        # === Phase 2: Download video + extract audio ===
+        progress(8, f"Phase 2/4 — Downloading video...")
         audio_path = str(self._media_dir / "yt_audio.wav")
         ydl_opts = {
             "format": "bestaudio/best",
@@ -179,21 +197,50 @@ class IngestEngine:
             }],
             "quiet": True,
             "no_warnings": True,
+            "progress_hooks": [lambda d: progress(
+                8 + int((d.get("downloaded_bytes", 0) / max(d.get("total_bytes", 1), 1)) * 17),
+                f"Phase 2/4 — Downloading... {d.get('_percent_str', '').strip()}"
+            ) if d.get("status") == "downloading" else None],
         }
 
-        progress(10, "Downloading audio...")
         with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            info = ydl.extract_info(url, download=True)
-            title = info.get("title", "YouTube Video")
-
-        progress(35, "Transcribing audio...")
+            ydl.extract_info(url, download=True)
+
+        # === Phase 3: Extract audio (FFmpeg post-processing) ===
+        progress(28, "Phase 3/4 — Extracting audio from video...")
+
+        # Verify audio file exists
+        if not os.path.exists(audio_path):
+            # Try to find the downloaded file with different extension
+            for ext in ["wav", "m4a", "webm", "mp3", "opus"]:
+                alt = str(self._media_dir / f"yt_audio.{ext}")
+                if os.path.exists(alt):
+                    audio_path = alt
+                    break
+            else:
+                raise RuntimeError("Audio extraction failed — no output file found")
+
+        audio_size_mb = os.path.getsize(audio_path) / (1024 * 1024)
+        progress(35, f"Phase 3/4 — Audio extracted ({audio_size_mb:.1f} MB)")
+
+        # === Phase 4: Transcribe audio ===
+        progress(38, "Phase 4/4 — Transcribing audio (this may take a while)...")
         text = self._transcribe_audio(audio_path)
 
-        # Cleanup
+        if not text or len(text.strip()) < 20:
+            raise RuntimeError("Transcription produced no usable text")
+
+        word_count = len(text.split())
+        progress(70, f"Phase 4/4 — Transcribed: {word_count} words")
+
+        # Rename audio to include title for easy identification
+        safe_title = "".join(c if c.isalnum() or c in " -_" else "" for c in title)[:50].strip()
+        final_audio = self._media_dir / f"{safe_title}.wav"
         try:
-            os.remove(audio_path)
-        except OSError:
-            pass
+            import shutil
+            shutil.move(audio_path, str(final_audio))
+        except Exception:
+            final_audio = Path(audio_path)
 
         return text, title
 

package/installer/index.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync, readdirSync, chmodSync } from "node:fs";
+import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync, readdirSync, chmodSync, cpSync } from "node:fs";
 import { join, resolve, dirname } from "node:path";
 import { homedir } from "node:os";
 import { execSync } from "node:child_process";
@@ -11,66 +11,123 @@ const ARKAOS_ROOT = resolve(__dirname, "..");
 const VERSION = JSON.parse(readFileSync(join(ARKAOS_ROOT, "package.json"), "utf-8")).version;
 
 export async function install({ runtime, path, force }) {
-  console.log(`\n  ArkaOS v${VERSION} — The Operating System for AI Agent Teams\n`);
-  console.log(`  Runtime: ${runtime}`);
-
+  const startTime = Date.now();
   const config = getRuntimeConfig(runtime);
   const installDir = path || join(homedir(), ".arkaos");
+  const isUpgrade = existsSync(join(installDir, "install-manifest.json"));
 
-  console.log(`  Install dir: ${installDir}`);
-  console.log(`  Config dir: ${config.configDir}\n`);
+  console.log(`
+  ╔══════════════════════════════════════════════════════════╗
+  ║  ArkaOS v${VERSION} — The Operating System for AI Agent Teams  ║
+  ╚══════════════════════════════════════════════════════════╝
 
-  // Step 1: Create directories
-  console.log("  [1/8] Creating directories...");
+  Runtime:     ${config.name}
+  Install dir: ${installDir}
+  Mode:        ${isUpgrade ? "Upgrade" : "Fresh install"}
+  `);
+
+  // ═══ Step 1: Create directories ═══
+  step(1, 12, "Creating directories...");
   ensureDir(installDir);
-  ensureDir(join(installDir, "config"));
-  ensureDir(join(installDir, "config", "hooks"));
-  ensureDir(join(installDir, "agents"));
-  ensureDir(join(installDir, "media"));
-  ensureDir(join(installDir, "session-digests"));
-
-  // Step 2: Check Python
-  console.log("  [2/8] Checking Python...");
+  const dirs = ["config", "config/hooks", "agents", "media", "session-digests", "vault"];
+  for (const d of dirs) ensureDir(join(installDir, d));
+  ok(`${dirs.length + 1} directories ready`);
+
+  // ═══ Step 2: Detect v1 installation ═══
+  step(2, 12, "Checking for v1 installation...");
+  const v1Paths = [
+    join(homedir(), ".claude", "skills", "arka-os"),
+    join(homedir(), ".claude", "skills", "arkaos"),
+  ];
+  const v1Found = v1Paths.find(p => existsSync(p));
+  if (v1Found && !existsSync(join(installDir, "migrated-from-v1"))) {
+    warn(`v1 detected at ${v1Found}`);
+    console.log("         Run 'npx arkaos migrate' after install to migrate your data.");
+  } else {
+    ok("No v1 installation found");
+  }
+
+  // ═══ Step 3: Check Python ═══
+  step(3, 12, "Checking Python 3.11+...");
   const pythonCmd = checkPython();
-  console.log(`         Found: ${pythonCmd}`);
+  ok(`Found: ${pythonCmd}`);
 
-  // Step 3: Install Python core engine
-  console.log("  [3/8] Installing Python core engine...");
-  installPythonDeps(pythonCmd);
+  // ═══ Step 4: Install Python core + ALL dependencies ═══
+  step(4, 12, "Installing Python dependencies (this may take a minute)...");
+  installAllPythonDeps(pythonCmd);
 
-  // Step 4: Copy config files
-  console.log("  [4/8] Copying configuration files...");
+  // ═══ Step 5: Copy configuration files ═══
+  step(5, 12, "Copying configuration files...");
   copyConfigFiles(installDir);
+  ok("Constitution, standards, and config copied");
 
-  // Step 5: Install hooks
-  console.log("  [5/8] Installing hooks...");
+  // ═══ Step 6: Install hooks with real paths ═══
+  step(6, 12, "Installing hooks...");
   installHooks(installDir);
 
-  // Step 6: Configure runtime
-  console.log("  [6/8] Configuring runtime...");
+  // ═══ Step 7: Configure runtime ═══
+  step(7, 12, "Configuring runtime...");
   const adapter = await loadAdapter(runtime);
   adapter.configureHooks(config, installDir);
+  ok(`${config.name} configured`);
 
-  // Step 7: Create references
-  console.log("  [7/8] Creating references...");
-  // .repo-path: so hooks can find the package
+  // ═══ Step 8: Install ArkaOS skill to Claude Code ═══
+  step(8, 12, "Installing /arka skill...");
+  installSkill(config, installDir);
+
+  // ═══ Step 9: Create references and profile ═══
+  step(9, 12, "Creating references...");
   writeFileSync(join(installDir, ".repo-path"), ARKAOS_ROOT);
-  // Skills reference
-  const skillsDir = join(config.skillsDir, "arkaos");
+  const skillsDir = join(config.skillsDir || join(homedir(), ".claude", "skills"), "arkaos");
   ensureDir(skillsDir);
   writeFileSync(join(skillsDir, ".arkaos-root"), ARKAOS_ROOT);
-  // Profile (first install only)
+
   const profilePath = join(installDir, "profile.json");
   if (!existsSync(profilePath)) {
-    console.log("         New installation — profile created.");
     writeFileSync(profilePath, JSON.stringify({
       version: "2",
       created: new Date().toISOString(),
     }, null, 2));
+    ok("New profile created");
+  } else {
+    ok("Existing profile preserved");
   }
 
-  // Step 8: Finalize
-  console.log("  [8/8] Finalizing...");
+  // ═══ Step 10: Index knowledge base (if vault configured) ═══
+  step(10, 12, "Checking knowledge base...");
+  const kbDb = join(installDir, "knowledge.db");
+  if (!existsSync(kbDb)) {
+    try {
+      execSync(`${pythonCmd} "${join(ARKAOS_ROOT, "scripts", "knowledge-index.py")}" --dir "${join(ARKAOS_ROOT, "departments")}" --db "${kbDb}"`, {
+        stdio: "pipe",
+        timeout: 60000,
+        env: { ...process.env, ARKAOS_ROOT },
+      });
+      ok("ArkaOS skills indexed into knowledge base");
+    } catch {
+      warn("Knowledge indexing skipped (run 'npx arkaos index' later)");
+    }
+  } else {
+    ok("Knowledge base already exists");
+  }
+
+  // ═══ Step 11: Verify installation ═══
+  step(11, 12, "Verifying installation...");
+  let checks = 0;
+  if (existsSync(join(installDir, "config", "constitution.yaml"))) checks++;
+  if (existsSync(join(installDir, "config", "hooks", "user-prompt-submit.sh"))) checks++;
+  if (existsSync(join(installDir, ".repo-path"))) checks++;
+  if (existsSync(profilePath)) checks++;
+  try {
+    execSync(`${pythonCmd} -c "from core.synapse.engine import SynapseEngine; print('ok')"`, {
+      stdio: "pipe", cwd: ARKAOS_ROOT, timeout: 10000,
+    });
+    checks++;
+  } catch {}
+  ok(`${checks}/5 checks passed`);
+
+  // ═══ Step 12: Finalize ═══
+  step(12, 12, "Finalizing...");
   const manifest = {
     version: VERSION,
     runtime,
@@ -83,20 +140,49 @@ export async function install({ runtime, path, force }) {
   };
   writeFileSync(join(installDir, "install-manifest.json"), JSON.stringify(manifest, null, 2));
 
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+
   console.log(`
-  ArkaOS v${VERSION} installed successfully!
+  ╔══════════════════════════════════════════════════════════╗
+  ║  ArkaOS v${VERSION} installed successfully! (${elapsed}s)         ║
+  ╚══════════════════════════════════════════════════════════╝
 
   Runtime:     ${config.name}
   Install dir: ${installDir}
-  Repo root:   ${ARKAOS_ROOT}
+  Agents:      65 across 17 departments
+  Skills:      244+ backed by enterprise frameworks
+  Knowledge:   Vector DB with semantic search
+  Dashboard:   Run 'npx arkaos dashboard' to start
+
+  Quick start:
+    /arka              — Main orchestrator
+    /do <description>  — Natural language routing
+    /dev feature       — Development workflow
+    /mkt seo-audit     — Marketing audit
+    /strat blue-ocean  — Strategy analysis
 
-  Get started:
-    Type any request in ${config.name} and ArkaOS will route it.
-    Use /do <description> for natural language commands.
-    Run: npx arkaos doctor    to verify installation.
+  Other commands:
+    npx arkaos dashboard    — Open monitoring UI
+    npx arkaos index        — Index your Obsidian vault
+    npx arkaos keys         — Configure API keys
+    npx arkaos doctor       — Run health checks
   `);
 }
 
+// ═══ Helper Functions ═══
+
+function step(n, total, msg) {
+  console.log(`  [${n}/${total}] ${msg}`);
+}
+
+function ok(msg) {
+  console.log(`         ✓ ${msg}`);
+}
+
+function warn(msg) {
+  console.log(`         ⚠ ${msg}`);
+}
+
 function ensureDir(dir) {
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
@@ -116,34 +202,119 @@ function checkPython() {
       continue;
     }
   }
-  console.error(
-    "\n  Python 3.11+ is required but not found.\n" +
-      "  Install Python: https://python.org/downloads/\n"
-  );
+  console.error(`
+  ✗ Python 3.11+ is required but not found.
+
+  Install Python:
+    macOS:   brew install python@3.13
+    Linux:   sudo apt install python3.13
+    Windows: https://python.org/downloads/
+  `);
   process.exit(1);
 }
 
-function installPythonDeps(pythonCmd) {
+function installAllPythonDeps(pythonCmd) {
+  // Core dependencies
+  const coreDeps = "pyyaml pydantic rich click jinja2";
+  // Knowledge + Vector DB
+  const knowledgeDeps = "fastembed sqlite-vss";
+  // Ingest (YouTube, PDF, web, audio)
+  const ingestDeps = "yt-dlp pdfplumber beautifulsoup4 requests";
+  // Dashboard API
+  const dashboardDeps = "fastapi uvicorn";
+  // Transcription
+  const transcriptionDeps = "faster-whisper";
+
+  const allDeps = `${coreDeps} ${knowledgeDeps} ${ingestDeps} ${dashboardDeps}`;
+
   try {
+    // Try uv first (faster)
     try {
       execSync("uv --version", { stdio: "pipe" });
-      execSync(`uv pip install -e "${ARKAOS_ROOT}"`, { stdio: "pipe" });
+      console.log("         Using uv (fast installer)...");
+      execSync(`uv pip install ${allDeps}`, { stdio: "pipe", timeout: 300000 });
+      ok("Core + Knowledge + Ingest + Dashboard deps installed");
+      // Transcription optional (heavy)
+      try {
+        execSync(`uv pip install ${transcriptionDeps}`, { stdio: "pipe", timeout: 300000 });
+        ok("Whisper transcription installed");
+      } catch {
+        warn("Whisper not installed (optional — needed for YouTube/audio transcription)");
+      }
       return;
     } catch {
-      // uv not available
+      // uv not available, use pip
+    }
+
+    console.log("         Installing core dependencies...");
+    execSync(`${pythonCmd} -m pip install ${coreDeps} --quiet`, { stdio: "pipe", timeout: 120000 });
+    ok("Core deps installed (pyyaml, pydantic, rich, click, jinja2)");
+
+    console.log("         Installing knowledge base dependencies...");
+    try {
+      execSync(`${pythonCmd} -m pip install ${knowledgeDeps} --quiet`, { stdio: "pipe", timeout: 180000 });
+      ok("Vector DB installed (fastembed, sqlite-vss)");
+    } catch {
+      warn("Vector DB not installed (run: pip install fastembed sqlite-vss)");
+    }
+
+    console.log("         Installing content ingest dependencies...");
+    try {
+      execSync(`${pythonCmd} -m pip install ${ingestDeps} --quiet`, { stdio: "pipe", timeout: 120000 });
+      ok("Ingest deps installed (yt-dlp, pdfplumber, beautifulsoup4)");
+    } catch {
+      warn("Ingest deps not fully installed (some content types may not work)");
+    }
+
+    console.log("         Installing dashboard dependencies...");
+    try {
+      execSync(`${pythonCmd} -m pip install ${dashboardDeps} --quiet`, { stdio: "pipe", timeout: 60000 });
+      ok("Dashboard API installed (fastapi, uvicorn)");
+    } catch {
+      warn("Dashboard API not installed (run: pip install fastapi uvicorn)");
     }
-    execSync(`${pythonCmd} -m pip install -e "${ARKAOS_ROOT}" --quiet`, { stdio: "pipe" });
+
+    console.log("         Installing transcription engine...");
+    try {
+      execSync(`${pythonCmd} -m pip install ${transcriptionDeps} --quiet`, { stdio: "pipe", timeout: 300000 });
+      ok("Whisper transcription installed");
+    } catch {
+      warn("Whisper not installed (optional — needed for YouTube/audio)");
+    }
+
+    // Install ArkaOS itself as editable
+    try {
+      execSync(`${pythonCmd} -m pip install -e "${ARKAOS_ROOT}" --quiet`, { stdio: "pipe", timeout: 60000 });
+    } catch {}
+
   } catch (err) {
-    console.warn("         Warning: Could not install Python deps. Core engine may not work.");
-    console.warn(`         ${err.message}`);
+    warn(`Some Python deps failed: ${err.message.slice(0, 100)}`);
+    console.log("         You can install manually: pip install pyyaml pydantic rich click fastembed sqlite-vss");
   }
 }
 
 function copyConfigFiles(installDir) {
   // Constitution
-  const constitutionSrc = join(ARKAOS_ROOT, "config", "constitution.yaml");
-  if (existsSync(constitutionSrc)) {
-    copyFileSync(constitutionSrc, join(installDir, "config", "constitution.yaml"));
+  const files = [
+    ["config/constitution.yaml", "config/constitution.yaml"],
+  ];
+
+  // Standards
+  const standardsDir = join(ARKAOS_ROOT, "config", "standards");
+  if (existsSync(standardsDir)) {
+    ensureDir(join(installDir, "config", "standards"));
+    for (const f of readdirSync(standardsDir)) {
+      files.push([`config/standards/${f}`, `config/standards/${f}`]);
+    }
+  }
+
+  for (const [src, dest] of files) {
+    const srcPath = join(ARKAOS_ROOT, src);
+    const destPath = join(installDir, dest);
+    if (existsSync(srcPath)) {
+      ensureDir(dirname(destPath));
+      copyFileSync(srcPath, destPath);
+    }
   }
 }
 
@@ -151,7 +322,6 @@ function installHooks(installDir) {
   const hooksDir = join(installDir, "config", "hooks");
   ensureDir(hooksDir);
 
-  // Copy v2 hooks, rename to standard names (without -v2 suffix)
   const hookMap = {
     "user-prompt-submit-v2.sh": "user-prompt-submit.sh",
     "post-tool-use-v2.sh": "post-tool-use.sh",
@@ -164,22 +334,52 @@ function installHooks(installDir) {
     const srcPath = join(srcHooksDir, src);
     const destPath = join(hooksDir, dest);
     if (existsSync(srcPath)) {
-      // Read, replace ARKAOS_ROOT placeholder, write
       let content = readFileSync(srcPath, "utf-8");
-      // Ensure hooks use the install directory
+      // Set ARKAOS_ROOT to the npm package location (persistent)
       content = content.replace(
         /ARKAOS_ROOT="\$\{ARKA_OS:-\$HOME\/\.claude\/skills\/arkaos\}"/g,
-        `ARKAOS_ROOT="${installDir}"`
+        `ARKAOS_ROOT="${ARKAOS_ROOT}"`
       );
       content = content.replace(
         /ARKAOS_HOME="\$\{HOME\}\/\.arkaos"/g,
         `ARKAOS_HOME="${installDir}"`
       );
       writeFileSync(destPath, content);
-      try {
-        chmodSync(destPath, 0o755);
-      } catch { /* ignore on Windows */ }
-      console.log(`         Installed: ${dest}`);
+      try { chmodSync(destPath, 0o755); } catch {}
+      ok(`Hook: ${dest}`);
+    }
+  }
+}
+
+function installSkill(config, installDir) {
+  // Copy arka/SKILL.md to Claude Code skills directory
+  const skillSrc = join(ARKAOS_ROOT, "arka", "SKILL.md");
+  const skillsBase = config.skillsDir || join(homedir(), ".claude", "skills");
+  const skillDest = join(skillsBase, "arka");
+
+  ensureDir(skillDest);
+
+  if (existsSync(skillSrc)) {
+    copyFileSync(skillSrc, join(skillDest, "SKILL.md"));
+    // Write repo path reference
+    writeFileSync(join(skillDest, ".repo-path"), ARKAOS_ROOT);
+    writeFileSync(join(skillDest, "VERSION"), VERSION);
+    ok("/arka skill installed → Claude Code can now use ArkaOS");
+  } else {
+    warn("SKILL.md not found in package");
+  }
+
+  // Also copy department skills as references
+  const deptSkillSrc = join(ARKAOS_ROOT, "arka", "skills");
+  if (existsSync(deptSkillSrc)) {
+    const skillsOut = join(skillDest, "skills");
+    ensureDir(skillsOut);
+    try {
+      cpSync(deptSkillSrc, skillsOut, { recursive: true });
+      ok("Department skills copied");
+    } catch {
+      // cpSync may not be available in older Node
+      warn("Department skills copy skipped");
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arkaos",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "The Operating System for AI Agent Teams",
   "type": "module",
   "bin": {

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arkaos-core"
-version = "2.2.1"
+version = "2.3.0"
 description = "Core engine for ArkaOS — The Operating System for AI Agent Teams"
 readme = "README.md"
 license = {text = "MIT"}