@walwal-harness/cli 7.1.8 → 7.1.9

package/apps/harness-dashboard/hooks/useHarnessStream.ts

@@ -0,0 +1,53 @@
+"use client";
+import { useEffect, useRef, useState } from "react";
+import type { HarnessSnapshot } from "@/lib/types";
+
+export type ConnectionState = "connecting" | "open" | "stale" | "failed";
+
+const FAILURE_THRESHOLD = 5;
+
+export function useHarnessStream(initial: HarnessSnapshot): {
+  snapshot: HarnessSnapshot;
+  connectionState: ConnectionState;
+} {
+  const [snapshot, setSnapshot] = useState<HarnessSnapshot>(initial);
+  const [connectionState, setConnectionState] = useState<ConnectionState>("connecting");
+  const failuresRef = useRef(0);
+
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const es = new EventSource("/api/stream");
+
+    es.onopen = () => {
+      failuresRef.current = 0;
+      setConnectionState("open");
+    };
+
+    es.onmessage = (ev) => {
+      try {
+        const next = JSON.parse(ev.data) as HarnessSnapshot;
+        setSnapshot(next);
+        failuresRef.current = 0;
+        setConnectionState("open");
+      } catch {
+        // Malformed payload — leave snapshot unchanged.
+      }
+    };
+
+    es.onerror = () => {
+      failuresRef.current += 1;
+      if (failuresRef.current >= FAILURE_THRESHOLD) {
+        setConnectionState("failed");
+        es.close();
+      } else {
+        setConnectionState("stale");
+      }
+    };
+
+    return () => {
+      es.close();
+    };
+  }, []);
+
+  return { snapshot, connectionState };
+}

package/apps/harness-dashboard/lib/__tests__/company-flow.test.ts

@@ -0,0 +1,270 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, "../../../../");
+const hasHarnessShellFixtures =
+  existsSync(path.join(repoRoot, "scripts", "lib", "harness-progress-migrate.sh")) &&
+  existsSync(path.join(repoRoot, "assets", "templates", "config.json"));
+const describeHarnessShell = hasHarnessShellFixtures ? describe : describe.skip;
+
+function runBash(script: string, projectRoot: string, args: string[] = []) {
+  return execFileSync("bash", [path.join(repoRoot, script), projectRoot, ...args], {
+    cwd: repoRoot,
+    encoding: "utf8",
+  });
+}
+
+function writeState(projectRoot: string, progress: unknown, configOverrides: Record<string, unknown> = {}) {
+  mkdirSync(path.join(projectRoot, ".harness", "actions", "meetings"), { recursive: true });
+
+  const config = JSON.parse(
+    readFileSync(path.join(repoRoot, "assets", "templates", "config.json"), "utf8")
+  ) as Record<string, unknown>;
+  Object.assign(config, configOverrides);
+
+  writeFileSync(path.join(projectRoot, ".harness", "config.json"), JSON.stringify(config, null, 2));
+  writeFileSync(path.join(projectRoot, ".harness", "progress.json"), JSON.stringify(progress, null, 2));
+}
+
+describeHarnessShell("company-loop shell flows", () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = mkdtempSync(path.join(tmpdir(), "walwal-company-"));
+  });
+
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("migrate_progress_schema normalizes legacy runtime mode while removing meeting decision mode", () => {
+    mkdirSync(path.join(dir, ".harness"), { recursive: true });
+    writeFileSync(
+      path.join(dir, ".harness", "progress.json"),
+      JSON.stringify(
+        {
+          mode: "team",
+          meetings: {
+            requested_mode: "hypothesis",
+            decision: {
+              mode: "legacy",
+              owner: "planner",
+              action_type: "hypothesis-validation",
+              tracks: [],
+              rendezvous: null,
+            },
+          },
+        },
+        null,
+        2
+      )
+    );
+
+    runBash("scripts/lib/harness-progress-migrate.sh", path.join(dir, ".harness", "progress.json"));
+
+    const migrated = JSON.parse(readFileSync(path.join(dir, ".harness", "progress.json"), "utf8"));
+    expect(migrated.mode).toBe("company");
+    expect(migrated.meetings.requested_mode).toBeUndefined();
+    expect(migrated.meetings.decision.mode).toBeUndefined();
+    expect(Array.isArray(migrated.meetings.decision.tracks)).toBe(true);
+  });
+
+  it("read-tracks falls back to conductor.tracks when fork_context is missing", () => {
+    writeState(dir, {
+      current_agent: "meeting-manager",
+      agent_status: "completed",
+      next_agent: "meeting-manager",
+      mode: "auto",
+      pipeline: "FULLSTACK",
+      workflow: { stage: "followup-review" },
+      meetings: {
+        requested_type: "followup-review",
+        requested_reason: "rendezvous",
+        active: ["meeting-manager"],
+        decision: {
+          owner: "cto",
+          action_type: "bugfix",
+          rationale: "test",
+          evidence: [],
+          drift_classification: "implementation_drift",
+          source_path: null,
+          tracks: [],
+          rendezvous: null,
+        },
+        fork_context: null,
+        fork_meeting_id: null,
+      },
+      conductor: {
+        tracks: [
+          {
+            id: "track-1",
+            owner: "cto",
+            action_type: "bugfix",
+            deliverable: "hotfix-result",
+            deliverable_path: "/tmp/hotfix.md",
+            status: "completed",
+          },
+          {
+            id: "track-2",
+            owner: "planner",
+            action_type: "hypothesis-validation",
+            deliverable: "validation-report",
+            deliverable_path: "/tmp/report.md",
+            status: "completed",
+          },
+        ],
+        rendezvous: { type: "followup-review", when: "next_cadence" },
+        fork_meeting_id: "M-20260508T080000Z",
+      },
+      planner: { requested_mode: null, last_brief: "hypothesis:done" },
+      service_ops: { auto_retro: { last_report: null, open_recommendations: 0 }, monitor: { alerts_this_sprint: 0 }, incident: { open: [] }, drift_classification: null },
+      goals: { current_adherence: null },
+      cqo: { sprint_verdict: "pending", open_regressions: 0, axes_below_threshold: [] },
+      cto: { open_hotfixes: 0 },
+      artifacts: { "plan.md": { status: "pending" }, "feature-list.json": { status: "pending" }, "api-contract.json": { status: "pending" } },
+    });
+
+    const tracks = JSON.parse(runBash("scripts/harness-meeting-doc.sh", dir, ["read-tracks"]));
+    expect(tracks).toHaveLength(2);
+    expect(tracks[0].owner).toBe("cto");
+    expect(tracks[1].owner).toBe("planner");
+  });
+
+  it("followup-review prepare preserves fork context and persists the fallback context", () => {
+    writeState(dir, {
+      current_agent: "meeting-manager",
+      agent_status: "completed",
+      next_agent: "meeting-manager",
+      mode: "auto",
+      pipeline: "FULLSTACK",
+      workflow: { stage: "followup-review" },
+      meetings: {
+        requested_type: "followup-review",
+        requested_reason: "rendezvous",
+        active: ["meeting-manager"],
+        decision: {
+          owner: "cto",
+          action_type: "bugfix",
+          rationale: "test",
+          evidence: [],
+          drift_classification: "implementation_drift",
+          source_path: null,
+          tracks: [],
+          rendezvous: null,
+        },
+        requested_tracks: [],
+        requested_rendezvous: null,
+        fork_context: null,
+        fork_meeting_id: null,
+      },
+      conductor: {
+        tracks: [
+          {
+            id: "track-1",
+            owner: "cto",
+            action_type: "bugfix",
+            deliverable: "hotfix-result",
+            deliverable_path: "/tmp/hotfix.md",
+            status: "completed",
+          },
+          {
+            id: "track-2",
+            owner: "planner",
+            action_type: "hypothesis-validation",
+            deliverable: "validation-report",
+            deliverable_path: "/tmp/report.md",
+            status: "completed",
+          },
+        ],
+        rendezvous: { type: "followup-review", when: "next_cadence" },
+        fork_meeting_id: "M-20260508T080000Z",
+      },
+      planner: { requested_mode: null, last_brief: "hypothesis:done" },
+      service_ops: { auto_retro: { last_report: null, open_recommendations: 0 }, monitor: { alerts_this_sprint: 0 }, incident: { open: [] }, drift_classification: null },
+      goals: { current_adherence: null },
+      cqo: { sprint_verdict: "pending", open_regressions: 0, axes_below_threshold: [] },
+      cto: { open_hotfixes: 0 },
+      artifacts: { "plan.md": { status: "pending" }, "feature-list.json": { status: "pending" }, "api-contract.json": { status: "pending" } },
+    });
+
+    const recordPath = runBash("scripts/harness-meeting-doc.sh", dir, ["prepare"]).trim();
+    const record = readFileSync(path.join(dir, recordPath), "utf8");
+    expect(record).toContain("## Fork Context (v6.2)");
+    expect(record).toContain("hotfix-result");
+    expect(record).toContain("validation-report");
+
+    const progress = JSON.parse(readFileSync(path.join(dir, ".harness", "progress.json"), "utf8"));
+    expect(progress.meetings.fork_context.prior_tracks).toHaveLength(2);
+    expect(progress.meetings.fork_context.fork_meeting_id).toBe("M-20260508T080000Z");
+  });
+
+  it("planner hypothesis-verdict completes by returning to meeting-manager and clearing the stale request", () => {
+    writeState(dir, {
+      current_agent: "planner",
+      agent_status: "completed",
+      next_agent: "planner",
+      mode: "auto",
+      pipeline: "FULLSTACK",
+      workflow: { stage: "coo-hypothesis-verdict" },
+      meetings: {
+        requested_type: "followup-review",
+        requested_reason: "rendezvous",
+        active: ["meeting-manager"],
+        decision: {
+          owner: "cto",
+          action_type: "bugfix",
+          rationale: "test",
+          evidence: [],
+          drift_classification: "implementation_drift",
+          source_path: null,
+          tracks: [],
+          rendezvous: null,
+        },
+        fork_context: null,
+        fork_meeting_id: "M-20260508T080000Z",
+      },
+      conductor: {
+        tracks: [
+          {
+            id: "track-1",
+            owner: "cto",
+            action_type: "bugfix",
+            deliverable: "hotfix-result",
+            deliverable_path: "/tmp/hotfix.md",
+            status: "completed",
+          },
+          {
+            id: "track-2",
+            owner: "planner",
+            action_type: "hypothesis-validation",
+            deliverable: "validation-report",
+            deliverable_path: "/tmp/report.md",
+            status: "completed",
+          },
+        ],
+        rendezvous: { type: "followup-review", when: "next_cadence" },
+        fork_meeting_id: "M-20260508T080000Z",
+      },
+      planner: { requested_mode: "hypothesis-verdict", last_brief: "hypothesis:done" },
+      service_ops: { auto_retro: { last_report: null, open_recommendations: 0 }, monitor: { alerts_this_sprint: 0 }, incident: { open: [] }, drift_classification: null },
+      goals: { current_adherence: null },
+      cqo: { sprint_verdict: "pending", open_regressions: 0, axes_below_threshold: [] },
+      cto: { open_hotfixes: 0 },
+      artifacts: { "plan.md": { status: "pending" }, "feature-list.json": { status: "pending" }, "api-contract.json": { status: "pending" } },
+    });
+
+    runBash("scripts/conductor-tick.sh", dir);
+
+    const progress = JSON.parse(readFileSync(path.join(dir, ".harness", "progress.json"), "utf8"));
+    expect(progress.next_agent).toBe("meeting-manager");
+    expect(progress.workflow.stage).toBe("followup-review");
+    expect(progress.planner.requested_mode).toBeNull();
+    expect(progress.meetings.requested_type).toBe("followup-review");
+  });
+});

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

@@ -0,0 +1,194 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+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;
+
+  beforeEach(() => {
+    dir = mkdtempSync(path.join(tmpdir(), "harness-state-"));
+  });
+
+  afterEach(() => {
+    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", () => {
+    mkdirSync(path.join(dir, ".harness"), { recursive: true });
+    writeFileSync(path.join(dir, ".harness", "progress.json"), "{ not json");
+    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");
+  });
+});

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

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "vitest";
+import { t } from "../i18n";
+
+describe("i18n.t", () => {
+  it("returns ko by default", () => {
+    expect(t("drawer.tab.agent_log")).toBe("에이전트 로그");
+  });
+
+  it("returns en when lang=en", () => {
+    expect(t("drawer.tab.agent_log", "en")).toBe("Agent Log");
+  });
+
+  it("falls back to the key when missing", () => {
+    expect(t("nonexistent.key", "en")).toBe("nonexistent.key");
+  });
+});

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

@@ -0,0 +1,42 @@
+import { describe, it, expect } from "vitest";
+import { ROOM_RECTS, CORRIDOR_RECTS, worldToScreen } from "../iso";
+
+describe("iso projection", () => {
+  it("worldToScreen is a pure linear transform", () => {
+    const a = worldToScreen(0, 0);
+    expect(a).toEqual({ sx: 0, sy: 0 });
+    const b = worldToScreen(2, 0);
+    const c = worldToScreen(0, 2);
+    expect(b.sy).toBe(c.sy);
+    expect(b.sx).toBe(-c.sx);
+  });
+
+  it("rooms do not overlap corridors (corridors fill the gaps)", () => {
+    for (const r of ROOM_RECTS) {
+      for (const c of CORRIDOR_RECTS) {
+        const overlapX = r.wx < c.wx + c.ww && c.wx < r.wx + r.ww;
+        const overlapY = r.wy < c.wy + c.wh && c.wy < r.wy + r.wh;
+        expect(
+          overlapX && overlapY,
+          `room ${r.id} overlaps corridor at (${c.wx},${c.wy})`
+        ).toBe(false);
+      }
+    }
+  });
+
+  it("rooms have unique ids and non-overlapping world rectangles", () => {
+    const ids = new Set(ROOM_RECTS.map((r) => r.id));
+    expect(ids.size).toBe(ROOM_RECTS.length);
+    expect(ROOM_RECTS.length).toBe(7);
+
+    for (let i = 0; i < ROOM_RECTS.length; i++) {
+      for (let j = i + 1; j < ROOM_RECTS.length; j++) {
+        const a = ROOM_RECTS[i];
+        const b = ROOM_RECTS[j];
+        const overlapX = a.wx < b.wx + b.ww && b.wx < a.wx + a.ww;
+        const overlapY = a.wy < b.wy + b.wh && b.wy < a.wy + a.wh;
+        expect(overlapX && overlapY, `rooms overlap: ${a.id} vs ${b.id}`).toBe(false);
+      }
+    }
+  });
+});

package/apps/harness-dashboard/lib/__tests__/safe-json.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { readJsonSafe } from "../safe-json";
+
+describe("readJsonSafe", () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = mkdtempSync(path.join(tmpdir(), "safe-json-"));
+  });
+
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("valid: returns ok with parsed value", () => {
+    const file = path.join(dir, "ok.json");
+    writeFileSync(file, JSON.stringify({ a: 1, b: "x" }));
+    const result = readJsonSafe<{ a: number; b: string }>(file);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value).toEqual({ a: 1, b: "x" });
+    }
+  });
+
+  it("corrupt: returns ok=false with reason='corrupt' and does not throw", () => {
+    const file = path.join(dir, "broken.json");
+    writeFileSync(file, "{ not json");
+    const result = readJsonSafe(file);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.reason).toBe("corrupt");
+    }
+  });
+
+  it("missing: returns ok=false with reason='missing' and does not throw", () => {
+    const file = path.join(dir, "absent.json");
+    const result = readJsonSafe(file);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.reason).toBe("missing");
+    }
+  });
+});