@walwal-harness/cli 7.1.7 → 7.1.9

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

@@ -0,0 +1,126 @@
+import type { AgentId, Dept, MinifigState } from "./types";
+
+export interface ProgressSlice {
+  current_agent?: AgentId | null;
+  next_agent?: AgentId | null;
+  agent_status?: string;
+  failure?: { agent?: AgentId | null; message?: string | null } | null;
+  meetings?: { active?: AgentId[] };
+  service_ops?: {
+    incident?: { open?: Array<{ id: string; dept?: string }> };
+    monitor?: { stream_active?: boolean; stream_target?: string | null };
+    requested_mode?: string | null;
+  };
+  // v6 NEXUS parallel mode (CLAUDE.md §Parallel Tracks). When tracks have
+  // owners with status=running, those agents are concurrently working —
+  // not just current_agent. The dashboard treats every running owner as
+  // typing so the parallel reality is visible.
+  conductor?: {
+    state?: string;
+    current_action?: string | null;
+    tracks?: Array<{ owner?: string; status?: string }>;
+  };
+}
+
+export interface DeriveContext {
+  // Distinct departments with at least one open incident — pre-computed by
+  // harness-state.ts so the mapping doesn't iterate the array per agent.
+  incidentDepts?: Set<string>;
+  // The agent's own department (passed in because we map by department, not
+  // by the bare AgentId).
+  dept?: Dept | "Operations";
+}
+
+// `conductor.current_action` carries strings like:
+//   "spawn:generator-frontend"
+//   "spawn:coo-developer:F12-006"
+//   "spawn:generator-backend (foundation F-101)"
+// Pull out the agent id from the head.
+export function parseSpawnAgent(action: string | null | undefined): string | null {
+  if (!action) return null;
+  const m = /^spawn:([a-z][a-z0-9-]*)/i.exec(action);
+  return m ? m[1].toLowerCase() : null;
+}
+
+function isAgentRunningTrack(
+  agentId: string,
+  conductor: ProgressSlice["conductor"]
+): boolean {
+  const tracks = conductor?.tracks ?? [];
+  return tracks.some(
+    (t) =>
+      t.owner === agentId &&
+      (t.status === "running" || t.status === "in_progress" || t.status === "active")
+  );
+}
+
+function isAgentQueuedTrack(
+  agentId: string,
+  conductor: ProgressSlice["conductor"]
+): boolean {
+  const tracks = conductor?.tracks ?? [];
+  return tracks.some((t) => t.owner === agentId && t.status === "pending");
+}
+
+// Priority: red-alert > talking > typing > queued > idle.
+// red-alert wins because incidents/failures must dominate the visual field.
+// talking wins over typing because meetings teleport overrides desk presence.
+// typing now reflects v6 NEXUS *parallel* mode — multiple agents can be
+// concurrently working, all of them get the typing aura.
+// queued makes autonomous handoff visible: when the company already assigned
+// a next department, that department sits at its desk even before the worker
+// process emits its first log line.
+export function deriveMinifigState(
+  agentId: AgentId,
+  progress: ProgressSlice | null,
+  ctx: DeriveContext = {}
+): MinifigState {
+  if (!progress) return "idle";
+  if (progress.failure?.agent === agentId) return "red-alert";
+  if (ctx.dept && ctx.incidentDepts && ctx.incidentDepts.size > 0) {
+    if (ctx.dept === "Operations" || ctx.incidentDepts.has(ctx.dept)) {
+      return "red-alert";
+    }
+  }
+  const inMeeting = progress.meetings?.active?.includes(agentId) ?? false;
+  if (inMeeting) return "talking";
+
+  // Parallel-typing signals (any one of these means the agent is working).
+  if (
+    progress.current_agent === agentId &&
+    progress.agent_status === "running"
+  ) {
+    return "typing";
+  }
+  if (isAgentRunningTrack(agentId, progress.conductor)) {
+    return "typing";
+  }
+  if (parseSpawnAgent(progress.conductor?.current_action) === agentId) {
+    return "typing";
+  }
+  // G-006: service-ops co-spawned in monitor mode is actively streaming.
+  if (
+    agentId === "service-ops" &&
+    progress.service_ops?.monitor?.stream_active === true
+  ) {
+    return "typing";
+  }
+  if (
+    progress.next_agent === agentId &&
+    progress.agent_status !== "blocked" &&
+    progress.agent_status !== "failed"
+  ) {
+    return "queued";
+  }
+  if (isAgentQueuedTrack(agentId, progress.conductor)) {
+    return "queued";
+  }
+
+  return "idle";
+}
+
+export function pickTalkingPreview(agentId: AgentId): string {
+  // Sprint 2 will pull this from progress.log; for Sprint 1 we surface a stub
+  // so the speech-bubble component has a sensible default.
+  return `${agentId}…`;
+}

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

@@ -0,0 +1,329 @@
+export type AgentId =
+  | "dispatcher"
+  | "brainstormer"
+  | "conductor"
+  | "meeting-manager"
+  | "planner"
+  | "coo-developer"
+  | "documentationer"
+  | "cto"
+  | "generator-backend"
+  | "generator-frontend"
+  | "generator-designer"
+  | "generator-devops"
+  | "cqo"
+  | "evaluator-functional"
+  | "evaluator-visual"
+  | "evaluator-code-quality"
+  | "evaluator-architecture"
+  | "evaluator-security"
+  | "service-ops";
+
+export type RoomId =
+  | "ceo"
+  | "meeting"
+  | "coo"
+  | "cto-team"
+  | "cqo-team"
+  | "service-ops"
+  | "archive";
+
+export type Dept = "CEO" | "Meeting" | "Planner" | "CTO" | "CQO" | "Operations";
+
+export type MinifigState = "idle" | "queued" | "typing" | "talking" | "red-alert";
+
+export interface AgentState {
+  id: AgentId;
+  name: string;
+  dept: Dept;
+  /** The agent's *current* room (after meeting teleport). */
+  room: RoomId;
+  /** The agent's home room — never changes. */
+  homeRoom: RoomId;
+  minifigState: MinifigState;
+  lastActivity: string | null;
+  talkingPreview?: string;
+  alertReason?: string;
+}
+
+export interface RoomMetrics {
+  sprint_number?: number;
+  last_review?: string | null;
+  last_audit?: string | null;
+  last_check?: string | null;
+  sprint_verdict?: "pending" | "PASS" | "FAIL";
+  open_alerts?: number;
+  open_arch_risks?: number;
+  open_regressions?: number;
+  cadence?: MeetingCadence;
+  next_scheduled?: string | null;
+  active_tracks?: number;
+  active_hypothesis?: number;
+  active_workers?: number;
+  open_incidents?: number;
+  pass_rate?: number | null;
+  contract_signed?: { be?: boolean; fe?: boolean };
+  eval_scores?: EvalScores | null;
+}
+
+export interface SeatLayout {
+  seats: number;
+  occupants: AgentId[];
+  overflow: number;
+}
+
+export interface RoomState {
+  id: RoomId;
+  label_ko: string;
+  label_en: string;
+  dept: Dept | "Archive";
+  metrics?: RoomMetrics;
+  seatLayout?: SeatLayout;
+}
+
+export interface GoalCard {
+  id: string;
+  title: string;
+  description_truncated?: string;
+  adherence: number | null;
+}
+
+export interface ArchiveEntry {
+  dir: string;
+  label: string;
+  result: "PASS" | "FAIL" | "unknown";
+  ts: string | null;
+}
+
+export interface ArchiveStat {
+  sprintCount: number;
+  recent: ArchiveEntry[];
+  all: ArchiveEntry[];
+}
+
+export type MeetingCadence = "light" | "normal" | "heavy";
+export type MeetingType =
+  | "standup"
+  | "sprint-review"
+  | "spec-review"
+  | "incident-war-room"
+  | "all-hands"
+  | "followup-review";
+
+export interface CurrentMeeting {
+  type: MeetingType;
+  topic?: string;
+  convened_at?: string | null;
+}
+
+export interface MeetingsState {
+  active: AgentId[];
+  cadence: MeetingCadence;
+  next_scheduled: string | null;
+  current: CurrentMeeting | null;
+}
+
+export type TrackStatus = "dispatched" | "in_progress" | "joined" | "blocked";
+
+export interface ParallelTrack {
+  id: string;
+  from_meeting: string;
+  to_dept: Dept | "Operations" | "Multi";
+  to_room: RoomId;
+  status: TrackStatus;
+  label?: string;
+}
+
+export type IncidentSeverity = "low" | "medium" | "high" | "critical";
+
+export interface IncidentEntry {
+  id: string;
+  dept: Dept | "Operations" | "Multi" | string;
+  severity: IncidentSeverity;
+  message?: string;
+  ts?: string | null;
+}
+
+export type HypothesisVerdict = "pending" | "valid" | "invalid";
+
+export interface HypothesisEntry {
+  id: string;
+  brief: string;
+  verdict: HypothesisVerdict;
+  ts?: string | null;
+}
+
+export type EscalationReason =
+  | "three-fail"
+  | "incident"
+  | "goal-violation"
+  | "budget"
+  | "other";
+
+export interface EscalationEntry {
+  id: string;
+  reason: EscalationReason | string;
+  message?: string;
+  ts?: string | null;
+}
+
+export type Pipeline = "FULLSTACK" | "FE-ONLY" | "BE-ONLY" | "META_REFACTOR" | null;
+
+export interface ContractSnapshot {
+  sprint_number: number | null;
+  pipeline: Pipeline;
+  api_version: string | null;
+  feature_total: number;
+  feature_passed: number;
+  feature_failed: number;
+  contract_signed: { be: boolean; fe: boolean };
+}
+
+export interface FeatureSummary {
+  id: string;
+  title: string;
+  status: "ready" | "blocked" | "in_progress" | "passed" | "failed" | "unknown";
+  passes: string[];
+}
+
+export interface EvalScores {
+  functional?: number | null;
+  visual?: number | null;
+  code_quality?: number | null;
+  architecture?: number | null;
+  security?: number | null;
+}
+
+export interface ErrorBanner {
+  level: "info" | "warn" | "error";
+  message_ko: string;
+  message_en: string;
+}
+
+export interface WorkerSnapshot {
+  team: number | string;
+  feature: string;
+  title?: string;
+  agent: AgentId | string;
+  phase?: string;
+  status: "spawned" | "recorded" | "running" | "idle" | "blocked" | "unknown";
+  pid?: number | null;
+  prompt?: string | null;
+  log?: string | null;
+  progress: number | null;
+  summary: string;
+  next_material?: string | null;
+}
+
+export interface MeetingRecord {
+  id: string;
+  path: string;
+  ts: string | null;
+  title: string;
+  verdict?: string | null;
+  summary: string;
+  content: string;
+}
+
+export interface OpsServiceHealth {
+  name: string;
+  host: string;
+  port: number;
+  status: "ok" | "degraded" | "down" | "unknown";
+  port_state?: string | null;
+  health_status?: number | null;
+  health_path?: string | null;
+  recent_errors?: number | null;
+}
+
+export interface EnvKeySummary {
+  key: string;
+  category: "secret" | "endpoint" | "port" | "mode" | "other";
+  masked: string;
+}
+
+export interface EnvFileSummary {
+  path: string;
+  updated_at: string | null;
+  key_count: number;
+  keys: EnvKeySummary[];
+}
+
+export interface OperationsDashboard {
+  workers: WorkerSnapshot[];
+  features: FeatureSummary[];
+  recentMeetings: MeetingRecord[];
+  opsHealth: OpsServiceHealth[];
+  envFiles: EnvFileSummary[];
+}
+
+export interface HarnessSnapshot {
+  version: string;
+  ts: string;
+  projectName: string;
+  projectPath: string;
+  agents: AgentState[];
+  rooms: RoomState[];
+  goal: GoalCard | null;
+  archive: ArchiveStat;
+  meetings: MeetingsState;
+  tracks: ParallelTrack[];
+  incidents: IncidentEntry[];
+  hypothesis: HypothesisEntry[];
+  escalations: EscalationEntry[];
+  contract: ContractSnapshot;
+  evalScores: EvalScores | null;
+  errorBanner: ErrorBanner | null;
+  dashboard: OperationsDashboard;
+  missions: MissionDoc[];
+  ownerHistory: OwnerPromptEntry[];
+  gotchas: GotchaEntry[];
+}
+
+// Real harness mission documents
+export interface WorkerDocEntry {
+  name: string;
+  content: string;
+  status: "COMPLETE" | "IN_PROGRESS" | "unknown";
+  owner: "cto" | "cqo" | "coo" | "cdo" | "ops" | "unknown";
+}
+
+export interface MissionDoc {
+  missionId: string;
+  ts: string;
+  type: "hotfix" | "feature" | "unknown";
+  label: string;
+  ceo: string | null;
+  cto: string | null;
+  cqo: string | null;
+  coo: string | null;
+  cdo: string | null;
+  ops: string | null;
+  workers: WorkerDocEntry[];
+  cxxPresent: string[];
+}
+
+export interface OwnerPromptEntry {
+  ts: string;
+  content: string;
+  type: "goal" | "hot-fix" | "other";
+}
+
+export interface GotchaEntry {
+  id: string;
+  title: string;
+  content: string;
+  tags: string[];
+}
+
+export type OrgRole = "owner" | "ceo" | "coo" | "cdo" | "cto" | "cqo" | "ops";
+
+export interface OrgNodeDef {
+  id: string;
+  role: OrgRole;
+  label: string;
+  sublabel?: string;
+  status: MinifigState;
+  activity: string | null;
+  agentIds: AgentId[];
+}

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

@@ -0,0 +1,64 @@
+import chokidar from "chokidar";
+import path from "node:path";
+
+export interface WatchHandle {
+  close(): Promise<void>;
+}
+
+export interface WatchOptions {
+  /** Coalesce rapid-fire events within this window (ms). */
+  debounceMs?: number;
+}
+
+// Watches the .harness/ directory for changes that affect the dashboard
+// snapshot — progress.json (state), progress.log (activity), actions/* (sprint
+// artifacts), archive/* (sprint history).
+export function watchHarness(
+  rootDir: string,
+  onChange: (changedPath: string) => void,
+  opts: WatchOptions = {}
+): WatchHandle {
+  const debounceMs = opts.debounceMs ?? 50;
+  const harnessDir = path.join(rootDir, ".harness");
+  const watcher = chokidar.watch(
+    [
+      path.join(harnessDir, "progress.json"),
+      path.join(harnessDir, "progress.log"),
+      path.join(harnessDir, "actions"),
+      path.join(harnessDir, "archive"),
+    ],
+    {
+      ignoreInitial: true,
+      awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 },
+      // Vitest creates and deletes temp harness dirs quickly; polling avoids
+      // macOS FSEvents EMFILE noise after close().
+      usePolling: process.env.VITEST === "true",
+      // Don't crawl deeply into archive — recent dirs only.
+      depth: 4,
+    }
+  );
+
+  let pending: NodeJS.Timeout | null = null;
+  let lastPath = "";
+
+  const fire = (changedPath: string) => {
+    lastPath = changedPath;
+    if (pending) return;
+    pending = setTimeout(() => {
+      pending = null;
+      onChange(lastPath);
+    }, debounceMs);
+  };
+
+  watcher.on("add", fire).on("change", fire).on("unlink", fire);
+
+  return {
+    async close() {
+      if (pending) {
+        clearTimeout(pending);
+        pending = null;
+      }
+      await watcher.close();
+    },
+  };
+}

package/apps/harness-dashboard/next-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+/// <reference path="./.next/types/routes.d.ts" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/apps/harness-dashboard/next.config.mjs

@@ -0,0 +1,9 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  reactStrictMode: true,
+  experimental: {
+    typedRoutes: false,
+  },
+};
+
+export default nextConfig;