@revealui/harnesses 0.1.8 → 0.1.10

package/README.md

@@ -1,9 +1,9 @@
 # @revealui/harnesses
 
-> **Commercial package** — requires a [RevealUI Pro license](https://revealui.com/pro). Free to install and evaluate; a license key is required for production use.
+> **Commercial package**  -  requires a [RevealUI Pro license](https://revealui.com/pro). Free to install and evaluate; a license key is required for production use.
 
 
-AI harness coordination for RevealUI — enables multiple AI coding tools to work on the same codebase safely and in parallel.
+AI harness coordination for RevealUI  -  enables multiple AI coding tools to work on the same codebase safely and in parallel.
 
 ## Features
 
@@ -99,10 +99,10 @@ pnpm --filter @revealui/harnesses build
 
 ## Related Documentation
 
-- [Coordination Rules](../../.claude/rules/coordination.md) — Multi-instance protocol
-- [Architecture Guide](../../docs/ARCHITECTURE.md) — System architecture
-- [Editors Package](../editors/README.md) — Editor daemon (parallel architecture)
+- [Coordination Rules](../../.claude/rules/coordination.md)  -  Multi-instance protocol
+- [Architecture Guide](../../docs/ARCHITECTURE.md)  -  System architecture
+- [Editors Package](../editors/README.md)  -  Editor daemon (parallel architecture)
 
 ## License
 
-Commercial — see [LICENSE.commercial](../../LICENSE.commercial)
+Commercial  -  see [LICENSE.commercial](../../LICENSE.commercial)

package/dist/{chunk-DGUM43GV.js → chunk-3RG5ZIWI.js}

@@ -8,4 +8,3 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 export {
   __require
 };
-//# sourceMappingURL=chunk-DGUM43GV.js.map

package/dist/{chunk-4F4ANKIZ.js → chunk-ADRJ4TTV.js}

@@ -89,11 +89,31 @@ function lockPathFor(workboardPath) {
 // src/workboard/session-identity.ts
 import { readFileSync as readFileSync2 } from "fs";
 function detectSessionType() {
+  const vaughnId = process.env.VAUGHN_AGENT_ID;
+  if (vaughnId) {
+    const tool = vaughnId.split("-")[0]?.toLowerCase();
+    if (tool === "claude") return "claude";
+    if (tool === "codex") return "codex";
+    if (tool === "cursor") return "cursor";
+    if (tool === "zed") return "zed";
+    return "terminal";
+  }
+  if (process.env.CLAUDE_AGENT_ROLE) return "claude";
+  try {
+    const cachePath = `/tmp/vaughn-session-${process.ppid}.id`;
+    const cached = readFileSync2(cachePath, "utf8").trim();
+    if (cached === "claude" || cached === "codex" || cached === "zed" || cached === "cursor") {
+      return cached;
+    }
+  } catch {
+  }
   try {
     let pid = process.ppid;
     for (let depth = 0; depth < 8; depth++) {
       if (!pid || pid <= 1) break;
       const cmdline = readFileSync2(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ").toLowerCase();
+      if (cmdline.includes("claude")) return "claude";
+      if (cmdline.includes("codex")) return "codex";
       if (cmdline.includes("zed")) return "zed";
       if (cmdline.includes("cursor")) return "cursor";
       const status = readFileSync2(`/proc/${pid}/status`, "utf8");
@@ -158,7 +178,7 @@ function parseTable(lines) {
     for (let j = 0; j < columns.length; j++) {
       const col = columns[j];
       const raw = (cells[j] || "").trim();
-      row[col] = raw === "\u2014" ? "" : raw;
+      row[col] = raw === "-" ? "" : raw;
     }
     rows.push(row);
   }
@@ -204,13 +224,13 @@ function parseWorkboard(content) {
   return state;
 }
 function padCell(value, width) {
-  const str = String(value || "\u2014");
+  const str = String(value || " - ");
   return str.length >= width ? str : str + " ".repeat(width - str.length);
 }
 function serializeTable(headers, rows) {
   if (headers.length === 0) return "(none)";
   const widths = headers.map((h) => {
-    const dataMax = rows.reduce((max, row) => Math.max(max, String(row[h] || "\u2014").length), 0);
+    const dataMax = rows.reduce((max, row) => Math.max(max, String(row[h] || " - ").length), 0);
     return Math.max(h.length, dataMax, 3);
   });
   const headerLine = `| ${headers.map((h, i) => padCell(h, widths[i])).join(" | ")} |`;
@@ -287,6 +307,7 @@ var WorkboardManager = class {
     }
     this.lockPath = lockPathFor(resolved);
   }
+  workboardPath;
   lockPath;
   // ---- Read/Write ----
   read() {
@@ -522,20 +543,15 @@ var WorkboardManager = class {
 function emptyState() {
   return { preamble: [], agents: [], tasks: [], blocked: [], done: [], log: [], _extra: {} };
 }
-var registerSession = WorkboardManager.prototype.registerAgent;
-var unregisterSession = WorkboardManager.prototype.unregisterAgent;
 
 export {
+  detectSessionType,
+  deriveSessionId,
   acquireLock,
   releaseLock,
   withLock,
   withLockAsync,
   atomicWriteSync,
   lockPathFor,
-  WorkboardManager,
-  registerSession,
-  unregisterSession,
-  detectSessionType,
-  deriveSessionId
+  WorkboardManager
 };
-//# sourceMappingURL=chunk-4F4ANKIZ.js.map

package/dist/{chunk-DGQ5OB6L.js → chunk-ANX4L2PF.js}

@@ -62,6 +62,52 @@ var SCHEMA_SQL = `
 
   CREATE INDEX IF NOT EXISTS idx_events_agent
     ON events (agent_id, created_at DESC);
+
+  CREATE TABLE IF NOT EXISTS worktrees (
+    agent_id      TEXT PRIMARY KEY,
+    branch        TEXT NOT NULL,
+    worktree_path TEXT NOT NULL,
+    base_branch   TEXT NOT NULL DEFAULT 'test',
+    status        TEXT NOT NULL DEFAULT 'active',
+    created_at    TIMESTAMP NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS agent_memory (
+    id            SERIAL PRIMARY KEY,
+    agent_id      TEXT NOT NULL,
+    memory_type   TEXT NOT NULL,
+    content       TEXT NOT NULL,
+    metadata      JSONB NOT NULL DEFAULT '{}',
+    created_at    TIMESTAMP NOT NULL DEFAULT NOW()
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_memory_agent_type
+    ON agent_memory (agent_id, memory_type, created_at DESC);
+
+  CREATE TABLE IF NOT EXISTS merge_requests (
+    id            TEXT PRIMARY KEY,
+    agent_id      TEXT NOT NULL,
+    task_id       TEXT,
+    source_branch TEXT NOT NULL,
+    base_branch   TEXT NOT NULL DEFAULT 'test',
+    status        TEXT NOT NULL DEFAULT 'pending',
+    pr_number     INTEGER,
+    pr_url        TEXT,
+    retry_count   INTEGER NOT NULL DEFAULT 0,
+    error_message TEXT,
+    ci_output     TEXT,
+    created_at    TIMESTAMP NOT NULL DEFAULT NOW(),
+    updated_at    TIMESTAMP NOT NULL DEFAULT NOW()
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_merge_requests_agent
+    ON merge_requests (agent_id, status);
+
+  CREATE INDEX IF NOT EXISTS idx_merge_requests_branch
+    ON merge_requests (source_branch);
+
+  CREATE INDEX IF NOT EXISTS idx_merge_requests_pr
+    ON merge_requests (pr_number) WHERE pr_number IS NOT NULL;
 `;
 
 // src/storage/daemon-store.ts
@@ -85,7 +131,7 @@ var DaemonStore = class {
     }
   }
   getDb() {
-    if (!this.db) throw new Error("DaemonStore not initialized \u2014 call init() first");
+    if (!this.db) throw new Error("DaemonStore not initialized  -  call init() first");
     return this.db;
   }
   // ---------------------------------------------------------------------------
@@ -371,10 +417,235 @@ var DaemonStore = class {
     );
     return result.affectedRows ?? 0;
   }
+  // ---------------------------------------------------------------------------
+  // Worktrees
+  // ---------------------------------------------------------------------------
+  /** Register a worktree for an agent. */
+  async registerWorktree(wt) {
+    const db = this.getDb();
+    const result = await db.query(
+      `INSERT INTO worktrees (agent_id, branch, worktree_path, base_branch)
+       VALUES ($1, $2, $3, $4)
+       ON CONFLICT (agent_id) DO UPDATE SET
+         branch = EXCLUDED.branch,
+         worktree_path = EXCLUDED.worktree_path,
+         base_branch = EXCLUDED.base_branch,
+         status = 'active'
+       RETURNING *`,
+      [wt.agentId, wt.branch, wt.worktreePath, wt.baseBranch ?? "test"]
+    );
+    return result.rows[0];
+  }
+  /** Get a worktree by agent ID. */
+  async getWorktree(agentId) {
+    const db = this.getDb();
+    const result = await db.query("SELECT * FROM worktrees WHERE agent_id = $1", [
+      agentId
+    ]);
+    return result.rows[0] ?? null;
+  }
+  /** List all active worktrees. */
+  async getActiveWorktrees() {
+    const db = this.getDb();
+    const result = await db.query(
+      "SELECT * FROM worktrees WHERE status = 'active' ORDER BY created_at"
+    );
+    return result.rows;
+  }
+  /** Update worktree status (active → merged | abandoned). */
+  async updateWorktreeStatus(agentId, status) {
+    const db = this.getDb();
+    const result = await db.query(
+      "UPDATE worktrees SET status = $2 WHERE agent_id = $1 RETURNING agent_id",
+      [agentId, status]
+    );
+    return (result.rows?.length ?? 0) > 0;
+  }
+  /** Remove a worktree record. */
+  async removeWorktree(agentId) {
+    const db = this.getDb();
+    const result = await db.query("DELETE FROM worktrees WHERE agent_id = $1 RETURNING agent_id", [
+      agentId
+    ]);
+    return (result.rows?.length ?? 0) > 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Agent Memory
+  // ---------------------------------------------------------------------------
+  /** Store a memory entry. */
+  async storeMemory(entry) {
+    const db = this.getDb();
+    const result = await db.query(
+      `INSERT INTO agent_memory (agent_id, memory_type, content, metadata)
+       VALUES ($1, $2, $3, $4)
+       RETURNING *`,
+      [entry.agentId, entry.memoryType, entry.content, JSON.stringify(entry.metadata ?? {})]
+    );
+    return result.rows[0];
+  }
+  /** Recall memory entries by agent and type (newest first). */
+  async recallMemory(query) {
+    const db = this.getDb();
+    const conditions = [];
+    const params = [];
+    let paramIdx = 1;
+    if (query.agentId) {
+      conditions.push(`agent_id = $${paramIdx++}`);
+      params.push(query.agentId);
+    }
+    if (query.memoryType) {
+      conditions.push(`memory_type = $${paramIdx++}`);
+      params.push(query.memoryType);
+    }
+    if (query.keyword) {
+      conditions.push(`content ILIKE $${paramIdx++}`);
+      params.push(`%${query.keyword}%`);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = query.limit ?? 20;
+    params.push(limit);
+    const result = await db.query(
+      `SELECT * FROM agent_memory ${where} ORDER BY created_at DESC LIMIT $${paramIdx}`,
+      params
+    );
+    return result.rows;
+  }
+  /** Get a summary of recent memory (last N per type for context injection). */
+  async summarizeMemory(agentId, perType) {
+    const db = this.getDb();
+    const result = await db.query(
+      `SELECT * FROM (
+         SELECT *, ROW_NUMBER() OVER (PARTITION BY memory_type ORDER BY created_at DESC) AS rn
+         FROM agent_memory WHERE agent_id = $1
+       ) sub WHERE rn <= $2
+       ORDER BY memory_type, created_at DESC`,
+      [agentId, perType]
+    );
+    return result.rows;
+  }
+  /** Prune old memory entries (keep last N per agent). */
+  async pruneMemory(keepPerAgent) {
+    const db = this.getDb();
+    const result = await db.query(
+      `DELETE FROM agent_memory WHERE id IN (
+         SELECT id FROM (
+           SELECT id, ROW_NUMBER() OVER (PARTITION BY agent_id ORDER BY created_at DESC) AS rn
+           FROM agent_memory
+         ) sub WHERE rn > $1
+       )`,
+      [keepPerAgent]
+    );
+    return result.affectedRows ?? 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Merge Requests
+  // ---------------------------------------------------------------------------
+  /** Create a merge request for an agent's branch. */
+  async createMergeRequest(mr) {
+    const db = this.getDb();
+    const result = await db.query(
+      `INSERT INTO merge_requests (id, agent_id, task_id, source_branch, base_branch)
+       VALUES ($1, $2, $3, $4, $5)
+       ON CONFLICT (id) DO UPDATE SET
+         status = 'pending',
+         retry_count = merge_requests.retry_count,
+         updated_at = NOW()
+       RETURNING *`,
+      [mr.id, mr.agentId, mr.taskId ?? null, mr.sourceBranch, mr.baseBranch ?? "test"]
+    );
+    return result.rows[0];
+  }
+  /** Get a merge request by ID. */
+  async getMergeRequest(id) {
+    const db = this.getDb();
+    const result = await db.query("SELECT * FROM merge_requests WHERE id = $1", [id]);
+    return result.rows[0] ?? null;
+  }
+  /** Get a merge request by source branch. */
+  async getMergeRequestByBranch(branch) {
+    const db = this.getDb();
+    const result = await db.query(
+      "SELECT * FROM merge_requests WHERE source_branch = $1 AND status NOT IN ('merged', 'escalated') ORDER BY created_at DESC LIMIT 1",
+      [branch]
+    );
+    return result.rows[0] ?? null;
+  }
+  /** Get a merge request by PR number. */
+  async getMergeRequestByPr(prNumber) {
+    const db = this.getDb();
+    const result = await db.query(
+      "SELECT * FROM merge_requests WHERE pr_number = $1 ORDER BY created_at DESC LIMIT 1",
+      [prNumber]
+    );
+    return result.rows[0] ?? null;
+  }
+  /** Update a merge request's fields. */
+  async updateMergeRequest(id, updates) {
+    const db = this.getDb();
+    const sets = ["updated_at = NOW()"];
+    const params = [];
+    let paramIdx = 1;
+    if (updates.status !== void 0) {
+      sets.push(`status = $${paramIdx++}`);
+      params.push(updates.status);
+    }
+    if (updates.prNumber !== void 0) {
+      sets.push(`pr_number = $${paramIdx++}`);
+      params.push(updates.prNumber);
+    }
+    if (updates.prUrl !== void 0) {
+      sets.push(`pr_url = $${paramIdx++}`);
+      params.push(updates.prUrl);
+    }
+    if (updates.errorMessage !== void 0) {
+      sets.push(`error_message = $${paramIdx++}`);
+      params.push(updates.errorMessage);
+    }
+    if (updates.ciOutput !== void 0) {
+      sets.push(`ci_output = $${paramIdx++}`);
+      params.push(updates.ciOutput);
+    }
+    params.push(id);
+    const result = await db.query(
+      `UPDATE merge_requests SET ${sets.join(", ")} WHERE id = $${paramIdx} RETURNING *`,
+      params
+    );
+    return result.rows[0] ?? null;
+  }
+  /** Increment the retry count for a merge request. */
+  async incrementMergeRetry(id) {
+    const db = this.getDb();
+    const result = await db.query(
+      `UPDATE merge_requests SET retry_count = retry_count + 1, updated_at = NOW()
+       WHERE id = $1 RETURNING retry_count`,
+      [id]
+    );
+    return result.rows[0]?.retry_count ?? 0;
+  }
+  /** List merge requests, optionally filtered by status and/or agent. */
+  async listMergeRequests(filter) {
+    const db = this.getDb();
+    const conditions = [];
+    const params = [];
+    let paramIdx = 1;
+    if (filter?.status) {
+      conditions.push(`status = $${paramIdx++}`);
+      params.push(filter.status);
+    }
+    if (filter?.agentId) {
+      conditions.push(`agent_id = $${paramIdx++}`);
+      params.push(filter.agentId);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = await db.query(
+      `SELECT * FROM merge_requests ${where} ORDER BY created_at DESC`,
+      params
+    );
+    return result.rows;
+  }
 };
 
 export {
   SCHEMA_SQL,
   DaemonStore
 };
-//# sourceMappingURL=chunk-DGQ5OB6L.js.map