@walwal-harness/cli 7.1.40 → 7.1.42

package/apps/harness-dashboard/components/brick/views-timeline.tsx

@@ -0,0 +1,238 @@
+"use client";
+
+/* =============================================================
+   walwal-harness · VIEW 3 — TIMELINE (cadence heatmap + swimlanes)
+   Ported from harness/views-timeline.jsx (design handoff).
+   Exports: TimelineView, Cadence
+   ============================================================= */
+
+import React, { useRef } from "react";
+import type { CSSProperties } from "react";
+
+import type {
+  AgentRole,
+  ContractState,
+  ContractWorker,
+  DocTarget,
+} from "../../lib/brick/contract";
+import { StatusDot, Label } from "./ui";
+
+const SPAN_MS = 12 * 3600 * 1000; // 12h window, now=left
+
+/** Inline style that also carries the per-agent `--hue` CSS custom property. */
+type HueStyle = CSSProperties & { "--hue": string };
+
+/* ---- Cadence (also rendered by the COMMAND view) ---------------------- */
+
+export interface CadenceProps {
+  /** 24 hourly buckets = owner prompts/hour. */
+  cadence: number[];
+}
+
+export function Cadence({ cadence }: CadenceProps) {
+  const max = Math.max(...cadence, 1);
+  return (
+    <div className="cadence">
+      <Label right={"max " + max + " · 24h"}>CADENCE · owner prompts / h</Label>
+      <div className="cad-row">
+        {cadence.map((v, i) => (
+          <div
+            key={i}
+            className="cad-cell"
+            title={v + " / h"}
+            style={{
+              background:
+                v === 0 ? "transparent" : `rgba(229,72,77,${0.28 + 0.55 * (v / max)})`,
+              borderColor: v === 0 ? "var(--bd)" : "rgba(229,72,77,0.5)",
+            }}
+          />
+        ))}
+      </div>
+      <div className="cad-axis">
+        <span>now</span>
+        <span>−12h</span>
+        <span>−24h</span>
+      </div>
+    </div>
+  );
+}
+
+/* ---- TimelineView ----------------------------------------------------- */
+
+export interface TimelineViewProps {
+  /** The single source-of-truth contract state. */
+  s: ContractState;
+  /** Open a document (agent report or worker brief) in the DocViewer. */
+  openDoc?: (target: DocTarget) => void;
+}
+
+type SwimMark = { ago: number; dur: number };
+
+type SwimRow = {
+  kind: "exec" | "worker";
+  id: string;
+  label: string;
+  hue: string;
+  agent: AgentRole;
+  status: string;
+  progress?: number | null;
+};
+
+export function TimelineView({ s, openDoc }: TimelineViewProps) {
+  // stable seeded marks per row id
+  const markCache = useRef<Record<string, SwimMark[]>>({});
+  function seedMarks(id: string, density: number): SwimMark[] {
+    const cached = markCache.current[id];
+    if (cached) return cached;
+    const arr: SwimMark[] = [];
+    const n = Math.floor(density * (4 + Math.random() * 7));
+    for (let i = 0; i < n; i++) {
+      arr.push({ ago: Math.random() * SPAN_MS, dur: 40000 + Math.random() * 600000 });
+    }
+    markCache.current[id] = arr;
+    return arr;
+  }
+
+  // build rows: exec + its workers
+  const order: AgentRole[] = ["ceo", "coo", "cto", "cqo", "cdo", "ops"];
+  const rows: SwimRow[] = [];
+  order.forEach((id) => {
+    const a = s.agents.find((x) => x.id === id);
+    if (!a) return;
+    rows.push({ kind: "exec", id: a.id, label: a.name, hue: a.hue, agent: a.id, status: a.status });
+    s.workers
+      .filter((w) => w.agent === id)
+      .forEach((w) => {
+        rows.push({
+          kind: "worker",
+          id: w.id,
+          label: w.name,
+          hue: a.hue,
+          agent: a.id,
+          status: w.status,
+          progress: w.progress,
+        });
+      });
+  });
+
+  // live marks from recent events (last 6 min) keyed to exec rows
+  const liveByAgent: Record<string, number[]> = {};
+  s.events.forEach((e) => {
+    if (e.at == null || e.agent === "") return;
+    const age = s.now - e.at;
+    if (age < 6 * 60 * 1000) {
+      (liveByAgent[e.agent] = liveByAgent[e.agent] || []).push(age);
+    }
+  });
+
+  const xOf = (ago: number): number => Math.max(0, Math.min(100, (ago / SPAN_MS) * 100));
+
+  // axis ticks
+  const ticks: number[] = [];
+  for (let h = 0; h <= 12; h += 2) ticks.push(h);
+
+  const openRow = (r: SwimRow) => {
+    if (!openDoc) return;
+    if (r.kind === "exec") {
+      openDoc({ type: "agent", agent: r.agent });
+      return;
+    }
+    const worker: ContractWorker | undefined = s.workers.find((w) => w.id === r.id);
+    if (worker) openDoc({ type: "worker", agent: r.agent, worker });
+  };
+
+  return (
+    <div className="timelineview">
+      <Cadence cadence={s.cadence} />
+      <div className="swim">
+        <Label
+          right={
+            rows.filter((r) => r.kind === "worker").length +
+            " workers · " +
+            order.length +
+            " execs"
+          }
+        >
+          ORCHESTRATION TIMELINE · now → −12h
+        </Label>
+        <div className="swim-axis">
+          <div className="swim-axis-pad" />
+          <div className="swim-axis-track">
+            {ticks.map((h) => (
+              <span
+                key={h}
+                className="swim-tick"
+                style={{ left: (h / 12) * 100 + "%" }}
+              >
+                {h === 0 ? "now" : "−" + h + "h"}
+              </span>
+            ))}
+          </div>
+        </div>
+        <div className="swim-rows">
+          {rows.map((r) => {
+            const marks = seedMarks(r.id, r.kind === "exec" ? 1.4 : 0.8);
+            const live = r.kind === "exec" ? liveByAgent[r.agent] || [] : [];
+            return (
+              <div
+                key={r.id}
+                className={"swim-row " + (r.kind === "exec" ? "is-exec" : "is-worker")}
+                onClick={() => openRow(r)}
+              >
+                <div className="swim-label" style={{ "--hue": r.hue } as HueStyle}>
+                  {r.kind === "exec" ? (
+                    <span
+                      className="glyph glyph-sm"
+                      style={{ color: r.hue, borderColor: r.hue + "55" }}
+                    >
+                      {r.label}
+                    </span>
+                  ) : (
+                    <span className="swim-wlabel">
+                      <span className="swim-tree">└</span>
+                      {r.label}
+                    </span>
+                  )}
+                  {r.kind === "exec" && <StatusDot status={r.status} size={6} />}
+                </div>
+                <div className="swim-track">
+                  <div className="swim-gridlines">
+                    {ticks.map((h) => (
+                      <span key={h} style={{ left: (h / 12) * 100 + "%" }} />
+                    ))}
+                  </div>
+                  {marks.map((m, i) => (
+                    <span
+                      key={i}
+                      className="swim-block"
+                      style={{
+                        left: xOf(m.ago) + "%",
+                        width: Math.max(0.6, (m.dur / SPAN_MS) * 100) + "%",
+                        background: r.hue,
+                        opacity: r.kind === "exec" ? 0.85 : 0.55,
+                      }}
+                    />
+                  ))}
+                  {live.map((age, i) => (
+                    <span
+                      key={"l" + i}
+                      className="swim-live"
+                      style={{ left: xOf(age) + "%", background: r.hue }}
+                    />
+                  ))}
+                  {r.kind === "worker" && r.progress != null && (
+                    <span
+                      className="swim-now-prog"
+                      style={{ background: r.hue }}
+                      title={Math.round(r.progress) + "%"}
+                    />
+                  )}
+                </div>
+              </div>
+            );
+          })}
+        </div>
+      </div>
+    </div>
+  );
+}

package/apps/harness-dashboard/lib/__tests__/harness-state.test.ts

@@ -3,7 +3,6 @@ import { mkdtempSync, mkdirSync, rmSync, utimesSync, writeFileSync } from "node:
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { readHarnessState } from "../harness-state";
-import { AGENT_ROSTER } from "../agent-roster";
 
 describe("readHarnessState", () => {
   let dir: string;
@@ -16,54 +15,9 @@ describe("readHarnessState", () => {
     rmSync(dir, { recursive: true, force: true });
   });
 
-  it("valid progress.json: derives typing for current_agent, talking for meetings.active, idle for the rest", () => {
-    mkdirSync(path.join(dir, ".harness"), { recursive: true });
-    writeFileSync(
-      path.join(dir, ".harness", "progress.json"),
-      JSON.stringify({
-        sprint: { number: 1 },
-        current_agent: "generator-backend",
-        agent_status: "running",
-        meetings: { active: ["planner"], cadence: "normal", next_scheduled: null },
-        cto: { last_review: "2026-05-07", open_arch_risks: 0 },
-        cqo: { last_audit: null, sprint_verdict: "pending", open_regressions: 0 },
-        service_ops: { monitor: { last_check: "2026-05-07", alerts_this_sprint: 0 } },
-        goals: {
-          active_id: "g1",
-          list: [{ id: "g1", title: "Brick Office MVP", description: "Phase C launch" }],
-          current_adherence: 0.6,
-        },
-      })
-    );
-
-    const snap = readHarnessState(dir);
-    expect(snap.errorBanner).toBeNull();
-    expect(snap.agents.length).toBe(AGENT_ROSTER.length);
-    expect(snap.agents.map((a) => a.id).sort()).toEqual(
-      AGENT_ROSTER.map((a) => a.id).sort()
-    );
-    const stateOf = (id: string) => snap.agents.find((a) => a.id === id)!.minifigState;
-    expect(stateOf("generator-backend")).toBe("typing");
-    expect(stateOf("planner")).toBe("talking");
-    expect(stateOf("dispatcher")).toBe("idle");
-    expect(snap.rooms.length).toBe(7);
-
-    const planner = snap.agents.find((a) => a.id === "planner")!;
-    expect(planner.room).toBe("meeting");
-    expect(planner.homeRoom).toBe("coo");
-
-    const meetingRoom = snap.rooms.find((r) => r.id === "meeting")!;
-    expect(meetingRoom.seatLayout).toBeDefined();
-    expect(meetingRoom.seatLayout!.occupants).toContain("planner");
-
-    expect(snap.goal).not.toBeNull();
-    expect(snap.goal!.title).toBe("Brick Office MVP");
-  });
-
   it("missing .harness: returns error banner, no crash", () => {
     const snap = readHarnessState(dir);
     expect(snap.errorBanner?.level).toBe("error");
-    expect(snap.agents.length).toBe(AGENT_ROSTER.length);
   });
 
   it("corrupt progress.json: returns error banner, no crash", () => {
@@ -72,124 +26,6 @@ describe("readHarnessState", () => {
     const snap = readHarnessState(dir);
     expect(snap.errorBanner?.level).toBe("error");
     expect(snap.errorBanner?.message_en).toContain("corrupt");
-    expect(snap.agents.length).toBe(AGENT_ROSTER.length);
-  });
-
-  it("v6 NEXUS: roster includes CTO, CQO, Brainstormer", () => {
-    const ids = AGENT_ROSTER.map((a) => a.id);
-    expect(ids).toContain("cto");
-    expect(ids).toContain("cqo");
-    expect(ids).toContain("brainstormer");
-  });
-
-  it("parallel tracks, hypothesis, escalations, incidents land in the snapshot", () => {
-    mkdirSync(path.join(dir, ".harness"), { recursive: true });
-    writeFileSync(
-      path.join(dir, ".harness", "progress.json"),
-      JSON.stringify({
-        sprint: { number: 3 },
-        pipeline: "FULLSTACK",
-        current_agent: "conductor",
-        agent_status: "running",
-        meetings: {
-          active: [],
-          cadence: "heavy",
-          next_scheduled: "2026-05-08T10:00Z",
-          current: { type: "incident-war-room", topic: "P0 prod outage" },
-        },
-        cto: {
-          last_review: "2026-05-07",
-          open_arch_risks: 1,
-          contract_signed: { be: true, fe: false },
-        },
-        cqo: {
-          last_audit: "2026-05-07",
-          sprint_verdict: "pending",
-          open_regressions: 2,
-          last_scores: {
-            functional: 2.9,
-            visual: 2.8,
-            code_quality: 2.5,
-            architecture: 2.95,
-            security: 3.0,
-          },
-        },
-        service_ops: {
-          monitor: { last_check: "2026-05-07", alerts_this_sprint: 4 },
-          incident: {
-            open: [
-              { id: "INC-1", dept: "CTO", severity: "critical", message: "DB down" },
-              { id: "INC-2", dept: "Operations", severity: "medium" },
-            ],
-          },
-        },
-        parallel_tracks: [
-          {
-            id: "T-1",
-            from_meeting: "spec-review",
-            to_dept: "CTO",
-            to_room: "cto-team",
-            status: "in_progress",
-          },
-          {
-            id: "T-2",
-            from_meeting: "spec-review",
-            to_dept: "Planner",
-            to_room: "coo",
-            status: "dispatched",
-          },
-        ],
-        hypothesis: {
-          active: [
-            { id: "H-1", brief: "Cache hit > 80%", verdict: "pending" },
-            { id: "H-2", brief: "p95 < 200ms", verdict: "valid" },
-          ],
-        },
-        escalations: {
-          open: [{ id: "E-1", reason: "three-fail", message: "regression x3" }],
-        },
-        contracts: {
-          api: { version: "v2.1.0" },
-          feature_list: { total: 16, passed: 12, failed: 1 },
-        },
-      })
-    );
-
-    const snap = readHarnessState(dir);
-    expect(snap.errorBanner).toBeNull();
-
-    expect(snap.tracks.map((t) => t.id)).toEqual(["T-1", "T-2"]);
-    expect(snap.incidents.length).toBe(2);
-    expect(snap.hypothesis.length).toBe(2);
-    expect(snap.escalations.length).toBe(1);
-    expect(snap.contract.pipeline).toBe("FULLSTACK");
-    expect(snap.contract.sprint_number).toBe(3);
-    expect(snap.contract.feature_total).toBe(16);
-    expect(snap.contract.contract_signed).toEqual({ be: true, fe: false });
-    expect(snap.evalScores?.code_quality).toBe(2.5);
-    expect(snap.meetings.cadence).toBe("heavy");
-    expect(snap.meetings.current?.type).toBe("incident-war-room");
-
-    // CTO has an open incident → CTO-dept agents go red-alert; Service-Ops
-    // is on-call and is *always* red when any incident is open.
-    const stateOf = (id: string) => snap.agents.find((a) => a.id === id)!.minifigState;
-    expect(stateOf("cto")).toBe("red-alert");
-    expect(stateOf("service-ops")).toBe("red-alert");
-    expect(stateOf("evaluator-visual")).toBe("idle"); // CQO dept untouched
-  });
-
-  it("buildArchive reads verdict.json when present", () => {
-    const sprintDir = path.join(dir, ".harness", "archive", "sprint-1");
-    mkdirSync(sprintDir, { recursive: true });
-    writeFileSync(path.join(sprintDir, "verdict.json"), JSON.stringify({ result: "PASS" }));
-    mkdirSync(path.join(dir, ".harness"), { recursive: true });
-    writeFileSync(
-      path.join(dir, ".harness", "progress.json"),
-      JSON.stringify({ sprint: { number: 1 } })
-    );
-
-    const snap = readHarnessState(dir);
-    expect(snap.archive.all.find((e) => e.dir === "sprint-1")?.result).toBe("PASS");
   });
 
   it("marks in-place goal document updates as submission only after the owner prompt", () => {
@@ -403,44 +239,11 @@ describe("readHarnessState", () => {
     const workers = readHarnessState(dir).missions[0].workers;
     expect(workers[0]).toMatchObject({
       name: "frontend-worker",
-      status: "COMPLETE",
+      status: "unknown",
       active: false,
     });
   });
 
-  it("reads manual worker telemetry with name, progress, eta, and report_path", () => {
-    const harnessDir = path.join(dir, ".harness");
-    mkdirSync(harnessDir, { recursive: true });
-    writeFileSync(
-      path.join(harnessDir, "progress.json"),
-      JSON.stringify({
-        agent_status: "running",
-        company_state: {
-          active_workers: 2,
-          workers: [
-            {
-              name: "frontend-engineer-multi-strategy",
-              status: "running",
-              progress: "70%",
-              eta: "2026-05-31 17:00",
-              report_path: ".harness/documents/goal-1/cto/workers/frontend-engineer-multi-strategy.md",
-            },
-          ],
-        },
-      })
-    );
-
-    const worker = readHarnessState(dir).dashboard.workers[0];
-    expect(worker).toMatchObject({
-      agent: "frontend-engineer-multi-strategy",
-      feature: "frontend-engineer-multi-strategy",
-      status: "running",
-      log: ".harness/documents/goal-1/cto/workers/frontend-engineer-multi-strategy.md",
-      progress: 0.7,
-    });
-    expect(worker.summary).toContain("2026-05-31 17:00");
-  });
-
   it("accepts keyed company_state.workers maps from manual CXX telemetry", () => {
     const harnessDir = path.join(dir, ".harness");
     const missionDir = path.join(harnessDir, "documents", "goal-1-dashboard");
@@ -468,10 +271,6 @@ describe("readHarnessState", () => {
     );
 
     const snap = readHarnessState(dir);
-    expect(snap.dashboard.workers[0]).toMatchObject({
-      agent: "engineering-engineering-code-reviewer",
-      status: "running",
-    });
     expect(snap.missions[0].workers[0]).toMatchObject({
       owner: "cqo",
       active: true,