@huynle/hub 0.8.3 → 0.8.5

package/src/config.ts

@@ -1,5 +1,5 @@
 // Per-machine spoke configuration, shared by every OpenCode process on the machine and edited
-// from the /hub dialog. Holds the machine token, so it is written with mode 0600.
+// from the /hub dialog. Holds the machine token, so it is written with mode 0600 (on Windows: an owner-only ACL).
 import { randomBytes } from "node:crypto"
 import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeSync } from "node:fs"
 import { homedir } from "node:os"
@@ -7,6 +7,7 @@ import path from "node:path"
 import { hubEnv, type Env } from "./env"
 import { APP_DIR, configBase, legacyPaths, migrateFirst } from "./migrate"
 import { isHubURL } from "./protocol"
+import { defaultWinAcl, isWin32, writeOwnerOnlyFile, type SecretFileOptions } from "./win-acl"
 
 export type Mode = "off" | "always" | "session"
 
@@ -169,8 +170,12 @@ export function readRawConfig(file: string): RawConfig | undefined {
   return parsed
 }
 
-/** Writes `content` to `file` atomically (a private temp file in the same directory, fsync, rename), mode 0600. */
-function writePrivate(file: string, content: string): void {
+/**
+ * Writes `content` to `file` atomically (a private temp file in the same directory, fsync, rename), mode 0600. On
+ * Windows the temporary file is restricted to the current user (an ACL) before the content is written (win-acl.ts).
+ */
+function writePrivate(file: string, content: string, options?: SecretFileOptions): void {
+  if (isWin32(options)) return writeOwnerOnlyFile(file, content, options?.acl ?? defaultWinAcl())
   mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 })
   const tmp = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`
   let fd: number | undefined
@@ -196,22 +201,22 @@ const serialize = (raw: RawConfig) => `${JSON.stringify(raw, null, 2)}\n`
  * returns the next one, written atomically with 0600. Refuses (throws, file untouched) when the file is not a JSON
  * object, so a hand-edited config is never replaced.
  */
-export function updateRawConfig(file: string, update: (raw: RawConfig) => RawConfig): void {
-  writePrivate(file, serialize(update(readRawConfig(file) ?? {})))
+export function updateRawConfig(file: string, update: (raw: RawConfig) => RawConfig, options?: SecretFileOptions): void {
+  writePrivate(file, serialize(update(readRawConfig(file) ?? {})), options)
 }
 
 /**
  * Atomic write with 0600 permissions. Lossless: keys config.json holds that VoiceConfig does not know are kept; the
  * known keys come from `config` (a known key it lacks is removed). A file that is not a JSON object is replaced.
  */
-export function writeConfig(file: string, config: VoiceConfig): void {
+export function writeConfig(file: string, config: VoiceConfig, options?: SecretFileOptions): void {
   let previous: RawConfig = {}
   try {
     previous = readRawConfig(file) ?? {}
   } catch {}
   const next: RawConfig = { ...previous }
   for (const key of CONFIG_KEYS) delete next[key]
-  writePrivate(file, serialize({ ...next, ...config }))
+  writePrivate(file, serialize({ ...next, ...config }), options)
 }
 
 /** Changing the server URL drops the machine credentials, which belong to the old server. */

package/src/index.ts

@@ -162,6 +162,33 @@ async function activity(kind: "service" | "standalone", directories: readonly st
   return { active: Object.keys(active ?? {}), jobs }
 }
 
+/**
+ * What OpenCode waits for in each session on this process's own server: its pending forms (session.form.list) and
+ * permission requests (session.permission.list). A session that cannot be read is left out; nothing when the
+ * server cannot be reached.
+ */
+async function pending(kind: "service" | "standalone", sessionIDs: readonly string[]) {
+  const client = await ownClient(kind).catch(() => undefined)
+  if (!client) return []
+  const out: Array<{ sessionID: string; forms: unknown[]; permissions: unknown[] }> = []
+  // One budget for the whole listing (the spoke gives up after 5 s too): a hung server stops being asked.
+  const signal = AbortSignal.timeout(PENDING_LIST_TIMEOUT_MS)
+  for (const sessionID of sessionIDs) {
+    if (signal.aborted) break
+    try {
+      const [forms, permissions] = await Promise.all([client.session.form.list({ sessionID }, { signal }), client.permission.list({ sessionID }, { signal })])
+      const list = (v: unknown) => unwrap<unknown[]>(v, Array.isArray)
+      out.push({ sessionID, forms: Array.isArray(list(forms)) ? list(forms) : [], permissions: Array.isArray(list(permissions)) ? list(permissions) : [] })
+    } catch {
+      // a session this server does not have (any more)
+    }
+  }
+  return out
+}
+
+/** How long one listing of pending forms and permissions may take on the own server. */
+const PENDING_LIST_TIMEOUT_MS = 5000
+
 /** Plugin API results may arrive bare or wrapped as { location, data }. */
 function unwrap<T>(value: unknown, isBare: (v: any) => boolean): T {
   const v = value as any
@@ -253,6 +280,7 @@ function hostFrom(ctx: Context, locations: () => PermissionLocation[], kind: "se
     },
     ...(canList(kind) ? { listRecent: (options?: { days: number; max: number; include: readonly string[]; signal?: AbortSignal }) => listRecent(kind, () => locations().map((l) => l.directory), options) } : {}),
     activity: (directories) => activity(kind, directories),
+    pending: (sessionIDs) => pending(kind, sessionIDs),
     // Fork and revert: over the own server's API (the plugin API has neither); only where it can be reached.
     ...(canList(kind)
       ? {

package/src/spoke/env-inject.ts

@@ -114,13 +114,28 @@ export function stripInheritedHubEnv(env: Env): void {
   for (const name of HUB_VARS) delete env[name]
 }
 
-/** Strips inherited HUB_*, sets the session's identity when it has one, and puts `binDir` first on PATH once. */
-export function applyHubEnv(env: Env, identity: Identity | undefined, binDir: string): void {
+/**
+ * Strips inherited HUB_*, sets the session's identity when it has one, and puts `binDir` first on PATH once. On
+ * win32 the variable is case-insensitive (usually `Path`) and ';'-separated: the one key keeps its name, entries
+ * compare without case, and no second `PATH` key is added (which one a child sees would be undefined).
+ */
+export function applyHubEnv(env: Env, identity: Identity | undefined, binDir: string, platform: string = process.platform): void {
   stripInheritedHubEnv(env)
   if (identity) {
     if (identity.url) env.HUB_URL = identity.url
     env.HUB_SESSION_TOKEN = identity.token
   }
+  if (platform === "win32") {
+    const keys = Object.keys(env).filter((k) => k.toLowerCase() === "path")
+    const key = keys.find((k) => env[k] !== undefined) ?? keys[0] ?? "Path"
+    const value = env[key]
+    for (const k of keys) delete env[k]
+    const same = (dir: string) => dir.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase() === binDir.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase()
+    const root = env.SystemRoot ?? env.SYSTEMROOT ?? "C:\\Windows"
+    const rest = value === undefined ? [`${root}\\System32`, root] : value.split(";").filter((dir) => dir && !same(dir))
+    env[key] = [binDir, ...rest].join(";")
+    return
+  }
   const rest = env.PATH === undefined ? DEFAULT_PATH : env.PATH.split(path.delimiter).filter((dir) => dir !== binDir)
   env.PATH = [binDir, ...rest].join(path.delimiter)
 }

package/src/spoke/launchers.ts

@@ -13,8 +13,16 @@
 // when nothing is there or it is hub's own link, and never when another `hub` is on PATH. ~/.local/bin/hubctl is left
 // to `hubctl setup`: it is the standalone hubctl's install path (a link there would make that install refuse to write
 // through it, and the launchers would exec themselves).
+//
+// On Windows (Phase 2) there are no sh scripts and no symlinks (they need Developer Mode or admin): the hub bin dir
+// gets hub.cmd and hubctl.cmd, which run ~\.local\bin\hubctl.exe when it is installed (decided at plugin start)
+// and the bundle otherwise, with BUN_BE_BUN set only inside the launcher (setlocal). ~\.local\bin\hub.cmd is a cmd
+// shim (packages/cli/src/bootstrap/transaction/shim.ts) to the bin dir's hub.cmd, under the same user-bin rule;
+// hubctl's own hub.cmd (a shim to hubctl.exe, link-hub) is the authority and is never touched. Older plugin versions
+// left POSIX launchers and a ~/.local/bin/hub symlink there; being hub's own, they are removed.
 import { accessSync, chmodSync, closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readlinkSync, readSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs"
 import path from "node:path"
+import { cmdShim, cmdWord, parseCmdShim } from "../../packages/cli/src/bootstrap/transaction/shim.ts"
 import { userBinLinkDecision, type UserBinEntry } from "../../packages/cli/src/setup/user-bin.ts"
 
 export const LAUNCHERS = ["hub", "hubctl"] as const
@@ -31,19 +39,35 @@ export interface LauncherOptions {
   readonly bun: boolean
   /** The CLI entry the runtime runs. */
   readonly entry: string
-  /** The standalone hubctl to prefer when it exists (standaloneHubctl(home)). */
+  /**
+   * The standalone hubctl to prefer when it exists (standaloneHubctl(home)). POSIX: checked when the launcher runs;
+   * win32: installLaunchers passes it only when it exists, and launcherScript then runs it unconditionally.
+   */
   readonly standalone?: string
+  /** The platform (default process.platform): "win32" writes cmd launchers. */
+  readonly platform?: string
 }
 
-/** Where `hubctl setup` installs the standalone hubctl (contract user-bin:hubctl). */
-export const standaloneHubctl = (home: string): string => path.join(home, ".local", "bin", "hubctl")
+const isWin = (platform: string | undefined) => (platform ?? process.platform) === "win32"
+
+/** Where `hubctl setup` installs the standalone hubctl (contract user-bin:hubctl, user-bin:hubctl.exe on Windows). */
+export const standaloneHubctl = (home: string, platform: string = process.platform): string => path.join(home, ".local", "bin", platform === "win32" ? "hubctl.exe" : "hubctl")
 
 /** A word quoted for sh. */
 const quote = (word: string) => `'${word.replaceAll("'", `'\\''`)}'`
 
 const LAUNCHER_HEADER = "#!/bin/sh\n# hub CLI launcher"
+const CMD_HEADER = "@rem hub CLI launcher"
+
+/** win32: a cmd file (CRLF, ASCII; every path one quoted word, see cmdWord). */
+function cmdLauncher({ execPath, bun, entry, standalone }: LauncherOptions): string {
+  const lines = standalone ? [`@${cmdWord(standalone)} %*`] : bun ? ["@setlocal", "@set BUN_BE_BUN=1", `@${cmdWord(execPath)} ${cmdWord(entry)} %*`] : [`@${cmdWord(execPath)} ${cmdWord(entry)} %*`]
+  return [`${CMD_HEADER}, written by the hub OpenCode plugin at start (edits are overwritten).`, ...lines, ""].join("\r\n")
+}
 
-export function launcherScript({ execPath, bun, entry, standalone }: LauncherOptions): string {
+export function launcherScript(options: LauncherOptions): string {
+  if (isWin(options.platform)) return cmdLauncher(options)
+  const { execPath, bun, entry, standalone } = options
   const command = bun ? `exec env BUN_BE_BUN=1 ${quote(execPath)} ${quote(entry)} "$@"` : `exec node ${quote(entry)} "$@"`
   const prefer = standalone ? `if [ -x ${quote(standalone)} ]; then exec ${quote(standalone)} "$@"; fi\n` : ""
   return `${LAUNCHER_HEADER}, written by the hub OpenCode plugin at start (edits are overwritten).\n${prefer}${command}\n`
@@ -62,6 +86,7 @@ export function cliEntry(root: string, bun: boolean): string | undefined {
  * reads half a file). Returns the names written.
  */
 export function installLaunchers(options: LauncherOptions & { readonly binDir: string }): { written: string[] } {
+  if (isWin(options.platform)) return installCmdLaunchers(options)
   const script = launcherScript(options)
   mkdirSync(options.binDir, { recursive: true, mode: 0o700 })
   const written: string[] = []
@@ -86,6 +111,34 @@ export function installLaunchers(options: LauncherOptions & { readonly binDir: s
   return { written }
 }
 
+/** win32: hub.cmd and hubctl.cmd (no modes); an older plugin's POSIX launchers there are removed. */
+function installCmdLaunchers(options: LauncherOptions & { readonly binDir: string }): { written: string[] } {
+  const { standalone, ...rest } = options
+  const script = launcherScript({ ...rest, ...(standalone && existsSync(standalone) ? { standalone } : {}) })
+  mkdirSync(options.binDir, { recursive: true, mode: 0o700 })
+  const written: string[] = []
+  for (const base of LAUNCHERS) {
+    const stale = path.join(options.binDir, base)
+    if (entryOf(stale) === "file" && isLauncher(stale)) rmSync(stale, { force: true })
+    const name = `${base}.cmd`
+    const file = path.join(options.binDir, name)
+    if (readText(file) === script) continue
+    const tmp = `${file}.${process.pid}.tmp`
+    writeFileSync(tmp, script)
+    renameSync(tmp, file)
+    written.push(name)
+  }
+  return { written }
+}
+
+const readText = (file: string): string | undefined => {
+  try {
+    return readFileSync(file, "latin1")
+  } catch {
+    return undefined
+  }
+}
+
 /** The user's own bin dir (contract root user-bin). */
 export const userBinDir = (home: string): string => path.join(home, ".local", "bin")
 
@@ -98,13 +151,13 @@ function entryOf(file: string): UserBinEntry {
   }
 }
 
-/** A file that starts like the launchers hub writes. */
-function isLauncher(file: string): boolean {
+/** A file that starts like the launchers hub writes (the cmd ones on win32). */
+function isLauncher(file: string, header: string = LAUNCHER_HEADER): boolean {
   let fd: number | undefined
   try {
     fd = openSync(file, "r")
-    const buffer = Buffer.alloc(LAUNCHER_HEADER.length)
-    return readSync(fd, buffer, 0, buffer.length, 0) === buffer.length && buffer.toString("utf8") === LAUNCHER_HEADER
+    const buffer = Buffer.alloc(header.length)
+    return readSync(fd, buffer, 0, buffer.length, 0) === buffer.length && buffer.toString("utf8") === header
   } catch {
     return false
   } finally {
@@ -126,17 +179,100 @@ function onPath(name: string, searchPath: string, skip: string): string | undefi
   return undefined
 }
 
+/** win32: PATH entries compare without case, separator style or a trailing separator. */
+const winKey = (dir: string) => dir.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase()
+
+/** win32: the first `name` with a PATHEXT extension on the ';'-separated `searchPath`, outside `skip`. */
+function onWinPath(name: string, searchPath: string, skip: string): string | undefined {
+  const exts = [".com", ".exe", ".bat", ".cmd"]
+  for (const dir of searchPath.split(";")) {
+    if (!dir || winKey(dir) === winKey(skip)) continue
+    for (const ext of exts) {
+      const file = path.join(dir, `${name}${ext}`)
+      try {
+        if (statSync(file).isFile()) return file
+      } catch {}
+    }
+  }
+  return undefined
+}
+
+/** win32: what a cmd file is, read as the user-bin rule sees links: a hub cmd shim is a link to its target. */
+function cmdEntryOf(file: string): { entry: UserBinEntry; pointsTo?: string } {
+  const entry = entryOf(file)
+  if (entry !== "file") return { entry }
+  let bytes: Uint8Array
+  try {
+    bytes = readFileSync(file)
+  } catch {
+    return { entry }
+  }
+  const target = parseCmdShim(bytes)
+  return target === undefined ? { entry } : { entry: "symlink", pointsTo: target }
+}
+
+/** win32: linkUserBin with cmd shims (see the header). */
+function linkUserBinCmd(options: { readonly home: string; readonly binDir: string; readonly path: string | undefined }): { linked: string[]; hint?: string } {
+  const userBin = userBinDir(options.home)
+  // An older plugin's symlink ~/.local/bin/hub → its POSIX launcher: hub's own, and unusable here.
+  const old = path.join(userBin, "hub")
+  if (entryOf(old) === "symlink") {
+    let to: string | undefined
+    try {
+      to = path.resolve(userBin, readlinkSync(old))
+    } catch {}
+    if (to !== undefined && (winKey(to) === winKey(path.join(options.binDir, "hub")) || isLauncher(to))) rmSync(old, { force: true })
+  }
+  const linkPath = path.join(userBin, "hub.cmd")
+  const target = path.join(options.binDir, "hub.cmd")
+  const { entry, pointsTo } = cmdEntryOf(linkPath)
+  const searchPath = options.path ?? ""
+  const onUserPath = searchPath.split(";").some((dir) => dir && winKey(dir) === winKey(userBin))
+  const pathHint = onUserPath ? undefined : `${userBin} is not on PATH: add it to your user PATH to use \`hub\` in your terminal`
+  // hubctl's link-hub shim to the standalone hubctl.exe: the authority, keep it.
+  if (pointsTo !== undefined && winKey(pointsTo) === winKey(standaloneHubctl(options.home, "win32"))) return { linked: [], ...(pathHint ? { hint: pathHint } : {}) }
+  const foundOnPath = onWinPath("hub", searchPath, options.binDir)
+  const decision = userBinLinkDecision({
+    entry,
+    ...(pointsTo !== undefined ? { pointsTo: winKey(pointsTo) === winKey(target) ? target : pointsTo } : {}),
+    target,
+    linkPath,
+    hubOwned: (p) => isLauncher(p, CMD_HEADER),
+    ...(foundOnPath !== undefined && winKey(foundOnPath) !== winKey(linkPath) ? { foundOnPath } : {}),
+  })
+  if (decision === "foreign") return { linked: [] }
+  if (decision === "shadowed") return { linked: [], hint: `\`hub\` on your PATH is ${foundOnPath}, not hub's CLI; hub's is ${target}` }
+  if (decision === "in-place") return { linked: [], ...(pathHint ? { hint: pathHint } : {}) }
+  mkdirSync(userBin, { recursive: true })
+  const shim = cmdShim(target)
+  // A new shim never replaces what may have appeared meanwhile ("wx"); hub's own is replaced atomically.
+  if (decision === "create") writeFileSync(linkPath, shim, { flag: "wx" })
+  else {
+    const tmp = `${linkPath}.${process.pid}.tmp`
+    rmSync(tmp, { force: true })
+    writeFileSync(tmp, shim)
+    try {
+      renameSync(tmp, linkPath)
+    } catch (cause) {
+      rmSync(tmp, { force: true })
+      throw cause
+    }
+  }
+  return { linked: ["hub.cmd"], ...(pathHint ? { hint: pathHint } : {}) }
+}
+
 /**
  * Links ~/.local/bin/hub to `binDir`/hub (see the header). Returns what it linked, and one hint when the user's
  * terminal will not find it (~/.local/bin not on `path`, or another `hub` comes first). Small synchronous calls,
  * nothing when converged (the plugin runs this at start).
  */
-export function linkUserBin(options: { readonly home: string; readonly binDir: string; readonly path: string | undefined; readonly defaultBinDir?: string | undefined }): { linked: string[]; hint?: string } {
+export function linkUserBin(options: { readonly home: string; readonly binDir: string; readonly path: string | undefined; readonly defaultBinDir?: string | undefined; readonly platform?: string }): { linked: string[]; hint?: string } {
   // Only the default hub bin dir (env-inject.ts defaultHubBinDir: the resolved state dir's bin, default
   // ~/.local/state/hub/bin): a custom HUB_STATE_DIR (tests, containers, a throwaway state) must never leave
   // ~/.local/bin pointing into it.
   const allowed = options.defaultBinDir ?? path.join(options.home, ".local", "state", "hub", "bin")
   if (path.resolve(options.binDir) !== path.resolve(allowed)) return { linked: [] }
+  if (isWin(options.platform)) return linkUserBinCmd(options)
   const userBin = userBinDir(options.home)
   const linkPath = path.join(userBin, "hub")
   const target = path.join(options.binDir, "hub")

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) => {
@@ -1784,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
@@ -1791,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.
@@ -1878,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) {
@@ -2030,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) }))