@heretek-ai/epistemic-swarm 1.1.2 → 1.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heretek-ai/epistemic-swarm",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Epistemic Swarm: an AI build factory for OpenCode v2 — grill, research, spec, build, QA and release, gated mechanically.",
   "type": "module",
   "license": "Apache-2.0",
@@ -41,7 +41,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@heretek-ai/es-core": "1.1.2",
+    "@heretek-ai/es-core": "1.1.3",
     "@opencode/plugin": "2.0.24"
   },
   "devDependencies": {

package/src/continue.ts

@@ -1,40 +1,77 @@
 // Factory continuation: when the factory's own session finishes a turn while
 // work remains (not halted, not waiting on a human approval or the grill), we
-// re-prompt it to continue. Progress-aware: three idle turns without any state
-// change stop the loop so a confused agent cannot spin on budget.
-import { pendingApprovals } from "@heretek-ai/es-core"
+// re-prompt it to continue. Progress-aware (core's progressPrint: stage
+// machine, research artifacts, seat outcomes, audit head): three idle turns
+// without progress pause the loop so a confused agent cannot spin on budget,
+// and the pause is announced instead of silent. While one of its seats is
+// still running the factory is not re-prompted: the host wakes it when the
+// seat finishes (#60).
+import { headline, pendingApprovals, progressPrint, readLiveness } from "@heretek-ai/es-core"
 import type { Runtime } from "./runtime.ts"
+import type { SeatTracker } from "./seats.ts"
 
 const ACTIVE = new Set(["RESEARCH", "SPEC", "BUILD", "QA", "RELEASE"])
-const STALL_LIMIT = 3
+export const STALL_LIMIT = 3
+
+export interface FactoryContinuation {
+  (
+    event: { type: string; data?: { sessionID?: string } },
+    agentOf: (sessionID: string) => Promise<string | undefined>,
+  ): Promise<void>
+  /** The pause notice for the current run, if the loop paused and nothing has moved since. */
+  paused(): string | undefined
+}
 
 export function createFactoryContinuation(
   ctx: { session: { prompt(input: any): Promise<unknown> } },
   runtime: Runtime,
-) {
+  options: {
+    readonly seats?: Pick<SeatTracker, "hasRunningChildren">
+    readonly onPause?: (notice: string) => void
+  } = {},
+): FactoryContinuation {
   const stalls = new Map<string, { print: string; count: number }>()
-  return async (
+  let notice: string | undefined
+
+  const continuation = async (
     event: { type: string; data?: { sessionID?: string } },
     agentOf: (sessionID: string) => Promise<string | undefined>,
   ) => {
     const sessionID = event.data?.sessionID
-    if (event.type !== "session.execution.succeeded" || !sessionID) return
+    if (!sessionID) return
+    // The human (or the host) set the factory going again: the pause is over,
+    // and the restarted factory gets a fresh budget of idle turns.
+    if (event.type === "session.execution.started" && notice && (await agentOf(sessionID)) === "factory") {
+      notice = undefined
+      stalls.delete(sessionID)
+      return
+    }
+    if (event.type !== "session.execution.succeeded") return
     if ((await agentOf(sessionID)) !== "factory") return
+    if (options.seats?.hasRunningChildren(sessionID)) return
     const state = await runtime.factory.read()
     if (!state || !ACTIVE.has(state.stage)) return
     if ((await pendingApprovals(runtime.root)).length) return
-    const print = JSON.stringify([
-      state.stage,
-      state.activePhase,
-      state.phases.map((phase) => [phase.status, phase.failures, phase.history.length]),
-    ])
+    const liveness = await readLiveness(runtime.root, state)
+    const print = progressPrint(state, liveness)
     const previous = stalls.get(sessionID)
     const count = previous?.print === print ? previous.count + 1 : 0
     stalls.set(sessionID, { print, count })
-    if (count >= STALL_LIMIT) return
+    if (count >= STALL_LIMIT) {
+      if (count === STALL_LIMIT) {
+        const text = `Factory paused: ${STALL_LIMIT} turns in ${state.stage} without progress. Check es status, then run /factory to continue.`
+        notice = text
+        options.onPause?.(text)
+      }
+      return
+    }
+    notice = undefined
     await ctx.session.prompt({
       sessionID,
-      text: `${await runtime.factory.summary(state)}\nThe factory run is not finished. Continue from the current stage (no human is needed unless an approval is due).`,
+      text: `${await runtime.factory.summary(state)}\n${headline(state, liveness)}\nThe factory run is not finished. Continue from the current stage (no human is needed unless an approval is due).`,
     })
   }
+
+  const paused = () => notice
+  return Object.assign(continuation, { paused })
 }

package/src/panels.tsx

@@ -1,28 +1,53 @@
 // The four TUI panels: factory dashboard, LSP manager, hook inspector and
-// brainstorm board. Each is a session.panel slot contribution (the host
-// renders the one whose name is open) and reads structured state from the
-// server plugin over RPC — the same human-only channel the dialogs use. While
-// open, a panel refetches on every server `changed` event and every couple of
-// seconds, so it follows a running factory.
+// brainstorm board, plus the prompt-footer liveness indicator. Each panel is a
+// session.panel slot contribution (the host renders the one whose name is
+// open) and reads structured state from the server plugin over RPC — the same
+// human-only channel the dialogs use. While open, a panel refetches on every
+// server `changed` event and every couple of seconds, so it follows a running
+// factory. The host gives panels no key bindings of their own (#57): each
+// panel binds Esc/q (close), f (fullscreen) and r (refresh) through a keymap
+// layer created inside it, which the host scopes to the panel's focus, and
+// shows them in a footer row.
 import { createResource, createSignal, For, onCleanup, Show } from "solid-js"
 
 export type PanelCall = (method: string, input?: unknown) => Promise<any>
 /** Subscribe to server state changes; returns the unsubscribe function. */
 export type PanelSubscribe = (listener: () => void) => () => void
 
+/** The host's session.panel slot input (the parts a panel uses). */
+export interface PanelHandle {
+  readonly close: () => void
+  readonly toggleFullscreen: () => void
+}
+
+interface PanelKeyCommand {
+  readonly title: string
+  readonly bind: string
+  readonly run: () => void
+}
+/** The host's keymap.layer: a layer created during render belongs to that panel's focus scope. */
+export type PanelLayer = (factory: () => { readonly commands: readonly PanelKeyCommand[] }) => void
+
 export interface PanelProps {
   readonly call: PanelCall
   readonly subscribe: PanelSubscribe
+  readonly panel?: PanelHandle
+  readonly layer?: PanelLayer
 }
 
 export const PANEL_REFRESH_MS = 2_000
+export const FOOTER_REFRESH_MS = 5_000
 
-/** Panel data, refetched on change events and on an interval while mounted. */
-function usePanelState(props: PanelProps, method: string): { data: () => any; error: () => string | undefined } {
+/** Panel data, refetched on change events, on an interval while mounted, and on demand. */
+function usePanelState(
+  props: PanelProps,
+  method: string,
+  everyMs = PANEL_REFRESH_MS,
+): { data: () => any; error: () => string | undefined; refresh: () => void } {
   const [version, setVersion] = createSignal(0)
   const bump = () => setVersion((value) => value + 1)
   const unsubscribe = props.subscribe(bump)
-  const timer = setInterval(bump, PANEL_REFRESH_MS)
+  const timer = setInterval(bump, everyMs)
   onCleanup(() => {
     unsubscribe()
     clearInterval(timer)
@@ -35,13 +60,29 @@ function usePanelState(props: PanelProps, method: string): { data: () => any; er
         (error: any) => ({ error: String(error?.data?.reason ?? error?.message ?? error) }),
       ),
   )
-  return { data: () => state.latest?.data, error: () => state.latest?.error }
+  return { data: () => state.latest?.data, error: () => state.latest?.error, refresh: bump }
+}
+
+/** The panel's keys: Esc or q closes it, f toggles fullscreen, r refetches. */
+export const PANEL_KEYS_HINT = "esc/q close · f fullscreen · r refresh"
+
+function usePanelKeys(props: PanelProps, refresh: () => void) {
+  const panel = props.panel
+  if (!panel || !props.layer) return
+  props.layer(() => ({
+    commands: [
+      { title: "close", bind: "escape,q", run: () => panel.close() },
+      { title: "fullscreen", bind: "f", run: () => panel.toggleFullscreen() },
+      { title: "refresh", bind: "r", run: refresh },
+    ],
+  }))
 }
 
 const Frame = (props: { title: string; children?: any }) => (
   <box flexDirection="column" padding={1} gap={1}>
     <text>{props.title}</text>
     {props.children}
+    <text>{PANEL_KEYS_HINT}</text>
   </box>
 )
 
@@ -53,21 +94,24 @@ const Failed = (props: { error: () => string | undefined }) => (
 
 const FactoryPanel = (props: PanelProps) => {
   const state = usePanelState(props, "factoryState")
+  usePanelKeys(props, state.refresh)
   return (
     <Frame title="Factory dashboard">
       <Failed error={state.error} />
       <Show when={state.data()} fallback={<text>{state.error() ? "" : "Loading factory state…"}</text>}>
         {(data: () => any) => (
           <>
-            <text>
-              Stage: {data().stage}
-              {data().runId ? ` · ${data().runId}` : ""}
-            </text>
-            <text>
-              Spend: ${data().spend.usd.toFixed(2)}
-              {data().spend.ceilingUSD ? ` / $${data().spend.ceilingUSD}` : ""}
-              {data().spend.estimated ? " (estimated)" : ""}
-            </text>
+            <text>{data().headline}</text>
+            <Show when={data().header} fallback={<text>Stage: {data().stage}</text>}>
+              <text>{data().header}</text>
+            </Show>
+            <Show when={data().stage !== "NONE"}>
+              <text>
+                Spend: ${data().spend.usd.toFixed(2)}
+                {data().spend.ceilingUSD ? ` / $${data().spend.ceilingUSD}` : ""}
+                {data().spend.estimated ? " (estimated)" : ""}
+              </text>
+            </Show>
             <Show when={data().tree}>
               <text>
                 Design tree (round {data().tree.round}): {data().tree.settled} settled · {data().tree.open} open ·{" "}
@@ -75,36 +119,65 @@ const FactoryPanel = (props: PanelProps) => {
                 {data().tree.facts ? ` (${data().tree.facts} for research)` : ""}
               </text>
             </Show>
+            <Show when={data().paused}>
+              <text>⏸ {data().paused}</text>
+            </Show>
             <Show when={data().halt}>
               <text>HALTED: {data().halt}</text>
             </Show>
-            <Show when={data().release}>
-              <text>PR: {data().release}</text>
-            </Show>
             <Show when={data().pending.length}>
-              <text>Waiting on human: {data().pending.join(", ")}</text>
+              <text>
+                Waiting on you: approve {data().pending.join(", ")}: run `es approve {data().pending[0]}` in a terminal
+                (/es-approve previews it)
+              </text>
+            </Show>
+            <Show when={data().seats.length}>
+              <box flexDirection="column">
+                <text>Seats:</text>
+                <For each={data().seats}>{(line: string) => <text>{`  ${line}`}</text>}</For>
+              </box>
+            </Show>
+            <Show when={data().research}>
+              <text>Research: {data().research}</text>
+            </Show>
+            <Show when={data().phases.length}>
+              <box flexDirection="column">
+                <text>Phases:</text>
+                <For each={data().phases}>
+                  {(phase: any) => (
+                    <text>
+                      {phase.id === data().activePhase ? "▶ " : "  "}
+                      {phase.id}
+                      {phase.title ? ` ${phase.title}` : ""} · {phase.status} · failures {phase.failures}
+                    </text>
+                  )}
+                </For>
+              </box>
             </Show>
             <Show when={data().audits?.length}>
-              <text>Audits:</text>
-              <For each={data().audits}>
-                {(audit: any) => (
-                  <text>
-                    {"  "}
-                    {audit.id} · {audit.target} · {audit.status} r{audit.round} · t:{audit.thesis} a:{audit.antithesis}
-                    {audit.tiebreak ? ` x:${audit.tiebreak}` : ""}
-                  </text>
-                )}
-              </For>
+              <box flexDirection="column">
+                <text>Audits:</text>
+                <For each={data().audits}>
+                  {(audit: any) => (
+                    <text>
+                      {"  "}
+                      {audit.id} · {audit.target} · {audit.status} r{audit.round} · t:{audit.thesis} a:
+                      {audit.antithesis}
+                      {audit.tiebreak ? ` x:${audit.tiebreak}` : ""}
+                    </text>
+                  )}
+                </For>
+              </box>
+            </Show>
+            <Show when={data().events.length}>
+              <box flexDirection="column">
+                <text>Recent events:</text>
+                <For each={data().events}>{(line: string) => <text>{`  ${line}`}</text>}</For>
+              </box>
+            </Show>
+            <Show when={data().release}>
+              <text>PR: {data().release}</text>
             </Show>
-            <text>Phases:</text>
-            <For each={data().phases}>
-              {(phase: any) => (
-                <text>
-                  {phase.id === data().activePhase ? "▶ " : "  "}
-                  {phase.id} · {phase.status} · failures {phase.failures}
-                </text>
-              )}
-            </For>
           </>
         )}
       </Show>
@@ -114,6 +187,7 @@ const FactoryPanel = (props: PanelProps) => {
 
 const LspPanel = (props: PanelProps) => {
   const state = usePanelState(props, "lspState")
+  usePanelKeys(props, state.refresh)
   return (
     <Frame title="Language servers">
       <Failed error={state.error} />
@@ -140,6 +214,7 @@ const LspPanel = (props: PanelProps) => {
 
 const HooksPanel = (props: PanelProps) => {
   const state = usePanelState(props, "hooksState")
+  usePanelKeys(props, state.refresh)
   return (
     <Frame title="Hook bridge">
       <Failed error={state.error} />
@@ -172,6 +247,7 @@ const HooksPanel = (props: PanelProps) => {
 
 const BrainstormPanel = (props: PanelProps) => {
   const state = usePanelState(props, "brainstormState")
+  usePanelKeys(props, state.refresh)
   return (
     <Frame title="Brainstorm board">
       <Failed error={state.error} />
@@ -218,28 +294,54 @@ export const PANEL_COMPONENTS: Readonly<Record<string, (props: PanelProps) => an
   brainstorm: BrainstormPanel,
 }
 
-const PANELS = Object.entries(PANEL_COMPONENTS).map(([name, Panel]) => ({
-  name,
-  render: (props: PanelProps) => <Panel call={props.call} subscribe={props.subscribe} />,
-}))
+/** The prompt-footer liveness indicator: "ES · RESEARCH · es-research-alpha running · 12s"; hidden without a run. */
+export const FactoryFooter = (props: PanelProps) => {
+  const state = usePanelState(props, "status", FOOTER_REFRESH_MS)
+  return (
+    <Show when={state.data()?.footer}>
+      <text>{state.data().footer}</text>
+    </Show>
+  )
+}
+
+/**
+ * Claim a slot. The entry point moved across host releases: opencode 2.0.x
+ * exposes it as context.ui.slot (arity 1 object form or arity 2 name/render
+ * form), later hosts as bare context.slot. Without either the slot stays
+ * unclaimed, but setup must not throw (commands keep working).
+ */
+function claimSlot(context: any, name: string, render: (input: any) => any): (() => void) | undefined {
+  const slotFn = typeof context.slot === "function" ? context.slot : context.ui?.slot
+  if (typeof slotFn !== "function") return undefined
+  const dispose = slotFn.length <= 1 ? slotFn({ append: name, render }) : slotFn(name, render)
+  return typeof dispose === "function" ? dispose : undefined
+}
 
-/** Claim the session.panel slot once per panel; each claim filters by name. */
+/** Claim the session.panel slot once per panel (each claim filters by name), and the footer indicator. */
 export function registerPanels(context: any, call: PanelCall, subscribe: PanelSubscribe): () => void {
-  // Slot entry point moved across host releases: opencode 2.0.x exposes it
-  // as context.ui.slot (arity 1 object form or arity 2 name/render form),
-  // later hosts as bare context.slot. Without either, panels stay
-  // unregistered but setup must not throw (commands keep working).
-  const slotFn = typeof context.slot === "function" ? context.slot : context.ui?.slot
-  if (typeof slotFn !== "function") return () => {}
+  const layer: PanelLayer | undefined =
+    typeof context.keymap?.layer === "function" ? (factory) => context.keymap.layer(factory) : undefined
   const disposers: Array<() => void> = []
-  for (const panel of PANELS) {
-    const render = (input: { name: string }) => (input.name === panel.name ? panel.render({ call, subscribe }) : null)
-    const dispose = slotFn.length <= 1 ? slotFn({ append: "session.panel", render }) : slotFn("session.panel", render)
-    if (typeof dispose === "function") disposers.push(dispose)
+  for (const [name, Panel] of Object.entries(PANEL_COMPONENTS)) {
+    const dispose = claimSlot(context, "session.panel", (input: { name: string } & Partial<PanelHandle>) =>
+      input.name === name ? (
+        <Panel
+          call={call}
+          subscribe={subscribe}
+          {...(input.close && input.toggleFullscreen
+            ? { panel: { close: input.close, toggleFullscreen: input.toggleFullscreen } }
+            : {})}
+          {...(layer ? { layer } : {})}
+        />
+      ) : null,
+    )
+    if (dispose) disposers.push(dispose)
   }
+  const footer = claimSlot(context, "prompt.footer.status", () => <FactoryFooter call={call} subscribe={subscribe} />)
+  if (footer) disposers.push(footer)
   return () => {
     for (const dispose of disposers) dispose()
   }
 }
 
-export const PANEL_NAMES = PANELS.map((panel) => panel.name)
+export const PANEL_NAMES = Object.keys(PANEL_COMPONENTS)

package/src/policy.ts

@@ -22,6 +22,7 @@ import {
 import { Error as ToolError } from "@opencode/plugin/promise/tool"
 import { HOST_WEB_TOOLS } from "./agents.ts"
 import type { Runtime } from "./runtime.ts"
+import type { SeatTracker } from "./seats.ts"
 
 const WRITE_TOOLS = new Set(["write", "edit"])
 
@@ -49,10 +50,32 @@ const appendContent = (content: unknown, text: string) =>
       ? [...content, { type: "text", text }]
       : text
 
-export function createPolicyHooks(runtime: Runtime) {
-  const before = async (event: { tool: string; agent: string; id: string; input: unknown }) => {
+/**
+ * Factory seats launch seats in the foreground only (#60). A background seat
+ * ends the launcher's turn, and in a headless run that turn's process exits
+ * and suspends the seat until the next turn; the launcher then reads "no
+ * progress" as a stall and relaunches a second writer. A foreground call
+ * returns when the seat finishes; two calls in one message run in parallel.
+ */
+function guardSeatLaunch(event: { agent: string; input: Record<string, any> }, seats: SeatTracker | undefined) {
+  if (event.input.background === true)
+    deny(
+      "Factory seats run in the foreground: call the subagent tool without background (it returns when the seat finishes). To run a pair in parallel, put both subagent calls in the same message.",
+    )
+  const target = typeof event.input.agent === "string" ? event.input.agent : undefined
+  const live = target ? seats?.running(target).find((seat) => seat.sessionID !== event.input.sessionID) : undefined
+  if (live)
+    deny(
+      `${live.agent} is still running (session ${live.sessionID}, last activity ${live.lastActivityAt}); wait for it to finish instead of launching a second one. es_status lists the running seats.`,
+    )
+}
+
+export function createPolicyHooks(runtime: Runtime, seats?: SeatTracker) {
+  const before = async (event: { tool: string; agent: string; id: string; sessionID?: string; input: unknown }) => {
     const seat = seatOf(event.agent)
     const input = (event.input ?? {}) as Record<string, any>
+    if (seat && event.tool === "subagent") guardSeatLaunch({ agent: event.agent, input }, seats)
+    if (seat && event.sessionID) await seats?.onTool(event.sessionID, event.agent, event.tool)
     if (seat || event.tool.startsWith("es_")) {
       const stop = await checkStopFile(runtime.root)
       if (stop.stopped)

package/src/rpc-def.ts

@@ -23,9 +23,15 @@ const Preview = obj({ ok: { type: "boolean" }, title: str, lines: strArray, prob
 export const EsRpc = Rpc.define({
   id: "epistemic-swarm",
   methods: {
+    /** The summary block, plus the plain headline and the one-line footer indicator (absent without a run). */
     status: {
       input: obj({}),
-      output: obj({ summary: str, stage: str, pending: strArray }, ["summary", "stage", "pending"]),
+      output: obj({ summary: str, stage: str, pending: strArray, headline: str, footer: str, paused: str }, [
+        "summary",
+        "stage",
+        "pending",
+        "headline",
+      ]),
     },
     /** The effective config (JSON), the files it came from, and load warnings to show once. */
     configState: {
@@ -60,6 +66,13 @@ export const EsRpc = Rpc.define({
           phases: { type: "array" },
           pending: strArray,
           audits: { type: "array" },
+          /** Liveness (1.1.3), rendered on the server with core's formatters. */
+          headline: str,
+          header: str,
+          seats: strArray,
+          research: str,
+          events: strArray,
+          paused: str,
           tree: obj(
             Object.fromEntries(
               ["round", "total", "settled", "open", "deferred", "facts", "frontier"].map((key) => [
@@ -70,7 +83,7 @@ export const EsRpc = Rpc.define({
             ["round", "total", "settled", "open", "deferred", "facts", "frontier"],
           ),
         },
-        ["stage", "spend", "phases", "pending"],
+        ["stage", "spend", "phases", "pending", "headline", "seats", "events"],
       ),
     },
     lspState: {
@@ -119,6 +132,7 @@ export const EsRpc = Rpc.define({
     },
   },
   events: {
-    changed: { schema: obj({ stage: str, summary: str }, ["stage", "summary"]) },
+    /** The factory state changed; `notice` carries an announcement (a paused continuation). */
+    changed: { schema: obj({ stage: str, summary: str, notice: str }, ["stage", "summary"]) },
   },
 })

package/src/rpc.ts

@@ -10,23 +10,29 @@ import {
   capabilityLoss,
   commandSetHash,
   describeTarget,
+  eventLine,
   factorySummary,
+  footerLine,
   type HookEngine,
   hashJson,
+  headerLine,
+  headline,
   installServer,
   isTrusted,
   loadGatesConfig,
   readFrontier,
   readIdeas,
+  readLiveness,
   readPlan,
   readResult,
   readScores,
   recordConsent,
+  researchLine,
+  seatLine,
   treeCounts,
   verifyControl,
 } from "@heretek-ai/es-core"
 import type { Runtime } from "./runtime.ts"
-import { pendingApprovals } from "./tools.ts"
 
 interface Ticket {
   readonly kind: string
@@ -36,7 +42,12 @@ interface Ticket {
 
 const TTL_MS = 120_000
 
-export function createRpcHandlers(runtime: Runtime, _notify: () => Promise<void>, hooks?: HookEngine) {
+export function createRpcHandlers(
+  runtime: Runtime,
+  _notify: () => Promise<void>,
+  hooks?: HookEngine,
+  live: { readonly paused?: () => string | undefined } = {},
+) {
   const tickets = new Map<string, Ticket>()
   const issue = (kind: string, subject: unknown) => {
     const token = randomBytes(12).toString("hex")
@@ -74,10 +85,16 @@ export function createRpcHandlers(runtime: Runtime, _notify: () => Promise<void>
   return {
     status: async () => {
       const state = await runtime.factory.read()
+      const liveness = await readLiveness(runtime.root, state)
+      const paused = live.paused?.()
+      const footer = footerLine(state, liveness, paused)
       return {
         summary: await runtime.factory.summary(state),
         stage: state?.stage ?? "NONE",
-        pending: (await pendingApprovals(runtime.root)).map((item) => item.stage),
+        pending: liveness.pending.map((item) => item.stage),
+        headline: headline(state, liveness),
+        ...(footer ? { footer } : {}),
+        ...(paused ? { paused } : {}),
       }
     },
     configState: async () => ({
@@ -88,7 +105,16 @@ export function createRpcHandlers(runtime: Runtime, _notify: () => Promise<void>
     factoryState: async () => {
       const state = await runtime.factory.read()
       const frontier = await readFrontier(runtime.root).catch(() => undefined)
+      const liveness = await readLiveness(runtime.root, state)
+      const research = researchLine(liveness)
+      const paused = live.paused?.()
       return {
+        headline: headline(state, liveness),
+        ...(state ? { header: headerLine(state, liveness) } : {}),
+        seats: liveness.seats.map((seat) => seatLine(liveness, seat)),
+        ...(research ? { research } : {}),
+        events: liveness.events.map(eventLine),
+        ...(paused ? { paused } : {}),
         ...(frontier ? { tree: treeCounts(frontier) } : {}),
         stage: state?.stage ?? "NONE",
         ...(state?.runId ? { runId: state.runId } : {}),
@@ -107,7 +133,7 @@ export function createRpcHandlers(runtime: Runtime, _notify: () => Promise<void>
           failures: phase.failures,
           qa: Object.fromEntries(Object.entries(phase.qa).filter(([, verdict]) => verdict !== undefined)),
         })),
-        pending: (await pendingApprovals(runtime.root)).map((item) => item.stage),
+        pending: liveness.pending.map((item) => item.stage),
         audits: (state ? allAudits(state) : []).map((audit) => ({
           id: audit.id,
           target: describeTarget(audit.target),