@revealui/harnesses 0.1.6 → 0.1.8

package/dist/chunk-6E2BKO6U.js

@@ -0,0 +1,2040 @@
+import {
+  DaemonStore
+} from "./chunk-DGQ5OB6L.js";
+import {
+  WorkboardManager,
+  deriveSessionId,
+  detectSessionType
+} from "./chunk-4F4ANKIZ.js";
+import {
+  __require
+} from "./chunk-DGUM43GV.js";
+
+// src/index.ts
+import { isFeatureEnabled } from "@revealui/core/features";
+import { initializeLicense } from "@revealui/core/license";
+import { logger } from "@revealui/core/observability/logger";
+
+// src/adapters/claude-code-adapter.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var ClaudeCodeAdapter = class {
+  id = "claude-code";
+  name = "Claude Code";
+  eventHandlers = /* @__PURE__ */ new Set();
+  workboardPath;
+  constructor(workboardPath) {
+    this.workboardPath = workboardPath ?? process.env.REVEALUI_WORKBOARD_PATH;
+  }
+  getCapabilities() {
+    return {
+      generateCode: false,
+      // interactive only — no headless CLI interface
+      analyzeCode: false,
+      // interactive only — no headless CLI interface
+      applyEdit: false,
+      // interactive only — edits are applied inside Claude Code sessions
+      applyConfig: false,
+      // config managed interactively via ~/.claude/settings.json
+      readWorkboard: this.workboardPath !== void 0,
+      writeWorkboard: this.workboardPath !== void 0
+    };
+  }
+  async getInfo() {
+    let version;
+    try {
+      const { stdout } = await execFileAsync("claude", ["--version"], {
+        timeout: 5e3
+      });
+      version = stdout.trim().split("\n")[0];
+    } catch {
+    }
+    return { id: this.id, name: this.name, version, capabilities: this.getCapabilities() };
+  }
+  async isAvailable() {
+    try {
+      await execFileAsync("claude", ["--version"], { timeout: 3e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  notifyRegistered() {
+    this.emit({ type: "harness-connected", harnessId: this.id });
+  }
+  notifyUnregistering() {
+    this.emit({ type: "harness-disconnected", harnessId: this.id });
+  }
+  async execute(command) {
+    try {
+      return await this.executeInner(command);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.emit({ type: "error", harnessId: this.id, message });
+      return { success: false, command: command.type, message };
+    }
+  }
+  async executeInner(command) {
+    switch (command.type) {
+      case "get-status": {
+        const available = await this.isAvailable();
+        return { success: true, command: command.type, data: { available } };
+      }
+      case "get-running-instances": {
+        return { success: true, command: command.type, data: [] };
+      }
+      case "generate-code":
+      case "analyze-code": {
+        return {
+          success: false,
+          command: command.type,
+          message: `${command.type} is not supported \u2014 Claude Code operates interactively`
+        };
+      }
+      case "apply-config": {
+        return {
+          success: false,
+          command: command.type,
+          message: "Config is managed interactively via ~/.claude/settings.json"
+        };
+      }
+      case "read-workboard": {
+        if (!this.workboardPath) {
+          return {
+            success: false,
+            command: command.type,
+            message: "REVEALUI_WORKBOARD_PATH is not set"
+          };
+        }
+        const manager = new WorkboardManager(this.workboardPath);
+        const state = await manager.readAsync();
+        return { success: true, command: command.type, data: state };
+      }
+      case "update-workboard": {
+        if (!this.workboardPath) {
+          return {
+            success: false,
+            command: command.type,
+            message: "REVEALUI_WORKBOARD_PATH is not set"
+          };
+        }
+        const manager = new WorkboardManager(this.workboardPath);
+        manager.updateAgent(command.sessionId, {
+          ...command.task !== void 0 && { task: command.task },
+          ...command.files !== void 0 && { files: command.files.join(", ") },
+          updated: `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)}Z`
+        });
+        return { success: true, command: command.type };
+      }
+      default: {
+        return {
+          success: false,
+          command: command.type,
+          message: `Command not supported by ${this.name}`
+        };
+      }
+    }
+  }
+  onEvent(handler) {
+    this.eventHandlers.add(handler);
+    return () => this.eventHandlers.delete(handler);
+  }
+  async dispose() {
+    this.eventHandlers.clear();
+  }
+  emit(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/adapters/cursor-adapter.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+var CursorAdapter = class {
+  id = "cursor";
+  name = "Cursor";
+  eventHandlers = /* @__PURE__ */ new Set();
+  workboardPath;
+  constructor(workboardPath) {
+    this.workboardPath = workboardPath ?? process.env.REVEALUI_WORKBOARD_PATH;
+  }
+  getCapabilities() {
+    return {
+      generateCode: false,
+      analyzeCode: false,
+      applyEdit: false,
+      applyConfig: false,
+      readWorkboard: this.workboardPath !== void 0,
+      writeWorkboard: this.workboardPath !== void 0
+    };
+  }
+  async getInfo() {
+    let version;
+    try {
+      const { stdout } = await execFileAsync2("cursor", ["--version"], {
+        timeout: 5e3
+      });
+      version = stdout.trim().split("\n")[0];
+    } catch {
+    }
+    return { id: this.id, name: this.name, version, capabilities: this.getCapabilities() };
+  }
+  async isAvailable() {
+    try {
+      await execFileAsync2("cursor", ["--version"], { timeout: 3e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  notifyRegistered() {
+    this.emit({ type: "harness-connected", harnessId: this.id });
+  }
+  notifyUnregistering() {
+    this.emit({ type: "harness-disconnected", harnessId: this.id });
+  }
+  async execute(command) {
+    try {
+      return await this.executeInner(command);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.emit({ type: "error", harnessId: this.id, message });
+      return { success: false, command: command.type, message };
+    }
+  }
+  async executeInner(command) {
+    switch (command.type) {
+      case "get-status": {
+        const available = await this.isAvailable();
+        return { success: true, command: command.type, data: { available } };
+      }
+      case "read-workboard": {
+        if (!this.workboardPath) {
+          return {
+            success: false,
+            command: command.type,
+            message: "REVEALUI_WORKBOARD_PATH is not set"
+          };
+        }
+        const manager = new WorkboardManager(this.workboardPath);
+        const state = await manager.readAsync();
+        return { success: true, command: command.type, data: state };
+      }
+      case "update-workboard": {
+        if (!this.workboardPath) {
+          return {
+            success: false,
+            command: command.type,
+            message: "REVEALUI_WORKBOARD_PATH is not set"
+          };
+        }
+        const manager = new WorkboardManager(this.workboardPath);
+        manager.updateAgent(command.sessionId, {
+          ...command.task !== void 0 && { task: command.task },
+          ...command.files !== void 0 && { files: command.files.join(", ") },
+          updated: `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)}Z`
+        });
+        return { success: true, command: command.type };
+      }
+      default: {
+        return {
+          success: false,
+          command: command.type,
+          message: `Command not supported by ${this.name}`
+        };
+      }
+    }
+  }
+  onEvent(handler) {
+    this.eventHandlers.add(handler);
+    return () => this.eventHandlers.delete(handler);
+  }
+  async dispose() {
+    this.eventHandlers.clear();
+  }
+  emit(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/config/config-sync.ts
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { dirname } from "path";
+
+// src/config/harness-config-paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var HOME = homedir();
+var REVEALUI_ROOT = process.env.REVEALUI_ROOT ?? join(HOME, ".revealui");
+var LOCAL_CONFIG_PATHS = {
+  "claude-code": join(HOME, ".claude", "settings.json"),
+  cursor: join(HOME, ".cursor", "settings.json"),
+  copilot: join(HOME, ".config", "github-copilot", "hosts.json")
+};
+var ROOT_CONFIG_FILES = {
+  "claude-code": "settings.json",
+  cursor: "settings.json",
+  copilot: "hosts.json"
+};
+function getLocalConfigPath(harnessId) {
+  return LOCAL_CONFIG_PATHS[harnessId];
+}
+function getRootConfigPath(harnessId, root = REVEALUI_ROOT) {
+  const file = ROOT_CONFIG_FILES[harnessId];
+  if (!file) return void 0;
+  return join(root, "harness-configs", harnessId, file);
+}
+function getConfigurableHarnesses() {
+  return Object.keys(LOCAL_CONFIG_PATHS);
+}
+
+// src/config/config-sync.ts
+function syncConfig(harnessId, direction, root) {
+  const localPath = getLocalConfigPath(harnessId);
+  const rootPath = getRootConfigPath(harnessId, root);
+  if (!(localPath && rootPath)) {
+    return {
+      success: false,
+      harnessId,
+      direction,
+      message: `No config path known for harness: ${harnessId}`
+    };
+  }
+  try {
+    if (direction === "pull") {
+      if (!existsSync(rootPath)) {
+        return {
+          success: false,
+          harnessId,
+          direction,
+          message: `Root config not found: ${rootPath}`
+        };
+      }
+      mkdirSync(dirname(localPath), { recursive: true });
+      backupIfExists(localPath);
+      copyFileSync(rootPath, localPath);
+      return { success: true, harnessId, direction, message: `Pulled ${rootPath} \u2192 ${localPath}` };
+    } else {
+      if (!existsSync(localPath)) {
+        return {
+          success: false,
+          harnessId,
+          direction,
+          message: `Local config not found: ${localPath}`
+        };
+      }
+      mkdirSync(dirname(rootPath), { recursive: true });
+      backupIfExists(rootPath);
+      copyFileSync(localPath, rootPath);
+      return { success: true, harnessId, direction, message: `Pushed ${localPath} \u2192 ${rootPath}` };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      harnessId,
+      direction,
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function diffConfig(harnessId, root) {
+  const localPath = getLocalConfigPath(harnessId);
+  const rootPath = getRootConfigPath(harnessId, root);
+  const localExists = !!localPath && existsSync(localPath);
+  const ssdExists = !!rootPath && existsSync(rootPath);
+  if (!(localExists && ssdExists)) {
+    return { harnessId, localExists, ssdExists, identical: false };
+  }
+  try {
+    const localContent = readFileSync(localPath, "utf8");
+    const ssdContent = readFileSync(rootPath, "utf8");
+    return { harnessId, localExists, ssdExists, identical: localContent === ssdContent };
+  } catch {
+    return { harnessId, localExists, ssdExists, identical: false };
+  }
+}
+function syncAllConfigs(direction, root) {
+  return getConfigurableHarnesses().map((id) => syncConfig(id, direction, root));
+}
+function diffAllConfigs(root) {
+  return getConfigurableHarnesses().map((id) => diffConfig(id, root));
+}
+function validateConfigJson(harnessId) {
+  const localPath = getLocalConfigPath(harnessId);
+  if (!localPath) return `No config path known for harness: ${harnessId}`;
+  if (!existsSync(localPath)) return `Config file not found: ${localPath}`;
+  try {
+    const content = readFileSync(localPath, "utf8");
+    JSON.parse(content);
+    return null;
+  } catch (err) {
+    return err instanceof Error ? err.message : String(err);
+  }
+}
+function backupIfExists(filePath) {
+  try {
+    if (existsSync(filePath)) {
+      copyFileSync(filePath, `${filePath}.bak`);
+    }
+  } catch {
+  }
+}
+
+// src/coordinator.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { join as join4 } from "path";
+
+// src/adapters/revealui-agent-adapter.ts
+var DEFAULT_CONFIG = {
+  projectRoot: process.cwd(),
+  maxIterations: 10,
+  timeoutMs: 12e4
+};
+var RevealUIAgentAdapter = class {
+  id = "revealui-agent";
+  name = "RevealUI Agent";
+  config;
+  eventHandlers = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  getCapabilities() {
+    return {
+      generateCode: true,
+      analyzeCode: true,
+      applyEdit: true,
+      applyConfig: false,
+      readWorkboard: (this.config.workboardPath ?? process.env.REVEALUI_WORKBOARD_PATH) !== void 0,
+      writeWorkboard: (this.config.workboardPath ?? process.env.REVEALUI_WORKBOARD_PATH) !== void 0
+    };
+  }
+  async getInfo() {
+    return {
+      id: this.id,
+      name: this.name,
+      version: "0.1.0",
+      capabilities: this.getCapabilities()
+    };
+  }
+  /**
+   * The RevealUI agent is available if at least one LLM provider is reachable.
+   * Checks in order: BitNet (localhost), Ollama (localhost), Groq (API key).
+   */
+  async isAvailable() {
+    if (process.env.BITNET_BASE_URL) {
+      try {
+        const url = `${process.env.BITNET_BASE_URL}/v1/models`;
+        const res = await fetch(url, { signal: AbortSignal.timeout(2e3) });
+        if (res.ok) return true;
+      } catch {
+      }
+    }
+    const ollamaUrl = process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
+    try {
+      const res = await fetch(`${ollamaUrl}/api/tags`, {
+        signal: AbortSignal.timeout(2e3)
+      });
+      if (res.ok) return true;
+    } catch {
+    }
+    if (process.env.GROQ_API_KEY) return true;
+    return false;
+  }
+  notifyRegistered() {
+    this.emit({ type: "harness-connected", harnessId: this.id });
+  }
+  notifyUnregistering() {
+    this.emit({ type: "harness-disconnected", harnessId: this.id });
+  }
+  async execute(command) {
+    try {
+      return await this.executeInner(command);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.emit({ type: "error", harnessId: this.id, message });
+      return { success: false, command: command.type, message };
+    }
+  }
+  async executeInner(command) {
+    switch (command.type) {
+      case "get-status": {
+        const available = await this.isAvailable();
+        return {
+          success: true,
+          command: command.type,
+          data: {
+            available,
+            provider: this.config.provider ?? "auto",
+            model: this.config.model ?? "auto",
+            projectRoot: this.config.projectRoot
+          }
+        };
+      }
+      case "headless-prompt": {
+        return this.runHeadlessPrompt(command.prompt, command.maxTurns, command.timeoutMs);
+      }
+      case "generate-code": {
+        return this.runHeadlessPrompt(
+          `Generate code: ${command.prompt}${command.language ? ` (language: ${command.language})` : ""}${command.context ? `
+
+Context:
+${command.context}` : ""}`
+        );
+      }
+      case "analyze-code": {
+        const question = command.question ?? "Analyze this file and explain what it does.";
+        return this.runHeadlessPrompt(
+          `Read the file at ${command.filePath} and answer: ${question}`
+        );
+      }
+      case "apply-edit": {
+        return this.runHeadlessPrompt(
+          `Apply the following diff to ${command.filePath}:
+
+${command.diff}`
+        );
+      }
+      case "apply-config":
+      case "sync-config":
+      case "diff-config": {
+        return {
+          success: false,
+          command: command.type,
+          message: "Config sync is not applicable \u2014 RevealUI agent uses the content layer directly"
+        };
+      }
+      case "read-workboard":
+      case "update-workboard": {
+        return {
+          success: false,
+          command: command.type,
+          message: "Workboard support not yet wired \u2014 use WorkboardManager directly"
+        };
+      }
+      default: {
+        return {
+          success: false,
+          command: command.type,
+          message: `Command not supported by ${this.name}`
+        };
+      }
+    }
+  }
+  /**
+   * Run a headless prompt through the coding agent.
+   * Lazy-imports @revealui/ai to avoid hard dependency at module load time.
+   * Types are inferred from the dynamic imports — no compile-time @revealui/ai dependency.
+   */
+  async runHeadlessPrompt(prompt, maxTurns, timeoutMs) {
+    const aiRuntimePath = "@revealui/ai/orchestration/streaming-runtime";
+    const aiClientPath = "@revealui/ai/llm/client";
+    const aiToolsPath = "@revealui/ai/tools/coding";
+    let runtimeMod;
+    let clientMod;
+    let toolsMod;
+    try {
+      [runtimeMod, clientMod, toolsMod] = await Promise.all([
+        import(aiRuntimePath),
+        import(aiClientPath),
+        import(aiToolsPath)
+      ]);
+    } catch {
+      return {
+        success: false,
+        command: "headless-prompt",
+        message: "@revealui/ai is not installed. Install it to use the RevealUI agent: npm install @revealui/ai"
+      };
+    }
+    const StreamingAgentRuntime = runtimeMod.StreamingAgentRuntime;
+    const createCodingTools = toolsMod.createCodingTools;
+    const projectRoot = this.config.projectRoot ?? process.cwd();
+    const tools = createCodingTools({ projectRoot });
+    let llmClient;
+    if (this.config.provider) {
+      const LLMClient = clientMod.LLMClient;
+      llmClient = new LLMClient({
+        provider: this.config.provider,
+        model: this.config.model,
+        baseURL: process.env.BITNET_BASE_URL ?? process.env.OLLAMA_BASE_URL,
+        apiKey: process.env.GROQ_API_KEY ?? "not-needed"
+      });
+    } else {
+      const createLLMClientFromEnv = clientMod.createLLMClientFromEnv;
+      llmClient = createLLMClientFromEnv();
+    }
+    const agent = {
+      id: "revealui-coding-agent",
+      name: "RevealUI Coding Agent",
+      instructions: this.buildInstructions(),
+      tools,
+      config: {},
+      getContext: () => ({ projectRoot, workingDirectory: projectRoot })
+    };
+    const task = {
+      id: `task-${Date.now()}`,
+      type: "headless-prompt",
+      description: prompt
+    };
+    const runtime = new StreamingAgentRuntime({
+      maxIterations: maxTurns ?? this.config.maxIterations ?? DEFAULT_CONFIG.maxIterations,
+      timeout: timeoutMs ?? this.config.timeoutMs ?? DEFAULT_CONFIG.timeoutMs
+    });
+    const taskId = task.id;
+    this.emit({ type: "generation-started", taskId });
+    const outputParts = [];
+    try {
+      for await (const chunk of runtime.streamTask(agent, task, llmClient)) {
+        switch (chunk.type) {
+          case "text":
+            if (chunk.content) outputParts.push(chunk.content);
+            break;
+          case "tool_call_result":
+            if (chunk.toolResult?.content) {
+              outputParts.push(`[tool: ${chunk.toolCall?.name}] ${chunk.toolResult.content}`);
+            }
+            break;
+          case "error":
+            if (chunk.error) outputParts.push(`[error] ${chunk.error}`);
+            break;
+          case "done":
+            break;
+        }
+      }
+    } finally {
+      await runtime.cleanup();
+    }
+    const output = outputParts.join("\n");
+    this.emit({ type: "generation-completed", taskId, output });
+    return {
+      success: true,
+      command: "headless-prompt",
+      message: output,
+      data: { taskId, output }
+    };
+  }
+  /**
+   * Build system instructions from the content layer.
+   * Loads rules from .claude/rules/ as a baseline (they are the canonical content).
+   */
+  buildInstructions() {
+    const lines = [
+      "You are the RevealUI coding agent. You help with software development tasks in this project.",
+      "Use the available tools to read, write, edit, search, and execute commands.",
+      "Always read files before modifying them. Prefer surgical edits over full rewrites.",
+      "Follow project conventions discovered via the project_context tool.",
+      ""
+    ];
+    try {
+      const { readdirSync, readFileSync: readFileSync2 } = __require("fs");
+      const { join: join5 } = __require("path");
+      const projectRoot = this.config.projectRoot ?? process.cwd();
+      const rulesDir = join5(projectRoot, ".claude", "rules");
+      const ruleFiles = readdirSync(rulesDir);
+      for (const file of ruleFiles) {
+        if (file.endsWith(".md")) {
+          const content = readFileSync2(join5(rulesDir, file), "utf8");
+          lines.push(`## ${file.replace(".md", "")}`, content, "");
+        }
+      }
+    } catch {
+    }
+    return lines.join("\n");
+  }
+  onEvent(handler) {
+    this.eventHandlers.add(handler);
+    return () => this.eventHandlers.delete(handler);
+  }
+  async dispose() {
+    this.eventHandlers.clear();
+  }
+  emit(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/detection/auto-detector.ts
+async function autoDetectHarnesses(registry) {
+  const candidates = [
+    new RevealUIAgentAdapter(),
+    new ClaudeCodeAdapter(),
+    new CursorAdapter()
+    // Copilot adapter excluded — stub only, no standalone CLI available
+  ];
+  const registered = [];
+  await Promise.all(
+    candidates.map(async (adapter) => {
+      try {
+        if (await adapter.isAvailable()) {
+          registry.register(adapter);
+          registered.push(adapter.id);
+        } else {
+          await adapter.dispose();
+        }
+      } catch {
+        await adapter.dispose();
+      }
+    })
+  );
+  return registered;
+}
+
+// src/registry/harness-registry.ts
+var HarnessRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  /** Register an adapter. Throws if an adapter with the same id already exists. */
+  register(adapter) {
+    if (this.adapters.has(adapter.id)) {
+      throw new Error(`Harness adapter already registered: ${adapter.id}`);
+    }
+    this.adapters.set(adapter.id, adapter);
+    adapter.notifyRegistered?.();
+  }
+  /** Unregister an adapter, disposing it in the process. */
+  async unregister(id) {
+    const adapter = this.adapters.get(id);
+    if (adapter) {
+      adapter.notifyUnregistering?.();
+      await adapter.dispose();
+      this.adapters.delete(id);
+    }
+  }
+  /** Retrieve an adapter by id. */
+  get(id) {
+    return this.adapters.get(id);
+  }
+  /** List all registered adapter ids. */
+  listAll() {
+    return Array.from(this.adapters.keys());
+  }
+  /** List ids of adapters that report isAvailable() === true. */
+  async listAvailable() {
+    const results = await Promise.all(
+      Array.from(this.adapters.entries()).map(async ([id, adapter]) => ({
+        id,
+        available: await adapter.isAvailable()
+      }))
+    );
+    return results.filter((r) => r.available).map((r) => r.id);
+  }
+  /** Dispose all adapters and clear the registry. */
+  async disposeAll() {
+    await Promise.all(Array.from(this.adapters.values()).map((a) => a.dispose()));
+    this.adapters.clear();
+  }
+};
+
+// src/server/http-gateway.ts
+import { randomBytes } from "crypto";
+import { createReadStream, existsSync as existsSync2, statSync } from "fs";
+import { createServer } from "http";
+import { extname, join as join2, normalize } from "path";
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".wasm": "application/wasm"
+};
+var HttpGateway = class {
+  server;
+  config;
+  /** 6-digit pairing code (regenerated on each start) */
+  pairingCode;
+  /** Active session tokens (bearer tokens granted after pairing) */
+  sessionTokens = /* @__PURE__ */ new Set();
+  /** Whether pairing has been completed at least once */
+  paired = false;
+  constructor(config) {
+    this.config = config;
+    this.pairingCode = generatePairingCode();
+    this.server = createServer((req, res) => this.handleRequest(req, res));
+  }
+  /** The current pairing code (display this in Studio/terminal) */
+  getPairingCode() {
+    return this.pairingCode;
+  }
+  /** Regenerate the pairing code (invalidates previous code) */
+  regeneratePairingCode() {
+    this.pairingCode = generatePairingCode();
+    return this.pairingCode;
+  }
+  async start() {
+    return new Promise((resolve, reject) => {
+      this.server.listen(this.config.port, this.config.host, () => resolve());
+      this.server.once("error", reject);
+    });
+  }
+  async stop() {
+    return new Promise((resolve) => this.server.close(() => resolve()));
+  }
+  handleRequest(req, res) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    const path = url.pathname;
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (path === "/api/pair" && req.method === "POST") {
+      this.handlePair(req, res);
+      return;
+    }
+    if (path === "/rpc" || path.startsWith("/api/")) {
+      if (!this.checkAuth(req, res)) return;
+      if (path === "/rpc" && req.method === "POST") {
+        this.handleRpc(req, res);
+        return;
+      }
+      if (path === "/api/pair" && req.method === "GET") {
+        this.handlePairStatus(res);
+        return;
+      }
+      if (path === "/api/status") {
+        this.handleStatus(res);
+        return;
+      }
+      if (path.startsWith("/api/stream") && req.method === "GET") {
+        const sessionFilter = path.split("/")[3] ?? null;
+        this.handleStream(req, res, sessionFilter);
+        return;
+      }
+      jsonResponse(res, 404, { error: "Not found" });
+      return;
+    }
+    this.handleStatic(path, res);
+  }
+  /** Verify the Authorization: Bearer <token> header */
+  checkAuth(req, res) {
+    if (this.sessionTokens.size === 0 && !this.paired) {
+      return true;
+    }
+    const authHeader = req.headers.authorization ?? "";
+    if (!authHeader.startsWith("Bearer ")) {
+      jsonResponse(res, 401, { error: "Authorization required", paired: this.paired });
+      return false;
+    }
+    const token = authHeader.slice(7);
+    if (!this.sessionTokens.has(token)) {
+      jsonResponse(res, 403, { error: "Invalid token" });
+      return false;
+    }
+    return true;
+  }
+  /** POST /api/pair — submit pairing code, receive session token */
+  handlePair(req, res) {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+      if (body.length > 1024) {
+        res.writeHead(413);
+        res.end();
+        req.destroy();
+      }
+    });
+    req.on("end", () => {
+      try {
+        const { code } = JSON.parse(body);
+        if (code !== this.pairingCode) {
+          jsonResponse(res, 403, { error: "Invalid pairing code" });
+          return;
+        }
+        const token = randomBytes(32).toString("hex");
+        this.sessionTokens.add(token);
+        this.paired = true;
+        this.pairingCode = generatePairingCode();
+        jsonResponse(res, 200, { token, expires: null });
+      } catch {
+        jsonResponse(res, 400, { error: "Invalid JSON" });
+      }
+    });
+  }
+  /** GET /api/pair — check pairing status */
+  handlePairStatus(res) {
+    jsonResponse(res, 200, {
+      paired: this.paired,
+      activeSessions: this.sessionTokens.size
+    });
+  }
+  /** GET /api/status — daemon status summary */
+  handleStatus(res) {
+    jsonResponse(res, 200, {
+      daemon: "revdev-harness",
+      pid: process.pid,
+      uptime: process.uptime(),
+      paired: this.paired,
+      activeSessions: this.sessionTokens.size
+    });
+  }
+  /** POST /rpc — proxy JSON-RPC to the daemon's dispatch */
+  handleRpc(req, res) {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+      if (body.length > 1048576) {
+        res.writeHead(413);
+        res.end();
+        req.destroy();
+      }
+    });
+    req.on("end", () => {
+      this.config.rpcDispatch.dispatchHttp(body, (response) => {
+        jsonResponse(res, 200, response);
+      });
+    });
+  }
+  /** GET /api/stream[/:sessionId] — SSE for agent output and exit events */
+  handleStream(req, res, sessionFilter) {
+    const spawner = this.config.spawner;
+    if (!spawner) {
+      jsonResponse(res, 503, { error: "Spawner not available" });
+      return;
+    }
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "Access-Control-Allow-Origin": "*"
+    });
+    res.write(": connected\n\n");
+    const onOutput = (evt) => {
+      if (sessionFilter && evt.sessionId !== sessionFilter) return;
+      res.write(`event: output
+data: ${JSON.stringify(evt)}
+
+`);
+    };
+    const onExit = (evt) => {
+      if (sessionFilter && evt.sessionId !== sessionFilter) return;
+      res.write(`event: exit
+data: ${JSON.stringify(evt)}
+
+`);
+    };
+    spawner.on("output", onOutput);
+    spawner.on("exit", onExit);
+    const keepalive = setInterval(() => {
+      res.write(": keepalive\n\n");
+    }, 3e4);
+    req.on("close", () => {
+      clearInterval(keepalive);
+      spawner.off("output", onOutput);
+      spawner.off("exit", onExit);
+    });
+  }
+  /** Serve static files from the Studio build directory */
+  handleStatic(urlPath, res) {
+    if (!this.config.staticDir) {
+      jsonResponse(res, 404, { error: "Static serving not configured" });
+      return;
+    }
+    const filePath = urlPath === "/" ? "/index.html" : urlPath;
+    const normalized = normalize(filePath);
+    if (normalized.includes("..")) {
+      res.writeHead(400);
+      res.end("Bad request");
+      return;
+    }
+    const fullPath = join2(this.config.staticDir, normalized);
+    const targetPath = existsSync2(fullPath) && statSync(fullPath).isFile() ? fullPath : join2(this.config.staticDir, "index.html");
+    if (!existsSync2(targetPath)) {
+      res.writeHead(404);
+      res.end("Not found");
+      return;
+    }
+    const ext = extname(targetPath);
+    const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+    res.writeHead(200, { "Content-Type": contentType });
+    createReadStream(targetPath).pipe(res);
+  }
+};
+function generatePairingCode() {
+  const bytes = randomBytes(4);
+  const num = bytes.readUInt32BE(0) % 1e6;
+  return num.toString().padStart(6, "0");
+}
+function jsonResponse(res, status, body) {
+  const json = JSON.stringify(body);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Content-Length": Buffer.byteLength(json)
+  });
+  res.end(json);
+}
+
+// src/server/inference-service.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
+var KNOWN_SNAPS = [
+  ["nemotron-3-nano", "General (reasoning + non-reasoning) \u2014 free tier default"],
+  ["gemma3", "General + vision \u2014 image understanding, multimodal"],
+  ["deepseek-r1", "Reasoning \u2014 complex analysis, chain-of-thought"],
+  ["qwen-vl", "Vision-language \u2014 document parsing, visual Q&A"]
+];
+var BITNET_MODEL_PATHS = [
+  `${process.env.HOME ?? "/root"}/models/bitnet`,
+  "/mnt/forge/models/bitnet"
+];
+async function commandExists(cmd) {
+  try {
+    await execFileAsync3("which", [cmd]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function run(cmd, args) {
+  return execFileAsync3(cmd, args, { timeout: 3e4 });
+}
+var InferenceService = class {
+  // ── Ollama ──────────────────────────────────────────────────────
+  async ollamaStatus() {
+    const installed = await commandExists("ollama");
+    if (!installed) return { installed: false, running: false, version: null };
+    let version = null;
+    try {
+      const { stdout } = await run("ollama", ["--version"]);
+      version = stdout.trim() || null;
+    } catch {
+    }
+    let running = false;
+    try {
+      await run("ollama", ["list"]);
+      running = true;
+    } catch {
+    }
+    return { installed, running, version };
+  }
+  async ollamaModels() {
+    const { stdout } = await run("ollama", ["list"]);
+    const models = [];
+    const lines = stdout.split("\n");
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i]?.trim();
+      if (!line) continue;
+      const parts = line.split(/\s+/);
+      if (parts.length >= 3) {
+        models.push({
+          name: parts[0] ?? "",
+          size: parts[2] ?? "",
+          modified: parts.slice(3).join(" ")
+        });
+      }
+    }
+    return models;
+  }
+  async ollamaPull(modelName) {
+    try {
+      const { stdout, stderr } = await execFileAsync3("ollama", ["pull", modelName], {
+        timeout: 6e5
+        // 10 min for large models
+      });
+      return { success: true, message: stdout || stderr };
+    } catch (err) {
+      return { success: false, message: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async ollamaDelete(modelName) {
+    await run("ollama", ["rm", modelName]);
+  }
+  async ollamaStart() {
+    const { spawn } = await import("child_process");
+    const child = spawn("ollama", ["serve"], {
+      stdio: "ignore",
+      detached: true
+    });
+    child.unref();
+  }
+  async ollamaStop() {
+    try {
+      await run("pkill", ["-f", "ollama serve"]);
+    } catch {
+    }
+  }
+  // ── BitNet ──────────────────────────────────────────────────────
+  async bitnetStatus() {
+    const installed = await commandExists("bitnet");
+    let modelPath = null;
+    if (installed) {
+      const { existsSync: existsSync4 } = await import("fs");
+      for (const p of BITNET_MODEL_PATHS) {
+        if (existsSync4(p)) {
+          modelPath = p;
+          break;
+        }
+      }
+    }
+    return { installed, modelPath };
+  }
+  // ── Inference Snaps ─────────────────────────────────────────────
+  async snapList() {
+    const results = [];
+    for (const [name, description] of KNOWN_SNAPS) {
+      let installed = false;
+      try {
+        await run("snap", ["list", name]);
+        installed = true;
+      } catch {
+      }
+      results.push({ name, description, installed });
+    }
+    return results;
+  }
+  async snapStatus(snapName) {
+    let installed = false;
+    let version = null;
+    try {
+      const { stdout } = await run("snap", ["list", snapName]);
+      installed = true;
+      const secondLine = stdout.split("\n")[1];
+      if (secondLine) {
+        version = secondLine.split(/\s+/)[1] ?? null;
+      }
+    } catch {
+      return { installed: false, running: false, snapName, endpoint: null, version: null };
+    }
+    let running = false;
+    try {
+      await run(snapName, ["status"]);
+      running = true;
+    } catch {
+    }
+    const endpoint = running ? "http://localhost:9090/v1" : null;
+    return { installed, running, snapName, endpoint, version };
+  }
+  async snapInstall(snapName) {
+    const known = KNOWN_SNAPS.some(([name]) => name === snapName);
+    if (!known) throw new Error(`Unknown inference snap: ${snapName}`);
+    try {
+      const { stdout, stderr } = await execFileAsync3("sudo", ["snap", "install", snapName], {
+        timeout: 3e5
+        // 5 min for large snaps
+      });
+      return { success: true, message: stdout || stderr };
+    } catch (err) {
+      return { success: false, message: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async snapRemove(snapName) {
+    await execFileAsync3("sudo", ["snap", "remove", snapName], { timeout: 6e4 });
+  }
+};
+
+// src/server/rpc-server.ts
+import { existsSync as existsSync3, unlinkSync } from "fs";
+import { createServer as createServer2 } from "net";
+
+// src/detection/process-detector.ts
+import { execFile as execFile4 } from "child_process";
+import { readdir } from "fs/promises";
+import { join as join3 } from "path";
+import { promisify as promisify4 } from "util";
+var execFileAsync4 = promisify4(execFile4);
+async function findProcesses(pattern) {
+  try {
+    const { stdout } = await execFileAsync4("pgrep", ["-a", pattern], { timeout: 3e3 });
+    return stdout.trim().split("\n").filter(Boolean).map((line) => {
+      const spaceIdx = line.indexOf(" ");
+      const pid = parseInt(line.slice(0, spaceIdx), 10);
+      const command = line.slice(spaceIdx + 1);
+      return { pid, command };
+    });
+  } catch {
+    return [];
+  }
+}
+var HARNESS_PROCESS_PATTERNS = {
+  "claude-code": ["claude"],
+  cursor: ["cursor", "Cursor"],
+  copilot: ["copilot"]
+};
+async function findHarnessProcesses(harnessId) {
+  const patterns = HARNESS_PROCESS_PATTERNS[harnessId];
+  if (!patterns) return [];
+  const results = await Promise.all(patterns.map((p) => findProcesses(p)));
+  return results.flat().map((p) => ({ ...p, harnessId }));
+}
+async function findAllHarnessProcesses() {
+  const results = await Promise.all(
+    Object.keys(HARNESS_PROCESS_PATTERNS).map((id) => findHarnessProcesses(id))
+  );
+  return results.flat();
+}
+async function findClaudeCodeSockets() {
+  const dirs = [
+    "/tmp",
+    process.env.XDG_RUNTIME_DIR,
+    join3(process.env.HOME ?? "/tmp", ".claude")
+  ].filter(Boolean);
+  const sockets = [];
+  for (const dir of dirs) {
+    try {
+      const entries = await readdir(dir);
+      for (const entry of entries) {
+        if (/^claude.*\.sock$/.test(entry)) {
+          sockets.push(join3(dir, entry));
+        }
+      }
+    } catch {
+    }
+  }
+  return sockets;
+}
+
+// src/server/rpc-server.ts
+var ERR_PARSE = -32700;
+var ERR_INVALID_PARAMS = -32602;
+var ERR_METHOD_NOT_FOUND = -32601;
+var ERR_INTERNAL = -32603;
+var RpcServer = class {
+  constructor(registry, socketPath, store) {
+    this.registry = registry;
+    this.socketPath = socketPath;
+    this.store = store;
+    this.server.on("connection", (socket) => {
+      let buffer = "";
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          this.handleLine(line.trim(), (response) => {
+            socket.write(`${JSON.stringify(response)}
+`);
+          });
+        }
+      });
+    });
+  }
+  server = createServer2();
+  healthCheckFn = null;
+  spawner = null;
+  inference = null;
+  handleLine(line, reply) {
+    let req;
+    try {
+      req = JSON.parse(line);
+    } catch {
+      reply({ jsonrpc: "2.0", id: null, error: { code: ERR_PARSE, message: "Parse error" } });
+      return;
+    }
+    this.dispatch(req).then(reply).catch((err) => {
+      reply({
+        jsonrpc: "2.0",
+        id: req.id,
+        error: { code: ERR_INTERNAL, message: err instanceof Error ? err.message : String(err) }
+      });
+    });
+  }
+  async dispatch(req) {
+    const { id, method, params } = req;
+    const p = params ?? {};
+    switch (method) {
+      case "harness.list": {
+        const ids = await this.registry.listAvailable();
+        const infos = await Promise.all(ids.map((id2) => this.registry.get(id2)?.getInfo()));
+        return { jsonrpc: "2.0", id, result: infos };
+      }
+      case "harness.info": {
+        const harnessId = p.harnessId;
+        if (!harnessId) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: "harnessId required" }
+          };
+        }
+        const adapter = this.registry.get(harnessId);
+        if (!adapter) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: `Harness not found: ${harnessId}` }
+          };
+        }
+        return { jsonrpc: "2.0", id, result: await adapter.getInfo() };
+      }
+      case "harness.execute": {
+        const harnessId = p.harnessId;
+        const command = p.command;
+        if (!(harnessId && command)) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: "harnessId and command required" }
+          };
+        }
+        const adapter = this.registry.get(harnessId);
+        if (!adapter) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: `Harness not found: ${harnessId}` }
+          };
+        }
+        const result = await adapter.execute(command);
+        return { jsonrpc: "2.0", id, result };
+      }
+      case "harness.syncConfig": {
+        const harnessId = p.harnessId;
+        const direction = p.direction;
+        if (!(harnessId && direction)) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: "harnessId and direction required" }
+          };
+        }
+        return { jsonrpc: "2.0", id, result: syncConfig(harnessId, direction) };
+      }
+      case "harness.diffConfig": {
+        const harnessId = p.harnessId;
+        if (!harnessId) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: "harnessId required" }
+          };
+        }
+        return { jsonrpc: "2.0", id, result: diffConfig(harnessId) };
+      }
+      case "harness.listRunning": {
+        const harnessId = p.harnessId;
+        if (!harnessId) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INVALID_PARAMS, message: "harnessId required" }
+          };
+        }
+        const processes = await findHarnessProcesses(harnessId);
+        return { jsonrpc: "2.0", id, result: processes };
+      }
+      case "ping": {
+        return { jsonrpc: "2.0", id, result: { status: "ok", pid: process.pid } };
+      }
+      case "harness.health": {
+        if (!this.healthCheckFn) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: ERR_INTERNAL, message: "Health check not configured" }
+          };
+        }
+        const health = await this.healthCheckFn();
+        return { jsonrpc: "2.0", id, result: health };
+      }
+      // -----------------------------------------------------------------------
+      // Session management (PGlite-backed)
+      // -----------------------------------------------------------------------
+      case "session.register": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        const env = p.env;
+        if (!agentId) return this.missingParam(id, "agentId");
+        const session = await this.store.registerSession({
+          id: agentId,
+          env: env ?? agentId,
+          task: p.task,
+          pid: p.pid
+        });
+        return { jsonrpc: "2.0", id, result: { session } };
+      }
+      case "session.update": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        if (!agentId) return this.missingParam(id, "agentId");
+        const session = await this.store.updateSession(agentId, {
+          task: p.task,
+          files: p.files
+        });
+        return { jsonrpc: "2.0", id, result: session };
+      }
+      case "session.end": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        if (!agentId) return this.missingParam(id, "agentId");
+        await this.store.endSession(agentId, p.exitSummary);
+        await this.store.releaseAllReservations(agentId);
+        await this.store.logEvent({
+          agentId,
+          eventType: "session-end",
+          payload: { exitSummary: p.exitSummary }
+        });
+        return { jsonrpc: "2.0", id, result: { ok: true } };
+      }
+      case "session.list": {
+        if (!this.store) return this.noStore(id);
+        const sessions = await this.store.getActiveSessions();
+        return { jsonrpc: "2.0", id, result: sessions };
+      }
+      case "session.history": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        if (!agentId) return this.missingParam(id, "agentId");
+        const limit = p.limit ?? 10;
+        const history = await this.store.getSessionHistory(agentId, limit);
+        return { jsonrpc: "2.0", id, result: history };
+      }
+      // -----------------------------------------------------------------------
+      // Inter-agent messaging (PGlite-backed)
+      // -----------------------------------------------------------------------
+      case "mail.send": {
+        if (!this.store) return this.noStore(id);
+        const fromAgent = p.fromAgent;
+        const toAgent = p.toAgent;
+        const subject = p.subject;
+        if (!(fromAgent && toAgent && subject)) {
+          return this.missingParam(id, "fromAgent, toAgent, subject");
+        }
+        const msg = await this.store.sendMessage({
+          fromAgent,
+          toAgent,
+          subject,
+          body: p.body
+        });
+        return { jsonrpc: "2.0", id, result: msg };
+      }
+      case "mail.broadcast": {
+        if (!this.store) return this.noStore(id);
+        const fromAgent = p.fromAgent;
+        const subject = p.subject;
+        if (!(fromAgent && subject)) return this.missingParam(id, "fromAgent, subject");
+        const sent = await this.store.broadcastMessage({
+          fromAgent,
+          subject,
+          body: p.body
+        });
+        return { jsonrpc: "2.0", id, result: { sent } };
+      }
+      case "mail.inbox": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        if (!agentId) return this.missingParam(id, "agentId");
+        const unreadOnly = p.unreadOnly ?? true;
+        const messages = await this.store.getInbox(agentId, unreadOnly);
+        return { jsonrpc: "2.0", id, result: messages };
+      }
+      case "mail.markRead": {
+        if (!this.store) return this.noStore(id);
+        const messageIds = p.messageIds;
+        if (!messageIds) return this.missingParam(id, "messageIds");
+        await this.store.markRead(messageIds);
+        return { jsonrpc: "2.0", id, result: { ok: true } };
+      }
+      // -----------------------------------------------------------------------
+      // File reservations (PGlite-backed)
+      // -----------------------------------------------------------------------
+      case "files.reserve": {
+        if (!this.store) return this.noStore(id);
+        const filePath = p.filePath;
+        const agentId = p.agentId;
+        if (!(filePath && agentId)) return this.missingParam(id, "filePath, agentId");
+        const ttlSeconds = p.ttlSeconds ?? 3600;
+        const reservation = await this.store.reserveFile({
+          filePath,
+          agentId,
+          ttlSeconds,
+          reason: p.reason
+        });
+        return { jsonrpc: "2.0", id, result: reservation };
+      }
+      case "files.check": {
+        if (!this.store) return this.noStore(id);
+        const filePath = p.filePath;
+        if (!filePath) return this.missingParam(id, "filePath");
+        const reservation = await this.store.checkReservation(filePath);
+        return { jsonrpc: "2.0", id, result: reservation };
+      }
+      case "files.release": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        if (!agentId) return this.missingParam(id, "agentId");
+        const released = await this.store.releaseAllReservations(agentId);
+        return { jsonrpc: "2.0", id, result: { released } };
+      }
+      case "files.list": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        if (!agentId) return this.missingParam(id, "agentId");
+        const reservations = await this.store.getReservations(agentId);
+        return { jsonrpc: "2.0", id, result: reservations };
+      }
+      // -----------------------------------------------------------------------
+      // Tasks (PGlite-backed)
+      // -----------------------------------------------------------------------
+      case "tasks.create": {
+        if (!this.store) return this.noStore(id);
+        const taskId = p.taskId;
+        const description = p.description;
+        if (!taskId) return this.missingParam(id, "taskId");
+        const task = await this.store.createTask({ id: taskId, description: description ?? "" });
+        return { jsonrpc: "2.0", id, result: task };
+      }
+      case "tasks.claim": {
+        if (!this.store) return this.noStore(id);
+        const taskId = p.taskId;
+        const agentId = p.agentId;
+        if (!(taskId && agentId)) return this.missingParam(id, "taskId, agentId");
+        const claim = await this.store.claimTask(taskId, agentId);
+        return { jsonrpc: "2.0", id, result: claim };
+      }
+      case "tasks.complete": {
+        if (!this.store) return this.noStore(id);
+        const taskId = p.taskId;
+        const agentId = p.agentId;
+        if (!(taskId && agentId)) return this.missingParam(id, "taskId, agentId");
+        const completed = await this.store.completeTask(taskId, agentId);
+        return { jsonrpc: "2.0", id, result: { ok: completed } };
+      }
+      case "tasks.release": {
+        if (!this.store) return this.noStore(id);
+        const taskId = p.taskId;
+        const agentId = p.agentId;
+        if (!(taskId && agentId)) return this.missingParam(id, "taskId, agentId");
+        const released = await this.store.releaseTask(taskId, agentId);
+        return { jsonrpc: "2.0", id, result: { ok: released } };
+      }
+      case "tasks.list": {
+        if (!this.store) return this.noStore(id);
+        const tasks = await this.store.listTasks({
+          status: p.status,
+          owner: p.owner
+        });
+        return { jsonrpc: "2.0", id, result: tasks };
+      }
+      // -----------------------------------------------------------------------
+      // Events (PGlite-backed)
+      // -----------------------------------------------------------------------
+      case "events.log": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        const eventType = p.eventType;
+        if (!(agentId && eventType)) return this.missingParam(id, "agentId, eventType");
+        const event = await this.store.logEvent({
+          agentId,
+          eventType,
+          payload: p.payload
+        });
+        return { jsonrpc: "2.0", id, result: event };
+      }
+      case "events.recent": {
+        if (!this.store) return this.noStore(id);
+        const limit = p.limit ?? 50;
+        const events = await this.store.getRecentEvents(limit);
+        return { jsonrpc: "2.0", id, result: events };
+      }
+      // -----------------------------------------------------------------------
+      // Agent spawner (process management)
+      // -----------------------------------------------------------------------
+      case "agent.spawn": {
+        if (!this.spawner) return this.noService(id, "spawner");
+        const name = p.name;
+        const backend = p.backend;
+        const model = p.model;
+        const prompt = p.prompt;
+        if (!(name && backend && model && prompt)) {
+          return this.missingParam(id, "name, backend, model, prompt");
+        }
+        const sessionId = this.spawner.spawn(
+          name,
+          backend,
+          model,
+          prompt
+        );
+        return { jsonrpc: "2.0", id, result: { sessionId } };
+      }
+      case "agent.stop": {
+        if (!this.spawner) return this.noService(id, "spawner");
+        const sessionId = p.sessionId;
+        if (!sessionId) return this.missingParam(id, "sessionId");
+        this.spawner.stop(sessionId);
+        return { jsonrpc: "2.0", id, result: { ok: true } };
+      }
+      case "agent.list": {
+        if (!this.spawner) return this.noService(id, "spawner");
+        return { jsonrpc: "2.0", id, result: this.spawner.list() };
+      }
+      case "agent.remove": {
+        if (!this.spawner) return this.noService(id, "spawner");
+        const sessionId = p.sessionId;
+        if (!sessionId) return this.missingParam(id, "sessionId");
+        this.spawner.remove(sessionId);
+        return { jsonrpc: "2.0", id, result: { ok: true } };
+      }
+      // -----------------------------------------------------------------------
+      // Inference management (Ollama, BitNet, Snaps)
+      // -----------------------------------------------------------------------
+      case "inference.ollama.status": {
+        if (!this.inference) return this.noService(id, "inference");
+        return { jsonrpc: "2.0", id, result: await this.inference.ollamaStatus() };
+      }
+      case "inference.ollama.models": {
+        if (!this.inference) return this.noService(id, "inference");
+        return { jsonrpc: "2.0", id, result: await this.inference.ollamaModels() };
+      }
+      case "inference.ollama.pull": {
+        if (!this.inference) return this.noService(id, "inference");
+        const modelName = p.modelName;
+        if (!modelName) return this.missingParam(id, "modelName");
+        return { jsonrpc: "2.0", id, result: await this.inference.ollamaPull(modelName) };
+      }
+      case "inference.ollama.delete": {
+        if (!this.inference) return this.noService(id, "inference");
+        const modelName = p.modelName;
+        if (!modelName) return this.missingParam(id, "modelName");
+        await this.inference.ollamaDelete(modelName);
+        return { jsonrpc: "2.0", id, result: { ok: true } };
+      }
+      case "inference.ollama.start": {
+        if (!this.inference) return this.noService(id, "inference");
+        await this.inference.ollamaStart();
+        return { jsonrpc: "2.0", id, result: { ok: true } };
+      }
+      case "inference.ollama.stop": {
+        if (!this.inference) return this.noService(id, "inference");
+        await this.inference.ollamaStop();
+        return { jsonrpc: "2.0", id, result: { ok: true } };
+      }
+      case "inference.bitnet.status": {
+        if (!this.inference) return this.noService(id, "inference");
+        return { jsonrpc: "2.0", id, result: await this.inference.bitnetStatus() };
+      }
+      case "inference.snap.list": {
+        if (!this.inference) return this.noService(id, "inference");
+        return { jsonrpc: "2.0", id, result: await this.inference.snapList() };
+      }
+      case "inference.snap.status": {
+        if (!this.inference) return this.noService(id, "inference");
+        const snapName = p.snapName;
+        if (!snapName) return this.missingParam(id, "snapName");
+        return { jsonrpc: "2.0", id, result: await this.inference.snapStatus(snapName) };
+      }
+      case "inference.snap.install": {
+        if (!this.inference) return this.noService(id, "inference");
+        const snapName = p.snapName;
+        if (!snapName) return this.missingParam(id, "snapName");
+        return { jsonrpc: "2.0", id, result: await this.inference.snapInstall(snapName) };
+      }
+      case "inference.snap.remove": {
+        if (!this.inference) return this.noService(id, "inference");
+        const snapName = p.snapName;
+        if (!snapName) return this.missingParam(id, "snapName");
+        await this.inference.snapRemove(snapName);
+        return { jsonrpc: "2.0", id, result: { ok: true } };
+      }
+      default:
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: { code: ERR_METHOD_NOT_FOUND, message: `Method not found: ${method}` }
+        };
+    }
+  }
+  /** Helper: store not configured error. */
+  noStore(id) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      error: { code: ERR_INTERNAL, message: "Daemon store not initialized" }
+    };
+  }
+  /** Helper: missing parameter error. */
+  missingParam(id, param) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      error: { code: ERR_INVALID_PARAMS, message: `Missing required parameter: ${param}` }
+    };
+  }
+  /** Helper: service not configured error. */
+  noService(id, service) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      error: { code: ERR_INTERNAL, message: `${service} service not initialized` }
+    };
+  }
+  /**
+   * Dispatch an HTTP request body (JSON-RPC) and call the reply callback.
+   * Used by HttpGateway to proxy requests without going through a socket.
+   */
+  dispatchHttp(body, reply) {
+    this.handleLine(body.trim(), reply);
+  }
+  /** Set the health check function (called by coordinator after construction). */
+  setHealthCheck(fn) {
+    this.healthCheckFn = fn;
+  }
+  /** Attach the spawner service (called by coordinator after construction). */
+  setSpawner(spawner) {
+    this.spawner = spawner;
+  }
+  /** Attach the inference service (called by coordinator after construction). */
+  setInference(inference) {
+    this.inference = inference;
+  }
+  /** Get the spawner service (used by HTTP gateway for SSE). */
+  getSpawner() {
+    return this.spawner;
+  }
+  start() {
+    if (existsSync3(this.socketPath)) {
+      unlinkSync(this.socketPath);
+    }
+    return new Promise((resolve, reject) => {
+      this.server.listen(this.socketPath, () => resolve());
+      this.server.once("error", reject);
+    });
+  }
+  stop() {
+    return new Promise((resolve) => this.server.close(() => resolve()));
+  }
+};
+
+// src/server/spawner-service.ts
+import { spawn as nodeSpawn } from "child_process";
+import { randomUUID } from "crypto";
+import { EventEmitter } from "events";
+var DEFAULT_CONFIG2 = {
+  snapEndpoint: "http://localhost:9090",
+  maxSessions: 8
+};
+var SpawnerService = class extends EventEmitter {
+  sessions = /* @__PURE__ */ new Map();
+  config;
+  constructor(overrides) {
+    super();
+    this.config = { ...DEFAULT_CONFIG2, ...overrides };
+  }
+  /** Spawn a new agent process. Returns the session ID. */
+  spawn(name, backend, model, prompt) {
+    if (this.sessions.size >= this.config.maxSessions) {
+      throw new Error(`Max sessions (${this.config.maxSessions}) reached`);
+    }
+    const sessionId = randomUUID();
+    let child;
+    switch (backend) {
+      case "Snap": {
+        const body = JSON.stringify({
+          model,
+          messages: [{ role: "user", content: prompt }],
+          stream: false
+        });
+        child = nodeSpawn(
+          "curl",
+          [
+            "-s",
+            "-X",
+            "POST",
+            `${this.config.snapEndpoint}/v1/chat/completions`,
+            "-H",
+            "Content-Type: application/json",
+            "-d",
+            body
+          ],
+          { stdio: ["ignore", "pipe", "pipe"] }
+        );
+        break;
+      }
+      case "Ollama": {
+        child = nodeSpawn("ollama", ["run", model, prompt], {
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        break;
+      }
+      case "BitNet": {
+        child = nodeSpawn("bitnet", ["run", "--model", model, "--prompt", prompt], {
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        break;
+      }
+    }
+    const proc = { name, model, backend, prompt, child, status: "running" };
+    this.sessions.set(sessionId, proc);
+    child.stdout?.on("data", (chunk) => {
+      const lines = chunk.toString().split("\n");
+      for (const line of lines) {
+        if (line.length > 0) {
+          this.emit("output", { sessionId, stream: "stdout", line });
+        }
+      }
+    });
+    child.stderr?.on("data", (chunk) => {
+      const lines = chunk.toString().split("\n");
+      for (const line of lines) {
+        if (line.length > 0) {
+          this.emit("output", { sessionId, stream: "stderr", line });
+        }
+      }
+    });
+    child.on("close", (code) => {
+      proc.status = code === 0 ? "stopped" : "errored";
+      this.emit("exit", { sessionId, code });
+    });
+    child.on("error", () => {
+      proc.status = "errored";
+      this.emit("exit", { sessionId, code: null });
+    });
+    return sessionId;
+  }
+  /** Stop a running agent by killing its process. */
+  stop(sessionId) {
+    const proc = this.sessions.get(sessionId);
+    if (!proc) throw new Error(`No agent session: ${sessionId}`);
+    if (proc.status !== "running") throw new Error(`Agent is not running (${proc.status})`);
+    proc.child.kill("SIGTERM");
+    proc.status = "stopped";
+  }
+  /** List all agent sessions. */
+  list() {
+    const result = [];
+    for (const [id, proc] of this.sessions) {
+      result.push({
+        id,
+        name: proc.name,
+        model: proc.model,
+        backend: proc.backend,
+        prompt: proc.prompt,
+        status: proc.status,
+        pid: proc.child.pid ?? null
+      });
+    }
+    return result;
+  }
+  /** Remove a stopped/errored session. */
+  remove(sessionId) {
+    const proc = this.sessions.get(sessionId);
+    if (!proc) throw new Error(`No agent session: ${sessionId}`);
+    if (proc.status === "running") throw new Error("Cannot remove a running agent \u2014 stop it first");
+    this.sessions.delete(sessionId);
+  }
+  /** Kill all running agents (called on daemon shutdown). */
+  stopAll() {
+    for (const [, proc] of this.sessions) {
+      if (proc.status === "running") {
+        proc.child.kill("SIGTERM");
+        proc.status = "stopped";
+      }
+    }
+  }
+};
+
+// src/coordinator.ts
+var HarnessCoordinator = class {
+  constructor(options) {
+    this.options = options;
+    const workboardPath = join4(options.projectRoot, ".claude", "workboard.md");
+    this.workboard = new WorkboardManager(workboardPath);
+  }
+  registry = new HarnessRegistry();
+  rpcServer = null;
+  httpGateway = null;
+  store = null;
+  spawner = null;
+  inference = null;
+  sessionId = null;
+  workboard;
+  async start() {
+    await autoDetectHarnesses(this.registry);
+    const type = detectSessionType();
+    const state = this.workboard.read();
+    const existingIds = state.agents.map((a) => a.id);
+    this.sessionId = deriveSessionId(type, existingIds);
+    const envLabels = {
+      zed: "Zed/ACP",
+      cursor: "Cursor",
+      terminal: "WSL/bash"
+    };
+    this.workboard.registerAgent({
+      id: this.sessionId,
+      env: envLabels[type] ?? type,
+      started: `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)}Z`,
+      task: this.options.task ?? "Harness coordination active",
+      files: "",
+      updated: `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)}Z`
+    });
+    const dataDir = join4(process.env.HOME ?? "/tmp", ".local", "share", "revealui", "harness.db");
+    mkdirSync2(dataDir, { recursive: true });
+    this.store = new DaemonStore({ dataDir });
+    await this.store.init();
+    const socketPath = this.options.socketPath ?? join4(process.env.HOME ?? "/tmp", ".local", "share", "revealui", "harness.sock");
+    this.rpcServer = new RpcServer(this.registry, socketPath, this.store);
+    this.rpcServer.setHealthCheck(() => this.healthCheck());
+    this.spawner = new SpawnerService();
+    this.inference = new InferenceService();
+    this.rpcServer.setSpawner(this.spawner);
+    this.rpcServer.setInference(this.inference);
+    await this.rpcServer.start();
+    if (this.options.httpPort) {
+      this.httpGateway = new HttpGateway({
+        port: this.options.httpPort,
+        host: this.options.httpHost ?? "0.0.0.0",
+        staticDir: this.options.httpStaticDir,
+        rpcDispatch: this.rpcServer,
+        spawner: this.spawner
+      });
+      await this.httpGateway.start();
+    }
+  }
+  async stop() {
+    if (this.sessionId) {
+      this.workboard.unregisterAgent(this.sessionId);
+      this.workboard.addLogEntry(
+        this.sessionId,
+        `Session ended \u2014 ${this.options.task ?? "harness coordination"}`
+      );
+    }
+    if (this.httpGateway) {
+      await this.httpGateway.stop();
+      this.httpGateway = null;
+    }
+    if (this.spawner) {
+      await this.spawner.stopAll();
+      this.spawner = null;
+    }
+    this.inference = null;
+    if (this.rpcServer) {
+      await this.rpcServer.stop();
+      this.rpcServer = null;
+    }
+    if (this.store) {
+      await this.store.close();
+      this.store = null;
+    }
+    await this.registry.disposeAll();
+  }
+  /** The registry of detected harnesses. Available after start(). */
+  getRegistry() {
+    return this.registry;
+  }
+  /** The workboard manager. */
+  getWorkboard() {
+    return this.workboard;
+  }
+  /** The daemon persistent store (available after start()). */
+  getStore() {
+    return this.store;
+  }
+  /** Register a custom adapter (must be called before start()). */
+  registerAdapter(adapter) {
+    this.registry.register(adapter);
+  }
+  /** The HTTP gateway (available after start() if httpPort was set). */
+  getHttpGateway() {
+    return this.httpGateway;
+  }
+  /** Run a health check across all registered harnesses and the workboard. */
+  async healthCheck() {
+    const diagnostics = [];
+    const StaleMs = 4 * 60 * 60 * 1e3;
+    const allIds = this.registry.listAll();
+    const registeredHarnesses = await Promise.all(
+      allIds.map(async (harnessId) => {
+        const adapter = this.registry.get(harnessId);
+        let available = false;
+        try {
+          available = adapter ? await adapter.isAvailable() : false;
+        } catch (err) {
+          diagnostics.push(
+            `${harnessId}: availability check failed \u2014 ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        if (!available) diagnostics.push(`${harnessId}: not available`);
+        return { harnessId, available };
+      })
+    );
+    let readable = false;
+    let sessionCount = 0;
+    const staleSessionIds = [];
+    try {
+      const state = this.workboard.read();
+      readable = true;
+      sessionCount = state.agents.length;
+      const now = Date.now();
+      for (const s of state.agents) {
+        const ts = Date.parse(s.updated);
+        if (!Number.isNaN(ts) && now - ts > StaleMs) {
+          staleSessionIds.push(s.id);
+        }
+      }
+      if (staleSessionIds.length > 0) {
+        diagnostics.push(`Stale sessions: ${staleSessionIds.join(", ")}`);
+      }
+    } catch (err) {
+      diagnostics.push(`Workboard unreadable: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const healthy = registeredHarnesses.some((h) => h.available) && readable && staleSessionIds.length === 0;
+    return {
+      healthy,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      registeredHarnesses,
+      workboard: { readable, sessionCount, staleSessionIds },
+      diagnostics
+    };
+  }
+};
+
+// src/index.ts
+async function checkHarnessesLicense() {
+  await initializeLicense();
+  if (!isFeatureEnabled("ai")) {
+    logger.warn(
+      "[@revealui/harnesses] AI harness integration requires a Pro or Enterprise license. Visit https://revealui.com/pricing for details.",
+      { feature: "ai" }
+    );
+    return false;
+  }
+  return true;
+}
+
+export {
+  ClaudeCodeAdapter,
+  CursorAdapter,
+  autoDetectHarnesses,
+  HarnessRegistry,
+  getLocalConfigPath,
+  getRootConfigPath,
+  getConfigurableHarnesses,
+  syncConfig,
+  diffConfig,
+  syncAllConfigs,
+  diffAllConfigs,
+  validateConfigJson,
+  findProcesses,
+  findHarnessProcesses,
+  findAllHarnessProcesses,
+  findClaudeCodeSockets,
+  RpcServer,
+  HarnessCoordinator,
+  checkHarnessesLicense
+};
+//# sourceMappingURL=chunk-6E2BKO6U.js.map