openclaw-node-harness 2.0.4 → 2.1.1

package/mission-control/src/components/cowork/role-picker.tsx

@@ -0,0 +1,102 @@
+"use client";
+
+import { useState, useRef, useEffect } from "react";
+import { Crown, Wrench, Eye, Shield, User } from "lucide-react";
+
+export const ROLES = [
+  { value: "lead", label: "Lead", icon: Crown, color: "text-purple-400", bg: "bg-purple-400/10" },
+  { value: "implementer", label: "Implementer", icon: Wrench, color: "text-cyan-400", bg: "bg-cyan-400/10" },
+  { value: "reviewer", label: "Reviewer", icon: Eye, color: "text-amber-400", bg: "bg-amber-400/10" },
+  { value: "auditor", label: "Auditor", icon: Shield, color: "text-red-400", bg: "bg-red-400/10" },
+  { value: "worker", label: "Worker", icon: User, color: "text-zinc-400", bg: "bg-zinc-400/10" },
+] as const;
+
+const ROLE_MAP = new Map(ROLES.map((r) => [r.value as string, r]));
+
+export function RoleBadge({ role }: { role: string }) {
+  const def = ROLE_MAP.get(role);
+  if (!def) {
+    return (
+      <span className="inline-flex items-center gap-1 rounded px-1.5 py-0.5 text-[10px] font-medium bg-zinc-800 text-zinc-300">
+        {role}
+      </span>
+    );
+  }
+  const Icon = def.icon;
+  return (
+    <span
+      className={`inline-flex items-center gap-1 rounded px-1.5 py-0.5 text-[10px] font-medium ${def.bg} ${def.color}`}
+    >
+      <Icon className="h-3 w-3" />
+      {def.label}
+    </span>
+  );
+}
+
+interface RolePickerProps {
+  value: string;
+  onChange: (role: string) => void;
+}
+
+export function RolePicker({ value, onChange }: RolePickerProps) {
+  const [open, setOpen] = useState(false);
+  const ref = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    const handler = (e: MouseEvent) => {
+      if (ref.current && !ref.current.contains(e.target as Node)) {
+        setOpen(false);
+      }
+    };
+    document.addEventListener("mousedown", handler);
+    return () => document.removeEventListener("mousedown", handler);
+  }, []);
+
+  return (
+    <div ref={ref} className="relative">
+      <button
+        type="button"
+        onClick={() => setOpen(!open)}
+        className="flex items-center gap-1 rounded border border-border px-2 py-1 text-xs hover:bg-accent/50 transition-colors"
+      >
+        <RoleBadge role={value} />
+      </button>
+      {open && (
+        <div className="absolute z-50 mt-1 w-40 rounded-md border border-border bg-card shadow-lg">
+          {ROLES.map((r) => {
+            const Icon = r.icon;
+            return (
+              <button
+                key={r.value}
+                type="button"
+                onClick={() => {
+                  onChange(r.value);
+                  setOpen(false);
+                }}
+                className={`flex w-full items-center gap-2 px-3 py-2 text-xs transition-colors hover:bg-accent/50 ${
+                  value === r.value ? "bg-accent/30" : ""
+                }`}
+              >
+                <Icon className={`h-3.5 w-3.5 ${r.color}`} />
+                <span>{r.label}</span>
+              </button>
+            );
+          })}
+          <div className="border-t border-border px-3 py-2">
+            <input
+              type="text"
+              placeholder="Custom role..."
+              className="w-full bg-transparent text-xs outline-none placeholder:text-muted-foreground"
+              onKeyDown={(e) => {
+                if (e.key === "Enter" && e.currentTarget.value.trim()) {
+                  onChange(e.currentTarget.value.trim());
+                  setOpen(false);
+                }
+              }}
+            />
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

package/mission-control/src/components/cowork/session-card.tsx

@@ -0,0 +1,284 @@
+"use client";
+
+import { useState } from "react";
+import {
+  ChevronDown,
+  ChevronRight,
+  Zap,
+  XCircle,
+  UserMinus,
+} from "lucide-react";
+import type { CollabSession, Task } from "@/lib/hooks";
+import { interveneSession } from "@/lib/hooks";
+import { RoleBadge } from "./role-picker";
+
+const STATUS_COLORS: Record<string, string> = {
+  recruiting: "bg-blue-400",
+  active: "bg-green-400 animate-pulse",
+  converged: "bg-indigo-400",
+  completed: "bg-zinc-500",
+  aborted: "bg-red-500",
+};
+
+const MODE_BADGE: Record<string, string> = {
+  parallel: "bg-cyan-400/10 text-cyan-400",
+  sequential: "bg-amber-400/10 text-amber-400",
+  review: "bg-purple-400/10 text-purple-400",
+};
+
+function NodeChip({
+  node,
+  sessionId,
+  isActive,
+}: {
+  node: CollabSession["nodes"][0];
+  sessionId: string;
+  isActive: boolean;
+}) {
+  const statusDot: Record<string, string> = {
+    recruited: "bg-blue-400",
+    active: "bg-green-400 animate-pulse",
+    idle: "bg-zinc-500",
+    dead: "bg-red-500",
+  };
+
+  const handleRemove = async () => {
+    if (!confirm(`Remove ${node.node_id} from session?`)) return;
+    await interveneSession({
+      action: "remove_node",
+      sessionId,
+      nodeId: node.node_id,
+    });
+  };
+
+  return (
+    <span className="group inline-flex items-center gap-1.5 rounded-md bg-card border border-border px-2 py-1 text-xs">
+      <span
+        className={`h-1.5 w-1.5 rounded-full ${statusDot[node.status] ?? "bg-zinc-600"}`}
+      />
+      <span className="font-mono text-[11px]">
+        {node.node_id.split("-")[0]}
+      </span>
+      <RoleBadge role={node.role} />
+      {isActive && node.status !== "dead" && (
+        <button
+          onClick={handleRemove}
+          className="hidden group-hover:inline-flex text-muted-foreground hover:text-red-400"
+          title="Remove node"
+        >
+          <UserMinus className="h-3 w-3" />
+        </button>
+      )}
+    </span>
+  );
+}
+
+const KANBAN_STATUS_CHIP: Record<string, string> = {
+  backlog: "bg-blue-500/15 text-blue-400",
+  in_progress: "bg-green-500/15 text-green-400",
+  review: "bg-yellow-500/15 text-yellow-400",
+  done: "bg-zinc-500/15 text-zinc-400",
+};
+
+export function SessionCard({ session, linkedTask }: { session: CollabSession; linkedTask?: Task | null }) {
+  const [expanded, setExpanded] = useState(false);
+  const isActive = ["recruiting", "active"].includes(session.status);
+
+  const currentRound = session.rounds?.[session.rounds.length - 1];
+  const reflectionCount = currentRound?.reflections?.length ?? 0;
+  const activeNodes = (session.nodes || []).filter(
+    (n) => n.status !== "dead"
+  ).length;
+
+  const handleAbort = async () => {
+    if (!confirm("Abort this session? The parent task will be cancelled."))
+      return;
+    await interveneSession({ action: "abort", sessionId: session.session_id });
+  };
+
+  const handleForceConverge = async () => {
+    if (
+      !confirm(
+        "Force convergence? Missing reflections will be filled synthetically."
+      )
+    )
+      return;
+    await interveneSession({
+      action: "force_converge",
+      sessionId: session.session_id,
+    });
+  };
+
+  return (
+    <div className="rounded-lg border border-border bg-card">
+      {/* Header */}
+      <div
+        className="flex items-center justify-between px-4 py-3 cursor-pointer"
+        onClick={() => setExpanded(!expanded)}
+      >
+        <div className="flex items-center gap-3">
+          {expanded ? (
+            <ChevronDown className="h-4 w-4 text-muted-foreground" />
+          ) : (
+            <ChevronRight className="h-4 w-4 text-muted-foreground" />
+          )}
+          <span
+            className={`h-2 w-2 rounded-full ${STATUS_COLORS[session.status] ?? "bg-zinc-600"}`}
+          />
+          <a
+            href={`/?task=${session.task_id}`}
+            onClick={(e) => e.stopPropagation()}
+            className="font-mono text-sm hover:text-cyan-400 underline underline-offset-2 decoration-dotted"
+          >
+            {session.task_id}
+          </a>
+          <span
+            className={`rounded px-1.5 py-0.5 text-[10px] font-medium ${MODE_BADGE[session.mode] ?? "bg-zinc-700 text-zinc-300"}`}
+          >
+            {session.mode}
+          </span>
+          <span className="text-[10px] text-muted-foreground uppercase">
+            {session.status}
+          </span>
+          {linkedTask && (
+            <span className={`rounded px-1.5 py-0.5 text-[10px] font-medium ${KANBAN_STATUS_CHIP[linkedTask.kanbanColumn] ?? "bg-zinc-700 text-zinc-300"}`}>
+              {linkedTask.kanbanColumn === "in_progress" ? "In Progress" : linkedTask.kanbanColumn}
+            </span>
+          )}
+        </div>
+      </div>
+
+      {/* Quick stats */}
+      <div className="flex items-center gap-4 px-4 pb-3 text-xs text-muted-foreground">
+        <span>
+          Round {session.current_round}/{session.max_rounds}
+        </span>
+        <span>
+          Nodes: {activeNodes}/{(session.nodes || []).length}
+        </span>
+        {currentRound && (
+          <span>
+            Reflections: {reflectionCount}/{activeNodes}
+          </span>
+        )}
+        <span className="capitalize">{session.convergence?.type}</span>
+      </div>
+
+      {/* Round progress bar */}
+      <div className="flex gap-1 px-4 pb-3">
+        {Array.from({ length: session.max_rounds }, (_, i) => {
+          const roundNum = i + 1;
+          const round = session.rounds?.find(
+            (r) => r.round_number === roundNum
+          );
+          let color = "bg-zinc-700";
+          if (round?.completed_at) color = "bg-green-500";
+          else if (round && !round.completed_at)
+            color = "bg-blue-500 animate-pulse";
+          return (
+            <div
+              key={i}
+              className={`h-1.5 flex-1 rounded-full ${color}`}
+              title={`Round ${roundNum}`}
+            />
+          );
+        })}
+      </div>
+
+      {/* Nodes */}
+      <div className="flex flex-wrap gap-1.5 px-4 pb-3">
+        {(session.nodes || []).map((node) => (
+          <NodeChip
+            key={node.node_id}
+            node={node}
+            sessionId={session.session_id}
+            isActive={isActive}
+          />
+        ))}
+      </div>
+
+      {/* Intervention buttons */}
+      {isActive && (
+        <div className="flex gap-2 px-4 pb-3">
+          <button
+            onClick={handleForceConverge}
+            className="flex items-center gap-1 rounded px-2 py-1 text-xs bg-purple-500/10 text-purple-400 hover:bg-purple-500/20 transition-colors"
+          >
+            <Zap className="h-3 w-3" />
+            Force Converge
+          </button>
+          <button
+            onClick={handleAbort}
+            className="flex items-center gap-1 rounded px-2 py-1 text-xs bg-red-500/10 text-red-400 hover:bg-red-500/20 transition-colors"
+          >
+            <XCircle className="h-3 w-3" />
+            Abort
+          </button>
+        </div>
+      )}
+
+      {/* Expanded: round history */}
+      {expanded && session.rounds && session.rounds.length > 0 && (
+        <div className="border-t border-border px-4 py-3 space-y-3">
+          {session.rounds.map((round) => (
+            <div key={round.round_number} className="space-y-1">
+              <div className="flex items-center gap-2 text-xs">
+                <span className="font-medium">R{round.round_number}</span>
+                <span className="text-muted-foreground">
+                  {round.completed_at ? "completed" : "in progress"}
+                </span>
+                <span className="text-muted-foreground">
+                  {round.reflections?.length ?? 0} reflections
+                </span>
+              </div>
+              {round.reflections?.map((ref) => (
+                <div
+                  key={`${ref.node_id}-${round.round_number}`}
+                  className="ml-4 rounded bg-accent/30 px-3 py-2 text-xs space-y-1"
+                >
+                  <div className="flex items-center gap-2">
+                    <span className="font-mono text-[11px]">
+                      {ref.node_id.split("-")[0]}
+                    </span>
+                    <span
+                      className={`rounded px-1 py-0.5 text-[9px] ${
+                        ref.vote === "converged"
+                          ? "bg-green-500/10 text-green-400"
+                          : ref.vote === "blocked"
+                            ? "bg-red-500/10 text-red-400"
+                            : "bg-zinc-700 text-zinc-300"
+                      }`}
+                    >
+                      {ref.vote}
+                    </span>
+                    <span className="text-muted-foreground">
+                      {Math.round(ref.confidence * 100)}%
+                    </span>
+                    {ref.synthetic && (
+                      <span className="text-[9px] text-yellow-500">
+                        synthetic
+                      </span>
+                    )}
+                  </div>
+                  {ref.summary && (
+                    <p className="text-muted-foreground line-clamp-2">
+                      {ref.summary}
+                    </p>
+                  )}
+                </div>
+              ))}
+            </div>
+          ))}
+
+          {/* Timestamps */}
+          <div className="pt-2 border-t border-border/50 text-[10px] text-muted-foreground flex gap-4">
+            <span>Started: {session.created_at?.slice(0, 19)}</span>
+            {session.completed_at && (
+              <span>Completed: {session.completed_at.slice(0, 19)}</span>
+            )}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

package/mission-control/src/components/layout/sidebar.tsx

@@ -2,8 +2,8 @@
 
 import Link from "next/link";
 import { usePathname } from "next/navigation";
-import { LayoutDashboard, Search, RefreshCw, Users, Calendar, GitBranch, BarChart3, MessageCircle, Network, Waypoints, Settings, Server } from "lucide-react";
-import { useState } from "react";
+import { LayoutDashboard, Search, RefreshCw, Users, Users2, Calendar, GitBranch, BarChart3, MessageCircle, Network, Waypoints, Settings, Server, Activity } from "lucide-react";
+import { useState, useEffect } from "react";
 import { LiveStream } from "@/components/board/live-stream";
 
 const NAV = [
@@ -17,9 +17,43 @@ const NAV = [
   { href: "/graph", label: "Knowledge Graph", icon: Network },
   { href: "/obsidian", label: "Obsidian View", icon: Waypoints },
   { href: "/mesh", label: "Mesh Nodes", icon: Server },
+  { href: "/cowork", label: "Cowork", icon: Users2 },
   { href: "/settings", label: "Settings", icon: Settings },
+  { href: "/diagnostics", label: "Diagnostics", icon: Activity },
 ];
 
+function NodeBadge() {
+  const [identity, setIdentity] = useState<{
+    nodeId: string;
+    role: "lead" | "worker";
+    platform: string;
+  } | null>(null);
+
+  useEffect(() => {
+    fetch("/api/mesh/identity")
+      .then((r) => r.json())
+      .then(setIdentity)
+      .catch(() => setIdentity(null));
+  }, []);
+
+  if (!identity) return null;
+
+  const isLead = identity.role === "lead";
+  return (
+    <div
+      className={`flex items-center gap-1.5 rounded px-2 py-0.5 text-[10px] font-medium tracking-wider uppercase ${
+        isLead
+          ? "bg-green-500/10 text-green-400"
+          : "bg-blue-500/10 text-blue-400"
+      }`}
+      title={`${identity.nodeId} (${identity.platform})`}
+    >
+      <span>{isLead ? "⬢" : "◇"}</span>
+      <span>{identity.role}</span>
+    </div>
+  );
+}
+
 export function Sidebar() {
   const pathname = usePathname();
   const [syncing, setSyncing] = useState(false);
@@ -40,6 +74,9 @@ export function Sidebar() {
         <span className="text-sm font-semibold tracking-tight">
           Mission Control
         </span>
+        <div className="ml-auto">
+          <NodeBadge />
+        </div>
       </div>
 
       <nav className="px-2 py-3 space-y-1">

package/mission-control/src/lib/__tests__/daily-log.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { parseDailyLog, listDailyLogs } from "../parsers/daily-log";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "daily-log-test-"));
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("parseDailyLog", () => {
+  it("parses a daily log with H1 heading", () => {
+    const filePath = path.join(tmpDir, "2026-03-15.md");
+    fs.writeFileSync(filePath, "# Session Notes\n\n- Did stuff\n- More stuff\n");
+    const entry = parseDailyLog(filePath);
+
+    expect(entry.date).toBe("2026-03-15");
+    expect(entry.title).toBe("Session Notes");
+    expect(entry.content).toContain("- Did stuff");
+    expect(entry.filePath).toBe(filePath);
+    expect(entry.modifiedAt).toBeDefined();
+  });
+
+  it("extracts date from filename", () => {
+    const filePath = path.join(tmpDir, "2026-01-01.md");
+    fs.writeFileSync(filePath, "content\n");
+    const entry = parseDailyLog(filePath);
+    expect(entry.date).toBe("2026-01-01");
+  });
+
+  it("falls back to date when no H1 heading", () => {
+    const filePath = path.join(tmpDir, "2026-02-28.md");
+    fs.writeFileSync(filePath, "No heading here\n");
+    const entry = parseDailyLog(filePath);
+    expect(entry.title).toBe("2026-02-28");
+  });
+
+  it("uses basename for non-date filenames", () => {
+    const filePath = path.join(tmpDir, "notes.md");
+    fs.writeFileSync(filePath, "content\n");
+    const entry = parseDailyLog(filePath);
+    expect(entry.date).toBe("notes");
+  });
+
+  it("throws for missing file", () => {
+    expect(() => parseDailyLog("/nonexistent/file.md")).toThrow("not found");
+  });
+});
+
+describe("listDailyLogs", () => {
+  it("lists YYYY-MM-DD.md files sorted chronologically", () => {
+    fs.writeFileSync(path.join(tmpDir, "2026-03-15.md"), "");
+    fs.writeFileSync(path.join(tmpDir, "2026-03-10.md"), "");
+    fs.writeFileSync(path.join(tmpDir, "2026-03-20.md"), "");
+    const logs = listDailyLogs(tmpDir);
+    expect(logs).toHaveLength(3);
+    expect(logs[0]).toContain("2026-03-10.md");
+    expect(logs[2]).toContain("2026-03-20.md");
+  });
+
+  it("excludes non-date files", () => {
+    fs.writeFileSync(path.join(tmpDir, "2026-03-15.md"), "");
+    fs.writeFileSync(path.join(tmpDir, "notes.md"), "");
+    fs.writeFileSync(path.join(tmpDir, "README.md"), "");
+    const logs = listDailyLogs(tmpDir);
+    expect(logs).toHaveLength(1);
+  });
+
+  it("returns empty for nonexistent directory", () => {
+    expect(listDailyLogs("/nonexistent/dir")).toEqual([]);
+  });
+
+  it("returns empty for empty directory", () => {
+    expect(listDailyLogs(tmpDir)).toEqual([]);
+  });
+});

package/mission-control/src/lib/__tests__/memory-md.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { parseMemoryMd } from "../parsers/memory-md";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "memory-md-test-"));
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("parseMemoryMd", () => {
+  it("extracts H1 title", () => {
+    const filePath = path.join(tmpDir, "MEMORY.md");
+    fs.writeFileSync(filePath, "# Long-Term Memory\n\nSome content\n");
+    const result = parseMemoryMd(filePath);
+    expect(result.title).toBe("Long-Term Memory");
+  });
+
+  it("defaults title to MEMORY.md when no H1", () => {
+    const filePath = path.join(tmpDir, "MEMORY.md");
+    fs.writeFileSync(filePath, "No heading\n## Section\nContent\n");
+    const result = parseMemoryMd(filePath);
+    expect(result.title).toBe("MEMORY.md");
+  });
+
+  it("parses ## sections", () => {
+    const filePath = path.join(tmpDir, "MEMORY.md");
+    fs.writeFileSync(filePath, [
+      "# Memory",
+      "",
+      "## User Context",
+      "- Senior dev",
+      "- Likes concise code",
+      "",
+      "## Project Notes",
+      "- Building mesh network",
+    ].join("\n"));
+    const result = parseMemoryMd(filePath);
+    expect(result.sections).toHaveLength(2);
+    expect(result.sections[0].heading).toBe("User Context");
+    expect(result.sections[0].content).toContain("Senior dev");
+    expect(result.sections[1].heading).toBe("Project Notes");
+  });
+
+  it("handles empty sections", () => {
+    const filePath = path.join(tmpDir, "MEMORY.md");
+    fs.writeFileSync(filePath, "# Memory\n## Empty\n## Next\nContent\n");
+    const result = parseMemoryMd(filePath);
+    expect(result.sections).toHaveLength(2);
+    expect(result.sections[0].content).toBe("");
+    expect(result.sections[1].content).toBe("Content");
+  });
+
+  it("preserves full content", () => {
+    const filePath = path.join(tmpDir, "MEMORY.md");
+    const content = "# Memory\n\nRaw content here\n";
+    fs.writeFileSync(filePath, content);
+    const result = parseMemoryMd(filePath);
+    expect(result.fullContent).toBe(content);
+  });
+
+  it("includes modification timestamp", () => {
+    const filePath = path.join(tmpDir, "MEMORY.md");
+    fs.writeFileSync(filePath, "content");
+    const result = parseMemoryMd(filePath);
+    expect(result.modifiedAt).toBeDefined();
+    expect(new Date(result.modifiedAt).getTime()).toBeGreaterThan(0);
+  });
+
+  it("throws for missing file", () => {
+    expect(() => parseMemoryMd("/nonexistent/MEMORY.md")).toThrow("not found");
+  });
+
+  it("handles file with no sections", () => {
+    const filePath = path.join(tmpDir, "MEMORY.md");
+    fs.writeFileSync(filePath, "# Memory\nJust a title and text\n");
+    const result = parseMemoryMd(filePath);
+    expect(result.sections).toHaveLength(0);
+    expect(result.title).toBe("Memory");
+  });
+});