feat(awareness): unified liveness + working-note now lines (#592)

* feat(awareness): unified liveness + working-note now lines

Two disconnected liveness systems (heartbeat files vs SQLite
observations) meant a dead heartbeat writer hid a live agent.
readHivemind now reconciles both when given a sqliteLiveness source and
stamps liveness_source per session. attention_inbox gains
active_working_notes — each other live session's latest
task_note_working note (30-min window) — and the SessionStart preface
shows up to 3 'now:' lines so agents start knowing what everyone else
is mid-flight on. No storage migration.

* fix(awareness): review follow-ups — normalize note previews, liveness parity everywhere

Working-note previews are whitespace-normalized at the source so
multi-line content cannot break single-line renderers. bridge_status,
startup_panel, and the worker viewer now pass sqliteLiveness too — a
SQLite-alive lane must not show dead in one surface and alive in
another.

---------

Co-authored-by: NagyVikt <nagy.viktordp@gmail.com>

Author: NagyVikt

.changeset/unified-liveness-working-notes.md

@@ -0,0 +1,7 @@
+---
+'@colony/core': minor
+'@colony/mcp-server': minor
+'@colony/hooks': minor
+---
+
+Cross-agent awareness: unified liveness + working-note "now lines". `readHivemind` accepts an optional `sqliteLiveness` source — sessions with stale heartbeat files but fresh SQLite observations are reclassified as working (`liveness_source: 'sqlite'`); every hivemind session now carries `liveness_source`. `attention_inbox` gains `active_working_notes` (latest task_note_working note per other live session, 30-min window) plus `summary.active_working_note_count`. The SessionStart task preface shows up to 3 co-participant "now:" lines so agents start each session knowing what everyone else is mid-flight on.

apps/mcp-server/src/tools/bridge.ts

@@ -122,14 +122,15 @@ export async function buildBridgeStatusPayload(
   store: MemoryStore,
   { session_id, agent, repo_root, branch, query }: BridgeStatusOptions,
 ): Promise<BridgeStatus> {
-  const snapshot = readHivemind(
-    toHivemindOptions({
+  const snapshot = readHivemind({
+    ...toHivemindOptions({
       repo_root,
       repo_roots: undefined,
       include_stale: true,
       limit: BRIDGE_LANE_LIMIT,
     }),
-  );
+    sqliteLiveness: store.storage,
+  });
   const attentionInbox = buildAttentionInbox(store, {
     session_id,
     agent,

apps/mcp-server/src/tools/hivemind.ts

@@ -57,6 +57,7 @@ export function register(server: McpServer, ctx: ToolContext): void {
       if (repo_roots !== undefined) options.repoRoots = repo_roots;
       if (include_stale !== undefined) options.includeStale = include_stale;
       if (limit !== undefined) options.limit = limit;
+      options.sqliteLiveness = store.storage;
       const snapshot = readHivemind(options);
       return { content: [{ type: 'text', text: JSON.stringify(snapshot) }] };
     }),
@@ -103,9 +104,12 @@ export function register(server: McpServer, ctx: ToolContext): void {
         const attentionIdentity = resolveAttentionIdentity(session_id, agent);
         const laneLimit =
           limit ?? (localMode ? DEFAULT_LOCAL_CONTEXT_LANE_LIMIT : DEFAULT_CONTEXT_LANE_LIMIT);
-        const snapshot = readHivemind(
-          toHivemindOptions({ repo_root, repo_roots, include_stale, limit: laneLimit }),
-        );
+        const snapshot = readHivemind({
+          ...toHivemindOptions({ repo_root, repo_roots, include_stale, limit: laneLimit }),
+          // Unified liveness: heartbeat-stale lanes with fresh SQLite
+          // observations come back as working (liveness_source: 'sqlite').
+          sqliteLiveness: store.storage,
+        });
         const memoryLimit = memory_limit ?? DEFAULT_CONTEXT_MEMORY_LIMIT;
         const maxClaims = max_claims ?? DEFAULT_CONTEXT_CLAIM_LIMIT;
         const maxHotFiles = max_hot_files ?? DEFAULT_CONTEXT_HOT_FILE_LIMIT;

apps/mcp-server/src/tools/startup-panel.ts

@@ -151,6 +151,7 @@ export async function buildStartupPanel(
   const snapshot = readHivemind({
     ...(args.repo_root !== undefined ? { repoRoot: args.repo_root } : {}),
     limit: STARTUP_LANE_LIMIT,
+    sqliteLiveness: store.storage,
   });
   const activeTask = resolveActiveTask(store, args);
   const scopedRepoRoot = args.repo_root ?? activeTask?.repo_root ?? null;

apps/mcp-server/test/autopilot.test.ts

@@ -186,6 +186,7 @@ function makeInbox(overrides: Partial<AttentionInbox> = {}): AttentionInbox {
       recent_other_claim_count: 0,
       live_file_contention_count: 0,
       hot_file_count: 0,
+      active_working_note_count: 0,
       omx_runtime_warning_count: 0,
       blocked: false,
       next_action: 'Idle.',
@@ -204,6 +205,7 @@ function makeInbox(overrides: Partial<AttentionInbox> = {}): AttentionInbox {
     recent_other_claims: [],
     live_file_contentions: [],
     file_heat: [],
+    active_working_notes: [],
     omx_runtime_warnings: [],
     ...overrides,
   };

apps/worker/src/server.ts

@@ -56,7 +56,7 @@ export function buildApp(
   options: WorkerAppOptions = {},
 ): Hono {
   const app = new Hono();
-  const readCachedHivemind = createHivemindReader(options);
+  const readCachedHivemind = createHivemindReader(store, options);
   const reportBuilder = options.discrepancyReportBuilder ?? buildDiscrepancyReport;
 
   app.use('*', async (_c, next) => {
@@ -565,20 +565,28 @@ function safeJsonObject(raw: string | null): Record<string, unknown> {
   }
 }
 
-function createHivemindReader(options: WorkerAppOptions): () => ReturnType<typeof readHivemind> {
+function createHivemindReader(
+  store: MemoryStore,
+  options: WorkerAppOptions,
+): () => ReturnType<typeof readHivemind> {
   let cached: ReturnType<typeof readHivemind> | null = null;
   let cachedAt = 0;
   return () => {
     const now = Date.now();
     if (cached && now - cachedAt < HIVEMIND_CACHE_TTL_MS) return cached;
-    cached = readWorkerHivemind(options);
+    cached = readWorkerHivemind(store, options);
     cachedAt = now;
     return cached;
   };
 }
 
-function readWorkerHivemind(options: WorkerAppOptions): ReturnType<typeof readHivemind> {
-  const input: HivemindOptions = { limit: 20 };
+function readWorkerHivemind(
+  store: MemoryStore,
+  options: WorkerAppOptions,
+): ReturnType<typeof readHivemind> {
+  // Same unified liveness as the MCP hivemind tools — the viewer must not
+  // show a SQLite-alive lane as dead.
+  const input: HivemindOptions = { limit: 20, sqliteLiveness: store.storage };
   if (options.hivemindRepoRoots?.length) {
     input.repoRoots = options.hivemindRepoRoots;
   }

docs/mcp.md

@@ -594,6 +594,8 @@ progressive-disclosure IDs should still call `hivemind_context`,
 Return live lane ownership plus compact relevant memory hits and negative warnings in one request.
 Before editing, inspect ownership, then claim touched files on the active task.
 
+Lane liveness is unified across both liveness systems: each session carries `liveness_source` (`heartbeat` | `sqlite` | `worktree-lock` | `file-lock` | `managed-worktree`). A lane whose heartbeat file went stale but whose session wrote a SQLite observation within the heartbeat window is reclassified as `working` with `liveness_source: "sqlite"` — a dead heartbeat writer no longer hides a live agent.
+
 ```json
 {
   "name": "hivemind_context",
@@ -1521,6 +1523,8 @@ Errors include `{ "code": "SESSION_NOT_FOUND", "error": "..." }` when either `ta
 
 Compact post-`hivemind_context` attention check for live pending handoffs, unread messages, blockers, stalled lanes, pending wakes, recent other-session file claims, stale claim cleanup signals, and decaying hot files. Expired handoffs are hidden from the pending bucket; the original observations remain available via timeline/search for audit. This is the main surface where `task_message` items show up: expired unread messages are hidden, read/replied messages stop triggering attention, and blocking messages remain prominent until read, replied, retracted, or expired. Use `task_messages` for a focused message-only inbox. Review compact IDs first, then fetch full bodies via `get_observations` only for the entries you need.
 
+The payload includes `active_working_notes`: the latest `task_note_working` note from each other live session on your in-scope tasks (30-minute window, 120-char preview, one entry per session, hydrate via `get_observations`). `summary.active_working_note_count` carries the count — this is the "what is everyone doing right now" surface.
+
 ```json
 {
   "name": "attention_inbox",

openspec/changes/agent-claude-unified-liveness-and-working-notes-aware-2026-06-12-14-54/.openspec.yaml

@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-06-12

openspec/changes/agent-claude-unified-liveness-and-working-notes-aware-2026-06-12-14-54/proposal.md

@@ -0,0 +1,13 @@
+## Why
+
+- Colony had two disconnected liveness systems — `.omx/state/active-sessions/` heartbeat files and the SQLite observations DB — so a dead heartbeat writer hid a live agent. And there was no "what is everyone doing right now" surface: agents had to hydrate timelines to learn what co-participants were mid-flight on.
+
+## What Changes
+
+- `readHivemind` accepts `sqliteLiveness` (satisfied by `MemoryStore.storage`); heartbeat-stale sessions with a SQLite observation inside the heartbeat window reclassify to `working` with new field `liveness_source: 'sqlite'`. All sessions carry `liveness_source` (`heartbeat`/`sqlite`/`worktree-lock`/`file-lock`/`managed-worktree`). MCP `hivemind` + `hivemind_context` pass the store.
+- `buildAttentionInbox` gains `active_working_notes[]` — the latest `task_note_working` note (kind `note` + `metadata.working_note`) per other session per in-scope task, 30-min window, 120-char preview — plus `summary.active_working_note_count`. Reuses `taskObservationsByKind`; **no storage migration**.
+- SessionStart task preface renders up to 3 co-participant `now:` lines (80-char) after the Joined-with line.
+
+## Impact
+
+- All additive. The Rust/codex bridge consuming hivemind payloads sees a new field; non-strict parsers unaffected.

openspec/changes/agent-claude-unified-liveness-and-working-notes-aware-2026-06-12-14-54/specs/unified-liveness-and-working-notes-awareness/spec.md

@@ -0,0 +1,20 @@
+## ADDED Requirements
+
+### Requirement: Unified session liveness
+Hivemind snapshots SHALL reconcile heartbeat-file liveness with SQLite observation freshness when a `sqliteLiveness` source is provided, exposing `liveness_source` per session.
+
+#### Scenario: SQLite-fresh session resurrected
+- **WHEN** a session's heartbeat is stale but its last observation is within the heartbeat window
+- **THEN** the session reports `activity: working` and `liveness_source: 'sqlite'`.
+
+#### Scenario: Best-effort on storage failure
+- **WHEN** the liveness source throws
+- **THEN** the snapshot still returns with heartbeat-derived activity.
+
+### Requirement: Working-note awareness surface
+`attention_inbox` SHALL surface the latest working note per other live session per in-scope task within a 30-minute window, and the SessionStart task preface SHALL render up to 3 such notes.
+
+#### Scenario: Inbox working notes
+- **WHEN** another session posted a `working_note` observation within 30 minutes
+- **THEN** `active_working_notes` contains one entry for that session with task_id, observation_id, agent, ts, and a 120-char preview
+- **AND** the caller's own notes and non-working notes are excluded.