@heretek-ai/epistemic-swarm 1.1.2 → 1.1.3

package/src/seats.ts

@@ -0,0 +1,109 @@
+// Seat tracker (1.1.3, #60): follows factory seats (registry subagents running
+// as host child sessions) through host events and records their state, last
+// tool and last activity in .factory/runtime/seats.json. es_status, `es
+// status`, the dashboard and the headless driver read it; the foreground guard
+// and the continuation ask it what is running right now.
+import { agentSpec, type SeatRecord, updateSeats } from "@heretek-ai/es-core"
+import type { Runtime } from "./runtime.ts"
+
+/** Activity-only updates (tool calls, steps) are persisted at most this often per seat. */
+const ACTIVITY_PERSIST_MS = 10_000
+
+interface HostEvent {
+  readonly type: string
+  readonly data?: {
+    readonly sessionID?: string
+    readonly parentID?: string
+    readonly agent?: string
+  }
+}
+
+export interface SeatTracker {
+  /** Feed one host event (session.created, session.execution.*, session.step.ended). */
+  onEvent(event: HostEvent, agentOf: (sessionID: string) => Promise<string | undefined>): Promise<void>
+  /** A seat is about to run `tool` (from the execute.before hook, which knows the tool name). */
+  onTool(sessionID: string, agent: string, tool: string): Promise<void>
+  /** Running seats in this host, optionally only one agent's. */
+  running(agent?: string): SeatRecord[]
+  /** Whether `parentID` has a seat child still running. */
+  hasRunningChildren(parentID: string): boolean
+}
+
+/** Factory seats are the registry's subagents; primary agents (factory, grill) are drivers, not seats. */
+const isSeat = (agent: string | undefined): agent is string => agentSpec(agent)?.mode === "subagent"
+
+export function createSeatTracker(
+  runtime: Runtime,
+  options: { readonly onChange?: () => void; readonly now?: () => Date } = {},
+): SeatTracker {
+  const seats = new Map<string, SeatRecord>()
+  const persistedAt = new Map<string, number>()
+  const now = () => (options.now ?? (() => new Date()))()
+
+  const persist = async (record: SeatRecord, transition: boolean) => {
+    const at = now().getTime()
+    if (!transition && at - (persistedAt.get(record.sessionID) ?? 0) < ACTIVITY_PERSIST_MS) return
+    persistedAt.set(record.sessionID, at)
+    const state = await runtime.factory.read().catch(() => undefined)
+    if (state)
+      await updateSeats(runtime.root, state.runId, (list) => {
+        const index = list.findIndex((item) => item.sessionID === record.sessionID)
+        if (index === -1) list.push(record)
+        else list[index] = record
+      }).catch(() => undefined)
+    if (transition) options.onChange?.()
+  }
+
+  const touch = async (sessionID: string, patch: Partial<SeatRecord>, transition: boolean) => {
+    const current = seats.get(sessionID)
+    if (!current) return
+    const next: SeatRecord = { ...current, lastActivityAt: now().toISOString(), ...patch }
+    seats.set(sessionID, next)
+    await persist(next, transition)
+  }
+
+  const start = async (sessionID: string, agent: string, parentID: string | undefined) => {
+    const at = now().toISOString()
+    // A continued seat keeps its start and last tool; it is running again, so it has no end.
+    const { endedAt: _ended, ...base } = seats.get(sessionID) ?? { sessionID, agent, startedAt: at }
+    const record: SeatRecord = { ...base, ...(parentID ? { parentID } : {}), lastActivityAt: at, state: "running" }
+    seats.set(sessionID, record)
+    await persist(record, true)
+  }
+
+  return {
+    async onEvent(event, agentOf) {
+      const sessionID = event.data?.sessionID
+      if (!sessionID) return
+      if (event.type === "session.created") {
+        if (event.data?.parentID && isSeat(event.data.agent))
+          await start(sessionID, event.data.agent, event.data.parentID)
+        return
+      }
+      if (event.type === "session.execution.started") {
+        // A seat created before this host started (or continued later) is picked up here.
+        const agent = seats.get(sessionID)?.agent ?? (await agentOf(sessionID))
+        if (isSeat(agent)) await start(sessionID, agent, seats.get(sessionID)?.parentID)
+        return
+      }
+      if (!seats.has(sessionID)) return
+      const at = now().toISOString()
+      if (event.type === "session.execution.succeeded")
+        await touch(sessionID, { state: "completed", endedAt: at }, true)
+      else if (event.type === "session.execution.failed") await touch(sessionID, { state: "failed", endedAt: at }, true)
+      else if (event.type === "session.execution.interrupted")
+        await touch(sessionID, { state: "interrupted", endedAt: at }, true)
+      else if (event.type === "session.step.ended") await touch(sessionID, {}, false)
+    },
+    async onTool(sessionID, agent, tool) {
+      if (!isSeat(agent) || !seats.has(sessionID)) return
+      await touch(sessionID, { lastTool: tool }, false)
+    },
+    running(agent) {
+      return [...seats.values()].filter((seat) => seat.state === "running" && (!agent || seat.agent === agent))
+    },
+    hasRunningChildren(parentID) {
+      return [...seats.values()].some((seat) => seat.state === "running" && seat.parentID === parentID)
+    },
+  }
+}

package/src/server.ts

@@ -9,9 +9,11 @@ import {
   factoryLayout,
   formatReport,
   git,
+  livenessLines,
   loadSkills,
   parseAuditTarget,
   readJson,
+  readLiveness,
   researchSourcesDir,
   runGates,
 } from "@heretek-ai/es-core"
@@ -24,6 +26,7 @@ import { createWebCache, PendingSearches, registerWebsearch } from "./research.t
 import { createRpcHandlers } from "./rpc.ts"
 import { EsRpc } from "./rpc-def.ts"
 import { createRuntime, parseOptions } from "./runtime.ts"
+import { createSeatTracker } from "./seats.ts"
 import { createSessionHooks, createSpendTracker } from "./session.ts"
 import { registerTools } from "./tools.ts"
 
@@ -74,8 +77,26 @@ export default Plugin.define({
     const searches = new PendingSearches()
     await ctx.websearch.transform((editor) => registerWebsearch(editor as any, runtime, searches))
 
+    // `changed` reaches the TUI (dashboard refetch, stage toast, footer). Bursts
+    // (seat activity, tool runs) are coalesced to at most one emit a second.
+    let emitChanged: (notice?: string) => Promise<void> = async () => {}
+    let lastEmit = 0
+    let queued: ReturnType<typeof setTimeout> | undefined
+    const notifySoon = () => {
+      if (queued) return
+      queued = setTimeout(
+        () => {
+          queued = undefined
+          lastEmit = Date.now()
+          void emitChanged()
+        },
+        Math.max(0, 1000 - (Date.now() - lastEmit)),
+      )
+    }
+    // Seat liveness (#60): fed by host events and the policy hook; read by the guard and the continuation.
+    const seats = createSeatTracker(runtime, { onChange: notifySoon })
     // Our policy runs first, so its denials win over any user hook.
-    const policy = createPolicyHooks(runtime)
+    const policy = createPolicyHooks(runtime, seats)
     const bridge = await createHookBridge(ctx as any, runtime, () => servers)
     const sessionAgents = new Map<string, string | undefined>()
     const agentOf = async (sessionID: string) => {
@@ -104,17 +125,35 @@ export default Plugin.define({
     await ctx.session.hook("context", session.context as any)
     await ctx.session.hook("context", bridge.context as any)
     await ctx.session.hook("compaction", session.compaction as any)
-    const continuation = createFactoryContinuation(ctx as any, runtime)
+    const continuation = createFactoryContinuation(ctx as any, runtime, {
+      seats,
+      onPause: (notice) => void emitChanged(notice),
+    })
 
     // Human-only channel for the TUI (approvals, trust, resume).
     let registration: { events: { emit: (...args: any[]) => Promise<void> } } | undefined
-    const notify = async () => {
-      const state = await runtime.factory.read()
-      await registration?.events
-        .emit("changed", { stage: state?.stage ?? "NONE", summary: await runtime.factory.summary(state) })
-        .catch(() => undefined)
+    // Fire-and-forget from event handlers: a state that cannot be read (halted
+    // mid-write, forged seal) must not surface as an unhandled rejection.
+    emitChanged = async (notice) => {
+      try {
+        const state = await runtime.factory.read()
+        await registration?.events.emit("changed", {
+          stage: state?.stage ?? "NONE",
+          summary: await runtime.factory.summary(state),
+          ...(notice ? { notice } : {}),
+        })
+      } catch {
+        // The next change or the panels' poll catches up.
+      }
     }
-    registration = await ctx.rpc.register(EsRpc, createRpcHandlers(runtime, notify, bridge.engine) as any)
+    registration = await ctx.rpc.register(
+      EsRpc,
+      createRpcHandlers(runtime, () => emitChanged(), bridge.engine, { paused: () => continuation.paused() }) as any,
+    )
+    // Every es_* tool may move the factory: let the TUI know (#62).
+    await ctx.tool.hook("execute.after", (async (event: { tool: string }) => {
+      if (event.tool.startsWith("es_")) notifySoon()
+    }) as any)
 
     await ctx.command.transform((editor) => {
       editor.add({
@@ -309,7 +348,10 @@ export default Plugin.define({
         name: "status",
         description: "Show the factory state (Epistemic Swarm)",
         execute: async ({ sessionID }) => {
-          await ctx.session.synthetic({ sessionID, text: await runtime.factory.summary() } as any)
+          const state = await runtime.factory.read()
+          const liveness = await readLiveness(runtime.root, state)
+          const text = [await runtime.factory.summary(state), ...livenessLines(state, liveness)].join("\n")
+          await ctx.session.synthetic({ sessionID, text } as any)
         },
       })
       editor.add({
@@ -365,6 +407,7 @@ export default Plugin.define({
       try {
         for await (const event of ctx.event.subscribe({ signal: abort.signal }) as AsyncIterable<any>) {
           await track(event).catch(() => undefined)
+          await seats.onEvent(event, agentOf).catch(() => undefined)
           await bridge.onEvent(event, agentOf).catch(() => undefined)
           await continuation(event, agentOf).catch(() => undefined)
         }
@@ -374,6 +417,7 @@ export default Plugin.define({
     })()
     return async () => {
       abort.abort()
+      if (queued) clearTimeout(queued)
       await runtime.lsp.stopAll()
     }
   },

package/src/tui.tsx

@@ -117,6 +117,14 @@ export default Plugin.define({
       toast((await call("lspInstall", { id, user, token })).message, "success")
     })
 
+    // Panels open beside the session (the host goes fullscreen on narrow
+    // terminals; f toggles it, Esc or q closes it). Only a session route can
+    // show a panel: say so instead of doing nothing.
+    const openPanel = (name: string) => {
+      if (!context.ui.panel.open(name, { presentation: "panel" }))
+        toast("Open a session first: Epistemic Swarm panels show beside a session.", "info")
+    }
+
     const status = guarded(async () => {
       const result = await call("status")
       await context.ui.dialog.alert({
@@ -174,9 +182,15 @@ export default Plugin.define({
           group: "Epistemic Swarm",
           palette: true,
           slash: { name: "es-factory" },
-          run: () => {
-            context.ui.panel.open("factory", { presentation: "fullscreen" })
-          },
+          run: () => openPanel("factory"),
+        },
+        {
+          id: "es.panel.close",
+          title: "Epistemic Swarm: close the panel",
+          group: "Epistemic Swarm",
+          palette: true,
+          slash: { name: "es-close" },
+          run: () => context.ui.panel.close(),
         },
         {
           id: "es.panel.lsp",
@@ -184,9 +198,7 @@ export default Plugin.define({
           group: "Epistemic Swarm",
           palette: true,
           slash: { name: "es-lsp-panel" },
-          run: () => {
-            context.ui.panel.open("lsp", { presentation: "fullscreen" })
-          },
+          run: () => openPanel("lsp"),
         },
         {
           id: "es.panel.hooks",
@@ -194,9 +206,7 @@ export default Plugin.define({
           group: "Epistemic Swarm",
           palette: true,
           slash: { name: "es-hooks" },
-          run: () => {
-            context.ui.panel.open("hooks", { presentation: "fullscreen" })
-          },
+          run: () => openPanel("hooks"),
         },
         {
           id: "es.panel.brainstorm",
@@ -204,14 +214,20 @@ export default Plugin.define({
           group: "Epistemic Swarm",
           palette: true,
           slash: { name: "es-brainstorm" },
-          run: () => {
-            context.ui.panel.open("brainstorm", { presentation: "fullscreen" })
-          },
+          run: () => openPanel("brainstorm"),
         },
       ],
     }))
 
-    const stop = rpc.events.on("changed", (event: any) => toast(`Factory → ${event.data.stage}`))
+    // `changed` fires on every seat transition and es_* tool run: toast only
+    // a stage change, or an announcement such as a paused continuation.
+    let lastStage: string | undefined
+    const stop = rpc.events.on("changed", (event: any) => {
+      const { stage, notice } = event.data ?? {}
+      if (notice) toast(notice, "info")
+      if (lastStage !== undefined && stage !== lastStage) toast(`Factory → ${stage}`)
+      lastStage = stage
+    })
     return () => {
       stopPanels()
       stop()