@shmulikdav/solix 1.0.0

package/dist/index.js

@@ -0,0 +1,3645 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/advisors.ts
+var PORT = process.env.SOLIX_PORT ?? "4242";
+var BASE = `http://127.0.0.1:${PORT}`;
+async function api(path, init) {
+  const res = await fetch(`${BASE}${path}`, init);
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status} on ${path}: ${text}`);
+  }
+  return await res.json();
+}
+async function listAdvisorsCmd() {
+  try {
+    const advisors2 = await api("/api/advisors");
+    if (!advisors2.length) {
+      console.log("No advisors found. Run `solix install` to seed the crew.");
+      return;
+    }
+    const lines = advisors2.map((a) => {
+      const flag = a.pinned ? "pinned" : a.enabled ? "on" : "off";
+      return `  ${a.id.padEnd(10)} ${a.codename.padEnd(10)} ${a.role.padEnd(10)} [${flag}]`;
+    });
+    console.log("id          codename   role       state");
+    console.log(lines.join("\n"));
+  } catch (err) {
+    console.error(`[solix] could not reach server at ${BASE}: ${String(err)}`);
+    console.error("[solix] is `solix start` running?");
+    process.exitCode = 1;
+  }
+}
+async function postAdvisor(id, action) {
+  try {
+    const res = await api(
+      `/api/advisors/${encodeURIComponent(id)}/${action}`,
+      { method: "POST" }
+    );
+    if (res.ok) {
+      console.log(`[solix] ${id} \u2192 ${action}`);
+    } else {
+      console.error(`[solix] failed: advisor not found?`);
+      process.exitCode = 1;
+    }
+  } catch (err) {
+    console.error(`[solix] could not reach server: ${String(err)}`);
+    process.exitCode = 1;
+  }
+}
+var enableAdvisorCmd = (id) => postAdvisor(id, "enable");
+var disableAdvisorCmd = (id) => postAdvisor(id, "disable");
+var pinAdvisorCmd = (id) => postAdvisor(id, "pin");
+var unpinAdvisorCmd = (id) => postAdvisor(id, "unpin");
+
+// src/demo.ts
+import { homedir } from "os";
+import { join } from "path";
+var PORT2 = process.env.SOLIX_PORT ?? "4242";
+var BASE2 = `http://127.0.0.1:${PORT2}`;
+async function postEvent(payload) {
+  await fetch(`${BASE2}/events`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+}
+function ts() {
+  return Date.now();
+}
+async function ensureReachable() {
+  try {
+    const res = await fetch(`${BASE2}/api/health`, {
+      signal: AbortSignal.timeout(800)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function pin(advisorId) {
+  await fetch(`${BASE2}/api/advisors/${encodeURIComponent(advisorId)}/pin`, {
+    method: "POST"
+  });
+}
+async function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function demoCmd(opts = {}) {
+  if (opts.port) process.env.SOLIX_PORT = String(opts.port);
+  if (!await ensureReachable()) {
+    console.error(
+      "[solix] server not reachable \u2014 run `solix start` first, then `solix demo` in another terminal"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const cwd = opts.cwd ?? join(homedir(), "demo-project");
+  console.log(`[solix demo] seeding fake state for ${BASE2}`);
+  console.log(`[solix demo] using fake cwd: ${cwd}`);
+  const sessions = [
+    {
+      id: "demo-a",
+      pid: 90001,
+      cwd,
+      payload: { session_id: "demo-a", model: "opus" },
+      prompt: "Refactor the orbital math for stable layout",
+      tools: [
+        { tool: "Read", file: "packages/web/src/scene/orbits.ts" },
+        { tool: "Edit", file: "packages/web/src/scene/orbits.ts" },
+        { tool: "Bash", cmd: "pnpm --filter @solix/web typecheck" }
+      ]
+    },
+    {
+      id: "demo-b",
+      pid: 90002,
+      cwd,
+      payload: { session_id: "demo-b", model: "sonnet" },
+      prompt: "Wire up the asteroid belt to real skill data",
+      tools: [
+        { tool: "Read", file: "packages/server/src/state/skills.ts" },
+        { tool: "Write", file: "packages/web/src/scene/AsteroidBelt.tsx" }
+      ]
+    },
+    {
+      id: "demo-c",
+      pid: 90003,
+      cwd,
+      payload: { session_id: "demo-c", model: "haiku" },
+      prompt: "Document the context envelope strategy",
+      tools: []
+    }
+  ];
+  for (const s of sessions) {
+    await postEvent({
+      event: "session_start",
+      pid: s.pid,
+      cwd: s.cwd,
+      ts: ts(),
+      payload: s.payload
+    });
+  }
+  await sleep(150);
+  for (const s of sessions.slice(0, 2)) {
+    await postEvent({
+      event: "user_prompt_submit",
+      pid: s.pid,
+      cwd: s.cwd,
+      ts: ts(),
+      payload: { session_id: s.id, prompt: s.prompt }
+    });
+  }
+  await sleep(100);
+  for (const t of sessions[0].tools) {
+    if (t.tool === "Bash") {
+      await postEvent({
+        event: "pre_tool_bash",
+        pid: sessions[0].pid,
+        cwd: sessions[0].cwd,
+        ts: ts(),
+        payload: {
+          session_id: sessions[0].id,
+          command: t.cmd
+        }
+      });
+    } else {
+      await postEvent({
+        event: "pre_tool_file",
+        pid: sessions[0].pid,
+        cwd: sessions[0].cwd,
+        ts: ts(),
+        payload: {
+          session_id: sessions[0].id,
+          tool_name: t.tool,
+          tool_input: { file_path: t.file }
+        }
+      });
+    }
+    await sleep(80);
+  }
+  await postEvent({
+    event: "pre_tool_task",
+    pid: sessions[1].pid,
+    cwd: sessions[1].cwd,
+    ts: ts(),
+    payload: { session_id: sessions[1].id }
+  });
+  await postEvent({
+    event: "notification",
+    pid: sessions[2].pid,
+    cwd: sessions[2].cwd,
+    ts: ts(),
+    payload: {
+      session_id: sessions[2].id,
+      tool_name: "Bash",
+      tool_input: { command: "git push origin main" },
+      message: "Permission for git push"
+    }
+  });
+  await fetch(`${BASE2}/api/sessions/demo-a/context`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ pct: 62 })
+  });
+  await fetch(`${BASE2}/api/sessions/demo-b/context`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ pct: 87 })
+  });
+  await pin("compass");
+  console.log(`[solix demo] seeded:`);
+  console.log(`  \u2022 3 user planets (opus / sonnet / haiku)`);
+  console.log(`  \u2022 1 active mission with tool-call comets`);
+  console.log(`  \u2022 1 subagent moon`);
+  console.log(`  \u2022 1 planet awaiting permission (red flare)`);
+  console.log(`  \u2022 1 planet at 87% context (orange flare)`);
+  console.log(`  \u2022 Compass pinned (always-on)`);
+  console.log(`[solix demo] open ${BASE2} to see it.`);
+}
+
+// src/doctor.ts
+import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { join as join3 } from "path";
+
+// src/paths.ts
+import { homedir as homedir2 } from "os";
+import { existsSync } from "fs";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+var SOLIX_HOME = process.env.SOLIX_HOME ?? join2(homedir2(), ".solix");
+var HOOKS_DIR = join2(SOLIX_HOME, "hooks");
+var SOLIX_SKILLS_DIR = join2(SOLIX_HOME, "skills");
+var CLAUDE_DIR = join2(homedir2(), ".claude");
+var CLAUDE_SETTINGS = join2(CLAUDE_DIR, "settings.json");
+var CLAUDE_BACKUP = join2(CLAUDE_DIR, "settings.solix.backup.json");
+var CLAUDE_AGENTS_DIR = join2(CLAUDE_DIR, "agents");
+var CLAUDE_SKILLS_DIR = join2(CLAUDE_DIR, "skills");
+var HOOK_NAMES = [
+  "session-start",
+  "prompt-submit",
+  "stop",
+  "subagent-stop",
+  "pre-tool-task",
+  "pre-tool-file",
+  "pre-tool-bash",
+  "post-tool",
+  "notification"
+];
+function packagedHooksDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join2(here, "hooks"),
+    join2(here, "..", "hooks"),
+    join2(here, "..", "..", "hooks")
+  ];
+  for (const p of candidates) {
+    if (existsSync(join2(p, "session-start.sh"))) return p;
+  }
+  return candidates[0];
+}
+function packagedAgentsDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join2(here, "..", "..", "agents"),
+    join2(here, "..", "..", "..", "agents"),
+    join2(here, "..", "..", "..", "..", "packages", "agents")
+  ];
+  for (const p of candidates) {
+    if (existsSync(join2(p, "manifest.json"))) return p;
+  }
+  return candidates[0];
+}
+function packagedSkillsDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join2(here, "..", "..", "skills"),
+    join2(here, "..", "..", "..", "skills"),
+    join2(here, "..", "..", "..", "..", "packages", "skills")
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) return p;
+  }
+  return candidates[0];
+}
+
+// src/doctor.ts
+async function probeHealth(port) {
+  const url = `http://127.0.0.1:${port}/api/health`;
+  try {
+    const res = await fetch(url, {
+      signal: AbortSignal.timeout(800)
+    });
+    if (!res.ok) {
+      return { ok: false, label: "Server reachable", detail: `HTTP ${res.status}` };
+    }
+    return { ok: true, label: "Server reachable", detail: url };
+  } catch (err) {
+    return {
+      ok: false,
+      label: "Server reachable",
+      detail: `not running on ${url}`
+    };
+  }
+}
+async function doctor() {
+  const port = Number(process.env.SOLIX_PORT ?? 4242);
+  const checks = [];
+  const nodeVersion = process.versions.node;
+  const major = Number(nodeVersion.split(".")[0]);
+  checks.push({
+    ok: major >= 20,
+    label: "Node.js >= 20",
+    detail: `v${nodeVersion}`
+  });
+  checks.push({
+    ok: existsSync2(SOLIX_HOME),
+    label: "Solix home directory",
+    detail: SOLIX_HOME
+  });
+  let allHooksPresent = true;
+  const missing = [];
+  for (const name of HOOK_NAMES) {
+    const p = join3(HOOKS_DIR, `${name}.sh`);
+    if (!existsSync2(p)) {
+      allHooksPresent = false;
+      missing.push(name);
+      continue;
+    }
+    try {
+      statSync(p);
+    } catch {
+      allHooksPresent = false;
+      missing.push(name);
+    }
+  }
+  checks.push({
+    ok: allHooksPresent,
+    label: "Hook scripts installed",
+    detail: allHooksPresent ? `${HOOK_NAMES.length} scripts in ${HOOKS_DIR}` : `missing: ${missing.join(", ")}`
+  });
+  checks.push({
+    ok: existsSync2(CLAUDE_SETTINGS),
+    label: "Claude settings.json present",
+    detail: CLAUDE_SETTINGS
+  });
+  checks.push({
+    ok: existsSync2(CLAUDE_BACKUP),
+    label: "Backup of settings.json",
+    detail: existsSync2(CLAUDE_BACKUP) ? CLAUDE_BACKUP : "not yet created"
+  });
+  let advisorCount = 0;
+  if (existsSync2(CLAUDE_AGENTS_DIR)) {
+    try {
+      advisorCount = readdirSync(CLAUDE_AGENTS_DIR).filter(
+        (f) => f.endsWith(".md")
+      ).length;
+    } catch {
+      advisorCount = 0;
+    }
+  }
+  checks.push({
+    ok: advisorCount > 0,
+    label: "Advisor agents installed",
+    detail: advisorCount > 0 ? `${advisorCount} agents in ${CLAUDE_AGENTS_DIR}` : "none yet \u2014 run `solix install`"
+  });
+  let skillCount = 0;
+  if (existsSync2(SOLIX_SKILLS_DIR)) {
+    try {
+      skillCount = readdirSync(SOLIX_SKILLS_DIR).filter((entry) => {
+        try {
+          return statSync(join3(SOLIX_SKILLS_DIR, entry)).isDirectory();
+        } catch {
+          return false;
+        }
+      }).length;
+    } catch {
+      skillCount = 0;
+    }
+  }
+  checks.push({
+    ok: skillCount >= 0,
+    label: "Solix skill pack",
+    detail: skillCount > 0 ? `${skillCount} skills in ${SOLIX_SKILLS_DIR}` : "none"
+  });
+  checks.push(await probeHealth(port));
+  console.log("\nSolix Diagnostics\n");
+  let allOk = true;
+  for (const c of checks) {
+    const icon = c.ok ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+    const detail = c.detail ? `  \x1B[2m${c.detail}\x1B[0m` : "";
+    console.log(`${icon} ${c.label}${detail}`);
+    if (!c.ok) allOk = false;
+  }
+  console.log("");
+  if (allOk) {
+    console.log("All checks passed. Solix is healthy.\n");
+  } else {
+    console.log(
+      "Some checks failed. Run `solix install` and `solix start` to fix common issues.\n"
+    );
+    process.exitCode = 1;
+  }
+}
+
+// src/galaxy.ts
+import { readFileSync, writeFileSync } from "fs";
+var PORT3 = process.env.SOLIX_PORT ?? "4242";
+var BASE3 = `http://127.0.0.1:${PORT3}`;
+async function api2(path, init) {
+  const res = await fetch(`${BASE3}${path}`, init);
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status} on ${path}: ${text}`);
+  }
+  return await res.json();
+}
+async function exportGalaxyCmd(outFile, opts = {}) {
+  try {
+    const params = new URLSearchParams();
+    if (opts.name) params.set("name", opts.name);
+    if (opts.author) params.set("author", opts.author);
+    if (opts.description) params.set("description", opts.description);
+    const qs = params.toString();
+    const manifest = await api2(
+      `/api/galaxy/export${qs ? `?${qs}` : ""}`
+    );
+    const text = JSON.stringify(manifest, null, 2) + "\n";
+    writeFileSync(outFile, text);
+    console.log(`[solix] exported galaxy to ${outFile}`);
+  } catch (err) {
+    console.error(`[solix] export failed: ${String(err)}`);
+    process.exitCode = 1;
+  }
+}
+async function publishGalaxyCmd(slug, opts = {}) {
+  try {
+    const res = await fetch(`${BASE3}/api/galaxy/publish`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ slug, ...opts })
+    });
+    const data = await res.json();
+    if (!res.ok || !data.ok) {
+      console.error(
+        `[solix] publish failed: ${data.error ?? `HTTP ${res.status}`}`
+      );
+      console.error(
+        "[solix] hint: set SOLIX_REGISTRY_URL and SOLIX_REGISTRY_KEY before starting the server."
+      );
+      process.exitCode = 1;
+      return;
+    }
+    console.log(`[solix] published as ${data.slug ?? slug}`);
+  } catch (err) {
+    console.error(`[solix] publish failed: ${String(err)}`);
+    process.exitCode = 1;
+  }
+}
+async function installFromRegistryCmd(slug) {
+  try {
+    const res = await fetch(
+      `${BASE3}/api/galaxy/registry/${encodeURIComponent(slug)}/install`,
+      { method: "POST" }
+    );
+    const data = await res.json();
+    if (!res.ok || !data.ok) {
+      console.error(
+        `[solix] install failed: ${data.error ?? `HTTP ${res.status}`}`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    console.log(
+      `[solix] installed ${slug}: ${data.advisorsEnabled} advisor(s) enabled, ${data.advisorsDisabled} disabled, ${data.projectsHinted} project(s) hinted`
+    );
+  } catch (err) {
+    console.error(`[solix] install failed: ${String(err)}`);
+    process.exitCode = 1;
+  }
+}
+async function importGalaxyCmd(fileOrUrl) {
+  try {
+    let body;
+    if (fileOrUrl.startsWith("http://") || fileOrUrl.startsWith("https://")) {
+      body = JSON.stringify({ url: fileOrUrl });
+    } else {
+      const text = readFileSync(fileOrUrl, "utf8");
+      body = text;
+    }
+    const res = await api2(`/api/galaxy/import`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body
+    });
+    if (res.ok) {
+      console.log(
+        `[solix] imported: ${res.advisorsEnabled} advisor(s) enabled, ${res.advisorsDisabled} disabled, ${res.projectsHinted} project(s) hinted`
+      );
+    } else {
+      console.error(`[solix] import failed: ${res.error ?? "unknown"}`);
+      process.exitCode = 1;
+    }
+  } catch (err) {
+    console.error(`[solix] import failed: ${String(err)}`);
+    process.exitCode = 1;
+  }
+}
+
+// src/install.ts
+import {
+  copyFileSync,
+  cpSync,
+  existsSync as existsSync3,
+  mkdirSync,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2,
+  chmodSync
+} from "fs";
+import { join as join4 } from "path";
+function readSettings() {
+  if (!existsSync3(CLAUDE_SETTINGS)) return {};
+  try {
+    const txt = readFileSync2(CLAUDE_SETTINGS, "utf8");
+    return JSON.parse(txt);
+  } catch (err) {
+    console.warn(`[solix] could not parse ${CLAUDE_SETTINGS}: ${String(err)}`);
+    return {};
+  }
+}
+function hookCommand(name) {
+  return `${HOOKS_DIR}/${name}.sh`;
+}
+function buildSolixHooks() {
+  return {
+    SessionStart: [
+      { matcher: "*", hooks: [{ type: "command", command: hookCommand("session-start") }] }
+    ],
+    UserPromptSubmit: [
+      { matcher: "*", hooks: [{ type: "command", command: hookCommand("prompt-submit") }] }
+    ],
+    Stop: [{ matcher: "*", hooks: [{ type: "command", command: hookCommand("stop") }] }],
+    SubagentStop: [
+      { matcher: "*", hooks: [{ type: "command", command: hookCommand("subagent-stop") }] }
+    ],
+    PreToolUse: [
+      { matcher: "Task", hooks: [{ type: "command", command: hookCommand("pre-tool-task") }] },
+      {
+        matcher: "Read|Write|Edit|MultiEdit",
+        hooks: [{ type: "command", command: hookCommand("pre-tool-file") }]
+      },
+      { matcher: "Bash", hooks: [{ type: "command", command: hookCommand("pre-tool-bash") }] }
+    ],
+    PostToolUse: [
+      { matcher: "*", hooks: [{ type: "command", command: hookCommand("post-tool") }] }
+    ],
+    Notification: [
+      { matcher: "*", hooks: [{ type: "command", command: hookCommand("notification") }] }
+    ]
+  };
+}
+function isSolixHook(entry) {
+  return entry.hooks.some((h) => h.command.includes(`${HOOKS_DIR}/`));
+}
+function mergeHooks(existing, solix) {
+  const merged = { ...existing ?? {} };
+  for (const [evt, solixEntries] of Object.entries(solix)) {
+    const userEntries = (merged[evt] ?? []).filter((e) => !isSolixHook(e));
+    merged[evt] = [...userEntries, ...solixEntries];
+  }
+  return merged;
+}
+function installHookScripts() {
+  mkdirSync(HOOKS_DIR, { recursive: true });
+  const src = packagedHooksDir();
+  if (!existsSync3(src)) {
+    throw new Error(
+      `Solix hook scripts not found at ${src}. Did the package build correctly?`
+    );
+  }
+  for (const name of HOOK_NAMES) {
+    const from = join4(src, `${name}.sh`);
+    const to = join4(HOOKS_DIR, `${name}.sh`);
+    copyFileSync(from, to);
+    chmodSync(to, 493);
+  }
+}
+function installAdvisorAgents() {
+  const src = packagedAgentsDir();
+  if (!existsSync3(src)) {
+    console.warn(`[solix] no advisors/ directory at ${src}; skipping`);
+    return 0;
+  }
+  const manifestPath = join4(src, "manifest.json");
+  if (!existsSync3(manifestPath)) return 0;
+  const manifest = JSON.parse(readFileSync2(manifestPath, "utf8"));
+  mkdirSync(CLAUDE_AGENTS_DIR, { recursive: true });
+  let copied = 0;
+  for (const a of manifest.advisors) {
+    const from = join4(src, a.agentMd);
+    const to = join4(CLAUDE_AGENTS_DIR, a.agentMd);
+    if (!existsSync3(from)) continue;
+    copyFileSync(from, to);
+    copied += 1;
+  }
+  return copied;
+}
+function installSolixSkills() {
+  const src = packagedSkillsDir();
+  if (!existsSync3(src)) return 0;
+  mkdirSync(SOLIX_SKILLS_DIR, { recursive: true });
+  let copied = 0;
+  for (const entry of readdirSync2(src)) {
+    const fromDir = join4(src, entry);
+    let isDir = false;
+    try {
+      isDir = statSync2(fromDir).isDirectory();
+    } catch {
+      continue;
+    }
+    if (!isDir) continue;
+    const toDir = join4(SOLIX_SKILLS_DIR, entry);
+    cpSync(fromDir, toDir, { recursive: true });
+    copied += 1;
+  }
+  return copied;
+}
+function install(opts = {}) {
+  mkdirSync(SOLIX_HOME, { recursive: true });
+  mkdirSync(CLAUDE_DIR, { recursive: true });
+  const existing = readSettings();
+  if (existsSync3(CLAUDE_SETTINGS) && !existsSync3(CLAUDE_BACKUP)) {
+    copyFileSync(CLAUDE_SETTINGS, CLAUDE_BACKUP);
+    console.log(`[solix] backed up settings.json -> ${CLAUDE_BACKUP}`);
+  } else if (opts.force && existsSync3(CLAUDE_SETTINGS)) {
+    copyFileSync(CLAUDE_SETTINGS, CLAUDE_BACKUP);
+  }
+  installHookScripts();
+  console.log(`[solix] installed hook scripts in ${HOOKS_DIR}`);
+  const advisorsCopied = installAdvisorAgents();
+  if (advisorsCopied > 0) {
+    console.log(
+      `[solix] installed ${advisorsCopied} advisor agents in ${CLAUDE_AGENTS_DIR}`
+    );
+  }
+  const skillsCopied = installSolixSkills();
+  if (skillsCopied > 0) {
+    console.log(
+      `[solix] installed ${skillsCopied} Solix skills in ${SOLIX_SKILLS_DIR}`
+    );
+  }
+  const merged = mergeHooks(existing.hooks, buildSolixHooks());
+  const next = { ...existing, hooks: merged };
+  writeFileSync2(CLAUDE_SETTINGS, JSON.stringify(next, null, 2) + "\n");
+  console.log(`[solix] merged hooks into ${CLAUDE_SETTINGS}`);
+}
+
+// src/skills.ts
+var PORT4 = process.env.SOLIX_PORT ?? "4242";
+var BASE4 = `http://127.0.0.1:${PORT4}`;
+async function api3(path, init) {
+  const res = await fetch(`${BASE4}${path}`, init);
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status} on ${path}: ${text}`);
+  }
+  return await res.json();
+}
+async function listSkillsCmd() {
+  try {
+    const skills2 = await api3("/api/skills");
+    if (!skills2.length) {
+      console.log(
+        "No skills found. Drop SKILL.md files into ~/.claude/skills/ or ~/.solix/skills/."
+      );
+      return;
+    }
+    console.log("source     id                              installed  name");
+    for (const s of skills2) {
+      const installed = String(s.installedInProjects.length).padStart(2, " ");
+      console.log(
+        `${s.source.padEnd(10)} ${s.id.padEnd(32)} ${installed}         ${s.name}`
+      );
+    }
+  } catch (err) {
+    console.error(`[solix] could not reach server at ${BASE4}: ${String(err)}`);
+    process.exitCode = 1;
+  }
+}
+async function installSkillCmd(id, projectId) {
+  if (!projectId) {
+    console.error(
+      "[solix] --project <projectId> is required (use `solix doctor` or `/api/projects` to find it)"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const res = await api3(
+      `/api/skills/${encodeURIComponent(id)}/install`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ projectId })
+      }
+    );
+    if (res.ok) {
+      console.log(`[solix] ${id} installed in project ${projectId}`);
+    } else {
+      console.error(`[solix] failed: skill not found?`);
+      process.exitCode = 1;
+    }
+  } catch (err) {
+    console.error(`[solix] could not reach server: ${String(err)}`);
+    process.exitCode = 1;
+  }
+}
+
+// ../server/src/create.ts
+import { serve } from "@hono/node-server";
+
+// ../server/src/broadcaster.ts
+var Broadcaster = class {
+  clients = /* @__PURE__ */ new Set();
+  add(ws) {
+    this.clients.add(ws);
+  }
+  remove(ws) {
+    this.clients.delete(ws);
+  }
+  send(ws, msg) {
+    if (ws.readyState !== ws.OPEN) return;
+    ws.send(JSON.stringify(msg));
+  }
+  broadcast(msg) {
+    const payload = JSON.stringify(msg);
+    for (const ws of this.clients) {
+      if (ws.readyState === ws.OPEN) {
+        ws.send(payload);
+      }
+    }
+  }
+  size() {
+    return this.clients.size;
+  }
+};
+
+// ../server/src/db.ts
+import Database from "better-sqlite3";
+
+// ../server/src/paths.ts
+import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
+import { mkdirSync as mkdirSync2 } from "fs";
+var SOLIX_HOME2 = process.env.SOLIX_HOME ?? join5(homedir3(), ".solix");
+var DB_PATH = join5(SOLIX_HOME2, "solix.db");
+var HOOKS_DIR2 = join5(SOLIX_HOME2, "hooks");
+var LOG_PATH = join5(SOLIX_HOME2, "solix.log");
+function ensureSolixHome() {
+  mkdirSync2(SOLIX_HOME2, { recursive: true });
+  mkdirSync2(HOOKS_DIR2, { recursive: true });
+}
+
+// ../server/src/db.ts
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS projects (
+  id TEXT PRIMARY KEY,
+  cwd TEXT NOT NULL UNIQUE,
+  name TEXT NOT NULL,
+  first_seen_at INTEGER NOT NULL,
+  last_active_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  pid INTEGER,
+  project_id TEXT NOT NULL REFERENCES projects(id),
+  parent_session_id TEXT REFERENCES sessions(id),
+  origin TEXT NOT NULL CHECK (origin IN ('external','internal')),
+  model TEXT,
+  status TEXT NOT NULL,
+  context_usage_pct REAL DEFAULT 0,
+  orbit_slot INTEGER NOT NULL,
+  cwd TEXT NOT NULL,
+  name TEXT,
+  kind TEXT NOT NULL DEFAULT 'user',
+  advisor_role TEXT,
+  current_mission_id TEXT,
+  last_completed_mission_id TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  terminated_at INTEGER
+);
+CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+CREATE INDEX IF NOT EXISTS idx_sessions_kind ON sessions(kind);
+
+CREATE TABLE IF NOT EXISTS advisors (
+  id TEXT PRIMARY KEY,
+  role TEXT NOT NULL,
+  codename TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL,
+  glyph TEXT,
+  color TEXT,
+  default_model TEXT,
+  agent_md_path TEXT NOT NULL,
+  required_skills_json TEXT DEFAULT '[]',
+  enabled INTEGER NOT NULL DEFAULT 0,
+  pinned INTEGER NOT NULL DEFAULT 0,
+  pinned_session_id TEXT,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS skills (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT,
+  source TEXT NOT NULL CHECK (source IN ('anthropic','solix','user')),
+  manifest_path TEXT NOT NULL,
+  installed_in_projects_json TEXT DEFAULT '[]',
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS galaxy_imports (
+  id TEXT PRIMARY KEY,
+  source_url TEXT,
+  manifest_json TEXT NOT NULL,
+  imported_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS audit_events (
+  id TEXT PRIMARY KEY,
+  ts INTEGER NOT NULL,
+  kind TEXT NOT NULL,
+  session_id TEXT,
+  advisor_id TEXT,
+  project_id TEXT,
+  summary TEXT NOT NULL,
+  payload_json TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_audit_ts ON audit_events(ts);
+CREATE INDEX IF NOT EXISTS idx_audit_session ON audit_events(session_id);
+
+CREATE TABLE IF NOT EXISTS galaxy_versions (
+  id TEXT PRIMARY KEY,
+  ts INTEGER NOT NULL,
+  ordinal INTEGER NOT NULL,
+  name TEXT NOT NULL,
+  author TEXT,
+  description TEXT,
+  manifest_json TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_galaxy_versions_ts ON galaxy_versions(ts);
+
+CREATE TABLE IF NOT EXISTS missions (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL REFERENCES sessions(id),
+  prompt TEXT NOT NULL,
+  short_name TEXT,
+  long_summary TEXT,
+  status TEXT NOT NULL,
+  started_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  duration_ms INTEGER,
+  total_tokens INTEGER,
+  lines_added INTEGER DEFAULT 0,
+  lines_removed INTEGER DEFAULT 0,
+  subagent_count INTEGER DEFAULT 0,
+  tool_call_count INTEGER DEFAULT 0,
+  files_touched_json TEXT DEFAULT '[]'
+);
+CREATE INDEX IF NOT EXISTS idx_missions_session ON missions(session_id);
+CREATE INDEX IF NOT EXISTS idx_missions_completed_at ON missions(completed_at);
+
+CREATE TABLE IF NOT EXISTS tool_calls (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  mission_id TEXT,
+  tool TEXT NOT NULL,
+  args_json TEXT,
+  status TEXT NOT NULL,
+  started_at INTEGER NOT NULL,
+  completed_at INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS scheduled_tasks (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id),
+  prompt TEXT NOT NULL,
+  cron TEXT NOT NULL,
+  enabled INTEGER DEFAULT 1,
+  last_run_at INTEGER,
+  next_run_at INTEGER NOT NULL
+);
+`;
+var _db = null;
+function ensureColumn(db, table, column, ddl) {
+  const cols = db.prepare(`PRAGMA table_info(${table})`).all();
+  if (!cols.some((c) => c.name === column)) {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl}`);
+  }
+}
+function getDb() {
+  if (_db) return _db;
+  ensureSolixHome();
+  const db = new Database(DB_PATH);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(SCHEMA);
+  ensureColumn(db, "sessions", "kind", "kind TEXT NOT NULL DEFAULT 'user'");
+  ensureColumn(db, "sessions", "advisor_role", "advisor_role TEXT");
+  ensureColumn(db, "advisors", "texture_pack", "texture_pack TEXT");
+  _db = db;
+  return db;
+}
+
+// ../server/src/http.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
+import { dirname as dirname4, extname, join as join8, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { spawnSync } from "child_process";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+
+// ../server/src/util.ts
+import { createHash } from "crypto";
+import { basename } from "path";
+function hashCwd(cwd) {
+  return createHash("sha1").update(cwd).digest("hex").slice(0, 12);
+}
+function projectNameFromCwd(cwd) {
+  return basename(cwd) || cwd;
+}
+function now() {
+  return Date.now();
+}
+
+// ../server/src/state/projects.ts
+function rowToProject(row) {
+  return {
+    id: row.id,
+    cwd: row.cwd,
+    name: row.name,
+    firstSeenAt: row.first_seen_at,
+    lastActiveAt: row.last_active_at
+  };
+}
+function ensureProject(db, cwd) {
+  const id = hashCwd(cwd);
+  const ts2 = now();
+  const existing = db.prepare("SELECT * FROM projects WHERE id = ?").get(id);
+  if (existing) {
+    db.prepare("UPDATE projects SET last_active_at = ? WHERE id = ?").run(
+      ts2,
+      id
+    );
+    return rowToProject({ ...existing, last_active_at: ts2 });
+  }
+  const name = projectNameFromCwd(cwd);
+  db.prepare(
+    `INSERT INTO projects (id, cwd, name, first_seen_at, last_active_at)
+     VALUES (?, ?, ?, ?, ?)`
+  ).run(id, cwd, name, ts2, ts2);
+  return {
+    id,
+    cwd,
+    name,
+    firstSeenAt: ts2,
+    lastActiveAt: ts2
+  };
+}
+function listProjects(db) {
+  const rows = db.prepare("SELECT * FROM projects ORDER BY last_active_at DESC").all();
+  return rows.map(rowToProject);
+}
+
+// ../server/src/state/sessions.ts
+function rowToSession(row) {
+  return {
+    id: row.id,
+    pid: row.pid ?? 0,
+    cwd: row.cwd,
+    projectId: row.project_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    status: row.status,
+    model: row.model ?? "default",
+    origin: row.origin,
+    kind: row.kind ?? "user",
+    advisorRole: row.advisor_role ?? void 0,
+    parentSessionId: row.parent_session_id ?? void 0,
+    contextUsagePct: row.context_usage_pct,
+    currentMissionId: row.current_mission_id ?? void 0,
+    lastCompletedMissionId: row.last_completed_mission_id ?? void 0,
+    orbitSlot: row.orbit_slot,
+    name: row.name ?? void 0
+  };
+}
+function nextOrbitSlot(db, projectId) {
+  const row = db.prepare(
+    `SELECT COALESCE(MAX(orbit_slot), -1) AS max_slot
+       FROM sessions
+       WHERE project_id = ? AND parent_session_id IS NULL
+         AND status NOT IN ('terminated')`
+  ).get(projectId);
+  return (row.max_slot ?? -1) + 1;
+}
+function upsertSession(db, input) {
+  const ts2 = now();
+  const existing = db.prepare("SELECT * FROM sessions WHERE id = ?").get(input.id);
+  if (existing) {
+    db.prepare(
+      `UPDATE sessions
+       SET pid = ?, status = CASE WHEN status = 'terminated' THEN 'idle' ELSE status END,
+           updated_at = ?
+       WHERE id = ?`
+    ).run(input.pid, ts2, input.id);
+    return rowToSession({
+      ...existing,
+      pid: input.pid,
+      updated_at: ts2
+    });
+  }
+  const orbitSlot = input.parentSessionId ? 0 : nextOrbitSlot(db, input.projectId);
+  const status = "idle";
+  const kind = input.kind ?? "user";
+  db.prepare(
+    `INSERT INTO sessions (
+       id, pid, project_id, parent_session_id, origin, model, status,
+       context_usage_pct, orbit_slot, cwd, name, kind, advisor_role,
+       created_at, updated_at
+     )
+     VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?, NULL, ?, ?, ?, ?)`
+  ).run(
+    input.id,
+    input.pid,
+    input.projectId,
+    input.parentSessionId ?? null,
+    input.origin,
+    input.model ?? "default",
+    status,
+    orbitSlot,
+    input.cwd,
+    kind,
+    input.advisorRole ?? null,
+    ts2,
+    ts2
+  );
+  return {
+    id: input.id,
+    pid: input.pid,
+    cwd: input.cwd,
+    projectId: input.projectId,
+    createdAt: ts2,
+    updatedAt: ts2,
+    status,
+    model: input.model ?? "default",
+    origin: input.origin,
+    kind,
+    advisorRole: input.advisorRole,
+    parentSessionId: input.parentSessionId,
+    contextUsagePct: 0,
+    orbitSlot
+  };
+}
+function setSessionStatus(db, sessionId, status) {
+  const ts2 = now();
+  if (status === "terminated") {
+    db.prepare(
+      `UPDATE sessions SET status = ?, updated_at = ?, terminated_at = ? WHERE id = ?`
+    ).run(status, ts2, ts2, sessionId);
+  } else {
+    db.prepare(
+      `UPDATE sessions SET status = ?, updated_at = ? WHERE id = ?`
+    ).run(status, ts2, sessionId);
+  }
+  return getSession(db, sessionId);
+}
+function setSessionMission(db, sessionId, missionId) {
+  const ts2 = now();
+  db.prepare(
+    `UPDATE sessions SET current_mission_id = ?, updated_at = ? WHERE id = ?`
+  ).run(missionId, ts2, sessionId);
+  return getSession(db, sessionId);
+}
+function setSessionContextUsage(db, sessionId, pct) {
+  const clamped = Math.max(0, Math.min(100, pct));
+  const ts2 = now();
+  db.prepare(
+    `UPDATE sessions SET context_usage_pct = ?, updated_at = ? WHERE id = ?`
+  ).run(clamped, ts2, sessionId);
+  return getSession(db, sessionId);
+}
+function getSession(db, sessionId) {
+  const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId);
+  return row ? rowToSession(row) : null;
+}
+function listActiveSessions(db) {
+  const rows = db.prepare(
+    `SELECT * FROM sessions
+       WHERE status != 'terminated'
+       ORDER BY created_at ASC`
+  ).all();
+  return rows.map(rowToSession);
+}
+function listSessionsForProject(db, projectId) {
+  const rows = db.prepare(
+    `SELECT * FROM sessions
+       WHERE project_id = ? AND status != 'terminated'
+       ORDER BY created_at ASC`
+  ).all(projectId);
+  return rows.map(rowToSession);
+}
+
+// ../server/src/state/missions.ts
+import { nanoid } from "nanoid";
+function rowToMission(row) {
+  let filesTouched = [];
+  try {
+    filesTouched = JSON.parse(row.files_touched_json);
+  } catch {
+    filesTouched = [];
+  }
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    startedAt: row.started_at,
+    completedAt: row.completed_at ?? void 0,
+    prompt: row.prompt,
+    shortName: row.short_name ?? row.prompt.slice(0, 32),
+    longSummary: row.long_summary ?? void 0,
+    status: row.status,
+    metrics: {
+      durationMs: row.duration_ms ?? void 0,
+      totalTokens: row.total_tokens ?? void 0,
+      linesAdded: row.lines_added,
+      linesRemoved: row.lines_removed,
+      subagentCount: row.subagent_count,
+      toolCallCount: row.tool_call_count
+    },
+    filesTouched
+  };
+}
+function shortNameFromPrompt(prompt) {
+  const words = prompt.trim().split(/\s+/).slice(0, 3);
+  if (!words.length) return "New Mission";
+  return words.map(
+    (w) => w.replace(/[^a-zA-Z0-9-]/g, "").toLowerCase().replace(/^./, (c) => c.toUpperCase())
+  ).filter(Boolean).join(" ") || "New Mission";
+}
+function startMission(db, sessionId, prompt) {
+  const id = nanoid();
+  const ts2 = now();
+  const shortName = shortNameFromPrompt(prompt);
+  db.prepare(
+    `INSERT INTO missions (id, session_id, prompt, short_name, status, started_at, files_touched_json)
+     VALUES (?, ?, ?, ?, 'active', ?, '[]')`
+  ).run(id, sessionId, prompt, shortName, ts2);
+  return {
+    id,
+    sessionId,
+    startedAt: ts2,
+    prompt,
+    shortName,
+    status: "active",
+    metrics: { subagentCount: 0, toolCallCount: 0 },
+    filesTouched: []
+  };
+}
+function completeMission(db, missionId, status = "completed") {
+  const ts2 = now();
+  const row = db.prepare("SELECT * FROM missions WHERE id = ?").get(missionId);
+  if (!row) return null;
+  const durationMs = ts2 - row.started_at;
+  db.prepare(
+    `UPDATE missions
+     SET status = ?, completed_at = ?, duration_ms = ?
+     WHERE id = ?`
+  ).run(status, ts2, durationMs, missionId);
+  return getMission(db, missionId);
+}
+function bumpToolCallCount(db, missionId) {
+  db.prepare(
+    `UPDATE missions SET tool_call_count = tool_call_count + 1 WHERE id = ?`
+  ).run(missionId);
+}
+function bumpSubagentCount(db, missionId) {
+  db.prepare(
+    `UPDATE missions SET subagent_count = subagent_count + 1 WHERE id = ?`
+  ).run(missionId);
+}
+function addTouchedFile(db, missionId, filePath) {
+  const row = db.prepare("SELECT files_touched_json FROM missions WHERE id = ?").get(missionId);
+  if (!row) return;
+  let files = [];
+  try {
+    files = JSON.parse(row.files_touched_json);
+  } catch {
+    files = [];
+  }
+  if (!files.includes(filePath)) {
+    files.push(filePath);
+    db.prepare("UPDATE missions SET files_touched_json = ? WHERE id = ?").run(
+      JSON.stringify(files),
+      missionId
+    );
+  }
+}
+function getMission(db, missionId) {
+  const row = db.prepare("SELECT * FROM missions WHERE id = ?").get(missionId);
+  return row ? rowToMission(row) : null;
+}
+function listMissions(db, opts = {}) {
+  const limit = Math.min(opts.limit ?? 200, 1e3);
+  if (opts.sessionId) {
+    const rows2 = db.prepare(
+      `SELECT * FROM missions WHERE session_id = ? ORDER BY started_at DESC LIMIT ?`
+    ).all(opts.sessionId, limit);
+    return rows2.map(rowToMission);
+  }
+  if (opts.projectId) {
+    const rows2 = db.prepare(
+      `SELECT m.* FROM missions m
+         JOIN sessions s ON s.id = m.session_id
+         WHERE s.project_id = ?
+         ORDER BY m.started_at DESC LIMIT ?`
+    ).all(opts.projectId, limit);
+    return rows2.map(rowToMission);
+  }
+  const rows = db.prepare(`SELECT * FROM missions ORDER BY started_at DESC LIMIT ?`).all(limit);
+  return rows.map(rowToMission);
+}
+
+// ../server/src/state/timeline.ts
+function loadTimeline(db, opts = {}) {
+  const sinceMs = opts.sinceMs ?? 0;
+  const untilMs = opts.untilMs ?? Date.now();
+  const limit = Math.min(opts.limit ?? 5e3, 2e4);
+  const sessions = db.prepare(
+    `SELECT id, project_id, cwd, status, created_at, terminated_at
+       FROM sessions
+       WHERE created_at <= ?
+         AND (terminated_at IS NULL OR terminated_at >= ?)`
+  ).all(untilMs, sinceMs);
+  const missions = db.prepare(
+    `SELECT id, session_id, short_name, prompt, status, started_at, completed_at
+       FROM missions
+       WHERE started_at <= ?
+         AND (completed_at IS NULL OR completed_at >= ?)
+       ORDER BY started_at ASC
+       LIMIT ?`
+  ).all(untilMs, sinceMs, limit);
+  const toolCalls = db.prepare(
+    `SELECT session_id, tool, started_at
+       FROM tool_calls
+       WHERE started_at BETWEEN ? AND ?
+       ORDER BY started_at ASC
+       LIMIT ?`
+  ).all(sinceMs, untilMs, limit);
+  const sessionMeta = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    sessionMeta.set(s.id, { projectId: s.project_id, cwd: s.cwd });
+  }
+  const events = [];
+  for (const s of sessions) {
+    if (s.created_at >= sinceMs && s.created_at <= untilMs) {
+      events.push({
+        ts: s.created_at,
+        type: "session_started",
+        sessionId: s.id,
+        projectId: s.project_id,
+        cwd: s.cwd
+      });
+    }
+    if (s.terminated_at && s.terminated_at >= sinceMs && s.terminated_at <= untilMs) {
+      events.push({
+        ts: s.terminated_at,
+        type: "session_terminated",
+        sessionId: s.id,
+        projectId: s.project_id,
+        cwd: s.cwd
+      });
+    }
+  }
+  for (const m of missions) {
+    if (m.started_at >= sinceMs && m.started_at <= untilMs) {
+      const meta = sessionMeta.get(m.session_id);
+      events.push({
+        ts: m.started_at,
+        type: "mission_started",
+        sessionId: m.session_id,
+        projectId: meta?.projectId,
+        cwd: meta?.cwd,
+        missionId: m.id,
+        missionShortName: m.short_name ?? void 0,
+        missionPrompt: m.prompt
+      });
+    }
+    if (m.completed_at && m.completed_at >= sinceMs && m.completed_at <= untilMs) {
+      const meta = sessionMeta.get(m.session_id);
+      events.push({
+        ts: m.completed_at,
+        type: "mission_completed",
+        sessionId: m.session_id,
+        projectId: meta?.projectId,
+        cwd: meta?.cwd,
+        missionId: m.id,
+        missionShortName: m.short_name ?? void 0
+      });
+    }
+  }
+  for (const t of toolCalls) {
+    const meta = sessionMeta.get(t.session_id);
+    events.push({
+      ts: t.started_at,
+      type: "tool_call",
+      sessionId: t.session_id,
+      projectId: meta?.projectId,
+      cwd: meta?.cwd,
+      toolName: t.tool
+    });
+  }
+  events.sort((a, b) => a.ts - b.ts);
+  const capped = events.length > limit ? events.slice(events.length - limit) : events;
+  const earliest = capped.length ? capped[0].ts : sinceMs;
+  const latest = capped.length ? capped[capped.length - 1].ts : untilMs;
+  return { earliest, latest, events: capped };
+}
+
+// ../server/src/state/audit.ts
+import { nanoid as nanoid2 } from "nanoid";
+function rowToAuditEvent(row) {
+  let payload;
+  if (row.payload_json) {
+    try {
+      payload = JSON.parse(row.payload_json);
+    } catch {
+      payload = void 0;
+    }
+  }
+  return {
+    id: row.id,
+    ts: row.ts,
+    kind: row.kind,
+    sessionId: row.session_id ?? void 0,
+    advisorId: row.advisor_id ?? void 0,
+    projectId: row.project_id ?? void 0,
+    summary: row.summary,
+    payload
+  };
+}
+function recordAudit(db, input) {
+  const event = {
+    id: nanoid2(),
+    ts: Date.now(),
+    kind: input.kind,
+    sessionId: input.sessionId,
+    advisorId: input.advisorId,
+    projectId: input.projectId,
+    summary: input.summary,
+    payload: input.payload
+  };
+  db.prepare(
+    `INSERT INTO audit_events
+       (id, ts, kind, session_id, advisor_id, project_id, summary, payload_json)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    event.id,
+    event.ts,
+    event.kind,
+    event.sessionId ?? null,
+    event.advisorId ?? null,
+    event.projectId ?? null,
+    event.summary,
+    event.payload ? JSON.stringify(event.payload) : null
+  );
+  return event;
+}
+function listAudit(db, opts = {}) {
+  const limit = Math.min(opts.limit ?? 200, 1e3);
+  const where = [];
+  const params = [];
+  if (opts.sessionId) {
+    where.push("session_id = ?");
+    params.push(opts.sessionId);
+  }
+  if (opts.kind) {
+    where.push("kind = ?");
+    params.push(opts.kind);
+  }
+  if (typeof opts.since === "number") {
+    where.push("ts >= ?");
+    params.push(opts.since);
+  }
+  if (typeof opts.until === "number") {
+    where.push("ts <= ?");
+    params.push(opts.until);
+  }
+  const whereClause = where.length ? `WHERE ${where.join(" AND ")}` : "";
+  const rows = db.prepare(
+    `SELECT * FROM audit_events ${whereClause}
+       ORDER BY ts DESC
+       LIMIT ?`
+  ).all(...params, limit);
+  return rows.map(rowToAuditEvent);
+}
+
+// ../server/src/state/advisors.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname2, join as join6, resolve } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function findAgentsDir() {
+  if (process.env.SOLIX_AGENTS_DIR && existsSync4(process.env.SOLIX_AGENTS_DIR)) {
+    return process.env.SOLIX_AGENTS_DIR;
+  }
+  const here = dirname2(fileURLToPath2(import.meta.url));
+  const candidates = [
+    // Bundled npm package: agents/ ships next to the bundled JS file.
+    resolve(here, "agents"),
+    resolve(here, "..", "..", "..", "agents"),
+    resolve(here, "..", "..", "agents"),
+    resolve(here, "..", "agents"),
+    resolve(process.cwd(), "packages", "agents")
+  ];
+  for (const c of candidates) {
+    if (existsSync4(join6(c, "manifest.json"))) return c;
+  }
+  return candidates[0];
+}
+var AGENTS_DIR = findAgentsDir();
+function readManifest() {
+  const path = join6(AGENTS_DIR, "manifest.json");
+  if (!existsSync4(path)) {
+    return { version: 1, advisors: [] };
+  }
+  return JSON.parse(readFileSync3(path, "utf8"));
+}
+function rowToAdvisor(row) {
+  let requiredSkills = [];
+  try {
+    requiredSkills = JSON.parse(row.required_skills_json);
+  } catch {
+    requiredSkills = [];
+  }
+  return {
+    id: row.id,
+    role: row.role,
+    codename: row.codename,
+    name: row.name,
+    description: row.description,
+    glyph: row.glyph ?? "",
+    color: row.color ?? "#94a3b8",
+    defaultModel: row.default_model ?? "default",
+    agentMdPath: row.agent_md_path,
+    enabled: row.enabled === 1,
+    pinned: row.pinned === 1,
+    pinnedSessionId: row.pinned_session_id ?? void 0,
+    requiredSkills,
+    texturePack: row.texture_pack ?? void 0
+  };
+}
+function seedAdvisors(db) {
+  const manifest = readManifest();
+  const ts2 = now();
+  const insert = db.prepare(
+    `INSERT OR IGNORE INTO advisors
+       (id, role, codename, name, description, glyph, color, default_model,
+        agent_md_path, required_skills_json, enabled, pinned, texture_pack, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)`
+  );
+  const refresh = db.prepare(
+    `UPDATE advisors
+     SET role = ?, codename = ?, name = ?, description = ?, glyph = ?,
+         color = ?, default_model = ?, agent_md_path = ?,
+         required_skills_json = ?, texture_pack = ?, updated_at = ?
+     WHERE id = ?`
+  );
+  for (const a of manifest.advisors) {
+    const md = join6(AGENTS_DIR, a.agentMd);
+    insert.run(
+      a.id,
+      a.role,
+      a.codename,
+      a.name,
+      a.description,
+      a.glyph,
+      a.color,
+      a.defaultModel,
+      md,
+      JSON.stringify(a.requiredSkills),
+      a.enabledByDefault ? 1 : 0,
+      a.texturePack ?? null,
+      ts2
+    );
+    refresh.run(
+      a.role,
+      a.codename,
+      a.name,
+      a.description,
+      a.glyph,
+      a.color,
+      a.defaultModel,
+      md,
+      JSON.stringify(a.requiredSkills),
+      a.texturePack ?? null,
+      ts2,
+      a.id
+    );
+  }
+  return listAdvisors(db);
+}
+function listAdvisors(db) {
+  const rows = db.prepare(
+    "SELECT * FROM advisors ORDER BY enabled DESC, pinned DESC, codename ASC"
+  ).all();
+  return rows.map(rowToAdvisor);
+}
+function getAdvisor(db, id) {
+  const row = db.prepare("SELECT * FROM advisors WHERE id = ?").get(id);
+  return row ? rowToAdvisor(row) : null;
+}
+function setAdvisorEnabled(db, id, enabled) {
+  const ts2 = now();
+  db.prepare(
+    "UPDATE advisors SET enabled = ?, updated_at = ? WHERE id = ?"
+  ).run(enabled ? 1 : 0, ts2, id);
+  return getAdvisor(db, id);
+}
+function setAdvisorPinned(db, id, pinned, sessionId) {
+  const ts2 = now();
+  db.prepare(
+    "UPDATE advisors SET pinned = ?, pinned_session_id = ?, updated_at = ? WHERE id = ?"
+  ).run(pinned ? 1 : 0, sessionId ?? null, ts2, id);
+  return getAdvisor(db, id);
+}
+function readAdvisorAgentMd(advisor) {
+  if (!existsSync4(advisor.agentMdPath)) {
+    return "";
+  }
+  return readFileSync3(advisor.agentMdPath, "utf8");
+}
+
+// ../server/src/state/context.ts
+var MISSIONS_FOR_HANDOFF = 3;
+var DEFAULT_ASKS = {
+  pm: "Review the recent missions and propose 1\u20133 next features in priority order, with a one-line rationale each.",
+  builder: "Identify the smallest unfinished item from the recent missions and propose an implementation plan.",
+  ux: "Audit the most recent UI-affecting mission for visual polish opportunities.",
+  reviewer: "Review the diff of the most recently completed mission. Output: numbered findings with severity and proposed fix.",
+  security: "Audit the changes from the last 3 missions for security regressions, especially around hooks, settings.json, and child-process spawns.",
+  qa: "Identify the most recent untested change and propose the smallest test that would catch a regression in it.",
+  devrel: "Identify the most recent user-facing change and update the README accordingly.",
+  perf: "Profile the most recent change for hot-path allocations or bundle-size regressions.",
+  release: "Decide whether the recent missions justify a patch / minor / major bump and draft a one-paragraph changelog entry.",
+  curator: "Review skills installed in this project against missions performed; recommend additions or retirements."
+};
+function summarizeMission(m) {
+  const head = `- ${m.shortName}: ${m.longSummary ?? m.prompt.slice(0, 120)}`;
+  const meta = `  (status: ${m.status}, ${m.metrics.toolCallCount} tool calls, ${m.metrics.subagentCount} subagents)`;
+  const files = m.filesTouched.length > 0 ? `  files: ${m.filesTouched.slice(0, 5).join(", ")}${m.filesTouched.length > 5 ? ` (+${m.filesTouched.length - 5})` : ""}` : "";
+  return [head, meta, files].filter(Boolean).join("\n");
+}
+function contextBudgetNote(target) {
+  if (!target) return "";
+  const pct = target.contextUsagePct;
+  if (pct >= 90) {
+    return `
+
+\u26A0 CONTEXT NEAR LIMIT: target session is at ${pct.toFixed(0)}%. Suggest the user run /compact before deeper work.`;
+  }
+  if (pct >= 80) {
+    return `
+
+\u26A0 Context budget warning: target session is at ${pct.toFixed(0)}%. Keep your output tight.`;
+  }
+  return "";
+}
+function buildContextEnvelope(db, args) {
+  const advisor = getAdvisor(db, args.advisorId);
+  if (!advisor) return null;
+  const target = args.targetSessionId ? getSession(db, args.targetSessionId) : null;
+  const recent = target ? listMissions(db, {
+    sessionId: target.id,
+    limit: MISSIONS_FOR_HANDOFF
+  }) : [];
+  const role = advisor.role;
+  const defaultAsk = DEFAULT_ASKS[role] ?? `Act in your role as ${advisor.codename} (${advisor.name}).`;
+  const userAsk = args.userPrompt?.trim();
+  const lines = [];
+  lines.push(`You are ${advisor.codename} (${advisor.name}).`);
+  lines.push("");
+  lines.push(advisor.description);
+  if (target) {
+    lines.push("");
+    lines.push(`Active project: ${target.cwd}`);
+    lines.push(
+      `Focused planet: ${target.name ?? target.id.slice(0, 8)} (${target.model}, status=${target.status}, context=${target.contextUsagePct.toFixed(0)}%)`
+    );
+  }
+  if (recent.length > 0) {
+    lines.push("");
+    lines.push(`Recent missions on this planet (latest first):`);
+    for (const m of recent) {
+      lines.push(summarizeMission(m));
+    }
+  } else if (target) {
+    lines.push("");
+    lines.push("No prior missions on this planet \u2014 you are starting clean.");
+  } else {
+    lines.push("");
+    lines.push(
+      "No focused planet \u2014 operate at the project level using your role guidance."
+    );
+  }
+  lines.push("");
+  lines.push("Specific ask:");
+  lines.push(userAsk && userAsk.length > 0 ? userAsk : defaultAsk);
+  const tail = contextBudgetNote(target);
+  if (tail) lines.push(tail);
+  return {
+    advisorId: advisor.id,
+    advisorRole: advisor.role,
+    prompt: lines.join("\n"),
+    recentMissions: recent,
+    targetSession: target
+  };
+}
+
+// ../server/src/state/skills.ts
+import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
+import { dirname as dirname3, join as join7, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { homedir as homedir4 } from "os";
+function findSolixSkillsDir() {
+  const here = dirname3(fileURLToPath3(import.meta.url));
+  const candidates = [
+    resolve2(here, "..", "..", "..", "skills"),
+    resolve2(here, "..", "..", "skills"),
+    resolve2(process.cwd(), "packages", "skills")
+  ];
+  for (const c of candidates) {
+    if (existsSync5(c)) return c;
+  }
+  return candidates[0];
+}
+var SOLIX_SKILLS_DIR2 = findSolixSkillsDir();
+var ANTHROPIC_SKILLS_DIR = join7(homedir4(), ".claude", "skills");
+function parseSkillManifest(manifestPath, fallbackId) {
+  try {
+    const txt = readFileSync4(manifestPath, "utf8");
+    const match = txt.match(/^---\n([\s\S]*?)\n---/);
+    let name = fallbackId;
+    let description = "";
+    if (match) {
+      const fm = match[1] ?? "";
+      const nameMatch = fm.match(/^name:\s*(.+)$/m);
+      const descMatch = fm.match(/^description:\s*(.+)$/m);
+      if (nameMatch) name = nameMatch[1].trim();
+      if (descMatch) description = descMatch[1].trim();
+    }
+    return { id: fallbackId, name, description };
+  } catch {
+    return null;
+  }
+}
+function rowToSkill(row) {
+  let installed = [];
+  try {
+    installed = JSON.parse(row.installed_in_projects_json);
+  } catch {
+    installed = [];
+  }
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description ?? "",
+    source: row.source,
+    manifestPath: row.manifest_path,
+    installedInProjects: installed
+  };
+}
+function discoverSkills(db) {
+  const ts2 = now();
+  const upsert = db.prepare(
+    `INSERT INTO skills (id, name, description, source, manifest_path, installed_in_projects_json, updated_at)
+     VALUES (?, ?, ?, ?, ?, '[]', ?)
+     ON CONFLICT(id) DO UPDATE SET
+       name = excluded.name,
+       description = excluded.description,
+       source = excluded.source,
+       manifest_path = excluded.manifest_path,
+       updated_at = excluded.updated_at`
+  );
+  const sources = [
+    { dir: ANTHROPIC_SKILLS_DIR, source: "anthropic" },
+    { dir: SOLIX_SKILLS_DIR2, source: "solix" }
+  ];
+  for (const { dir, source } of sources) {
+    if (!existsSync5(dir)) continue;
+    for (const entry of readdirSync3(dir)) {
+      const full = join7(dir, entry);
+      let isDir = false;
+      try {
+        isDir = statSync3(full).isDirectory();
+      } catch {
+        continue;
+      }
+      if (!isDir) continue;
+      const manifestPath = join7(full, "SKILL.md");
+      if (!existsSync5(manifestPath)) continue;
+      const parsed = parseSkillManifest(manifestPath, entry);
+      if (!parsed) continue;
+      const id = `${source}:${parsed.id}`;
+      upsert.run(
+        id,
+        parsed.name,
+        parsed.description,
+        source,
+        manifestPath,
+        ts2
+      );
+    }
+  }
+  return listSkills(db);
+}
+function listSkills(db) {
+  const rows = db.prepare("SELECT * FROM skills ORDER BY source ASC, name ASC").all();
+  return rows.map(rowToSkill);
+}
+function getSkill(db, id) {
+  const row = db.prepare("SELECT * FROM skills WHERE id = ?").get(id);
+  return row ? rowToSkill(row) : null;
+}
+function readSkillManifest(skill) {
+  if (!existsSync5(skill.manifestPath)) return "";
+  return readFileSync4(skill.manifestPath, "utf8");
+}
+function recordSkillInstall(db, skillId, projectId) {
+  const skill = getSkill(db, skillId);
+  if (!skill) return null;
+  const projects = /* @__PURE__ */ new Set([...skill.installedInProjects, projectId]);
+  db.prepare(
+    "UPDATE skills SET installed_in_projects_json = ?, updated_at = ? WHERE id = ?"
+  ).run(JSON.stringify([...projects]), now(), skillId);
+  return getSkill(db, skillId);
+}
+
+// ../server/src/state/galaxy.ts
+import { nanoid as nanoid3 } from "nanoid";
+function exportManifest(db, opts = {}) {
+  const advisors2 = listAdvisors(db);
+  const skills2 = listSkills(db);
+  const projects = listProjects(db);
+  const manifestAdvisors = advisors2.filter((a) => a.enabled).map((a) => ({
+    role: a.id,
+    pinned: a.pinned,
+    model: a.defaultModel
+  })).sort((a, b) => a.role.localeCompare(b.role));
+  const manifestSkills = skills2.map((s) => ({ id: s.id, source: s.source })).sort((a, b) => a.id.localeCompare(b.id));
+  const manifestProjects = projects.map((p) => ({ name: p.name, cwd: p.cwd })).sort((a, b) => a.name.localeCompare(b.name));
+  return {
+    version: 1,
+    name: opts.name ?? "My Galaxy",
+    author: opts.author,
+    description: opts.description,
+    advisors: manifestAdvisors,
+    skills: manifestSkills,
+    projects: manifestProjects
+  };
+}
+function importManifest(db, manifest, sourceUrl) {
+  if (manifest.version !== 1) {
+    throw new Error(`Unsupported galaxy manifest version: ${manifest.version}`);
+  }
+  const enabledRoles = new Set(manifest.advisors.map((a) => a.role));
+  const allAdvisors = listAdvisors(db);
+  let enabled = 0;
+  let disabled = 0;
+  for (const a of allAdvisors) {
+    const shouldEnable = enabledRoles.has(a.id);
+    if (shouldEnable && !a.enabled) {
+      setAdvisorEnabled(db, a.id, true);
+      enabled++;
+    } else if (!shouldEnable && a.enabled) {
+      const isCore = ["compass", "forge", "lumen", "argus", "sentinel"].includes(
+        a.id
+      );
+      if (!isCore) {
+        setAdvisorEnabled(db, a.id, false);
+        disabled++;
+      }
+    }
+  }
+  db.prepare(
+    `INSERT INTO galaxy_imports (id, source_url, manifest_json, imported_at)
+     VALUES (?, ?, ?, ?)`
+  ).run(nanoid3(), sourceUrl ?? null, JSON.stringify(manifest), now());
+  return {
+    advisorsEnabled: enabled,
+    advisorsDisabled: disabled,
+    projectsHinted: manifest.projects.length
+  };
+}
+function listImportHistory(db) {
+  const rows = db.prepare(
+    "SELECT id, source_url, manifest_json, imported_at FROM galaxy_imports ORDER BY imported_at DESC LIMIT 20"
+  ).all();
+  return rows.map((r) => {
+    let name = "(unknown)";
+    try {
+      const m = JSON.parse(r.manifest_json);
+      name = m.name;
+    } catch {
+    }
+    return {
+      id: r.id,
+      sourceUrl: r.source_url ?? void 0,
+      importedAt: r.imported_at,
+      manifestName: name
+    };
+  });
+}
+function rowToVersion(row) {
+  let manifest;
+  try {
+    manifest = JSON.parse(row.manifest_json);
+  } catch {
+    manifest = {
+      version: 1,
+      name: row.name,
+      advisors: [],
+      skills: [],
+      projects: []
+    };
+  }
+  return {
+    id: row.id,
+    ts: row.ts,
+    ordinal: row.ordinal,
+    name: row.name,
+    author: row.author ?? void 0,
+    description: row.description ?? void 0,
+    manifest
+  };
+}
+function snapshotExport(db, manifest) {
+  const last = db.prepare(
+    "SELECT manifest_json, ordinal FROM galaxy_versions ORDER BY ordinal DESC LIMIT 1"
+  ).get();
+  if (last) {
+    const lastJson = last.manifest_json;
+    const newJson = JSON.stringify(manifest);
+    if (lastJson === newJson) {
+      const existing = db.prepare("SELECT * FROM galaxy_versions WHERE ordinal = ? LIMIT 1").get(last.ordinal);
+      return rowToVersion(existing);
+    }
+  }
+  const id = nanoid3();
+  const ts2 = now();
+  const ordinal = (last?.ordinal ?? 0) + 1;
+  db.prepare(
+    `INSERT INTO galaxy_versions (id, ts, ordinal, name, author, description, manifest_json)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    ts2,
+    ordinal,
+    manifest.name,
+    manifest.author ?? null,
+    manifest.description ?? null,
+    JSON.stringify(manifest)
+  );
+  return {
+    id,
+    ts: ts2,
+    ordinal,
+    name: manifest.name,
+    author: manifest.author,
+    description: manifest.description,
+    manifest
+  };
+}
+function listVersions(db, limit = 50) {
+  const rows = db.prepare(
+    "SELECT * FROM galaxy_versions ORDER BY ordinal DESC LIMIT ?"
+  ).all(Math.min(limit, 500));
+  return rows.map(rowToVersion);
+}
+function getVersion(db, id) {
+  const row = db.prepare("SELECT * FROM galaxy_versions WHERE id = ? LIMIT 1").get(id);
+  return row ? rowToVersion(row) : null;
+}
+
+// ../shared/src/galaxyDiff.ts
+function diffManifests(a, b) {
+  const advisorsA = new Map(a.advisors.map((x) => [x.role, x]));
+  const advisorsB = new Map(b.advisors.map((x) => [x.role, x]));
+  const advisorAdded = [...advisorsB.keys()].filter(
+    (k) => !advisorsA.has(k)
+  );
+  const advisorRemoved = [...advisorsA.keys()].filter(
+    (k) => !advisorsB.has(k)
+  );
+  const advisorPinChanged = [...advisorsB.keys()].filter((k) => advisorsA.has(k)).map((k) => ({
+    role: k,
+    from: advisorsA.get(k).pinned,
+    to: advisorsB.get(k).pinned
+  })).filter((c) => c.from !== c.to);
+  const skillsA = new Set(a.skills.map((s) => s.id));
+  const skillsB = new Set(b.skills.map((s) => s.id));
+  const skillAdded = [...skillsB].filter((id) => !skillsA.has(id));
+  const skillRemoved = [...skillsA].filter((id) => !skillsB.has(id));
+  const projectsA = new Set(a.projects.map((p) => p.name));
+  const projectsB = new Set(b.projects.map((p) => p.name));
+  const projectAdded = [...projectsB].filter((n) => !projectsA.has(n));
+  const projectRemoved = [...projectsA].filter((n) => !projectsB.has(n));
+  return {
+    advisors: {
+      added: advisorAdded.sort(),
+      removed: advisorRemoved.sort(),
+      pinChanged: advisorPinChanged.sort(
+        (x, y) => x.role.localeCompare(y.role)
+      )
+    },
+    skills: {
+      added: skillAdded.sort(),
+      removed: skillRemoved.sort()
+    },
+    projects: {
+      added: projectAdded.sort(),
+      removed: projectRemoved.sort()
+    }
+  };
+}
+
+// ../server/src/cloud.ts
+var RegistryClient = class {
+  constructor(baseUrl = process.env.SOLIX_REGISTRY_URL ?? "", apiKey = process.env.SOLIX_REGISTRY_KEY) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  baseUrl;
+  apiKey;
+  isConfigured() {
+    return Boolean(this.baseUrl);
+  }
+  async publish(slug, manifest) {
+    if (!this.isConfigured()) {
+      throw new Error(
+        "Registry URL not configured. Set SOLIX_REGISTRY_URL."
+      );
+    }
+    if (!this.apiKey) {
+      throw new Error(
+        "Registry API key required to publish. Set SOLIX_REGISTRY_KEY."
+      );
+    }
+    const url = `${this.baseUrl.replace(/\/$/, "")}/v1/galaxies/${encodeURIComponent(slug)}`;
+    const res = await fetch(url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.apiKey
+      },
+      body: JSON.stringify(manifest),
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Publish failed: HTTP ${res.status} ${text}`);
+    }
+    return await res.json();
+  }
+  async pull(slug) {
+    if (!this.isConfigured()) {
+      throw new Error(
+        "Registry URL not configured. Set SOLIX_REGISTRY_URL."
+      );
+    }
+    const url = `${this.baseUrl.replace(/\/$/, "")}/v1/galaxies/${encodeURIComponent(slug)}`;
+    const res = await fetch(url, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Pull failed: HTTP ${res.status} ${text}`);
+    }
+    const data = await res.json();
+    if ("manifest" in data && data.manifest) {
+      return data.manifest;
+    }
+    return data;
+  }
+  async listSlugs() {
+    if (!this.isConfigured()) return [];
+    const url = `${this.baseUrl.replace(/\/$/, "")}/v1/galaxies`;
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(5e3) });
+      if (!res.ok) return [];
+      const data = await res.json();
+      if (Array.isArray(data)) return data;
+      return data.slugs ?? [];
+    } catch {
+      return [];
+    }
+  }
+};
+
+// ../server/src/http.ts
+function createHttpApp(opts) {
+  const app = new Hono();
+  app.use("*", cors());
+  const registry = new RegistryClient();
+  app.get(
+    "/api/health",
+    (c) => c.json({
+      ok: true,
+      service: "solix",
+      version: "1.0.0",
+      ts: Date.now()
+    })
+  );
+  app.post("/events", async (c) => {
+    let body = null;
+    try {
+      body = await c.req.json();
+    } catch (err) {
+      console.warn("[events] bad JSON", err);
+      return c.json({ ok: true });
+    }
+    if (body && body.event) {
+      opts.router.handleHookEvent(body);
+    }
+    return c.json({ ok: true });
+  });
+  app.get("/api/projects", (c) => c.json(listProjects(opts.db)));
+  app.get("/api/projects/:id/sessions", (c) => {
+    const id = c.req.param("id");
+    return c.json(listSessionsForProject(opts.db, id));
+  });
+  app.get("/api/sessions/:id", (c) => {
+    const id = c.req.param("id");
+    const s = getSession(opts.db, id);
+    if (!s) return c.json({ error: "not found" }, 404);
+    return c.json(s);
+  });
+  app.post("/api/sessions/:id/permission", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.requestId)
+      return c.json({ error: "requestId required" }, 400);
+    const ok = opts.router.resolvePermission(
+      body.requestId,
+      Boolean(body.approved)
+    );
+    return c.json({ ok });
+  });
+  app.post("/api/sessions/:id/terminate", (c) => {
+    const id = c.req.param("id");
+    const s = setSessionStatus(opts.db, id, "terminated");
+    return c.json({ ok: Boolean(s) });
+  });
+  app.post("/api/sessions/:id/context", async (c) => {
+    const id = c.req.param("id");
+    const body = await c.req.json().catch(() => ({}));
+    if (typeof body.pct !== "number") {
+      return c.json({ error: "pct (number) required" }, 400);
+    }
+    opts.router.setContextUsage(id, body.pct);
+    return c.json({ ok: true });
+  });
+  app.get("/api/missions", (c) => {
+    const sessionId = c.req.query("sessionId");
+    const projectId = c.req.query("projectId");
+    const limitStr = c.req.query("limit");
+    const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+    return c.json(
+      listMissions(opts.db, {
+        sessionId,
+        projectId,
+        limit
+      })
+    );
+  });
+  app.get("/api/timeline", (c) => {
+    const sinceMsStr = c.req.query("sinceMs");
+    const untilMsStr = c.req.query("untilMs");
+    const limitStr = c.req.query("limit");
+    const sinceMs = sinceMsStr ? parseInt(sinceMsStr, 10) : Date.now() - 30 * 60 * 1e3;
+    const untilMs = untilMsStr ? parseInt(untilMsStr, 10) : Date.now();
+    const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+    return c.json(loadTimeline(opts.db, { sinceMs, untilMs, limit }));
+  });
+  app.get("/api/audit", (c) => {
+    const sessionId = c.req.query("sessionId") ?? void 0;
+    const kindStr = c.req.query("kind");
+    const sinceStr = c.req.query("since");
+    const untilStr = c.req.query("until");
+    const limitStr = c.req.query("limit");
+    return c.json(
+      listAudit(opts.db, {
+        sessionId,
+        kind: kindStr ? kindStr : void 0,
+        since: sinceStr ? parseInt(sinceStr, 10) : void 0,
+        until: untilStr ? parseInt(untilStr, 10) : void 0,
+        limit: limitStr ? parseInt(limitStr, 10) : void 0
+      })
+    );
+  });
+  app.get("/api/advisors", (c) => c.json(listAdvisors(opts.db)));
+  app.get("/api/advisors/:id", (c) => {
+    const a = getAdvisor(opts.db, c.req.param("id"));
+    if (!a) return c.json({ error: "not found" }, 404);
+    return c.json({ ...a, agentMd: readAdvisorAgentMd(a) });
+  });
+  app.post("/api/advisors/:id/enable", (c) => {
+    const a = setAdvisorEnabled(opts.db, c.req.param("id"), true);
+    return c.json({ ok: Boolean(a), advisor: a });
+  });
+  app.post("/api/advisors/:id/disable", (c) => {
+    const a = setAdvisorEnabled(opts.db, c.req.param("id"), false);
+    return c.json({ ok: Boolean(a), advisor: a });
+  });
+  app.post("/api/advisors/:id/pin", (c) => {
+    const ok = opts.router.pinAdvisor(c.req.param("id"));
+    return c.json({ ok });
+  });
+  app.post("/api/advisors/:id/unpin", (c) => {
+    const ok = opts.router.unpinAdvisor(c.req.param("id"));
+    return c.json({ ok });
+  });
+  app.get("/api/advisors/:id/preview", (c) => {
+    const id = c.req.param("id");
+    const targetSessionId = c.req.query("targetSessionId") ?? void 0;
+    const prompt = c.req.query("prompt") ?? void 0;
+    const env = buildContextEnvelope(opts.db, {
+      advisorId: id,
+      targetSessionId,
+      userPrompt: prompt
+    });
+    if (!env) return c.json({ error: "advisor not found" }, 404);
+    return c.json({
+      advisorId: env.advisorId,
+      role: env.advisorRole,
+      prompt: env.prompt,
+      recentMissionsCount: env.recentMissions.length,
+      targetSessionId: env.targetSession?.id ?? null,
+      contextUsagePct: env.targetSession?.contextUsagePct ?? null
+    });
+  });
+  app.post("/api/advisors/:id/invoke", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const result = opts.router.invokeAdvisor(
+      c.req.param("id"),
+      body.targetSessionId,
+      body.prompt
+    );
+    return c.json(result);
+  });
+  app.get("/api/skills", (c) => c.json(listSkills(opts.db)));
+  app.get("/api/skills/:id", (c) => {
+    const id = decodeURIComponent(c.req.param("id"));
+    const s = getSkill(opts.db, id);
+    if (!s) return c.json({ error: "not found" }, 404);
+    return c.json({ ...s, manifest: readSkillManifest(s) });
+  });
+  app.post("/api/skills/:id/install", async (c) => {
+    const id = decodeURIComponent(c.req.param("id"));
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.projectId)
+      return c.json({ error: "projectId required" }, 400);
+    const s = recordSkillInstall(opts.db, id, body.projectId);
+    return c.json({ ok: Boolean(s), skill: s });
+  });
+  app.get("/api/galaxy/export", (c) => {
+    const name = c.req.query("name") ?? void 0;
+    const author = c.req.query("author") ?? void 0;
+    const description = c.req.query("description") ?? void 0;
+    const preview = c.req.query("preview") === "1";
+    const manifest = exportManifest(opts.db, {
+      name,
+      author,
+      description
+    });
+    if (!preview) snapshotExport(opts.db, manifest);
+    return c.json(manifest);
+  });
+  app.get("/api/galaxy/versions", (c) => {
+    const limitStr = c.req.query("limit");
+    const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+    return c.json(listVersions(opts.db, limit));
+  });
+  app.get("/api/galaxy/versions/:id", (c) => {
+    const v = getVersion(opts.db, c.req.param("id"));
+    if (!v) return c.json({ error: "not found" }, 404);
+    return c.json(v);
+  });
+  app.get("/api/galaxy/diff", (c) => {
+    const fromId = c.req.query("from");
+    const toId = c.req.query("to");
+    if (!fromId || !toId) {
+      return c.json({ error: "from and to query params required" }, 400);
+    }
+    const from = getVersion(opts.db, fromId);
+    const to = getVersion(opts.db, toId);
+    if (!from || !to) return c.json({ error: "version not found" }, 404);
+    return c.json({
+      from: { id: from.id, ordinal: from.ordinal, ts: from.ts },
+      to: { id: to.id, ordinal: to.ordinal, ts: to.ts },
+      diff: diffManifests(from.manifest, to.manifest)
+    });
+  });
+  app.post("/api/galaxy/import", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "invalid JSON" }, 400);
+    }
+    let manifest;
+    let sourceUrl;
+    if ("url" in body && typeof body.url === "string") {
+      sourceUrl = body.url;
+      try {
+        const res = await fetch(body.url, {
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (!res.ok) {
+          return c.json(
+            { error: `fetch failed: HTTP ${res.status}` },
+            502
+          );
+        }
+        manifest = await res.json();
+      } catch (err) {
+        return c.json({ error: `fetch failed: ${String(err)}` }, 502);
+      }
+    } else {
+      manifest = body;
+    }
+    if (typeof manifest.version !== "number") {
+      return c.json({ error: "manifest missing version" }, 400);
+    }
+    try {
+      const result = importManifest(opts.db, manifest, sourceUrl);
+      opts.router.broadcastGalaxyImported(manifest);
+      return c.json({ ok: true, ...result });
+    } catch (err) {
+      return c.json({ error: String(err) }, 400);
+    }
+  });
+  app.get("/api/galaxy/imports", (c) => c.json(listImportHistory(opts.db)));
+  let preflightCache = null;
+  app.get("/api/system/preflight", (c) => {
+    if (preflightCache) return c.json(preflightCache);
+    try {
+      const res = spawnSync("claude", ["--version"], {
+        timeout: 2e3,
+        encoding: "utf8"
+      });
+      if (res.status === 0) {
+        preflightCache = {
+          claudeAvailable: true,
+          version: (res.stdout ?? "").trim() || void 0
+        };
+      } else {
+        preflightCache = { claudeAvailable: false };
+      }
+    } catch {
+      preflightCache = { claudeAvailable: false };
+    }
+    return c.json(preflightCache);
+  });
+  const webDist = findWebDist();
+  if (webDist) {
+    app.get("*", (c) => {
+      const url = new URL(c.req.url);
+      if (url.pathname.startsWith("/api/") || url.pathname.startsWith("/events") || url.pathname.startsWith("/ws")) {
+        return c.notFound();
+      }
+      const safe = url.pathname.replace(/\.\.+/g, ".");
+      const candidate = join8(webDist, safe === "/" ? "index.html" : safe);
+      let filePath = candidate;
+      try {
+        if (!existsSync6(filePath) || statSync4(filePath).isDirectory()) {
+          filePath = join8(webDist, "index.html");
+        }
+      } catch {
+        filePath = join8(webDist, "index.html");
+      }
+      if (!existsSync6(filePath)) return c.notFound();
+      const data = readFileSync5(filePath);
+      return new Response(data, {
+        headers: { "Content-Type": mimeFor(filePath) }
+      });
+    });
+  }
+  app.get(
+    "/api/galaxy/registry/status",
+    (c) => c.json({
+      configured: registry.isConfigured(),
+      url: process.env.SOLIX_REGISTRY_URL ?? null
+    })
+  );
+  app.get("/api/galaxy/registry", async (c) => {
+    const slugs = await registry.listSlugs();
+    return c.json({ slugs });
+  });
+  app.get("/api/galaxy/registry/:slug", async (c) => {
+    const slug = c.req.param("slug");
+    try {
+      const manifest = await registry.pull(slug);
+      return c.json(manifest);
+    } catch (err) {
+      return c.json({ error: String(err) }, 502);
+    }
+  });
+  app.post("/api/galaxy/registry/:slug/install", async (c) => {
+    const slug = c.req.param("slug");
+    try {
+      const manifest = await registry.pull(slug);
+      const result = importManifest(opts.db, manifest, `registry:${slug}`);
+      opts.router.broadcastGalaxyImported(manifest);
+      return c.json({ ok: true, ...result });
+    } catch (err) {
+      return c.json({ error: String(err) }, 502);
+    }
+  });
+  app.post("/api/galaxy/publish", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.slug) {
+      return c.json({ error: "slug required" }, 400);
+    }
+    const manifest = exportManifest(opts.db, {
+      name: body.name,
+      author: body.author,
+      description: body.description
+    });
+    try {
+      const published = await registry.publish(body.slug, manifest);
+      return c.json({ ok: true, ...published });
+    } catch (err) {
+      return c.json({ error: String(err) }, 502);
+    }
+  });
+  return app;
+}
+function findWebDist() {
+  if (process.env.SOLIX_WEB_DIST) {
+    return existsSync6(process.env.SOLIX_WEB_DIST) ? process.env.SOLIX_WEB_DIST : null;
+  }
+  const here = dirname4(fileURLToPath4(import.meta.url));
+  const candidates = [
+    // Bundled npm package: web/ ships next to the bundled JS file.
+    resolve3(here, "web"),
+    // Monorepo: server's compiled output is at packages/server/dist.
+    resolve3(here, "..", "..", "web", "dist"),
+    resolve3(here, "..", "..", "..", "web", "dist"),
+    resolve3(here, "..", "..", "..", "packages", "web", "dist"),
+    resolve3(process.cwd(), "packages", "web", "dist")
+  ];
+  for (const c of candidates) {
+    if (existsSync6(join8(c, "index.html"))) return c;
+  }
+  return null;
+}
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".map": "application/json"
+};
+function mimeFor(filePath) {
+  return MIME[extname(filePath).toLowerCase()] ?? "application/octet-stream";
+}
+
+// ../server/src/launcher.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import { nanoid as nanoid4 } from "nanoid";
+var FAKE_CLAUDE = process.env.SOLIX_FAKE_CLAUDE === "1";
+var Launcher = class {
+  constructor(db, broadcaster) {
+    this.db = db;
+    this.broadcaster = broadcaster;
+  }
+  db;
+  broadcaster;
+  byPid = /* @__PURE__ */ new Map();
+  byAdvisor = /* @__PURE__ */ new Map();
+  // Sessions that were spawned by the UI's "+ Task" button. Keyed by the
+  // sessionId we synthesize at launch (not Claude's session_id, which arrives
+  // via the SessionStart hook later).
+  internalTasks = /* @__PURE__ */ new Map();
+  /** Returns the advisor role bound to a given pid, if any. */
+  advisorRoleForPid(pid) {
+    return this.byPid.get(pid)?.advisorId;
+  }
+  /**
+   * Pin (spawn) an advisor as an always-on Claude Code session.
+   * Returns true if the spawn succeeded (or a synthetic session was created).
+   */
+  pin(advisorId, cwd) {
+    if (this.byAdvisor.has(advisorId)) return true;
+    const advisor = getAdvisor(this.db, advisorId);
+    if (!advisor) return false;
+    if (FAKE_CLAUDE) {
+      return this.pinSynthetic(advisor.id, advisor.codename, cwd);
+    }
+    try {
+      const child = spawn(
+        "claude",
+        ["--agent", advisor.id, "--no-tty"],
+        {
+          cwd,
+          stdio: ["pipe", "pipe", "pipe"],
+          detached: false
+        }
+      );
+      const pid = child.pid;
+      if (!pid) {
+        this.broadcaster.broadcast({
+          type: "toast",
+          level: "error",
+          message: `Could not spawn claude for ${advisor.codename}`
+        });
+        return false;
+      }
+      const record = { advisorId, pid, child };
+      this.byPid.set(pid, record);
+      this.byAdvisor.set(advisorId, record);
+      setAdvisorPinned(this.db, advisorId, true);
+      child.on("exit", () => {
+        this.cleanup(advisorId, pid);
+      });
+      child.on("error", (err) => {
+        console.warn(`[launcher] ${advisorId} error:`, err.message);
+        this.broadcaster.broadcast({
+          type: "toast",
+          level: "warn",
+          message: `${advisor.codename} exited (${err.message})`
+        });
+        this.cleanup(advisorId, pid);
+      });
+      return true;
+    } catch (err) {
+      console.warn(`[launcher] spawn failed for ${advisorId}:`, err);
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "warn",
+        message: `claude binary not found \u2014 pinned ${advisor.codename} as synthetic`
+      });
+      return this.pinSynthetic(advisor.id, advisor.codename, cwd);
+    }
+  }
+  pinSynthetic(advisorId, codename, cwd) {
+    const project = ensureProject(this.db, cwd);
+    const sessionId = `advisor-${advisorId}-${nanoid4(6)}`;
+    const fakePid = 1e5 + Math.floor(Math.random() * 1e5);
+    const session = upsertSession(this.db, {
+      id: sessionId,
+      pid: fakePid,
+      projectId: project.id,
+      cwd,
+      origin: "internal",
+      kind: "advisor",
+      advisorRole: advisorId
+    });
+    setSessionStatus(this.db, sessionId, "idle");
+    setAdvisorPinned(this.db, advisorId, true, sessionId);
+    const record = {
+      advisorId,
+      pid: fakePid,
+      syntheticSessionId: sessionId
+    };
+    this.byPid.set(fakePid, record);
+    this.byAdvisor.set(advisorId, record);
+    this.broadcaster.broadcast({ type: "session_upsert", session });
+    this.broadcaster.broadcast({
+      type: "toast",
+      level: "info",
+      message: `${codename} pinned (always-on)`
+    });
+    return true;
+  }
+  unpin(advisorId) {
+    const record = this.byAdvisor.get(advisorId);
+    if (!record) {
+      setAdvisorPinned(this.db, advisorId, false);
+      return true;
+    }
+    if (record.child) {
+      try {
+        record.child.kill("SIGTERM");
+      } catch (err) {
+        console.warn(`[launcher] kill failed for ${advisorId}:`, err);
+      }
+    }
+    this.cleanup(advisorId, record.pid);
+    return true;
+  }
+  cleanup(advisorId, pid) {
+    const record = this.byAdvisor.get(advisorId);
+    this.byAdvisor.delete(advisorId);
+    this.byPid.delete(pid);
+    setAdvisorPinned(this.db, advisorId, false);
+    if (record?.syntheticSessionId) {
+      setSessionStatus(this.db, record.syntheticSessionId, "terminated");
+      this.broadcaster.broadcast({
+        type: "session_remove",
+        sessionId: record.syntheticSessionId
+      });
+    }
+    const advisor = getAdvisor(this.db, advisorId);
+    if (advisor) {
+      this.broadcaster.broadcast({ type: "advisor_upsert", advisor });
+    }
+  }
+  shutdownAll() {
+    for (const advisorId of [...this.byAdvisor.keys()]) {
+      this.unpin(advisorId);
+    }
+  }
+  /**
+   * Spawn a fresh `claude --print` task in the given cwd. Hooks fire as
+   * usual so the planet appears and animates; when the process exits, the
+   * captured stdout becomes a final assistant message in the chat.
+   *
+   * In FAKE_CLAUDE dev mode the task is synthesized so the visuals work
+   * without a real claude binary on PATH.
+   */
+  launch(opts) {
+    if (!opts.initialPrompt.trim()) return { ok: false };
+    if (FAKE_CLAUDE) {
+      return this.launchSynthetic(opts);
+    }
+    if (!existsSync7(opts.cwd)) {
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "error",
+        message: `Launch failed: cwd does not exist (${opts.cwd})`
+      });
+      return { ok: false };
+    }
+    const args = ["--print"];
+    if (opts.model) args.push("--model", String(opts.model));
+    args.push(opts.initialPrompt);
+    const sessionId = `task-${nanoid4(8)}`;
+    return this.spawnPrint({
+      sessionId,
+      cwd: opts.cwd,
+      args,
+      isFollowUp: false
+    });
+  }
+  sendPromptToInternal(sessionId, text) {
+    if (!text.trim()) return false;
+    const session = this.db.prepare(
+      "SELECT cwd, origin FROM sessions WHERE id = ? LIMIT 1"
+    ).get(sessionId);
+    if (!session?.cwd) {
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "warn",
+        message: `Cannot send prompt: session not found`
+      });
+      return false;
+    }
+    if (session.origin !== "internal") {
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "warn",
+        message: `Cannot send prompt: external session \u2014 type in your terminal`
+      });
+      return false;
+    }
+    if (FAKE_CLAUDE) {
+      this.broadcaster.broadcast({
+        type: "chat_delta",
+        sessionId,
+        delta: {
+          messageId: `fake-a-${Date.now()}`,
+          role: "assistant",
+          content: `(SOLIX_FAKE_CLAUDE=1) Pretending to run: ${text.slice(0, 200)}`,
+          ts: Date.now(),
+          done: true
+        }
+      });
+      return true;
+    }
+    const args = ["--print", "--continue", text];
+    return this.spawnPrint({
+      sessionId,
+      cwd: session.cwd,
+      args,
+      isFollowUp: true
+    }).ok;
+  }
+  spawnPrint(opts) {
+    let child;
+    try {
+      child = spawn("claude", opts.args, {
+        cwd: opts.cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false
+      });
+    } catch (err) {
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "error",
+        message: `claude binary not found \u2014 is Claude Code installed?`
+      });
+      console.warn("[launcher] spawn failed", err);
+      return { ok: false };
+    }
+    const pid = child.pid ?? 0;
+    if (!opts.isFollowUp) {
+      this.internalTasks.set(opts.sessionId, { cwd: opts.cwd });
+    }
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.setEncoding("utf8").on("data", (c) => stdout += c);
+    child.stderr?.setEncoding("utf8").on("data", (c) => stderr += c);
+    this.broadcaster.broadcast({
+      type: "toast",
+      level: "info",
+      message: `Launched task in ${opts.cwd} (pid ${pid})`
+    });
+    child.on("exit", (code) => {
+      const text = stdout.trim();
+      if (text) {
+        this.broadcaster.broadcast({
+          type: "chat_delta",
+          sessionId: opts.sessionId,
+          delta: {
+            messageId: `task-${opts.sessionId}-${Date.now()}`,
+            role: "assistant",
+            content: text,
+            ts: Date.now(),
+            done: true
+          }
+        });
+      }
+      if (code !== 0) {
+        this.broadcaster.broadcast({
+          type: "toast",
+          level: "warn",
+          message: `Task exited ${code}${stderr ? `: ${stderr.slice(0, 120)}` : ""}`
+        });
+      }
+    });
+    child.on("error", (err) => {
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "error",
+        message: `Task error: ${err.message}`
+      });
+    });
+    return { ok: true, sessionId: opts.sessionId };
+  }
+  launchSynthetic(opts) {
+    const project = ensureProject(this.db, opts.cwd);
+    const sessionId = `task-${nanoid4(8)}`;
+    const fakePid = 2e5 + Math.floor(Math.random() * 1e5);
+    upsertSession(this.db, {
+      id: sessionId,
+      pid: fakePid,
+      projectId: project.id,
+      cwd: opts.cwd,
+      origin: "internal",
+      model: opts.model ?? "sonnet"
+    });
+    const active = setSessionStatus(this.db, sessionId, "active");
+    if (active)
+      this.broadcaster.broadcast({ type: "session_upsert", session: active });
+    this.broadcaster.broadcast({
+      type: "chat_delta",
+      sessionId,
+      delta: {
+        messageId: `u-${sessionId}`,
+        role: "user",
+        content: opts.initialPrompt,
+        ts: Date.now(),
+        done: true
+      }
+    });
+    setTimeout(() => {
+      this.broadcaster.broadcast({
+        type: "chat_delta",
+        sessionId,
+        delta: {
+          messageId: `a-${sessionId}`,
+          role: "assistant",
+          content: `(SOLIX_FAKE_CLAUDE=1) Synthetic task complete. In real mode, Solix would have spawned \`claude --print\` at ${opts.cwd}.`,
+          ts: Date.now(),
+          done: true
+        }
+      });
+      const idle = setSessionStatus(this.db, sessionId, "idle");
+      if (idle)
+        this.broadcaster.broadcast({ type: "session_upsert", session: idle });
+    }, 600);
+    return { ok: true, sessionId };
+  }
+};
+
+// ../server/src/router.ts
+import { nanoid as nanoid6 } from "nanoid";
+
+// ../server/src/state/toolcalls.ts
+import { nanoid as nanoid5 } from "nanoid";
+function recordToolCall(db, input) {
+  const id = nanoid5();
+  const ts2 = now();
+  const status = input.status ?? "running";
+  db.prepare(
+    `INSERT INTO tool_calls (id, session_id, mission_id, tool, args_json, status, started_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    input.sessionId,
+    input.missionId ?? null,
+    input.tool,
+    JSON.stringify(input.args ?? {}),
+    status,
+    ts2
+  );
+  return {
+    id,
+    sessionId: input.sessionId,
+    missionId: input.missionId,
+    tool: input.tool,
+    args: input.args ?? {},
+    startedAt: ts2,
+    status
+  };
+}
+
+// ../server/src/router.ts
+var EventRouter = class {
+  constructor(db, broadcaster, launcher, transcripts) {
+    this.db = db;
+    this.broadcaster = broadcaster;
+    this.launcher = launcher;
+    this.transcripts = transcripts;
+  }
+  db;
+  broadcaster;
+  launcher;
+  transcripts;
+  permissions = /* @__PURE__ */ new Map();
+  setLauncher(launcher) {
+    this.launcher = launcher;
+  }
+  handleHookEvent(event) {
+    try {
+      switch (event.event) {
+        case "session_start":
+          this.onSessionStart(event);
+          break;
+        case "user_prompt_submit":
+          this.onUserPromptSubmit(event);
+          break;
+        case "stop":
+          this.onStop(event);
+          break;
+        case "subagent_stop":
+          this.onSubagentStop(event);
+          break;
+        case "pre_tool_task":
+          this.onPreToolTask(event);
+          break;
+        case "pre_tool_file":
+          this.onPreToolFile(event);
+          break;
+        case "pre_tool_bash":
+          this.onPreToolBash(event);
+          break;
+        case "post_tool":
+          this.onPostTool(event);
+          break;
+        case "notification":
+          this.onNotification(event);
+          break;
+        default:
+          console.warn("[router] unknown event", event);
+      }
+    } catch (err) {
+      console.error("[router] error handling event", event.event, err);
+    }
+  }
+  extractSessionId(event) {
+    const p = event.payload;
+    if (typeof p.session_id === "string") return p.session_id;
+    if (typeof p.sessionId === "string") return p.sessionId;
+    return `pid-${event.pid}`;
+  }
+  extractParentSessionId(event) {
+    const p = event.payload;
+    if (typeof p.parent_session_id === "string") return p.parent_session_id;
+    if (typeof p.parentSessionId === "string") return p.parentSessionId;
+    return void 0;
+  }
+  extractModel(event) {
+    const p = event.payload;
+    const m = p.model;
+    if (typeof m === "string") return m;
+    return "default";
+  }
+  onSessionStart(event) {
+    const project = ensureProject(this.db, event.cwd);
+    const sessionId = this.extractSessionId(event);
+    const advisorRole = this.launcher?.advisorRoleForPid(event.pid);
+    const session = upsertSession(this.db, {
+      id: sessionId,
+      pid: event.pid,
+      projectId: project.id,
+      cwd: event.cwd,
+      origin: event.payload.origin === "internal" ? "internal" : advisorRole ? "internal" : "external",
+      model: this.extractModel(event),
+      parentSessionId: this.extractParentSessionId(event),
+      kind: advisorRole ? "advisor" : "user",
+      advisorRole
+    });
+    this.broadcaster.broadcast({ type: "session_upsert", session });
+    if (!session.parentSessionId) {
+      this.transcripts?.startWatching(sessionId, event.cwd);
+    }
+  }
+  onUserPromptSubmit(event) {
+    const sessionId = this.extractSessionId(event);
+    const p = event.payload;
+    const prompt = typeof p.prompt === "string" ? p.prompt : "untitled prompt";
+    let session = getSession(this.db, sessionId);
+    if (!session) {
+      const project = ensureProject(this.db, event.cwd);
+      session = upsertSession(this.db, {
+        id: sessionId,
+        pid: event.pid,
+        projectId: project.id,
+        cwd: event.cwd,
+        origin: "external",
+        model: this.extractModel(event)
+      });
+    }
+    const mission = startMission(this.db, sessionId, prompt);
+    const updated = setSessionMission(this.db, sessionId, mission.id);
+    const active = updated ? setSessionStatus(this.db, sessionId, "active") : null;
+    this.broadcaster.broadcast({ type: "mission_upsert", mission });
+    if (active) {
+      this.broadcaster.broadcast({ type: "session_upsert", session: active });
+    }
+  }
+  onStop(event) {
+    const sessionId = this.extractSessionId(event);
+    const session = getSession(this.db, sessionId);
+    if (!session) return;
+    if (session.currentMissionId) {
+      const mission = completeMission(
+        this.db,
+        session.currentMissionId,
+        "completed"
+      );
+      if (mission) {
+        this.broadcaster.broadcast({ type: "mission_upsert", mission });
+      }
+    }
+    const updated = setSessionMission(this.db, sessionId, null);
+    const idle = updated ? setSessionStatus(this.db, sessionId, "idle") : null;
+    if (idle) {
+      this.broadcaster.broadcast({ type: "session_upsert", session: idle });
+    }
+  }
+  onSubagentStop(event) {
+    const subSessionId = this.extractSessionId(event);
+    const session = getSession(this.db, subSessionId);
+    if (!session) return;
+    const terminated = setSessionStatus(this.db, subSessionId, "terminated");
+    if (terminated) {
+      this.broadcaster.broadcast({
+        type: "session_remove",
+        sessionId: subSessionId
+      });
+    }
+  }
+  onPreToolTask(event) {
+    const parentSessionId = this.extractSessionId(event);
+    const parent = getSession(this.db, parentSessionId);
+    if (!parent) return;
+    const subId = nanoid6();
+    const sub = upsertSession(this.db, {
+      id: subId,
+      pid: event.pid,
+      projectId: parent.projectId,
+      cwd: event.cwd,
+      origin: parent.origin,
+      model: parent.model,
+      parentSessionId
+    });
+    const active = setSessionStatus(this.db, subId, "active");
+    if (parent.currentMissionId) {
+      bumpSubagentCount(this.db, parent.currentMissionId);
+      const mission = getMission(this.db, parent.currentMissionId);
+      if (mission)
+        this.broadcaster.broadcast({ type: "mission_upsert", mission });
+    }
+    this.broadcaster.broadcast({
+      type: "session_upsert",
+      session: active ?? sub
+    });
+  }
+  onPreToolFile(event) {
+    const sessionId = this.extractSessionId(event);
+    const session = getSession(this.db, sessionId);
+    if (!session) return;
+    const p = event.payload;
+    const tool = typeof p.tool_name === "string" ? p.tool_name : "File";
+    const filePath = typeof p.file_path === "string" ? p.file_path : typeof p.tool_input?.file_path === "string" ? p.tool_input.file_path : "";
+    const toolCall = recordToolCall(this.db, {
+      sessionId,
+      missionId: session.currentMissionId,
+      tool,
+      args: { file_path: filePath }
+    });
+    if (session.currentMissionId && filePath) {
+      addTouchedFile(this.db, session.currentMissionId, filePath);
+    }
+    this.broadcaster.broadcast({ type: "tool_call", toolCall });
+  }
+  onPreToolBash(event) {
+    const sessionId = this.extractSessionId(event);
+    const session = getSession(this.db, sessionId);
+    if (!session) return;
+    const p = event.payload;
+    const command = typeof p.command === "string" ? p.command : typeof p.tool_input?.command === "string" ? p.tool_input.command : "";
+    const toolCall = recordToolCall(this.db, {
+      sessionId,
+      missionId: session.currentMissionId,
+      tool: "Bash",
+      args: { command }
+    });
+    this.broadcaster.broadcast({ type: "tool_call", toolCall });
+  }
+  onPostTool(event) {
+    const sessionId = this.extractSessionId(event);
+    const session = getSession(this.db, sessionId);
+    if (!session?.currentMissionId) return;
+    bumpToolCallCount(this.db, session.currentMissionId);
+    const mission = getMission(this.db, session.currentMissionId);
+    if (mission)
+      this.broadcaster.broadcast({ type: "mission_upsert", mission });
+  }
+  onNotification(event) {
+    const sessionId = this.extractSessionId(event);
+    const p = event.payload;
+    const message = typeof p.message === "string" ? p.message : "Permission requested";
+    const tool = typeof p.tool_name === "string" ? p.tool_name : "unknown";
+    const requestId = nanoid6();
+    this.permissions.set(requestId, {
+      requestId,
+      sessionId,
+      tool,
+      args: p.tool_input ?? {},
+      createdAt: Date.now()
+    });
+    const updated = setSessionStatus(this.db, sessionId, "awaiting_permission");
+    if (updated) {
+      this.broadcaster.broadcast({
+        type: "session_upsert",
+        session: updated
+      });
+    }
+    this.broadcaster.broadcast({
+      type: "permission_request",
+      sessionId,
+      tool,
+      args: p.tool_input ?? {},
+      requestId
+    });
+    this.broadcaster.broadcast({
+      type: "toast",
+      level: "warn",
+      message: `Permission requested: ${message}`
+    });
+  }
+  invokeAdvisor(advisorId, targetSessionId, prompt) {
+    const advisor = getAdvisor(this.db, advisorId);
+    if (!advisor) return { ok: false };
+    const envelope = buildContextEnvelope(this.db, {
+      advisorId,
+      targetSessionId,
+      userPrompt: prompt
+    });
+    if (!envelope) return { ok: false };
+    const target = envelope.targetSession;
+    const targetLabel = target ? `${target.name ?? target.id.slice(0, 8)}` : "project level";
+    this.broadcaster.broadcast({
+      type: "toast",
+      level: "info",
+      message: `Invoke ${advisor.codename} \u2192 ${targetLabel} \xB7 ${envelope.recentMissions.length} mission(s) in envelope`
+    });
+    recordAudit(this.db, {
+      kind: "advisor_invoked",
+      advisorId,
+      sessionId: target?.id,
+      projectId: target?.projectId,
+      summary: `Invoked ${advisor.codename} \u2192 ${targetLabel}`,
+      payload: { prompt, missionsInEnvelope: envelope.recentMissions.length }
+    });
+    return { ok: true, envelope: envelope.prompt };
+  }
+  pinAdvisor(advisorId, cwd = process.cwd()) {
+    if (!this.launcher) {
+      const advisor2 = setAdvisorPinned(this.db, advisorId, true);
+      if (!advisor2) return false;
+      this.broadcaster.broadcast({ type: "advisor_upsert", advisor: advisor2 });
+      recordAudit(this.db, {
+        kind: "advisor_pinned",
+        advisorId,
+        summary: `Pinned ${advisor2.codename}`
+      });
+      return true;
+    }
+    const ok = this.launcher.pin(advisorId, cwd);
+    const advisor = getAdvisor(this.db, advisorId);
+    if (advisor) {
+      this.broadcaster.broadcast({ type: "advisor_upsert", advisor });
+      if (ok) {
+        recordAudit(this.db, {
+          kind: "advisor_pinned",
+          advisorId,
+          summary: `Pinned ${advisor.codename} in ${cwd}`
+        });
+      }
+    }
+    return ok;
+  }
+  unpinAdvisor(advisorId) {
+    if (this.launcher) {
+      this.launcher.unpin(advisorId);
+    } else {
+      setAdvisorPinned(this.db, advisorId, false);
+    }
+    const advisor = getAdvisor(this.db, advisorId);
+    if (advisor) {
+      this.broadcaster.broadcast({ type: "advisor_upsert", advisor });
+      recordAudit(this.db, {
+        kind: "advisor_unpinned",
+        advisorId,
+        summary: `Unpinned ${advisor.codename}`
+      });
+    }
+    return true;
+  }
+  resolvePermission(requestId, approved) {
+    const pending = this.permissions.get(requestId);
+    if (!pending) return false;
+    this.permissions.delete(requestId);
+    const status = approved ? "active" : "idle";
+    const session = setSessionStatus(this.db, pending.sessionId, status);
+    if (session)
+      this.broadcaster.broadcast({ type: "session_upsert", session });
+    const argSummary = (() => {
+      const k = Object.keys(pending.args)[0];
+      if (!k) return "";
+      const v = pending.args[k];
+      const s = typeof v === "string" ? v : JSON.stringify(v);
+      return `: ${s.length > 80 ? s.slice(0, 80) + "\u2026" : s}`;
+    })();
+    recordAudit(this.db, {
+      kind: approved ? "permission_approved" : "permission_denied",
+      sessionId: pending.sessionId,
+      projectId: session?.projectId,
+      summary: `${approved ? "Approved" : "Denied"} ${pending.tool} for ${session?.name ?? pending.sessionId.slice(0, 8)}${argSummary}`,
+      payload: { tool: pending.tool, args: pending.args }
+    });
+    return true;
+  }
+  launchInternalSession(opts) {
+    if (!this.launcher) return { ok: false };
+    if (!opts.initialPrompt?.trim()) {
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "warn",
+        message: "Launch needs an initial prompt"
+      });
+      return { ok: false };
+    }
+    return this.launcher.launch({
+      cwd: opts.cwd,
+      model: opts.model,
+      initialPrompt: opts.initialPrompt
+    });
+  }
+  sendPromptToSession(sessionId, text) {
+    if (!this.launcher) return false;
+    return this.launcher.sendPromptToInternal(sessionId, text);
+  }
+  /** Pending permission requests, used by the WS snapshot so a fresh
+   * client connection sees what's already waiting on the server. */
+  pendingPermissions() {
+    return [...this.permissions.values()];
+  }
+  broadcastGalaxyImported(manifest) {
+    this.broadcaster.broadcast({ type: "galaxy_imported", manifest });
+    this.broadcaster.broadcast({
+      type: "toast",
+      level: "info",
+      message: `Galaxy "${manifest.name}" imported`
+    });
+    recordAudit(this.db, {
+      kind: "galaxy_imported",
+      summary: `Imported galaxy "${manifest.name}"`,
+      payload: {
+        author: manifest.author,
+        advisorCount: manifest.advisors.length,
+        skillCount: manifest.skills.length,
+        projectCount: manifest.projects.length
+      }
+    });
+  }
+  setContextUsage(sessionId, pct) {
+    const session = setSessionContextUsage(this.db, sessionId, pct);
+    if (session) {
+      this.broadcaster.broadcast({
+        type: "context_update",
+        sessionId,
+        usagePct: session.contextUsagePct
+      });
+    }
+  }
+};
+
+// ../server/src/ws.ts
+import { WebSocketServer } from "ws";
+function attachWs(server, ctx) {
+  const wss = new WebSocketServer({ noServer: true });
+  server.on(
+    "upgrade",
+    (req, socket, head) => {
+      const url = req.url ?? "";
+      if (!url.startsWith("/ws")) {
+        socket.destroy();
+        return;
+      }
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit("connection", ws, req);
+      });
+    }
+  );
+  wss.on("connection", (ws) => {
+    ctx.broadcaster.add(ws);
+    const snapshot = {
+      type: "snapshot",
+      projects: listProjects(ctx.db),
+      sessions: listActiveSessions(ctx.db),
+      missions: listMissions(ctx.db, { limit: 100 }),
+      advisors: listAdvisors(ctx.db),
+      skills: listSkills(ctx.db)
+    };
+    ctx.broadcaster.send(ws, snapshot);
+    for (const p of ctx.router.pendingPermissions()) {
+      ctx.broadcaster.send(ws, {
+        type: "permission_request",
+        sessionId: p.sessionId,
+        tool: p.tool,
+        args: p.args,
+        requestId: p.requestId
+      });
+    }
+    ws.on("message", (raw) => {
+      let msg = null;
+      try {
+        msg = JSON.parse(String(raw));
+      } catch {
+        return;
+      }
+      if (!msg) return;
+      handleClientMessage(ctx, ws, msg);
+    });
+    ws.on("close", () => {
+      ctx.broadcaster.remove(ws);
+    });
+    ws.on("error", () => {
+      ctx.broadcaster.remove(ws);
+    });
+  });
+  return wss;
+}
+function handleClientMessage(ctx, _ws, msg) {
+  switch (msg.type) {
+    case "permission_response":
+      ctx.router.resolvePermission(msg.requestId, msg.approved);
+      break;
+    case "terminate_session":
+      break;
+    case "send_prompt":
+      ctx.router.sendPromptToSession(msg.sessionId, msg.text);
+      break;
+    case "launch_session":
+      ctx.router.launchInternalSession({
+        cwd: msg.cwd,
+        model: msg.model,
+        initialPrompt: msg.initialPrompt
+      });
+      break;
+    case "invoke_advisor":
+      ctx.router.invokeAdvisor(
+        msg.advisorId,
+        msg.targetSessionId,
+        msg.prompt
+      );
+      break;
+    case "pin_advisor":
+      ctx.router.pinAdvisor(msg.advisorId);
+      break;
+    case "unpin_advisor":
+      ctx.router.unpinAdvisor(msg.advisorId);
+      break;
+    default:
+      break;
+  }
+}
+
+// ../server/src/state/transcript.ts
+import {
+  closeSync,
+  existsSync as existsSync8,
+  openSync,
+  readSync,
+  statSync as statSync5,
+  watch
+} from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join9 } from "path";
+var TRANSCRIPT_BASE = join9(homedir5(), ".claude", "projects");
+var CONTEXT_BUDGETS_BY_MODEL = {
+  "claude-opus-4-7": 2e5,
+  "claude-opus-4-6": 2e5,
+  "claude-sonnet-4-6": 2e5,
+  "claude-haiku-4-5": 2e5,
+  default: 2e5
+};
+var REPLAY_TAIL_BYTES = 64 * 1024;
+function encodeProjectPath(cwd) {
+  return cwd.replace(/[/\\]/g, "-");
+}
+function transcriptPathFor(cwd, sessionId) {
+  return join9(TRANSCRIPT_BASE, encodeProjectPath(cwd), `${sessionId}.jsonl`);
+}
+var TranscriptWatcherManager = class {
+  constructor(db, broadcaster) {
+    this.db = db;
+    this.broadcaster = broadcaster;
+    void this.db;
+  }
+  db;
+  broadcaster;
+  records = /* @__PURE__ */ new Map();
+  deferredRetry = /* @__PURE__ */ new Map();
+  /**
+   * Begin tailing this session's transcript. Idempotent. If the file doesn't
+   * exist yet, retries every second for up to 10 s (Claude Code creates the
+   * file slightly after the SessionStart hook fires).
+   */
+  startWatching(sessionId, cwd) {
+    if (this.records.has(sessionId)) return;
+    const filePath = transcriptPathFor(cwd, sessionId);
+    if (!existsSync8(filePath)) {
+      this.scheduleRetry(sessionId, cwd, 0);
+      return;
+    }
+    this.attach(sessionId, filePath);
+  }
+  scheduleRetry(sessionId, cwd, attempt) {
+    if (attempt >= 10) return;
+    const t = setTimeout(() => {
+      this.deferredRetry.delete(sessionId);
+      const filePath = transcriptPathFor(cwd, sessionId);
+      if (existsSync8(filePath)) {
+        this.attach(sessionId, filePath);
+      } else {
+        this.scheduleRetry(sessionId, cwd, attempt + 1);
+      }
+    }, 1e3);
+    this.deferredRetry.set(sessionId, t);
+  }
+  attach(sessionId, filePath) {
+    let size = 0;
+    try {
+      size = statSync5(filePath).size;
+    } catch {
+      return;
+    }
+    const startPos = Math.max(0, size - REPLAY_TAIL_BYTES);
+    const record = {
+      sessionId,
+      filePath,
+      position: startPos,
+      initialRead: startPos > 0
+    };
+    this.records.set(sessionId, record);
+    this.readNewLines(record);
+    try {
+      record.fsWatcher = watch(filePath, () => {
+        this.readNewLines(record);
+      });
+    } catch (err) {
+      console.warn(
+        `[transcript] could not watch ${filePath}:`,
+        err.message
+      );
+    }
+  }
+  readNewLines(record) {
+    let stat;
+    try {
+      stat = statSync5(record.filePath);
+    } catch {
+      return;
+    }
+    if (stat.size <= record.position) return;
+    let buf;
+    try {
+      const fd = openSync(record.filePath, "r");
+      buf = Buffer.alloc(stat.size - record.position);
+      readSync(fd, buf, 0, buf.length, record.position);
+      closeSync(fd);
+    } catch (err) {
+      console.warn(
+        `[transcript] read failed for ${record.filePath}:`,
+        err.message
+      );
+      return;
+    }
+    record.position = stat.size;
+    let text = buf.toString("utf8");
+    if (record.initialRead) {
+      const nl = text.indexOf("\n");
+      text = nl >= 0 ? text.slice(nl + 1) : "";
+      record.initialRead = false;
+    }
+    const lines = text.split("\n");
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      this.processLine(record.sessionId, line);
+    }
+  }
+  processLine(sessionId, line) {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const message = obj.message;
+    if (!message) return;
+    const role = message.role;
+    if (role === "user") {
+      this.emitUser(sessionId, obj);
+    } else if (role === "assistant") {
+      this.emitAssistant(sessionId, obj);
+    }
+  }
+  emitUser(sessionId, obj) {
+    const content = this.flattenUserContent(obj.message?.content);
+    if (!content) return;
+    this.broadcaster.broadcast({
+      type: "chat_delta",
+      sessionId,
+      delta: {
+        messageId: obj.uuid ?? obj.promptId ?? `u-${Date.now()}-${Math.random()}`,
+        role: "user",
+        content,
+        ts: this.parseTs(obj.timestamp),
+        done: true
+      }
+    });
+  }
+  emitAssistant(sessionId, obj) {
+    const message = obj.message;
+    if (!message) return;
+    if (message.usage) {
+      const total = (message.usage.input_tokens ?? 0) + (message.usage.cache_read_input_tokens ?? 0) + (message.usage.cache_creation_input_tokens ?? 0);
+      const budget = CONTEXT_BUDGETS_BY_MODEL[message.model ?? "default"] ?? CONTEXT_BUDGETS_BY_MODEL.default;
+      const pct = Math.min(100, total / budget * 100);
+      this.broadcaster.broadcast({
+        type: "context_update",
+        sessionId,
+        usagePct: pct
+      });
+    }
+    const content = this.flattenAssistantContent(message.content);
+    if (!content) return;
+    this.broadcaster.broadcast({
+      type: "chat_delta",
+      sessionId,
+      delta: {
+        messageId: message.id ?? `a-${Date.now()}-${Math.random()}`,
+        role: "assistant",
+        content,
+        ts: this.parseTs(obj.timestamp),
+        done: true
+      }
+    });
+  }
+  flattenUserContent(content) {
+    if (!content) return "";
+    if (typeof content === "string") return content;
+    const parts = [];
+    for (const b of content) {
+      if (!b || typeof b !== "object") continue;
+      if (b.type === "text" && b.text) parts.push(b.text);
+      else if (b.type === "tool_result") {
+        const inner = b.content;
+        const text = typeof inner === "string" ? inner : Array.isArray(inner) ? inner.map(
+          (x) => typeof x === "object" && x !== null && "text" in x ? String(x.text ?? "") : ""
+        ).join("\n") : "";
+        if (text) parts.push(`[tool result]
+${text.slice(0, 600)}`);
+      }
+    }
+    return parts.join("\n").trim();
+  }
+  flattenAssistantContent(content) {
+    if (!content) return "";
+    if (typeof content === "string") return content;
+    const parts = [];
+    for (const b of content) {
+      if (!b || typeof b !== "object") continue;
+      if (b.type === "text" && b.text) {
+        parts.push(b.text);
+      } else if (b.type === "tool_use" && b.name) {
+        const inputSummary = JSON.stringify(b.input ?? {}).slice(0, 120);
+        parts.push(`\u25B8 ${b.name} ${inputSummary}`);
+      } else if (b.type === "thinking" && b.thinking) {
+        const t = b.thinking.replace(/\s+/g, " ").slice(0, 100);
+        if (t) parts.push(`\u{1F4AD} ${t}\u2026`);
+      }
+    }
+    return parts.join("\n\n").trim();
+  }
+  parseTs(value) {
+    if (!value) return Date.now();
+    const t = Date.parse(value);
+    return Number.isFinite(t) ? t : Date.now();
+  }
+  stopWatching(sessionId) {
+    const r = this.records.get(sessionId);
+    if (r?.fsWatcher) {
+      try {
+        r.fsWatcher.close();
+      } catch {
+      }
+    }
+    this.records.delete(sessionId);
+    const t = this.deferredRetry.get(sessionId);
+    if (t) {
+      clearTimeout(t);
+      this.deferredRetry.delete(sessionId);
+    }
+  }
+  shutdownAll() {
+    for (const id of [...this.records.keys()]) this.stopWatching(id);
+    for (const id of [...this.deferredRetry.keys()]) this.stopWatching(id);
+  }
+};
+
+// ../server/src/create.ts
+async function createSolixServer(opts = {}) {
+  const port = opts.port ?? 4242;
+  const hostname = opts.hostname ?? "127.0.0.1";
+  const db = getDb();
+  seedAdvisors(db);
+  discoverSkills(db);
+  const broadcaster = new Broadcaster();
+  const launcher = new Launcher(db, broadcaster);
+  const transcripts = new TranscriptWatcherManager(db, broadcaster);
+  const router = new EventRouter(db, broadcaster, launcher, transcripts);
+  const app = createHttpApp({ db, router });
+  const server = serve({
+    fetch: app.fetch,
+    port,
+    hostname
+  });
+  attachWs(server, {
+    db,
+    router,
+    broadcaster
+  });
+  return {
+    port,
+    hostname,
+    close: () => new Promise((resolve4) => {
+      transcripts.shutdownAll();
+      launcher.shutdownAll();
+      server.close(() => resolve4());
+    })
+  };
+}
+
+// src/start.ts
+import open from "open";
+var BANNER = `
+   ____   ___  _     ___ __  __
+  / ___| / _ \\| |   |_ _|  \\/  |
+  \\___ \\| | | | |    | || |\\/| |
+   ___) | |_| | |___ | || |  | |
+  |____/ \\___/|_____|___|_|  |_|
+
+  a solar-system command center for Claude Code
+`;
+async function start(opts = {}) {
+  const port = opts.port ?? Number(process.env.SOLIX_PORT ?? 4242);
+  console.log(BANNER);
+  const handle = await createSolixServer({ port });
+  const url = `http://${handle.hostname}:${handle.port}`;
+  console.log(`[solix] server listening on ${url}`);
+  console.log(`[solix] events  -> POST ${url}/events`);
+  console.log(`[solix] ws      -> ws://${handle.hostname}:${handle.port}/ws`);
+  if (!opts.noOpen) {
+    try {
+      await open(url);
+    } catch {
+      console.log(`[solix] open ${url} in your browser to view`);
+    }
+  }
+  console.log(
+    "[solix] start any `claude` session to see your first planet appear"
+  );
+  const shutdown = async (sig) => {
+    console.log(`
+[solix] ${sig} \u2014 shutting down`);
+    await handle.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+}
+
+// src/uninstall.ts
+import { copyFileSync as copyFileSync2, existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+function uninstall() {
+  if (existsSync9(CLAUDE_BACKUP)) {
+    copyFileSync2(CLAUDE_BACKUP, CLAUDE_SETTINGS);
+    console.log(`[solix] restored settings.json from backup`);
+    return;
+  }
+  if (!existsSync9(CLAUDE_SETTINGS)) {
+    console.log("[solix] nothing to uninstall (no settings.json found)");
+    return;
+  }
+  const cur = JSON.parse(
+    readFileSync6(CLAUDE_SETTINGS, "utf8")
+  );
+  if (cur.hooks) {
+    for (const [evt, entries] of Object.entries(cur.hooks)) {
+      cur.hooks[evt] = entries.filter(
+        (e) => !e.hooks.some((h) => h.command.includes(HOOKS_DIR))
+      );
+      if (cur.hooks[evt].length === 0) delete cur.hooks[evt];
+    }
+  }
+  writeFileSync3(CLAUDE_SETTINGS, JSON.stringify(cur, null, 2) + "\n");
+  console.log(`[solix] removed Solix hooks from ${CLAUDE_SETTINGS}`);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("solix").description("Solix \u2014 a solar-system command center for Claude Code agents").version("1.0.0");
+program.command("start", { isDefault: true }).description("Start the Solix server and open the browser").option("-p, --port <port>", "port to listen on", (v) => parseInt(v, 10), 4242).option("--no-open", "do not open browser automatically").action(async (opts) => {
+  await start({ port: opts.port, noOpen: !opts.open });
+});
+program.command("install").description("Install Solix hooks into ~/.claude/settings.json").option("--force", "overwrite even if hooks already present").action((opts) => {
+  install({ force: opts.force });
+  console.log("\n[solix] install complete. Run `solix start` next.");
+});
+program.command("uninstall").description("Restore ~/.claude/settings.json from backup").action(() => {
+  uninstall();
+});
+program.command("doctor").description("Run diagnostics").action(async () => {
+  await doctor();
+});
+program.command("demo").description(
+  "Seed the running server with fake planets, missions, and a pinned advisor (great for first-run)"
+).option("-p, --port <port>", "server port", (v) => parseInt(v, 10), 4242).action(async (opts) => {
+  await demoCmd({ port: opts.port });
+});
+var advisors = program.command("advisors").description("Manage built-in advisor agents (PM, Builder, UX, etc.)");
+advisors.command("list", { isDefault: true }).description("List all advisor agents and their state").action(async () => {
+  await listAdvisorsCmd();
+});
+advisors.command("enable <id>").description("Enable an advisor (renders in the inner crew ring)").action(async (id) => {
+  await enableAdvisorCmd(id);
+});
+advisors.command("disable <id>").description("Disable an advisor").action(async (id) => {
+  await disableAdvisorCmd(id);
+});
+advisors.command("pin <id>").description("Pin an advisor (always-on planet)").action(async (id) => {
+  await pinAdvisorCmd(id);
+});
+advisors.command("unpin <id>").description("Unpin an advisor (back to on-demand)").action(async (id) => {
+  await unpinAdvisorCmd(id);
+});
+var skills = program.command("skills").description("Manage discovered skills (asteroid belt)");
+skills.command("list", { isDefault: true }).description("List all known skills (Anthropic + Solix pack)").action(async () => {
+  await listSkillsCmd();
+});
+skills.command("install <id>").description("Mark a skill as installed in a project").option("--project <projectId>", "project id (hash of cwd)").action(async (id, opts) => {
+  await installSkillCmd(id, opts.project);
+});
+var galaxy = program.command("galaxy").description("Export and import shareable galaxy configurations");
+galaxy.command("export <out>").description("Export the current galaxy to a JSON manifest file").option("--name <name>", "galaxy name", "My Galaxy").option("--author <author>", "author name").option("--description <desc>", "short description").action(
+  async (out, opts) => {
+    await exportGalaxyCmd(out, opts);
+  }
+);
+galaxy.command("import <fileOrUrl>").description("Import a galaxy manifest from a local file or URL").action(async (fileOrUrl) => {
+  await importGalaxyCmd(fileOrUrl);
+});
+galaxy.command("publish <slug>").description("Publish the current galaxy to the configured registry").option("--name <name>", "galaxy name", "My Galaxy").option("--author <author>", "author name").option("--description <desc>", "short description").action(
+  async (slug, opts) => {
+    await publishGalaxyCmd(slug, opts);
+  }
+);
+galaxy.command("install <slug>").description("Pull and install a galaxy from the configured registry").action(async (slug) => {
+  await installFromRegistryCmd(slug);
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});