@walwal-harness/cli 7.1.8 → 7.1.9

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

@@ -0,0 +1,159 @@
+import { describe, it, expect } from "vitest";
+import { deriveMinifigState } from "../state-mapping";
+
+describe("deriveMinifigState", () => {
+  it("returns idle when there is no progress data", () => {
+    expect(deriveMinifigState("planner", null)).toBe("idle");
+  });
+
+  it("returns typing when agent is current and running", () => {
+    expect(
+      deriveMinifigState("generator-backend", {
+        current_agent: "generator-backend",
+        agent_status: "running",
+      })
+    ).toBe("typing");
+  });
+
+  it("does not return typing when agent_status is not running", () => {
+    expect(
+      deriveMinifigState("generator-backend", {
+        current_agent: "generator-backend",
+        agent_status: "completed",
+      })
+    ).toBe("idle");
+  });
+
+  it("returns queued when agent is assigned as next_agent", () => {
+    expect(
+      deriveMinifigState("cto", {
+        current_agent: "planner",
+        next_agent: "cto",
+        agent_status: "completed",
+      })
+    ).toBe("queued");
+  });
+
+  it("returns talking when agent is in meetings.active", () => {
+    expect(
+      deriveMinifigState("planner", {
+        meetings: { active: ["planner", "dispatcher"] },
+      })
+    ).toBe("talking");
+  });
+
+  it("talking wins over typing when both apply", () => {
+    expect(
+      deriveMinifigState("planner", {
+        current_agent: "planner",
+        agent_status: "running",
+        meetings: { active: ["planner"] },
+      })
+    ).toBe("talking");
+  });
+
+  it("red-alert wins over everything", () => {
+    expect(
+      deriveMinifigState("evaluator-functional", {
+        current_agent: "evaluator-functional",
+        agent_status: "running",
+        meetings: { active: ["evaluator-functional"] },
+        failure: { agent: "evaluator-functional", message: "regression" },
+      })
+    ).toBe("red-alert");
+  });
+
+  it("Service-Ops always goes red-alert when any incident is open", () => {
+    // Even if the incident's dept is unknown, Service-Ops is the on-call
+    // department and should reflect the alert state.
+    expect(
+      deriveMinifigState(
+        "service-ops",
+        { current_agent: null, agent_status: "idle" },
+        { dept: "Operations", incidentDepts: new Set(["CTO"]) }
+      )
+    ).toBe("red-alert");
+  });
+
+  it("dept-matching incident lights up the dept's agents", () => {
+    expect(
+      deriveMinifigState(
+        "generator-backend",
+        { current_agent: null },
+        { dept: "CTO", incidentDepts: new Set(["CTO"]) }
+      )
+    ).toBe("red-alert");
+  });
+
+  it("agents in unrelated dept stay idle when incident is elsewhere", () => {
+    expect(
+      deriveMinifigState(
+        "evaluator-visual",
+        { current_agent: null },
+        { dept: "CQO", incidentDepts: new Set(["CTO"]) }
+      )
+    ).toBe("idle");
+  });
+
+  it("v6 parallel: conductor.tracks running owners are typing", () => {
+    expect(
+      deriveMinifigState("planner", {
+        current_agent: "coo-developer",
+        agent_status: "running",
+        conductor: {
+          tracks: [
+            { owner: "planner", status: "running" },
+            { owner: "documentationer", status: "completed" },
+          ],
+        },
+      })
+    ).toBe("typing");
+  });
+
+  it("v6 parallel: conductor.tracks pending owners are queued", () => {
+    expect(
+      deriveMinifigState("documentationer", {
+        current_agent: "planner",
+        agent_status: "running",
+        conductor: {
+          tracks: [
+            { owner: "planner", status: "running" },
+            { owner: "documentationer", status: "pending" },
+          ],
+        },
+      })
+    ).toBe("queued");
+  });
+
+  it("v6 parallel: conductor.current_action spawn target is typing", () => {
+    // current_agent has finished the previous tick; the next agent appears in
+    // current_action and must already light up so the office never goes dark.
+    expect(
+      deriveMinifigState("generator-backend", {
+        current_agent: "cto",
+        agent_status: "completed",
+        conductor: { current_action: "spawn:generator-backend (foundation F-101)" },
+      })
+    ).toBe("typing");
+  });
+
+  it("G-006: service-ops with stream_active=true is typing", () => {
+    expect(
+      deriveMinifigState("service-ops", {
+        current_agent: "generator-frontend",
+        agent_status: "running",
+        service_ops: { monitor: { stream_active: true, stream_target: "generator-frontend" } },
+      })
+    ).toBe("typing");
+  });
+
+  it("agents not involved stay idle (default-to-desk handled in 3D)", () => {
+    expect(
+      deriveMinifigState("evaluator-architecture", {
+        current_agent: "generator-backend",
+        agent_status: "running",
+        conductor: { tracks: [{ owner: "planner", status: "running" }] },
+      })
+    ).toBe("idle");
+  });
+});

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

@@ -0,0 +1,48 @@
+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 { watchHarness } from "../watcher";
+
+describe("watchHarness", () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = mkdtempSync(path.join(tmpdir(), "watch-"));
+    mkdirSync(path.join(dir, ".harness", "actions"), { recursive: true });
+    mkdirSync(path.join(dir, ".harness", "archive"), { recursive: true });
+    writeFileSync(path.join(dir, ".harness", "progress.json"), "{}");
+  });
+
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("fires onChange when progress.json is rewritten", async () => {
+    const events: string[] = [];
+    const handle = watchHarness(dir, (p) => events.push(p), { debounceMs: 30 });
+
+    // Wait for chokidar's initial scan to settle.
+    await new Promise((r) => setTimeout(r, 250));
+
+    writeFileSync(
+      path.join(dir, ".harness", "progress.json"),
+      JSON.stringify({ updated: true })
+    );
+
+    // Wait long enough for awaitWriteFinish stabilityThreshold (100) +
+    // debounce (30) + a little slack.
+    await new Promise((r) => setTimeout(r, 400));
+
+    await handle.close();
+    expect(events.length).toBeGreaterThan(0);
+    expect(events.some((e) => e.endsWith("progress.json"))).toBe(true);
+  });
+
+  it("close() releases the watcher cleanly", async () => {
+    const handle = watchHarness(dir, () => {});
+    await new Promise((r) => setTimeout(r, 100));
+    await handle.close();
+    // No assertion — test passes if close() resolves without throwing.
+  });
+});

package/apps/harness-dashboard/lib/agent-roster.ts

@@ -0,0 +1,42 @@
+import type { AgentId, Dept, RoomId } from "./types";
+
+export interface RosterEntry {
+  id: AgentId;
+  name: string;
+  dept: Dept;
+  room: RoomId;
+}
+
+// SoT for the office roster. Mirrors v6 NEXUS organization in CLAUDE.md.
+// Order within a room dictates desk assignment (see lib/furniture.ts).
+export const AGENT_ROSTER: RosterEntry[] = [
+  { id: "dispatcher", name: "CEO (Dispatcher)", dept: "CEO", room: "ceo" },
+  { id: "brainstormer", name: "Brainstormer", dept: "CEO", room: "ceo" },
+  { id: "meeting-manager", name: "Meeting Manager", dept: "Meeting", room: "meeting" },
+  { id: "planner", name: "COO (Planner)", dept: "Planner", room: "coo" },
+  { id: "coo-developer", name: "Developer 1 (Hypothesis Cell)", dept: "Planner", room: "coo" },
+  { id: "documentationer", name: "Documentationer 1 (Hypothesis Cell)", dept: "Planner", room: "coo" },
+  { id: "cto", name: "CTO (Gen 총괄)", dept: "CTO", room: "cto-team" },
+  { id: "conductor", name: "Conductor", dept: "CTO", room: "cto-team" },
+  { id: "generator-backend", name: "Generator — Backend", dept: "CTO", room: "cto-team" },
+  { id: "generator-frontend", name: "Generator — Frontend", dept: "CTO", room: "cto-team" },
+  { id: "generator-designer", name: "Designer", dept: "CTO", room: "cto-team" },
+  { id: "generator-devops", name: "DevOps", dept: "CTO", room: "cto-team" },
+  { id: "cqo", name: "CQO (Eval 총괄)", dept: "CQO", room: "cqo-team" },
+  { id: "evaluator-functional", name: "Eval — Functional", dept: "CQO", room: "cqo-team" },
+  { id: "evaluator-visual", name: "Eval — Visual", dept: "CQO", room: "cqo-team" },
+  { id: "evaluator-code-quality", name: "Eval — Code Quality", dept: "CQO", room: "cqo-team" },
+  { id: "evaluator-architecture", name: "Eval — Architecture", dept: "CQO", room: "cqo-team" },
+  { id: "evaluator-security", name: "Eval — Security", dept: "CQO", room: "cqo-team" },
+  { id: "service-ops", name: "Service Ops", dept: "Operations", room: "service-ops" },
+];
+
+export const ROOM_LABELS: Record<RoomId, { ko: string; en: string; dept: Dept | "Archive" }> = {
+  ceo: { ko: "CEO실", en: "CEO Office", dept: "CEO" },
+  meeting: { ko: "회의실", en: "Meeting Room", dept: "Meeting" },
+  coo: { ko: "COO실", en: "COO Office", dept: "Planner" },
+  "cto-team": { ko: "CTO팀", en: "CTO Team", dept: "CTO" },
+  "cqo-team": { ko: "CQO팀", en: "CQO Team", dept: "CQO" },
+  "service-ops": { ko: "Service-Ops", en: "Service Ops", dept: "Operations" },
+  archive: { ko: "아카이브", en: "Archive", dept: "Archive" },
+};

package/apps/harness-dashboard/lib/furniture.ts

@@ -0,0 +1,165 @@
+import { ROOM_RECTS, type RoomRect } from "./iso";
+import type { RoomId } from "./types";
+import { AGENT_ROSTER } from "./agent-roster";
+
+// How many desks each room should physically contain. The meeting room is
+// over-provisioned because anyone can drop in. Room desks must accommodate the
+// full roster in agent-roster.ts (CEO+Brainstormer; CTO+Conductor+4 Generators;
+// CQO+5 Evaluators).
+export const ROOM_CAPACITY: Record<RoomId, number> = {
+  ceo: 2,
+  meeting: 7,
+  coo: 3,
+  "cto-team": 6,
+  "cqo-team": 6,
+  "service-ops": 1,
+  archive: 0,
+};
+
+export interface DeskSlot {
+  index: number;
+  // Desk position (slab top center) in world coords.
+  desk: [number, number, number];
+  // Where the seated character stands (chair position).
+  chair: [number, number, number];
+  // Facing direction (yaw, radians) — character faces the desk.
+  facing: number;
+}
+
+const DESK_INSET = 0.55; // distance from room edge to desk
+const DESK_SPACING_MIN = 0.85;
+
+// Layout desks in two rows along the room's long axis, each row hugging one
+// of the long walls. Chairs sit on the inside of each row.
+export function deskSlotsForRoom(rect: RoomRect): DeskSlot[] {
+  const cap = ROOM_CAPACITY[rect.id];
+  if (cap === 0) return [];
+
+  const slots: DeskSlot[] = [];
+  const longAxisIsX = rect.ww >= rect.wh;
+  const longLen = longAxisIsX ? rect.ww : rect.wh;
+  const shortLen = longAxisIsX ? rect.wh : rect.ww;
+
+  // 2 rows if room is deep enough, else 1 row.
+  const rows = shortLen >= 2.0 && cap >= 3 ? 2 : 1;
+  const perRow = Math.ceil(cap / rows);
+  const usable = longLen - DESK_INSET * 2;
+  const spacing = perRow > 1 ? Math.max(DESK_SPACING_MIN, usable / perRow) : 0;
+  const startLong = rect.wx + (longAxisIsX ? DESK_INSET + spacing / 2 : 0);
+  const startLongZ = rect.wy + (!longAxisIsX ? DESK_INSET + spacing / 2 : 0);
+
+  for (let i = 0; i < cap; i++) {
+    const row = i % rows;
+    const col = Math.floor(i / rows);
+    const longOffset = perRow > 1 ? col * spacing : longLen / 2;
+
+    let dx: number;
+    let dz: number;
+    let cx: number;
+    let cz: number;
+    let facing: number;
+
+    if (longAxisIsX) {
+      dx = (startLong as number) + longOffset;
+      // Row 0 hugs the +z wall, row 1 hugs the -z wall.
+      const wallZ =
+        row === 0 ? rect.wy + rect.wh - DESK_INSET : rect.wy + DESK_INSET;
+      dz = wallZ;
+      cx = dx;
+      cz = row === 0 ? wallZ - 0.55 : wallZ + 0.55;
+      facing = row === 0 ? Math.PI : 0; // face the wall (Roblox cubicle vibe)
+    } else {
+      dz = (startLongZ as number) + longOffset;
+      const wallX =
+        row === 0 ? rect.wx + rect.ww - DESK_INSET : rect.wx + DESK_INSET;
+      dx = wallX;
+      cx = row === 0 ? wallX - 0.55 : wallX + 0.55;
+      cz = dz;
+      facing = row === 0 ? -Math.PI / 2 : Math.PI / 2;
+    }
+
+    slots.push({
+      index: i,
+      desk: [dx, 0.2, dz],
+      chair: [cx, 0.2, cz],
+      facing,
+    });
+  }
+
+  return slots;
+}
+
+// Stable mapping: which desk slot each agent owns in their *home* room.
+// Built once at module load from AGENT_ROSTER.
+const agentHomeDesk: Record<string, DeskSlot> = (() => {
+  const out: Record<string, DeskSlot> = {};
+  const counters = new Map<RoomId, number>();
+  for (const entry of AGENT_ROSTER) {
+    const slots = deskSlotsForRoom(
+      ROOM_RECTS.find((r) => r.id === entry.room)!
+    );
+    if (slots.length === 0) continue;
+    const idx = counters.get(entry.room) ?? 0;
+    out[entry.id] = slots[idx % slots.length];
+    counters.set(entry.room, idx + 1);
+  }
+  return out;
+})();
+
+export function homeDeskFor(agentId: string): DeskSlot | undefined {
+  return agentHomeDesk[agentId];
+}
+
+// Door positions per room — used by Floor3D to leave gaps in the walls and by
+// the meeting-room teleport logic. We pick the side that opens onto the
+// largest neighbor footprint so the office reads as "all connected".
+export interface DoorSpec {
+  side: "north" | "south" | "east" | "west";
+  // World position of the door center.
+  position: [number, number];
+  width: number;
+}
+
+export function doorsForRoom(rect: RoomRect): DoorSpec[] {
+  const w = 1.0;
+  const cx = rect.wx + rect.ww / 2;
+  const cz = rect.wy + rect.wh / 2;
+  const doors: DoorSpec[] = [];
+
+  // Every room has a door on every side that opens onto a corridor — the
+  // corridor mesh is drawn around all rooms in Floor3D.
+  switch (rect.id) {
+    case "ceo":
+      doors.push({ side: "east", position: [rect.wx + rect.ww, cz], width: w });
+      doors.push({ side: "south", position: [cx, rect.wy + rect.wh], width: w });
+      break;
+    case "meeting":
+      doors.push({ side: "west", position: [rect.wx, cz], width: w });
+      doors.push({ side: "east", position: [rect.wx + rect.ww, cz], width: w });
+      doors.push({ side: "south", position: [cx, rect.wy + rect.wh], width: w });
+      break;
+    case "coo":
+      doors.push({ side: "west", position: [rect.wx, cz], width: w });
+      doors.push({ side: "south", position: [cx, rect.wy + rect.wh], width: w });
+      break;
+    case "cto-team":
+      doors.push({ side: "north", position: [cx, rect.wy], width: w });
+      doors.push({ side: "east", position: [rect.wx + rect.ww, cz], width: w });
+      doors.push({ side: "south", position: [cx, rect.wy + rect.wh], width: w });
+      break;
+    case "cqo-team":
+      doors.push({ side: "north", position: [cx, rect.wy], width: w });
+      doors.push({ side: "west", position: [rect.wx, cz], width: w });
+      doors.push({ side: "south", position: [cx, rect.wy + rect.wh], width: w });
+      break;
+    case "service-ops":
+      doors.push({ side: "north", position: [cx, rect.wy], width: w });
+      doors.push({ side: "east", position: [rect.wx + rect.ww, cz], width: w });
+      break;
+    case "archive":
+      doors.push({ side: "north", position: [cx, rect.wy], width: w });
+      doors.push({ side: "west", position: [rect.wx, cz], width: w });
+      break;
+  }
+  return doors;
+}

package/apps/harness-dashboard/lib/harness-root.ts

@@ -0,0 +1,20 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+// Resolves the directory that contains `.harness/`. Search order:
+//   1. env HARNESS_ROOT (absolute path) — escape hatch for tests/CI.
+//   2. Walk up from cwd until we find a `.harness/` directory.
+//   3. Fall back to cwd (caller will see errorBanner via readHarnessState).
+export function resolveHarnessRoot(start: string = process.cwd()): string {
+  const fromEnv = process.env.HARNESS_ROOT;
+  if (fromEnv && existsSync(path.join(fromEnv, ".harness"))) {
+    return fromEnv;
+  }
+  let current = path.resolve(start);
+  while (true) {
+    if (existsSync(path.join(current, ".harness"))) return current;
+    const parent = path.dirname(current);
+    if (parent === current) return start;
+    current = parent;
+  }
+}