@mikenguyen69/harness 0.1.0-beta.1

package/dist/internal/system/board/index.js

@@ -0,0 +1,276 @@
+/** Lane `activity_at` older than this renders muted as "quiet for <age>" (own freshness, not run heartbeat). */
+export const ACTIVITY_QUIET_THRESHOLD_MS = 60_000;
+/** "3m" / "1h 4m" from a ms age — for the "machine silent since …" label. */
+function humanAge(ms) {
+    if (ms < 0)
+        return "unknown";
+    const m = Math.floor(ms / 60_000);
+    if (m < 60)
+        return `${m}m`;
+    return `${Math.floor(m / 60)}h ${m % 60}m`;
+}
+function runPanel(overlay) {
+    if (!overlay || overlay.runs.length === 0) {
+        return { title: "Runs — live overlay", status: "insufficient-data", data: [] };
+    }
+    const data = overlay.runs.map((r) => {
+        const d = r.document;
+        const counts = (d.counts ?? {});
+        const needs = (d.needs_you ?? []).map((n) => {
+            const kind = String(n.kind ?? "");
+            const unitId = n.unit_id ? String(n.unit_id) : null;
+            return {
+                kind,
+                unit_id: unitId,
+                message: String(n.message ?? ""),
+                unblock: String(n.unblock ?? ""),
+                door_anchor: /door/i.test(kind) && unitId ? `#door-${unitId}` : null,
+            };
+        });
+        const lanes = (d.lanes ?? []).map((l) => {
+            const lane = {
+                unit_id: String(l.unit_id ?? ""),
+                step: String(l.step ?? ""),
+                runner: String(l.runner ?? ""),
+                model: String(l.model ?? ""),
+                attempt: Number(l.attempt ?? 1),
+                retry_budget: Number(l.retry_budget ?? 0),
+                cost: Number(l.cost ?? 0),
+                reconstructed: l.emitter === "orchestrator",
+            };
+            if (l.activity !== undefined)
+                lane.activity = String(l.activity);
+            if (l.activity_at !== undefined)
+                lane.activity_at = String(l.activity_at);
+            if (l.turn !== undefined)
+                lane.turn = Number(l.turn);
+            if (l.tokens !== undefined) {
+                const t = l.tokens;
+                if (t.in !== undefined && t.out !== undefined) {
+                    lane.tokens = { in: Number(t.in), out: Number(t.out) };
+                }
+            }
+            if (l.recent !== undefined) {
+                lane.recent = l.recent.map((r) => String(r));
+            }
+            return lane;
+        });
+        return {
+            machine_id: r.machine_id,
+            run_id: r.run_id,
+            system_id: String(d.system_id ?? ""),
+            spec_ref: String(d.spec_ref ?? ""),
+            liveness: r.liveness === "stale" ? "stale" : "live",
+            silent_for: r.liveness === "stale" ? humanAge(r.heartbeat_age_ms) : null,
+            merged: Number(counts.merged ?? 0),
+            dag_size: Number(counts.dag_size ?? 0),
+            needs_you: needs,
+            lanes,
+        };
+    });
+    return { title: "Runs — live overlay", status: "ok", data };
+}
+export function buildBoard(p, now = new Date().toISOString(), overlay) {
+    const merged = p.counts.units["merged"] ?? 0;
+    const totalCost = p.sessions.reduce((s, x) => s + x.costUsd, 0);
+    const modelForUnit = new Map();
+    for (const s of p.sessions)
+        if (s.unit)
+            modelForUnit.set(s.unit, s.model);
+    const lanes = {};
+    for (const u of p.units) {
+        const comp = u.component ?? "(unassigned)";
+        (lanes[comp] ??= []).push({
+            id: u.id,
+            state: u.state,
+            model: modelForUnit.get(`${comp}#${u.id}`) ?? null,
+        });
+    }
+    const panel = (title, empty, data) => ({
+        title,
+        status: empty ? "insufficient-data" : "ok",
+        data,
+    });
+    return {
+        system: p.system,
+        generatedAt: now,
+        panels: {
+            portfolioPulse: panel("Portfolio pulse", p.counts.events === 0, {
+                units: p.counts.units,
+                doorsOpen: p.counts.doorsOpen,
+                systemHalts: p.counts.systemHalts,
+                escapes: p.counts.escapes,
+                costPerMergedUnit: merged > 0 ? Number((totalCost / merged).toFixed(2)) : null,
+            }),
+            doorsQueue: panel("Doors — your queue", p.doors.filter((d) => d.state === "opened").length === 0, p.doors
+                .filter((d) => d.state === "opened")
+                .sort((a, b) => Date.parse(a.openedAt) - Date.parse(b.openedAt))
+                .map((d) => ({
+                id: d.id,
+                unitId: d.unitId,
+                classes: d.classes,
+                openedAt: d.openedAt,
+            }))),
+            systemLanes: panel("Systems — in-flight by component", p.units.length === 0, lanes),
+            escapeFeed: panel("Escape feed → corpus", p.escapes.length === 0, p.escapes),
+            fleet: panel("Agent fleet", p.sessions.length === 0, p.sessions.map((s) => ({
+                id: s.id,
+                unit: s.unit,
+                model: s.model,
+                costUsd: Number(s.costUsd.toFixed(2)),
+            }))),
+            calibrationStrip: panel("Calibration — pending proposals", true, []),
+            runs: runPanel(overlay),
+            runAnalysis: panel("Run analysis", p.runAnalyses.every((r) => r.findings.length === 0), p.runAnalyses.flatMap((r) => r.findings.map((f) => ({
+                id: `${r.runId}:${f.unitId}:${f.rule}`,
+                runId: r.runId,
+                unitId: f.unitId,
+                rule: f.rule,
+                severity: f.severity,
+                count: f.count,
+            })))),
+        },
+    };
+}
+/** A single self-contained HTML page embedding the board data + a tiny renderer. */
+export function renderBoardHtml(board) {
+    const json = JSON.stringify(board, null, 2).replace(/</g, "\\u003c");
+    return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>Operations Board — ${board.system ?? "harness"}</title>
+<style>
+  :root{color-scheme:light dark}
+  body{font:14px/1.5 ui-sans-serif,system-ui,sans-serif;margin:0;padding:24px;background:#0e1216;color:#e5e9ee}
+  h1{font-size:1.3rem;margin:0 0 4px} .sub{color:#9aa4b1;margin-bottom:20px;font-size:.85rem}
+  .grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(280px,1fr));gap:14px}
+  /* P7.3 — the live-runs strip spans the full width, above the auto-fit grid. */
+  .strip{margin-bottom:14px}
+  .strip .panel{padding:14px 16px}
+  .runlist{display:flex;flex-wrap:wrap;gap:12px}
+  .runlist>.run{flex:1 1 340px;min-width:300px;border:1px solid #222a33;border-radius:8px;padding:8px 10px;background:#12181e}
+  .panel{border:1px solid #2a333d;border-radius:10px;background:#161c22;padding:14px 16px}
+  .panel h2{font-size:.8rem;letter-spacing:.08em;text-transform:uppercase;color:#9aa4b1;margin:0 0 10px}
+  .insufficient{color:#6b7583;font-style:italic}
+  .kv{display:flex;justify-content:space-between;border-bottom:1px solid #222a33;padding:3px 0}
+  .kv:last-child{border:0}
+  code{font-family:ui-monospace,monospace;font-size:.82em;color:#5bb8d4}
+  .chip{display:inline-block;font-family:ui-monospace,monospace;font-size:.72rem;border:1px solid #3b4653;border-radius:99px;padding:1px 7px;margin:2px 3px 0 0}
+  .lane-act{color:#9aa4b1;font-size:.78rem;margin-left:4px}.lane-act.quiet{color:#6b7583;font-style:italic}
+  .lane-log{display:block;margin-top:3px;font-family:ui-monospace,monospace;font-size:.78rem;color:#c3ccd6}
+  .log-line{overflow-wrap:anywhere;padding:1px 0}
+  .log-verb{color:#6b7583;margin-right:5px}
+</style></head>
+<body>
+<h1>Operations Board</h1>
+<div class="sub">system: <code>${board.system ?? "—"}</code> · generated ${board.generatedAt}</div>
+<section class="strip" id="runs-strip"></section>
+<div class="grid" id="root"></div>
+<script id="data" type="application/json">${json}</script>
+<script>
+const B = JSON.parse(document.getElementById('data').textContent);
+const root = document.getElementById('root');
+const strip = document.getElementById('runs-strip');
+const esc = s => String(s).replace(/[&<>]/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;'}[c]));
+const ACTIVITY_QUIET_THRESHOLD_MS = ${ACTIVITY_QUIET_THRESHOLD_MS};
+function humanAge(ms) {
+  if (ms < 0) return 'unknown';
+  const m = Math.floor(ms / 60_000);
+  if (m < 60) return m + 'm';
+  return Math.floor(m / 60) + 'h ' + (m % 60) + 'm';
+}
+function laneHasActivity(l) {
+  return 'activity' in l || 'activity_at' in l || 'turn' in l || 'tokens' in l || 'recent' in l;
+}
+function laneActivityHtml(l, run, nowMs) {
+  // Lane freshness and run liveness are different questions — a lane can be
+  // actively streaming activity while its run's heartbeat hasn't ticked in a
+  // while (long implement steps). Gauge quiet/fresh from the lane's own
+  // activity_at, never from run.liveness.
+  if (!laneHasActivity(l)) return '';
+  let line = '';
+  if ('activity_at' in l || 'activity' in l) {
+    const atMs = l.activity_at ? Date.parse(l.activity_at) : NaN;
+    const ageMs = Number.isFinite(atMs) ? nowMs - atMs : 0;
+    if (Number.isFinite(atMs) && ageMs > ACTIVITY_QUIET_THRESHOLD_MS) {
+      line = '<span class="lane-act quiet">quiet for ' + esc(humanAge(ageMs)) + '</span>';
+    } else if ('activity' in l) {
+      line = '<span class="lane-act">' + esc(l.activity) + '</span>';
+    }
+  }
+  const meta = [];
+  if ('turn' in l) meta.push('turn ' + esc(l.turn));
+  // a runner that reports no usage (cursor) always carries {in:0,out:0} —
+  // showing "0/0" on every lane is noise, not signal.
+  if ('tokens' in l && (l.tokens.in || l.tokens.out)) meta.push(esc(l.tokens.in) + '/' + esc(l.tokens.out));
+  const metaHtml = meta.length ? '<span class="lane-act">' + meta.join(' · ') + '</span>' : '';
+  // newest first — recent is pushed oldest→newest, so read it back to front.
+  const recentHtml = ('recent' in l && l.recent.length)
+    ? '<div class="lane-log">' + l.recent.slice().reverse().map(renderLogLine).join('') + '</div>'
+    : '';
+  return line + metaHtml + recentHtml;
+}
+/** "verb: target" renders with a dimmed verb and a bright target — a log line, not a status pill. */
+function renderLogLine(text) {
+  const m = /^([A-Za-z][\\w-]*): ([\\s\\S]*)$/.exec(text);
+  if (!m) return '<div class="log-line">' + esc(text) + '</div>';
+  return '<div class="log-line"><span class="log-verb">' + esc(m[1]) + '</span> ' + esc(m[2]) + '</div>';
+}
+for (const [key, p] of Object.entries(B.panels)) {
+  // the runs section is a full-width strip ABOVE the grid, never a grid cell.
+  const host = key === 'runs' ? strip : root;
+  const el = document.createElement('div'); el.className = 'panel';
+  let inner = '<h2>' + esc(p.title) + '</h2>';
+  if (p.status === 'insufficient-data') inner += '<div class="insufficient">insufficient data</div>';
+  else inner += render(key, p.data);
+  el.innerHTML = inner; host.appendChild(el);
+}
+if (!strip.hasChildNodes()) strip.remove();
+function render(key, d) {
+  if (key === 'portfolioPulse') return Object.entries({
+    ...d.units, 'doors open': d.doorsOpen, 'system halts': d.systemHalts,
+    'escapes': d.escapes, '$/merged unit': d.costPerMergedUnit ?? 'n/a'
+  }).map(([k,v]) => '<div class="kv"><span>'+esc(k)+'</span><code>'+esc(v)+'</code></div>').join('');
+  if (key === 'systemLanes') return Object.entries(d).map(([c, units]) =>
+    '<div class="kv"><span><code>'+esc(c)+'</code></span><span>'+units.map(u=>'<span class="chip" id="unit-'+esc(u.id)+'">'+esc(u.id)+' · '+esc(u.state)+'</span>').join('')+'</span></div>').join('');
+  if (key === 'runs') return '<div class="runlist">' + d.map(r => {
+    const head = '<div class="kv"><span><code>'+esc(r.machine_id)+' / '+esc(r.run_id)+'</code> '
+      + (r.liveness === 'stale'
+          ? '<span class="chip" style="border-color:#7a5b2e;color:#e0b062">stale — machine silent '+esc(r.silent_for)+'</span>'
+          : '<span class="chip" style="border-color:#2e7a4b;color:#62e0a0">live</span>')
+      + '</span><code>'+esc(r.merged)+'/'+esc(r.dag_size)+' merged</code></div>';
+    const nowMs = Date.parse(B.generatedAt);
+    const lanes = r.lanes.map(l => '<div class="kv"><span id="unit-'+esc(l.unit_id)+'">'
+      + '<code>'+esc(l.unit_id)+'</code> '+esc(l.step)
+      + ' <span class="chip">'+esc(l.runner)+' · '+esc(l.model)+'</span>'
+      + (l.reconstructed ? ' <span class="chip" style="border-color:#555;color:#9aa4b1">reconstructed</span>' : '')
+      + laneActivityHtml(l, r, nowMs)
+      + '</span><code>#'+esc(l.attempt)+'/'+esc(l.retry_budget+1)+' · $'+esc(l.cost.toFixed ? l.cost.toFixed(2) : l.cost)+'</code></div>').join('');
+    const needs = r.needs_you.map(n => '<div class="kv"><span>'
+      + '<span class="chip" style="border-color:#7a3b3b;color:#e79a9a">'+esc(n.kind)+'</span> '
+      + (n.door_anchor ? '<a href="'+esc(n.door_anchor)+'">'+esc(n.unit_id||'')+'</a>' : esc(n.unit_id||''))
+      + ' — '+esc(n.message)+'</span><code>'+esc(n.unblock)+'</code></div>').join('');
+    return '<div class="run">' + head + lanes + (needs ? '<div class="kv"><span>needs you</span></div>'+needs : '') + '</div>';
+  }).join('') + '</div>';
+  // doors + fleet render typed fields — never a raw JSON blob (G2.2).
+  if (key === 'doorsQueue') {
+    if (d.length === 0) return '<div class="insufficient">none</div>';
+    return d.map(row => '<div class="kv" id="door-'+esc(row.unitId)+'"><span><code>'+esc(row.id)+'</code> · '+esc(row.unitId)
+      + ' · <span class="chip">'+(row.classes||[]).map(esc).join('</span><span class="chip">')+'</span></span>'
+      + '<code>'+esc(row.openedAt)+'</code></div>').join('');
+  }
+  if (key === 'fleet') {
+    if (d.length === 0) return '<div class="insufficient">none</div>';
+    return d.map(row => '<div class="kv"><span><code>'+esc(row.id)+'</code> · '+esc(row.unit || '—')
+      + ' · '+esc(row.model || '—')+'</span><code>$'+esc(Number(row.costUsd ?? 0).toFixed(2))+'</code></div>').join('');
+  }
+  if (Array.isArray(d)) {
+    if (d.length === 0) return '<div class="insufficient">none</div>';
+    return d.map(row => '<div class="kv"><span>'+esc(row.id || row.scenario || row.unitId || '')+'</span><code>'
+      + esc(Object.entries(row).filter(([k])=>k!=='id').map(([k,v])=>k+'='+(Array.isArray(v)?v.join('|'):v)).join(' · '))+'</code></div>').join('');
+  }
+  return '<pre>'+esc(JSON.stringify(d,null,1))+'</pre>';
+}
+</script>
+</body></html>
+`;
+}
+//# sourceMappingURL=index.js.map

package/dist/internal/system/board/live.js

@@ -0,0 +1,277 @@
+/** Live, local-only operations dashboard over every initialized harness repo. */
+import { createServer } from "node:http";
+import { basename, join, resolve } from "node:path";
+import { existsSync, readdirSync } from "node:fs";
+import { buildBoard, ACTIVITY_QUIET_THRESHOLD_MS } from "./index.js";
+import { project, projectLedger } from "../hub/index.js";
+import { projectRuns } from "../runstatus/index.js";
+const SKIP_DIRS = new Set([
+    ".git", ".harness", ".worktrees", ".dry-run", "node_modules", "dist",
+    "coverage", "docs", "test", "tests", "e2e", "fixture", "fixtures", "examples",
+]);
+export function discoverHarnessRepositories(roots) {
+    const found = new Map();
+    const visit = (dir, isRoot) => {
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        const names = new Set(entries.map((entry) => entry.name));
+        const manifest = names.has("system.toml")
+            ? "system.toml"
+            : names.has("component.toml")
+                ? "component.toml"
+                : undefined;
+        if (manifest) {
+            const root = resolve(dir);
+            found.set(root.toLowerCase(), {
+                name: basename(root),
+                root,
+                ledgerDir: join(root, ".harness", "ledger"),
+                spoolDir: join(root, ".harness", "spool"),
+                manifest,
+            });
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (SKIP_DIRS.has(entry.name) && !isRoot)
+                continue;
+            if (SKIP_DIRS.has(entry.name))
+                continue;
+            visit(join(dir, entry.name), false);
+        }
+    };
+    for (const root of roots.map((path) => resolve(path)))
+        visit(root, true);
+    return [...found.values()].sort((a, b) => a.name.localeCompare(b.name) || a.root.localeCompare(b.root));
+}
+export function buildLiveDashboard(roots) {
+    const sources = discoverHarnessRepositories(roots);
+    const repositories = sources.map((source) => {
+        try {
+            const projection = projectLedger(source.ledgerDir);
+            const overlay = existsSync(source.spoolDir) ? projectRuns(source.spoolDir) : undefined;
+            const board = buildBoard(projection, new Date().toISOString(), overlay);
+            return {
+                name: source.name,
+                root: source.root,
+                manifest: source.manifest,
+                system: projection.system ?? source.name,
+                status: projection.counts.events > 0 || (overlay?.runs.length ?? 0) > 0 ? "active" : "no-data",
+                events: projection.counts.events,
+                board,
+            };
+        }
+        catch (error) {
+            return {
+                name: source.name,
+                root: source.root,
+                manifest: source.manifest,
+                system: source.name,
+                status: "error",
+                error: error.message,
+                events: 0,
+                board: buildBoard(project([])),
+            };
+        }
+    });
+    const units = (state) => repositories.reduce((total, repo) => total + (repo.board.panels.portfolioPulse.data.units[state] ?? 0), 0);
+    return {
+        generatedAt: new Date().toISOString(),
+        roots: roots.map((path) => resolve(path)),
+        summary: {
+            repositories: repositories.length,
+            repositoriesWithData: repositories.filter((repo) => repo.status === "active").length,
+            events: repositories.reduce((total, repo) => total + repo.events, 0),
+            planned: units("planned"),
+            executing: units("executing"),
+            inReview: units("in-review"),
+            merged: units("merged"),
+            doorsOpen: repositories.reduce((total, repo) => total + repo.board.panels.portfolioPulse.data.doorsOpen, 0),
+            // "active" means live — a stale run (silent past the threshold) is not
+            // work happening right now, and counting it alongside live runs made
+            // the headline number describe mostly zombies.
+            activeRuns: repositories.reduce((total, repo) => total + repo.board.panels.runs.data.filter((r) => r.liveness === "live").length, 0),
+            needsYou: repositories.reduce((total, repo) => total + repo.board.panels.runs.data.reduce((n, run) => n + run.needs_you.length, 0), 0),
+        },
+        repositories,
+    };
+}
+export async function startBoardServer(opts) {
+    const host = opts.host ?? "127.0.0.1";
+    if (!["127.0.0.1", "::1", "localhost"].includes(host)) {
+        throw new Error(`board serve is local-only; refusing host ${host}`);
+    }
+    const roots = opts.roots.map((path) => resolve(path));
+    const clients = new Set();
+    const dashboard = () => buildLiveDashboard(roots);
+    const server = createServer((request, response) => {
+        const url = new URL(request.url ?? "/", `http://${host}`);
+        if (request.method !== "GET")
+            return send(response, 405, "text/plain; charset=utf-8", "method not allowed\n");
+        if (url.pathname === "/health")
+            return send(response, 200, "text/plain; charset=utf-8", "ok\n");
+        if (url.pathname === "/api/dashboard") {
+            return send(response, 200, "application/json; charset=utf-8", JSON.stringify(dashboard()));
+        }
+        if (url.pathname === "/events") {
+            response.writeHead(200, {
+                "content-type": "text/event-stream; charset=utf-8",
+                "cache-control": "no-cache, no-transform",
+                connection: "keep-alive",
+                "x-content-type-options": "nosniff",
+            });
+            response.write(`event: dashboard\ndata: ${JSON.stringify(dashboard())}\n\n`);
+            clients.add(response);
+            request.on("close", () => clients.delete(response));
+            return;
+        }
+        if (url.pathname === "/" || url.pathname === "/index.html") {
+            return send(response, 200, "text/html; charset=utf-8", LIVE_BOARD_HTML);
+        }
+        if (url.pathname === "/favicon.ico")
+            return send(response, 204, "image/x-icon", "");
+        return send(response, 404, "text/plain; charset=utf-8", "not found\n");
+    });
+    const timer = setInterval(() => {
+        if (!clients.size)
+            return;
+        const message = `event: dashboard\ndata: ${JSON.stringify(dashboard())}\n\n`;
+        for (const client of clients)
+            client.write(message);
+    }, opts.refreshMs ?? 2_000);
+    timer.unref();
+    await new Promise((accept, reject) => {
+        server.once("error", reject);
+        server.listen(opts.port ?? 4317, host, () => accept());
+    });
+    const address = server.address();
+    const port = typeof address === "object" && address ? address.port : opts.port ?? 4317;
+    return {
+        url: `http://${host === "::1" ? "[::1]" : host}:${port}/`,
+        close: () => new Promise((accept, reject) => {
+            clearInterval(timer);
+            for (const client of clients)
+                client.end();
+            server.close((error) => error ? reject(error) : accept());
+        }),
+    };
+}
+function send(response, status, type, body) {
+    response.writeHead(status, {
+        "content-type": type,
+        "cache-control": "no-store",
+        "x-content-type-options": "nosniff",
+        "content-security-policy": "default-src 'self'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'self'",
+    });
+    response.end(body);
+}
+export const LIVE_BOARD_HTML = `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Harness Operations</title><style>
+:root{color-scheme:dark;--bg:#0a0d0c;--panel:#111614;--line:#26302b;--muted:#84918a;--text:#edf3ef;--green:#79e6a4;--amber:#efc56b;--red:#ff8b83;--cyan:#72d8d0}
+*{box-sizing:border-box}body{margin:0;background:radial-gradient(circle at 70% -10%,#163028 0,transparent 32rem),var(--bg);color:var(--text);font:14px/1.45 Inter,ui-sans-serif,system-ui,sans-serif}
+main{width:min(1480px,calc(100% - 32px));margin:auto;padding:28px 0 60px}header{display:flex;align-items:end;justify-content:space-between;gap:20px;margin-bottom:24px}h1{font-size:clamp(24px,4vw,42px);letter-spacing:-.045em;margin:0}.eyebrow{color:var(--green);font:700 11px ui-monospace,monospace;letter-spacing:.18em;text-transform:uppercase}.meta{color:var(--muted);text-align:right}.live{display:inline-flex;gap:7px;align-items:center;color:var(--green)}.live:before{content:"";width:7px;height:7px;border-radius:50%;background:currentColor;box-shadow:0 0 12px currentColor}.live.paused{color:var(--amber)}.live.paused:before{animation:none}
+.toolbar{display:flex;gap:10px;align-items:center;justify-content:flex-end}.pause-btn{font:11px ui-monospace,monospace;letter-spacing:.04em;color:var(--muted);background:transparent;border:1px solid var(--line);border-radius:99px;padding:3px 10px;cursor:pointer}.pause-btn:hover{border-color:var(--muted);color:var(--text)}.pause-btn.active{border-color:#7a5b2e;color:var(--amber)}
+.summary{display:grid;grid-template-columns:repeat(7,minmax(110px,1fr));gap:10px;margin-bottom:18px}.metric,.repo,.attention{border:1px solid var(--line);background:color-mix(in srgb,var(--panel) 94%,transparent);border-radius:14px}.metric{padding:13px 14px}.metric b{display:block;font:600 25px ui-monospace,monospace}.metric span{color:var(--muted);font-size:11px;text-transform:uppercase;letter-spacing:.08em}
+.attention{display:none;padding:14px 16px;margin-bottom:18px;border-color:#68483c}.attention.show{display:block}.attention h2{color:var(--amber)}h2{font-size:12px;text-transform:uppercase;letter-spacing:.12em;margin:0 0 10px}.attention-row,.row{display:flex;justify-content:space-between;gap:18px;padding:7px 0;border-top:1px solid var(--line)}code{color:var(--cyan);font:12px ui-monospace,monospace;overflow-wrap:anywhere}
+.repos{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,440px),1fr));gap:14px}.repo{padding:17px;min-width:0}.repo-head{display:flex;align-items:start;justify-content:space-between;gap:16px;margin-bottom:14px}.repo h3{font-size:19px;margin:2px 0}.path{color:var(--muted);font:11px ui-monospace,monospace;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:62ch}.badge,.chip{display:inline-flex;border:1px solid var(--line);border-radius:99px;padding:2px 7px;font:10px ui-monospace,monospace;color:var(--muted)}.badge.active{border-color:#2e6845;color:var(--green)}
+.hero{margin-bottom:14px;padding:13px 15px;border:1px solid #2e6845;border-radius:10px;background:color-mix(in srgb,var(--panel) 85%,#0f2c1d 15%)}.hero h4{color:var(--green);font-size:11px;text-transform:uppercase;letter-spacing:.1em;margin:0 0 8px}.run-block{padding:6px 0;border-top:1px solid var(--line)}.run-block:first-child{border-top:0}
+.stale-details{margin-top:8px;border-top:1px solid var(--line);padding-top:8px}.stale-details summary{cursor:pointer;color:var(--muted);font-size:11px;text-transform:uppercase;letter-spacing:.06em}.stale-details[open] summary{margin-bottom:6px}
+.sections{display:grid;grid-template-columns:repeat(auto-fit,minmax(160px,1fr));gap:16px}.section h4{color:var(--muted);font-size:10px;text-transform:uppercase;letter-spacing:.1em;margin:0 0 5px}
+.lane-act{color:var(--muted);font-size:12px}.lane-act.quiet{color:#5f6b65;font-style:italic}
+.lane-log{display:block;margin-top:4px;font-family:ui-monospace,monospace;font-size:12px;color:#c3ccd6}.log-line{overflow-wrap:anywhere;padding:1px 0}.log-verb{color:var(--muted);margin-right:5px}
+.empty{color:#5f6b65;font-style:italic;padding:7px 0}.state{font-family:ui-monospace,monospace}.state.merged{color:var(--green)}.state.executing,.state.in-review{color:var(--amber)}.state.live{color:var(--green)}.state.stale{color:var(--amber)}.door{color:var(--red)}
+.quiet-repos{margin-top:18px}.quiet-repos h2{color:var(--muted)}.quiet-row{display:flex;align-items:center;gap:10px;padding:6px 0;border-top:1px solid var(--line);font-size:12px;color:var(--muted)}.quiet-row:first-child{border-top:0}.quiet-row b{color:var(--text);font-weight:600}.quiet-row .path{max-width:44ch}
+footer{color:var(--muted);font-size:11px;margin-top:22px}
+@media(max-width:900px){.summary{grid-template-columns:repeat(3,1fr)}header{align-items:start;flex-direction:column}.meta{text-align:left}.toolbar{justify-content:flex-start}}@media(max-width:560px){main{width:min(100% - 20px,1480px);padding-top:18px}.summary{grid-template-columns:repeat(2,1fr)}.sections{grid-template-columns:1fr}.attention-row,.row{display:block}.repo{padding:14px}}
+</style></head><body><main><header><div><div class="eyebrow">System harness · local control plane</div><h1>Harness Operations</h1></div><div class="meta"><div class="toolbar"><button id="pauseBtn" class="pause-btn" type="button">⏸ pause</button><span class="live" id="connection">connecting</span></div><span id="updated">waiting for signal</span></div></header><section class="summary" id="summary"></section><section class="attention" id="attention"><h2>Needs you</h2><div id="attentionRows"></div></section><section class="repos" id="repos"></section><section class="quiet-repos" id="quietRepos"></section><footer>Read-only · durable truth comes from each repository ledger · in-flight state comes from run-status spools</footer></main>
+<script>
+const $=id=>document.getElementById(id), esc=v=>String(v??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+const ACTIVITY_QUIET_THRESHOLD_MS=${ACTIVITY_QUIET_THRESHOLD_MS};
+function humanAge(ms){if(ms<0)return'unknown';const m=Math.floor(ms/60000);if(m<60)return m+'m';return Math.floor(m/60)+'h '+(m%60)+'m';}
+function laneHasActivity(l){return'activity'in l||'activity_at'in l||'turn'in l||'tokens'in l||'recent'in l;}
+// "verb: target" renders with a dimmed verb and a bright target — a log line, not a status pill.
+function renderLogLine(text){const m=/^([A-Za-z][\\w-]*): ([\\s\\S]*)$/.exec(text);if(!m)return'<div class="log-line">'+esc(text)+'</div>';return'<div class="log-line"><span class="log-verb">'+esc(m[1])+'</span> '+esc(m[2])+'</div>';}
+function laneActivityHtml(l,run,nowMs){
+  // Lane freshness and run liveness are different questions — a lane can be actively
+  // streaming activity through a long implement step while its run's heartbeat sits
+  // well past the staleness threshold. Gauge quiet/fresh from the lane's own
+  // activity_at, never from run.liveness (that was hiding the richest data on the board).
+  if(!laneHasActivity(l))return'';
+  let line='';
+  if('activity_at'in l||'activity'in l){
+    const atMs=l.activity_at?Date.parse(l.activity_at):NaN;
+    const ageMs=Number.isFinite(atMs)?nowMs-atMs:0;
+    if(Number.isFinite(atMs)&&ageMs>ACTIVITY_QUIET_THRESHOLD_MS)line='<div class="lane-act quiet">quiet for '+esc(humanAge(ageMs))+'</div>';
+    else if('activity'in l)line='<div class="lane-act">'+esc(l.activity)+'</div>';
+  }
+  const meta=[];
+  if('turn'in l)meta.push('turn '+esc(l.turn));
+  // a runner that reports no usage (cursor) always carries {in:0,out:0} — showing "0/0" on every lane is noise.
+  if('tokens'in l&&(l.tokens.in||l.tokens.out))meta.push(esc(l.tokens.in)+'/'+esc(l.tokens.out));
+  const metaHtml=meta.length?'<div class="lane-act">'+meta.join(' · ')+'</div>':'';
+  // newest first — recent is pushed oldest→newest, so read it back to front.
+  const recentHtml=('recent'in l&&l.recent.length)?'<div class="lane-log">'+l.recent.slice().reverse().map(renderLogLine).join('')+'</div>':'';
+  return line+metaHtml+recentHtml;
+}
+function renderRunBlock(x,nowMs){
+  const head='<div class="row"><span>'+esc(x.machine_id)+' · <code>'+esc(x.run_id)+'</code></span><span class="state '+esc(x.liveness)+'">'+esc(x.liveness)+(x.liveness==='stale'&&x.silent_for?' — silent '+esc(x.silent_for):'')+' · '+esc(x.merged)+'/'+esc(x.dag_size)+'</span></div>';
+  const lanes=x.lanes.map(l=>'<div class="row"><span><code>'+esc(l.unit_id)+'</code> · '+esc(l.step)+'</span><span class="chip">'+esc(l.runner)+' / '+esc(l.model)+'</span></div>'+laneActivityHtml(l,x,nowMs)).join('');
+  return '<div class="run-block">'+head+lanes+'</div>';
+}
+// A run can be "stale" by its own heartbeat cadence (once per full loop
+// iteration) while a lane inside it is still visibly, freshly active — the
+// exact mismatch laneActivityHtml corrects for a single lane. Grouping here
+// must ask the same question, or a run doing real work gets buried behind
+// the same "stale" collapse it was just exempted from at the lane level.
+function runHasFreshActivity(x,nowMs){
+  return x.lanes.some(l=>{
+    if(!('activity_at'in l))return false;
+    const at=Date.parse(l.activity_at);
+    return Number.isFinite(at)&&(nowMs-at)<=ACTIVITY_QUIET_THRESHOLD_MS;
+  });
+}
+// The thing changing belongs above the things that aren't: a run that's live
+// (or quietly stale by heartbeat but still visibly working) renders full-width
+// and prominent; a run with nothing fresh anywhere collapses behind a
+// disclosure so zombie runs don't out-weigh the one doing real work.
+function renderRunsHero(runs,nowMs){
+  const promoted=runs.filter(x=>x.liveness==='live'||runHasFreshActivity(x,nowMs));
+  const quiet=runs.filter(x=>!(x.liveness==='live'||runHasFreshActivity(x,nowMs)));
+  const promotedHtml=promoted.map(x=>renderRunBlock(x,nowMs)).join('');
+  const quietHtml=quiet.length?('<details class="stale-details"><summary>'+esc(quiet.length)+' quiet run'+(quiet.length>1?'s':'')+'</summary>'+quiet.map(x=>renderRunBlock(x,nowMs)).join('')+'</details>'):'';
+  if(!promotedHtml&&!quietHtml)return'';
+  return '<div class="hero"><h4>Live runs</h4>'+promotedHtml+quietHtml+'</div>';
+}
+function render(d){$('updated').textContent='updated '+new Date(d.generatedAt).toLocaleTimeString();const s=d.summary;const metrics=[['repositories',s.repositories],['events',s.events],['planned',s.planned],['executing',s.executing],['in review',s.inReview],['merged',s.merged],['open doors',s.doorsOpen]];$('summary').innerHTML=metrics.map(([k,v])=>'<div class="metric"><b>'+esc(v)+'</b><span>'+esc(k)+'</span></div>').join('');
+const needs=[];for(const repo of d.repositories)for(const run of repo.board.panels.runs.data)for(const n of run.needs_you)needs.push({...n,repo:repo.name,run:run.run_id});$('attention').classList.toggle('show',needs.length>0);$('attentionRows').innerHTML=needs.map(n=>'<div class="attention-row"><span><span class="chip door">'+esc(n.kind)+'</span> '+esc(n.repo)+' · '+esc(n.unit_id||n.run)+'</span><code>'+esc(n.unblock)+'</code></div>').join('');
+const active=[],quiet=[];
+for(const repo of d.repositories){
+  const p=repo.board.panels;
+  const hasSignal=p.runs.data.length>0||p.doorsQueue.data.length>0||p.fleet.data.length>0||p.runAnalysis.data.length>0||Object.values(p.systemLanes.data).some(list=>list.length>0);
+  (hasSignal?active:quiet).push(repo);
+}
+$('repos').innerHTML=active.map(renderRepo).join('')||'<div class="empty">No repository has signal yet</div>';
+$('quietRepos').innerHTML=quiet.length?('<h2>Quiet — '+quiet.length+' repositor'+(quiet.length>1?'ies':'y')+' with no unit / run / door / fleet signal</h2>'+quiet.map(renderQuietRepo).join('')):'';
+}
+function renderQuietRepo(r){return '<div class="quiet-row"><span class="badge '+esc(r.status)+'">'+esc(r.status)+'</span><b>'+esc(r.name)+'</b><span class="path" title="'+esc(r.root)+'">'+esc(r.root)+'</span><code>'+esc(r.events)+' events</code></div>';}
+function renderRepo(r){const p=r.board.panels,units=Object.entries(p.systemLanes.data).flatMap(([component,list])=>list.map(u=>({...u,component}))),runs=p.runs.data,doors=p.doorsQueue.data,fleet=p.fleet.data,runAnalysis=p.runAnalysis.data,nowMs=Date.parse(r.board.generatedAt);
+const hero=renderRunsHero(runs,nowMs);
+return '<article class="repo"><div class="repo-head"><div><div class="eyebrow">'+esc(r.system)+'</div><h3>'+esc(r.name)+'</h3><div class="path" title="'+esc(r.root)+'">'+esc(r.root)+'</div></div><span class="badge '+esc(r.status)+'">'+esc(r.status)+' · '+esc(r.events)+' events</span></div>'+hero+'<div class="sections"><section class="section"><h4>Units</h4>'+(units.length?units.map(u=>'<div class="row"><span><code>'+esc(u.component)+'</code> · '+esc(u.id)+'</span><span class="state '+esc(u.state)+'">'+esc(u.state)+'</span></div>').join(''):'<div class="empty">No unit signal</div>')+'</section><section class="section"><h4>Doors</h4>'+(doors.length?doors.map(x=>'<div class="row"><span class="door">'+esc(x.unitId)+'</span><code>'+esc(x.classes.join(', '))+'</code></div>').join(''):'<div class="empty">No open doors</div>')+'</section><section class="section"><h4>Fleet</h4>'+(fleet.length?fleet.map(x=>'<div class="row"><span><code>'+esc(x.id)+'</code> · '+esc(x.model||'unknown')+'</span><span>$'+esc(Number(x.costUsd).toFixed(2))+'</span></div>').join(''):'<div class="empty">No session signal</div>')+'</section><section class="section"><h4>Run analysis</h4>'+(runAnalysis.length?runAnalysis.map(x=>'<div class="row"><span><code>'+esc(x.unitId)+'</code> · '+esc(x.rule)+'</span><span class="chip">'+esc(x.severity)+' ×'+esc(x.count)+'</span></div>').join(''):'<div class="empty">No run analysis yet</div>')+'</section></div></article>'}
+// Pause freezes rendering (so you can select/copy text mid-stream) without dropping the
+// connection — new pushes are buffered and counted, then applied in one shot on resume.
+let paused=false,latestData=null,missed=0;
+function updatePauseUi(){const c=$('connection');const btn=$('pauseBtn');if(paused){btn.textContent='▶ resume'+(missed?' ('+missed+' new)':'');btn.classList.add('active');c.classList.add('paused');c.textContent='paused';}else{btn.textContent='⏸ pause';btn.classList.remove('active');c.classList.remove('paused');}}
+$('pauseBtn').addEventListener('click',()=>{paused=!paused;if(!paused){missed=0;if(latestData)render(latestData);c_setLive();}updatePauseUi();});
+function c_setLive(){$('connection').textContent='live';}
+const stream=new EventSource('/events');
+stream.addEventListener('dashboard',e=>{latestData=JSON.parse(e.data);if(paused){missed++;updatePauseUi();}else{render(latestData);c_setLive();}});
+stream.onerror=()=>{if(!paused)$('connection').textContent='reconnecting';};
+fetch('/api/dashboard').then(r=>r.json()).then(d=>{latestData=d;render(d);});
+</script></body></html>`;
+//# sourceMappingURL=live.js.map

package/dist/internal/system/calibration/cli.js

@@ -0,0 +1,45 @@
+/**
+ * `harness calibrate` — the weekly calibration job.
+ *
+ *   harness calibrate [--ledger <dir>] [--baseline <baseline.json>]
+ *                     [--window 30] [--emit]
+ *
+ * Prints promote/demote/delete proposals, each with its evidence query. With
+ * --emit, appends them as calibration.proposed events. Below the volume floor
+ * it derates to monthly and proposes nothing.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { emitProposals, proposeCalibration } from "./index.js";
+function flag(args, name) {
+    const i = args.indexOf(`--${name}`);
+    return i >= 0 && args[i + 1] ? args[i + 1] : undefined;
+}
+export function calibrateCommand(args) {
+    const ledgerDir = flag(args, "ledger") ?? ".harness/ledger";
+    const baselinePath = flag(args, "baseline");
+    const baseline = baselinePath && existsSync(baselinePath)
+        ? JSON.parse(readFileSync(baselinePath, "utf8"))
+        : undefined;
+    const report = proposeCalibration({
+        ledgerDir,
+        ...(baseline ? { baseline } : {}),
+        windowDays: Number(flag(args, "window") ?? 30),
+    });
+    process.stdout.write(`cadence: ${report.cadence} (${report.envelopesInWindow} envelopes in ${report.windowDays}d)\n`);
+    if (report.insufficient) {
+        process.stdout.write("  insufficient data — no proposals\n");
+        return 0;
+    }
+    for (const p of report.proposals) {
+        const move = p.from ? ` ${p.from} → ${p.to}` : "";
+        process.stdout.write(`  ${p.action.toUpperCase()} ${p.target}${move}   (${p.evidence})\n`);
+    }
+    if (report.proposals.length === 0)
+        process.stdout.write("  no changes proposed\n");
+    if (args.includes("--emit")) {
+        const n = emitProposals(report, ledgerDir);
+        process.stderr.write(`emitted ${n} calibration.proposed event(s)\n`);
+    }
+    return 0;
+}
+//# sourceMappingURL=cli.js.map