@revealui/harnesses 0.1.7 → 0.1.9

package/dist/chunk-YYAYTCRM.js

@@ -0,0 +1,3016 @@
+import {
+  DaemonStore
+} from "./chunk-ANX4L2PF.js";
+import {
+  WorkboardManager,
+  deriveSessionId,
+  detectSessionType
+} from "./chunk-Y4FFO3TO.js";
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
+
+// src/index.ts
+import { isFeatureEnabled } from "@revealui/core/features";
+import { initializeLicense } from "@revealui/core/license";
+import { logger } from "@revealui/core/observability/logger";
+
+// 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/coordination/ci-feedback.ts
+var MAX_RETRIES = 3;
+var CIFeedback = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  /**
+   * Handle a CI report. Called when GitHub Actions posts results
+   * to the daemon HTTP gateway.
+   */
+  async report(params) {
+    const mr = await this.findMergeRequest(params);
+    if (!mr) {
+      return { action: "no_merge_request" };
+    }
+    await this.store.logEvent({
+      agentId: mr.agent_id,
+      eventType: params.success ? "ci-passed" : "ci-failed",
+      payload: {
+        mergeId: mr.id,
+        prNumber: params.prNumber,
+        failedJob: params.failedJob,
+        runUrl: params.runUrl
+      }
+    });
+    if (params.success) {
+      return this.handleSuccess(mr);
+    }
+    return this.handleFailure(mr, params);
+  }
+  // ---------------------------------------------------------------------------
+  // Private  -  success path
+  // ---------------------------------------------------------------------------
+  async handleSuccess(mr) {
+    await this.store.updateMergeRequest(mr.id, { status: "merged" });
+    if (mr.task_id) {
+      await this.store.completeTask(mr.task_id, mr.agent_id);
+    }
+    await this.store.updateWorktreeStatus(mr.agent_id, "merged");
+    await this.store.sendMessage({
+      fromAgent: "ci-feedback",
+      toAgent: mr.agent_id,
+      subject: "CI passed  -  PR ready to merge",
+      body: `PR ${mr.pr_url ?? `#${mr.pr_number}`} passed CI. Merge request ${mr.id} is complete.`
+    });
+    await this.store.storeMemory({
+      agentId: mr.agent_id,
+      memoryType: "result",
+      content: `CI passed for ${mr.source_branch}. PR ${mr.pr_number ?? "(unknown)"} is ready.`,
+      metadata: { mergeId: mr.id, prNumber: mr.pr_number }
+    });
+    return { action: "merged", mergeRequestId: mr.id };
+  }
+  // ---------------------------------------------------------------------------
+  // Private  -  failure path
+  // ---------------------------------------------------------------------------
+  async handleFailure(mr, params) {
+    const retryCount = await this.store.incrementMergeRetry(mr.id);
+    await this.store.updateMergeRequest(mr.id, {
+      status: "ci_failed",
+      ciOutput: params.output?.slice(0, 1e4),
+      errorMessage: `CI failed (attempt ${retryCount}/${MAX_RETRIES}): ${params.failedJob ?? "unknown job"}`
+    });
+    if (retryCount >= MAX_RETRIES) {
+      return this.escalate(mr, retryCount, params);
+    }
+    const category = this.categorizeFailure(params);
+    const taskId = `fix-${mr.id}-${retryCount}`;
+    const description = this.buildFixTaskDescription(mr, category, params);
+    await this.store.createTask({ id: taskId, description });
+    await this.store.claimTask(taskId, mr.agent_id);
+    await this.store.sendMessage({
+      fromAgent: "ci-feedback",
+      toAgent: mr.agent_id,
+      subject: `CI failed \u2014 fix task created (attempt ${retryCount}/${MAX_RETRIES})`,
+      body: description
+    });
+    await this.store.storeMemory({
+      agentId: mr.agent_id,
+      memoryType: "action",
+      content: `CI failed on ${mr.source_branch}: ${category} error. Fix task ${taskId} created. Attempt ${retryCount}/${MAX_RETRIES}.`,
+      metadata: {
+        mergeId: mr.id,
+        category,
+        failedJob: params.failedJob,
+        retryCount
+      }
+    });
+    return {
+      action: "fix_task_created",
+      mergeRequestId: mr.id,
+      taskId,
+      retryCount
+    };
+  }
+  /** Escalate to human after max retries. */
+  async escalate(mr, retryCount, params) {
+    await this.store.updateMergeRequest(mr.id, { status: "escalated" });
+    await this.store.broadcastMessage({
+      fromAgent: "ci-feedback",
+      subject: `ESCALATION: ${mr.source_branch} failed CI ${retryCount} times`,
+      body: [
+        `Merge request ${mr.id} has failed CI ${retryCount} times and needs human intervention.`,
+        `Agent: ${mr.agent_id}`,
+        `Branch: ${mr.source_branch} \u2192 ${mr.base_branch}`,
+        `PR: ${mr.pr_url ?? `#${mr.pr_number}`}`,
+        `Last failure: ${params.failedJob ?? "unknown"}`,
+        `Run: ${params.runUrl ?? "no URL"}`
+      ].join("\n")
+    });
+    await this.store.logEvent({
+      agentId: mr.agent_id,
+      eventType: "merge-escalated",
+      payload: {
+        mergeId: mr.id,
+        retryCount,
+        failedJob: params.failedJob,
+        runUrl: params.runUrl
+      }
+    });
+    return {
+      action: "escalated",
+      mergeRequestId: mr.id,
+      retryCount
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Private  -  helpers
+  // ---------------------------------------------------------------------------
+  /** Find the merge request associated with this CI run. */
+  async findMergeRequest(params) {
+    if (params.prNumber) {
+      const mr = await this.store.getMergeRequestByPr(params.prNumber);
+      if (mr) return mr;
+    }
+    if (params.branch) {
+      return this.store.getMergeRequestByBranch(params.branch);
+    }
+    return null;
+  }
+  /** Categorize the CI failure from the job name or output. */
+  categorizeFailure(params) {
+    const job = params.failedJob?.toLowerCase() ?? "";
+    const output = params.output?.toLowerCase() ?? "";
+    if (job.includes("lint") || job.includes("quality")) return "lint";
+    if (job.includes("typecheck") || job.includes("type")) return "typecheck";
+    if (job.includes("test") && !job.includes("e2e")) return "test";
+    if (job.includes("build")) return "build";
+    if (job.includes("e2e") || job.includes("playwright")) return "e2e";
+    if (output.includes("biome") || output.includes("lint")) return "lint";
+    if (output.includes("ts2") || output.includes("type error")) return "typecheck";
+    if (output.includes("vitest") || output.includes("test failed")) return "test";
+    if (output.includes("build failed") || output.includes("esbuild")) return "build";
+    return "unknown";
+  }
+  /** Build a descriptive fix task for the agent. */
+  buildFixTaskDescription(mr, category, params) {
+    const lines = [`Fix CI ${category} failure on branch ${mr.source_branch}.`];
+    switch (category) {
+      case "lint":
+        lines.push("Run `pnpm lint:fix` and commit the changes.");
+        break;
+      case "typecheck":
+        lines.push("Run `pnpm typecheck:all` locally and fix type errors.");
+        break;
+      case "test":
+        lines.push("Run `pnpm test` locally and fix failing tests.");
+        break;
+      case "build":
+        lines.push("Run `pnpm build` locally and fix build errors.");
+        break;
+      case "e2e":
+        lines.push("Check Playwright E2E test output and fix the failing scenarios.");
+        break;
+      default:
+        lines.push("Review the CI output and fix the issue.");
+    }
+    if (params.runUrl) {
+      lines.push(`CI run: ${params.runUrl}`);
+    }
+    if (params.output) {
+      const truncated = params.output.slice(0, 2e3);
+      lines.push("", "CI output (truncated):", "```", truncated, "```");
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/coordination/merge-pipeline.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var GIT_TIMEOUT = 3e4;
+var GH_TIMEOUT = 15e3;
+async function getWorkspaceDependencyOrder(repoRoot) {
+  try {
+    const { stdout } = await execFileAsync("pnpm", ["ls", "--depth", "0", "--json", "-r"], {
+      cwd: repoRoot,
+      timeout: GIT_TIMEOUT
+    });
+    const packages = JSON.parse(stdout);
+    return packages.map((p) => p.name);
+  } catch {
+    return [];
+  }
+}
+var MergePipeline = class {
+  constructor(store, config) {
+    this.store = store;
+    this.repoRoot = config.repoRoot;
+    this.baseBranch = config.baseBranch ?? "test";
+    this.remote = config.remote ?? "origin";
+  }
+  store;
+  repoRoot;
+  baseBranch;
+  remote;
+  /**
+   * Request a merge for an agent's branch into the base branch.
+   * Creates a merge_request record and attempts the merge.
+   */
+  async requestMerge(params) {
+    const mergeId = `merge-${params.agentId}-${Date.now()}`;
+    const baseBranch = params.baseBranch ?? this.baseBranch;
+    await this.store.createMergeRequest({
+      id: mergeId,
+      agentId: params.agentId,
+      taskId: params.taskId,
+      sourceBranch: params.sourceBranch,
+      baseBranch
+    });
+    await this.store.logEvent({
+      agentId: params.agentId,
+      eventType: "merge-requested",
+      payload: { mergeId, sourceBranch: params.sourceBranch, baseBranch }
+    });
+    return this.processMerge(mergeId);
+  }
+  /**
+   * Process a pending merge request: fetch, check for conflicts,
+   * fast-forward merge, and create a PR.
+   */
+  async processMerge(mergeId) {
+    const mr = await this.store.getMergeRequest(mergeId);
+    if (!mr) {
+      return { mergeRequestId: mergeId, status: "pending", error: "Merge request not found" };
+    }
+    await this.store.updateMergeRequest(mergeId, { status: "merging" });
+    try {
+      await this.git(["fetch", this.remote, mr.base_branch, mr.source_branch]);
+      const conflictCheck = await this.checkConflicts(mr.source_branch, mr.base_branch);
+      if (!conflictCheck.clean) {
+        await this.handleConflict(mr, conflictCheck.conflictingFiles);
+        return {
+          mergeRequestId: mergeId,
+          status: "conflict",
+          conflictingFiles: conflictCheck.conflictingFiles,
+          error: `Merge conflict in: ${conflictCheck.conflictingFiles.join(", ")}`
+        };
+      }
+      const prResult = await this.createPR(mr);
+      await this.store.updateMergeRequest(mergeId, {
+        status: "pr_created",
+        prNumber: prResult.number,
+        prUrl: prResult.url
+      });
+      await this.store.logEvent({
+        agentId: mr.agent_id,
+        eventType: "pr-created",
+        payload: { mergeId, prNumber: prResult.number, prUrl: prResult.url }
+      });
+      return {
+        mergeRequestId: mergeId,
+        status: "pr_created",
+        prUrl: prResult.url,
+        prNumber: prResult.number
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      await this.store.updateMergeRequest(mergeId, {
+        status: "ci_failed",
+        errorMessage: message
+      });
+      return { mergeRequestId: mergeId, status: "ci_failed", error: message };
+    }
+  }
+  /** Get the current status of a merge request. */
+  async getStatus(mergeId) {
+    const mr = await this.store.getMergeRequest(mergeId);
+    if (!mr) {
+      return { mergeRequestId: mergeId, status: "pending", error: "Not found" };
+    }
+    return {
+      mergeRequestId: mergeId,
+      status: mr.status,
+      prUrl: mr.pr_url ?? void 0,
+      prNumber: mr.pr_number ?? void 0,
+      error: mr.error_message ?? void 0
+    };
+  }
+  /** Retry a failed or conflicted merge request. */
+  async resolve(mergeId) {
+    const mr = await this.store.getMergeRequest(mergeId);
+    if (!mr) {
+      return { mergeRequestId: mergeId, status: "pending", error: "Not found" };
+    }
+    if (mr.status !== "conflict" && mr.status !== "ci_failed") {
+      return {
+        mergeRequestId: mergeId,
+        status: mr.status,
+        error: `Cannot resolve: status is ${mr.status}`
+      };
+    }
+    await this.store.updateMergeRequest(mergeId, { status: "pending", errorMessage: "" });
+    return this.processMerge(mergeId);
+  }
+  /** List all active (non-terminal) merge requests. */
+  async listActive() {
+    const all = await this.store.listMergeRequests();
+    return all.filter((mr) => mr.status !== "merged" && mr.status !== "escalated");
+  }
+  /**
+   * Get the workspace dependency order for merge sequencing.
+   * Packages that are dependencies of others should merge first.
+   */
+  async getDependencyOrder() {
+    return getWorkspaceDependencyOrder(this.repoRoot);
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  /** Run a git command in the repo root. */
+  async git(args) {
+    const { stdout } = await execFileAsync("git", args, {
+      cwd: this.repoRoot,
+      timeout: GIT_TIMEOUT
+    });
+    return stdout.trim();
+  }
+  /**
+   * Check whether source branch merges cleanly into base branch.
+   * Uses `git merge-tree` (available in Git 2.38+) for a tree-only check
+   * that doesn't touch the working directory.
+   */
+  async checkConflicts(sourceBranch, baseBranch) {
+    try {
+      await execFileAsync(
+        "git",
+        [
+          "merge-tree",
+          "--write-tree",
+          `${this.remote}/${baseBranch}`,
+          `${this.remote}/${sourceBranch}`
+        ],
+        { cwd: this.repoRoot, timeout: GIT_TIMEOUT }
+      );
+      return { clean: true, conflictingFiles: [] };
+    } catch (err) {
+      const output = err instanceof Error && "stdout" in err ? String(err.stdout) : "";
+      const conflicting = [];
+      for (const line of output.split("\n")) {
+        if (line.startsWith("CONFLICT")) {
+          const parts = line.split(" ");
+          const lastPart = parts[parts.length - 1];
+          if (lastPart) conflicting.push(lastPart);
+        }
+      }
+      return { clean: false, conflictingFiles: conflicting };
+    }
+  }
+  /** Notify conflicting agents via the messaging system. */
+  async handleConflict(mr, conflictingFiles) {
+    await this.store.updateMergeRequest(mr.id, {
+      status: "conflict",
+      errorMessage: `Conflict in: ${conflictingFiles.join(", ")}`
+    });
+    const notifiedAgents = /* @__PURE__ */ new Set();
+    for (const file of conflictingFiles) {
+      const reservation = await this.store.checkReservation(file);
+      if (reservation && reservation.agent_id !== mr.agent_id) {
+        notifiedAgents.add(reservation.agent_id);
+      }
+    }
+    for (const agentId of notifiedAgents) {
+      await this.store.sendMessage({
+        fromAgent: "merge-pipeline",
+        toAgent: agentId,
+        subject: `Merge conflict with ${mr.agent_id}`,
+        body: `Branch ${mr.source_branch} conflicts with your work on: ${conflictingFiles.join(", ")}. Please coordinate resolution.`
+      });
+    }
+    await this.store.sendMessage({
+      fromAgent: "merge-pipeline",
+      toAgent: mr.agent_id,
+      subject: "Merge conflict detected",
+      body: `Your branch ${mr.source_branch} has conflicts with ${mr.base_branch} in: ${conflictingFiles.join(", ")}. Resolve and call merge.resolve to retry.`
+    });
+    await this.store.logEvent({
+      agentId: mr.agent_id,
+      eventType: "merge-conflict",
+      payload: {
+        mergeId: mr.id,
+        conflictingFiles,
+        notifiedAgents: [...notifiedAgents]
+      }
+    });
+  }
+  /** Create a GitHub PR using the `gh` CLI. */
+  async createPR(mr) {
+    const title = `agent/${mr.agent_id}: ${mr.task_id ?? mr.source_branch}`;
+    const body = [
+      "## Automated Agent PR",
+      "",
+      `**Agent**: ${mr.agent_id}`,
+      `**Branch**: ${mr.source_branch} \u2192 ${mr.base_branch}`,
+      mr.task_id ? `**Task**: ${mr.task_id}` : "",
+      "",
+      "This PR was created automatically by the merge pipeline.",
+      "CI must pass before merge."
+    ].filter(Boolean).join("\n");
+    const { stdout } = await execFileAsync(
+      "gh",
+      [
+        "pr",
+        "create",
+        "--base",
+        mr.base_branch,
+        "--head",
+        mr.source_branch,
+        "--title",
+        title,
+        "--body",
+        body
+      ],
+      { cwd: this.repoRoot, timeout: GH_TIMEOUT }
+    );
+    const url = stdout.trim();
+    const parts = url.split("/");
+    const number = Number.parseInt(parts[parts.length - 1] ?? "0", 10);
+    return { number, url };
+  }
+};
+
+// src/vaughn/capabilities.ts
+function createDefaultCapabilities() {
+  return {
+    dispatch: {
+      generateCode: false,
+      analyzeCode: false,
+      applyEdit: false,
+      executeCommand: false
+    },
+    readWorkboard: false,
+    writeWorkboard: false,
+    claimTasks: false,
+    reportConflicts: false,
+    headless: false,
+    resumable: false,
+    forkable: false,
+    backgroundable: false,
+    hooks: { supported: false, granularity: "none", canBlock: false },
+    sandbox: { supported: false, modes: [] },
+    supportsWorktrees: false,
+    supportsSkills: false,
+    supportsMcp: false,
+    memory: { supported: false, backend: "none" },
+    maxContextTokens: 0,
+    lifecycleEvents: []
+  };
+}
+var TOOL_PROFILES = {
+  "claude-code": {
+    dispatch: {
+      generateCode: false,
+      analyzeCode: false,
+      applyEdit: false,
+      executeCommand: false
+    },
+    readWorkboard: true,
+    writeWorkboard: true,
+    claimTasks: true,
+    reportConflicts: true,
+    headless: true,
+    resumable: false,
+    forkable: false,
+    backgroundable: true,
+    hooks: { supported: true, granularity: "all-tools", canBlock: true },
+    sandbox: { supported: false, modes: [] },
+    supportsWorktrees: true,
+    supportsSkills: true,
+    supportsMcp: true,
+    memory: { supported: false, backend: "none" },
+    maxContextTokens: 2e5,
+    lifecycleEvents: [
+      "session.start",
+      "session.stop",
+      "prompt.submit",
+      "tool.before",
+      "tool.after",
+      "tool.blocked"
+    ]
+  },
+  codex: {
+    dispatch: {
+      generateCode: false,
+      analyzeCode: false,
+      applyEdit: false,
+      executeCommand: false
+    },
+    readWorkboard: true,
+    writeWorkboard: true,
+    claimTasks: true,
+    reportConflicts: false,
+    headless: true,
+    resumable: true,
+    forkable: true,
+    backgroundable: true,
+    hooks: { supported: true, granularity: "bash-only", canBlock: true },
+    sandbox: { supported: true, modes: ["read-only", "workspace-write", "full-access"] },
+    supportsWorktrees: false,
+    supportsSkills: true,
+    supportsMcp: true,
+    memory: { supported: true, backend: "sqlite" },
+    maxContextTokens: 2e5,
+    lifecycleEvents: [
+      "session.start",
+      "session.stop",
+      "prompt.submit",
+      "tool.before",
+      "tool.after",
+      "tool.blocked"
+    ]
+  },
+  cursor: {
+    dispatch: {
+      generateCode: false,
+      analyzeCode: false,
+      applyEdit: false,
+      executeCommand: false
+    },
+    readWorkboard: false,
+    writeWorkboard: false,
+    claimTasks: false,
+    reportConflicts: false,
+    headless: false,
+    resumable: false,
+    forkable: false,
+    backgroundable: false,
+    hooks: { supported: false, granularity: "none", canBlock: false },
+    sandbox: { supported: false, modes: [] },
+    supportsWorktrees: false,
+    supportsSkills: false,
+    supportsMcp: false,
+    memory: { supported: false, backend: "none" },
+    maxContextTokens: 128e3,
+    lifecycleEvents: []
+  },
+  "revealui-agent": {
+    dispatch: {
+      generateCode: true,
+      analyzeCode: true,
+      applyEdit: true,
+      executeCommand: true
+    },
+    readWorkboard: true,
+    writeWorkboard: true,
+    claimTasks: true,
+    reportConflicts: true,
+    headless: true,
+    resumable: false,
+    forkable: false,
+    backgroundable: true,
+    hooks: { supported: true, granularity: "all-tools", canBlock: true },
+    sandbox: { supported: false, modes: [] },
+    supportsWorktrees: true,
+    supportsSkills: true,
+    supportsMcp: true,
+    memory: { supported: true, backend: "crdt" },
+    maxContextTokens: 2e5,
+    lifecycleEvents: [
+      "session.start",
+      "session.stop",
+      "session.crash",
+      "prompt.submit",
+      "tool.before",
+      "tool.after",
+      "tool.blocked",
+      "task.claimed",
+      "task.completed",
+      "agent.heartbeat"
+    ]
+  }
+};
+
+// src/vaughn/degradation-strategies.ts
+var DEGRADATION_TABLE = {
+  "claude-code": {
+    "session.crash": "polyfill",
+    "task.claimed": "polyfill",
+    "task.completed": "polyfill",
+    "agent.heartbeat": "polyfill"
+  },
+  codex: {
+    "session.crash": "polyfill",
+    "task.claimed": "polyfill",
+    "task.completed": "polyfill",
+    "agent.heartbeat": "polyfill"
+  },
+  cursor: {
+    "session.start": "absent",
+    "session.stop": "absent",
+    "session.crash": "polyfill",
+    "prompt.submit": "absent",
+    "tool.before": "absent",
+    "tool.after": "absent",
+    "tool.blocked": "absent",
+    "task.claimed": "absent",
+    "task.completed": "absent",
+    "agent.heartbeat": "polyfill"
+  },
+  "revealui-agent": {
+    // RevealUI Agent natively supports all 10 events; no degradation needed.
+  }
+};
+function getDegradationStrategy(toolName, event) {
+  const toolDegradations = DEGRADATION_TABLE[toolName];
+  if (!toolDegradations) return "absent";
+  return toolDegradations[event];
+}
+
+// src/vaughn/event-envelope.ts
+import { z } from "zod";
+var VAUGHN_VERSION = "0.1.0";
+var VAUGHN_EVENTS = [
+  "session.start",
+  "session.stop",
+  "session.crash",
+  "prompt.submit",
+  "tool.before",
+  "tool.after",
+  "tool.blocked",
+  "task.claimed",
+  "task.completed",
+  "agent.heartbeat"
+];
+var vaughnEventSchema = z.enum([
+  "session.start",
+  "session.stop",
+  "session.crash",
+  "prompt.submit",
+  "tool.before",
+  "tool.after",
+  "tool.blocked",
+  "task.claimed",
+  "task.completed",
+  "agent.heartbeat"
+]);
+var vaughnEventEnvelopeSchema = z.object({
+  version: z.literal(VAUGHN_VERSION),
+  event: vaughnEventSchema,
+  timestamp: z.string().min(1),
+  agentId: z.string().min(1),
+  toolName: z.string().min(1),
+  sessionId: z.string().min(1),
+  payload: z.record(z.string(), z.unknown())
+});
+function createEventEnvelope(event, agentId, toolName, sessionId, payload = {}) {
+  return {
+    version: VAUGHN_VERSION,
+    event,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    agentId,
+    toolName,
+    sessionId,
+    payload
+  };
+}
+
+// src/vaughn/event-normalizer.ts
+var VaughnEventNormalizer = class {
+  constructor(toolName, agentId, sessionId) {
+    this.toolName = toolName;
+    this.agentId = agentId;
+    this.sessionId = sessionId;
+  }
+  toolName;
+  agentId;
+  sessionId;
+  /**
+   * Map a HarnessEvent type to its canonical VAUGHN event.
+   * Returns null if the event has no VAUGHN mapping.
+   */
+  mapEventType(event) {
+    switch (event.type) {
+      case "harness-connected":
+        return "session.start";
+      case "harness-disconnected":
+        return "session.stop";
+      case "generation-started":
+        return "tool.before";
+      case "generation-completed":
+        return "tool.after";
+      case "error":
+        return "session.crash";
+      default:
+        return null;
+    }
+  }
+  /** Extract event-specific payload fields. */
+  extractPayload(event) {
+    switch (event.type) {
+      case "harness-connected":
+        return { harnessId: event.harnessId };
+      case "harness-disconnected":
+        return { harnessId: event.harnessId };
+      case "generation-started":
+        return { taskId: event.taskId };
+      case "generation-completed":
+        return { taskId: event.taskId, output: event.output };
+      case "error":
+        return { harnessId: event.harnessId, message: event.message };
+      default:
+        return {};
+    }
+  }
+  /**
+   * Normalize a HarnessEvent into a VaughnEventEnvelope.
+   *
+   * Returns null if:
+   * - The event has no VAUGHN mapping
+   * - The degradation strategy for this tool/event is 'absent'
+   */
+  normalize(event) {
+    const vaughnEvent = this.mapEventType(event);
+    if (!vaughnEvent) return null;
+    const degradation = getDegradationStrategy(this.toolName, vaughnEvent);
+    if (degradation === "absent") return null;
+    const payload = this.extractPayload(event);
+    if (degradation) {
+      payload.degraded = true;
+      payload.degradationStrategy = degradation;
+    }
+    const envelope = createEventEnvelope(
+      vaughnEvent,
+      this.agentId,
+      this.toolName,
+      this.sessionId,
+      payload
+    );
+    return { envelope, degradation };
+  }
+  /** Convenience: normalize and return just the envelope (or null). */
+  normalizeToEnvelope(event) {
+    return this.normalize(event)?.envelope ?? null;
+  }
+};
+
+// 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();
+  vaughnEventHandlers = /* @__PURE__ */ new Set();
+  vaughnNormalizer = null;
+  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()
+    };
+  }
+  /** Get the VAUGHN capability profile for this adapter. */
+  getVaughnCapabilities() {
+    return TOOL_PROFILES["revealui-agent"];
+  }
+  /** Subscribe to VAUGHN-normalized events. */
+  onVaughnEvent(handler) {
+    this.vaughnEventHandlers.add(handler);
+    if (!this.vaughnNormalizer) {
+      this.vaughnNormalizer = new VaughnEventNormalizer(
+        "revealui-agent",
+        this.id,
+        `session-${Date.now()}`
+      );
+    }
+    return () => this.vaughnEventHandlers.delete(handler);
+  }
+  /** Generate tool-native config files from canonical VAUGHN config (stub). */
+  async generateConfig(_config) {
+    return { files: /* @__PURE__ */ new Map() };
+  }
+  /** Read tool-native config into canonical form (stub). */
+  async readConfig() {
+    return {};
+  }
+  /**
+   * The RevealUI agent is available if at least one LLM provider is reachable.
+   * Checks in order: Ollama (localhost), Groq (API key).
+   */
+  async isAvailable() {
+    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  -  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  -  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.INFERENCE_SNAPS_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();
+    this.vaughnEventHandlers.clear();
+    this.vaughnNormalizer = null;
+  }
+  emit(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+    if (this.vaughnNormalizer && this.vaughnEventHandlers.size > 0) {
+      const envelope = this.vaughnNormalizer.normalizeToEnvelope(event);
+      if (envelope) {
+        for (const handler of this.vaughnEventHandlers) {
+          try {
+            handler(envelope);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/detection/auto-detector.ts
+async function autoDetectHarnesses(registry) {
+  const candidates = [new RevealUIAgentAdapter()];
+  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"
+    });
+    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 max = Math.floor(4294967296 / 1e6) * 1e6;
+  let num;
+  do {
+    const bytes = randomBytes(4);
+    num = bytes.readUInt32BE(0);
+  } while (num >= max);
+  return (num % 1e6).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 execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+var KNOWN_SNAPS = [
+  ["nemotron-3-nano", "General (reasoning + non-reasoning)  -  free tier default"],
+  ["gemma3", "General + vision  -  image understanding, multimodal"],
+  ["deepseek-r1", "Reasoning  -  complex analysis, chain-of-thought"],
+  ["qwen-vl", "Vision-language  -  document parsing, visual Q&A"]
+];
+async function commandExists(cmd) {
+  try {
+    await execFileAsync2("which", [cmd]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var ALLOWED_COMMANDS = /* @__PURE__ */ new Set(["ollama", "snap", "pkill", "which"]);
+async function run(cmd, args) {
+  if (!ALLOWED_COMMANDS.has(cmd)) {
+    throw new Error(`Command not allowed: ${cmd}`);
+  }
+  return execFileAsync2(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) {
+    if (!/^[\w./:@-]+$/.test(modelName)) {
+      return { success: false, message: `Invalid model name: ${modelName}` };
+    }
+    try {
+      const { stdout, stderr } = await execFileAsync2("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) {
+    if (!/^[\w./:@-]+$/.test(modelName)) {
+      throw new Error(`Invalid model name: ${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 {
+    }
+  }
+  // ── 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) {
+    const known = KNOWN_SNAPS.some(([name]) => name === snapName);
+    if (!known) throw new Error(`Unknown inference snap: ${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 execFileAsync2("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 execFileAsync2("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 execFile3 } from "child_process";
+import { readdir } from "fs/promises";
+import { join as join3 } from "path";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
+async function findProcesses(pattern) {
+  try {
+    const { stdout } = await execFileAsync3("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/vaughn/config-normalizer.ts
+var MCP_SERVER_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
+var FORBIDDEN_MCP_SERVER_NAMES = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "hasOwnProperty",
+  "isPrototypeOf",
+  "propertyIsEnumerable",
+  "toLocaleString",
+  "toString",
+  "valueOf"
+]);
+function isSafeMcpServerName(name) {
+  return typeof name === "string" && MCP_SERVER_NAME_PATTERN.test(name) && !FORBIDDEN_MCP_SERVER_NAMES.has(name);
+}
+function vaughnConfigToClaudeSettings(config) {
+  const settings = {};
+  if (config.permissions.autoApprove.length > 0 || config.permissions.deny.length > 0) {
+    settings.permissions = {};
+    if (config.permissions.autoApprove.length > 0) {
+      settings.permissions.allow = config.permissions.autoApprove;
+    }
+    if (config.permissions.deny.length > 0) {
+      settings.permissions.deny = config.permissions.deny;
+    }
+  }
+  if (Object.keys(config.environment.variables).length > 0) {
+    settings.env = { ...config.environment.variables };
+  }
+  if (config.environment.mcpServers.length > 0) {
+    const servers = {};
+    for (const server of config.environment.mcpServers) {
+      if (!isSafeMcpServerName(server.name)) continue;
+      servers[server.name] = {
+        command: server.command,
+        ...server.args && { args: server.args },
+        ...server.env && { env: server.env }
+      };
+    }
+    if (Object.keys(servers).length > 0) {
+      settings.mcpServers = servers;
+    }
+  }
+  return settings;
+}
+function claudeSettingsToVaughnConfig(settings) {
+  const config = {};
+  if (settings.permissions) {
+    config.permissions = {
+      autoApprove: settings.permissions.allow ?? [],
+      deny: settings.permissions.deny ?? []
+    };
+  }
+  const mcpServers = settings.mcpServers ? Object.entries(settings.mcpServers).filter(([name]) => isSafeMcpServerName(name)).map(([name, server]) => ({
+    name,
+    command: server.command,
+    ...server.args && { args: server.args },
+    ...server.env && { env: server.env }
+  })) : [];
+  config.environment = {
+    variables: settings.env ?? {},
+    mcpServers
+  };
+  return config;
+}
+function vaughnConfigToCursorrules(config) {
+  const lines = [];
+  lines.push("# Project Rules");
+  lines.push("");
+  lines.push("## Identity");
+  lines.push(`- Name: ${config.identity.name}`);
+  if (config.identity.role) {
+    lines.push(`- Role: ${config.identity.role}`);
+  }
+  lines.push("");
+  if (config.rules.length > 0) {
+    lines.push("## Rules");
+    lines.push("");
+    for (const rule of config.rules) {
+      lines.push(`### ${rule.id}`);
+      lines.push("");
+      lines.push(rule.description);
+      lines.push("");
+      lines.push(renderRuleContent(rule));
+      lines.push("");
+    }
+  }
+  if (config.skills.length > 0) {
+    lines.push("## Skills");
+    lines.push("");
+    for (const skill of config.skills) {
+      lines.push(`### ${skill.name}`);
+      lines.push("");
+      lines.push(skill.description);
+      lines.push("");
+      lines.push(skill.instructions);
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function vaughnConfigToAgentsMd(config) {
+  const lines = [];
+  lines.push("# AGENTS.md");
+  lines.push("");
+  lines.push(`> Generated by VAUGHN protocol v${VAUGHN_VERSION}`);
+  lines.push("");
+  lines.push("## Identity");
+  lines.push("");
+  lines.push(`- Name: ${config.identity.name}`);
+  lines.push(`- Email: ${config.identity.email}`);
+  if (config.identity.role) {
+    lines.push(`- Role: ${config.identity.role}`);
+  }
+  lines.push("");
+  if (config.permissions.deny.length > 0) {
+    lines.push("## Denied Operations");
+    lines.push("");
+    for (const d of config.permissions.deny) {
+      lines.push(`- ${d}`);
+    }
+    lines.push("");
+  }
+  if (config.rules.length > 0) {
+    lines.push("## Rules");
+    lines.push("");
+    for (const rule of config.rules) {
+      lines.push(`### ${rule.id}`);
+      lines.push("");
+      lines.push(rule.description);
+      lines.push("");
+      if (rule.appliesTo.length > 0) {
+        lines.push(`Applies to: ${rule.appliesTo.join(", ")}`);
+        lines.push("");
+      }
+      lines.push(renderRuleContent(rule));
+      lines.push("");
+    }
+  }
+  if (config.commands.length > 0) {
+    lines.push("## Commands");
+    lines.push("");
+    for (const cmd of config.commands) {
+      lines.push(`### /${cmd.id}`);
+      lines.push("");
+      lines.push(cmd.description);
+      lines.push("");
+      if (cmd.steps.length > 0) {
+        lines.push("Steps:");
+        for (let i = 0; i < cmd.steps.length; i++) {
+          lines.push(`${i + 1}. ${cmd.steps[i]}`);
+        }
+        lines.push("");
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function generateAllConfigs(config) {
+  const files = /* @__PURE__ */ new Map();
+  files.set(".claude/settings.json", JSON.stringify(vaughnConfigToClaudeSettings(config), null, 2));
+  files.set(".cursorrules", vaughnConfigToCursorrules(config));
+  files.set("AGENTS.md", vaughnConfigToAgentsMd(config));
+  for (const rule of config.rules) {
+    const frontmatter = [
+      "---",
+      `description: ${rule.description}`,
+      ...rule.appliesTo.length > 0 ? [`globs: ${rule.appliesTo.join(", ")}`] : [],
+      "---"
+    ].join("\n");
+    files.set(`.claude/rules/${rule.id}.md`, `${frontmatter}
+
+${renderRuleContent(rule)}
+`);
+  }
+  return { files };
+}
+function renderRuleContent(rule) {
+  let content = rule.content;
+  for (const [key, value] of Object.entries(rule.variables)) {
+    content = content.split(`{{${key}}}`).join(value);
+  }
+  return content;
+}
+
+// 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 _RpcServer {
+  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)}
+`);
+          });
+        }
+      });
+    });
+  }
+  registry;
+  socketPath;
+  store;
+  server = createServer2();
+  healthCheckFn = null;
+  spawner = null;
+  inference = null;
+  mergePipeline = null;
+  ciFeedback = null;
+  vaughnDispatchFn = null;
+  vaughnEventQueue = [];
+  static MAX_VAUGHN_EVENTS = 100;
+  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 };
+      }
+      // -----------------------------------------------------------------------
+      // Worktrees (PGlite-backed)
+      // -----------------------------------------------------------------------
+      case "worktree.create": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        const branch = p.branch;
+        const worktreePath = p.worktreePath;
+        if (!(agentId && branch && worktreePath))
+          return this.missingParam(id, "agentId, branch, worktreePath");
+        const wt = await this.store.registerWorktree({
+          agentId,
+          branch,
+          worktreePath,
+          baseBranch: p.baseBranch
+        });
+        return { jsonrpc: "2.0", id, result: wt };
+      }
+      case "worktree.get": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        if (!agentId) return this.missingParam(id, "agentId");
+        const wt = await this.store.getWorktree(agentId);
+        return { jsonrpc: "2.0", id, result: wt };
+      }
+      case "worktree.list": {
+        if (!this.store) return this.noStore(id);
+        const worktrees = await this.store.getActiveWorktrees();
+        return { jsonrpc: "2.0", id, result: worktrees };
+      }
+      case "worktree.status": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        const status = p.status;
+        if (!(agentId && status)) return this.missingParam(id, "agentId, status");
+        const ok = await this.store.updateWorktreeStatus(agentId, status);
+        return { jsonrpc: "2.0", id, result: { success: ok } };
+      }
+      case "worktree.remove": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        if (!agentId) return this.missingParam(id, "agentId");
+        const ok = await this.store.removeWorktree(agentId);
+        return { jsonrpc: "2.0", id, result: { success: ok } };
+      }
+      // -----------------------------------------------------------------------
+      // Agent Memory (PGlite-backed)
+      // -----------------------------------------------------------------------
+      case "memory.store": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        const memoryType = p.memoryType;
+        const content = p.content;
+        if (!(agentId && memoryType && content))
+          return this.missingParam(id, "agentId, memoryType, content");
+        const entry = await this.store.storeMemory({
+          agentId,
+          memoryType,
+          content,
+          metadata: p.metadata
+        });
+        return { jsonrpc: "2.0", id, result: entry };
+      }
+      case "memory.recall": {
+        if (!this.store) return this.noStore(id);
+        const entries = await this.store.recallMemory({
+          agentId: p.agentId,
+          memoryType: p.memoryType,
+          keyword: p.keyword,
+          limit: p.limit
+        });
+        return { jsonrpc: "2.0", id, result: entries };
+      }
+      case "memory.summarize": {
+        if (!this.store) return this.noStore(id);
+        const agentId = p.agentId;
+        if (!agentId) return this.missingParam(id, "agentId");
+        const perType = p.perType ?? 5;
+        const entries = await this.store.summarizeMemory(agentId, perType);
+        return { jsonrpc: "2.0", id, result: entries };
+      }
+      // -----------------------------------------------------------------------
+      // 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 } };
+      }
+      case "agent.input":
+      case "agent.resize": {
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32601, message: "PTY interaction not supported for current backends" }
+        };
+      }
+      // -----------------------------------------------------------------------
+      // Inference management (Ollama, 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.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 } };
+      }
+      // -----------------------------------------------------------------------
+      // Merge Pipeline
+      // -----------------------------------------------------------------------
+      case "merge.request": {
+        if (!this.mergePipeline) return this.noService(id, "merge-pipeline");
+        const agentId = p.agentId;
+        const sourceBranch = p.sourceBranch;
+        if (!(agentId && sourceBranch)) return this.missingParam(id, "agentId, sourceBranch");
+        const result = await this.mergePipeline.requestMerge({
+          agentId,
+          sourceBranch,
+          taskId: p.taskId,
+          baseBranch: p.baseBranch
+        });
+        return { jsonrpc: "2.0", id, result };
+      }
+      case "merge.status": {
+        if (!this.mergePipeline) return this.noService(id, "merge-pipeline");
+        const mergeId = p.mergeId;
+        if (!mergeId) return this.missingParam(id, "mergeId");
+        const result = await this.mergePipeline.getStatus(mergeId);
+        return { jsonrpc: "2.0", id, result };
+      }
+      case "merge.resolve": {
+        if (!this.mergePipeline) return this.noService(id, "merge-pipeline");
+        const mergeId = p.mergeId;
+        if (!mergeId) return this.missingParam(id, "mergeId");
+        const result = await this.mergePipeline.resolve(mergeId);
+        return { jsonrpc: "2.0", id, result };
+      }
+      case "merge.list": {
+        if (!this.mergePipeline) return this.noService(id, "merge-pipeline");
+        const result = await this.mergePipeline.listActive();
+        return { jsonrpc: "2.0", id, result };
+      }
+      // -----------------------------------------------------------------------
+      // CI Feedback
+      // -----------------------------------------------------------------------
+      case "ci.report": {
+        if (!this.ciFeedback) return this.noService(id, "ci-feedback");
+        const result = await this.ciFeedback.report({
+          prNumber: p.prNumber,
+          branch: p.branch,
+          success: p.success,
+          output: p.output,
+          runUrl: p.runUrl,
+          failedJob: p.failedJob
+        });
+        return { jsonrpc: "2.0", id, result };
+      }
+      // -----------------------------------------------------------------------
+      // VAUGHN Protocol
+      // -----------------------------------------------------------------------
+      case "vaughn.capabilities": {
+        const result = [];
+        for (const adapterId of this.registry.listAll()) {
+          const caps = TOOL_PROFILES[adapterId];
+          if (caps) result.push({ id: adapterId, capabilities: caps });
+        }
+        return { jsonrpc: "2.0", id, result };
+      }
+      case "vaughn.dispatch": {
+        if (!this.vaughnDispatchFn) return this.noService(id, "vaughn-dispatch");
+        const description = p.description;
+        if (!description) return this.missingParam(id, "description");
+        const requirements = p.requirements ?? {};
+        const adapterId = this.vaughnDispatchFn(requirements, description);
+        return { jsonrpc: "2.0", id, result: { adapterId } };
+      }
+      case "vaughn.events": {
+        const limit = p.limit ?? 50;
+        const events = this.vaughnEventQueue.slice(-limit);
+        return { jsonrpc: "2.0", id, result: events };
+      }
+      case "vaughn.config.sync": {
+        const config = p.config;
+        if (!config) return this.missingParam(id, "config");
+        const generated = generateAllConfigs(config);
+        const files = {};
+        for (const [path, content] of generated.files) {
+          files[path] = content;
+        }
+        return { jsonrpc: "2.0", id, result: { files } };
+      }
+      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;
+  }
+  /** Attach the merge pipeline (called by coordinator after construction). */
+  setMergePipeline(pipeline) {
+    this.mergePipeline = pipeline;
+  }
+  /** Attach the CI feedback handler (called by coordinator after construction). */
+  setCIFeedback(feedback) {
+    this.ciFeedback = feedback;
+  }
+  /** Attach the VAUGHN dispatch function (called by coordinator after construction). */
+  setVaughnDispatch(fn) {
+    this.vaughnDispatchFn = fn;
+  }
+  /** Push a VAUGHN event into the recent event queue (capped at 100). */
+  pushVaughnEvent(event) {
+    this.vaughnEventQueue.push(event);
+    if (this.vaughnEventQueue.length > _RpcServer.MAX_VAUGHN_EVENTS) {
+      this.vaughnEventQueue.shift();
+    }
+  }
+  /** 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;
+      }
+    }
+    const proc = {
+      name,
+      model,
+      backend,
+      prompt,
+      child,
+      status: "running"
+    };
+    this.sessions.set(sessionId, proc);
+    child.stdout?.on("data", (chunk) => {
+      const data = chunk.toString();
+      if (data.length > 0) {
+        this.emit("output", { sessionId, stream: "stdout", data });
+      }
+    });
+    child.stderr?.on("data", (chunk) => {
+      const data = chunk.toString();
+      if (data.length > 0) {
+        this.emit("output", { sessionId, stream: "stderr", data });
+      }
+    });
+    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  -  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);
+  }
+  options;
+  registry = new HarnessRegistry();
+  vaughnCapabilities = /* @__PURE__ */ new Map();
+  rpcServer = null;
+  httpGateway = null;
+  store = null;
+  spawner = null;
+  inference = null;
+  mergePipeline = null;
+  ciFeedback = 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.rpcServer.setVaughnDispatch((req, desc) => this.dispatchTask(req, desc));
+    this.spawner = new SpawnerService();
+    this.inference = new InferenceService();
+    this.rpcServer.setSpawner(this.spawner);
+    this.rpcServer.setInference(this.inference);
+    this.mergePipeline = new MergePipeline(this.store, {
+      repoRoot: this.options.projectRoot
+    });
+    this.ciFeedback = new CIFeedback(this.store);
+    this.rpcServer.setMergePipeline(this.mergePipeline);
+    this.rpcServer.setCIFeedback(this.ciFeedback);
+    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;
+    this.mergePipeline = null;
+    this.ciFeedback = 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);
+  }
+  /** Register explicit VAUGHN capabilities for an adapter. */
+  registerVaughnCapabilities(adapterId, capabilities) {
+    this.vaughnCapabilities.set(adapterId, capabilities);
+  }
+  /**
+   * Dispatch a task to the best-matching adapter based on VAUGHN capability requirements.
+   *
+   * Returns the selected adapter ID, or null if no adapter matches.
+   * Prefers adapters with hooks.canBlock for safety-critical dispatch.
+   */
+  dispatchTask(requirements, _description) {
+    const candidates = [];
+    for (const id of this.registry.listAll()) {
+      const caps = this.vaughnCapabilities.get(id) ?? TOOL_PROFILES[id];
+      if (!caps) continue;
+      if (this.matchesRequirements(caps, requirements)) {
+        candidates.push({ id, caps });
+      }
+    }
+    if (candidates.length === 0) return null;
+    const blocking = candidates.filter((c) => c.caps.hooks.canBlock);
+    const best = blocking.length > 0 ? blocking[0] : candidates[0];
+    return best?.id ?? null;
+  }
+  /** Check whether capabilities satisfy requirements. */
+  matchesRequirements(caps, req) {
+    if (req.dispatch) {
+      if (req.dispatch.generateCode && !caps.dispatch.generateCode) return false;
+      if (req.dispatch.analyzeCode && !caps.dispatch.analyzeCode) return false;
+      if (req.dispatch.applyEdit && !caps.dispatch.applyEdit) return false;
+      if (req.dispatch.executeCommand && !caps.dispatch.executeCommand) return false;
+    }
+    if (req.headless && !caps.headless) return false;
+    if (req.resumable && !caps.resumable) return false;
+    if (req.forkable && !caps.forkable) return false;
+    if (req.backgroundable && !caps.backgroundable) return false;
+    if (req.readWorkboard && !caps.readWorkboard) return false;
+    if (req.writeWorkboard && !caps.writeWorkboard) return false;
+    if (req.claimTasks && !caps.claimTasks) return false;
+    if (req.reportConflicts && !caps.reportConflicts) return false;
+    if (req.supportsWorktrees && !caps.supportsWorktrees) return false;
+    if (req.supportsSkills && !caps.supportsSkills) return false;
+    if (req.supportsMcp && !caps.supportsMcp) return false;
+    if (req.hooks) {
+      if (req.hooks.supported && !caps.hooks.supported) return false;
+      if (req.hooks.canBlock && !caps.hooks.canBlock) return false;
+    }
+    if (req.sandbox?.supported && !caps.sandbox.supported) return false;
+    if (req.memory?.supported && !caps.memory.supported) return false;
+    return true;
+  }
+  /** 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 {
+  createDefaultCapabilities,
+  TOOL_PROFILES,
+  getDegradationStrategy,
+  VAUGHN_VERSION,
+  VAUGHN_EVENTS,
+  vaughnEventSchema,
+  vaughnEventEnvelopeSchema,
+  createEventEnvelope,
+  VaughnEventNormalizer,
+  autoDetectHarnesses,
+  HarnessRegistry,
+  getLocalConfigPath,
+  getRootConfigPath,
+  getConfigurableHarnesses,
+  syncConfig,
+  diffConfig,
+  syncAllConfigs,
+  diffAllConfigs,
+  validateConfigJson,
+  findProcesses,
+  findHarnessProcesses,
+  findAllHarnessProcesses,
+  findClaudeCodeSockets,
+  vaughnConfigToClaudeSettings,
+  claudeSettingsToVaughnConfig,
+  vaughnConfigToCursorrules,
+  vaughnConfigToAgentsMd,
+  generateAllConfigs,
+  RpcServer,
+  HarnessCoordinator,
+  checkHarnessesLicense
+};