@huynle/hub 0.9.2 → 0.10.1

package/src/central/registry.ts

@@ -16,6 +16,7 @@ import { BLOCKER_ID_MAX, StatusBoard, askBlocker, errorTypeLabel, permissionRequ
 import { sanitizeLabel } from "./agent/envelope"
 import { redactCredentials } from "../../packages/protocol/src/credentials.ts"
 import { DoneWatch } from "./done"
+import { FrontRelays, RelayRefused } from "./front-relays"
 import { SentenceStream } from "./say-stream"
 import type { ActivityStep, NotificationKind } from "./push"
 
@@ -53,7 +54,8 @@ export interface MachineRef {
 }
 
 /** A status tree entry as the hub reports it: working sessions carry when their current run started. */
-export type LiveStatus = SessionStatus & { readonly since?: number }
+/** `since`: a working entry's run start; `blockedSince`: when a blocked entry's oldest open blocker was first seen. */
+export type LiveStatus = SessionStatus & { readonly since?: number; readonly blockedSince?: number }
 
 /** Timer functions (injectable for tests). */
 export interface Timers {
@@ -125,6 +127,13 @@ export interface ActivityItem {
 export const ACTIVITY_LIMIT = 30
 /** Root sessions whose activity is remembered. */
 const ACTIVITY_ROOTS = 200
+/**
+ * (Session findability) Harnesses whose spokes report every prompt the hub carried as origin "hub" (Claude Code: a
+ * UserPromptSubmit after the hub's hubPrompt), so each of their user items was typed in the terminal.
+ */
+const HUB_PROMPTS_ORIGIN_HUB: ReadonlySet<string> = new Set(["claude-code"])
+/** Blocker first sightings kept (the oldest dropped first). */
+const BLOCKERS_SEEN = 5000
 
 /** A session counts as watched while a device reported it visible within this window. */
 export const PRESENCE_WINDOW_MS = 45_000
@@ -450,6 +459,10 @@ export const FRONT_GONE_MS = 10_000
 export type FrontAction =
   | { readonly kind: "adopt"; readonly mainID: string; readonly connID: string; readonly frontID: string }
   | { readonly kind: "remove"; readonly connID: string; readonly sessionID: string }
+  /** (P2) An update about a session the Concierge front relayed to: frontUpdate through the front's linking process. */
+  | { readonly kind: "update"; readonly connID: string; readonly mainID: string; readonly text: string; readonly finished?: boolean }
+
+export { RELAY_REASON, RELAYS_PER_UTTERANCE, RelayRefused } from "./front-relays"
 
 /** (voice front P1) The front in front of a main session: who created it, and whether a sessions frame listed it yet. */
 interface Front {
@@ -493,6 +506,10 @@ const isFrontInfo = (s: SessionInfo) => s.voiceFrontOf !== undefined || s.agent
 /** Older spokes reported exposed sessions only, without the field. */
 const isOn = (s: SessionInfo) => s.exposed !== false
 
+/** Recent terminal prompt inbox IDs remembered per root (replay dedupe), and roots remembered. */
+const TERMINAL_PROMPT_IDS = 256
+const TERMINAL_PROMPT_ROOTS = 2_000
+
 export class Registry {
   /** (REC-01) Voice recording taps; optional, best effort. */
   recordingTap?: RecordingTap
@@ -516,6 +533,10 @@ export class Registry {
   private readonly sessionsListeners = new Set<(connID: string) => void>()
   /** Called when the user's own prompt reached a session's inbox (typed or spoken in the harness). */
   private readonly humanTurnListeners = new Set<(sessionID: string, tenant?: string) => void>()
+  private readonly agentWorkListeners = new Set<(rootID: string, tenant: string, what: "turn" | "tool") => void>()
+  private readonly terminalPromptListeners = new Set<(rootID: string, tenant: string) => void>()
+  /** Root → its recently counted terminal prompt inbox IDs (an exact replay is counted once); bounded both ways. */
+  private readonly terminalPromptSeen = new Map<string, Set<string>>()
   private readonly sessionDeletedListeners = new Set<(sessionID: string, tenant: string) => void>()
   /** Pending form ID → its session and every connection that forwarded it, first first (like permissions). */
   private readonly forms = new Map<string, PendingForm>()
@@ -567,6 +588,8 @@ export class Registry {
   private readonly presence = new Map<string, { sessionID: string; at: number }>()
   /** Session → start time of its current run (session.execution.started). */
   private readonly since = new Map<string, number>()
+  /** (Session findability) Blocker ID → when this process first saw it (the "waiting 12m" of Needs you). */
+  private readonly blockerSeen = new Map<string, number>()
   /** Session → streamed text waiting for its send window. */
   private readonly streams = new Map<string, Stream>()
   /** Machine → its latest terminals frame and the connection that sent it. */
@@ -592,6 +615,63 @@ export class Registry {
     private readonly tenantOf: TenantOf = () => "",
   ) {
     this.doneWatch = new DoneWatch(timers, (rootID) => this.settledTree(rootID), (rootID) => this.alert("done", rootID))
+    this.relays = new FrontRelays({ now, timers, send: (update) => this.relayUpdate(update) })
+  }
+
+  /** (voice front P2) The Concierge front's relays: utterance bindings and the sessions it relayed to. */
+  private readonly relays: FrontRelays
+
+  /** (P2) The hub steered the user's utterance (from `deviceID`) into the active front of `mainID`. */
+  frontUtterance(mainID: string, inboxID: string, deviceID?: string, text?: string): void {
+    const front = this.fronts.get(mainID)
+    if (front) this.relays.utterance(front.frontID, inboxID, deviceID, text)
+  }
+
+  /**
+   * (P2) A relay the front `frontID` asks for over `connID`: the front's main and the utterance's device, with one
+   * relay taken from that utterance (`release` gives it back). RelayRefused unless `connID` links the active front
+   * and the front's latest input is a recent utterance of the user's with relays left.
+   */
+  takeRelay(connID: string, frontID: string): { readonly mainID: string } & ReturnType<FrontRelays["take"]> {
+    const mainID = this.frontMain.get(frontID)
+    const front = mainID === undefined ? undefined : this.fronts.get(mainID)
+    if (mainID === undefined || front?.frontID !== frontID) throw new RelayRefused("Not an active voice front")
+    if ((this.linker(front) ?? front.connID) !== connID) throw new RelayRefused("Only the front's own process relays for it")
+    return { mainID, ...this.relays.take(frontID) }
+  }
+
+  /** (P2) A relay reached `targetID`: its results go to the front of `mainID`. */
+  noteRelay(mainID: string, targetID: string, title: string, inboxID?: string): void {
+    this.relays.relayed(mainID, targetID, title, inboxID)
+  }
+
+  /** (P2) Sends an update about a relayed session to the front's linking process. */
+  private relayUpdate(update: { mainID: string; text: string; finished?: boolean }): void {
+    const front = this.fronts.get(update.mainID)
+    const connID = front ? (this.linker(front) ?? this.owner(front.frontID)) : undefined
+    if (connID === undefined) return
+    this.frontAction({ kind: "update", connID, mainID: update.mainID, text: update.text, ...(update.finished ? { finished: true } : {}) })
+  }
+
+  /**
+   * (P2) A session the Concierge front relayed to: its permission, question and failure are announced once as the
+   * Concierge's speech ("Hub API needs your permission to run a command."), and its root's events (from the process
+   * that owns it) feed the front's updates.
+   */
+  private observeRelayed(connID: string, sessionID: string, type: string, data: Record<string, unknown>): void {
+    const rootID = this.rootOf(sessionID) ?? sessionID
+    if (rootID === sessionID && (this.owner(rootID) ?? connID) === connID) this.relays.observe(rootID, type, data)
+    const target = this.relays.target(rootID)
+    if (!target || !this.fronts.has(target.mainID)) return
+    if (type === "permission.asked" || type === "form.created") return this.announceOwnAsk(type, sessionID, data, target.mainID, target.title)
+    if (type !== "session.execution.failed") return
+    const at = this.announcedFailures.get(sessionID)
+    if (at !== undefined && this.now() - at <= FAILURE_DEDUPE_MS) return
+    remember(this.announcedFailures, sessionID, this.now())
+    const message = (data.error as { message?: unknown } | undefined)?.message
+    const reason = redactCredentials(typeof message === "string" ? message : "").text.replace(/\s+/g, " ").trim().replace(/[.!]+$/, "").slice(0, ANNOUNCE_REASON_MAX)
+    const who = sessionID === rootID ? target.title : `A worker of ${target.title}`
+    this.announce(target.mainID, `announce:failed:${sessionID}`, reason ? `${who} failed: ${reason}.` : `${who} failed.`, true)
   }
 
   /**
@@ -753,6 +833,27 @@ export class Registry {
     return () => this.humanTurnListeners.delete(listener)
   }
 
+  /**
+   * (Session findability) Listens to the agent's work: a turn started (session.execution.started) or a tool called
+   * (session.tool.called), on the root session of the tree (subagents count for their root).
+   */
+  onAgentWork(listener: (rootID: string, tenant: string, what: "turn" | "tool") => void): () => void {
+    this.agentWorkListeners.add(listener)
+    return () => this.agentWorkListeners.delete(listener)
+  }
+
+  /**
+   * (Session findability) Listens to prompts the user typed in a session's terminal, on the root of the tree: a user
+   * inbox item the hub did not carry. Exact, never guessed: a spoke announcing inboxCarried (OpenCode, Codex) marks
+   * what the hub carried (`carried`); Claude Code reports the hub's prompts as origin "hub" (HUB_PROMPTS_ORIGIN_HUB).
+   * Any other spoke (an older OpenCode or Codex spoke) cannot tell them apart, so its user items are not reported
+   * here. Counted from the root's owner process only.
+   */
+  onTerminalPrompt(listener: (rootID: string, tenant: string) => void): () => void {
+    this.terminalPromptListeners.add(listener)
+    return () => this.terminalPromptListeners.delete(listener)
+  }
+
   /** Listens to sessions a spoke reports deleted (session.deleted, seen once by the pod holding the spoke). */
   onSessionDeleted(listener: (sessionID: string, tenant: string) => void): () => void {
     this.sessionDeletedListeners.add(listener)
@@ -901,6 +1002,7 @@ export class Registry {
         this.observeBoards(event, tenant)
         return
       }
+      this.blockerFirstSeen(data.id)
       const request = permissionRequest(data)
       const blocker = askBlocker(event)
       this.permissions.set(data.id, { connIDs: [connID], sessionID, tenant, ...(request ? { request } : {}), ...(blocker ? { blocker } : {}) })
@@ -910,6 +1012,7 @@ export class Registry {
     if (event.type === "form.created" && sessionID) {
       const formID = (data.form as Record<string, unknown> | undefined)?.id
       if (typeof formID === "string") {
+        this.blockerFirstSeen(formID)
         const known = this.forms.get(formID)
         if (known && !known.connIDs.includes(connID)) known.connIDs.push(connID)
         else if (!known) {
@@ -947,6 +1050,7 @@ export class Registry {
     if (sessionID) this.observeActivity(event, sessionID, data)
     if (sessionID) this.observeWorkerSpeech(event.type, sessionID, data)
     if (sessionID) this.observeWorkerBlockers(event.type, sessionID, data)
+    if (sessionID) this.observeRelayed(connID, sessionID, event.type, data)
 
     if (streamed && sessionID) {
       const rootID = this.rootOf(sessionID)
@@ -960,11 +1064,38 @@ export class Registry {
       const tenant = this.sessionTenant(sessionID)
       for (const listener of [...this.humanTurnListeners]) listener(sessionID, tenant)
     }
+    if (event.type === "session.inbox.delivered" && data.origin === "user" && data.carried !== true && sessionID && tenant !== undefined && this.terminalPromptListeners.size) {
+      const exact = conn.features.has("inboxCarried") || HUB_PROMPTS_ORIGIN_HUB.has(helloHarness(conn.hello).harness)
+      const rootID = this.rootOf(sessionID) ?? sessionID
+      const owner = this.owner(rootID)
+      if (exact && (owner === undefined || owner === connID) && this.firstTerminalPrompt(rootID, data.inboxID)) for (const listener of [...this.terminalPromptListeners]) listener(rootID, tenant)
+    }
+    if ((event.type === "session.execution.started" || event.type === "session.tool.called") && sessionID && tenant !== undefined && this.agentWorkListeners.size) {
+      const rootID = this.rootOf(sessionID) ?? sessionID
+      // Several processes may forward the same events: counted from the root's owner only (any, when none is known).
+      const owner = this.owner(rootID)
+      if (owner === undefined || owner === connID) for (const listener of [...this.agentWorkListeners]) listener(rootID, tenant, event.type === "session.tool.called" ? "tool" : "turn")
+    }
     if (event.type === "session.deleted" && sessionID) this.setConversation(sessionID, false)
+    if (event.type === "session.deleted" && sessionID) this.terminalPromptSeen.delete(sessionID)
     if (event.type === "session.deleted" && sessionID) for (const listener of [...this.sessionDeletedListeners]) listener(sessionID, tenant)
     if (closedPermission) this.permissionClosed(...closedPermission)
   }
 
+  /** A terminal prompt not counted before for this root (by inboxID; one without an ID always counts). */
+  private firstTerminalPrompt(rootID: string, inboxID: unknown): boolean {
+    if (typeof inboxID !== "string" || !inboxID) return true
+    let seen = this.terminalPromptSeen.get(rootID)
+    if (seen?.has(inboxID)) return false
+    if (seen) this.terminalPromptSeen.delete(rootID)
+    else seen = new Set()
+    this.terminalPromptSeen.set(rootID, seen)
+    seen.add(inboxID)
+    if (seen.size > TERMINAL_PROMPT_IDS) seen.delete(seen.values().next().value!)
+    if (this.terminalPromptSeen.size > TERMINAL_PROMPT_ROOTS) this.terminalPromptSeen.delete(this.terminalPromptSeen.keys().next().value!)
+    return true
+  }
+
   /** (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
@@ -1219,22 +1350,22 @@ export class Registry {
    * (voice front P1) Main's own permission or question while its front is active, once per request: "The session
    * needs your permission to run a command." / "The session has a question: Which branch?" (no command line, as push).
    */
-  private announceOwnAsk(type: string, sessionID: string, data: Record<string, unknown>): void {
+  private announceOwnAsk(type: string, sessionID: string, data: Record<string, unknown>, speakAs = sessionID, who = "The session"): void {
     const blocker = askBlocker({ type, data })
     if (!blocker) return
     const key = `${type} ${blocker.id}`
     if (this.announcedBlockers.has(key)) return
     remember(this.announcedBlockers, key, true)
-    if (blocker.kind === "permission") return this.announce(sessionID, `announce:permission:${blocker.id}`, `The session needs your permission to ${permissionPhrase(blocker.action)}.`, false)
+    if (blocker.kind === "permission") return this.announce(speakAs, `announce:permission:${blocker.id}`, `${who} needs your permission to ${permissionPhrase(blocker.action)}.`, false)
     // OpenCode's question tool titles its form "Questions": one question is read as itself (a field's description is
     // the question, its title the short header), several are counted.
     const fields = blocker.fields ?? []
-    if (blocker.question && fields.length > 1) return this.announce(sessionID, `announce:form:${blocker.id}`, `The session has ${fields.length} questions.`, false)
+    if (blocker.question && fields.length > 1) return this.announce(speakAs, `announce:form:${blocker.id}`, `${who} has ${fields.length} questions.`, false)
     // The blocker may drop descriptions to stay small: the event's own field has it.
     const raw = (data.form as { fields?: Array<{ description?: unknown }> } | undefined)?.fields?.[0]
     const question = fields.length === 1 ? (typeof raw?.description === "string" && raw.description.trim() ? raw.description : fields[0]!.description || fields[0]!.title) : undefined
     const title = spokenTitle(question || (blocker.question ? undefined : blocker.summary))
-    this.announce(sessionID, `announce:form:${blocker.id}`, title ? `The session has a question: ${title}` : "The session has a question.", false)
+    this.announce(speakAs, `announce:form:${blocker.id}`, title ? `${who} has a question: ${title}` : `${who} has a question.`, false)
   }
 
   /** Pairs a child session's latest assistant message with successful execution and speaks it once. */
@@ -1491,10 +1622,21 @@ export class Registry {
     return this.active.has(sessionID) || this.remoteBusy.has(sessionID)
   }
 
-  /** Adds `since` (run start) to working entries and agents' recommendations to permission blockers. */
+  /** When a blocker was first seen (now, the first time it is asked about). */
+  private blockerFirstSeen(id: string): number {
+    let at = this.blockerSeen.get(id)
+    if (at === undefined) remember(this.blockerSeen, id, (at = this.now()), BLOCKERS_SEEN)
+    return at
+  }
+
+  /**
+   * Adds `since` (run start) to working entries, `blockedSince` (when the oldest open blocker was first seen) to
+   * blocked ones, and agents' recommendations to permission blockers.
+   */
   private live(sessions: SessionStatus[]): LiveStatus[] {
     return sessions.map((s) => {
       const since = s.state === "working" ? this.since.get(s.id) : undefined
+      const blockedSince = s.state === "blocked" && s.blockers.length ? Math.min(...s.blockers.map((b) => this.blockerFirstSeen(b.id))) : undefined
       const recommended = s.blockers.some((b) => b.kind === "permission" && this.permissions.get(b.id)?.recommendation)
       const blockers = recommended
         ? s.blockers.map((b) => {
@@ -1502,8 +1644,8 @@ export class Registry {
             return recommendation ? { ...b, recommendation } : b
           })
         : s.blockers
-      const entry = recommended ? { ...s, blockers } : s
-      return since === undefined ? entry : { ...entry, since }
+      const entry: LiveStatus = recommended ? { ...s, blockers } : s
+      return since === undefined && blockedSince === undefined ? entry : { ...entry, ...(since !== undefined ? { since } : {}), ...(blockedSince !== undefined ? { blockedSince } : {}) }
     })
   }
 
@@ -1909,6 +2051,12 @@ export class Registry {
     this.emit({ type: "catalog" })
   }
 
+  /** (AF3) Conversation mode of a session now; `front` once a front was asked for (as its conversation messages). */
+  conversationOf(sessionID: string): { on: boolean; front?: boolean } {
+    const on = this.conversations.has(sessionID)
+    return { on, ...(on && this.frontWanted.has(sessionID) ? { front: this.fronts.has(sessionID) } : {}) }
+  }
+
   /** (voice front P1) The active front of a main session, if any. */
   frontOf(sessionID: string): string | undefined {
     return this.fronts.get(sessionID)?.frontID
@@ -2050,6 +2198,7 @@ export class Registry {
   private unmapFront(mainID: string): void {
     const front = this.fronts.get(mainID)
     if (!front) return
+    this.relays.forget(mainID, front.frontID)
     this.fronts.delete(mainID)
     if (this.frontMain.get(front.frontID) === mainID) this.frontMain.delete(front.frontID)
   }
@@ -2132,7 +2281,11 @@ export class Registry {
       case "session.deleted":
         return this.frontFailed(mainID)
       case "session.inbox.delivered":
-        if (typeof data.inboxID === "string") this.delivered(data.inboxID)
+        if (typeof data.inboxID === "string") {
+          this.delivered(data.inboxID)
+          // (P2) The front's latest input: an utterance of the user's may relay, a wake never.
+          this.relays.frontDelivered(frontID, data.inboxID)
+        }
         return
     }
   }

package/src/central/speech/service.ts

@@ -8,11 +8,13 @@ import {
   lowerLayers,
   resolveStt,
   resolveTts,
+  speechReady,
   speechView,
   updateSpeech,
   userSpeechView,
   type Resolved,
   type SpeechDefaults,
+  type SpeechReady,
   type SpeechView,
   type StoredSpeech,
   type UserSpeechView,
@@ -146,6 +148,13 @@ export class SpeechService {
     return openrouter ? withCurrent(parseModels(body), resolved.model) : speechModelList(kind, body, resolved.model)
   }
 
+  /** Whether each direction can work at all for the scope (a user's settings over the default; see speechReady). */
+  ready(userID?: string): SpeechReady {
+    const settings = this.options.store.speechSettings()
+    const user = this.userSettings(userID)
+    return speechReady(resolveStt(settings, this.options.defaults, user), resolveTts(settings, this.options.defaults, user))
+  }
+
   private userSettings(userID: string | undefined): StoredSpeech | undefined {
     return userID === undefined ? undefined : (this.options.store.userSpeech?.(userID) ?? {})
   }

package/src/central/spoke-ws.ts

@@ -234,6 +234,11 @@ export class SpokeHub {
   /** Cluster mode: the directory heartbeat, RPC responder and close notices are set up. */
   private readonly started: Promise<void>
   readonly websocket: WebSocketHandler<SpokeSocketData>
+  /**
+   * (voice front P2) Serves relayToSession for `owner` (the machine's owner) from `connID`: the hub's checks and the
+   * prompt (set by the hub once its acting engine exists). Unset: refused.
+   */
+  relayToSession?: (owner: string, connID: string, req: Extract<SpokeRequest, { op: "relayToSession" }>) => Promise<ResultFor["relayToSession"]>
 
   constructor(private readonly options: SpokeHubOptions) {
     const staleMs = options.staleMs ?? 60_000
@@ -731,6 +736,10 @@ export class SpokeHub {
         const next = req.sessionID ? `/s/${encodeURIComponent(req.sessionID)}${req.voice ? "?voice=1" : ""}` : "/"
         return { url: `${publicURL}/login?code=${code}&next=${next}` }
       }
+      case "relayToSession":
+        // A sandboxed (launch-bound) harness never relays as the user.
+        if (ws.data.launch || !this.relayToSession) throw new Error("This hub does not relay for this process")
+        return this.relayToSession(owner, ws.data.connID, req)
     }
   }
 
@@ -739,6 +748,10 @@ export class SpokeHub {
     const { registry } = this.options
     const failed = (cause: unknown) => console.error("[hub] voice front request failed:", cause instanceof Error ? cause.message : cause)
     if (action.kind === "remove") return void this.request(action.connID, { op: "removeFront", sessionID: action.sessionID }).catch(failed)
+    if (action.kind === "update") {
+      if (!registry.supports(action.connID, "conciergeFront")) return
+      return void this.request(action.connID, { op: "frontUpdate", sessionID: action.mainID, text: action.text, ...(action.finished ? { finished: true } : {}) }).catch(failed)
+    }
     this.request(action.connID, { op: "conversation", sessionID: action.mainID, on: true, front: true, frontID: action.frontID }).then((result) => registry.frontAnswer(action.mainID, action.connID, result.front?.sessionID), failed)
   }
 

package/src/central/store.ts

@@ -39,7 +39,7 @@ export interface UserRecord {
   viewPrefs?: ViewPrefs
   /** (RF2) Hosts and `*.suffix`es whose web images the console loads at once (normalised; absent = none). */
   mediaAllowlist?: string[]
-  /** Session ID → per-session Voice and complex-worker model overrides, oldest first. */
+  /** Session ID → per-session Voice model (the voice front's), oldest first. An older hub's worker entry is ignored. */
   modelPrefs?: Record<string, SessionModelPrefs>
   /** Session ID → when the user last read it (ms), least recently marked first. */
   reads?: Record<string, number>
@@ -998,25 +998,22 @@ export class Store {
 
   // ---------- per-user, per-session model preferences ----------
 
+  /** A session's Voice model (the voice front's); an obsolete Worker model stored by older hubs is left out. */
   modelPrefs(id: string, sessionID: string): SessionModelPrefs {
-    const prefs = this.user(id)?.modelPrefs?.[sessionID]
-    return prefs ? structuredClone(prefs) : {}
+    const voice = this.user(id)?.modelPrefs?.[sessionID]?.voice
+    return voice ? { voice: structuredClone(voice) } : {}
   }
 
-  setModelPrefs(id: string, sessionID: string, change: { voice?: ModelSelection | null; worker?: ModelSelection | null }): Promise<SessionModelPrefs> {
+  setModelPrefs(id: string, sessionID: string, change: { voice?: ModelSelection | null }): Promise<SessionModelPrefs> {
     return this.mutate((tx) => {
       const user = this.user(id)
       if (!user) return {}
       const all = user.modelPrefs ?? (user.modelPrefs = {})
-      const next: { voice?: ModelSelection; worker?: ModelSelection } = this.modelPrefs(id, sessionID)
-      for (const key of ["voice", "worker"] as const) {
-        if (!(key in change)) continue
-        const value = change[key]
-        if (value === null) delete next[key]
-        else if (value !== undefined) next[key] = structuredClone(value)
-      }
+      const next: { voice?: ModelSelection } = this.modelPrefs(id, sessionID)
+      if (change.voice === null) delete next.voice
+      else if (change.voice !== undefined) next.voice = structuredClone(change.voice)
       delete all[sessionID]
-      if (next.voice || next.worker) all[sessionID] = next
+      if (next.voice) all[sessionID] = next
       while (Object.keys(all).length > MODEL_PREFS_LIMIT) delete all[Object.keys(all)[0]!]
       tx.touch("users", id)
       return this.modelPrefs(id, sessionID)

package/src/config.ts

@@ -17,18 +17,17 @@ export interface VoiceConfig {
   /** Session IDs exposed when mode is "session". */
   readonly sessions: readonly string[]
   readonly machineName: string
-  /** Agent the voice orchestrator delegates work to in conversation mode. */
-  readonly subagent: string
   /** Start a local hub in the background when the server is loopback and nothing answers (default true). */
   readonly autoStartLocalHub: boolean
   /** Read open sessions and workspaces from the Herdr CLI (default true; the service process only). */
   readonly herdr: boolean
   /** History window of the session listing: root sessions from the last `days` days, at most `max`. */
   readonly list: ListWindow
-  /** Fast model the voice agent talks with in conversation mode ("provider/model[#variant]"). */
+  /**
+   * Fast model the voice front talks with in Voice mode ("provider/model[#variant]"); a session's Voice model in the
+   * console wins. Pick a fast paid model: free ones run out of quota (the front then falls back to the session).
+   */
   readonly voiceModel?: string
-  /** Model subagents work on; defaults to the session's model before conversation mode. */
-  readonly workModel?: string
   readonly machineID?: string
   readonly token?: string
 }
@@ -42,8 +41,26 @@ export const DEFAULT_LIST: ListWindow = Object.freeze({ days: 30, max: 100 })
 const LIST_LIMITS = { days: 365, max: 500 } as const
 
 export const DEFAULT_SERVER = "http://127.0.0.1:4097"
-export const DEFAULT_SUBAGENT = "general"
-const AGENT_ID = /^[A-Za-z0-9_.-]{1,64}$/
+/**
+ * Keys older plugins read and wrote for the removed "voice" agent: `subagent` (the agent it delegated to) and
+ * `workModel` (its workers' model). Read without error, ignored, never written; logged once per process.
+ */
+export const OBSOLETE_CONFIG_KEYS = ["subagent", "workModel"] as const
+const OBSOLETE_WHY: Record<(typeof OBSOLETE_CONFIG_KEYS)[number], string> = {
+  subagent: "the voice agent that delegated to it is gone",
+  workModel: "the voice agent whose workers used it is gone",
+}
+const warnedKeys = new Set<string>()
+
+/** Logs each obsolete key `raw` holds, once per `seen` (the process by default). */
+export function warnObsoleteKeys(raw: unknown, log: (line: string) => void = console.warn, seen: Set<string> = warnedKeys): void {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return
+  for (const key of OBSOLETE_CONFIG_KEYS) {
+    if (!(key in raw) || seen.has(key)) continue
+    seen.add(key)
+    log(`[hub] config.json: "${key}" is obsolete (${OBSOLETE_WHY[key]}: Voice mode always uses the voice front now); it is ignored and removed on the next save`)
+  }
+}
 const MODEL_REF = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.:\/-]+(?:#[A-Za-z0-9_.-]+)?$/
 
 export interface ModelRef {
@@ -98,7 +115,7 @@ export function prepareConfigPath(env: Env = process.env, home: string = homedir
 }
 
 export function defaults(machineName: string): VoiceConfig {
-  return { server: DEFAULT_SERVER, mode: "off", sessions: [], machineName, subagent: DEFAULT_SUBAGENT, autoStartLocalHub: true, herdr: true, list: { ...DEFAULT_LIST } }
+  return { server: DEFAULT_SERVER, mode: "off", sessions: [], machineName, autoStartLocalHub: true, herdr: true, list: { ...DEFAULT_LIST } }
 }
 
 /** Normalizes untrusted JSON into a config, falling back to defaults field by field. */
@@ -114,12 +131,10 @@ export function normalize(raw: unknown, machineName: string): VoiceConfig {
     mode,
     sessions,
     machineName: typeof r.machineName === "string" && r.machineName ? r.machineName : machineName,
-    subagent: typeof r.subagent === "string" && AGENT_ID.test(r.subagent) ? r.subagent : base.subagent,
     autoStartLocalHub: r.autoStartLocalHub !== false,
     herdr: r.herdr !== false,
     list: listWindow(r.list),
     ...(modelRef(r.voiceModel) ? { voiceModel: modelRef(r.voiceModel) } : {}),
-    ...(modelRef(r.workModel) ? { workModel: modelRef(r.workModel) } : {}),
     ...(typeof r.machineID === "string" && r.machineID ? { machineID: r.machineID } : {}),
     ...(typeof r.token === "string" && r.token ? { token: r.token } : {}),
   }
@@ -138,14 +153,16 @@ function listWindow(raw: unknown): ListWindow {
 
 export function readConfig(file: string, machineName: string): VoiceConfig {
   try {
-    return normalize(JSON.parse(readFileSync(file, "utf8")), machineName)
+    const raw = JSON.parse(readFileSync(file, "utf8"))
+    warnObsoleteKeys(raw)
+    return normalize(raw, machineName)
   } catch {
     return defaults(machineName)
   }
 }
 
 /** The keys VoiceConfig owns in config.json; every other key belongs to someone else and is preserved. */
-const CONFIG_KEYS = ["server", "mode", "sessions", "machineName", "subagent", "autoStartLocalHub", "herdr", "list", "voiceModel", "workModel", "machineID", "token"] as const satisfies readonly (keyof VoiceConfig)[]
+const CONFIG_KEYS = ["server", "mode", "sessions", "machineName", "autoStartLocalHub", "herdr", "list", "voiceModel", "machineID", "token"] as const satisfies readonly (keyof VoiceConfig)[]
 
 type RawConfig = Record<string, unknown>
 
@@ -215,7 +232,7 @@ export function writeConfig(file: string, config: VoiceConfig, options?: SecretF
     previous = readRawConfig(file) ?? {}
   } catch {}
   const next: RawConfig = { ...previous }
-  for (const key of CONFIG_KEYS) delete next[key]
+  for (const key of [...CONFIG_KEYS, ...OBSOLETE_CONFIG_KEYS]) delete next[key]
   writePrivate(file, serialize({ ...next, ...config }), options)
 }