@huynle/hub 0.8.2 → 0.8.4

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

@@ -141,6 +141,12 @@ export interface SpokeHost {
    * were already running when this process started, or while its event stream was down.
    */
   activity?(directories: readonly string[]): Promise<{ readonly active: readonly string[]; readonly jobs: ReadonlyArray<JobInfo & { readonly sessionID: string }> }>
+  /**
+   * What OpenCode waits for in each of the sessions, from this process's own server: pending forms (FormInfo, as in
+   * form.created) and permission requests (as in permission.asked). A session it could not read is left out.
+   * Absent, or empty when the server cannot be reached: only what this process saw asked is re-announced.
+   */
+  pending?(sessionIDs: readonly string[]): Promise<ReadonlyArray<PendingAsks>>
   /**
    * Recent root sessions with their workspace: those in the history window (`days`, at most `max`), plus `include`
    * (always listed: open, running, ...). The background service lists every session; a foreground `opencode serve`
@@ -177,6 +183,13 @@ export interface SpokeHost {
   revertCommit?(sessionID: string): Promise<unknown>
 }
 
+/** A session's pending forms and permission requests as OpenCode lists them (raw, see SpokeHost.pending). */
+export interface PendingAsks {
+  readonly sessionID: string
+  readonly forms: readonly unknown[]
+  readonly permissions: readonly unknown[]
+}
+
 /** A form reply for OpenCode: an answer, or a cancel. */
 export type FormAction =
   | { readonly sessionID: string; readonly formID: string; readonly answer: FormAnswer }
@@ -205,6 +218,8 @@ export interface SpokeOptions {
   readonly forkNoteTimeoutMs?: number
   readonly snapshotIntervalMs?: number
   readonly seedIntervalMs?: number
+  /** Longest the own server may take to list a seed's pending forms and permissions (default 5 s). */
+  readonly pendingTimeoutMs?: number
   /** Delay before re-listing the service's sessions after a session event (default 2 s). */
   readonly seedDebounceMs?: number
   /** Longest one session listing may take before it is abandoned and later listings run (default 60 s). */
@@ -389,6 +404,15 @@ export class Spoke {
   private started = false
   /** A seedActivity call is in flight. */
   private seeding = false
+  /**
+   * Pending permissions and forms (`per <id>` / `frm <id>`) with the event that asked them, as forwarded: the hub
+   * keeps them only as long as this connection, so they are announced again after a reconnect (see reannounce).
+   * `seq` orders them against a pending listing (one asked while OpenCode was being asked is never closed by it).
+   */
+  private readonly asks = new Map<string, { sessionID: string; event: { type: string; data: Record<string, unknown> }; seq: number }>()
+  private askSeq = 0
+  /** Asks seen answered or cancelled (an ID never comes back): a listing taken before the reply cannot revive them. */
+  private readonly closedAsks = new Set<string>()
   /** Sessions shown by OpenCode TUIs (voice.presence). */
   private readonly presenceBook = new PresenceBook()
   /** Form replies waiting for a TUI to carry them out (when the plugin cannot reach its own server). */
@@ -907,6 +931,9 @@ export class Spoke {
       onWelcome: () => {
         this.sendSnapshot()
         this.sendTerminals(true)
+        // A new connection: the hub dropped what was pending with the old one (or restarted). What this process
+        // remembers goes out again at once; the seed then asks OpenCode what it still waits for.
+        this.reannounce()
         void this.seedActivity()
       },
       onState: (state, error) => {
@@ -1135,6 +1162,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":
@@ -1781,6 +1811,7 @@ export class Spoke {
         const title = (event.data as Record<string, unknown>).title
         if (typeof title === "string") for (const waiter of this.renameWaiters.get(sessionID) ?? []) waiter(title)
       }
+      this.trackAsk(event)
       if (this.tracker.observe(event, Date.now())) this.scheduleSnapshot()
       if (REVERT_EVENTS.has(event.type) && typeof sessionID === "string") void this.observeRevert(event, sessionID)
       if (typeof sessionID === "string") this.profiles.settle(sessionID) // a turn boundary makes a staged profile effective
@@ -1788,21 +1819,123 @@ export class Spoke {
         this.scheduleSeed()
       }
       void this.fetchInfo()
-      if (this.connection?.state === "connected" && (FORWARDED_EVENTS.has(event.type) || COMPACTED_EVENTS.has(event.type))) {
-        // Activity events go out compact: tool inputs become a short summary, outputs are dropped; job exits
-        // get their session from the job.
-        const compact = this.withOrigin(compactActivity({ type: event.type, data: (event.data ?? {}) as Record<string, unknown> }, (id) => this.tracker.jobSession(id)))
-        if (compact && shouldForward(this.config, this.tracker, compact)) {
-          this.announce(compact)
-          this.connection.send({ t: "event", event: compact })
-          if (compact.type === "session.execution.failed" && typeof sessionID === "string" && !this.announced.has(sessionID)) this.unheardFailures.add(sessionID)
-        }
-      }
+      this.forward(event)
     } catch (cause) {
       console.error("[hub] event handling failed", cause)
     }
   }
 
+  /** Sends an OpenCode event to the hub (compact), when connected and the hub may see its session. */
+  private forward(event: EventLike): void {
+    if (this.connection?.state !== "connected" || (!FORWARDED_EVENTS.has(event.type) && !COMPACTED_EVENTS.has(event.type))) return
+    // Activity events go out compact: tool inputs become a short summary, outputs are dropped; job exits
+    // get their session from the job.
+    const compact = this.withOrigin(compactActivity({ type: event.type, data: (event.data ?? {}) as Record<string, unknown> }, (id) => this.tracker.jobSession(id)))
+    if (!compact || !shouldForward(this.config, this.tracker, compact)) return
+    this.announce(compact)
+    this.connection.send({ t: "event", event: compact })
+    const sessionID = (event.data as Record<string, unknown> | undefined)?.sessionID
+    if (compact.type === "session.execution.failed" && typeof sessionID === "string" && !this.announced.has(sessionID)) this.unheardFailures.add(sessionID)
+  }
+
+  /** Keeps `asks` current: a permission or form asked, replied, cancelled, or its session deleted. */
+  private trackAsk(event: EventLike): void {
+    const data = (event.data ?? {}) as Record<string, any>
+    if (event.type === "permission.asked" && typeof data.id === "string" && typeof data.sessionID === "string") {
+      this.rememberAsk(`per ${data.id}`, data.sessionID, event)
+    } else if (event.type === "form.created" && typeof data.form?.id === "string" && typeof data.form?.sessionID === "string") {
+      this.rememberAsk(`frm ${data.form.id}`, data.form.sessionID, event)
+    } else if (event.type === "permission.replied" && typeof data.requestID === "string") this.closeAsk(`per ${data.requestID}`)
+    else if ((event.type === "form.replied" || event.type === "form.cancelled") && typeof data.id === "string") this.closeAsk(`frm ${data.id}`)
+    else if (event.type === "session.deleted" && typeof data.sessionID === "string") {
+      for (const [key, ask] of this.asks) if (ask.sessionID === data.sessionID) this.asks.delete(key)
+    }
+  }
+
+  private closeAsk(key: string): void {
+    this.asks.delete(key)
+    this.closedAsks.add(key)
+    if (this.closedAsks.size > ASKS_CLOSED_KEPT) this.closedAsks.delete(this.closedAsks.values().next().value!)
+  }
+
+  private rememberAsk(key: string, sessionID: string, event: EventLike): void {
+    if (this.closedAsks.has(key)) return
+    this.asks.delete(key)
+    this.asks.set(key, { sessionID, event: { type: event.type, data: (event.data ?? {}) as Record<string, unknown> }, seq: ++this.askSeq })
+    if (this.asks.size > ASKS_KEPT) this.asks.delete(this.asks.keys().next().value!)
+  }
+
+  /**
+   * Announces every pending permission and form again (after a reconnect: the hub dropped them with the old
+   * connection). A hub without "pendingReplay" would notify a re-sent permission again: it gets the forms only.
+   */
+  private reannounce(): void {
+    const permissions = this.hubSupports("pendingReplay")
+    for (const ask of [...this.asks.values()]) if (permissions || ask.event.type !== "permission.asked") this.forward(ask.event)
+  }
+
+  /**
+   * Asks OpenCode what the sessions wait for (the active ones, and those with something pending here): forms and
+   * permissions this process never saw asked (it started afterwards, or its stream was down) are announced; those
+   * it remembers that OpenCode no longer lists (answered while the stream was down) are closed on the hub.
+   */
+  private async reconcileAsks(active: readonly string[]): Promise<void> {
+    const pending = this.host.pending
+    if (!pending) return
+    // Sessions with something remembered first: a reply missed while the stream was down is only seen by asking.
+    const ids = [...new Set([...[...this.asks.values()].map((a) => a.sessionID).reverse(), ...active])].slice(0, PENDING_SESSIONS_MAX)
+    if (!ids.length) return
+    const asked = this.askSeq
+    const limit = this.options.pendingTimeoutMs ?? PENDING_TIMEOUT_MS
+    let timer: ReturnType<typeof setTimeout> | undefined
+    let lists: ReadonlyArray<PendingAsks>
+    try {
+      const listed = Promise.resolve(pending.call(this.host, ids))
+      listed.catch(() => {}) // a listing that fails after the timeout is not an unhandled rejection
+      const timeout = new Promise<never>((_, reject) => (timer = setTimeout(() => reject(new Error(`no answer within ${limit} ms`)), limit)))
+      lists = await Promise.race([listed, timeout])
+    } catch (cause) {
+      console.error("[hub] could not read pending questions and permissions", errorText(cause))
+      return
+    } finally {
+      clearTimeout(timer)
+    }
+    for (const list of lists) {
+      if (!ids.includes(list.sessionID)) continue
+      const listed = new Set<string>()
+      const found: EventLike[] = []
+      for (const form of Array.isArray(list.forms) ? list.forms : []) {
+        const f = form as Record<string, unknown> | null
+        if (typeof f?.id !== "string" || f.sessionID !== list.sessionID) continue
+        listed.add(`frm ${f.id}`)
+        if (!this.asks.has(`frm ${f.id}`) && !this.closedAsks.has(`frm ${f.id}`)) found.push({ type: "form.created", data: { form: f } })
+      }
+      for (const request of Array.isArray(list.permissions) ? list.permissions : []) {
+        const r = request as Record<string, unknown> | null
+        if (typeof r?.id !== "string" || r.sessionID !== list.sessionID) continue
+        listed.add(`per ${r.id}`)
+        if (!this.asks.has(`per ${r.id}`) && !this.closedAsks.has(`per ${r.id}`)) found.push({ type: "permission.asked", data: r })
+      }
+      const gone: EventLike[] = []
+      for (const [key, ask] of this.asks) {
+        if (ask.sessionID !== list.sessionID || ask.seq > asked || listed.has(key)) continue
+        const id = key.slice(4)
+        // unlisted: the hub drops only this process's hold on it (another process may still hold it).
+        gone.push(
+          key.startsWith("per ")
+            ? { type: "permission.replied", data: { sessionID: ask.sessionID, requestID: id, unlisted: true } }
+            : { type: "form.cancelled", data: { sessionID: ask.sessionID, id, unlisted: true } },
+        )
+      }
+      for (const event of [...found, ...gone]) {
+        this.trackAsk(event)
+        this.tasks.observe(event, Date.now())
+        if (this.tracker.observe(event, Date.now())) this.scheduleSnapshot()
+        this.forward(event)
+      }
+    }
+  }
+
   /**
    * Adds who put the item in the inbox (user or hub) to session.inbox.delivered, for hubs that route messages
    * (they reset reply-chain hops on a user's turn); when unknown, the event goes out unchanged.
@@ -1875,6 +2008,7 @@ export class Spoke {
         const event = { type: "session.seed", data: { sessionID: id, status, jobs, ...(error ? { error } : {}) } }
         if (this.connection?.state === "connected" && shouldForward(this.config, this.tracker, event)) this.connection.send({ t: "event", event })
       }
+      await this.reconcileAsks([...active])
       void this.fetchInfo()
       this.scheduleSnapshot()
     } catch (cause) {
@@ -2027,6 +2161,15 @@ const LISTING_TIMEOUT_MS = 60_000
 /** Directories whose shells are listed when seeding. */
 const SEED_DIRECTORIES = 20
 
+/** Pending permissions and forms remembered to announce again (oldest dropped). */
+const ASKS_KEPT = 200
+/** Answered or cancelled asks remembered (oldest dropped). */
+const ASKS_CLOSED_KEPT = 1000
+/** Sessions whose pending forms and permissions are read from OpenCode in one seed. */
+const PENDING_SESSIONS_MAX = 50
+/** Longest the own server may take to list them (SpokeOptions.pendingTimeoutMs). */
+const PENDING_TIMEOUT_MS = 5000
+
 /** Keeps the terminals frame within the protocol's limits. */
 function limitWorkspaces(workspaces: readonly HerdrWorkspace[]): HerdrWorkspace[] {
   return workspaces.slice(0, 200).map((w) => ({ id: w.id, label: w.label, directories: w.directories.slice(0, 20) }))

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

@@ -64,6 +64,8 @@ export interface FormFieldSpec {
 
 export const FORM_MAX_FIELDS = 20
 export const FORM_MAX_OPTIONS = 50
+/** Largest blocker kept and shown (JSON characters): the board, the catalog and the hub's kept copy carry it. */
+export const BLOCKER_MAX_BYTES = 64_000
 const FORM_TEXT_MAX = 2000
 const FORM_LABEL_MAX = 300
 const FIELD_TYPES = new Set<FormFieldSpec["type"]>(["string", "number", "integer", "boolean", "multiselect", "external"])
@@ -98,6 +100,22 @@ const SOURCE_ID_MAX = 200
 export const BLOCKER_MAX_RESOURCES = 10
 const BLOCKER_RESOURCE_MAX = 500
 
+/** Longest blocker ID (a longer one is no usable request) and permission summary kept. */
+export const BLOCKER_ID_MAX = 200
+const BLOCKER_SUMMARY_MAX = 2000
+
+/** The strings of `list` joined with ", ", at most `max` characters (never joins more than it keeps). */
+function joinBounded(list: unknown, max: number): string {
+  if (!Array.isArray(list)) return ""
+  let out = ""
+  for (const v of list) {
+    if (typeof v !== "string") continue
+    out = out ? `${out}, ${v}` : v
+    if (out.length >= max) return out.slice(0, max)
+  }
+  return out
+}
+
 /** Strings of `list`, bounded; `cut` is set when anything was dropped or shortened. */
 function boundedStrings(list: unknown, maxItems: number, maxLength: number): { items: string[]; cut: boolean } {
   if (!Array.isArray(list)) return { items: [], cut: list !== undefined }
@@ -134,7 +152,7 @@ function permissionBlocker(data: Record<string, any>): Blocker {
   return {
     kind: "permission",
     id: data.id,
-    summary: [data.action, (data.resources ?? []).join(", ")].filter(Boolean).join(": "),
+    summary: [action, joinBounded(data.resources, BLOCKER_SUMMARY_MAX)].filter(Boolean).join(": "),
     ...(action ? { action } : {}),
     ...(resources.length ? { resources } : {}),
   }
@@ -169,29 +187,55 @@ export function formFieldSpec(raw: any): FormFieldSpec | undefined {
   const d = raw.default
   if (typeof d === "boolean" || num(d) !== undefined) out.default = d
   else if (typeof d === "string") out.default = d.slice(0, FORM_TEXT_MAX)
-  else if (Array.isArray(d)) out.default = d.filter((x: unknown) => typeof x === "string").slice(0, FORM_MAX_OPTIONS)
+  else if (Array.isArray(d)) out.default = d.filter((x: unknown) => typeof x === "string").slice(0, FORM_MAX_OPTIONS).map((x: string) => x.slice(0, FORM_LABEL_MAX))
   if (Array.isArray(raw.when)) {
     const when = raw.when
       .filter((w: any) => typeof w?.key === "string" && (w.op === "eq" || w.op === "neq") && ["string", "number", "boolean"].includes(typeof w.value))
       .slice(0, 10)
-      .map((w: any) => ({ key: w.key, op: w.op, value: w.value }))
+      .map((w: any) => ({ key: w.key.slice(0, FORM_LABEL_MAX), op: w.op, value: typeof w.value === "string" ? w.value.slice(0, FORM_LABEL_MAX) : w.value }))
     if (when.length) out.when = when
   }
   return out as unknown as FormFieldSpec
 }
 
-/** A form.created event's form as a blocker. */
+/**
+ * A form.created event's form as a blocker, at most BLOCKER_MAX_BYTES: over it the descriptions go, then the fields
+ * (the card then asks to answer in the terminal).
+ */
 function formBlocker(form: any): Blocker {
-  const fields = Array.isArray(form.fields) ? form.fields.map(formFieldSpec).filter(Boolean).slice(0, FORM_MAX_FIELDS) : []
-  return {
-    kind: "form",
+  const fields: FormFieldSpec[] = []
+  for (const raw of Array.isArray(form.fields) ? form.fields : []) {
+    if (fields.length >= FORM_MAX_FIELDS) break
+    const field = formFieldSpec(raw)
+    if (field) fields.push(field)
+  }
+  const head = {
+    kind: "form" as const,
     id: form.id,
     summary: typeof form.title === "string" && form.title ? form.title.slice(0, FORM_LABEL_MAX) : "question",
     ...(form.metadata?.kind === "question" ? { question: true as const } : {}),
-    ...(fields.length ? { fields } : {}),
   }
+  const full: Blocker = { ...head, ...(fields.length ? { fields } : {}) }
+  if (JSON.stringify(full).length <= BLOCKER_MAX_BYTES) return full
+  const plain: Blocker = { ...head, fields: fields.map(withoutDescriptions) }
+  return JSON.stringify(plain).length <= BLOCKER_MAX_BYTES ? plain : head
 }
 
+function withoutDescriptions(field: FormFieldSpec): FormFieldSpec {
+  const { description: _, ...rest } = field
+  return rest.options ? { ...rest, options: rest.options.map(({ description: _d, ...option }) => option) } : rest
+}
+
+/** The blocker a permission.asked or form.created event shows (bounded); undefined for other events. */
+export function askBlocker(event: EventLike): Blocker | undefined {
+  const data = (event.data ?? {}) as Record<string, any>
+  if (event.type === "permission.asked" && usableID(data.id)) return permissionBlocker(data)
+  if (event.type === "form.created" && usableID(data.form?.id)) return formBlocker(data.form)
+  return undefined
+}
+
+const usableID = (id: unknown): id is string => typeof id === "string" && id.length > 0 && id.length <= BLOCKER_ID_MAX
+
 /** A model request OpenCode retries: the attempt, why, when the next one runs (epoch ms) and the error's type. */
 export interface RetryInfo {
   readonly attempt?: number
@@ -271,6 +315,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 +359,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 +368,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":
@@ -332,27 +380,39 @@ export class StatusBoard {
         entry.retry = undefined
         return true
       }
-      case "permission.asked":
-        return this.update(data.sessionID, (entry) => {
+      case "permission.asked": {
+        const blocker = askBlocker(event)
+        return !!blocker && this.update(data.sessionID, (entry) => {
           if (entry.blockers.some((b) => b.id === data.id)) return
-          entry.blockers.push(permissionBlocker(data))
+          entry.blockers.push(blocker)
         })
+      }
       case "permission.replied":
         return this.unblock(data.sessionID, data.requestID)
-      case "form.created":
-        return this.update(data.form?.sessionID, (entry) => {
+      case "form.created": {
+        const blocker = askBlocker(event)
+        return !!blocker && this.update(data.form?.sessionID, (entry) => {
           if (entry.blockers.some((b) => b.id === data.form.id)) return
-          entry.blockers.push(formBlocker(data.form))
+          entry.blockers.push(blocker)
         })
+      }
       case "form.replied":
       case "form.cancelled":
         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)
         })
@@ -377,6 +437,14 @@ export class StatusBoard {
     }
   }
 
+  /** Puts a pending blocker (askBlocker) back on a session of the tree. True when it was missing. */
+  restoreBlocker(sessionID: string, blocker: Blocker): boolean {
+    const entry = this.sessions.get(sessionID)
+    if (!entry || entry.blockers.some((b) => b.id === blocker.id)) return false
+    entry.blockers.push(structuredClone(blocker))
+    return true
+  }
+
   get(id: string): SessionStatus | undefined {
     const entry = this.sessions.get(id)
     return entry && view(entry)
@@ -477,17 +545,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-Cb1DcrQf.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-DifgVuKS.js";import{t as l}from"./ArtifactWorkbench-C37tZZ3e.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-XTnwXl-Y.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-C37tZZ3e.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};