@revealui/harnesses 0.1.7 → 0.1.9

package/dist/index.d.ts

@@ -1,61 +1,12 @@
-import { HarnessAdapter, HarnessCapabilities, HarnessInfo, HarnessCommand, HarnessCommandResult, HarnessEvent, ConfigDiffEntry, ConfigSyncDirection, ConfigSyncResult, HealthCheckResult, HarnessProcessInfo } from './types/index.js';
+import { ConfigDiffEntry, ConfigSyncDirection, ConfigSyncResult, HarnessAdapter, HealthCheckResult, HarnessProcessInfo, HarnessEvent } from './types/index.js';
+export { HarnessCapabilities, HarnessCommand, HarnessCommandResult, HarnessInfo } from './types/index.js';
 export { Agent, Command, ContentGenerator, ContentSummary, DiffEntry, GeneratedFile, Manifest, PreambleTier, ResolverContext, Rule, Skill, ValidationResult, buildManifest, diffContent, generateContent, listContent, validateManifest } from './content/index.js';
-import { WorkboardManager } from './workboard/index.js';
-export { ConflictResult, SessionType, WorkboardEntry, WorkboardSession, WorkboardState, acquireLock, atomicWriteSync, deriveSessionId, detectSessionType, lockPathFor, releaseLock, withLock, withLockAsync } from './workboard/index.js';
-import 'zod';
-
-/**
- * Adapter for Anthropic Claude Code (CLI: `claude`).
- *
- * Claude Code communicates via its CLI. Config lives at
- * ~/.claude/settings.json and project-level .claude/settings.json.
- * MCP integration is handled separately by @revealui/mcp.
- *
- * Workboard read/write requires REVEALUI_WORKBOARD_PATH to be set to the
- * absolute path of the workboard.md file.
- */
-declare class ClaudeCodeAdapter implements HarnessAdapter {
-    readonly id = "claude-code";
-    readonly name = "Claude Code";
-    private readonly eventHandlers;
-    private readonly workboardPath;
-    constructor(workboardPath?: string);
-    getCapabilities(): HarnessCapabilities;
-    getInfo(): Promise<HarnessInfo>;
-    isAvailable(): Promise<boolean>;
-    notifyRegistered(): void;
-    notifyUnregistering(): void;
-    execute(command: HarnessCommand): Promise<HarnessCommandResult>;
-    private executeInner;
-    onEvent(handler: (event: HarnessEvent) => void): () => void;
-    dispose(): Promise<void>;
-    private emit;
-}
-
-/**
- * Adapter for Cursor IDE.
- *
- * Cursor is a VS Code fork with built-in AI capabilities.
- * This adapter detects Cursor via `cursor --version` and provides
- * workboard read/write when REVEALUI_WORKBOARD_PATH is set.
- */
-declare class CursorAdapter implements HarnessAdapter {
-    readonly id = "cursor";
-    readonly name = "Cursor";
-    private readonly eventHandlers;
-    private readonly workboardPath;
-    constructor(workboardPath?: string);
-    getCapabilities(): HarnessCapabilities;
-    getInfo(): Promise<HarnessInfo>;
-    isAvailable(): Promise<boolean>;
-    notifyRegistered(): void;
-    notifyUnregistering(): void;
-    execute(command: HarnessCommand): Promise<HarnessCommandResult>;
-    private executeInner;
-    onEvent(handler: (event: HarnessEvent) => void): () => void;
-    dispose(): Promise<void>;
-    private emit;
-}
+import { D as DaemonStore, M as MergeRequest } from './index-w5ashbfb.js';
+export { A as AgentMessage, a as AgentSession, b as AgentTask, c as DaemonEvent, d as DaemonStoreConfig, F as FileReservation, S as SCHEMA_SQL } from './index-w5ashbfb.js';
+import { z } from 'zod';
+import { EventEmitter } from 'node:events';
+import { WorkboardManager, WorkboardState } from './workboard/index.js';
+export { ConflictResult, SessionType, WorkboardEntry, WorkboardSession, acquireLock, atomicWriteSync, deriveSessionId, detectSessionType, lockPathFor, releaseLock, withLock, withLockAsync } from './workboard/index.js';
 
 /**
  * Syncs harness config between local filesystem and root backup.
@@ -107,6 +58,519 @@ declare class HarnessRegistry {
     disposeAll(): Promise<void>;
 }
 
+/**
+ * CIFeedback  -  Layer 4 of the Autonomous Agent Architecture.
+ *
+ * Receives CI results (posted by GitHub Actions via the daemon's HTTP gateway),
+ * and routes them back to agents:
+ *   - Green: mark merge request as merged, complete the linked task
+ *   - Red: parse the failure category, create a fix task, assign back
+ *          to the originating agent (up to MAX_RETRIES), then escalate
+ *
+ * The CI workflow posts to `POST /rpc` with method `ci.report`.
+ */
+
+interface CIReportParams {
+    /** PR number the CI ran on. */
+    prNumber?: number;
+    /** Branch name the CI ran on (fallback lookup if prNumber missing). */
+    branch?: string;
+    /** Whether CI passed. */
+    success: boolean;
+    /** Raw CI output (truncated to 10KB by the caller). */
+    output?: string;
+    /** GitHub Actions run URL for reference. */
+    runUrl?: string;
+    /** Which CI job failed (e.g., 'quality', 'typecheck', 'test-unit', 'build'). */
+    failedJob?: string;
+}
+interface CIFeedbackResult {
+    action: 'merged' | 'fix_task_created' | 'escalated' | 'no_merge_request' | 'error';
+    mergeRequestId?: string;
+    taskId?: string;
+    retryCount?: number;
+    error?: string;
+}
+declare class CIFeedback {
+    private readonly store;
+    constructor(store: DaemonStore);
+    /**
+     * Handle a CI report. Called when GitHub Actions posts results
+     * to the daemon HTTP gateway.
+     */
+    report(params: CIReportParams): Promise<CIFeedbackResult>;
+    private handleSuccess;
+    private handleFailure;
+    /** Escalate to human after max retries. */
+    private escalate;
+    /** Find the merge request associated with this CI run. */
+    private findMergeRequest;
+    /** Categorize the CI failure from the job name or output. */
+    private categorizeFailure;
+    /** Build a descriptive fix task for the agent. */
+    private buildFixTaskDescription;
+}
+
+/**
+ * MergePipeline  -  Layer 3 of the Autonomous Agent Architecture.
+ *
+ * Watches task completions, diffs agent worktree branches, attempts
+ * fast-forward merges into a staging branch, and creates PRs to `test`.
+ *
+ * Conflict detection notifies conflicting agents via the messaging system.
+ * Merges are ordered by the workspace dependency graph (topological sort).
+ */
+
+interface MergePipelineConfig {
+    /** Absolute path to the repo root. */
+    repoRoot: string;
+    /** Default base branch for PRs (default: 'test'). */
+    baseBranch?: string;
+    /** GitHub remote name (default: 'origin'). */
+    remote?: string;
+}
+interface MergeResult {
+    mergeRequestId: string;
+    status: MergeRequest['status'];
+    prUrl?: string;
+    prNumber?: number;
+    error?: string;
+    conflictingFiles?: string[];
+}
+declare class MergePipeline {
+    private readonly store;
+    private readonly repoRoot;
+    private readonly baseBranch;
+    private readonly remote;
+    constructor(store: DaemonStore, config: MergePipelineConfig);
+    /**
+     * Request a merge for an agent's branch into the base branch.
+     * Creates a merge_request record and attempts the merge.
+     */
+    requestMerge(params: {
+        agentId: string;
+        sourceBranch: string;
+        taskId?: string;
+        baseBranch?: string;
+    }): Promise<MergeResult>;
+    /**
+     * Process a pending merge request: fetch, check for conflicts,
+     * fast-forward merge, and create a PR.
+     */
+    processMerge(mergeId: string): Promise<MergeResult>;
+    /** Get the current status of a merge request. */
+    getStatus(mergeId: string): Promise<MergeResult>;
+    /** Retry a failed or conflicted merge request. */
+    resolve(mergeId: string): Promise<MergeResult>;
+    /** List all active (non-terminal) merge requests. */
+    listActive(): Promise<MergeRequest[]>;
+    /**
+     * Get the workspace dependency order for merge sequencing.
+     * Packages that are dependencies of others should merge first.
+     */
+    getDependencyOrder(): Promise<string[]>;
+    /** Run a git command in the repo root. */
+    private git;
+    /**
+     * 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.
+     */
+    private checkConflicts;
+    /** Notify conflicting agents via the messaging system. */
+    private handleConflict;
+    /** Create a GitHub PR using the `gh` CLI. */
+    private createPR;
+}
+
+/**
+ * VAUGHN Capability Model (Section 4 of VAUGHN.md)
+ *
+ * Defines the full superset of capabilities an adapter can declare.
+ * Adapters degrade gracefully when a tool lacks a feature.
+ */
+/** Available sandbox isolation modes. */
+type SandboxMode = 'read-only' | 'workspace-write' | 'full-access';
+/** Hook granularity levels. */
+type HookGranularity = 'none' | 'bash-only' | 'all-tools';
+/** Memory backend types. */
+type MemoryBackend = 'none' | 'sqlite' | 'crdt' | 'file';
+/**
+ * Full capability declaration for a VAUGHN adapter.
+ * Each adapter declares this statically at registration time.
+ */
+interface VaughnCapabilities {
+    /** Dispatch operations: can the adapter programmatically invoke these? */
+    dispatch: {
+        /** Adapter can send a prompt and get code back */
+        generateCode: boolean;
+        /** Adapter can request code analysis */
+        analyzeCode: boolean;
+        /** Adapter can send a diff to apply */
+        applyEdit: boolean;
+        /** Adapter can invoke shell commands */
+        executeCommand: boolean;
+    };
+    /** Coordination capabilities */
+    readWorkboard: boolean;
+    writeWorkboard: boolean;
+    claimTasks: boolean;
+    reportConflicts: boolean;
+    /** Lifecycle capabilities */
+    headless: boolean;
+    resumable: boolean;
+    forkable: boolean;
+    backgroundable: boolean;
+    /** Safety: hook system */
+    hooks: {
+        supported: boolean;
+        granularity: HookGranularity;
+        canBlock: boolean;
+    };
+    /** Safety: OS-level sandboxing */
+    sandbox: {
+        supported: boolean;
+        modes: SandboxMode[];
+        writablePaths?: string[];
+    };
+    supportsWorktrees: boolean;
+    /** Context capabilities */
+    supportsSkills: boolean;
+    supportsMcp: boolean;
+    memory: {
+        supported: boolean;
+        backend: MemoryBackend;
+    };
+    maxContextTokens: number;
+    /** Which lifecycle events the tool emits natively */
+    lifecycleEvents: string[];
+}
+/** Creates a default capabilities object with all features disabled. */
+declare function createDefaultCapabilities(): VaughnCapabilities;
+/**
+ * Known capability profiles for supported tools (Section 4.2).
+ * These are reference profiles; actual adapters may override.
+ */
+declare const TOOL_PROFILES: Record<string, VaughnCapabilities>;
+
+/**
+ * VAUGHN Lifecycle Events (Section 5 of VAUGHN.md)
+ *
+ * Defines the 10 canonical lifecycle events, the event envelope,
+ * Zod schemas for runtime validation, and a factory function.
+ */
+
+/** Protocol version. */
+declare const VAUGHN_VERSION: "0.1.0";
+/** The 10 canonical VAUGHN lifecycle events. */
+type VaughnEvent = 'session.start' | 'session.stop' | 'session.crash' | 'prompt.submit' | 'tool.before' | 'tool.after' | 'tool.blocked' | 'task.claimed' | 'task.completed' | 'agent.heartbeat';
+/** All valid event names as a readonly array. */
+declare const VAUGHN_EVENTS: readonly VaughnEvent[];
+/** Standard envelope wrapping every VAUGHN event (Section 5.4). */
+interface VaughnEventEnvelope {
+    version: typeof VAUGHN_VERSION;
+    event: VaughnEvent;
+    timestamp: string;
+    agentId: string;
+    toolName: string;
+    sessionId: string;
+    payload: Record<string, unknown>;
+}
+/** Zod schema for runtime validation of event envelopes. */
+declare const vaughnEventSchema: z.ZodEnum<{
+    "session.start": "session.start";
+    "session.stop": "session.stop";
+    "prompt.submit": "prompt.submit";
+    "tool.before": "tool.before";
+    "tool.after": "tool.after";
+    "tool.blocked": "tool.blocked";
+    "session.crash": "session.crash";
+    "task.claimed": "task.claimed";
+    "task.completed": "task.completed";
+    "agent.heartbeat": "agent.heartbeat";
+}>;
+declare const vaughnEventEnvelopeSchema: z.ZodObject<{
+    version: z.ZodLiteral<"0.1.0">;
+    event: z.ZodEnum<{
+        "session.start": "session.start";
+        "session.stop": "session.stop";
+        "prompt.submit": "prompt.submit";
+        "tool.before": "tool.before";
+        "tool.after": "tool.after";
+        "tool.blocked": "tool.blocked";
+        "session.crash": "session.crash";
+        "task.claimed": "task.claimed";
+        "task.completed": "task.completed";
+        "agent.heartbeat": "agent.heartbeat";
+    }>;
+    timestamp: z.ZodString;
+    agentId: z.ZodString;
+    toolName: z.ZodString;
+    sessionId: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+/** Creates a VaughnEventEnvelope with the current timestamp. */
+declare function createEventEnvelope(event: VaughnEvent, agentId: string, toolName: string, sessionId: string, payload?: Record<string, unknown>): VaughnEventEnvelope;
+
+interface OllamaStatus {
+    installed: boolean;
+    running: boolean;
+    version: string | null;
+}
+interface OllamaModel {
+    name: string;
+    size: string;
+    modified: string;
+}
+interface ModelPullResult {
+    success: boolean;
+    message: string;
+}
+interface SnapStatus {
+    installed: boolean;
+    running: boolean;
+    snapName: string;
+    endpoint: string | null;
+    version: string | null;
+}
+interface SnapModel {
+    name: string;
+    description: string;
+    installed: boolean;
+}
+/**
+ * Manages local inference engines (Ollama, Snaps) on the daemon host.
+ * Each method mirrors the equivalent Tauri command from `inference.rs`.
+ */
+declare class InferenceService {
+    ollamaStatus(): Promise<OllamaStatus>;
+    ollamaModels(): Promise<OllamaModel[]>;
+    ollamaPull(modelName: string): Promise<ModelPullResult>;
+    ollamaDelete(modelName: string): Promise<void>;
+    ollamaStart(): Promise<void>;
+    ollamaStop(): Promise<void>;
+    snapList(): Promise<SnapModel[]>;
+    snapStatus(snapName: string): Promise<SnapStatus>;
+    snapInstall(snapName: string): Promise<ModelPullResult>;
+    snapRemove(snapName: string): Promise<void>;
+}
+
+type AgentBackend = 'Snap' | 'Ollama';
+interface AgentSessionInfo {
+    id: string;
+    name: string;
+    model: string;
+    backend: AgentBackend;
+    prompt: string;
+    status: 'running' | 'stopped' | 'errored';
+    pid: number | null;
+}
+interface SpawnerConfig {
+    /** Inference snap OpenAI-compatible endpoint (default: http://localhost:9090) */
+    snapEndpoint: string;
+    /** Max concurrent agent sessions (default: 8) */
+    maxSessions: number;
+}
+/**
+ * Manages agent process lifecycle on the daemon host.
+ *
+ * Emits:
+ *   'output' → AgentOutputEvent  (each stdout/stderr line)
+ *   'exit'   → AgentExitEvent    (process termination)
+ */
+declare class SpawnerService extends EventEmitter {
+    private readonly sessions;
+    private readonly config;
+    constructor(overrides?: Partial<SpawnerConfig>);
+    /** Spawn a new agent process. Returns the session ID. */
+    spawn(name: string, backend: AgentBackend, model: string, prompt: string): string;
+    /** Stop a running agent by killing its process. */
+    stop(sessionId: string): void;
+    /** List all agent sessions. */
+    list(): AgentSessionInfo[];
+    /** Remove a stopped/errored session. */
+    remove(sessionId: string): void;
+    /** Kill all running agents (called on daemon shutdown). */
+    stopAll(): void;
+}
+
+interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: number | string | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+/**
+ * JSON-RPC 2.0 server over a Unix domain socket.
+ * Mirrors RpcServer from packages/editors.
+ *
+ * Methods:
+ *   ping                      → { status: 'ok', pid }
+ *   harness.list              → HarnessInfo[]
+ *   harness.execute           → HarnessCommandResult
+ *   harness.info              → HarnessInfo
+ *   harness.listRunning       → HarnessProcessInfo[]
+ *   harness.syncConfig        → ConfigSyncResult
+ *   harness.diffConfig        → ConfigDiffEntry
+ *   harness.health            → HealthCheckResult
+ *   session.register          → AgentSession
+ *   session.update            → AgentSession
+ *   session.end               → { ok: true }
+ *   session.list              → AgentSession[]
+ *   session.history           → AgentSession[]
+ *   mail.send                 → AgentMessage
+ *   mail.broadcast            → { sent: number }
+ *   mail.inbox                → AgentMessage[]
+ *   mail.markRead             → { ok: true }
+ *   files.reserve             → { success, holder? }
+ *   files.check               → FileReservation | null
+ *   files.release             → { released: number }
+ *   files.list                → FileReservation[]
+ *   tasks.create              → AgentTask
+ *   tasks.claim               → { success, owner? }
+ *   tasks.complete            → { ok: boolean }
+ *   tasks.release             → { ok: boolean }
+ *   tasks.list                → AgentTask[]
+ *   events.log                → DaemonEvent
+ *   events.recent             → DaemonEvent[]
+ *   agent.spawn               → { sessionId: string }
+ *   agent.stop                → { ok: true }
+ *   agent.list                → AgentSessionInfo[]
+ *   agent.remove              → { ok: true }
+ *   agent.input               → { ok: true }
+ *   agent.resize              → { ok: true }
+ *   inference.ollama.status   → OllamaStatus
+ *   inference.ollama.models   → OllamaModel[]
+ *   inference.ollama.pull     → ModelPullResult
+ *   inference.ollama.delete   → { ok: true }
+ *   inference.ollama.start    → { ok: true }
+ *   inference.ollama.stop     → { ok: true }
+ *   inference.snap.list       → SnapModel[]
+ *   inference.snap.status     → SnapStatus
+ *   inference.snap.install    → ModelPullResult
+ *   inference.snap.remove     → { ok: true }
+ *   merge.request             → MergeResult
+ *   merge.status              → MergeResult
+ *   merge.resolve             → MergeResult
+ *   merge.list                → MergeRequest[]
+ *   ci.report                 → CIFeedbackResult
+ *   vaughn.capabilities       → VaughnAdapterCapability[]
+ *   vaughn.dispatch           → { adapterId: string | null }
+ *   vaughn.events             → VaughnEventEnvelope[]
+ *   vaughn.config.sync        → { files: Record<string, string> }
+ */
+declare class RpcServer {
+    private readonly registry;
+    private readonly socketPath;
+    private readonly store?;
+    private server;
+    private healthCheckFn;
+    private spawner;
+    private inference;
+    private mergePipeline;
+    private ciFeedback;
+    private vaughnDispatchFn;
+    private readonly vaughnEventQueue;
+    private static readonly MAX_VAUGHN_EVENTS;
+    constructor(registry: HarnessRegistry, socketPath: string, store?: DaemonStore | undefined);
+    private handleLine;
+    private dispatch;
+    /** Helper: store not configured error. */
+    private noStore;
+    /** Helper: missing parameter error. */
+    private missingParam;
+    /** Helper: service not configured error. */
+    private noService;
+    /**
+     * 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: string, reply: (response: JsonRpcResponse) => void): void;
+    /** Set the health check function (called by coordinator after construction). */
+    setHealthCheck(fn: () => Promise<unknown>): void;
+    /** Attach the spawner service (called by coordinator after construction). */
+    setSpawner(spawner: SpawnerService): void;
+    /** Attach the inference service (called by coordinator after construction). */
+    setInference(inference: InferenceService): void;
+    /** Attach the merge pipeline (called by coordinator after construction). */
+    setMergePipeline(pipeline: MergePipeline): void;
+    /** Attach the CI feedback handler (called by coordinator after construction). */
+    setCIFeedback(feedback: CIFeedback): void;
+    /** Attach the VAUGHN dispatch function (called by coordinator after construction). */
+    setVaughnDispatch(fn: (requirements: Partial<VaughnCapabilities>, description: string) => string | null): void;
+    /** Push a VAUGHN event into the recent event queue (capped at 100). */
+    pushVaughnEvent(event: VaughnEventEnvelope): void;
+    /** Get the spawner service (used by HTTP gateway for SSE). */
+    getSpawner(): SpawnerService | null;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+
+/**
+ * HTTP gateway that exposes the harness daemon over TCP.
+ *
+ * Routes:
+ *   POST /rpc               -  JSON-RPC 2.0 proxy (same protocol as Unix socket)
+ *   GET  /api/pair           -  Returns pairing status (requires valid token or no token set)
+ *   POST /api/pair           -  Submit pairing code to get a session token
+ *   GET  /api/stream/:id      -  SSE stream of agent output (real-time)
+ *   GET  /                   -  Serves Studio static frontend (index.html)
+ *   GET  /assets/*           -  Serves static assets
+ *
+ * Auth:
+ *   All /rpc and /api/* requests (except POST /api/pair) require:
+ *     Authorization: Bearer <session-token>
+ *   The session token is obtained via the pairing flow.
+ */
+interface HttpGatewayConfig {
+    /** TCP port to listen on (default: 7890) */
+    port: number;
+    /** Bind address (default: '0.0.0.0' for Tailscale access) */
+    host: string;
+    /** Path to Studio static build directory (optional  -  disables static serving if absent) */
+    staticDir?: string;
+    /** Reference to the Unix-socket RPC server for dispatching */
+    rpcDispatch: RpcServer;
+    /** Reference to the spawner service (enables SSE streaming) */
+    spawner?: SpawnerService;
+}
+declare class HttpGateway {
+    private server;
+    private readonly config;
+    /** 6-digit pairing code (regenerated on each start) */
+    private pairingCode;
+    /** Active session tokens (bearer tokens granted after pairing) */
+    private sessionTokens;
+    /** Whether pairing has been completed at least once */
+    private paired;
+    constructor(config: HttpGatewayConfig);
+    /** The current pairing code (display this in Studio/terminal) */
+    getPairingCode(): string;
+    /** Regenerate the pairing code (invalidates previous code) */
+    regeneratePairingCode(): string;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleRequest;
+    /** Verify the Authorization: Bearer <token> header */
+    private checkAuth;
+    /** POST /api/pair  -  submit pairing code, receive session token */
+    private handlePair;
+    /** GET /api/pair  -  check pairing status */
+    private handlePairStatus;
+    /** GET /api/status  -  daemon status summary */
+    private handleStatus;
+    /** POST /rpc  -  proxy JSON-RPC to the daemon's dispatch */
+    private handleRpc;
+    /** GET /api/stream[/:sessionId]  -  SSE for agent output and exit events */
+    private handleStream;
+    /** Serve static files from the Studio build directory */
+    private handleStatic;
+}
+
 interface CoordinatorOptions {
     /** Absolute path to the project root (where .claude/workboard.md lives) */
     projectRoot: string;
@@ -114,9 +578,15 @@ interface CoordinatorOptions {
     socketPath?: string;
     /** Session task description shown in the workboard */
     task?: string;
+    /** Enable HTTP gateway for remote access (default: disabled) */
+    httpPort?: number;
+    /** HTTP gateway bind address (default: '0.0.0.0') */
+    httpHost?: string;
+    /** Path to Studio static build for serving via HTTP gateway */
+    httpStaticDir?: string;
 }
 /**
- * HarnessCoordinator — single entry point for harness-to-harness coordination.
+ * HarnessCoordinator  -  single entry point for harness-to-harness coordination.
  *
  * On start:
  *   1. Auto-detects installed AI harnesses and registers them
@@ -131,7 +601,14 @@ interface CoordinatorOptions {
 declare class HarnessCoordinator {
     private readonly options;
     private readonly registry;
+    private readonly vaughnCapabilities;
     private rpcServer;
+    private httpGateway;
+    private store;
+    private spawner;
+    private inference;
+    private mergePipeline;
+    private ciFeedback;
     private sessionId;
     private readonly workboard;
     constructor(options: CoordinatorOptions);
@@ -141,15 +618,29 @@ declare class HarnessCoordinator {
     getRegistry(): HarnessRegistry;
     /** The workboard manager. */
     getWorkboard(): WorkboardManager;
+    /** The daemon persistent store (available after start()). */
+    getStore(): DaemonStore | null;
     /** Register a custom adapter (must be called before start()). */
     registerAdapter(adapter: HarnessAdapter): void;
+    /** Register explicit VAUGHN capabilities for an adapter. */
+    registerVaughnCapabilities(adapterId: string, capabilities: VaughnCapabilities): void;
+    /**
+     * 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: Partial<VaughnCapabilities>, _description: string): string | null;
+    /** Check whether capabilities satisfy requirements. */
+    private matchesRequirements;
+    /** The HTTP gateway (available after start() if httpPort was set). */
+    getHttpGateway(): HttpGateway | null;
     /** Run a health check across all registered harnesses and the workboard. */
     healthCheck(): Promise<HealthCheckResult>;
 }
 
 /**
  * Detects available AI harnesses and registers them in the registry.
- * Mirrors autoDetectEditors from packages/editors.
  *
  * Creates an adapter for each known harness, checks isAvailable(),
  * and registers those that respond. Unavailable adapters are disposed.
@@ -169,38 +660,232 @@ declare function findAllHarnessProcesses(): Promise<HarnessProcessInfo[]>;
 declare function findClaudeCodeSockets(): Promise<string[]>;
 
 /**
- * JSON-RPC 2.0 server over a Unix domain socket.
- * Mirrors RpcServer from packages/editors.
+ * VAUGHN Adapter Interface (Section 7 of VAUGHN.md)
  *
- * Methods:
- *   harness.list              → HarnessInfo[]
- *   harness.execute           → HarnessCommandResult
- *   harness.info              → HarnessInfo
- *   harness.listRunning       → HarnessProcessInfo[]
- *   harness.syncConfig        → ConfigSyncResult
- *   harness.diffConfig        → ConfigDiffEntry
- *   harness.health            → HealthCheckResult
+ * The adapter is the boundary between a tool's native interface and the
+ * VAUGHN protocol. This extends the existing HarnessAdapter with full
+ * VAUGHN capabilities.
  */
-declare class RpcServer {
-    private readonly registry;
-    private readonly socketPath;
-    private server;
-    private healthCheckFn;
-    constructor(registry: HarnessRegistry, socketPath: string);
-    private handleLine;
-    private dispatch;
-    /** Set the health check function (called by coordinator after construction). */
-    setHealthCheck(fn: () => Promise<unknown>): void;
-    start(): Promise<void>;
-    stop(): Promise<void>;
+
+/** MCP server configuration entry. */
+interface McpServerConfig {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+/** Canonical configuration schema (Section 6.1). */
+interface VaughnConfig {
+    identity: {
+        name: string;
+        email: string;
+        role?: string;
+    };
+    permissions: {
+        autoApprove: string[];
+        deny: string[];
+        sandboxMode?: 'read-only' | 'workspace-write' | 'full-access';
+    };
+    environment: {
+        variables: Record<string, string>;
+        mcpServers: McpServerConfig[];
+    };
+    rules: VaughnRule[];
+    skills: VaughnSkill[];
+    commands: VaughnCommand[];
+}
+/** Tool-agnostic rule definition (Section 6.3). */
+interface VaughnRule {
+    id: string;
+    description: string;
+    content: string;
+    appliesTo: string[];
+    variables: Record<string, string>;
+}
+/** Tool-agnostic skill definition. */
+interface VaughnSkill {
+    id: string;
+    name: string;
+    description: string;
+    instructions: string;
+}
+/** Tool-agnostic command definition. */
+interface VaughnCommand {
+    id: string;
+    name: string;
+    description: string;
+    steps: string[];
+}
+/** Result of config generation: a map of file paths to contents. */
+interface GeneratedFiles {
+    files: Map<string, string>;
+}
+/** Result of executing a VAUGHN command. */
+interface VaughnCommandResult {
+    success: boolean;
+    message?: string;
+    data?: unknown;
+}
+/** VAUGHN error codes (Section 11.1). */
+type VaughnErrorCode = 'ADAPTER_UNAVAILABLE' | 'CAPABILITY_MISSING' | 'TASK_ALREADY_CLAIMED' | 'TASK_NOT_FOUND' | 'CONFLICT_DETECTED' | 'HOOK_BLOCKED' | 'SANDBOX_DENIED' | 'SESSION_EXPIRED' | 'CONFIG_INVALID' | 'TOOL_RESERVED' | 'WORKBOARD_LOCKED' | 'IDENTITY_CONFLICT';
+/** Structured error envelope (Section 11.2). */
+interface VaughnError {
+    code: VaughnErrorCode;
+    message: string;
+    agentId?: string;
+    details?: Record<string, unknown>;
+}
+/** Summary information about a registered adapter. */
+interface VaughnAdapterInfo {
+    id: string;
+    available: boolean;
+    version: string | null;
+    capabilities: VaughnCapabilities;
+}
+/**
+ * Contract for a VAUGHN adapter.
+ *
+ * This is the full VAUGHN interface. Existing HarnessAdapters can be
+ * wrapped to implement this interface incrementally.
+ */
+interface VaughnAdapter {
+    /** Unique stable identifier, e.g. 'claude-code', 'codex', 'revealui-agent' */
+    readonly id: string;
+    /** Full capability declaration */
+    readonly capabilities: VaughnCapabilities;
+    /** Initialize the adapter (connect to tool, set up event listeners) */
+    initialize(): Promise<void>;
+    /** Release all resources held by this adapter */
+    dispose(): Promise<void>;
+    /** True if the tool is installed and accessible */
+    isAvailable(): Promise<boolean>;
+    /** Tool version string, or null if unavailable */
+    getVersion(): Promise<string | null>;
+    /** Subscribe to VAUGHN-normalized events (adapter -> coordinator) */
+    onEvent(handler: (event: VaughnEventEnvelope) => void): void;
+    /** Execute a typed command against this tool (coordinator -> adapter) */
+    execute?(command: VaughnCommand): Promise<VaughnCommandResult>;
+    /** Generate tool-native config files from canonical VAUGHN config */
+    generateConfig(config: VaughnConfig): Promise<GeneratedFiles>;
+    /** Read tool-native config and parse into canonical form (optional) */
+    readConfig?(): Promise<Partial<VaughnConfig>>;
+    /** Read workboard state through the tool's native interface (if capable) */
+    readWorkboard?(): Promise<WorkboardState>;
+    /** Write workboard state through the tool's native interface (if capable) */
+    writeWorkboard?(state: WorkboardState): Promise<void>;
+}
+
+/**
+ * VAUGHN Config Normalization (Section 6 of VAUGHN.md)
+ *
+ * Bidirectional: VaughnConfig <-> Claude Code settings.json
+ * Write-only: VaughnConfig -> .cursorrules markdown
+ * Write-only: VaughnConfig -> AGENTS.md markdown
+ */
+
+/** Result of config generation: map of relative file paths to contents. */
+interface ConfigGenerationResult {
+    files: Map<string, string>;
+}
+/** Subset of Claude Code settings.json we read/write. */
+interface ClaudeCodeSettings {
+    permissions?: {
+        allow?: string[];
+        deny?: string[];
+    };
+    env?: Record<string, string>;
+    mcpServers?: Record<string, {
+        command: string;
+        args?: string[];
+        env?: Record<string, string>;
+    }>;
+}
+/** Convert a VaughnConfig to Claude Code settings.json format. */
+declare function vaughnConfigToClaudeSettings(config: VaughnConfig): ClaudeCodeSettings;
+/** Parse Claude Code settings.json into a partial VaughnConfig. */
+declare function claudeSettingsToVaughnConfig(settings: ClaudeCodeSettings): Partial<VaughnConfig>;
+/** Generate .cursorrules markdown from VaughnConfig. */
+declare function vaughnConfigToCursorrules(config: VaughnConfig): string;
+/** Generate AGENTS.md markdown from VaughnConfig. */
+declare function vaughnConfigToAgentsMd(config: VaughnConfig): string;
+/**
+ * Generate all config files from a VaughnConfig.
+ * Returns a map of relative file paths to contents.
+ */
+declare function generateAllConfigs(config: VaughnConfig): ConfigGenerationResult;
+
+/**
+ * VAUGHN Degradation Model (Section 5.3 of VAUGHN.md)
+ *
+ * When a tool does not emit a native event for a VAUGHN event,
+ * the adapter applies one of three strategies.
+ */
+
+/**
+ * Degradation strategy applied when a tool lacks native support for an event.
+ *
+ * - polyfill: Adapter synthesizes the event from other signals (same semantics, higher latency)
+ * - degrade: Partial functionality, weaker guarantee, explicitly documented
+ * - absent: No meaningful approximation; capability is reported as missing
+ */
+type DegradationStrategy = 'polyfill' | 'degrade' | 'absent';
+/**
+ * Returns the degradation strategy for a given tool and event.
+ *
+ * - Returns `undefined` if the tool natively supports the event (no degradation).
+ * - Returns the strategy if the tool lacks native support.
+ * - Returns `'absent'` for unknown tools (conservative default).
+ */
+declare function getDegradationStrategy(toolName: string, event: VaughnEvent): DegradationStrategy | undefined;
+
+/**
+ * VAUGHN Event Normalization Layer
+ *
+ * Translates HarnessEvent -> VaughnEventEnvelope, applying
+ * degradation strategies for events the tool cannot emit natively.
+ */
+
+/** Result of normalizing a HarnessEvent. */
+interface NormalizedEvent {
+    envelope: VaughnEventEnvelope;
+    /** Undefined when the tool natively supports the event. */
+    degradation: DegradationStrategy | undefined;
+}
+/**
+ * Translates tool-native HarnessEvents into VAUGHN canonical event envelopes.
+ *
+ * Each instance is bound to a specific tool/agent/session identity.
+ * Call `normalize()` with each HarnessEvent to get a VaughnEventEnvelope.
+ */
+declare class VaughnEventNormalizer {
+    private readonly toolName;
+    private readonly agentId;
+    private readonly sessionId;
+    constructor(toolName: string, agentId: string, sessionId: string);
+    /**
+     * Map a HarnessEvent type to its canonical VAUGHN event.
+     * Returns null if the event has no VAUGHN mapping.
+     */
+    private mapEventType;
+    /** Extract event-specific payload fields. */
+    private extractPayload;
+    /**
+     * 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: HarnessEvent): NormalizedEvent | null;
+    /** Convenience: normalize and return just the envelope (or null). */
+    normalizeToEnvelope(event: HarnessEvent): VaughnEventEnvelope | null;
 }
 
 /**
- * @revealui/harnesses — AI Harness Integration System (Server-side)
+ * @revealui/harnesses  -  AI Harness Integration System (Server-side)
  *
  * Adapters, registry, workboard coordination, and JSON-RPC server for
- * integrating AI coding tools (Claude Code, Cursor) into the
- * RevealUI development workflow.
+ * integrating native AI agents into the RevealUI development workflow.
  *
  * Pro tier feature: gated behind isFeatureEnabled("ai").
  *
@@ -209,4 +894,4 @@ declare class RpcServer {
 /** Check whether the harnesses feature is licensed for this installation. */
 declare function checkHarnessesLicense(): Promise<boolean>;
 
-export { ClaudeCodeAdapter, ConfigDiffEntry, ConfigSyncDirection, ConfigSyncResult, type CoordinatorOptions, CursorAdapter, HarnessAdapter, HarnessCapabilities, HarnessCommand, HarnessCommandResult, HarnessCoordinator, HarnessEvent, HarnessInfo, HarnessProcessInfo, HarnessRegistry, HealthCheckResult, RpcServer, WorkboardManager, autoDetectHarnesses, checkHarnessesLicense, diffAllConfigs, diffConfig, findAllHarnessProcesses, findClaudeCodeSockets, findHarnessProcesses, findProcesses, getConfigurableHarnesses, getLocalConfigPath, getRootConfigPath, syncAllConfigs, syncConfig, validateConfigJson };
+export { type ClaudeCodeSettings, ConfigDiffEntry, type ConfigGenerationResult, ConfigSyncDirection, ConfigSyncResult, type CoordinatorOptions, DaemonStore, type DegradationStrategy, type GeneratedFiles, HarnessAdapter, HarnessCoordinator, HarnessEvent, HarnessProcessInfo, HarnessRegistry, HealthCheckResult, type HookGranularity, type McpServerConfig, type MemoryBackend, type NormalizedEvent, RpcServer, type SandboxMode, TOOL_PROFILES, VAUGHN_EVENTS, VAUGHN_VERSION, type VaughnAdapter, type VaughnAdapterInfo, type VaughnCapabilities, type VaughnCommand, type VaughnCommandResult, type VaughnConfig, type VaughnError, type VaughnErrorCode, type VaughnEvent, type VaughnEventEnvelope, VaughnEventNormalizer, type VaughnRule, type VaughnSkill, WorkboardManager, WorkboardState, autoDetectHarnesses, checkHarnessesLicense, claudeSettingsToVaughnConfig, createDefaultCapabilities, createEventEnvelope, diffAllConfigs, diffConfig, findAllHarnessProcesses, findClaudeCodeSockets, findHarnessProcesses, findProcesses, generateAllConfigs, getConfigurableHarnesses, getDegradationStrategy, getLocalConfigPath, getRootConfigPath, syncAllConfigs, syncConfig, validateConfigJson, vaughnConfigToAgentsMd, vaughnConfigToClaudeSettings, vaughnConfigToCursorrules, vaughnEventEnvelopeSchema, vaughnEventSchema };