openclaw-node-harness 2.0.4 → 2.1.1

package/mission-control/src/lib/__tests__/task-markdown.test.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect } from "vitest";
+import { parseTasksMarkdown, serializeTasksMarkdown } from "../parsers/task-markdown";
+
+describe("parseTasksMarkdown", () => {
+  it("parses a minimal task", () => {
+    const md = `# Active Tasks
+
+Updated: 2026-03-21
+
+## Live Tasks
+
+- task_id: T-20260321-001
+  title: Test task
+  status: queued
+  owner: main
+  success_criteria:
+  artifacts:
+  next_action: do something
+  updated_at: 2026-03-21T12:00:00Z
+`;
+    const tasks = parseTasksMarkdown(md);
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].id).toBe("T-20260321-001");
+    expect(tasks[0].title).toBe("Test task");
+    expect(tasks[0].status).toBe("queued");
+    expect(tasks[0].owner).toBe("main");
+    expect(tasks[0].nextAction).toBe("do something");
+  });
+
+  it("parses mesh execution fields", () => {
+    const md = `## Live Tasks
+
+- task_id: T-20260321-002
+  title: Mesh task
+  status: running
+  owner: daedalus
+  success_criteria:
+  artifacts:
+  next_action: n/a
+  execution: mesh
+  mesh_task_id: MESH-TEST-001
+  mesh_node: calos-ubuntu
+  metric: tests pass
+  budget_minutes: 60
+  scope:
+    - src/lib/
+    - src/app/
+  updated_at: 2026-03-21T12:00:00Z
+`;
+    const tasks = parseTasksMarkdown(md);
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].execution).toBe("mesh");
+    expect(tasks[0].meshTaskId).toBe("MESH-TEST-001");
+    expect(tasks[0].meshNode).toBe("calos-ubuntu");
+    expect(tasks[0].metric).toBe("tests pass");
+    expect(tasks[0].budgetMinutes).toBe(60);
+    expect(tasks[0].scope).toEqual(["src/lib/", "src/app/"]);
+  });
+
+  it("parses collaboration fields", () => {
+    const md = `## Live Tasks
+
+- task_id: T-20260321-003
+  title: Collab task
+  status: queued
+  owner: main
+  success_criteria:
+  artifacts:
+  next_action: n/a
+  execution: mesh
+  collaboration: {"mode":"parallel","min_nodes":2,"max_nodes":3}
+  preferred_nodes:
+    - node-a
+    - node-b
+  cluster_id: security-team
+  updated_at: 2026-03-21T12:00:00Z
+`;
+    const tasks = parseTasksMarkdown(md);
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].collaboration).toEqual({ mode: "parallel", min_nodes: 2, max_nodes: 3 });
+    expect(tasks[0].preferredNodes).toEqual(["node-a", "node-b"]);
+    expect(tasks[0].clusterId).toBe("security-team");
+  });
+
+  it("parses scheduling fields", () => {
+    const md = `## Live Tasks
+
+- task_id: T-20260321-004
+  title: Scheduled task
+  status: queued
+  owner: main
+  success_criteria:
+  artifacts:
+  next_action: n/a
+  needs_approval: false
+  trigger_kind: cron
+  trigger_cron: 0 10 * * 1
+  trigger_tz: America/New_York
+  is_recurring: true
+  capacity_class: heavy
+  auto_priority: 5
+  updated_at: 2026-03-21T12:00:00Z
+`;
+    const tasks = parseTasksMarkdown(md);
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].needsApproval).toBe(false);
+    expect(tasks[0].triggerKind).toBe("cron");
+    expect(tasks[0].triggerCron).toBe("0 10 * * 1");
+    expect(tasks[0].triggerTz).toBe("America/New_York");
+    expect(tasks[0].isRecurring).toBe(true);
+    expect(tasks[0].capacityClass).toBe("heavy");
+    expect(tasks[0].autoPriority).toBe(5);
+  });
+
+  it("returns empty for markdown without Live Tasks section", () => {
+    const md = `# Active Tasks\n\nNo tasks here.`;
+    expect(parseTasksMarkdown(md)).toEqual([]);
+  });
+});
+
+describe("serializeTasksMarkdown round-trip", () => {
+  it("round-trips a minimal task", () => {
+    const md = `# Active Tasks
+
+Updated: 2026-03-21
+
+## Live Tasks
+
+- task_id: T-20260321-001
+  title: Test task
+  status: queued
+  owner: main
+  success_criteria:
+  artifacts:
+  next_action: do something
+  updated_at: 2026-03-21T12:00:00Z
+`;
+    const parsed = parseTasksMarkdown(md);
+    const serialized = serializeTasksMarkdown(parsed);
+    const reparsed = parseTasksMarkdown(serialized);
+
+    expect(reparsed).toHaveLength(1);
+    expect(reparsed[0].id).toBe(parsed[0].id);
+    expect(reparsed[0].title).toBe(parsed[0].title);
+    expect(reparsed[0].status).toBe(parsed[0].status);
+    expect(reparsed[0].nextAction).toBe(parsed[0].nextAction);
+  });
+
+  it("round-trips mesh + collab fields", () => {
+    const md = `## Live Tasks
+
+- task_id: MESH-001
+  title: Full mesh task
+  status: running
+  owner: daedalus
+  success_criteria:
+    - tests pass
+    - no regressions
+  artifacts:
+    - /path/to/output.json
+  next_action: wait for results
+  execution: mesh
+  mesh_task_id: NATS-001
+  mesh_node: node-alpha
+  metric: all green
+  budget_minutes: 45
+  scope:
+    - src/
+  collaboration: {"mode":"review","min_nodes":2}
+  preferred_nodes:
+    - node-alpha
+    - node-beta
+  cluster_id: dev-team
+  updated_at: 2026-03-21T15:00:00Z
+`;
+    const parsed = parseTasksMarkdown(md);
+    const serialized = serializeTasksMarkdown(parsed);
+    const reparsed = parseTasksMarkdown(serialized);
+
+    expect(reparsed[0].execution).toBe("mesh");
+    expect(reparsed[0].meshTaskId).toBe("NATS-001");
+    expect(reparsed[0].scope).toEqual(["src/"]);
+    expect(reparsed[0].preferredNodes).toEqual(["node-alpha", "node-beta"]);
+    expect(reparsed[0].clusterId).toBe("dev-team");
+    expect(reparsed[0].successCriteria).toEqual(["tests pass", "no regressions"]);
+    expect(reparsed[0].artifacts).toEqual(["/path/to/output.json"]);
+  });
+});

package/mission-control/src/lib/__tests__/wikilinks.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect } from "vitest";
+import {
+  extractWikilinks,
+  extractTaskIds,
+  extractFileRefs,
+  buildResolutionMaps,
+  resolveWikilink,
+  extractAllReferences,
+} from "../memory/wikilinks";
+
+describe("extractWikilinks", () => {
+  it("extracts basic wikilinks", () => {
+    const result = extractWikilinks("See [[Project Alpha]] and [[Task Beta]]");
+    expect(result).toEqual(["Project Alpha", "Task Beta"]);
+  });
+
+  it("handles aliased wikilinks [[target|display]]", () => {
+    const result = extractWikilinks("Check [[real-target|Display Name]]");
+    expect(result).toEqual(["real-target"]);
+  });
+
+  it("deduplicates wikilinks", () => {
+    const result = extractWikilinks("[[Foo]] and [[Foo]] again");
+    expect(result).toEqual(["Foo"]);
+  });
+
+  it("ignores wikilinks inside code blocks", () => {
+    const result = extractWikilinks("```\n[[Inside Code]]\n```\nOutside [[Real]]");
+    expect(result).toEqual(["Real"]);
+  });
+
+  it("ignores wikilinks inside inline code", () => {
+    const result = extractWikilinks("Use `[[NotALink]]` but [[ActualLink]]");
+    expect(result).toEqual(["ActualLink"]);
+  });
+
+  it("returns empty for no wikilinks", () => {
+    expect(extractWikilinks("No links here")).toEqual([]);
+  });
+
+  it("skips empty targets", () => {
+    expect(extractWikilinks("[[]]")).toEqual([]);
+  });
+
+  it("trims whitespace from targets", () => {
+    const result = extractWikilinks("[[  Padded  ]]");
+    expect(result).toEqual(["Padded"]);
+  });
+});
+
+describe("extractTaskIds", () => {
+  it("extracts T-YYYYMMDD-NNN format", () => {
+    const result = extractTaskIds("Working on T-20260305-001 and T-20260310-042");
+    expect(result).toEqual(["T-20260305-001", "T-20260310-042"]);
+  });
+
+  it("extracts ARCANE-style IDs", () => {
+    const result = extractTaskIds("ARCANE-M01 and ARCANE-B02-3");
+    expect(result).toEqual(["ARCANE-M01", "ARCANE-B02-3"]);
+  });
+
+  it("deduplicates task IDs", () => {
+    const result = extractTaskIds("T-20260305-001 mentioned twice: T-20260305-001");
+    expect(result).toEqual(["T-20260305-001"]);
+  });
+
+  it("ignores IDs in code blocks", () => {
+    const result = extractTaskIds("```\nT-20260101-999\n```");
+    expect(result).toEqual([]);
+  });
+});
+
+describe("extractFileRefs", () => {
+  it("extracts markdown file references", () => {
+    const result = extractFileRefs("See docs/README.md for details");
+    expect(result).toContain("docs/README.md");
+  });
+
+  it("extracts various extensions", () => {
+    const result = extractFileRefs("Edit src/app.ts and config.json");
+    expect(result).toContain("src/app.ts");
+    expect(result).toContain("config.json");
+  });
+
+  it("skips http URLs", () => {
+    const result = extractFileRefs("Visit https://example.com/page");
+    // http refs are filtered out
+    const httpRefs = result.filter((r) => r.includes("http"));
+    expect(httpRefs).toEqual([]);
+  });
+
+  it("includes short but valid file refs", () => {
+    // "a.md" is 4 chars, passes the >= 4 length check
+    const result = extractFileRefs("see a.md for info");
+    expect(result).toContain("a.md");
+  });
+});
+
+describe("buildResolutionMaps", () => {
+  it("builds path, basename, and title maps", () => {
+    const docs = [
+      { filePath: "projects/alpha/README.md", title: "Alpha Project" },
+      { filePath: "memory/notes.md", title: "Session Notes" },
+    ];
+    const maps = buildResolutionMaps(docs);
+
+    expect(maps.byPath.has("projects/alpha/README.md")).toBe(true);
+    expect(maps.byBasename.has("readme")).toBe(true);
+    expect(maps.byTitle.has("alpha project")).toBe(true);
+  });
+
+  it("first doc wins for basename conflicts", () => {
+    const docs = [
+      { filePath: "a/notes.md", title: null },
+      { filePath: "b/notes.md", title: null },
+    ];
+    const maps = buildResolutionMaps(docs);
+    expect(maps.byBasename.get("notes")).toBe("a/notes.md");
+  });
+});
+
+describe("resolveWikilink", () => {
+  const maps = buildResolutionMaps([
+    { filePath: "projects/alpha.md", title: "Alpha Project" },
+    { filePath: "memory/2026-03-01.md", title: "March 1 Log" },
+  ]);
+
+  it("resolves exact path", () => {
+    expect(resolveWikilink("projects/alpha.md", maps)).toBe("projects/alpha.md");
+  });
+
+  it("resolves path without .md extension", () => {
+    expect(resolveWikilink("projects/alpha", maps)).toBe("projects/alpha.md");
+  });
+
+  it("resolves by basename (case-insensitive)", () => {
+    expect(resolveWikilink("Alpha", maps)).toBe("projects/alpha.md");
+  });
+
+  it("resolves by title (case-insensitive)", () => {
+    expect(resolveWikilink("alpha project", maps)).toBe("projects/alpha.md");
+  });
+
+  it("returns null for unresolvable target", () => {
+    expect(resolveWikilink("nonexistent", maps)).toBeNull();
+  });
+});
+
+describe("extractAllReferences", () => {
+  const maps = buildResolutionMaps([
+    { filePath: "projects/alpha.md", title: "Alpha Project" },
+    { filePath: "tasks/T-20260305-001.md", title: "T-20260305-001" },
+    { filePath: "self.md", title: "Self" },
+  ]);
+
+  it("combines wikilinks, task IDs, and file refs", () => {
+    const content = "See [[Alpha Project]] and T-20260305-001 in projects/alpha.md";
+    const refs = extractAllReferences(content, maps, "self.md");
+    expect(refs).toContain("projects/alpha.md");
+    expect(refs).toContain("tasks/T-20260305-001.md");
+  });
+
+  it("excludes self-references", () => {
+    const content = "[[Self]] is this document";
+    const refs = extractAllReferences(content, maps, "self.md");
+    expect(refs).not.toContain("self.md");
+  });
+
+  it("deduplicates across sources", () => {
+    const content = "[[Alpha Project]] and projects/alpha.md";
+    const refs = extractAllReferences(content, maps, "self.md");
+    const alphaCount = refs.filter((r) => r === "projects/alpha.md").length;
+    expect(alphaCount).toBe(1);
+  });
+});

package/mission-control/src/lib/config.ts

@@ -19,3 +19,70 @@ export const LORE_DIRS = [
   path.join(WORKSPACE_ROOT, "projects", "arcane", "lore", "canon"),
   path.join(WORKSPACE_ROOT, "projects", "arcane", "lore", "drafts"),
 ];
+
+// ── LLM-Agnostic Identity & Model Configuration ──
+// Override via env vars to use any agent name, human name, or LLM provider.
+
+/** Name of the autonomous agent (shown in kanban, scheduler, notifications) */
+export const AGENT_NAME = process.env.OPENCLAW_AGENT_NAME || "Daedalus";
+
+/** Name of the human operator (shown in done-gate, manual task ownership) */
+export const HUMAN_NAME = process.env.OPENCLAW_HUMAN_NAME || "Gui";
+
+/** Dispatch signal filename (agent picks up auto-dispatched tasks via this file) */
+export const DISPATCH_SIGNAL_FILE = `${AGENT_NAME.toLowerCase()}-dispatch.json`;
+
+// ── Model Capability Tiers ──
+// Maps provider-agnostic capability levels to concrete model names.
+// Override LLM_PROVIDER env var to switch between providers.
+
+export type CapabilityTier = "fast" | "standard" | "reasoning";
+
+export const LLM_PROVIDER = process.env.LLM_PROVIDER || "anthropic";
+
+const MODEL_MAP: Record<string, Record<CapabilityTier, string>> = {
+  anthropic: { fast: "haiku", standard: "sonnet", reasoning: "opus" },
+  openai: { fast: "gpt-4o-mini", standard: "gpt-4o", reasoning: "o1" },
+  google: { fast: "gemini-2.0-flash", standard: "gemini-2.5-pro", reasoning: "gemini-2.5-pro" },
+  local: { fast: "llama-3.2-3b", standard: "llama-3.3-70b", reasoning: "deepseek-r1" },
+};
+
+/**
+ * Resolve a capability tier to a concrete model name for the active provider.
+ * Falls back to the tier name itself if provider is unknown.
+ */
+export function getModel(tier: CapabilityTier): string {
+  return MODEL_MAP[LLM_PROVIDER]?.[tier] ?? tier;
+}
+
+/**
+ * Get the full model map for a provider (for UI display).
+ */
+export function getProviderModels(provider?: string): Record<CapabilityTier, string> | null {
+  return MODEL_MAP[provider || LLM_PROVIDER] ?? null;
+}
+
+/** All registered provider names */
+export const AVAILABLE_PROVIDERS = Object.keys(MODEL_MAP);
+
+/** Validates that a URL path parameter is safe for use in file paths. */
+export function validatePathParam(param: string): string {
+  const cleaned = param.trim();
+  if (!cleaned || !/^[\w][\w.-]{0,127}$/.test(cleaned)) {
+    throw new Error(`Invalid path parameter: "${param.slice(0, 40)}"`);
+  }
+  return cleaned;
+}
+
+// ── Node Identity (Distributed MC) ──
+import { hostname } from "os";
+
+/** This node's unique identifier in the mesh */
+export const NODE_ID = process.env.OPENCLAW_NODE_ID || hostname();
+
+/** This node's role: "lead" (full authority) or "worker" (read + propose) */
+export const NODE_ROLE: "lead" | "worker" =
+  (process.env.OPENCLAW_NODE_ROLE as "lead" | "worker") || "lead";
+
+/** Platform identifier for display */
+export const NODE_PLATFORM = process.platform === "darwin" ? "macOS" : "Linux";

package/mission-control/src/lib/db/index.ts

@@ -2,7 +2,7 @@ import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import * as schema from "./schema";
 import { DB_PATH } from "../config";
-import fs from "fs";
+import fs, { chmodSync, existsSync } from "fs";
 import path from "path";
 
 let _db: ReturnType<typeof drizzle<typeof schema>> | null = null;
@@ -406,6 +406,75 @@ function runMigrations(sqlite: Database.Database) {
     CREATE INDEX IF NOT EXISTS idx_token_usage_node ON token_usage(node_id);
     CREATE INDEX IF NOT EXISTS idx_token_usage_ts ON token_usage(timestamp);
   `);
+
+  // --- Cowork: Clusters ---
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS clusters (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      description TEXT,
+      color TEXT,
+      default_mode TEXT DEFAULT 'parallel',
+      default_convergence TEXT DEFAULT 'unanimous',
+      convergence_threshold INTEGER DEFAULT 66,
+      max_rounds INTEGER DEFAULT 5,
+      status TEXT DEFAULT 'active',
+      updated_at TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS cluster_members (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      cluster_id TEXT NOT NULL,
+      node_id TEXT NOT NULL,
+      role TEXT NOT NULL DEFAULT 'worker',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(cluster_id, node_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_cluster_members_cluster ON cluster_members(cluster_id);
+    CREATE INDEX IF NOT EXISTS idx_cluster_members_node ON cluster_members(node_id);
+  `);
+
+  // Migrate cluster_members: add created_at if missing (old table had joined_at)
+  const cmCols = sqlite.prepare("PRAGMA table_info(cluster_members)").all() as Array<{ name: string }>;
+  const cmColNames = cmCols.map((c) => c.name);
+  if (!cmColNames.includes("created_at")) {
+    sqlite.exec("ALTER TABLE cluster_members ADD COLUMN created_at TEXT NOT NULL DEFAULT (datetime('now'))");
+    if (cmColNames.includes("joined_at")) {
+      sqlite.exec("UPDATE cluster_members SET created_at = joined_at WHERE joined_at IS NOT NULL");
+    }
+  }
+
+  // Normalize: set execution='local' for pre-existing rows where it's NULL
+  sqlite.exec("UPDATE tasks SET execution = 'local' WHERE execution IS NULL");
+
+  // Add cluster_id to tasks if missing
+  if (!colNames.includes("cluster_id")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN cluster_id TEXT");
+  }
+
+  // --- Distributed MC: mesh sync tracking columns ---
+  if (!colNames.includes("mesh_revision")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN mesh_revision INTEGER");
+  }
+  if (!colNames.includes("mesh_synced_at")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN mesh_synced_at TEXT");
+  }
+  if (!colNames.includes("mesh_origin")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN mesh_origin TEXT");
+  }
+
+  // Collab routing columns — bridge reads these from markdown to build NATS payload
+  if (!colNames.includes("collaboration")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN collaboration TEXT");
+  }
+  if (!colNames.includes("preferred_nodes")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN preferred_nodes TEXT");
+  }
+  if (!colNames.includes("exclude_nodes")) {
+    sqlite.exec("ALTER TABLE tasks ADD COLUMN exclude_nodes TEXT");
+  }
 }
 
 export function getDb() {
@@ -419,6 +488,21 @@ export function getDb() {
 
   runMigrations(_sqlite);
 
+  // Lock down DB file permissions — owner read/write only
+  try {
+    if (existsSync(DB_PATH)) {
+      chmodSync(DB_PATH, 0o600);
+    }
+    const walPath = DB_PATH + "-wal";
+    if (existsSync(walPath)) {
+      chmodSync(walPath, 0o600);
+    }
+    const journalPath = DB_PATH + "-journal";
+    if (existsSync(journalPath)) {
+      chmodSync(journalPath, 0o600);
+    }
+  } catch {}
+
   _db = drizzle(_sqlite, { schema });
   return _db;
 }

package/mission-control/src/lib/db/schema.ts

@@ -21,7 +21,7 @@ export const tasks = sqliteTable("tasks", {
   endDate: text("end_date"), // ISO date: "2026-04-15" (range end)
   color: text("color"), // hex color for Gantt bars
   description: text("description"), // markdown body for projects/phases
-  needsApproval: integer("needs_approval").default(1), // 0=Daedalus can start, 1=wait for Gui
+  needsApproval: integer("needs_approval").default(1), // 0=agent can auto-start, 1=wait for human approval
   triggerKind: text("trigger_kind").default("none"), // "none" | "at" | "cron"
   triggerAt: text("trigger_at"), // ISO datetime for one-shot trigger
   triggerCron: text("trigger_cron"), // cron expression (e.g. "0 10 * * 1")
@@ -30,14 +30,18 @@ export const tasks = sqliteTable("tasks", {
   capacityClass: text("capacity_class").default("normal"), // "light" | "normal" | "heavy"
   autoPriority: integer("auto_priority").default(0), // higher = dispatched first
   // Mesh execution fields (synced from active-tasks.md)
-  execution: text("execution"), // "mesh" = dispatched via mesh bridge; null = manual/Daedalus
+  execution: text("execution"), // "mesh" = dispatched via mesh bridge; "local" = agent executes locally
   meshTaskId: text("mesh_task_id"), // NATS KV task ID (e.g. "MESH-TEST-003")
   meshNode: text("mesh_node"), // node that claimed the task (e.g. "calos-ubuntu")
   metric: text("metric"), // mechanical success check (e.g. "tests pass")
   budgetMinutes: integer("budget_minutes").default(30), // agent time budget
   scope: text("scope"), // JSON array of allowed file paths
+  collaboration: text("collaboration"), // JSON: { mode, min_nodes, max_nodes, convergence, ... }
+  preferredNodes: text("preferred_nodes"), // JSON array of node IDs for mesh routing
+  excludeNodes: text("exclude_nodes"), // JSON array of node IDs to avoid
+  clusterId: text("cluster_id"), // FK to clusters.id for collab dispatch
   showInCalendar: integer("show_in_calendar").default(0), // 1=show meta-task in calendar view
-  acknowledgedAt: text("acknowledged_at"), // ISO datetime — when Daedalus acknowledged auto-dispatch
+  acknowledgedAt: text("acknowledged_at"), // ISO datetime — when the agent acknowledged auto-dispatch
   updatedAt: text("updated_at").notNull(),
   createdAt: text("created_at")
     .notNull()
@@ -216,3 +220,57 @@ export type SoulEvolution = typeof soulEvolutionLog.$inferSelect;
 export type NewSoulEvolution = typeof soulEvolutionLog.$inferInsert;
 export type SoulSpawn = typeof soulSpawns.$inferSelect;
 export type NewSoulSpawn = typeof soulSpawns.$inferInsert;
+
+// --- Cowork: Clusters ---
+
+export const clusters = sqliteTable("clusters", {
+  id: text("id").primaryKey(), // slug: "security-team"
+  name: text("name").notNull(),
+  description: text("description"),
+  color: text("color"), // hex: "#6366f1"
+  defaultMode: text("default_mode").default("parallel"), // parallel | sequential | review
+  defaultConvergence: text("default_convergence").default("unanimous"), // unanimous | majority | coordinator
+  convergenceThreshold: integer("convergence_threshold").default(66), // 0-100 (for majority)
+  maxRounds: integer("max_rounds").default(5),
+  status: text("status").default("active"), // active | archived
+  updatedAt: text("updated_at").notNull(),
+  createdAt: text("created_at")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+});
+
+export const clusterMembers = sqliteTable("cluster_members", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  clusterId: text("cluster_id").notNull(),
+  nodeId: text("node_id").notNull(),
+  role: text("role").notNull().default("worker"), // lead | implementer | reviewer | auditor | worker | custom
+  createdAt: text("created_at")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+});
+
+export type Cluster = typeof clusters.$inferSelect;
+export type NewCluster = typeof clusters.$inferInsert;
+export type ClusterMember = typeof clusterMembers.$inferSelect;
+export type NewClusterMember = typeof clusterMembers.$inferInsert;
+
+// ── HyperAgent Protocol (stub — dashboard views deferred) ──────────
+
+export const hyperagentProposals = sqliteTable("hyperagent_proposals", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  externalId: integer("external_id"),
+  title: text("title").notNull(),
+  proposalType: text("proposal_type").notNull(),
+  status: text("status").notNull().default("pending"),
+  description: text("description"),
+  soulId: text("soul_id"),
+  nodeId: text("node_id"),
+  reviewedBy: text("reviewed_by"),
+  reviewedAt: text("reviewed_at"),
+  createdAt: text("created_at")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+});
+
+export type HyperagentProposal = typeof hyperagentProposals.$inferSelect;
+export type NewHyperagentProposal = typeof hyperagentProposals.$inferInsert;