@huynle/hub 0.8.1 → 0.8.3

package/src/central/recording/taps.ts

@@ -0,0 +1,105 @@
+// REC-01 registry taps (contract: Event schema → Hub): turn.started / first.token / turn.ended of the recorded root
+// session, tool rows (summary only, never the output), say.sent per spoken sentence, reply.full, utterance.delivered.
+// The registry calls these only from the session owner's connection; everything here is synchronous and cheap, the
+// writes happen in the recording service (asynchronous, best effort).
+import type { HubEventKind } from "../../protocol"
+import type { RecordingTap } from "../registry"
+
+export interface TapSink {
+  /** Records a hub event into every active recording of (userID, sessionID); a no-op without one. */
+  hub(userID: string, sessionID: string, kind: HubEventKind, fields: Record<string, unknown>): void
+  /** False when the user surely has no active recording (a fresh, empty cache); true when unsure. */
+  mayRecord(userID: string): boolean
+}
+
+const OUTCOMES: Record<string, "succeeded" | "failed" | "interrupted"> = {
+  "session.execution.succeeded": "succeeded",
+  "session.execution.failed": "failed",
+  "session.execution.interrupted": "interrupted",
+}
+const TOOL_STATES: Record<string, "called" | "success" | "failed"> = {
+  "session.tool.called": "called",
+  "session.tool.success": "success",
+  "session.tool.failed": "failed",
+}
+
+const remember = <K, V>(map: Map<K, V>, key: K, value: V, max = 1000) => {
+  map.delete(key)
+  map.set(key, value)
+  if (map.size > max) map.delete(map.keys().next().value as K)
+}
+
+export class RegistryTaps implements RecordingTap {
+  /** Root sessions whose turn started and whose first text delta is not seen yet. */
+  private readonly firstToken = new Set<string>()
+  /** Tool names by call ID (session.tool.input.started carries the name, the later events do not). */
+  private readonly tools = new Map<string, string>()
+
+  constructor(private readonly sink: TapSink) {}
+
+  wants(tenant: string, sessionID: string, type: string): boolean {
+    if (type === "session.text.delta") return this.firstToken.has(sessionID) && this.sink.mayRecord(tenant)
+    if (type === "session.execution.started") return true
+    return this.sink.mayRecord(tenant)
+  }
+
+  event(tenant: string, sessionID: string, type: string, data: Record<string, unknown>): void {
+    if (type === "session.execution.started") {
+      this.firstToken.add(sessionID)
+      if (this.firstToken.size > 1000) this.firstToken.delete(this.firstToken.values().next().value as string)
+      this.sink.hub(tenant, sessionID, "turn.started", {})
+      return
+    }
+    const outcome = OUTCOMES[type]
+    if (outcome) {
+      this.firstToken.delete(sessionID)
+      this.sink.hub(tenant, sessionID, "turn.ended", { outcome })
+      return
+    }
+    if (type === "session.text.delta") {
+      if (!this.firstToken.delete(sessionID)) return
+      const { assistantMessageID: messageID, ordinal } = data
+      this.sink.hub(tenant, sessionID, "first.token", { ...(typeof messageID === "string" ? { messageID } : {}), ...(typeof ordinal === "number" ? { ordinal } : {}) })
+      return
+    }
+    const callID = typeof data.id === "string" ? data.id : undefined
+    if (type === "session.tool.input.started") {
+      if (callID && typeof data.name === "string") remember(this.tools, callID, data.name.slice(0, 120))
+      return
+    }
+    const state = TOOL_STATES[type]
+    if (!state || !callID) return
+    const tool = this.tools.get(callID)
+    if (state !== "called") this.tools.delete(callID)
+    // The summary only (summarizeToolInput on the spoke): never the input itself, never the output or error.
+    const summary = state === "called" && typeof data.summary === "string" ? data.summary : undefined
+    this.sink.hub(tenant, sessionID, "tool", { callID, ...(tool ? { tool } : {}), ...(summary !== undefined ? { summary } : {}), state })
+  }
+
+  sentence(tenant: string, sessionID: string, messageID: string, ordinal: number, seq: number, text: string): void {
+    this.sink.hub(tenant, sessionID, "say.sent", { messageID, ordinal, seq, text })
+  }
+
+  reply(tenant: string, sessionID: string, messageID: string, ordinal: number, text: string): void {
+    if (!text.trim()) return
+    this.sink.hub(tenant, sessionID, "reply.full", { messageID, ordinal, text })
+  }
+
+  heard(tenant: string, sessionID: string, inboxID: string): void {
+    this.sink.hub(tenant, sessionID, "utterance.delivered", { inboxID })
+  }
+}
+
+/** A TTS ref header "<messageID>:<ordinal>:<seq>:<i>" (seq may be empty); undefined when malformed. */
+export function parseTtsRef(header: string | null): { messageID: string; ordinal: number; seq?: number; i: number } | undefined {
+  if (!header || header.length > 400) return undefined
+  const parts = header.split(":")
+  if (parts.length < 4) return undefined
+  const i = Number(parts.pop())
+  const seqText = parts.pop()!
+  const ordinal = Number(parts.pop())
+  const messageID = parts.join(":")
+  const seq = seqText === "" ? undefined : Number(seqText)
+  if (!messageID || !Number.isSafeInteger(i) || !Number.isSafeInteger(ordinal) || (seq !== undefined && !Number.isSafeInteger(seq))) return undefined
+  return { messageID, ordinal, ...(seq !== undefined ? { seq } : {}), i }
+}

package/src/central/recording/zip.ts

@@ -0,0 +1,138 @@
+// REC-01 streaming zip writer for recording exports (contract: Export response): the STORE method (no
+// compression; WAV hardly compresses), CRC-32 (Bun.hash.crc32), data descriptors (flag bit 3) so nothing is
+// buffered per entry, UTF-8 names (flag bit 11), no ZIP64 (RECORDING_LIMITS.userBytes keeps an export far below 4 GiB).
+
+export interface ZipEntry {
+  /** Path inside the archive ("manifest.json", "<id>/audio/000001.wav"). */
+  readonly name: string
+  /** The entry's bytes, read once when the writer reaches it; undefined writes an empty entry. */
+  body(): Promise<Uint8Array | ReadableStream<Uint8Array> | undefined>
+}
+
+const FLAGS = 0x0008 | 0x0800
+/** 1980-01-01 00:00 in DOS time (the exports carry their own timestamps in the manifest). */
+const DOS_TIME = 0
+const DOS_DATE = (0 << 9) | (1 << 5) | 1
+
+interface Written {
+  readonly name: Uint8Array
+  readonly offset: number
+  readonly crc: number
+  readonly size: number
+}
+
+const le = (size: number) => {
+  const bytes = new Uint8Array(size)
+  return { bytes, view: new DataView(bytes.buffer) }
+}
+
+function localHeader(name: Uint8Array): Uint8Array {
+  const { bytes, view } = le(30 + name.length)
+  view.setUint32(0, 0x04034b50, true)
+  view.setUint16(4, 20, true)
+  view.setUint16(6, FLAGS, true)
+  view.setUint16(8, 0, true)
+  view.setUint16(10, DOS_TIME, true)
+  view.setUint16(12, DOS_DATE, true)
+  // CRC and sizes follow in the data descriptor.
+  view.setUint16(26, name.length, true)
+  bytes.set(name, 30)
+  return bytes
+}
+
+function descriptor(crc: number, size: number): Uint8Array {
+  const { bytes, view } = le(16)
+  view.setUint32(0, 0x08074b50, true)
+  view.setUint32(4, crc, true)
+  view.setUint32(8, size, true)
+  view.setUint32(12, size, true)
+  return bytes
+}
+
+function centralEntry(entry: Written): Uint8Array {
+  const { bytes, view } = le(46 + entry.name.length)
+  view.setUint32(0, 0x02014b50, true)
+  view.setUint16(4, 20, true)
+  view.setUint16(6, 20, true)
+  view.setUint16(8, FLAGS, true)
+  view.setUint16(10, 0, true)
+  view.setUint16(12, DOS_TIME, true)
+  view.setUint16(14, DOS_DATE, true)
+  view.setUint32(16, entry.crc, true)
+  view.setUint32(20, entry.size, true)
+  view.setUint32(24, entry.size, true)
+  view.setUint16(28, entry.name.length, true)
+  view.setUint32(42, entry.offset, true)
+  bytes.set(entry.name, 46)
+  return bytes
+}
+
+function endOfDirectory(count: number, size: number, offset: number): Uint8Array {
+  const { bytes, view } = le(22)
+  view.setUint32(0, 0x06054b50, true)
+  view.setUint16(8, count, true)
+  view.setUint16(10, count, true)
+  view.setUint32(12, size, true)
+  view.setUint32(16, offset, true)
+  return bytes
+}
+
+/** The archive of `entries`, streamed: each entry's body is read only when the reader gets to it. */
+export function zipStream(entries: Iterable<ZipEntry> | AsyncIterable<ZipEntry>): ReadableStream<Uint8Array> {
+  async function* produce(): AsyncGenerator<Uint8Array> {
+    const written: Written[] = []
+    let offset = 0
+    for await (const entry of entries as AsyncIterable<ZipEntry>) {
+      const name = new TextEncoder().encode(entry.name)
+      const header = localHeader(name)
+      const start = offset
+      yield header
+      offset += header.length
+      let crc = 0
+      let size = 0
+      const body = await entry.body()
+      const take = (chunk: Uint8Array) => {
+        crc = Bun.hash.crc32(chunk, crc)
+        size += chunk.length
+        offset += chunk.length
+      }
+      if (body instanceof Uint8Array) {
+        take(body)
+        if (body.length) yield body
+      } else if (body) {
+        for await (const chunk of body as unknown as AsyncIterable<Uint8Array>) {
+          take(chunk)
+          if (chunk.length) yield chunk
+        }
+      }
+      crc >>>= 0
+      const tail = descriptor(crc, size)
+      yield tail
+      offset += tail.length
+      written.push({ name, offset: start, crc, size })
+    }
+    const directoryStart = offset
+    let directorySize = 0
+    for (const entry of written) {
+      const bytes = centralEntry(entry)
+      directorySize += bytes.length
+      yield bytes
+    }
+    yield endOfDirectory(written.length, directorySize, directoryStart)
+  }
+  const iterator = produce()
+  return new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        const { done, value } = await iterator.next()
+        if (done) controller.close()
+        else controller.enqueue(value)
+      } catch (cause) {
+        controller.error(cause)
+      }
+    },
+    async cancel() {
+      await iterator.return(undefined)
+    },
+  })
+}

package/src/central/registry.ts

@@ -11,7 +11,7 @@
 // another one and reaches it through SpokeHub.request (pod RPC). Events, alerts and speech stay with the pod that
 // holds the connection; remote state is never re-exported.
 import path from "node:path"
-import { HARNESS_OPENCODE, helloHarness, spokeFeatures, type EvidenceLevel, type ForwardedEvent, type Hello, type HerdrWorkspace, type ProcessKind, type SessionInfo, type SessionRevertInfo, type SpokeFeature, type SpokeMode, type TerminalInfo, type Terminals } from "../protocol"
+import { HARNESS_OPENCODE, helloHarness, spokeFeatures, type EvidenceLevel, type ForwardedEvent, type Hello, type HerdrWorkspace, type ProcessKind, type SessionInfo, type RevertCommitted, type SessionRevertInfo, type SpokeFeature, type SpokeMode, type TerminalInfo, type Terminals } from "../protocol"
 import { StatusBoard, errorTypeLabel, permissionRequest, providerFailureNeedsUser, providerRetryNeedsUser, type Blocker, type BlockerRecommendation, type PermissionRequest, type SessionStatus } from "../status"
 import { sanitizeLabel } from "./agent/envelope"
 import { DoneWatch } from "./done"
@@ -20,6 +20,23 @@ import type { ActivityStep, NotificationKind } from "./push"
 
 export { ACTIVITY_INTERVAL_MINUTES } from "./store"
 /** A tool call that took at least this long is named in activity updates (shorter ones are only counted). */
+/**
+ * (REC-01) Voice recording taps: what the hub sees of a recorded root session (docs/voice-recording.md). Called
+ * only from the session owner's connection (deduped like speakDelta), never changing behaviour; the tap writes
+ * only into recordings of `tenant` (the session's owner) and answers at once (its writes are asynchronous).
+ */
+export interface RecordingTap {
+  /** Cheap pre-check before an event is tapped (e.g. a text delta only while a first token is awaited). */
+  wants(tenant: string, sessionID: string, type: string): boolean
+  event(tenant: string, sessionID: string, type: string, data: Record<string, unknown>): void
+  sentence(tenant: string, sessionID: string, messageID: string, ordinal: number, seq: number, text: string): void
+  reply(tenant: string, sessionID: string, messageID: string, ordinal: number, text: string): void
+  heard(tenant: string, sessionID: string, inboxID: string): void
+}
+
+/** Spoke events a RecordingTap sees (root sessions only). */
+const TAPPED = new Set(["session.execution.started", "session.execution.succeeded", "session.execution.failed", "session.execution.interrupted", "session.tool.input.started", "session.tool.called", "session.tool.success", "session.tool.failed", "session.text.delta"])
+
 export const LONG_TOOL_MS = 30_000
 
 export class BusyError extends Error {
@@ -224,6 +241,8 @@ export interface SessionView extends BrowserFields {
   readonly terminal?: TerminalInfo
   /** A staged revert (feature "revert"), as the most recent report says. */
   readonly revert?: SessionRevertInfo
+  /** The latest committed revert's removed window (feature "revert"), as the most recent report says. */
+  readonly revertCommitted?: RevertCommitted
   /** (CON-04) A locked (Concierge) session: the agent and the context revision the most recent report says. */
   readonly agent?: string
   readonly contextRevision?: number
@@ -397,6 +416,9 @@ const eventSessionID = (event: ForwardedEvent): string | undefined => {
 const isOn = (s: SessionInfo) => s.exposed !== false
 
 export class Registry {
+  /** (REC-01) Voice recording taps; optional, best effort. */
+  recordingTap?: RecordingTap
+
   private readonly conns = new Map<string, Conn>()
   private readonly boards = new Map<string, StatusBoard>()
   /**
@@ -553,6 +575,12 @@ export class Registry {
     return conn && this.tenant(conn)
   }
 
+  /** The committed revert windows the connection reports for its own tenant's sessions (feature "revert"). */
+  revertCommits(connID: string): Array<{ sessionID: string; committed: RevertCommitted }> {
+    const conn = this.conn(connID)
+    return conn ? this.visible(conn).flatMap((s) => (s.revertCommitted ? [{ sessionID: s.id, committed: s.revertCommitted }] : [])) : []
+  }
+
   /** IDs of the sessions the connection reports for its own tenant (subagents included); empty when unknown. */
   reportedSessions(connID: string): string[] {
     const conn = this.conn(connID)
@@ -736,6 +764,7 @@ export class Registry {
     }
 
     if (sessionID) this.trackRun(event.type, sessionID)
+    if (sessionID && this.recordingTap && TAPPED.has(event.type)) this.tap(connID, tenant, sessionID, event.type, data)
     const before = sessionID ? this.status(sessionID)?.find((s) => s.id === sessionID) : undefined
     this.observeBoards(event, tenant)
     if (sessionID) this.activitySteps(event.type, sessionID, data, before)
@@ -761,6 +790,31 @@ export class Registry {
     if (closedPermission) this.permissionClosed(...closedPermission)
   }
 
+  /** (REC-01) Hands a root session's event to the recording tap once: from the session's owner connection only. */
+  private tap(connID: string, tenant: string | undefined, sessionID: string, type: string, data: Record<string, unknown>): void {
+    const tap = this.recordingTap
+    if (!tap || tenant === undefined) return
+    try {
+      if (!tap.wants(tenant, sessionID, type) || this.rootOf(sessionID) !== sessionID || this.owner(sessionID) !== connID) return
+      tap.event(tenant, sessionID, type, data)
+    } catch (cause) {
+      console.error(`[hub] recording tap failed: ${(cause as Error).message}`)
+    }
+  }
+
+  /** (REC-01) A tap call that never throws into the registry. */
+  private tapSafely(call: (tap: RecordingTap, tenant: string) => void, sessionID: string): void {
+    const tap = this.recordingTap
+    if (!tap) return
+    const tenant = this.sessionTenant(sessionID)
+    if (tenant === undefined) return
+    try {
+      call(tap, tenant)
+    } catch (cause) {
+      console.error(`[hub] recording tap failed: ${(cause as Error).message}`)
+    }
+  }
+
   /** Records when a session's run started (kept by the first process to report it while it runs). */
   private trackRun(type: string, sessionID: string): void {
     if (type === "session.execution.started") {
@@ -808,8 +862,10 @@ export class Registry {
 
   /** Remembers an utterance's inbox item so its delivery is reported as a heard event. */
   trackUtterance(sessionID: string, inboxID: string): void {
-    if (this.deliveries.delete(inboxID)) this.emit({ type: "heard", sessionID, inboxID })
-    else remember(this.utterances, inboxID, sessionID)
+    if (this.deliveries.delete(inboxID)) {
+      this.emit({ type: "heard", sessionID, inboxID })
+      this.tapSafely((tap, tenant) => tap.heard(tenant, sessionID, inboxID), sessionID)
+    } else remember(this.utterances, inboxID, sessionID)
   }
 
   /**
@@ -833,6 +889,7 @@ export class Registry {
     if (sessionID === undefined) return remember(this.deliveries, inboxID, true)
     this.utterances.delete(inboxID)
     this.emit({ type: "heard", sessionID, inboxID })
+    this.tapSafely((tap, tenant) => tap.heard(tenant, sessionID, inboxID), sessionID)
   }
 
   /** Root text streaming in conversation mode: each sentence is spoken as soon as it is complete. */
@@ -864,13 +921,16 @@ export class Registry {
     const state = this.rootSpeech.get(key) ?? { sessionID, connID: "", stream: new SentenceStream(), seq: 0 }
     this.rootSpeech.delete(key)
     for (const sentence of state.stream.end(text)) this.emitSentence(state, messageID, ordinal, sentence)
+    this.tapSafely((tap, tenant) => tap.reply(tenant, sessionID, messageID, ordinal, text), sessionID)
     // Nobody is listening on a phone: push the whole reply so it reaches a locked screen.
     if (text.trim() && !this.watched(sessionID)) this.alert("say", sessionID, { text })
   }
 
   private emitSentence(state: RootSpeech, messageID: string, ordinal: number, text: string): void {
     this.heardFrom(state.sessionID, text)
-    this.emit({ type: "say", sessionID: state.sessionID, messageID, ordinal, seq: state.seq++, text })
+    const seq = state.seq++
+    this.emit({ type: "say", sessionID: state.sessionID, messageID, ordinal, seq, text })
+    this.tapSafely((tap, tenant) => tap.sentence(tenant, state.sessionID, messageID, ordinal, seq, text), state.sessionID)
   }
 
   /** The run stopped or conversation mode ended: the rest of its text parts is not spoken. */
@@ -1174,6 +1234,15 @@ export class Registry {
   }
 
   /** Something in the session's tree is working or waiting for the user (typed input steers then). */
+  /**
+   * Whether a process reports a staged revert for the session (feature "revert"): anything admitted into it would
+   * commit the revert (OpenCode's next prompt does), so hub deliveries and act prompts wait or are refused.
+   */
+  revertStaged(sessionID: string): boolean {
+    for (const conn of this.all()) if (this.reports(conn, sessionID)?.revert) return true
+    return false
+  }
+
   running(sessionID: string): boolean {
     const state = this.browserFields(sessionID).state
     return state === "working" || state === "blocked"
@@ -1296,6 +1365,7 @@ export class Registry {
       updated: info.updated,
       ...(terminal ? { open: true, terminal } : {}),
       ...(info.revert ? { revert: info.revert } : {}),
+      ...(info.revertCommitted ? { revertCommitted: info.revertCommitted } : {}),
       ...(info.agent !== undefined ? { agent: info.agent } : {}),
       ...(info.contextRevision !== undefined ? { contextRevision: info.contextRevision } : {}),
       ...fields,
@@ -1745,10 +1815,12 @@ export class Registry {
   recommend(requestID: string, recommendation: BlockerRecommendation): boolean {
     const origin = this.permissions.get(requestID)
     if (!origin) return false
-    const why = recommendation.why === undefined ? "" : sanitizeLabel(recommendation.why, RECOMMENDATION_WHY_MAX)
+    // (R-03) Without recommends it only links the Decision: no why either.
+    const recommends = recommendation.recommends === "approve"
+    const why = !recommends || recommendation.why === undefined ? "" : sanitizeLabel(recommendation.why, RECOMMENDATION_WHY_MAX)
     origin.recommendation = {
       by: sanitizeLabel(recommendation.by, RECOMMENDATION_BY_MAX) || "An agent",
-      recommends: "approve",
+      ...(recommends ? { recommends: "approve" as const } : {}),
       ...(why ? { why } : {}),
       ...(recommendation.decisionID && DECISION_ID.test(recommendation.decisionID) ? { decisionID: recommendation.decisionID } : {}),
     }
@@ -1788,6 +1860,19 @@ export class Registry {
     }
   }
 
+  /**
+   * The user dismissed the session's last run failure: its status board stops showing it (consoles and the Concierge
+   * see the state leave "error") until it fails again. True when there was one to clear.
+   */
+  dismissError(sessionID: string): boolean {
+    const rootID = this.rootOf(sessionID)
+    const board = rootID === undefined ? undefined : this.boards.get(rootID)
+    if (rootID === undefined || !board?.observe({ type: "session.error.dismissed", data: { sessionID } })) return false
+    this.changed(this.sessionTenant(rootID))
+    this.emit({ type: "status", sessionID: rootID, sessions: this.live(board.snapshot().sessions) })
+    return true
+  }
+
   /** After a stop or interrupt: releases the turn locks in the session's tree and ends their waiting requests. */
   cancelTurns(sessionID: string): void {
     const rootID = this.rootOf(sessionID) ?? sessionID

package/src/central/revert-windows.ts

@@ -0,0 +1,66 @@
+// Committed revert windows (feature "revert", docs/session-view.md → Fork and revert). A committed revert removed a
+// session's history from the reverted message on; hub message rows (agent messages the session sent or got) from
+// the reverted message's time until the revert was staged belonged to that history (later ones were held for after
+// it, decision 3q94ez94). The spoke reports the latest window (SessionInfo.revertCommitted); the hub keeps every
+// window per (user, session) in the StateStore, so GET /api/sessions/:id/messages leaves those rows out for good
+// (also after the spoke restarts or another process reports the session).
+import type { RevertCommitted } from "../protocol"
+import type { StateStore } from "./backend/types"
+
+const COLLECTION = "revertWindows"
+/** Windows kept per session (the oldest go first). */
+export const REVERT_WINDOWS_MAX = 50
+
+export interface RevertWindow {
+  readonly from: number
+  readonly until: number
+  /** Commit time (identifies the commit). */
+  readonly at: number
+}
+
+interface Stored {
+  readonly windows: readonly RevertWindow[]
+}
+
+/** Whether a row at `at` falls into one of the windows. */
+export function inRevertWindow(at: unknown, windows: readonly RevertWindow[]): boolean {
+  return typeof at === "number" && windows.some((w) => at >= w.from && at < w.until)
+}
+
+export class RevertWindows {
+  /** Windows known stored (by user, session and the whole window): the frames that repeat them read nothing. */
+  private readonly stored = new Set<string>()
+
+  constructor(private readonly state: StateStore) {}
+
+  /**
+   * A reported window (each sessions frame repeats it): kept unless known stored. Only a stored (or already present)
+   * window is remembered, so one reported first without its start (nothing to store), or whose write failed, is taken
+   * again from the next frame. Errors are the caller's.
+   */
+  async observe(userID: string, sessionID: string, committed: RevertCommitted): Promise<void> {
+    if (committed.from === undefined || committed.until <= committed.from) return
+    const key = JSON.stringify([userID, sessionID, committed.from, committed.until, committed.at])
+    if (this.stored.has(key)) return
+    if (await this.record(userID, sessionID, committed)) this.stored.add(key)
+  }
+
+  async list(userID: string, sessionID: string): Promise<readonly RevertWindow[]> {
+    return (await this.state.get<Stored>(userID, COLLECTION, sessionID))?.value.windows ?? []
+  }
+
+  /**
+   * Keeps a reported window (one without a start removes no rows: skipped). True when it is stored now (new, or
+   * already there); false when skipped or the write lost a race (version check).
+   */
+  async record(userID: string, sessionID: string, committed: RevertCommitted): Promise<boolean> {
+    if (committed.from === undefined || committed.until <= committed.from) return false
+    const window: RevertWindow = { from: committed.from, until: committed.until, at: committed.at }
+    const current = await this.state.get<Stored>(userID, COLLECTION, sessionID)
+    const windows = current?.value.windows ?? []
+    if (windows.some((w) => w.at === window.at && w.from === window.from && w.until === window.until)) return true
+    const next = [...windows, window].slice(-REVERT_WINDOWS_MAX)
+    const result = await this.state.put<Stored>(userID, COLLECTION, sessionID, { windows: next }, current ? { ifVersion: current.version } : {})
+    return result.ok
+  }
+}

package/src/central/spoke-ws.ts

@@ -61,9 +61,12 @@ export interface Notifier {
 
 /** The spoke answered with an error, or disconnected before answering. */
 export class SpokeError extends Error {
-  constructor(message: string) {
+  /** The refusal's protocol code (Res.code, e.g. "busy", "not_found"), when the spoke sent one. */
+  readonly code?: string
+  constructor(message: string, code?: string) {
     super(message)
     this.name = "SpokeError"
+    if (code !== undefined) this.code = code
   }
 }
 
@@ -518,6 +521,8 @@ export class SpokeHub {
       const owner = this.options.registry.sessionTenant(sessionID)
       if (owner !== undefined && owner !== call.tenant) throw new SpokeError("Unknown session")
     }
+    // A dismissed error: the session's status board is this pod's (its connection is here), not the calling pod's.
+    if (call.kind === "spoke" && call.req.op === "dismissError") this.options.registry.dismissError(call.req.sessionID)
     return call.kind === "node" ? this.requestNode(call.connID, call.req) : this.request(call.connID, call.req)
   }
 
@@ -669,7 +674,7 @@ export class SpokeHub {
   }
 
   /** Resolves or rejects the pending request a `res` frame answers. */
-  private settle(connID: string, message: { readonly id: string; readonly ok: boolean; readonly result?: unknown; readonly error?: string }): void {
+  private settle(connID: string, message: { readonly id: string; readonly ok: boolean; readonly result?: unknown; readonly error?: string; readonly code?: string }): void {
     const pending = this.pending.get(message.id)
     if (!pending || pending.connID !== connID) return
     this.pending.delete(message.id)
@@ -683,7 +688,7 @@ export class SpokeHub {
       return pending.resolve(message.result)
     }
     if (message.ok) pending.resolve(message.result)
-    else pending.reject(new SpokeError(message.error || `OpenCode ${pending.op} request failed`))
+    else pending.reject(new SpokeError(message.error || `OpenCode ${pending.op} request failed`, message.code))
   }
 
   private async answer(ws: Socket, frame: Req<SpokeRequest>): Promise<void> {

package/src/central/teams/staffing.ts

@@ -547,7 +547,7 @@ export class TeamStaffingService {
   /** The launch body: the caller's, with the role's placement/harness/model/profile defaults and team labels. */
   private async launchSpec(userID: string, team: Team, role: TeamRoleSpec, base: unknown, requestID: string): Promise<Record<string, unknown>> {
     if (!isObj(base)) throw new AgentError("invalid", "launch must be a launch body (workspace, prompt, …)")
-    if (base.key !== undefined) throw new AgentError("invalid", "launch.key is set by staffing", { hint: "Send an Idempotency-Key header instead" })
+    if (base.key !== undefined) throw new AgentError("invalid", "launch.key is set by staffing", { hint: "Send idempotencyKey (the Idempotency-Key header) instead" })
     const labels = isObj(base.labels) ? base.labels : base.labels === undefined ? {} : undefined
     if (!labels) throw new AgentError("invalid", "launch.labels must be an object")
     if (TEAM_LAUNCH_LABEL in labels || TEAM_REQUEST_LABEL in labels) throw new AgentError("invalid", `launch.labels ${TEAM_LAUNCH_LABEL} and ${TEAM_REQUEST_LABEL} are set by staffing`)
@@ -567,7 +567,7 @@ export class TeamStaffingService {
       ...(agentProfile !== undefined ? { agentProfile } : {}),
       labels: { ...labels, [TEAM_LAUNCH_LABEL]: team.id, [TEAM_REQUEST_LABEL]: requestID },
     }
-    validateLaunchSpec(spec)
+    validateLaunchSpec(spec, { staffing: true })
     return spec
   }
 

package/src/index.ts

@@ -27,9 +27,10 @@ import path from "node:path"
 import { nodeConfigPath, readWorkspaceRoots } from "./spoke/node-roots"
 import { PromptReferences } from "./spoke/prompt-refs"
 import { PROFILE_TOOL, PROFILE_TOOL_DESCRIPTION, PROFILE_TOOL_INPUT } from "./spoke/profile-apply"
-import { replyPermission, vcsReader, type PermissionLocation, type VcsReader } from "./spoke/locations"
+import { listedNames, namesReader, replyPermission, serverNames, vcsReader, type PermissionLocation, type VcsReader } from "./spoke/locations"
 import { foregroundEndpoint, formOutcome } from "./spoke/own-server"
 import { joinProcess, type Membership } from "./spoke/singleton"
+import { applySessionContext, sortTools } from "./spoke/session-context"
 import { detectKind, Spoke, SpokeError, type FormAction, type SpokeHost } from "./spoke/spoke"
 
 /** Where the spoke keeps the IDs of Concierge sessions (always restricted to the Concierge's tools). */
@@ -171,15 +172,24 @@ function unwrap<T>(value: unknown, isBare: (v: any) => boolean): T {
 function permissionLocation(ctx: Context): PermissionLocation {
   const permission = ctx.permission as any
   const vcs = (ctx as any).vcs
+  const skill = (ctx as any).skill
+  const command = (ctx as any).command
   return {
     directory: ctx.location.directory,
     get: (input) => permission.get(input),
     reply: (input) => permission.reply(input),
-    // OpenCode's plugin vcs answers for this instance's location only (whatever location is passed).
+    // OpenCode's plugin vcs, skill and command lists answer for this instance's location only (whatever location is passed).
     ...(vcs?.diff && vcs?.get ? { vcs: vcsOf(vcs, ctx.location.directory) } : {}),
+    ...(skill?.list && command?.list ? { names: () => localNamesOf(skill, command, ctx.location.directory) } : {}),
   }
 }
 
+/** A plugin instance's own location's skill and command names (its lists answer only for that location). */
+async function localNamesOf(skill: any, command: any, directory: string) {
+  const [skills, commands] = await Promise.all([skill.list({ location: { directory } }), command.list({ location: { directory } })])
+  return { skills: listedNames(skills), commands: listedNames(commands) }
+}
+
 /** A vcs API's working-copy changes and current branch of a directory (plugin API or own-server client). */
 function vcsOf(vcs: any, directory: string) {
   return {
@@ -206,7 +216,10 @@ function hostFrom(ctx: Context, locations: () => PermissionLocation[], kind: "se
   const skill = (ctx as any).skill
   const command = (ctx as any).command
   const vcsRead = vcsReader(locations, async () => (canList(kind) ? serverVcs(await ownClient(kind).catch(() => undefined)) : undefined))
-  const names = (value: unknown) => (unwrap<ReadonlyArray<{ name?: unknown }>>(value, Array.isArray) ?? []).flatMap((item) => (typeof item?.name === "string" ? [item.name] : []))
+  const namesRead = namesReader(locations, async () => {
+    const client = canList(kind) ? await ownClient(kind).catch(() => undefined) : undefined
+    return client?.skill && client?.command ? serverNames(client) : undefined
+  })
   return {
     directory: ctx.location.directory,
     opencodeVersion: ctx.app?.version ?? "unknown",
@@ -253,14 +266,9 @@ function hostFrom(ctx: Context, locations: () => PermissionLocation[], kind: "se
       unwrap<{ id: string }>(await session.create({ location: { directory }, ...(title ? { title } : {}) }), (v) => typeof v.id === "string"),
     ...(mcp?.list ? { mcpList: async (directory: string) => unwrap<ReadonlyArray<unknown>>(await mcp.list({ location: { directory } }), Array.isArray) } : {}),
     // Hub profiles (src/spoke/profile-apply.ts): local skills/commands win over a profile's; its own need the tool.
-    ...(skill?.list && command?.list
-      ? {
-          localNames: async (directory: string) => {
-            const [skills, commands] = await Promise.all([skill.list({ location: { directory } }), command.list({ location: { directory } })])
-            return { skills: names(skills), commands: names(commands) }
-          },
-        }
-      : {}),
+    // Read in the session's own directory (src/spoke/locations.ts); unknown (undefined): the profile's skills and
+    // commands are not offered, never checked against another folder's names.
+    ...((skill?.list && command?.list) || canList(kind) ? { localNames: (directory: string) => namesRead(directory) } : {}),
     profileTool: typeof (ctx as any).tool?.transform === "function",
     // A directory's branch and changes: its own plugin instance, else the own server (src/spoke/locations.ts).
     ...(vcs?.diff || canList(kind) ? { vcsDiff: (directory: string) => vcsRead.diff(directory), vcsBranch: (directory: string) => vcsRead.branch(directory) } : {}),
@@ -364,12 +372,16 @@ export default definePlugin({
           // A hub profile: after OpenCode's own parts (local instructions win), for this session only.
           for (const text of spoke?.profiles.systemParts(event.sessionID) ?? []) event.system.push({ type: "text", text })
           if (event.tools && !spoke?.profiles.toolVisible(event.sessionID)) delete event.tools[PROFILE_TOOL]
-          // (CON-04) The hub's session context: its parts after the profile's, its denied tools removed.
-          for (const text of spoke?.contexts.systemParts(event.sessionID) ?? []) event.system.push({ type: "text", text })
+          // (CON-04) The hub's session context: its stable parts after the profile's, its board after the conversation
+          // (V-01: the prompt cache survives a board change), its denied tools removed, the kept tools in name order.
+          if (spoke) applySessionContext(event as any, spoke.contexts.systemParts(event.sessionID), spoke.contexts.tailParts(event.sessionID))
           if (event.tools) spoke?.contexts.filterTools(event.sessionID, event.tools as Record<string, unknown>)
           // The concierge agent keeps exactly CONCIERGE_TOOLS even without a hub context (a spoke that restarted before
           // the hub re-sent it): OpenCode 2.2.3 offers `skill` whatever the agent's rules say.
-          if (event.tools && event.agent === CONCIERGE_AGENT) for (const name of Object.keys(event.tools)) if (!(CONCIERGE_TOOLS as readonly string[]).includes(name)) delete event.tools[name]
+          if (event.tools && event.agent === CONCIERGE_AGENT) {
+            for (const name of Object.keys(event.tools)) if (!(CONCIERGE_TOOLS as readonly string[]).includes(name)) delete event.tools[name]
+            sortTools(event.tools as Record<string, unknown>)
+          }
         }),
       ),
       // The voice agent stops one worker ("cancel the deploy one") without stopping itself or the others.