openclaw-node-harness 2.0.4 → 2.1.0

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

@@ -35,6 +35,11 @@ export interface Task {
   metric: string | null;
   budgetMinutes: number | null;
   scope: string | null;
+  // Collab routing fields
+  collaboration: string | null;
+  preferredNodes: string | null;
+  excludeNodes: string | null;
+  clusterId: string | null;
   showInCalendar: number | null;
   acknowledgedAt: string | null;
   updatedAt: string;
@@ -451,6 +456,213 @@ export function useBurndown(projectId: string | null) {
   return { burndown: data ?? null, error, isLoading };
 }
 
+// --- Cowork: Clusters & Collab Sessions ---
+
+export interface ClusterMemberView {
+  id: number;
+  nodeId: string;
+  role: string;
+  nodeStatus: string;
+  createdAt: string;
+}
+
+export interface ClusterView {
+  id: string;
+  name: string;
+  description: string | null;
+  color: string | null;
+  defaultMode: string;
+  defaultConvergence: string;
+  convergenceThreshold: number;
+  maxRounds: number;
+  status: string;
+  members: ClusterMemberView[];
+  updatedAt: string;
+  createdAt: string;
+}
+
+export interface CollabNode {
+  node_id: string;
+  role: string;
+  scope: string[];
+  joined_at: string;
+  status: string;
+}
+
+export interface CollabReflection {
+  node_id: string;
+  summary: string;
+  learnings: string;
+  artifacts: string[];
+  confidence: number;
+  vote: string;
+  parse_failed?: boolean;
+  synthetic?: boolean;
+  submitted_at: string;
+}
+
+export interface CollabRound {
+  round_number: number;
+  started_at: string;
+  completed_at: string | null;
+  shared_intel: string;
+  reflections: CollabReflection[];
+}
+
+export interface CollabSession {
+  session_id: string;
+  task_id: string;
+  mode: string;
+  status: string;
+  min_nodes: number;
+  max_nodes: number | null;
+  nodes: CollabNode[];
+  current_round: number;
+  max_rounds: number;
+  rounds: CollabRound[];
+  convergence: {
+    type: string;
+    threshold: number;
+    metric: string | null;
+    min_quorum: number;
+  };
+  scope_strategy: string;
+  result: Record<string, unknown> | null;
+  audit_log: Array<{ ts: string; event: string; [k: string]: unknown }>;
+  created_at: string;
+  completed_at: string | null;
+}
+
+export function useClusters() {
+  const { data, error, isLoading } = useSWR<{ clusters: ClusterView[] }>(
+    "/api/cowork/clusters",
+    fetcher,
+    { refreshInterval: 10000 }
+  );
+  return { clusters: data?.clusters ?? [], error, isLoading };
+}
+
+export function useCollabSessions(status?: string, refreshInterval = 5000) {
+  const params = status ? `?status=${status}` : "";
+  const { data, error, isLoading } = useSWR<{
+    sessions: CollabSession[];
+    natsAvailable: boolean;
+  }>(`/api/cowork/sessions${params}`, fetcher, { refreshInterval });
+  return {
+    sessions: data?.sessions ?? [],
+    natsAvailable: data?.natsAvailable ?? true,
+    error,
+    isLoading,
+  };
+}
+
+export async function createCluster(params: {
+  name: string;
+  description?: string;
+  color?: string;
+  defaultMode?: string;
+  defaultConvergence?: string;
+  convergenceThreshold?: number;
+  maxRounds?: number;
+  members?: Array<{ nodeId: string; role: string }>;
+}) {
+  const res = await fetch("/api/cowork/clusters", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(params),
+  });
+  const data = await res.json();
+  await mutate("/api/cowork/clusters");
+  return data;
+}
+
+export async function updateCluster(id: string, updates: Record<string, unknown>) {
+  const res = await fetch(`/api/cowork/clusters/${id}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(updates),
+  });
+  const data = await res.json();
+  await mutate("/api/cowork/clusters");
+  return data;
+}
+
+export async function deleteCluster(id: string) {
+  await fetch(`/api/cowork/clusters/${id}`, { method: "DELETE" });
+  await mutate("/api/cowork/clusters");
+}
+
+export async function addClusterMember(clusterId: string, nodeId: string, role: string) {
+  const res = await fetch(`/api/cowork/clusters/${clusterId}/members`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ nodeId, role }),
+  });
+  const data = await res.json();
+  await mutate("/api/cowork/clusters");
+  return data;
+}
+
+export async function updateClusterMember(clusterId: string, nodeId: string, role: string) {
+  const res = await fetch(`/api/cowork/clusters/${clusterId}/members`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ nodeId, role }),
+  });
+  const data = await res.json();
+  await mutate("/api/cowork/clusters");
+  return data;
+}
+
+export async function removeClusterMember(clusterId: string, nodeId: string) {
+  await fetch(
+    `/api/cowork/clusters/${clusterId}/members?nodeId=${encodeURIComponent(nodeId)}`,
+    { method: "DELETE" }
+  );
+  await mutate("/api/cowork/clusters");
+}
+
+export async function dispatchCollabTask(params: {
+  title: string;
+  description?: string;
+  clusterId?: string;
+  nodes?: Array<{ nodeId: string; role: string }>;
+  mode?: string;
+  convergence?: { type: string; threshold?: number; metric?: string };
+  scopeStrategy?: string;
+  budgetMinutes?: number;
+  maxRounds?: number;
+  metric?: string;
+  scope?: string[];
+}) {
+  const res = await fetch("/api/cowork/dispatch", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(params),
+  });
+  const data = await res.json();
+  await mutate("/api/cowork/sessions");
+  await mutate("/api/cowork/clusters");
+  await mutate("/api/tasks");
+  return data;
+}
+
+export async function interveneSession(params: {
+  action: "abort" | "force_converge" | "remove_node";
+  sessionId: string;
+  nodeId?: string;
+}) {
+  const res = await fetch("/api/cowork/intervene", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(params),
+  });
+  const data = await res.json();
+  await mutate("/api/cowork/sessions");
+  await mutate("/api/tasks");
+  return data;
+}
+
 // --- Mesh SSE integration ---
 
 /**
@@ -470,6 +682,14 @@ export function useMeshSSE() {
       mutate("/api/activity");
     };
 
+    const invalidateCollab = () => {
+      mutate("/api/cowork/sessions");
+      mutate("/api/cowork/clusters");
+      mutate("/api/tasks");
+      mutate("/api/activity");
+    };
+
+    // Task events
     es.addEventListener("completed", invalidate);
     es.addEventListener("claimed", invalidate);
     es.addEventListener("started", invalidate);
@@ -478,6 +698,22 @@ export function useMeshSSE() {
     es.addEventListener("released", invalidate);
     es.addEventListener("cancelled", invalidate);
 
+    // Collab events (mesh.events.collab.* → event type is "collab.{action}")
+    es.addEventListener("collab.created", invalidateCollab);
+    es.addEventListener("collab.joined", invalidateCollab);
+    es.addEventListener("collab.round_started", invalidateCollab);
+    es.addEventListener("collab.reflection_received", invalidateCollab);
+    es.addEventListener("collab.converged", invalidateCollab);
+    es.addEventListener("collab.completed", invalidateCollab);
+    es.addEventListener("collab.aborted", invalidateCollab);
+    es.addEventListener("collab.node_removed", invalidateCollab);
+
+    // KV task state changes (from dual-iterator watcher)
+    es.addEventListener("kv.task.updated", () => {
+      mutate("/api/mesh/tasks");
+      mutate("/api/tasks");
+    });
+
     es.onerror = () => {
       // EventSource auto-reconnects
     };
@@ -521,6 +757,79 @@ export function useTokenUsage(period: "today" | "week" | "month" = "today") {
   return { tokenData: data ?? null, error, isLoading };
 }
 
+// --- Mesh Tasks (Distributed MC) ---
+
+export interface MeshTask {
+  task_id: string;
+  title: string;
+  description: string;
+  status: string;
+  origin: string;
+  owner: string | null;
+  priority: number;
+  budget_minutes: number;
+  metric: string | null;
+  created_at: string;
+  [key: string]: unknown;
+}
+
+export function useMeshTasks() {
+  const { data, error, isLoading } = useSWR<{
+    tasks: MeshTask[];
+    natsAvailable: boolean;
+  }>("/api/mesh/tasks", fetcher, {
+    refreshInterval: 5000,
+  });
+  return {
+    meshTasks: data?.tasks ?? [],
+    natsAvailable: data?.natsAvailable ?? false,
+    error,
+    isLoading,
+  };
+}
+
+export function useNodeIdentity() {
+  const { data, error, isLoading } = useSWR<{
+    nodeId: string;
+    role: "lead" | "worker";
+    platform: string;
+  }>("/api/mesh/identity", fetcher);
+  return { identity: data ?? null, error, isLoading };
+}
+
+export async function createMeshTask(task: {
+  title: string;
+  description?: string;
+  priority?: number;
+  budget_minutes?: number;
+  metric?: string;
+  [key: string]: unknown;
+}) {
+  const res = await fetch("/api/mesh/tasks", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(task),
+  });
+  const data = await res.json();
+  await mutate("/api/mesh/tasks");
+  return data;
+}
+
+export async function updateMeshTask(
+  id: string,
+  updates: Record<string, unknown>,
+  revision: number
+) {
+  const res = await fetch(`/api/mesh/tasks/${id}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ ...updates, revision }),
+  });
+  const data = await res.json();
+  await mutate("/api/mesh/tasks");
+  return data;
+}
+
 // --- Scheduler ---
 
 export function useSchedulerTick(intervalMs = 30_000) {

package/mission-control/src/lib/memory/entities.ts

@@ -12,6 +12,7 @@
  */
 
 import { getRawDb } from "../db";
+import { AGENT_NAME, HUMAN_NAME } from "../config";
 
 // ── Types ──
 
@@ -32,8 +33,8 @@ export interface RelationMatch {
 // Bootstrap the graph with known entities. The extraction loop will discover new ones.
 
 const KNOWN_ENTITIES: EntityMatch[] = [
-  { name: "Gui", type: "person" },
-  { name: "Daedalus", type: "person" },
+  { name: HUMAN_NAME, type: "person" },
+  { name: AGENT_NAME, type: "person" },
   { name: "Arcane", type: "project", aliases: ["Arcane Rapture", "arcane-rapture"] },
   { name: "Mission Control", type: "project", aliases: ["MC", "mission-control"] },
   { name: "OpenClaw", type: "project", aliases: ["openclaw"] },

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

@@ -11,6 +11,8 @@ interface NatsGlobals {
   __nats_nc?: NatsConnection | null;
   __nats_connectingSince?: number | null;
   __nats_healthKv?: KV | null;
+  __nats_collabKv?: KV | null;
+  __nats_tasksKv?: KV | null;
 }
 
 const g = globalThis as unknown as NatsGlobals;
@@ -45,6 +47,7 @@ const NATS_URL = resolveNatsUrl();
 
 // KV bucket name — nodes write here, MC reads
 const HEALTH_BUCKET = "MESH_NODE_HEALTH";
+const TASKS_BUCKET = "MESH_TASKS";
 
 /**
  * Get or create a singleton NATS connection.
@@ -73,16 +76,22 @@ export async function getNats(): Promise<NatsConnection | null> {
     });
     console.log("[nats] connected to", NATS_URL);
 
-    // Reset KV handle on reconnect so it's re-fetched fresh
+    // Reset KV handles on reconnect so they're re-fetched fresh
     g.__nats_healthKv = null;
+    g.__nats_collabKv = null;
+    g.__nats_tasksKv = null;
 
     g.__nats_nc.closed().then(() => {
       console.log("[nats] connection closed — will reconnect on next request");
       g.__nats_nc = null;
       g.__nats_healthKv = null;
+      g.__nats_collabKv = null;
+      g.__nats_tasksKv = null;
     }).catch(() => {
       g.__nats_nc = null;
       g.__nats_healthKv = null;
+      g.__nats_collabKv = null;
+      g.__nats_tasksKv = null;
     });
 
     return g.__nats_nc;
@@ -123,4 +132,60 @@ export async function getHealthKv(): Promise<KV | null> {
   }
 }
 
+// KV bucket for collab sessions — daemon writes, MC reads
+const COLLAB_BUCKET = "MESH_COLLAB";
+
+/**
+ * Get the MESH_COLLAB KV bucket (JetStream).
+ *
+ * Collab sessions are written by mesh-collab-daemon, MC reads only.
+ * No TTL — sessions are managed by daemon lifecycle, not expiry.
+ * Returns null if NATS is unavailable.
+ */
+export async function getCollabKv(): Promise<KV | null> {
+  if (g.__nats_collabKv) return g.__nats_collabKv;
+
+  const conn = await getNats();
+  if (!conn) return null;
+
+  try {
+    const js = conn.jetstream();
+    g.__nats_collabKv = await js.views.kv(COLLAB_BUCKET, {
+      history: 1,
+    });
+    return g.__nats_collabKv;
+  } catch (err) {
+    console.error("[nats] Collab KV bucket error:", (err as Error).message);
+    return null;
+  }
+}
+
+/**
+ * Get the MESH_TASKS KV bucket (JetStream).
+ *
+ * Tasks are coordinated through this bucket — the lead writes,
+ * workers read via watch. On worker nodes, this enables the
+ * Kanban to display mesh tasks in real-time.
+ *
+ * Creates the bucket on first call if it doesn't exist (idempotent).
+ * Returns null if NATS is unavailable.
+ */
+export async function getTasksKv(): Promise<KV | null> {
+  if (g.__nats_tasksKv) return g.__nats_tasksKv;
+
+  const conn = await getNats();
+  if (!conn) return null;
+
+  try {
+    const js = conn.jetstream();
+    g.__nats_tasksKv = await js.views.kv(TASKS_BUCKET, {
+      history: 1,
+    });
+    return g.__nats_tasksKv;
+  } catch (err) {
+    console.error("[nats] Tasks KV bucket error:", (err as Error).message);
+    return null;
+  }
+}
+
 export { sc, StringCodec };

package/mission-control/src/lib/parsers/task-markdown.ts

@@ -36,6 +36,11 @@ export interface ParsedTask {
   metric: string | null;
   budgetMinutes: number;
   scope: string[];
+  // Collab routing fields
+  collaboration: Record<string, unknown> | null;
+  preferredNodes: string[];
+  excludeNodes: string[];
+  clusterId: string | null;
 }
 
 /* ------------------------------------------------------------------ */
@@ -51,6 +56,7 @@ const STATUS_TO_KANBAN: Record<string, string> = {
   "waiting-user": "review",
   done: "done",
   cancelled: "done",
+  archived: "done", // hidden from view but still in done column if shown
 };
 
 const KANBAN_TO_STATUS: Record<string, string> = {
@@ -90,7 +96,7 @@ export function parseTasksMarkdown(content: string): ParsedTask[] {
   const lines = liveSection.split("\n");
 
   let current: Partial<ParsedTask> | null = null;
-  let currentArrayKey: "successCriteria" | "artifacts" | "scope" | null = null;
+  let currentArrayKey: "successCriteria" | "artifacts" | "scope" | "preferredNodes" | "excludeNodes" | null = null;
 
   function flush() {
     if (current && current.id) {
@@ -125,6 +131,10 @@ export function parseTasksMarkdown(content: string): ParsedTask[] {
         metric: current.metric ?? null,
         budgetMinutes: current.budgetMinutes ?? 30,
         scope: current.scope ?? [],
+        collaboration: current.collaboration ?? null,
+        preferredNodes: current.preferredNodes ?? [],
+        excludeNodes: current.excludeNodes ?? [],
+        clusterId: current.clusterId ?? null,
       });
     }
   }
@@ -134,7 +144,7 @@ export function parseTasksMarkdown(content: string): ParsedTask[] {
     const taskIdMatch = line.match(/^- task_id:\s*(.+)$/);
     if (taskIdMatch) {
       flush();
-      current = { id: taskIdMatch[1].trim(), successCriteria: [], artifacts: [], scope: [] };
+      current = { id: taskIdMatch[1].trim(), successCriteria: [], artifacts: [], scope: [], preferredNodes: [], excludeNodes: [] };
       currentArrayKey = null;
       continue;
     }
@@ -285,6 +295,27 @@ export function parseTasksMarkdown(content: string): ParsedTask[] {
           current.scope = [];
           currentArrayKey = "scope";
           break;
+        // Collab routing fields
+        case "collaboration":
+          try {
+            current.collaboration = value ? JSON.parse(value) : null;
+          } catch {
+            current.collaboration = null;
+          }
+          currentArrayKey = null;
+          break;
+        case "preferred_nodes":
+          current.preferredNodes = [];
+          currentArrayKey = "preferredNodes";
+          break;
+        case "exclude_nodes":
+          current.excludeNodes = [];
+          currentArrayKey = "excludeNodes";
+          break;
+        case "cluster_id":
+          current.clusterId = value || null;
+          currentArrayKey = null;
+          break;
         case "updated_at":
           current.updatedAt = value;
           currentArrayKey = null;
@@ -450,6 +481,25 @@ export function serializeTasksMarkdown(tasks: ParsedTask[]): string {
         lines.push(`    - ${s}`);
       }
     }
+    // Collab routing fields
+    if (t.collaboration) {
+      lines.push(`  collaboration: ${JSON.stringify(t.collaboration)}`);
+    }
+    if (t.preferredNodes && t.preferredNodes.length > 0) {
+      lines.push("  preferred_nodes:");
+      for (const n of t.preferredNodes) {
+        lines.push(`    - ${n}`);
+      }
+    }
+    if (t.excludeNodes && t.excludeNodes.length > 0) {
+      lines.push("  exclude_nodes:");
+      for (const n of t.excludeNodes) {
+        lines.push(`    - ${n}`);
+      }
+    }
+    if (t.clusterId) {
+      lines.push(`  cluster_id: ${t.clusterId}`);
+    }
     lines.push(`  updated_at: ${t.updatedAt}`);
 
     return lines.join("\n");

package/mission-control/src/lib/parsers/transcript.ts

@@ -15,10 +15,10 @@ export interface TranscriptEvent {
 }
 
 /**
- * Encode a workspace path to Claude's project directory format.
+ * Encode a workspace path to the agent CLI's project directory format.
  * Same algorithm as agent-activity.js: strip leading /, replace / and . with -
  */
-function toClaudeProjectPath(workspacePath: string): string {
+function toAgentProjectPath(workspacePath: string): string {
   return workspacePath.replace(/\\/g, "/").replace(/:/g, "").replace(/[/.]/g, "-");
 }
 
@@ -29,8 +29,8 @@ const WORKSPACE = process.env.WORKSPACE_ROOT || path.join(HOME, ".openclaw/works
  * Transcript source directories — scans ALL frontend transcript stores.
  */
 const TRANSCRIPT_DIRS = [
-  // Claude Code workspace sessions (cross-platform path encoding)
-  path.join(HOME, ".claude/projects", toClaudeProjectPath(WORKSPACE)),
+  // Agent CLI workspace sessions (cross-platform path encoding)
+  path.join(HOME, ".claude/projects", toAgentProjectPath(WORKSPACE)),
   // OpenClaw Gateway sessions (Discord, Telegram, etc.)
   path.join(HOME, ".openclaw/agents/main/sessions"),
 ];

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

@@ -1,4 +1,4 @@
-import { eq, and, ne, or, lte, like, desc } from "drizzle-orm";
+import { eq, and, ne, or, lte, like, desc, isNull } from "drizzle-orm";
 import { CronExpressionParser } from "cron-parser";
 import { writeFileSync, mkdirSync } from "fs";
 import path from "path";
@@ -7,7 +7,7 @@ import { tasks, dependencies } from "./db/schema";
 import { statusToKanban } from "./parsers/task-markdown";
 import { syncTasksToMarkdown } from "./sync/tasks";
 import { logActivity } from "./activity";
-import { WORKSPACE_ROOT } from "./config";
+import { WORKSPACE_ROOT, AGENT_NAME, DISPATCH_SIGNAL_FILE } from "./config";
 import { gatewayNotify } from "./gateway-notify";
 
 
@@ -238,23 +238,23 @@ export function schedulerTick(): TickResult {
   }
 
   // --- Phase 2: Single-task dispatch ---
-  // Rule: ONE auto-start task at a time. Daedalus owns it and works autonomously.
+  // Rule: ONE auto-start task at a time. The agent owns it and works autonomously.
   // Next task only dispatched when current is done, blocked, or waiting-user.
 
-  // Check if Daedalus already has an active auto-dispatched task
-  const daedalusRunning = db
+  // Check if the agent already has an active auto-dispatched task
+  const agentRunning = db
     .select()
     .from(tasks)
     .where(
       and(
         eq(tasks.status, "running"),
-        eq(tasks.owner, "Daedalus"),
+        eq(tasks.owner, AGENT_NAME),
         ne(tasks.id, "__LIVE_SESSION__")
       )
     )
     .all();
 
-  const hasActiveTask = daedalusRunning.length > 0;
+  const hasActiveTask = agentRunning.length > 0;
 
   // Dispatchable: needs_approval=0 AND (status="ready" OR (status="queued" AND trigger_kind="none"))
   const dispatchable = db
@@ -263,6 +263,7 @@ export function schedulerTick(): TickResult {
     .where(
       and(
         eq(tasks.needsApproval, 0),
+        or(isNull(tasks.execution), ne(tasks.execution, "mesh")),
         or(
           eq(tasks.status, "ready"),
           and(eq(tasks.status, "queued"), eq(tasks.triggerKind, "none"))
@@ -308,7 +309,7 @@ export function schedulerTick(): TickResult {
       .set({
         status: "running",
         kanbanColumn: statusToKanban("running"),
-        owner: "Daedalus",
+        owner: AGENT_NAME,
         updatedAt: now.toISOString(),
       })
       .where(eq(tasks.id, next.id))
@@ -322,7 +323,7 @@ export function schedulerTick(): TickResult {
     );
 
     // Notify via gateway message (TUI chat)
-    const notifyText = `MC-Kanban: NEW AUTOTASK FOR DAEDALUS READY: "${next.title}"`;
+    const notifyText = `MC-Kanban: NEW AUTOTASK FOR ${AGENT_NAME.toUpperCase()} READY: "${next.title}"`;
     gatewayNotify(notifyText).catch((err) => {
       console.error("MC gateway notify failed:", err);
     });
@@ -332,7 +333,7 @@ export function schedulerTick(): TickResult {
       const signalDir = path.join(WORKSPACE_ROOT, ".tmp");
       mkdirSync(signalDir, { recursive: true });
       writeFileSync(
-        path.join(signalDir, "daedalus-dispatch.json"),
+        path.join(signalDir, DISPATCH_SIGNAL_FILE),
         JSON.stringify({
           taskId: next.id,
           title: next.title,
@@ -350,7 +351,7 @@ export function schedulerTick(): TickResult {
       result.skipped.push(t.id);
     }
   } else {
-    // All eligible tasks stay in backlog (Daedalus busy or nothing to dispatch)
+    // All eligible tasks stay in backlog (agent busy or nothing to dispatch)
     for (const t of eligible) {
       result.skipped.push(t.id);
     }