@walwal-harness/cli 7.1.34 → 7.1.37

package/CHANGELOG.md

@@ -31,6 +31,25 @@ docmeta:
 
 ## Unreleased
 
+## 7.1.37 — Project-local dashboard runtime + wake reliability (2026-05-31)
+
+- Dashboard runtime now lives under each project’s `.harness/dashboard/` instead of the shared `~/.walwal-harness/dashboard/` cache, with generated dependencies/build output ignored via `.gitignore`.
+- Dashboard heatmap is no longer filtered by the selected goal/submission/hot-fix; it shows all recorded activity while still preserving mission IDs on active cells.
+- Dashboard worker parsing now accepts `name`, `progress`, `eta`, and `report_path` telemetry and no longer treats docmeta-only report drafts as proof of live worker activity.
+- Init/migrate now best-effort registers the project with the hourly wake scheduler, and wake status now uses the macOS `launchctl print gui/$UID/...` state to avoid false `NOT loaded` reports.
+
+## 7.1.36 — Stop hook active-loop guard + visible heatmap (2026-05-29)
+
+- Stop hook no longer runs worker evidence validation before deciding whether the company loop should chain.
+- Worker evidence validation can be scoped to the newest active mission so legacy/archive mission records cannot keep Stop blocked forever.
+- Dashboard heatmap now uses 10-minute buckets across 24 hours, making activity visible without horizontal scrolling through 1440 minute cells.
+
+## 7.1.35 — Dashboard heatmap mission scoping (2026-05-29)
+
+- Dashboard heatmap samples are now scoped to the selected mission, so worker rows no longer inherit activity from unrelated stale-active missions.
+- Activity recording now chooses the newest active mission when legacy runtime state contains multiple `active:true` mission-state files.
+- Init/migrate now deactivates duplicate active submission/hot-fix children under the same goal instead of only creating missing mission-state files.
+
 ## 7.1.26 — Lazy rule links + MCP steward (2026-05-27)
 
 ### Added

package/HR-Resource/ceo/SKILL.md

@@ -9,6 +9,17 @@ disable-model-invocation: false
 
 You are the only direct conversation channel with the Owner.
 
+## Autonomous Operating Charter
+
+The Owner gives direction and final acceptance, not routine operating answers.
+
+- Do not ask the Owner whether to continue, which option to choose, which worker to hire, or whether to start the next planned step.
+- When a decision is needed, decide from mission evidence, conventions, gotchas, CXX recommendations, and the smallest reversible path. Record the decision and rationale in `ceo.md`.
+- If CEO cannot decide alone, convene the relevant CXX agents and use their written recommendations to decide. Do not turn the uncertainty into an Owner question.
+- Treat Owner messages as direction changes, new requirements, hot-fixes, final acceptance feedback, or explicit constraints. They are not required to keep the company loop moving.
+- Only stop for Owner input when the next action requires external authority the harness cannot infer or obtain: credentials/secrets, payment approval, legal/business acceptance, production access not already granted, destructive data action, or a goal conflict that would knowingly violate the Owner's stated direction.
+- When stopped for external authority, mark the mission `blocked` with the exact missing authority and the internally recommended default. Do not ask an open-ended question.
+
 ## Lazy Rule Loading
 
 Before routing or accepting CXX work, enforce lazy loading:
@@ -29,7 +40,7 @@ Before routing or accepting CXX work, enforce lazy loading:
    - CQO: quality gates, e2e/backtest strategy, regression and archive criteria.
    - OPS: build/service environment monitoring, CQO verification watch, port map checks, launch observation, production watch, and exception monitoring.
 4. Route completed outputs to the next responsible CXX.
-5. Report outcomes and escalations to the Owner.
+5. Report outcomes, final acceptance requests, and true external-authority blocks to the Owner.
 
 ## Hard Rules
 
@@ -41,9 +52,9 @@ Before routing or accepting CXX work, enforce lazy loading:
 - Every CXX starts from fresh context and records decisions in `.harness/documents/{goal-or-child-mission}/{cxx}.md`.
 - Hiring or resource-manager output is never a stopping point. After missing workers are registered, immediately continue routing to the responsible CXX fresh sessions and require those CXX agents to brief/run the hired workers. Do not end the turn with only a hiring summary while the Owner goal remains unfinished.
 - Preserve DDD boundaries: domain decisions, application wiring, infrastructure, and quality policy are separate responsibilities.
-- Before CTO/CDO/OPS allocate runnable services, agree with the Owner on a `{xx}000` base port and write it to project `.env` as `HARNESS_BASE_PORT={xx}000`. Mentioning the value in `ceo.md` is not sufficient.
+- Before CTO/CDO/OPS allocate runnable services, choose a `{xx}000` base port from available local evidence unless the Owner already specified one, then write it to project `.env` as `HARNESS_BASE_PORT={xx}000`. Mentioning the value in `ceo.md` is not sufficient.
 - After writing `.env`, verify with `grep '^HARNESS_BASE_PORT=' .env` before routing service work.
-- For service monitoring, collect the Owner's server mapping first: local PC, Docker, VM, AWS/cloud, host, port, health path, log path, and contact/source.
+- For service monitoring, derive the server mapping from repository config, running processes, Docker, scripts, logs, and CXX reports first: local PC, Docker, VM, AWS/cloud, host, port, health path, log path, and contact/source. If a production target or credential is unavailable, record a BLOCKED external-authority item instead of asking a broad Owner question.
 - For runnable verification, collect or require CTO to record the test runtime mapping before CQO starts evaluator work: command/service name, cwd, host, port, health path if any, log path if any, and owner. OPS must watch that runtime during CQO Playwright/E2E/API/visual/performance/regression checks.
 - CEO must not accept CQO PASS for a runnable product unless OPS has supplied clean verification-watch evidence or an explicit not-applicable reason. Open OPS incidents, missing runtime mapping, missing required logs, service down, or health mismatch block Owner acceptance.
 - After launch, CEO treats OPS production incidents as company events. CEO convenes CTO/CQO/OPS when user-impacting production signals appear; CTO owns recovery, CQO owns regression confirmation, and OPS owns evidence and close criteria.
@@ -94,7 +105,7 @@ If CEO needs implementation done, CEO routes to CTO. CTO then hires dev workers.
 If CEO needs QA done, CEO routes to CQO. CQO then hires evaluator/tester workers.
 CEO does not contact workers. CXX contact workers.
 
-**When a CXX is unavailable or unresponsive:** escalate to the Owner. Do not act on their behalf.
+**When a CXX is unavailable or unresponsive:** retry with a fresh role-scoped context, route to another relevant CXX for recovery planning, or record an internal blocker with evidence. Escalate to the Owner only when the blocker requires external authority listed in the Autonomous Operating Charter.
 
 ## Worktree Isolation Failure — No git Repo
 

package/HR-Resource/ops/SKILL.md

@@ -17,7 +17,7 @@ OPS owns three environment classes:
 
 - Build environment: command-based local execution such as `flutter run`, `npm run dev`, test watchers, local build scripts, and other foreground/background commands used by CXX workers.
 - Verification environment: the runnable local, preview, Docker, or cloud target used while CQO evaluator workers run Playwright, E2E, API, visual, accessibility, performance, or regression checks.
-- Service environment: an actual server endpoint that can be monitored. The server may be the Owner's local PC, Docker, a VM, AWS, or another cloud/server target. OPS does not invent this mapping; CEO must collect it from the Owner and record it before OPS treats it as live.
+- Service environment: an actual server endpoint that can be monitored. The server may be the Owner's local PC, Docker, a VM, AWS, or another cloud/server target. OPS does not invent this mapping; CEO/CTO/OPS must derive it from repo config, scripts, running processes, Docker, logs, and CXX reports before OPS treats it as live. Escalate to Owner only when external authority is missing, such as credentials or unavailable production access.
 
 OPS is not the implementation owner. CTO/DevOps workers start or change systems; OPS observes whether the declared build/service environments are healthy and raises evidence-backed events.
 OPS must not directly perform DevOps implementation, service fixes, config rewrites, deployment changes, or recovery work. OPS may only monitor, classify, brief hired Ops/DevOps workers, review their reports, and escalate evidence-backed events.
@@ -46,8 +46,8 @@ After service launch, OPS continues the same monitoring duty against `runtime.pr
 
 ## Port Policy
 
-- CEO must agree on a `{xx}000` base port with the Owner before CXX services are allocated.
-- The agreed base port is recorded in project `.env` as `HARNESS_BASE_PORT`.
+- CEO/CTO/OPS must choose an available `{xx}000` base port before CXX services are allocated, unless the Owner already specified one.
+- The selected base port is recorded in project `.env` as `HARNESS_BASE_PORT`.
 - Service-specific ports must be derived above that base port, for example `HARNESS_FRONTEND_PORT`, `HARNESS_API_PORT`, and `HARNESS_DASHBOARD_PORT`.
 - CXX agents must read `.env` or `.harness/config.json runtime.ports.base` before assigning ports.
 - OPS reports any service using an unmapped or off-range port as an ops drift.

package/README.md

@@ -164,7 +164,7 @@ Run on a different port:
 bash scripts/harness-dashboard-up.sh --port 3002
 ```
 
-Force-refresh the isolated dashboard cache when an older dashboard is still shown:
+Force-refresh the project-local dashboard runtime when an older dashboard is still shown:
 
 ```bash
 bash scripts/harness-dashboard-up.sh --port 3002 --reinstall
@@ -175,7 +175,9 @@ Dashboard options:
 | Option | Role |
 |---|---|
 | `--port <port>` | Run Brick Office on a custom port, e.g. `3002` |
-| `--reinstall` | Delete and rebuild the isolated dashboard cache under `~/.walwal-harness/dashboard/` |
+| `--reinstall` | Delete and rebuild the project-local dashboard runtime under `.harness/dashboard/` |
+
+The dashboard app copy lives under `.harness/dashboard/` for the current project. Generated dependencies and build output are ignored via `.gitignore`; the runtime files the dashboard reads remain the normal `.harness/` files.
 
 ### Company Auto-Chain State
 
@@ -283,6 +285,9 @@ harness-hiring           → register and onboard worker
 
 | Version | Summary |
 |---|---|
+| 7.1.37 | Project-local dashboard runtime under `.harness/dashboard/`, unfiltered all-mission heatmap, worker telemetry parsing, and more reliable hourly wake registration/status |
+| 7.1.36 | Stop hook only validates worker evidence while chaining the active loop, scopes validation to the newest active mission, and makes the 24h heatmap visible at 10-minute resolution |
+| 7.1.35 | Fix dashboard heatmap mission scoping, choose the newest active mission for activity recording, and normalize duplicate active child mission states during init/migrate |
 | 7.1.34 | Fix dashboard 500 when `company_state.workers` is recorded as a keyed worker map instead of an array |
 | 7.1.33 | Dashboard keeps recently written worker reports active even when docmeta is present, and CXX skills now record worker activity telemetry for live dashboard state |
 | 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 |

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

@@ -59,8 +59,8 @@ type CxxRole = typeof CXX_ROLES[number];
 // Workers always sit under a non-CEO CXX (CEO delegates, never owns workers).
 const WORKER_OWNERS = ["coo", "cdo", "cto", "cqo", "ops"] as const;
 type WorkerOwnerRole = typeof WORKER_OWNERS[number];
-const BUCKET_MS = 60_000;
-const VISIBLE_BUCKETS = 24 * 60;
+const BUCKET_MS = 10 * 60_000;
+const VISIBLE_BUCKETS = 24 * 6;
 const LANE_LABEL_WIDTH = 110;
 const TIME_LABEL_HEIGHT = 18;
 const LANE_ROW_HEIGHT = 18;
@@ -116,7 +116,7 @@ export function Scene({ snapshot: initial, lang = "ko" }: SceneProps) {
     );
   }, [snapshot.missions, selectedGoal]);
 
-  const lanes = useMemo(() => buildLanes(snapshot, selectedMission), [selectedMission, snapshot]);
+  const lanes = useMemo(() => buildLanes(snapshot), [snapshot]);
   const heatmapStartedAt = useMemo(() => Date.now() - VISIBLE_BUCKETS * BUCKET_MS, [snapshot.ts]);
   const persistedHeatSamples = useMemo<HeatSample[]>(
     () =>
@@ -130,13 +130,13 @@ export function Scene({ snapshot: initial, lang = "ko" }: SceneProps) {
     [snapshot.activitySamples]
   );
   const [heatSamples, setHeatSamples] = useState<HeatSample[]>([]);
-  const sampleSourceRef = useRef({ lanes, snapshot, selectedMission });
+  const sampleSourceRef = useRef({ lanes, snapshot });
   useEffect(() => {
-    sampleSourceRef.current = { lanes, snapshot, selectedMission };
-  });
+    sampleSourceRef.current = { lanes, snapshot };
+  }, [lanes, snapshot]);
   useEffect(() => {
     const tick = () => {
-      const { lanes, snapshot, selectedMission } = sampleSourceRef.current;
+      const { lanes, snapshot } = sampleSourceRef.current;
       // Gate live samples on the harness runtime — once the session reports
       // completion (or there's no current/next agent), every "active" signal
       // is stale (todos stay status="active", worker mtimes stay recent), so
@@ -156,7 +156,7 @@ export function Scene({ snapshot: initial, lang = "ko" }: SceneProps) {
       }
       setHeatSamples((prev) => {
         const now = Date.now();
-        const activeMission = selectedMission ?? snapshot.missions[0] ?? null;
+        const activeMission = snapshot.missions.find((mission) => mission.active) ?? snapshot.missions[0] ?? null;
         const next: HeatSample[] = [];
         for (const lane of lanes) {
           // Live overlay records active work only. Historical participation is
@@ -201,7 +201,12 @@ export function Scene({ snapshot: initial, lang = "ko" }: SceneProps) {
     return () => clearInterval(id);
   }, []);
   const { cells: heatmap, totalBuckets } = useMemo(
-    () => buildHeatmap(snapshot, lanes, [...persistedHeatSamples, ...heatSamples], heatmapStartedAt),
+    () => buildHeatmap(
+      snapshot,
+      lanes,
+      [...persistedHeatSamples, ...heatSamples],
+      heatmapStartedAt
+    ),
     [heatSamples, heatmapStartedAt, lanes, persistedHeatSamples, snapshot]
   );
   const [selectedLaneId, setSelectedLaneId] = useState(lanes[0]?.id ?? "ceo");
@@ -1374,7 +1379,8 @@ const CadencePromptTooltip = (() => {
 
 // ===== Heatmap =====
 
-function formatMinuteOffset(minutes: number) {
+function formatBucketOffset(bucket: number) {
+  const minutes = bucket * (BUCKET_MS / 60_000);
   if (minutes === 0) return "now";
   if (minutes < 60) return `-${minutes}m`;
   const h = Math.floor(minutes / 60);
@@ -1486,7 +1492,7 @@ function WorkflowHeatmap({
                 className="grid place-items-center font-mono text-[9px] leading-none text-slate-500"
                 style={{ gridColumn: idx + 2, gridRow: 1 }}
               >
-                {showLabel ? formatMinuteOffset(idx) : ""}
+                {showLabel ? formatBucketOffset(idx) : ""}
               </div>
             );
           })}
@@ -1800,14 +1806,39 @@ function heatColor(count: number) {
 
 // ===== Lane / Heatmap builders =====
 
-function buildLanes(snapshot: HarnessSnapshot, selectedMission: MissionDoc | null): AgentLane[] {
-  const activeMission = selectedMission ?? snapshot.missions[0] ?? null;
+function buildLanes(snapshot: HarnessSnapshot): AgentLane[] {
+  const activeMission = snapshot.missions.find((mission) => mission.active) ?? snapshot.missions[0] ?? null;
+  const workersByRole = new Map<CxxRole, Array<{ worker: WorkerDocEntry; mission: MissionDoc }>>();
+  for (const role of CXX_ROLES) workersByRole.set(role, []);
+
+  const workerIndex = new Map<string, { worker: WorkerDocEntry; mission: MissionDoc }>();
+  for (const mission of snapshot.missions) {
+    for (const worker of mission.workers) {
+      if (!CXX_ROLES.includes(worker.owner as CxxRole)) continue;
+      const role = worker.owner as CxxRole;
+      const key = `${role}:${worker.name}`;
+      const existing = workerIndex.get(key);
+      if (
+        !existing ||
+        (!existing.worker.active && worker.active) ||
+        (existing.worker.status === "COMPLETE" && worker.status !== "COMPLETE")
+      ) {
+        workerIndex.set(key, { worker, mission });
+      }
+    }
+  }
+
+  for (const entry of workerIndex.values()) {
+    workersByRole.get(entry.worker.owner as CxxRole)?.push(entry);
+  }
+
   // CXX → its workers, then next CXX → its workers (proper hierarchy).
   // No cap: heatmap container scrolls vertically so OPS at the bottom is always
   // reachable even when upstream CXX bring many workers.
   const lanes: AgentLane[] = [];
   for (const role of CXX_ROLES) {
-    const workers = activeMission?.workers.filter((w) => w.owner === role) ?? [];
+    const workerEntries = workersByRole.get(role) ?? [];
+    const workers = workerEntries.map((entry) => entry.worker);
     const todos = snapshot.todos.filter((t) => t.owner === role);
     const hasError =
       (role === "ops" && snapshot.incidents.length > 0) ||
@@ -1826,7 +1857,7 @@ function buildLanes(snapshot: HarnessSnapshot, selectedMission: MissionDoc | nul
       workers,
       mission: activeMission,
     });
-    for (const worker of workers) {
+    for (const { worker, mission } of workerEntries) {
       lanes.push({
         id: `${role}:${worker.name}`,
         label: `└ ${worker.displayName.slice(0, 16)}`,
@@ -1837,7 +1868,7 @@ function buildLanes(snapshot: HarnessSnapshot, selectedMission: MissionDoc | nul
         todos: 0,
         workers: [],
         worker,
-        mission: activeMission,
+        mission,
       });
     }
   }
@@ -1895,7 +1926,7 @@ function buildHeatmap(
         y,
         laneId: lane.id,
         laneLabel: lane.label,
-        bucketLabel: formatMinuteOffset(x),
+        bucketLabel: formatBucketOffset(x),
         count: agg?.count ?? 0,
         hotfix: agg?.hotfix ?? false,
         mission: missionId ? missionById.get(missionId) ?? null : null,

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

@@ -382,7 +382,7 @@ describe("readHarnessState", () => {
     });
   });
 
-  it("keeps recently written docmeta worker reports active without an explicit COMPLETE marker", () => {
+  it("does not treat a recently written docmeta draft as live worker activity without runtime state", () => {
     const harnessDir = path.join(dir, ".harness");
     const missionDir = path.join(harnessDir, "documents", "goal-1-dashboard");
     mkdirSync(path.join(missionDir, "cto", "workers"), { recursive: true });
@@ -403,9 +403,42 @@ describe("readHarnessState", () => {
     const workers = readHarnessState(dir).missions[0].workers;
     expect(workers[0]).toMatchObject({
       name: "frontend-worker",
-      status: "IN_PROGRESS",
-      active: true,
+      status: "COMPLETE",
+      active: false,
+    });
+  });
+
+  it("reads manual worker telemetry with name, progress, eta, and report_path", () => {
+    const harnessDir = path.join(dir, ".harness");
+    mkdirSync(harnessDir, { recursive: true });
+    writeFileSync(
+      path.join(harnessDir, "progress.json"),
+      JSON.stringify({
+        agent_status: "running",
+        company_state: {
+          active_workers: 2,
+          workers: [
+            {
+              name: "frontend-engineer-multi-strategy",
+              status: "running",
+              progress: "70%",
+              eta: "2026-05-31 17:00",
+              report_path: ".harness/documents/goal-1/cto/workers/frontend-engineer-multi-strategy.md",
+            },
+          ],
+        },
+      })
+    );
+
+    const worker = readHarnessState(dir).dashboard.workers[0];
+    expect(worker).toMatchObject({
+      agent: "frontend-engineer-multi-strategy",
+      feature: "frontend-engineer-multi-strategy",
+      status: "running",
+      log: ".harness/documents/goal-1/cto/workers/frontend-engineer-multi-strategy.md",
+      progress: 0.7,
     });
+    expect(worker.summary).toContain("2026-05-31 17:00");
   });
 
   it("accepts keyed company_state.workers maps from manual CXX telemetry", () => {

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

@@ -45,7 +45,6 @@ import type {
 
 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 {
@@ -148,22 +147,31 @@ interface RawProgress {
   company_state?: {
     active_workers?: number;
     workers?: Array<{
+      name?: string;
       team?: number | string;
       feature?: string;
       agent?: string;
       phase?: string;
       prompt?: string | null;
       log?: string | null;
+      report?: string | null;
+      report_path?: string | null;
+      progress?: string | number | null;
+      eta?: string | null;
       spawn_status?: string;
       status?: string;
       pid?: number | null;
     }> | Record<string, {
+      name?: string;
       team?: number | string;
       feature?: string;
       agent?: string;
       phase?: string;
       prompt?: string | null;
       log?: string | null;
+      report_path?: string | null;
+      progress?: string | number | null;
+      eta?: string | null;
       spawn_status?: string;
       status?: string;
       pid?: number | null;
@@ -797,6 +805,7 @@ function readFeatureTitles(rootDir: string): Map<string, string> {
 }
 
 interface RawWorker {
+  name?: string;
   team?: number | string;
   feature?: string;
   agent?: string;
@@ -808,6 +817,9 @@ interface RawWorker {
   pid?: number | null;
   owner?: string;
   report?: string | null;
+  report_path?: string | null;
+  progress?: string | number | null;
+  eta?: string | null;
 }
 type WorkerOwner = WorkerDocEntry["owner"];
 
@@ -859,6 +871,14 @@ function readMissionState(missionPath: string): {
 }
 
 function deriveWorkerProgress(worker: RawWorker): number | null {
+  const explicit = worker?.progress;
+  if (typeof explicit === "number" && Number.isFinite(explicit)) {
+    return explicit > 1 ? Math.max(0, Math.min(1, explicit / 100)) : Math.max(0, Math.min(1, explicit));
+  }
+  if (typeof explicit === "string") {
+    const match = explicit.match(/(\d+(?:\.\d+)?)/);
+    if (match) return Math.max(0, Math.min(1, Number(match[1]) / 100));
+  }
   const status = (worker?.status ?? worker?.spawn_status ?? "").toLowerCase();
   if (status === "blocked" || status === "failed") return 0.35;
   if (status === "recorded") return 0.15;
@@ -868,17 +888,24 @@ function deriveWorkerProgress(worker: RawWorker): number | null {
 }
 
 function normalizeRawWorkers(value: RawWorker[] | Record<string, RawWorker> | null | undefined): RawWorker[] {
-  if (Array.isArray(value)) return value;
+  const normalizeOne = (worker: RawWorker, fallbackName: string | null = null, idx = 0): RawWorker => {
+    const name = worker.name ?? worker.agent ?? worker.feature ?? fallbackName ?? `worker-${idx + 1}`;
+    const report = worker.report ?? worker.report_path ?? null;
+    return {
+      ...worker,
+      name,
+      team: worker.team ?? idx + 1,
+      agent: worker.agent ?? name,
+      feature: worker.feature ?? name,
+      log: worker.log ?? report,
+      report,
+    };
+  };
+  if (Array.isArray(value)) return value.map((worker, idx) => normalizeOne(worker, null, idx));
   if (!value || typeof value !== "object") return [];
   return Object.entries(value).map(([name, worker], idx) => {
     const w = worker && typeof worker === "object" ? worker : {};
-    return {
-      ...w,
-      team: (w as RawWorker).team ?? idx + 1,
-      agent: (w as RawWorker).agent ?? name,
-      feature: (w as RawWorker).feature ?? name,
-      log: (w as RawWorker).log ?? (w as RawWorker & { report?: string | null }).report ?? null,
-    };
+    return normalizeOne(w as RawWorker, name, idx);
   });
 }
 
@@ -911,7 +938,8 @@ function buildWorkers(rootDir: string, progress: RawProgress | null): WorkerSnap
     const feature = w.feature ?? `worker-${idx + 1}`;
     const promptText = w.prompt ? readTextSafe(path.join(rootDir, w.prompt)) : null;
     const logText = w.log ? readTextSafe(path.join(rootDir, w.log)) : null;
-    const summarySource = firstLine(logText) || firstLine(promptText) || `${w.agent ?? "worker"} assigned`;
+    const eta = w.eta ? ` ETA ${w.eta}` : "";
+    const summarySource = firstLine(logText) || firstLine(promptText) || `${w.agent ?? w.name ?? "worker"} ${w.status ?? "assigned"}${eta}`;
     const material = w.prompt ?? w.log ?? null;
     const rawStatus = (w.status ?? w.spawn_status ?? "unknown").toLowerCase();
     const status = ["spawned", "recorded", "running", "idle", "blocked"].includes(rawStatus)
@@ -1036,13 +1064,13 @@ function activeWorkerNames(progress: RawProgress | null): Set<string> {
   if (isHarnessRuntimeIdle(progress)) return active;
   const workers = [
     ...normalizeRawWorkers(progress?.company_state?.workers),
-    ...(progress?.company_state?.last_dispatch ?? []),
+    ...normalizeRawWorkers(progress?.company_state?.last_dispatch),
   ];
   for (const worker of workers) {
     const rawStatus = (worker.status ?? worker.spawn_status ?? "").toLowerCase();
     if (["complete", "completed", "done", "idle"].includes(rawStatus)) continue;
-    for (const value of [worker.agent, worker.feature]) {
-      const normalized = normalizeWorkerName(value);
+    for (const value of [worker.name, worker.agent, worker.feature, worker.report, worker.report_path, worker.log]) {
+      const normalized = normalizeWorkerName(value && /[\\/]/.test(value) ? path.basename(value) : value);
       if (normalized) active.add(normalized);
     }
   }
@@ -1262,21 +1290,17 @@ function readMissions(rootDir: string, progress: RawProgress | null = null, limi
             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 statusMatch = content.match(/##\s*Status\s*\n+([A-Z_]+)/);
             const hasDocmeta = /^---[\s\S]*?docmeta:[\s\S]*?---/.test(content);
-            // Worker docs often write docmeta before appending final evidence.
-            // Without an explicit COMPLETE marker, keep recent writes visible as
-            // active; after the activity window they become historical reports.
+            // Runtime state is the source of truth for live activity. A
+            // recently touched docmeta-only draft is not enough to prove that a
+            // detached worker session is still running.
             const status: WorkerDocEntry["status"] = statusMatch
               ? (statusMatch[1] as WorkerDocEntry["status"])
-              : hasDocmeta && recentlyTouched && !runtimeIdle
-              ? "IN_PROGRESS"
               : hasDocmeta
               ? "COMPLETE"
               : "unknown";