@revealui/harnesses 0.1.8 → 0.1.9

package/dist/{chunk-6E2BKO6U.js → chunk-YYAYTCRM.js}

@@ -1,274 +1,20 @@
 import {
   DaemonStore
-} from "./chunk-DGQ5OB6L.js";
+} from "./chunk-ANX4L2PF.js";
 import {
   WorkboardManager,
   deriveSessionId,
   detectSessionType
-} from "./chunk-4F4ANKIZ.js";
+} from "./chunk-Y4FFO3TO.js";
 import {
   __require
-} from "./chunk-DGUM43GV.js";
+} 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/adapters/claude-code-adapter.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-var ClaudeCodeAdapter = class {
-  id = "claude-code";
-  name = "Claude Code";
-  eventHandlers = /* @__PURE__ */ new Set();
-  workboardPath;
-  constructor(workboardPath) {
-    this.workboardPath = workboardPath ?? process.env.REVEALUI_WORKBOARD_PATH;
-  }
-  getCapabilities() {
-    return {
-      generateCode: false,
-      // interactive only — no headless CLI interface
-      analyzeCode: false,
-      // interactive only — no headless CLI interface
-      applyEdit: false,
-      // interactive only — edits are applied inside Claude Code sessions
-      applyConfig: false,
-      // config managed interactively via ~/.claude/settings.json
-      readWorkboard: this.workboardPath !== void 0,
-      writeWorkboard: this.workboardPath !== void 0
-    };
-  }
-  async getInfo() {
-    let version;
-    try {
-      const { stdout } = await execFileAsync("claude", ["--version"], {
-        timeout: 5e3
-      });
-      version = stdout.trim().split("\n")[0];
-    } catch {
-    }
-    return { id: this.id, name: this.name, version, capabilities: this.getCapabilities() };
-  }
-  async isAvailable() {
-    try {
-      await execFileAsync("claude", ["--version"], { timeout: 3e3 });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  notifyRegistered() {
-    this.emit({ type: "harness-connected", harnessId: this.id });
-  }
-  notifyUnregistering() {
-    this.emit({ type: "harness-disconnected", harnessId: this.id });
-  }
-  async execute(command) {
-    try {
-      return await this.executeInner(command);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.emit({ type: "error", harnessId: this.id, message });
-      return { success: false, command: command.type, message };
-    }
-  }
-  async executeInner(command) {
-    switch (command.type) {
-      case "get-status": {
-        const available = await this.isAvailable();
-        return { success: true, command: command.type, data: { available } };
-      }
-      case "get-running-instances": {
-        return { success: true, command: command.type, data: [] };
-      }
-      case "generate-code":
-      case "analyze-code": {
-        return {
-          success: false,
-          command: command.type,
-          message: `${command.type} is not supported \u2014 Claude Code operates interactively`
-        };
-      }
-      case "apply-config": {
-        return {
-          success: false,
-          command: command.type,
-          message: "Config is managed interactively via ~/.claude/settings.json"
-        };
-      }
-      case "read-workboard": {
-        if (!this.workboardPath) {
-          return {
-            success: false,
-            command: command.type,
-            message: "REVEALUI_WORKBOARD_PATH is not set"
-          };
-        }
-        const manager = new WorkboardManager(this.workboardPath);
-        const state = await manager.readAsync();
-        return { success: true, command: command.type, data: state };
-      }
-      case "update-workboard": {
-        if (!this.workboardPath) {
-          return {
-            success: false,
-            command: command.type,
-            message: "REVEALUI_WORKBOARD_PATH is not set"
-          };
-        }
-        const manager = new WorkboardManager(this.workboardPath);
-        manager.updateAgent(command.sessionId, {
-          ...command.task !== void 0 && { task: command.task },
-          ...command.files !== void 0 && { files: command.files.join(", ") },
-          updated: `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)}Z`
-        });
-        return { success: true, command: command.type };
-      }
-      default: {
-        return {
-          success: false,
-          command: command.type,
-          message: `Command not supported by ${this.name}`
-        };
-      }
-    }
-  }
-  onEvent(handler) {
-    this.eventHandlers.add(handler);
-    return () => this.eventHandlers.delete(handler);
-  }
-  async dispose() {
-    this.eventHandlers.clear();
-  }
-  emit(event) {
-    for (const handler of this.eventHandlers) {
-      try {
-        handler(event);
-      } catch {
-      }
-    }
-  }
-};
-
-// src/adapters/cursor-adapter.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile2);
-var CursorAdapter = class {
-  id = "cursor";
-  name = "Cursor";
-  eventHandlers = /* @__PURE__ */ new Set();
-  workboardPath;
-  constructor(workboardPath) {
-    this.workboardPath = workboardPath ?? process.env.REVEALUI_WORKBOARD_PATH;
-  }
-  getCapabilities() {
-    return {
-      generateCode: false,
-      analyzeCode: false,
-      applyEdit: false,
-      applyConfig: false,
-      readWorkboard: this.workboardPath !== void 0,
-      writeWorkboard: this.workboardPath !== void 0
-    };
-  }
-  async getInfo() {
-    let version;
-    try {
-      const { stdout } = await execFileAsync2("cursor", ["--version"], {
-        timeout: 5e3
-      });
-      version = stdout.trim().split("\n")[0];
-    } catch {
-    }
-    return { id: this.id, name: this.name, version, capabilities: this.getCapabilities() };
-  }
-  async isAvailable() {
-    try {
-      await execFileAsync2("cursor", ["--version"], { timeout: 3e3 });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  notifyRegistered() {
-    this.emit({ type: "harness-connected", harnessId: this.id });
-  }
-  notifyUnregistering() {
-    this.emit({ type: "harness-disconnected", harnessId: this.id });
-  }
-  async execute(command) {
-    try {
-      return await this.executeInner(command);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.emit({ type: "error", harnessId: this.id, message });
-      return { success: false, command: command.type, message };
-    }
-  }
-  async executeInner(command) {
-    switch (command.type) {
-      case "get-status": {
-        const available = await this.isAvailable();
-        return { success: true, command: command.type, data: { available } };
-      }
-      case "read-workboard": {
-        if (!this.workboardPath) {
-          return {
-            success: false,
-            command: command.type,
-            message: "REVEALUI_WORKBOARD_PATH is not set"
-          };
-        }
-        const manager = new WorkboardManager(this.workboardPath);
-        const state = await manager.readAsync();
-        return { success: true, command: command.type, data: state };
-      }
-      case "update-workboard": {
-        if (!this.workboardPath) {
-          return {
-            success: false,
-            command: command.type,
-            message: "REVEALUI_WORKBOARD_PATH is not set"
-          };
-        }
-        const manager = new WorkboardManager(this.workboardPath);
-        manager.updateAgent(command.sessionId, {
-          ...command.task !== void 0 && { task: command.task },
-          ...command.files !== void 0 && { files: command.files.join(", ") },
-          updated: `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)}Z`
-        });
-        return { success: true, command: command.type };
-      }
-      default: {
-        return {
-          success: false,
-          command: command.type,
-          message: `Command not supported by ${this.name}`
-        };
-      }
-    }
-  }
-  onEvent(handler) {
-    this.eventHandlers.add(handler);
-    return () => this.eventHandlers.delete(handler);
-  }
-  async dispose() {
-    this.eventHandlers.clear();
-  }
-  emit(event) {
-    for (const handler of this.eventHandlers) {
-      try {
-        handler(event);
-      } catch {
-      }
-    }
-  }
-};
-
 // src/config/config-sync.ts
 import { copyFileSync, existsSync, mkdirSync, readFileSync } from "fs";
 import { dirname } from "path";
@@ -396,6 +142,764 @@ function backupIfExists(filePath) {
 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(),
@@ -407,6 +911,8 @@ var RevealUIAgentAdapter = class {
   name = "RevealUI Agent";
   config;
   eventHandlers = /* @__PURE__ */ new Set();
+  vaughnEventHandlers = /* @__PURE__ */ new Set();
+  vaughnNormalizer = null;
   constructor(config) {
     this.config = { ...DEFAULT_CONFIG, ...config };
   }
@@ -428,19 +934,35 @@ var RevealUIAgentAdapter = class {
       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: BitNet (localhost), Ollama (localhost), Groq (API key).
+   * Checks in order: Ollama (localhost), Groq (API key).
    */
   async isAvailable() {
-    if (process.env.BITNET_BASE_URL) {
-      try {
-        const url = `${process.env.BITNET_BASE_URL}/v1/models`;
-        const res = await fetch(url, { signal: AbortSignal.timeout(2e3) });
-        if (res.ok) return true;
-      } catch {
-      }
-    }
     const ollamaUrl = process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
     try {
       const res = await fetch(`${ollamaUrl}/api/tags`, {
@@ -512,7 +1034,7 @@ ${command.diff}`
         return {
           success: false,
           command: command.type,
-          message: "Config sync is not applicable \u2014 RevealUI agent uses the content layer directly"
+          message: "Config sync is not applicable  -  RevealUI agent uses the content layer directly"
         };
       }
       case "read-workboard":
@@ -520,7 +1042,7 @@ ${command.diff}`
         return {
           success: false,
           command: command.type,
-          message: "Workboard support not yet wired \u2014 use WorkboardManager directly"
+          message: "Workboard support not yet wired  -  use WorkboardManager directly"
         };
       }
       default: {
@@ -535,7 +1057,7 @@ ${command.diff}`
   /**
    * 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.
+   * 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";
@@ -567,7 +1089,7 @@ ${command.diff}`
       llmClient = new LLMClient({
         provider: this.config.provider,
         model: this.config.model,
-        baseURL: process.env.BITNET_BASE_URL ?? process.env.OLLAMA_BASE_URL,
+        baseURL: process.env.INFERENCE_SNAPS_BASE_URL ?? process.env.OLLAMA_BASE_URL,
         apiKey: process.env.GROQ_API_KEY ?? "not-needed"
       });
     } else {
@@ -658,6 +1180,8 @@ ${command.diff}`
   }
   async dispose() {
     this.eventHandlers.clear();
+    this.vaughnEventHandlers.clear();
+    this.vaughnNormalizer = null;
   }
   emit(event) {
     for (const handler of this.eventHandlers) {
@@ -666,17 +1190,23 @@ ${command.diff}`
       } 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(),
-    new ClaudeCodeAdapter(),
-    new CursorAdapter()
-    // Copilot adapter excluded — stub only, no standalone CLI available
-  ];
+  const candidates = [new RevealUIAgentAdapter()];
   const registered = [];
   await Promise.all(
     candidates.map(async (adapter) => {
@@ -848,7 +1378,7 @@ var HttpGateway = class {
     }
     return true;
   }
-  /** POST /api/pair — submit pairing code, receive session token */
+  /** POST /api/pair  -  submit pairing code, receive session token */
   handlePair(req, res) {
     let body = "";
     req.on("data", (chunk) => {
@@ -876,14 +1406,14 @@ var HttpGateway = class {
       }
     });
   }
-  /** GET /api/pair — check pairing status */
+  /** GET /api/pair  -  check pairing status */
   handlePairStatus(res) {
     jsonResponse(res, 200, {
       paired: this.paired,
       activeSessions: this.sessionTokens.size
     });
   }
-  /** GET /api/status — daemon status summary */
+  /** GET /api/status  -  daemon status summary */
   handleStatus(res) {
     jsonResponse(res, 200, {
       daemon: "revdev-harness",
@@ -893,7 +1423,7 @@ var HttpGateway = class {
       activeSessions: this.sessionTokens.size
     });
   }
-  /** POST /rpc — proxy JSON-RPC to the daemon's dispatch */
+  /** POST /rpc  -  proxy JSON-RPC to the daemon's dispatch */
   handleRpc(req, res) {
     let body = "";
     req.on("data", (chunk) => {
@@ -910,7 +1440,7 @@ var HttpGateway = class {
       });
     });
   }
-  /** GET /api/stream[/:sessionId] — SSE for agent output and exit events */
+  /** GET /api/stream[/:sessionId]  -  SSE for agent output and exit events */
   handleStream(req, res, sessionFilter) {
     const spawner = this.config.spawner;
     if (!spawner) {
@@ -920,8 +1450,7 @@ var HttpGateway = class {
     res.writeHead(200, {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-      "Access-Control-Allow-Origin": "*"
+      Connection: "keep-alive"
     });
     res.write(": connected\n\n");
     const onOutput = (evt) => {
@@ -976,9 +1505,13 @@ data: ${JSON.stringify(evt)}
   }
 };
 function generatePairingCode() {
-  const bytes = randomBytes(4);
-  const num = bytes.readUInt32BE(0) % 1e6;
-  return num.toString().padStart(6, "0");
+  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);
@@ -990,29 +1523,29 @@ function jsonResponse(res, status, body) {
 }
 
 // src/server/inference-service.ts
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-var execFileAsync3 = promisify3(execFile3);
+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) \u2014 free tier default"],
-  ["gemma3", "General + vision \u2014 image understanding, multimodal"],
-  ["deepseek-r1", "Reasoning \u2014 complex analysis, chain-of-thought"],
-  ["qwen-vl", "Vision-language \u2014 document parsing, visual Q&A"]
-];
-var BITNET_MODEL_PATHS = [
-  `${process.env.HOME ?? "/root"}/models/bitnet`,
-  "/mnt/forge/models/bitnet"
+  ["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 execFileAsync3("which", [cmd]);
+    await execFileAsync2("which", [cmd]);
     return true;
   } catch {
     return false;
   }
 }
+var ALLOWED_COMMANDS = /* @__PURE__ */ new Set(["ollama", "snap", "pkill", "which"]);
 async function run(cmd, args) {
-  return execFileAsync3(cmd, args, { timeout: 3e4 });
+  if (!ALLOWED_COMMANDS.has(cmd)) {
+    throw new Error(`Command not allowed: ${cmd}`);
+  }
+  return execFileAsync2(cmd, args, { timeout: 3e4 });
 }
 var InferenceService = class {
   // ── Ollama ──────────────────────────────────────────────────────
@@ -1052,8 +1585,11 @@ var InferenceService = class {
     return models;
   }
   async ollamaPull(modelName) {
+    if (!/^[\w./:@-]+$/.test(modelName)) {
+      return { success: false, message: `Invalid model name: ${modelName}` };
+    }
     try {
-      const { stdout, stderr } = await execFileAsync3("ollama", ["pull", modelName], {
+      const { stdout, stderr } = await execFileAsync2("ollama", ["pull", modelName], {
         timeout: 6e5
         // 10 min for large models
       });
@@ -1063,6 +1599,9 @@ var InferenceService = class {
     }
   }
   async ollamaDelete(modelName) {
+    if (!/^[\w./:@-]+$/.test(modelName)) {
+      throw new Error(`Invalid model name: ${modelName}`);
+    }
     await run("ollama", ["rm", modelName]);
   }
   async ollamaStart() {
@@ -1079,21 +1618,6 @@ var InferenceService = class {
     } catch {
     }
   }
-  // ── BitNet ──────────────────────────────────────────────────────
-  async bitnetStatus() {
-    const installed = await commandExists("bitnet");
-    let modelPath = null;
-    if (installed) {
-      const { existsSync: existsSync4 } = await import("fs");
-      for (const p of BITNET_MODEL_PATHS) {
-        if (existsSync4(p)) {
-          modelPath = p;
-          break;
-        }
-      }
-    }
-    return { installed, modelPath };
-  }
   // ── Inference Snaps ─────────────────────────────────────────────
   async snapList() {
     const results = [];
@@ -1109,6 +1633,8 @@ var InferenceService = class {
     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 {
@@ -1134,7 +1660,7 @@ var InferenceService = class {
     const known = KNOWN_SNAPS.some(([name]) => name === snapName);
     if (!known) throw new Error(`Unknown inference snap: ${snapName}`);
     try {
-      const { stdout, stderr } = await execFileAsync3("sudo", ["snap", "install", snapName], {
+      const { stdout, stderr } = await execFileAsync2("sudo", ["snap", "install", snapName], {
         timeout: 3e5
         // 5 min for large snaps
       });
@@ -1144,7 +1670,7 @@ var InferenceService = class {
     }
   }
   async snapRemove(snapName) {
-    await execFileAsync3("sudo", ["snap", "remove", snapName], { timeout: 6e4 });
+    await execFileAsync2("sudo", ["snap", "remove", snapName], { timeout: 6e4 });
   }
 };
 
@@ -1153,14 +1679,14 @@ import { existsSync as existsSync3, unlinkSync } from "fs";
 import { createServer as createServer2 } from "net";
 
 // src/detection/process-detector.ts
-import { execFile as execFile4 } from "child_process";
+import { execFile as execFile3 } from "child_process";
 import { readdir } from "fs/promises";
 import { join as join3 } from "path";
-import { promisify as promisify4 } from "util";
-var execFileAsync4 = promisify4(execFile4);
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
 async function findProcesses(pattern) {
   try {
-    const { stdout } = await execFileAsync4("pgrep", ["-a", pattern], { timeout: 3e3 });
+    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);
@@ -1209,12 +1735,198 @@ async function findClaudeCodeSockets() {
   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 {
+var RpcServer = class _RpcServer {
   constructor(registry, socketPath, store) {
     this.registry = registry;
     this.socketPath = socketPath;
@@ -1234,10 +1946,18 @@ var RpcServer = class {
       });
     });
   }
+  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 {
@@ -1553,6 +2273,87 @@ var RpcServer = class {
         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": {
@@ -1564,12 +2365,7 @@ var RpcServer = class {
         if (!(name && backend && model && prompt)) {
           return this.missingParam(id, "name, backend, model, prompt");
         }
-        const sessionId = this.spawner.spawn(
-          name,
-          backend,
-          model,
-          prompt
-        );
+        const sessionId = this.spawner.spawn(name, backend, model, prompt);
         return { jsonrpc: "2.0", id, result: { sessionId } };
       }
       case "agent.stop": {
@@ -1590,8 +2386,16 @@ var RpcServer = class {
         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, BitNet, Snaps)
+      // Inference management (Ollama, Snaps)
       // -----------------------------------------------------------------------
       case "inference.ollama.status": {
         if (!this.inference) return this.noService(id, "inference");
@@ -1624,10 +2428,6 @@ var RpcServer = class {
         await this.inference.ollamaStop();
         return { jsonrpc: "2.0", id, result: { ok: true } };
       }
-      case "inference.bitnet.status": {
-        if (!this.inference) return this.noService(id, "inference");
-        return { jsonrpc: "2.0", id, result: await this.inference.bitnetStatus() };
-      }
       case "inference.snap.list": {
         if (!this.inference) return this.noService(id, "inference");
         return { jsonrpc: "2.0", id, result: await this.inference.snapList() };
@@ -1651,6 +2451,90 @@ var RpcServer = class {
         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",
@@ -1702,6 +2586,25 @@ var RpcServer = class {
   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;
@@ -1771,29 +2674,26 @@ var SpawnerService = class extends EventEmitter {
         });
         break;
       }
-      case "BitNet": {
-        child = nodeSpawn("bitnet", ["run", "--model", model, "--prompt", prompt], {
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        break;
-      }
     }
-    const proc = { name, model, backend, prompt, child, status: "running" };
+    const proc = {
+      name,
+      model,
+      backend,
+      prompt,
+      child,
+      status: "running"
+    };
     this.sessions.set(sessionId, proc);
     child.stdout?.on("data", (chunk) => {
-      const lines = chunk.toString().split("\n");
-      for (const line of lines) {
-        if (line.length > 0) {
-          this.emit("output", { sessionId, stream: "stdout", line });
-        }
+      const data = chunk.toString();
+      if (data.length > 0) {
+        this.emit("output", { sessionId, stream: "stdout", data });
       }
     });
     child.stderr?.on("data", (chunk) => {
-      const lines = chunk.toString().split("\n");
-      for (const line of lines) {
-        if (line.length > 0) {
-          this.emit("output", { sessionId, stream: "stderr", line });
-        }
+      const data = chunk.toString();
+      if (data.length > 0) {
+        this.emit("output", { sessionId, stream: "stderr", data });
       }
     });
     child.on("close", (code) => {
@@ -1834,7 +2734,8 @@ var SpawnerService = class extends EventEmitter {
   remove(sessionId) {
     const proc = this.sessions.get(sessionId);
     if (!proc) throw new Error(`No agent session: ${sessionId}`);
-    if (proc.status === "running") throw new Error("Cannot remove a running agent \u2014 stop it first");
+    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). */
@@ -1855,12 +2756,16 @@ var HarnessCoordinator = class {
     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() {
@@ -1889,10 +2794,17 @@ var HarnessCoordinator = class {
     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({
@@ -1922,6 +2834,8 @@ var HarnessCoordinator = class {
       this.spawner = null;
     }
     this.inference = null;
+    this.mergePipeline = null;
+    this.ciFeedback = null;
     if (this.rpcServer) {
       await this.rpcServer.stop();
       this.rpcServer = null;
@@ -1948,6 +2862,57 @@ var HarnessCoordinator = class {
   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;
@@ -2017,8 +2982,15 @@ async function checkHarnessesLicense() {
 }
 
 export {
-  ClaudeCodeAdapter,
-  CursorAdapter,
+  createDefaultCapabilities,
+  TOOL_PROFILES,
+  getDegradationStrategy,
+  VAUGHN_VERSION,
+  VAUGHN_EVENTS,
+  vaughnEventSchema,
+  vaughnEventEnvelopeSchema,
+  createEventEnvelope,
+  VaughnEventNormalizer,
   autoDetectHarnesses,
   HarnessRegistry,
   getLocalConfigPath,
@@ -2033,8 +3005,12 @@ export {
   findHarnessProcesses,
   findAllHarnessProcesses,
   findClaudeCodeSockets,
+  vaughnConfigToClaudeSettings,
+  claudeSettingsToVaughnConfig,
+  vaughnConfigToCursorrules,
+  vaughnConfigToAgentsMd,
+  generateAllConfigs,
   RpcServer,
   HarnessCoordinator,
   checkHarnessesLicense
 };
-//# sourceMappingURL=chunk-6E2BKO6U.js.map