@walwal-harness/cli 7.1.19 → 7.1.21

package/CHANGELOG.md

@@ -31,13 +31,19 @@ docmeta:
 
 ## Unreleased
 
+### Changed
+- Dashboard Org Tree now positions only hired HR-Resource workers from `hr-roster.json`, requiring a backing `.harness/shared/HR-Resource/{worker}/SKILL.md`.
+- Running hired workers are highlighted under their owning CXX instead of showing queue jobs as worker seats.
+- Dashboard SSE now watches mission documents, hired-worker roster, and HR-Resource changes so worker updates appear without browser refresh.
+- Dashboard worker cards now prefer mission/report task labels and mark recently updated unfinished worker reports as active when runtime active-worker state is absent.
+
 ### Added
 - Hourly wake can now run either `claude -p` or `codex exec` via `HARNESS_WAKE_EXECUTOR=claude|codex`.
 - Hourly wake supports `HARNESS_WAKE_MODE=headless|tmux|record`; `tmux` creates a separate time-boxed session per hourly company tick for easier inspection.
 - Deterministic conductor fallback runs after each hourly review so meeting decisions can advance even when the LLM runtime is unavailable.
 - Hourly meeting minutes now split meaningful progress from paperwork-only artifacts and track strategy cadence drift.
 
-### Changed
+### Runtime Changed
 - launchd wake PATH now includes `$HOME/.local/bin` so local Claude/Codex installs are found from non-interactive jobs.
 - Service-Ops records repeated incident signatures and marks repeated incidents as `recovery_required`, causing hourly meetings to route to CTO runtime recovery instead of repeating discussion.
 

package/README.md

@@ -181,7 +181,7 @@ npx walwal-harness init --force --project-root /path/to/project
 Features:
 
 - **Split Workspace** — full-viewport left/right panes keep Org Tree + Mission Timeline beside the selected mission detail; both panes scroll independently with hidden scrollbars, and the detail pane resets to top on selection changes
-- **Org Tree** — live status of Owner → CEO → CXX → Workers hierarchy, with worker cards grouped under their owning CXX; clicking any node initializes the right pane to the relevant history, CXX document, or worker report
+- **Org Tree** — live status of Owner → CEO → CXX → Workers hierarchy, with worker cards created only from hired `hr-roster.json` entries backed by `.harness/shared/HR-Resource/{worker}/SKILL.md`; running hired workers are highlighted under their owning CXX
 - **Mission Timeline** — clickable history of goal/submission/hot-fix missions showing the full dispatch chain
 - **Mission Flow tab** — per-mission flow: Owner prompt → CEO routing → CXX → owner-specific worker evidence → CQO verdict
 - **History tab** — mission-specific Owner request (from CEO summary + closest progress.log match)

package/apps/harness-dashboard/components/OrgTree.tsx

@@ -225,9 +225,9 @@ export function OrgTree({ snapshot, activeNodeId, onNodeClick }: OrgTreeProps) {
     },
   ];
 
-  // Workers are grouped by their owning CXX so evaluator reports sit under CQO,
-  // implementation reports under CTO, and legacy flat reports stay visible.
-  const workers = currentMission?.workers ?? [];
+  // Only hired HR-Resource workers are positioned in the org chart. Legacy
+  // report-only workers remain visible in mission documents, but not as seats.
+  const workers = (currentMission?.workers ?? []).filter((w) => w.hired);
 
   return (
     <div className="w-full px-4 py-6 select-none">
@@ -272,14 +272,16 @@ export function OrgTree({ snapshot, activeNodeId, onNodeClick }: OrgTreeProps) {
       {/* Row 3: CXX nodes with workers below */}
       <div className="flex gap-3 justify-center">
         {cxxNodes.map((node) => {
-          const nodeWorkers = workers.filter(
-            (w) => w.owner === node.role || (w.owner === "unknown" && node.role === "cto")
-          );
+          const nodeWorkers = workers.filter((w) => w.owner === node.role);
+          const hasActiveWorker = nodeWorkers.some((w) => w.active);
+          const displayNode = hasActiveWorker
+            ? { ...node, status: "typing" as const, activity: "Worker active" }
+            : node;
 
           return (
             <div key={node.id} className="flex flex-col items-center gap-2">
               <OrgCard
-                node={node}
+                node={displayNode}
                 size="md"
                 active={activeNodeId === node.id}
                 onClick={onNodeClick}
@@ -289,38 +291,53 @@ export function OrgTree({ snapshot, activeNodeId, onNodeClick }: OrgTreeProps) {
                 <>
                   <div className="w-px h-3 bg-gray-700/60" />
                   <div className="flex flex-col gap-1.5 w-full">
-                    {nodeWorkers.map((w) => (
+                    {nodeWorkers.map((w) => {
+                      const workerNodeId = `worker-${node.role}-${w.name}`;
+                      const workerActive = activeNodeId === workerNodeId || w.active;
+                      return (
                       <button
-                        key={w.name}
+                        key={`${node.role}-${w.name}`}
                         type="button"
                         onClick={() =>
                           onNodeClick({
-                            id: `worker-${w.name}`,
+                            id: workerNodeId,
                             role: node.role,
-                            label: w.name,
-                            sublabel: w.status,
-                            status: w.status === "COMPLETE" ? "idle" : "typing",
-                            activity: null,
+                            label: w.displayName,
+                            sublabel: w.active ? `running · ${w.name}` : `${w.status} · ${w.name}`,
+                            status: w.active ? "typing" : w.status === "COMPLETE" ? "idle" : "queued",
+                            activity: w.sourcePath ?? null,
                             agentIds: [],
                           })
                         }
-                        className={`rounded border border-gray-700/40 bg-gray-800/30 px-2 py-1.5 text-left min-w-[130px] max-w-[160px] transition-all hover:border-white/20 ${
-                          activeNodeId === `worker-${w.name}` ? "ring-1 ring-cyan-300" : ""
-                        }`}
+                        className={`relative rounded border px-2 py-1.5 text-left min-w-[130px] max-w-[160px] transition-all hover:border-white/20 ${
+                          workerActive
+                            ? "border-cyan-300/70 bg-cyan-400/10 shadow-[0_0_18px_rgba(34,211,238,0.18)]"
+                            : "border-gray-700/40 bg-gray-800/30"
+                        } ${activeNodeId === workerNodeId ? "ring-1 ring-cyan-300" : ""}`}
                       >
-                        <div className="font-mono text-[9px] text-gray-500">worker</div>
-                        <div className="text-[11px] font-medium text-gray-200 truncate">
-                          {w.name}
+                        {w.active && (
+                          <span className="absolute right-2 top-2 h-1.5 w-1.5 rounded-full bg-cyan-300 animate-pulse" />
+                        )}
+                        <div className={`font-mono text-[9px] ${w.active ? "text-cyan-300/80" : "text-gray-500"}`}>
+                          hired worker
+                        </div>
+                        <div className="text-[11px] font-medium text-gray-200 truncate pr-3">
+                          {w.displayName}
                         </div>
                         <div
                           className={`text-[9px] font-mono mt-0.5 ${
-                            w.status === "COMPLETE" ? "text-emerald-400" : "text-amber-400"
-                          }`}
+                            w.active
+                              ? "text-cyan-300"
+                              : w.status === "COMPLETE"
+                              ? "text-emerald-400"
+                              : "text-amber-400"
+                        }`}
                         >
-                          {w.status}
+                          {w.active ? "RUNNING" : w.status}
                         </div>
                       </button>
-                    ))}
+                      );
+                    })}
                   </div>
                 </>
               )}

package/apps/harness-dashboard/components/Scene.tsx

@@ -77,7 +77,7 @@ export function Scene({ snapshot: initial, lang = "ko" }: SceneProps) {
     selectedAgent?.id ?? "",
   ].join(":");
   const selectedWorkerName = selectedNode?.id.startsWith("worker-")
-    ? selectedNode.label
+    ? selectedNode.id.replace(/^worker-[^-]+-/, "")
     : undefined;
   const selectedDocumentRole = selectedWorkerName
     ? "worker"

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

@@ -247,4 +247,54 @@ describe("readHarnessState", () => {
     expect(missions[0].type).toBe("submission");
     expect(missions.find((mission) => mission.missionId === "goal-1-auth-system")?.type).toBe("goal");
   });
+
+  it("positions only hired HR-Resource workers and marks active workers", () => {
+    const harnessDir = path.join(dir, ".harness");
+    const missionDir = path.join(harnessDir, "documents", "goal-1-dashboard");
+    mkdirSync(path.join(missionDir, "cto", "workers"), { recursive: true });
+    mkdirSync(path.join(harnessDir, "shared", "HR-Resource", "react-ui-worker"), { recursive: true });
+    writeFileSync(path.join(missionDir, "ceo.md"), "# Dashboard\n");
+    writeFileSync(
+      path.join(missionDir, "cto", "workers", "react-ui-worker.md"),
+      "## Status\nIN_PROGRESS\n"
+    );
+    writeFileSync(
+      path.join(harnessDir, "shared", "HR-Resource", "react-ui-worker", "SKILL.md"),
+      "# React UI Worker\n"
+    );
+    writeFileSync(
+      path.join(harnessDir, "shared", "hr-roster.json"),
+      JSON.stringify({
+        hired: [
+          {
+            worker: "react-ui-worker",
+            owner: "cto",
+            skillPath: ".harness/shared/HR-Resource/react-ui-worker/SKILL.md",
+          },
+          {
+            worker: "missing-worker",
+            owner: "cto",
+            skillPath: ".harness/shared/HR-Resource/missing-worker/SKILL.md",
+          },
+        ],
+      })
+    );
+    writeFileSync(
+      path.join(harnessDir, "progress.json"),
+      JSON.stringify({
+        company_state: {
+          workers: [{ agent: "react-ui-worker", status: "running", feature: "F1" }],
+        },
+      })
+    );
+
+    const workers = readHarnessState(dir).missions[0].workers;
+    expect(workers.map((w) => w.name)).toEqual(["react-ui-worker"]);
+    expect(workers[0]).toMatchObject({
+      owner: "cto",
+      hired: true,
+      active: true,
+      sourcePath: ".harness/shared/HR-Resource/react-ui-worker/SKILL.md",
+    });
+  });
 });

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

@@ -11,7 +11,10 @@ describe("watchHarness", () => {
     dir = mkdtempSync(path.join(tmpdir(), "watch-"));
     mkdirSync(path.join(dir, ".harness", "actions"), { recursive: true });
     mkdirSync(path.join(dir, ".harness", "archive"), { recursive: true });
+    mkdirSync(path.join(dir, ".harness", "documents"), { recursive: true });
+    mkdirSync(path.join(dir, ".harness", "shared", "HR-Resource"), { recursive: true });
     writeFileSync(path.join(dir, ".harness", "progress.json"), "{}");
+    writeFileSync(path.join(dir, ".harness", "shared", "hr-roster.json"), "{\"hired\":[]}");
   });
 
   afterEach(() => {
@@ -45,4 +48,43 @@ describe("watchHarness", () => {
     await handle.close();
     // No assertion — test passes if close() resolves without throwing.
   });
+
+  it("fires onChange when hired workers or mission documents change", async () => {
+    const events: string[] = [];
+    const handle = watchHarness(dir, (p) => events.push(p), { debounceMs: 30 });
+
+    await new Promise((r) => setTimeout(r, 250));
+
+    writeFileSync(
+      path.join(dir, ".harness", "shared", "hr-roster.json"),
+      JSON.stringify({ hired: [{ worker: "react-ui-worker", owner: "cto" }] })
+    );
+    await new Promise((r) => setTimeout(r, 300));
+
+    mkdirSync(
+      path.join(dir, ".harness", "shared", "HR-Resource", "react-ui-worker"),
+      { recursive: true }
+    );
+    writeFileSync(
+      path.join(dir, ".harness", "shared", "HR-Resource", "react-ui-worker", "SKILL.md"),
+      "# React UI Worker\n"
+    );
+    await new Promise((r) => setTimeout(r, 300));
+
+    mkdirSync(
+      path.join(dir, ".harness", "documents", "goal-1", "cto", "workers"),
+      { recursive: true }
+    );
+    writeFileSync(
+      path.join(dir, ".harness", "documents", "goal-1", "cto", "workers", "react-ui-worker.md"),
+      "## Status\nIN_PROGRESS\n"
+    );
+
+    await new Promise((r) => setTimeout(r, 500));
+
+    await handle.close();
+    expect(events.some((e) => e.endsWith("hr-roster.json"))).toBe(true);
+    expect(events.some((e) => e.endsWith("SKILL.md"))).toBe(true);
+    expect(events.some((e) => e.endsWith("react-ui-worker.md"))).toBe(true);
+  });
 });

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

@@ -41,6 +41,7 @@ import type {
 
 const SNAPSHOT_VERSION = "1.2.0";
 const GOAL_DESC_TRUNCATE = 200;
+const RECENT_WORKER_ACTIVE_MS = 10 * 60 * 1000;
 
 interface RawProgress {
   goals?: {
@@ -775,6 +776,16 @@ function readFeatureTitles(rootDir: string): Map<string, string> {
 }
 
 type RawWorker = NonNullable<NonNullable<RawProgress["company_state"]>["workers"]>[number];
+type WorkerOwner = WorkerDocEntry["owner"];
+
+interface HiredWorkerEntry {
+  name: string;
+  owner: Exclude<WorkerOwner, "unknown">;
+  sourcePath: string | null;
+  mission: string | null;
+  task: string | null;
+  capability: string | null;
+}
 
 function deriveWorkerProgress(worker: RawWorker): number | null {
   const status = (worker?.status ?? worker?.spawn_status ?? "").toLowerCase();
@@ -837,6 +848,109 @@ function buildWorkers(rootDir: string, progress: RawProgress | null): WorkerSnap
   });
 }
 
+function normalizeWorkerName(value: string | null | undefined): string {
+  return (value ?? "")
+    .toLowerCase()
+    .replace(/^harness-/, "")
+    .replace(/\.md$/, "")
+    .trim();
+}
+
+function normalizeWorkerOwner(value: string | null | undefined): HiredWorkerEntry["owner"] | null {
+  const owner = (value ?? "").toLowerCase().replace(/^harness-/, "");
+  if (owner === "coo" || owner === "cdo" || owner === "cto" || owner === "cqo" || owner === "ops") {
+    return owner;
+  }
+  return null;
+}
+
+function readHiredWorkers(rootDir: string): HiredWorkerEntry[] {
+  const rosterPath = path.join(rootDir, ".harness", "shared", "hr-roster.json");
+  const roster = readJsonSafe<{
+    hired?: Array<{
+      worker?: string;
+      name?: string;
+      owner?: string;
+      owningCxx?: string;
+      mission?: string;
+      task?: string;
+      capability?: string;
+      skillPath?: string;
+      skillPaths?: { source?: string };
+    }>;
+  }>(rosterPath);
+  if (!roster.ok) return [];
+
+  const seen = new Set<string>();
+  const hired: HiredWorkerEntry[] = [];
+  for (const entry of roster.value.hired ?? []) {
+    const name = normalizeWorkerName(entry.worker ?? entry.name);
+    const owner = normalizeWorkerOwner(entry.owner ?? entry.owningCxx);
+    if (!name || !owner) continue;
+
+    const sourcePath = entry.skillPaths?.source ?? entry.skillPath ?? `.harness/shared/HR-Resource/${name}/SKILL.md`;
+    const sourceAbs = path.join(rootDir, sourcePath);
+    if (!existsSync(sourceAbs)) continue;
+
+    const key = `${owner}:${name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    hired.push({
+      name,
+      owner,
+      sourcePath,
+      mission: entry.mission ?? null,
+      task: entry.task ?? null,
+      capability: entry.capability ?? null,
+    });
+  }
+  return hired;
+}
+
+function hiredForMission(
+  hiredWorkers: HiredWorkerEntry[],
+  name: string,
+  owner: WorkerOwner,
+  missionId: string,
+): HiredWorkerEntry | undefined {
+  const candidates = hiredWorkers.filter(
+    (w) => w.name === name && (w.owner === owner || owner === "unknown")
+  );
+  return candidates.find((w) => w.mission === missionId) ?? candidates[0];
+}
+
+function workerDisplayName(content: string, hired: HiredWorkerEntry | undefined, fallback: string): string {
+  const title = content.match(/^\s*title:\s*["']?(.+?)["']?\s*$/m)?.[1]?.trim();
+  if (title) return truncateText(title.replace(/\s+—\s+Worker Report$/i, ""), 42);
+
+  const heading = content.match(/^#\s+(.+)$/m)?.[1]?.trim();
+  if (heading) return truncateText(heading.replace(/\s+—\s+.*$/i, ""), 42);
+
+  if (hired?.task) {
+    const capability = hired.capability ? ` · ${hired.capability}` : "";
+    return truncateText(`${hired.task}${capability}`, 42);
+  }
+
+  return fallback;
+}
+
+function activeWorkerNames(progress: RawProgress | null): Set<string> {
+  const active = new Set<string>();
+  const workers = [
+    ...(progress?.company_state?.workers ?? []),
+    ...(progress?.company_state?.last_dispatch ?? []),
+  ];
+  for (const worker of workers) {
+    const rawStatus = (worker.status ?? worker.spawn_status ?? "").toLowerCase();
+    if (["completed", "done", "idle"].includes(rawStatus)) continue;
+    for (const value of [worker.agent, worker.feature]) {
+      const normalized = normalizeWorkerName(value);
+      if (normalized) active.add(normalized);
+    }
+  }
+  return active;
+}
+
 function meetingTitleFromMarkdown(text: string, fallback: string): string {
   const heading = text.match(/^#\s+(.+)$/m)?.[1]?.trim();
   return heading || fallback;
@@ -989,6 +1103,8 @@ function buildRuntime(progress: RawProgress | null): RuntimeSnapshot {
 function readMissions(rootDir: string, progress: RawProgress | null = null, limit = 15): MissionDoc[] {
   const docsDir = path.join(rootDir, ".harness", "documents");
   if (!existsSync(docsDir)) return [];
+  const hiredWorkers = readHiredWorkers(rootDir);
+  const activeWorkers = activeWorkerNames(progress);
 
   const missionDirs: Array<{ rel: string; abs: string }> = [];
   const cxxDocNames = new Set(["ceo.md", "cto.md", "cqo.md", "coo.md", "cdo.md", "ops.md"]);
@@ -1035,20 +1151,39 @@ function readMissions(rootDir: string, progress: RawProgress | null = null, limi
       };
 
       const workers: WorkerDocEntry[] = [];
-      const addWorkersFromDir = (owner: WorkerDocEntry["owner"], relDir: string) => {
+      const workersByKey = new Map<string, WorkerDocEntry>();
+      const addWorkersFromDir = (owner: WorkerOwner, relDir: string) => {
         const workersDir = path.join(missionPath, relDir);
         if (!existsSync(workersDir)) return;
         try {
           for (const f of readdirSync(workersDir)) {
             if (!f.endsWith(".md")) continue;
+            const reportAbs = path.join(missionPath, relDir, f);
             const content = readMd(`${relDir}/${f}`) ?? "";
             const statusMatch = content.match(/##\s*Status\s*\n+([A-Z_]+)/);
-            workers.push({
-              name: f.replace(".md", ""),
+            const status = (statusMatch?.[1] as WorkerDocEntry["status"]) ?? "unknown";
+            const name = normalizeWorkerName(f);
+            const hired = hiredForMission(hiredWorkers, name, owner, rel);
+            let updatedAt: string | null = null;
+            let recentlyTouched = false;
+            try {
+              const mtime = statSync(reportAbs).mtime;
+              updatedAt = mtime.toISOString();
+              recentlyTouched = Date.now() - mtime.getTime() < RECENT_WORKER_ACTIVE_MS;
+            } catch { /* ignore */ }
+            const entry: WorkerDocEntry = {
+              name,
+              displayName: workerDisplayName(content, hired, name),
               content,
-              status: (statusMatch?.[1] as WorkerDocEntry["status"]) ?? "unknown",
-              owner,
-            });
+              status,
+              owner: hired?.owner ?? owner,
+              hired: !!hired,
+              active: activeWorkers.has(name) || (recentlyTouched && status !== "COMPLETE"),
+              sourcePath: hired?.sourcePath ?? null,
+              reportPath: path.relative(rootDir, reportAbs),
+              updatedAt,
+            };
+            workersByKey.set(`${entry.owner}:${entry.name}`, entry);
           }
         } catch { /* ignore */ }
       };
@@ -1060,6 +1195,25 @@ function readMissions(rootDir: string, progress: RawProgress | null = null, limi
       addWorkersFromDir("ops", "ops/workers");
       addWorkersFromDir("unknown", "workers");
 
+      for (const hired of hiredWorkers) {
+        const key = `${hired.owner}:${hired.name}`;
+        if (workersByKey.has(key)) continue;
+        workersByKey.set(key, {
+          name: hired.name,
+          displayName: workerDisplayName("", hired, hired.name),
+          content: "",
+          status: activeWorkers.has(hired.name) ? "IN_PROGRESS" : "unknown",
+          owner: hired.owner,
+          hired: true,
+          active: activeWorkers.has(hired.name),
+          sourcePath: hired.sourcePath,
+          reportPath: null,
+          updatedAt: null,
+        });
+      }
+
+      workers.push(...workersByKey.values());
+
       const cxxRoles = ["ceo", "cto", "cqo", "coo", "cdo", "ops"] as const;
       const cxxPresent = cxxRoles.filter(role => existsSync(path.join(missionPath, `${role}.md`)));
 

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

@@ -297,9 +297,15 @@ export interface HarnessSnapshot {
 // Real harness mission documents
 export interface WorkerDocEntry {
   name: string;
+  displayName: string;
   content: string;
   status: "COMPLETE" | "IN_PROGRESS" | "unknown";
   owner: "cto" | "cqo" | "coo" | "cdo" | "ops" | "unknown";
+  hired: boolean;
+  active: boolean;
+  sourcePath?: string | null;
+  reportPath?: string | null;
+  updatedAt?: string | null;
 }
 
 export interface MissionDoc {

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

@@ -10,9 +10,8 @@ export interface WatchOptions {
   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).
+// Watches .harness paths that affect the dashboard snapshot: runtime progress,
+// actions, mission documents, hired-worker roster/resources, and archive state.
 export function watchHarness(
   rootDir: string,
   onChange: (changedPath: string) => void,
@@ -25,6 +24,9 @@ export function watchHarness(
       path.join(harnessDir, "progress.json"),
       path.join(harnessDir, "progress.log"),
       path.join(harnessDir, "actions"),
+      path.join(harnessDir, "documents"),
+      path.join(harnessDir, "shared", "hr-roster.json"),
+      path.join(harnessDir, "shared", "HR-Resource"),
       path.join(harnessDir, "archive"),
     ],
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walwal-harness/cli",
-  "version": "7.1.19",
+  "version": "7.1.21",
   "description": "Company-style AI agent harness for Claude and Codex. Installs commands, CXX agents, skills, HR-Resource hiring pool, and project-local .harness runtime state.",
   "bin": {
     "walwal-harness": "bin/init.js"