feat(observability): restore monitoring coverage, make gaps visible, stream executions

Monitoring coverage was 3 of 89 active entities. Three bugs, each hidden by
discarded errors in checkdefaults:

- writeCheck generated a fresh uuid, inserted the check entity ON CONFLICT
  (slug) DO NOTHING, then wrote a check_defs row referencing it. On any
  re-seed the slug already existed, the entity insert no-oped, and the FK
  violated — aborting the ingest transaction and surfacing as an unrelated
  failure several entities later. Re-seeding has been broken since; prod's
  coverage was frozen at its first successful seed. This is what
  TestSeedIngestIdempotentAndNoDuplicateEdges had been reporting.
- shortSlug truncated to the last 8 chars, so all 21 ingress routes collapsed
  to ".network" and overwrote each other; service:jellyfin collided with
  lxc:jellyfin.
- The ssh-script checker never read the `args` config checkdefaults wrote, so
  process_check.sh always ran without its unit name and returned "unknown".

Coverage is now 75/89. Monitoring is declared per entity type in
seeds/ontology.yaml and resolved through the is-a hierarchy, so a type can say
it warrants nothing (site, lan, mesh, cluster) and never be reported as a gap.
coverageSweep raises an `unmonitored` signal only where a type declares
monitoring it lacks — 8 real gaps, no false positives.

Also:
- entity_types.attribute_schema was never ingested: the seed loader read
  "attribute_schema" but the YAML says "attributes", so all 60 types stored
  JSON null.
- ListExecutions ignored its declared target/action/correlation_id filters and
  paginated on a non-unique target slug, dropping and repeating rows.
- started_at was captured but only written at terminal state, so a running
  execution reported NULL for its whole life. The three MCP auto-run copies
  wrote no timing at all; they are now one autoRun helper.
- SSH output was buffered to completion and discarded entirely on timeout.
  Both sshExec copies now stream through a shared execlog sink into
  execution_logs, and keep partial output when a command is cancelled.
- executions.correlation_id was a random per-execution uuid that correlated
  nothing; it is now the chat session id, which is what lets the chat tail
  live output.
- reversible_low had no auto-run branch despite policy declaring it
  unattended. Since computeCommandRisk never returns it, the class only arises
  when an agent declares it over a read_only command — so gating it penalised
  candor without adding safety.
- backup-target gains a backup-freshness checker (portable find -mmin, since
  the first target is on macOS), resolving its host by walking backs-up-to
  backwards. The pre-deploy pg_dump is now a tracked backup target.

UI: an Executions section on entity detail with live output tailing, and
streamed output under a running `run` call in the chat timeline.

Migrations 022-024. Ops.svelte and context.ts exclude execution.output from
their refetch triggers, which would otherwise fire once a second per command.

Co-Authored-By: Claude <noreply@anthropic.com>

web/src/lib/stores/activity.ts

@@ -1,6 +1,7 @@
 import { derived, type Readable } from 'svelte/store'
 import { messages, chatFor, type ChatMessage, type ToolCallResult } from './chat'
 import { planSteps, currentTask, workspaceFor, taskFor } from './workspace'
+import { liveExecutionOutputFor, type LiveExecutionOutput } from './execstream'
 import type { PlanStep, Session } from '$lib/api'
 
 export { type ToolCallResult }
@@ -28,6 +29,10 @@ export interface ActivityEntry {
   stepSeq?: number
   indent?: boolean
   status: 'running' | 'done' | 'failed'
+  // Command output streaming in while a `run` tool call is still executing.
+  // Distinct from `detail`, which is only populated once the tool_result
+  // arrives — for an auto-run that is the moment the command finishes.
+  liveOutput?: string
 }
 
 // Detail text is kept full-length (not hard-truncated to a preview snippet)
@@ -199,12 +204,31 @@ export const activityLog = derived([messages, planSteps, currentTask], ([$msgs,
   computeActivityLog($msgs, $steps, $task)
 )
 
+// Attach streaming output to the `run` entry that is currently executing.
+// Nomos runs tools sequentially, so the last still-running run entry is the
+// one the output belongs to.
+function withLiveOutput(
+  entries: ActivityEntry[],
+  live: LiveExecutionOutput | null
+): ActivityEntry[] {
+  if (!live?.output) return entries
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i]
+    if (e.type === 'tool_running' && e.status === 'running' && e.toolName === 'run') {
+      entries[i] = { ...e, liveOutput: live.output }
+      break
+    }
+  }
+  return entries
+}
+
 export function activityLogFor(sessionId: string): Readable<ActivityEntry[]> {
   const chat = chatFor(sessionId)
   const ws = workspaceFor(sessionId)
   const task = taskFor(sessionId)
-  return derived([chat.messages, ws.planSteps, task], ([$msgs, $steps, $task]) =>
-    computeActivityLog($msgs, $steps, $task)
+  const live = liveExecutionOutputFor(sessionId)
+  return derived([chat.messages, ws.planSteps, task, live], ([$msgs, $steps, $task, $live]) =>
+    withLiveOutput(computeActivityLog($msgs, $steps, $task), $live)
   )
 }
 

web/src/lib/stores/context.ts

@@ -22,10 +22,13 @@ export async function refreshContext() {
 function onEvent(ev: OikosEvent) {
   if (ev.id <= lastSeenEventId) return
   lastSeenEventId = ev.id
+  // execution.output carries no summary-level change — it just signals that a
+  // running command printed more. Excluded so a single noisy command doesn't
+  // refresh the dashboard summary once a second.
   if (
     ev.type.startsWith('approval.') ||
     ev.type.startsWith('signal.') ||
-    ev.type.startsWith('execution.') ||
+    (ev.type.startsWith('execution.') && ev.type !== 'execution.output') ||
     ev.type === 'health.changed'
   ) {
     refreshContext()

web/src/lib/stores/execstream.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { get, writable } from 'svelte/store'
+import type { OikosEvent } from './events'
+
+// The store is driven entirely by SSE events plus a log fetch, so both are
+// mocked. What matters is the correlation logic: an execution.output event is
+// matched to a chat session by correlation_id, which MCP-initiated executions
+// now carry (it used to be a random per-execution UUID that correlated
+// nothing).
+
+const liveEvents = writable<OikosEvent[]>([])
+const subscribeEvents = vi.fn(() => () => {})
+const fetchExecutionLogs = vi.fn(async (id: string) => ({
+  items: [],
+  combined: `output-for-${id}`
+}))
+
+vi.mock('./events', () => ({
+  liveEvents,
+  subscribeEvents
+}))
+vi.mock('$lib/api', () => ({
+  fetchExecutionLogs: (id: string) => fetchExecutionLogs(id)
+}))
+
+let mod: typeof import('./execstream')
+
+function event(partial: Partial<OikosEvent>): OikosEvent {
+  return {
+    id: Math.floor(Math.random() * 1e9),
+    ts: new Date().toISOString(),
+    type: 'execution.output',
+    entity_id: 'exec-1',
+    severity: 'info',
+    source: 'actuator',
+    data: {},
+    correlation_id: 'session-1',
+    ...partial
+  } as OikosEvent
+}
+
+// The store fetches asynchronously; let the microtask queue drain.
+const settle = () => new Promise((r) => setTimeout(r, 0))
+
+beforeEach(async () => {
+  liveEvents.set([])
+  fetchExecutionLogs.mockClear()
+  vi.resetModules()
+  mod = await import('./execstream')
+})
+
+describe('liveExecutionOutputFor', () => {
+  it('picks up output for its own session', async () => {
+    const store = mod.liveExecutionOutputFor('session-1')
+    const stop = store.subscribe(() => {})
+
+    liveEvents.set([event({ entity_id: 'exec-1', correlation_id: 'session-1' })])
+    await settle()
+
+    expect(fetchExecutionLogs).toHaveBeenCalledWith('exec-1')
+    expect(get(store)).toEqual({ executionId: 'exec-1', output: 'output-for-exec-1' })
+    stop()
+  })
+
+  // Without this every open chat window would tail every other session's
+  // commands.
+  it('ignores output belonging to a different session', async () => {
+    const store = mod.liveExecutionOutputFor('session-1')
+    const stop = store.subscribe(() => {})
+
+    liveEvents.set([event({ entity_id: 'exec-9', correlation_id: 'session-2' })])
+    await settle()
+
+    expect(fetchExecutionLogs).not.toHaveBeenCalled()
+    expect(get(store)).toBeNull()
+    stop()
+  })
+
+  it('ignores unrelated event types', async () => {
+    const store = mod.liveExecutionOutputFor('session-1')
+    const stop = store.subscribe(() => {})
+
+    liveEvents.set([event({ type: 'signal.raised' })])
+    await settle()
+
+    expect(fetchExecutionLogs).not.toHaveBeenCalled()
+    stop()
+  })
+
+  // A session runs commands one after another; the second must not inherit
+  // the first one's output.
+  it('resets when a new execution starts in the same session', async () => {
+    const store = mod.liveExecutionOutputFor('session-1')
+    const stop = store.subscribe(() => {})
+
+    liveEvents.set([event({ entity_id: 'exec-1' })])
+    await settle()
+    expect(get(store)?.executionId).toBe('exec-1')
+
+    liveEvents.set([event({ entity_id: 'exec-2' })])
+    await settle()
+    expect(get(store)).toEqual({ executionId: 'exec-2', output: 'output-for-exec-2' })
+    stop()
+  })
+
+  // Once the command finishes its output belongs to the tool_result, not to a
+  // still-"running" entry — leaving it set would show stale output against
+  // the next command.
+  it('clears on a terminal execution event', async () => {
+    const store = mod.liveExecutionOutputFor('session-1')
+    const stop = store.subscribe(() => {})
+
+    liveEvents.set([event({ entity_id: 'exec-1' })])
+    await settle()
+    expect(get(store)).not.toBeNull()
+
+    liveEvents.set([event({ type: 'execution.completed', entity_id: 'exec-1' })])
+    await settle()
+    expect(get(store)).toBeNull()
+    stop()
+  })
+
+  it('does not clear on another session completing', async () => {
+    const store = mod.liveExecutionOutputFor('session-1')
+    const stop = store.subscribe(() => {})
+
+    liveEvents.set([event({ entity_id: 'exec-1' })])
+    await settle()
+
+    liveEvents.set([
+      event({ type: 'execution.completed', entity_id: 'exec-5', correlation_id: 'session-2' })
+    ])
+    await settle()
+    expect(get(store)).not.toBeNull()
+    stop()
+  })
+})

web/src/lib/stores/execstream.ts

@@ -0,0 +1,102 @@
+// Live command output for a chat session's currently-running execution.
+//
+// The chat renders a `run` tool call as "running" from the moment the tool_use
+// arrives until its tool_result comes back — and for an auto-run that gap IS
+// the command's runtime. Until now that window showed only the arguments; the
+// output appeared all at once at the end.
+//
+// Correlation works because MCP-initiated executions now carry the chat
+// session id as their correlation_id, and every execution.output event carries
+// that through. So an event can be matched to the session on screen without a
+// lookup. Nomos runs tools sequentially, so at most one execution is in flight
+// per session — no ambiguity about which entry the output belongs to.
+//
+// Only auto-runs stream. A gated run returns "execution queued" immediately,
+// so its tool entry is already `done` and the command executes minutes later
+// after approval — the entity detail window is where that one is watched.
+
+import { readable, type Readable } from 'svelte/store'
+import { liveEvents, subscribeEvents } from './events'
+import { fetchExecutionLogs } from '$lib/api'
+
+export interface LiveExecutionOutput {
+  executionId: string
+  output: string
+}
+
+const cache = new Map<string, Readable<LiveExecutionOutput | null>>()
+
+/**
+ * Live output for whichever execution this session is currently running.
+ * Resets when a different execution starts, so output from a previous command
+ * never bleeds into the next one's entry.
+ */
+export function liveExecutionOutputFor(sessionId: string): Readable<LiveExecutionOutput | null> {
+  const existing = cache.get(sessionId)
+  if (existing) return existing
+
+  const store = readable<LiveExecutionOutput | null>(null, (set) => {
+    let currentId: string | null = null
+    let inFlight = false
+    // Coalesce: a refetch already running means the next event's data will be
+    // covered by a single follow-up, rather than queueing a request per event.
+    let queued = false
+
+    async function refresh(executionId: string) {
+      if (inFlight) {
+        queued = true
+        return
+      }
+      inFlight = true
+      try {
+        const logs = await fetchExecutionLogs(executionId)
+        // Drop a response for an execution that is no longer current.
+        if (currentId === executionId) set({ executionId, output: logs.combined })
+      } finally {
+        inFlight = false
+        if (queued) {
+          queued = false
+          if (currentId) refresh(currentId)
+        }
+      }
+    }
+
+    const unsubscribeSSE = subscribeEvents()
+    const unsubscribeEvents = liveEvents.subscribe((events) => {
+      const ev = events[0]
+      if (!ev) return
+
+      // Lifecycle end: clear so the finished command's output stops being
+      // shown against a new "running" entry.
+      if (
+        ev.correlation_id === sessionId &&
+        (ev.type === 'execution.completed' ||
+          ev.type === 'execution.failed' ||
+          ev.type === 'execution.cancelled')
+      ) {
+        currentId = null
+        set(null)
+        return
+      }
+
+      if (ev.type !== 'execution.output') return
+      if (ev.correlation_id !== sessionId) return
+      if (!ev.entity_id) return
+
+      if (ev.entity_id !== currentId) {
+        currentId = ev.entity_id
+        set({ executionId: currentId, output: '' })
+      }
+      refresh(ev.entity_id)
+    })
+
+    return () => {
+      unsubscribeEvents()
+      unsubscribeSSE()
+      cache.delete(sessionId)
+    }
+  })
+
+  cache.set(sessionId, store)
+  return store
+}