@huynle/hub 0.8.2 → 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

@@ -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 {
@@ -399,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>()
   /**
@@ -744,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)
@@ -769,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") {
@@ -816,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)
   }
 
   /**
@@ -841,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. */
@@ -872,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. */
@@ -1808,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/spoke-ws.ts

@@ -521,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)
   }
 

package/src/spoke/session-context.ts

@@ -2,9 +2,10 @@
 // a session's per-turn context; the spoke keeps it in this process's memory (like profile layers, profile-apply.ts):
 //
 // - parts: instructions then notes are appended by the plugin's context hook after the profile parts; the board goes
-//   after the conversation as a system message (V-01: it changes between turns, and OpenCode sends tools, system,
-//   then messages, so a board in the system prompt made every push re-write the cached conversation; see
-//   applySessionContext). The whole set replaces the previous one.
+//   after the conversation (V-01: it changes between turns, and OpenCode sends tools, system, then messages, so a
+//   board in the system prompt made every push re-write the cached conversation; see applySessionContext) as
+//   user-side <system-update> text (V-01b: OmniRoute hoists a system message after the conversation back into the
+//   system prompt). The whole set replaces the previous one.
 // - The kept tools are put in name order (the request lists them in the hook's record order).
 // - tools.allow: the exact tool names the session keeps; the hook deletes every other tool on every turn (unknown
 //   future tools included: fail closed). tools.deny: globs of tool names deleted as well.
@@ -73,22 +74,41 @@ function hint(message: HookMessage): void {
   if (part && part.cache === undefined) message.content[index] = { ...part, cache: EPHEMERAL }
 }
 
+/** (V-01b) The board as user-side text: in <system-update> tags, its markup escaped so no text can close them. */
+export function boardUpdate(tail: readonly string[]): string {
+  const text = tail
+    .join("\n\n")
+    .replace(/[\ud800-\udfff]/gu, "") // lone surrogates (a strict provider rejects the request)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+  return `<system-update>\n${text}\n</system-update>`
+}
+
 /**
  * (V-01) Adds a session context to a context hook's request so the provider's prompt cache survives a board change.
  * OpenCode sends tools, the system parts, then the messages; it puts cache breakpoints on the last tool, the first and
  * last system part and the last message (4 at most). The stable parts end the system prompt (the last one carries a
- * hint); the board follows the conversation as one system message (with a hint), and the conversation's last message
+ * hint); the board follows the conversation as one user message (with a hint), and the conversation's last message
  * gets a hint, so the next turn reads everything up to it from the cache whatever the board says. Without a board
- * nothing is added after the conversation; a request without messages gets the board in its system prompt.
+ * (or an empty one) nothing is added after the conversation; a request without messages gets the same <system-update>
+ * text at the end of its system prompt.
+ *
+ * (V-01b) The board is user-side text, never a system message: on the OmniRoute route (claude/claude-sonnet-5-5,
+ * measured through a logging proxy) a system message after the conversation is hoisted into the top-level system
+ * prompt, so a changed board invalidated the whole cached conversation again. The prompt's instructions say the
+ * board arrives in <system-update> tags and is never the user's words; boardUpdate escapes its markup.
  */
 export function applySessionContext(event: { system: HookPart[]; messages?: HookMessage[] }, system: readonly string[], tail: readonly string[]): void {
   const messages = Array.isArray(event.messages) ? event.messages : undefined
-  const ending = messages ? system : [...system, ...tail]
+  // (V-01b verify) An empty board adds nothing; a board is always the escaped <system-update> text, never raw.
+  const board = tail.filter((text) => text.trim() !== "")
+  const ending = messages || !board.length ? system : [...system, boardUpdate(board)]
   ending.forEach((text, i) => event.system.push(i === ending.length - 1 ? { type: "text", text, cache: EPHEMERAL } : { type: "text", text }))
-  if (!messages || !tail.length) return
+  if (!messages || !board.length) return
   const last = messages[lastIndex(messages, (m) => !isEffort(m))]
   if (last) hint(last)
-  messages.push({ role: "system", content: [{ type: "text", text: tail.join("\n\n"), cache: EPHEMERAL }] })
+  messages.push({ role: "user", content: [{ type: "text", text: boardUpdate(board), cache: EPHEMERAL }] })
 }
 
 /** Locked sessions kept at most (oldest dropped; the hub keeps 20 Concierge sessions per user). */

package/src/spoke/spoke.ts

@@ -1135,6 +1135,9 @@ export class Spoke {
         return {}
       case "rename":
         return this.rename(req.sessionID, req.title)
+      case "dismissError":
+        this.unheardFailures.delete(req.sessionID)
+        return { dismissed: this.tracker.dismissError(req.sessionID) } satisfies ResultFor["dismissError"]
       case "autoName":
         return this.autoName(req.sessionID)
       case "stop":

package/src/spoke/tracker.ts

@@ -94,7 +94,7 @@ export class SessionTracker {
   private readonly jobs = new Map<string, { sessionID: string; running: boolean }>()
   /** A session's pending retry (session.retry.scheduled, or a retry status), until its run moves on. */
   private readonly retries = new Map<string, RetryStatus>()
-  /** A session's last run failure, until its next run starts. */
+  /** A session's last run failure, until its next run starts (or the user dismisses it). */
   private readonly errors = new Map<string, CompactRunError>()
 
   /** Applies an event seen in this process. Returns true when the snapshot may have changed. */
@@ -339,6 +339,11 @@ export class SessionTracker {
     return this.errors.get(sessionID)
   }
 
+  /** Forgets the session's last run failure (the user dismissed it). True when there was one. */
+  dismissError(sessionID: string): boolean {
+    return this.errors.delete(sessionID)
+  }
+
   /** Sessions whose last run failed (no run started since). */
   failed(): string[] {
     return [...this.errors.keys()]

package/src/status.ts

@@ -271,6 +271,8 @@ interface Entry {
   error?: string
   errorType?: string
   errorStatus?: number
+  /** The error the user dismissed (fingerprint), so a seed of it (a spoke that cannot forget it) stays hidden. */
+  dismissed?: string
   blockers: Blocker[]
   jobs: JobInfo[]
 }
@@ -313,6 +315,7 @@ export class StatusBoard {
           entry.running = true
           entry.retry = undefined
           clearError(entry)
+          entry.dismissed = undefined
         })
       case "session.execution.succeeded":
       case "session.execution.interrupted":
@@ -321,6 +324,7 @@ export class StatusBoard {
         return this.update(data.sessionID, (entry) => {
           endRun(entry)
           setError(entry, data.error)
+          entry.dismissed = undefined
         })
       // Output resumed: the retry succeeded (OpenCode sends no status for it).
       case "session.text.delta":
@@ -349,10 +353,18 @@ export class StatusBoard {
         return this.unblock(data.sessionID, data.id)
       case "session.status":
         return this.update(data.sessionID, (entry) => setStatus(entry, data.status))
+      // Hub-defined: the user dismissed the session's last error (it shows again on its next failure).
+      case "session.error.dismissed": {
+        const entry = typeof data.sessionID === "string" ? this.sessions.get(data.sessionID) : undefined
+        if (!entry?.error) return false
+        entry.dismissed = fingerprint(entry)
+        clearError(entry)
+        return true
+      }
       case "session.seed":
         return this.update(data.sessionID, (entry) => {
           setStatus(entry, data.status)
-          if (typeof data.error?.message === "string" && data.error.message) setError(entry, data.error)
+          if (typeof data.error?.message === "string" && data.error.message && fingerprint(errorFields(data.error)) !== entry.dismissed) setError(entry, data.error)
           entry.jobs = entry.jobs.filter((job) => job.status !== "running")
           for (const job of Array.isArray(data.jobs) ? data.jobs : []) if (isJob(job)) upsertJob(entry, job)
         })
@@ -477,17 +489,31 @@ function setStatus(entry: Entry, status: any): void {
       ...(errorStatus !== undefined ? { errorStatus } : {}),
     }
   } else entry.retry = undefined
-  if (type === "busy") clearError(entry)
+  if (type === "busy") {
+    clearError(entry)
+    entry.dismissed = undefined
+  }
 }
 
 const ERROR_TYPE_MAX = 100
 const ERROR_MESSAGE_MAX = 1000
 
 /** A failed run's error: its message, type and status. */
+function errorFields(error: any): Pick<Entry, "error" | "errorType" | "errorStatus"> {
+  return {
+    error: typeof error?.message === "string" && error.message ? error.message.slice(0, ERROR_MESSAGE_MAX) : "failed",
+    errorType: text(error?.type, ERROR_TYPE_MAX),
+    errorStatus: num(error?.status),
+  }
+}
+
 function setError(entry: Entry, error: any): void {
-  entry.error = typeof error?.message === "string" && error.message ? error.message.slice(0, ERROR_MESSAGE_MAX) : "failed"
-  entry.errorType = text(error?.type, ERROR_TYPE_MAX)
-  entry.errorStatus = num(error?.status)
+  Object.assign(entry, errorFields(error))
+}
+
+/** An error as setError keeps it (message, type, status), to recognise a dismissed one when seeded again. */
+function fingerprint(entry: Pick<Entry, "error" | "errorType" | "errorStatus">): string {
+  return JSON.stringify([entry.error, entry.errorType ?? null, entry.errorStatus ?? null])
 }
 
 function clearError(entry: Entry): void {

package/web/dist/assets/{ArtifactPage-R0ZTpHca.js → ArtifactPage-CSotAWob.js}

@@ -1 +1 @@
-import{At as e,Et as t,ft as n,i as r,r as i,yt as a}from"./ui-Dh1-78Cl.js";import{L as o,R as s,z as c}from"./index-g4V9mfSr.js";import{t as l}from"./ArtifactWorkbench-sP2mZccC.js";var u=a(`<div class="feature-page av-page">`),d=a(`<a class="icon-btn av-back"href=/artifacts aria-label="All artifacts"title="All artifacts">`);function f(a){return(()=>{var f=u();return n(f,e(l,{get id(){return a.id},layout:`page`,get lead(){return[e(t,{get when(){return o()},get children(){return e(r,{icon:`menu`,label:`Open sidebar`,onClick:s})}}),(()=>{var t=d();return n(t,e(i,{name:`back`})),t})()]},get actions(){return e(r,{class:`av-wide`,icon:`split`,label:`Open in pane`,onClick:()=>c(a.id)})}})),f})()}export{f as default};
+import{At as e,Et as t,ft as n,i as r,r as i,yt as a}from"./ui-Qo2Pd9-O.js";import{L as o,R as s,z as c}from"./index-6mdQ7eUY.js";import{t as l}from"./ArtifactWorkbench-CkmWnP6L.js";var u=a(`<div class="feature-page av-page">`),d=a(`<a class="icon-btn av-back"href=/artifacts aria-label="All artifacts"title="All artifacts">`);function f(a){return(()=>{var f=u();return n(f,e(l,{get id(){return a.id},layout:`page`,get lead(){return[e(t,{get when(){return o()},get children(){return e(r,{icon:`menu`,label:`Open sidebar`,onClick:s})}}),(()=>{var t=d();return n(t,e(i,{name:`back`})),t})()]},get actions(){return e(r,{class:`av-wide`,icon:`split`,label:`Open in pane`,onClick:()=>c(a.id)})}})),f})()}export{f as default};

package/web/dist/assets/{ArtifactPane-C9KrBna8.js → ArtifactPane-DPHjiWce.js}

@@ -1 +1 @@
-import{At as e,Pt as t,ft as n,ht as r,r as i,yt as a}from"./ui-Dh1-78Cl.js";import{t as o}from"./ArtifactWorkbench-sP2mZccC.js";var s=a(`<a class=icon-btn aria-label="Full page"title="Open the artifact's full page">`);function c(a){return e(o,{get id(){return a.artifactID},layout:`pane`,onArtifact:e=>a.onTitle?.(e.title||`Untitled`),get actions(){return(()=>{var o=s();return n(o,e(i,{name:`expand`})),t(()=>r(o,`href`,`/artifacts/${encodeURIComponent(a.artifactID)}`)),o})()},get trailing(){return a.paneTools}})}export{c as ArtifactPane};
+import{At as e,Pt as t,ft as n,ht as r,r as i,yt as a}from"./ui-Qo2Pd9-O.js";import{t as o}from"./ArtifactWorkbench-CkmWnP6L.js";var s=a(`<a class=icon-btn aria-label="Full page"title="Open the artifact's full page">`);function c(a){return e(o,{get id(){return a.artifactID},layout:`pane`,onArtifact:e=>a.onTitle?.(e.title||`Untitled`),get actions(){return(()=>{var o=s();return n(o,e(i,{name:`expand`})),t(()=>r(o,`href`,`/artifacts/${encodeURIComponent(a.artifactID)}`)),o})()},get trailing(){return a.paneTools}})}export{c as ArtifactPane};