@walwal-harness/cli 7.1.30 → 7.1.32

package/README.md

@@ -201,6 +201,7 @@ It also closes structured work state:
 - active/pending/paused todos in `.harness/todos/state.json` become `done`
 - active `mission-state.json` files become `{"lifecycle":"complete","active":false}`
 - the dashboard stops treating recent worker report mtimes as live activity after runtime completion
+- heatmap activity is persisted in `.harness/activity/YYYY-MM-DD.jsonl` and pruned after 7 days
 
 Existing users should update and migrate from the target project:
 
@@ -282,6 +283,7 @@ harness-hiring           → register and onboard worker
 
 | Version | Summary |
 |---|---|
+| 7.1.31 | Persist dashboard heatmap activity to 7-day JSONL logs, load persisted samples in the dashboard, and backfill activity during migrate from existing mission docs/progress logs |
 | 7.1.29 | Idempotent AGENTS/CLAUDE doc merge with marked harness sections, mission lifecycle backfill for init/migrate, completion closes todos and mission-state, and Layer Activity now lists CXX/worker rows sorted by remaining work |
 | 7.1.28 | Dashboard APM rewrite: top header consolidation, Knowledge Base panel (gotchas/conventions), Layer Activity (CEO/CXX/Worker TODO·DONE·Remain via goal-scope inference), Recent Report list (worker mtime desc), Cadence strip with click-to-prompt tooltip in local timezone, heatmap click-tooltip with empty-cell guard, Document Viewer expand-to-50vw with docmeta hidden, Command Log bubble popover |
 | 7.1.19 | `migrate` now carries OPS verification rules into existing installs: runtime.verification merge, HARNESS refresh, and AGENTS migration block |

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

@@ -60,7 +60,7 @@ type CxxRole = typeof CXX_ROLES[number];
 const WORKER_OWNERS = ["coo", "cdo", "cto", "cqo", "ops"] as const;
 type WorkerOwnerRole = typeof WORKER_OWNERS[number];
 const BUCKET_MS = 60_000;
-const VISIBLE_BUCKETS = 60;
+const VISIBLE_BUCKETS = 24 * 60;
 const LANE_LABEL_WIDTH = 110;
 const TIME_LABEL_HEIGHT = 18;
 const LANE_ROW_HEIGHT = 18;
@@ -117,7 +117,18 @@ export function Scene({ snapshot: initial, lang = "ko" }: SceneProps) {
   }, [snapshot.missions, selectedGoal]);
 
   const lanes = useMemo(() => buildLanes(snapshot, selectedMission), [selectedMission, snapshot]);
-  const sessionStartedAtRef = useRef(Date.now());
+  const heatmapStartedAt = useMemo(() => Date.now() - VISIBLE_BUCKETS * BUCKET_MS, [snapshot.ts]);
+  const persistedHeatSamples = useMemo<HeatSample[]>(
+    () =>
+      snapshot.activitySamples.map((sample) => ({
+        ts: Date.parse(sample.ts),
+        laneId: sample.laneId,
+        count: sample.count,
+        hotfix: sample.hotfix,
+        missionId: sample.missionId,
+      })).filter((sample) => Number.isFinite(sample.ts)),
+    [snapshot.activitySamples]
+  );
   const [heatSamples, setHeatSamples] = useState<HeatSample[]>([]);
   const sampleSourceRef = useRef({ lanes, snapshot, selectedMission });
   useEffect(() => {
@@ -148,20 +159,16 @@ export function Scene({ snapshot: initial, lang = "ko" }: SceneProps) {
         const activeMission = selectedMission ?? snapshot.missions[0] ?? null;
         const next: HeatSample[] = [];
         for (const lane of lanes) {
-          // 3-state activity:
-          //   0 = none        (not on this mission)
-          //   1 = standby     (participated / has output, no live work)
-          //   2 = in-progress (actively running right now)
+          // Live overlay records active work only. Historical participation is
+          // backfilled from persisted activity logs; completed reports must not
+          // keep repainting the current minute forever.
           let activity = 0;
           if (lane.kind === "worker") {
             const w = lane.worker;
             if (w) {
               if (w.active || w.status === "IN_PROGRESS") activity = 2;
-              else if (w.content || w.status === "COMPLETE") activity = 1;
             }
           } else {
-            const presentInMission =
-              lane.mission?.cxxPresent.includes(lane.role) ?? false;
             const liveTodos = snapshot.todos.filter(
               (t) =>
                 t.owner === lane.role &&
@@ -172,7 +179,7 @@ export function Scene({ snapshot: initial, lang = "ko" }: SceneProps) {
               (w) => w.active || w.status === "IN_PROGRESS"
             ).length;
             if (liveTodos > 0 && runningWorkers === 0) activity = 2;
-            else if (presentInMission || lane.workers.length > 0 || runningWorkers > 0) activity = 1;
+            else if (runningWorkers > 0) activity = 2;
           }
           if (activity <= 0) continue;
           next.push({
@@ -194,8 +201,8 @@ export function Scene({ snapshot: initial, lang = "ko" }: SceneProps) {
     return () => clearInterval(id);
   }, []);
   const { cells: heatmap, totalBuckets } = useMemo(
-    () => buildHeatmap(snapshot, lanes, heatSamples, sessionStartedAtRef.current),
-    [heatSamples, lanes, snapshot]
+    () => buildHeatmap(snapshot, lanes, [...persistedHeatSamples, ...heatSamples], heatmapStartedAt),
+    [heatSamples, heatmapStartedAt, lanes, persistedHeatSamples, snapshot]
   );
   const [selectedLaneId, setSelectedLaneId] = useState(lanes[0]?.id ?? "ceo");
   const [dragStart, setDragStart] = useState<{ x: number; y: number } | null>(null);

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

@@ -40,11 +40,13 @@ import type {
   WorkerDocEntry,
   WorkerSnapshot,
   CxxTodo,
+  ActivitySample,
 } from "./types";
 
 const SNAPSHOT_VERSION = "1.2.0";
 const GOAL_DESC_TRUNCATE = 200;
 const RECENT_WORKER_ACTIVE_MS = 10 * 60 * 1000;
+const ACTIVITY_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 
 interface RawProgress {
   goals?: {
@@ -230,6 +232,7 @@ function emptySnapshot(banner: ErrorBanner | null = null, rootDir?: string): Har
     conventions: [],
     todos: [],
     events: [],
+    activitySamples: [],
   };
 }
 
@@ -1516,6 +1519,36 @@ function readEvents(rootDir: string, limit = 40): HarnessEvent[] {
   }));
 }
 
+function readActivitySamples(rootDir: string): ActivitySample[] {
+  const activityDir = path.join(rootDir, ".harness", "activity");
+  if (!existsSync(activityDir)) return [];
+  const cutoff = Date.now() - ACTIVITY_RETENTION_MS;
+  const files = readdirSync(activityDir)
+    .filter((name) => /^\d{4}-\d{2}-\d{2}\.jsonl$/.test(name))
+    .sort()
+    .slice(-8);
+  const rows: ActivitySample[] = [];
+  for (const file of files) {
+    for (const raw of readJsonlTail<Record<string, unknown>>(path.join(activityDir, file), 100_000).reverse()) {
+      const ts = typeof raw.ts === "string" ? raw.ts : null;
+      const time = ts ? Date.parse(ts) : NaN;
+      if (!ts || !Number.isFinite(time) || time < cutoff) continue;
+      const laneId = typeof raw.laneId === "string" ? raw.laneId : null;
+      if (!laneId) continue;
+      const count = Math.max(0, Math.min(2, Number(raw.count ?? 0)));
+      if (count <= 0) continue;
+      rows.push({
+        ts,
+        laneId,
+        count,
+        hotfix: raw.hotfix === true,
+        missionId: typeof raw.missionId === "string" ? raw.missionId : null,
+      });
+    }
+  }
+  return rows.sort((a, b) => Date.parse(a.ts) - Date.parse(b.ts));
+}
+
 export function readHarnessState(rootDir: string): HarnessSnapshot {
   const harnessDir = path.join(rootDir, ".harness");
   if (!existsSync(harnessDir)) {
@@ -1548,6 +1581,7 @@ export function readHarnessState(rootDir: string): HarnessSnapshot {
     snapshot.conventions = readConventions(rootDir);
     snapshot.todos = readTodos(rootDir);
     snapshot.events = readEvents(rootDir);
+    snapshot.activitySamples = readActivitySamples(rootDir);
     return snapshot;
   }
 
@@ -1603,6 +1637,7 @@ export function readHarnessState(rootDir: string): HarnessSnapshot {
     conventions: readConventions(rootDir),
     todos: readTodos(rootDir),
     events: readEvents(rootDir),
+    activitySamples: readActivitySamples(rootDir),
   };
 }
 

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

@@ -295,6 +295,15 @@ export interface HarnessSnapshot {
   conventions: ConventionEntry[];
   todos: CxxTodo[];
   events: HarnessEvent[];
+  activitySamples: ActivitySample[];
+}
+
+export interface ActivitySample {
+  ts: string;
+  laneId: string;
+  count: number;
+  hotfix: boolean;
+  missionId: string | null;
 }
 
 export interface CxxTodo {

package/bin/init.js

@@ -941,6 +941,20 @@ function refreshScriptsForMigrate({ dryRun = false, backupDir = null } = {}) {
   chmodShellScripts(scriptsDest);
 }
 
+function migrateActivityHistory({ dryRun = false } = {}) {
+  const recorder = path.join(PROJECT_ROOT, 'scripts', 'harness-activity-record.js');
+  if (!fs.existsSync(recorder)) return;
+  log('  activity/: legacy documents/progress.log → 7-day heatmap JSONL backfill');
+  if (dryRun) return;
+  try {
+    execSync(`node ${JSON.stringify(recorder)} ${JSON.stringify(PROJECT_ROOT)} --migrate`, {
+      stdio: 'ignore',
+    });
+  } catch {
+    log('  activity/: backfill skipped (node recorder failed)');
+  }
+}
+
 // ─────────────────────────────────────────
 // 3a. Commands → .claude/commands/
 // ─────────────────────────────────────────
@@ -1996,6 +2010,7 @@ function runMigrate(opts = {}) {
   // Runtime scripts are package-owned. Migrate must refresh them so existing
   // projects receive wake/meeting/OPS fixes without requiring a full init.
   refreshScriptsForMigrate({ dryRun, backupDir });
+  migrateActivityHistory({ dryRun });
   updateRuleRegistryLinks(flags.ruleRegistryLinks || [], { dryRun, backupDir });
 
   // 1. progress.json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walwal-harness/cli",
-  "version": "7.1.30",
+  "version": "7.1.32",
   "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"

package/scripts/conductor-tick.sh

@@ -656,6 +656,10 @@ fi
 
 set_progress "$filter"
 
+if command -v node >/dev/null 2>&1 && [ -f "$SCRIPT_DIR/harness-activity-record.js" ]; then
+  node "$SCRIPT_DIR/harness-activity-record.js" "$PROJECT_ROOT" >/dev/null 2>&1 || true
+fi
+
 if [ "$meeting_prepare" = true ] && [ "$next" = "meeting-manager" ]; then
   bash "$SCRIPT_DIR/harness-meeting-doc.sh" "$PROJECT_ROOT" prepare >/dev/null 2>&1 || true
 fi

package/scripts/harness-activity-record.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const RETENTION_MS = 7 * DAY_MS;
+const RECENT_MS = 10 * 60 * 1000;
+const CXX_ROLES = ["ceo", "coo", "cdo", "cto", "cqo", "ops"];
+const WORKER_OWNERS = ["coo", "cdo", "cto", "cqo", "ops"];
+const TERMINAL_LIFECYCLES = new Set(["closed", "cancelled", "superseded", "complete"]);
+
+function readJson(filePath, fallback = null) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function readText(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function walk(dir) {
+  const out = [];
+  if (!fs.existsSync(dir)) return out;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...walk(p));
+    else out.push(p);
+  }
+  return out;
+}
+
+function isoDay(ts) {
+  return new Date(ts).toISOString().slice(0, 10);
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function pruneActivity(activityDir, now = Date.now()) {
+  if (!fs.existsSync(activityDir)) return;
+  for (const entry of fs.readdirSync(activityDir)) {
+    if (!/^\d{4}-\d{2}-\d{2}\.jsonl$/.test(entry)) continue;
+    const day = entry.slice(0, 10);
+    const cutoff = Date.parse(`${day}T23:59:59.999Z`);
+    if (Number.isFinite(cutoff) && now - cutoff > RETENTION_MS) {
+      fs.rmSync(path.join(activityDir, entry), { force: true });
+    }
+  }
+}
+
+function parseLifecycle(missionDir) {
+  const state = readJson(path.join(missionDir, "mission-state.json"), null);
+  const lifecycle = typeof state?.lifecycle === "string" ? state.lifecycle : "unknown";
+  return { lifecycle, active: state?.active === true || lifecycle === "active" };
+}
+
+function collectMissions(root) {
+  const docsDir = path.join(root, ".harness", "documents");
+  if (!fs.existsSync(docsDir)) return [];
+  const dirs = [];
+  const visit = (dir) => {
+    if (fs.existsSync(path.join(dir, "ceo.md")) || fs.existsSync(path.join(dir, "mission-state.json"))) {
+      dirs.push(dir);
+    }
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && !["workers", "archive"].includes(entry.name)) visit(path.join(dir, entry.name));
+    }
+  };
+  visit(docsDir);
+  return dirs.map((dir) => {
+    const rel = path.relative(docsDir, dir);
+    const state = parseLifecycle(dir);
+    const cxxPresent = CXX_ROLES.filter((role) => fs.existsSync(path.join(dir, `${role}.md`)));
+    const workers = [];
+    for (const owner of WORKER_OWNERS) {
+      const workerDir = path.join(dir, owner, "workers");
+      for (const file of walk(workerDir).filter((p) => p.endsWith(".md"))) {
+        const content = readText(file);
+        const stat = fs.statSync(file);
+        const name = path.basename(file, ".md");
+        const complete = /(^|\n)(status:\s*COMPLETE|##\s*Status\s*\n\s*COMPLETE)\b/i.test(content);
+        workers.push({
+          owner,
+          name,
+          laneId: `${owner}:${name}`,
+          content,
+          complete,
+          updatedAt: stat.mtimeMs,
+        });
+      }
+    }
+    return {
+      missionId: rel,
+      dir,
+      lifecycle: state.lifecycle,
+      active: state.active,
+      cxxPresent,
+      workers,
+      mtimeMs: fs.statSync(dir).mtimeMs,
+    };
+  });
+}
+
+function readTodos(root) {
+  const state = readJson(path.join(root, ".harness", "todos", "state.json"), {});
+  const owners = state?.owners && typeof state.owners === "object" ? state.owners : {};
+  return Object.entries(owners).flatMap(([owner, items]) =>
+    Array.isArray(items)
+      ? items.map((item) => ({ ...item, owner }))
+      : []
+  );
+}
+
+function runtimeIdle(root) {
+  const p = readJson(path.join(root, ".harness", "progress.json"), {});
+  return (
+    p?.agent_status === "completed" ||
+    p?.agent_status === "complete" ||
+    ((p?.current_agent ?? null) === null && (p?.next_agent === null || p?.next_agent === "none"))
+  );
+}
+
+function currentSamples(root, now = Date.now()) {
+  const missions = collectMissions(root);
+  const active = missions.find((m) => m.active) ?? missions.sort((a, b) => b.mtimeMs - a.mtimeMs)[0] ?? null;
+  if (!active) return [];
+  const todos = readTodos(root);
+  const idle = runtimeIdle(root);
+  const samples = [];
+  for (const role of CXX_ROLES) {
+    const workers = active.workers.filter((w) => w.owner === role);
+    const runningWorkers = workers.filter((w) => !idle && !w.complete && now - w.updatedAt < RECENT_MS);
+    const liveTodos = todos.filter((t) => t.owner === role && !["done", "completed"].includes(String(t.status)));
+    let count = 0;
+    if (!idle && liveTodos.length > 0 && runningWorkers.length === 0) count = 2;
+    else if (runningWorkers.length > 0) count = 2;
+    if (count > 0) samples.push({ ts: new Date(now).toISOString(), laneId: role, count, hotfix: active.missionId.includes("hotfix"), missionId: active.missionId });
+  }
+  for (const worker of active.workers) {
+    const count = !idle && !worker.complete && now - worker.updatedAt < RECENT_MS ? 2 : 0;
+    if (count > 0) samples.push({ ts: new Date(now).toISOString(), laneId: worker.laneId, count, hotfix: active.missionId.includes("hotfix"), missionId: active.missionId });
+  }
+  return samples;
+}
+
+function legacySamples(root) {
+  const now = Date.now();
+  const samples = [];
+  for (const mission of collectMissions(root)) {
+    const terminal = TERMINAL_LIFECYCLES.has(mission.lifecycle);
+    for (const role of mission.cxxPresent.filter((r) => CXX_ROLES.includes(r))) {
+      const file = path.join(mission.dir, `${role}.md`);
+      const ts = fs.existsSync(file) ? fs.statSync(file).mtimeMs : mission.mtimeMs;
+      if (now - ts <= RETENTION_MS) {
+        samples.push({ ts: new Date(ts).toISOString(), laneId: role, count: terminal ? 1 : 2, hotfix: mission.missionId.includes("hotfix"), missionId: mission.missionId });
+      }
+    }
+    for (const worker of mission.workers) {
+      if (now - worker.updatedAt <= RETENTION_MS) {
+        samples.push({ ts: new Date(worker.updatedAt).toISOString(), laneId: worker.laneId, count: worker.complete || terminal ? 1 : 2, hotfix: mission.missionId.includes("hotfix"), missionId: mission.missionId });
+      }
+    }
+  }
+  const progressLog = path.join(root, ".harness", "progress.log");
+  for (const line of readText(progressLog).split("\n")) {
+    const m = line.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z).*\b(ceo|coo|cdo|cto|cqo|ops)\b/i);
+    if (!m) continue;
+    const ts = Date.parse(m[1]);
+    if (Number.isFinite(ts) && now - ts <= RETENTION_MS) {
+      samples.push({ ts: new Date(ts).toISOString(), laneId: m[2].toLowerCase(), count: 1, hotfix: /hot-?fix/i.test(line), missionId: null });
+    }
+  }
+  return samples;
+}
+
+function appendSamples(root, samples) {
+  if (samples.length === 0) return;
+  const activityDir = path.join(root, ".harness", "activity");
+  ensureDir(activityDir);
+  const byDay = new Map();
+  for (const sample of samples) {
+    const day = isoDay(Date.parse(sample.ts));
+    if (!byDay.has(day)) byDay.set(day, []);
+    byDay.get(day).push(sample);
+  }
+  for (const [day, rows] of byDay) {
+    fs.appendFileSync(path.join(activityDir, `${day}.jsonl`), rows.map((r) => JSON.stringify(r)).join("\n") + "\n");
+  }
+  pruneActivity(activityDir);
+}
+
+function main() {
+  const root = path.resolve(process.argv[2] || ".");
+  const mode = process.argv.includes("--migrate") ? "migrate" : "sample";
+  if (!fs.existsSync(path.join(root, ".harness"))) return;
+  appendSamples(root, mode === "migrate" ? legacySamples(root) : currentSamples(root));
+}
+
+main();

package/scripts/harness-company-complete.sh

@@ -70,4 +70,8 @@ if [ -d "$DOCS" ]; then
   done
 fi
 
+if command -v node >/dev/null 2>&1 && [ -f "$SCRIPT_DIR/harness-activity-record.js" ]; then
+  node "$SCRIPT_DIR/harness-activity-record.js" "$PROJECT_ROOT" >/dev/null 2>&1 || true
+fi
+
 echo "[company-complete] marked complete: $REASON"