@huynle/hub 0.8.0 → 0.8.1

package/src/central/agent/message-limits.ts

@@ -1,9 +1,27 @@
 // Loop protection for agent messages (design §3.4), over the backend interfaces with an injected clock.
 //
-// - HopTracker: every message carries a hop. A session's (or app's) depth is the deepest hop that reached it
-//   since its last human turn; what it sends carries depth + 1. The user sends hop 0, and a hop-0 message (or a
-//   human turn in the session) resets the depth. A hop over HOP_CAP is delivered without waking and the user
-//   is alerted (the delivery engine does both).
+// - HopTracker: every message carries a hop. A session's depth is the deepest hop that reached it since its last
+//   human turn; what it sends (msg, ask, reply, decline) carries depth + 1. The user sends hop 0, and a hop-0
+//   message (or a human turn in the session) resets the depth. A hop over HOP_CAP is delivered without waking and
+//   the user is alerted (the delivery engine does both).
+// - Apps (app:<tokenID>, including the hub's own app:concierge, the workspace coordinator and team intake) keep NO
+//   depth (S1, bug wge0vjdz; decision in Brain, tag fixup-0.8.1): one token serves many unrelated conversations and
+//   has no human turn to reset it, so a shared depth grew by 2 per ask/reply round trip and silenced the app for
+//   24 h after 4 of them. Instead the hop is per conversation: a NEW msg or ask from an app is hop 1, a reply or
+//   decline from an app is the hop of the message it answers + 1, and messages to an app raise nothing. Reply
+//   ping-pong through an app still counts up (the session side keeps its depth) and hits HOP_CAP. Session-to-session
+//   behaviour is unchanged.
+// - Relay depth (0.8.1 verify finding 1): so an app cannot launder a chain by relaying between sessions as NEW
+//   messages (A → app → B → app → A, each hop 1), an app remembers, per (user, app) and per sending session, the
+//   deepest hop it RECEIVED from a session in the last RELAY_WINDOW_MS (5 min; refreshed by each message, then it
+//   fades). Its new msg/ask carries that relay depth + 1 (else 1), counting only what OTHER sessions sent it: what
+//   the recipient itself sent is the same conversation, not a relay, so a one-to-one app conversation stays at hop 1
+//   at any pace (the S1 case; an app answering one session with new messages forever is held by the pair limit and
+//   the recipient's wake budget instead). A relay loop through an app thus reaches HOP_CAP after ~8 hops. Only
+//   session senders count (the user's hop 0 and other apps do not), and the hub's own parties (HUB_APP_TOKENS:
+//   app:concierge, the workspace coordinator, team intake) keep none: they send on events and submissions, not on
+//   the messages they receive (team intake carries the submitter's depth + 1 itself, SendOptions.chainHop). It is
+//   not a persistent depth: messages to an app still raise nothing beyond this time-boxed memory.
 // - MessageLimiter: fixed windows aligned to the clock (so retryAfter is exact): messages per sender→recipient
 //   pair and per user (refused with rate_limited), and wakes per recipient (exhausted: deliver without waking).
 import type { Clock, Counters, StateStore } from "../backend/types"
@@ -18,26 +36,67 @@ export const HOP_TTL_MS = 24 * 60 * 60_000
 
 export const overHopCap = (hop: number): boolean => hop > HOP_CAP
 
+/** How long what an app received from a session raises the app's new messages (relay depth). */
+export const RELAY_WINDOW_MS = 5 * 60_000
+/** Sending sessions remembered per (user, app); the oldest go first. */
+export const RELAY_SOURCES_MAX = 32
+/** The hub's own app parties (app:<tokenID>): no relay depth (see the header). */
+export const HUB_APP_TOKENS: ReadonlySet<string> = new Set(["concierge", "workspace-coordinator", "team-intake"])
+
 /** StateStore collection: partyKey → HopDepth. */
 const HOPS = "message-hops"
+/** StateStore collection: partyKey of an app → RelayDepth. */
+const RELAYS = "message-relays"
 
 interface HopDepth {
   readonly depth: number
   readonly at: number
 }
 
+interface RelayDepth {
+  /** Sending session → the deepest hop it sent the app, and when it last sent one. */
+  readonly sources: Readonly<Record<string, HopDepth>>
+}
+
+/** What a message continues: the message a reply or decline answers, and its recipient. */
+export interface HopContext {
+  readonly answering?: { readonly hop: number }
+  readonly to?: Party
+}
+
+const relays = (party: Party): party is Extract<Party, { kind: "app" }> => party.kind === "app" && !HUB_APP_TOKENS.has(party.tokenID)
+
 export class HopTracker {
   private readonly state: StateStore
   private readonly now: Clock
+  private readonly relayWindowMs: number
 
-  constructor(deps: { readonly state: StateStore; readonly now?: Clock }) {
+  constructor(deps: { readonly state: StateStore; readonly now?: Clock; readonly relayWindowMs?: number }) {
     this.state = deps.state
     this.now = deps.now ?? Date.now
+    this.relayWindowMs = deps.relayWindowMs ?? RELAY_WINDOW_MS
+  }
+
+  /**
+   * The hop a message from `from` carries. The user: 0. An app: a reply or decline (`answering`) is the answered
+   * message's hop + 1; a new msg or ask is its relay depth toward `to` + 1 (see the header). A session: its depth + 1.
+   */
+  async next(userID: string, from: Party, context: HopContext = {}): Promise<number> {
+    if (from.kind === "user") return 0
+    if (from.kind === "app") return (context.answering ? context.answering.hop : await this.relayDepth(userID, from, context.to)) + 1
+    return (await this.depth(userID, from)) + 1
   }
 
-  /** The hop a new message from `from` carries. */
-  async next(userID: string, from: Party): Promise<number> {
-    return from.kind === "user" ? 0 : (await this.depth(userID, from)) + 1
+  /** The deepest hop sessions other than `to` sent the app within the relay window (0: none; hub parties: 0). */
+  async relayDepth(userID: string, app: Party, to?: Party): Promise<number> {
+    if (!relays(app)) return 0
+    const entry = (await this.state.get<RelayDepth>(userID, RELAYS, partyKey(app)))?.value
+    const skip = to?.kind === "session" ? to.sessionID : undefined
+    let deepest = 0
+    for (const [sessionID, source] of Object.entries(entry?.sources ?? {})) {
+      if (sessionID !== skip && this.relayLive(source)) deepest = Math.max(deepest, source.depth)
+    }
+    return deepest
   }
 
   /** The deepest hop that reached the party since its last human turn (0: none, or forgotten). */
@@ -45,9 +104,13 @@ export class HopTracker {
     return this.live((await this.state.get<HopDepth>(userID, HOPS, partyKey(party)))?.value)
   }
 
-  /** A message with `hop` reached the party. */
-  async received(userID: string, to: Party, hop: number): Promise<void> {
-    if (to.kind === "user") return
+  /**
+   * A message with `hop` from `from` reached the party. Sessions keep a depth; an app (not a hub party) only
+   * remembers, for RELAY_WINDOW_MS, what each session sent it (relay depth); the user keeps nothing.
+   */
+  async received(userID: string, to: Party, hop: number, from?: Party): Promise<void> {
+    if (relays(to) && from?.kind === "session") return this.relayed(userID, to, from.sessionID, hop)
+    if (to.kind !== "session") return
     const at = this.now()
     await updateVersioned<HopDepth>(this.state, userID, HOPS, partyKey(to), (current) => ({ depth: hop === 0 ? 0 : Math.max(this.live(current), hop), at }))
   }
@@ -57,6 +120,21 @@ export class HopTracker {
     await this.state.delete(userID, HOPS, partyKey({ kind: "session", sessionID }))
   }
 
+  private async relayed(userID: string, app: Party, sessionID: string, hop: number): Promise<void> {
+    const at = this.now()
+    await updateVersioned<RelayDepth>(this.state, userID, RELAYS, partyKey(app), (current) => {
+      const live = Object.entries(current?.sources ?? {}).filter(([id, source]) => id !== sessionID && this.relayLive(source))
+      const previous = current?.sources[sessionID]
+      const depth = Math.max(previous && this.relayLive(previous) ? previous.depth : 0, hop)
+      const kept = live.sort((a, b) => b[1].at - a[1].at).slice(0, RELAY_SOURCES_MAX - 1)
+      return { sources: Object.fromEntries([[sessionID, { depth, at }], ...kept]) }
+    })
+  }
+
+  private relayLive(source: HopDepth): boolean {
+    return this.now() - source.at < this.relayWindowMs
+  }
+
   private live(entry: HopDepth | undefined): number {
     return entry && this.now() - entry.at < HOP_TTL_MS ? entry.depth : 0
   }

package/src/central/agent/message-routes.ts

@@ -154,7 +154,13 @@ function decisionFields(body: Body): Omit<AskInput, "question" | "about" | "expi
   return out as Omit<AskInput, "question" | "about" | "expiresInMs"> & { urgency?: Urgency; tier?: Tier; about?: string[] }
 }
 
-const sentView = ({ message, delivery }: Sent) => ({ message, ...(delivery ? { delivery } : {}) })
+/** The stored message, how it was delivered and, for a session recipient, whether it woke it (and why not). */
+const sentView = ({ message, delivery, woke, wakeSkipped }: Sent) => ({
+  message,
+  ...(delivery ? { delivery } : {}),
+  ...(woke === undefined ? {} : { woke }),
+  ...(wakeSkipped ? { wakeSkipped } : {}),
+})
 
 export function messageRoutes(deps: MessageDeps): AgentRoute[] {
   const { delivery, feed } = deps
@@ -270,8 +276,7 @@ export function messageRoutes(deps: MessageDeps): AgentRoute[] {
         if (decisionAsked) throw new AgentError("invalid", "options, recommendation, urgency, tier, deadline, onTimeout and about are for asks to @me")
         const sent = await send(user.id, actor, to, "ask", text, options, all)
         if (all) return ok({ sent: sent.map(sentView) }, 201)
-        const { message, delivery: how } = sent[0]!
-        return ok({ ...sentView({ message, ...(how ? { delivery: how } : {}) }), ...(await settled(user.id, message, wait, request.signal)) }, 201)
+        return ok({ ...sentView(sent[0]!), ...(await settled(user.id, sent[0]!.message, wait, request.signal)) }, 201)
       },
     },
     {

package/src/central/agent/messages.ts

@@ -42,9 +42,10 @@ export type MessageKind = "msg" | "ask" | "reply" | "decline"
 export type MessageState = "sent" | "open" | "answered" | "declined" | "expired"
 /**
  * How a message reached its recipient (design §3.3), recorded by the delivery engine. (CON-10) "dropped": it was
- * pending for a session that ended for good (a retired Concierge session) and will never be delivered.
+ * pending for a session that ended for good (a retired Concierge session) and will never be delivered. "expired": it
+ * was pending for PENDING_MS (its recipient stayed offline or busy) and will never be delivered; its sender was told.
  */
-export type Delivery = "steer" | "turn" | "queued" | "retained" | "pending" | "dropped"
+export type Delivery = "steer" | "turn" | "queued" | "retained" | "pending" | "dropped" | "expired"
 
 export interface Message {
   readonly id: string

package/src/central/agent/placement.ts

@@ -5,7 +5,7 @@
 //   announcing "launch" (each harness has its own service spoke: a Claude Code one never serves an OpenCode launch),
 //   and for openshell launches the node feature "sandbox" (it starts and stops the harness itself; the sandbox's
 //   launch-bound spoke creates the session, so no service spoke is needed)), then the placement's machine and labels (mode require: hard; prefer: ranking only), then
-//   free slots (capacity minus used minus reservations). The best node has the preference, then most free slots,
+//   free slots (capacity minus used minus reservations; a capacity wait gives each full node's counts). The best node has the preference, then most free slots,
 //   then the lowest machine ID. A launch that cannot be placed waits for capacity (a fitting node is full) or for a
 //   match (no node fits; the reason names each node's first problem).
 // - Admission (per user, hub.json agents.launches): admit() refuses a new launch with rate_limited while maxQueued
@@ -17,13 +17,17 @@
 //   the end. A pass first returns launches left placing by a dead holder to the queue, then walks queued launches
 //   oldest first: while fewer than maxActive are placing/provisioning/running, each is matched against the
 //   user's nodes and moved queued → placing → provisioning on the machine. A launch that cannot be placed now is
-//   reported as waiting and does not hold back later ones; earlier launches always pick first. Reservations are
+//   reported as waiting and does not hold back later ones; earlier launches always pick first. The active wait names
+//   who holds the cap (counts by launcher label; a revoked app token's launches are flagged). The Concierge's own
+//   launch (by app:concierge with label hub/system=concierge) neither counts toward maxActive nor waits for it; it
+//   still takes a node slot. Reservations are
 //   launches provisioning or running on a machine that its node does not report (yet); slots taken in the pass
 //   count at once. Reasons go on the launch only when it moves; waiting reasons are returned for the engine.
 // - PlacementLoop runs passes: kick(user) when something changed (a launch queued or ended, a node connected or
 //   reported capacity, a service spoke came), coalescing kicks during a pass into one more, plus a sweep over
 //   users() every intervalMs for whatever a kick missed (e.g. another process held the lease). Each placed launch
-//   goes to onPlaced (the launch engine starts provisioning); failures go to onError and never stop the loop.
+//   goes to onPlaced (the launch engine starts provisioning), then the pass's waiting launches to onWaiting (the
+//   engine stores the reason on the launch); failures go to onError and never stop the loop.
 // - Node and spoke info come through PlacementNodes / PlacementSpokes, which the launch engine adapts from the
 //   NodeRegistry and the Registry; memory is not matched (a spec has no memory need yet).
 import type { NodeCapacity, NodeRuntimeInfo } from "../../protocol"
@@ -62,7 +66,7 @@ export interface Candidate extends PlacementNode {
 
 export type Match =
   | { readonly ok: true; readonly node: PlacementNode; readonly preferred: boolean }
-  | { readonly ok: false; readonly wait: "capacity" | "no_match"; readonly reason: string }
+  | { readonly ok: false; readonly wait: "capacity" | "no_match"; readonly reason: string; readonly shared?: string }
 
 const label = (node: PlacementNode) => node.name ?? node.machineID
 
@@ -102,13 +106,13 @@ export function matchNode(userID: string, spec: LaunchSpec, candidates: readonly
   const own = candidates.filter((node) => node.owner === userID)
   if (own.length === 0) return { ok: false, wait: "no_match", reason: "No node is connected" }
   const require = spec.placement.mode === "require"
-  const problems: string[] = []
+  const problems: { node: string; problem: string }[] = []
   const full: Candidate[] = []
   const free: { node: Candidate; preferred: boolean }[] = []
   for (const node of own) {
     const placement = placementProblem(spec, node)
     const problem = hardProblem(spec, node) ?? (require ? placement : undefined)
-    if (problem) problems.push(`${label(node)} ${problem}`)
+    if (problem) problems.push({ node: label(node), problem })
     else if (freeSlots(node) <= 0) full.push(node)
     else free.push({ node, preferred: placement === undefined })
   }
@@ -122,8 +126,17 @@ export function matchNode(userID: string, spec: LaunchSpec, candidates: readonly
     const best = free[0]!
     return { ok: true, node: best.node, preferred: best.preferred }
   }
-  if (full.length > 0) return { ok: false, wait: "capacity", reason: `Waiting for a free slot on ${full.map(label).join(", ")}` }
-  return { ok: false, wait: "no_match", reason: `No node fits: ${problems.join("; ")}` }
+  if (full.length > 0) {
+    const used = (node: Candidate) => `${node.used.slots}/${node.capacity.slots} used, ${node.reserved} reserved`
+    return {
+      ok: false,
+      wait: "capacity",
+      reason: `Waiting for a free slot on ${full.map((node) => `${label(node)} (${used(node)})`).join(", ")}`,
+      // An app or session may not see the user's machines: no names.
+      shared: full.length === 1 ? `Waiting for a free slot on the fitting machine (${used(full[0]!)})` : `Waiting for a free slot on ${full.length} fitting machines (all full)`,
+    }
+  }
+  return { ok: false, wait: "no_match", reason: `No node fits: ${problems.map((p) => `${p.node} ${p.problem}`).join("; ")}`, shared: `No machine fits: ${[...new Set(problems.map((p) => p.problem))].join("; ")}` }
 }
 
 
@@ -157,6 +170,27 @@ export interface PlacementSpokes {
   launchHarnesses(userID: string, machineID: string): readonly string[] | Promise<readonly string[]>
 }
 
+/** Who launched what (the launch engine adapts the user's app tokens). */
+export interface PlacementLaunchers {
+  /** Whether the launcher (`app:<token id>`) was revoked: its launches still count, flagged. */
+  revoked(userID: string, by: string): boolean
+}
+
+/** The hub's own Concierge party (packages/protocol concierge.ts CONCIERGE_PARTY) and its launch label. */
+const CONCIERGE_BY = "app:concierge"
+/** The Concierge's own launch: neither counts toward nor waits for maxActive (it still takes a node slot). */
+export const isSystemLaunch = (launch: Pick<Launch, "by" | "spec">): boolean => launch.by === CONCIERGE_BY && launch.spec.labels["hub/system"] === "concierge"
+
+/** A launcher as a waiting reason names it: you, app "label" (or its token ID), a session's label or ID. */
+function launcherText(launch: Pick<Launch, "by" | "byLabel">, revoked: boolean): string {
+  const { by, byLabel } = launch
+  let text: string
+  if (by === undefined || by === "user") text = "you"
+  else if (by.startsWith("app:")) text = byLabel ? `app ${JSON.stringify(byLabel)}` : `app ${by.slice(4)}`
+  else text = byLabel ?? by
+  return revoked ? `${text} (launcher revoked)` : text
+}
+
 export interface PlacementDeps {
   readonly store: LaunchStore
   readonly nodes: PlacementNodes
@@ -168,6 +202,8 @@ export interface PlacementDeps {
   readonly caps?: HubLaunches
   readonly now?: Clock
   readonly leaseMs?: number
+  /** Revoked launchers (flagged in the active wait); without it none is. */
+  readonly launchers?: PlacementLaunchers
 }
 
 /** A launch the pass placed: it is now provisioning on the node's machine. */
@@ -184,7 +220,10 @@ export interface Waiting {
   readonly launchID: string
   /** capacity: a fitting node is full; no_match: no node fits; active: the user's maxActive is reached. */
   readonly wait: "capacity" | "no_match" | "active"
+  /** For the user: names other launchers and machines. */
   readonly reason: string
+  /** For the launch's own launcher (app or session), when it differs: counts only, no names. */
+  readonly shared?: string
 }
 
 /** One pass. leased false: another holder has the user's lease, or it was lost mid-pass (placed: before that). */
@@ -251,16 +290,18 @@ export class Placement {
       launches = await store.list(userID)
       const queued = launches.filter((l) => l.state === "queued")
       if (queued.length === 0) return { leased: true, placed, waiting }
-      let active = launches.filter((l) => ACTIVE.includes(l.state)).length
+      const counted = launches.filter((l) => ACTIVE.includes(l.state) && !isSystemLaunch(l))
+      let active = counted.length
       const candidates = await this.candidates(userID, launches)
       for (const launch of queued) {
-        if (active >= this.caps.maxActive) {
-          waiting.push({ launchID: launch.id, wait: "active", reason: `Waiting: ${active} launches are active (the most per user)` })
+        const system = isSystemLaunch(launch)
+        if (!system && active >= this.caps.maxActive) {
+          waiting.push({ launchID: launch.id, wait: "active", ...this.activeReason(userID, counted, launch) })
           continue
         }
         const match = matchNode(userID, launch.spec, candidates)
         if (!match.ok) {
-          waiting.push({ launchID: launch.id, wait: match.wait, reason: match.reason })
+          waiting.push({ launchID: launch.id, wait: match.wait, reason: match.reason, ...(match.shared !== undefined ? { shared: match.shared } : {}) })
           continue
         }
         const name = match.node.name ?? match.node.machineID
@@ -268,14 +309,21 @@ export class Placement {
         const placing = await skipGone(store.transition(userID, launch.id, "placing", { reason: `Placing on ${name}`, from: ["queued"] }))
         if (!placing) continue
         if (!(await held())) return lost()
-        const provisioning = await store.transition(userID, launch.id, "provisioning", {
-          reason: `Placed on ${name}${match.preferred ? "" : " (preferred placement not available)"}`,
-          machineID: match.node.machineID,
-          from: ["placing"],
-        })
+        // A stop between the two steps (e.g. the Concierge reaping an orphan) wins: skipped, not an error.
+        const provisioning = await skipGone(
+          store.transition(userID, launch.id, "provisioning", {
+            reason: `Placed on ${name}${match.preferred ? "" : " (preferred placement not available)"}`,
+            machineID: match.node.machineID,
+            from: ["placing"],
+          }),
+        )
+        if (!provisioning) continue
         const index = candidates.findIndex((c) => c.machineID === match.node.machineID)
         candidates[index] = { ...candidates[index]!, reserved: candidates[index]!.reserved + 1 }
-        active++
+        if (!system) {
+          active++
+          counted.push(provisioning)
+        }
         placed.push({ userID, launch: provisioning, node: match.node, preferred: match.preferred, fence: lease.fence })
       }
       return { leased: true, placed, waiting }
@@ -284,6 +332,25 @@ export class Placement {
     }
   }
 
+  /**
+   * The user's text names who holds the cap, most first ("Waiting: 4 of 4 active launches: 3 by app "ci", 1 by you;
+   * …"); the launcher's own text gives counts only: its own launches and the others'.
+   */
+  private activeReason(userID: string, active: readonly Launch[], waiting: Launch): { reason: string; shared: string } {
+    const own = active.filter((l) => (l.by ?? "user") === (waiting.by ?? "user")).length
+    const others = active.length - own
+    const split = [own ? `${own} yours` : undefined, others ? `${others} by others` : undefined].filter(Boolean).join(", ")
+    const shared = `Waiting: ${active.length} of ${this.caps.maxActive} active launches (${split}); ask the user to stop one or raise agents.launches.maxActive`
+    const counts = new Map<string, number>()
+    for (const launch of active) {
+      const revoked = launch.by !== undefined && launch.by.startsWith("app:") && this.deps.launchers?.revoked(userID, launch.by) === true
+      const text = launcherText(launch, revoked)
+      counts.set(text, (counts.get(text) ?? 0) + 1)
+    }
+    const holders = [...counts].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)).map(([text, n]) => `${n} by ${text}`)
+    return { reason: `Waiting: ${active.length} of ${this.caps.maxActive} active launches: ${holders.join(", ")}; stop one or raise agents.launches.maxActive`, shared }
+  }
+
   /** The user's nodes with their service spoke and reservations (placed launches the node does not report yet). */
   private async candidates(userID: string, launches: readonly Launch[]): Promise<Candidate[]> {
     const nodes = (await this.deps.nodes.nodes(userID)).filter((node) => node.owner === userID)
@@ -323,6 +390,8 @@ export interface PlacementLoopDeps {
   readonly users: () => Promise<readonly string[]>
   /** The engine takes a placed (provisioning) launch from here. */
   readonly onPlaced: (placed: Placed) => void | Promise<void>
+  /** The launches the pass could not place, with why (only for a pass that held the user's lease). */
+  readonly onWaiting?: (userID: string, waiting: readonly Waiting[]) => void | Promise<void>
   readonly onError?: (cause: unknown, userID?: string) => void
   readonly timers?: Timers
   readonly intervalMs?: number
@@ -415,5 +484,11 @@ export class PlacementLoop {
         this.onError(cause, userID)
       }
     }
+    if (!result.leased || !this.deps.onWaiting) return
+    try {
+      await this.deps.onWaiting(userID, result.waiting)
+    } catch (cause) {
+      this.onError(cause, userID)
+    }
   }
 }

package/src/central/agent/read-routes.ts

@@ -352,6 +352,8 @@ function sessionFilter(deps: ReadDeps, userID: string, params: URLSearchParams):
   const q = params.get("q") ?? ""
   if (q.length > QUERY_MAX) throw new AgentError("invalid", `q is at most ${QUERY_MAX} characters`)
   const wanted = words(q)
+  // (FX-07) A q with no letters or digits ("@", "«»", "?") names no word: it matches nothing (never every session).
+  const nothing = q.trim() !== "" && wanted.length === 0
   const states = params.get("state")?.split(",").filter(Boolean)
   if (states?.some((state) => !STATES.has(state))) throw new AgentError("invalid", "state must be idle, working, blocked or error (comma-separated)")
   const machine = params.get("machine") || undefined
@@ -362,6 +364,7 @@ function sessionFilter(deps: ReadDeps, userID: string, params: URLSearchParams):
     return [label.slice(0, at), label.slice(at + 1)] as const
   })
   return (row, view) => {
+    if (nothing) return false
     const { root, name } = projectOf(row.session)
     if (project !== undefined && root !== project && name.toLowerCase() !== project.toLowerCase()) return false
     if (states?.length && !states.includes(view.state)) return false

package/src/central/agent/routes.ts

@@ -53,7 +53,7 @@ import type { ActivityTracker } from "../concierge/activity"
 import { boardRoutes as conciergeBoardRoutes } from "../concierge/board-routes"
 import type { ResultTracker } from "../concierge/board-results"
 import { type ConciergeIdentity, watchlistRoutes } from "../concierge/watchlist-routes"
-import { conciergeRoutes } from "../concierge/routes"
+import { conciergeRoutes, type MachineModel } from "../concierge/routes"
 import { guardConciergeRoutes } from "../concierge/guard"
 import { isConciergeLaunch } from "../concierge/supervisor"
 import type { ConciergeService } from "../concierge/service"
@@ -166,6 +166,8 @@ export interface AgentDeps {
     readonly protects?: (userID: string, sessionID: string) => Promise<boolean>
     /** (CON-04) The Concierge service: /api/agent/concierge settings, enable/disable/restart and notes. */
     readonly service?: ConciergeService
+    /** (FX-04) A machine's OpenCode model list (routes.ts machineModels): GET …/concierge/machines/:id/models. */
+    readonly models?: (machineID: string) => Promise<MachineModel[]>
     /** (CON-06 and later) More Concierge routes (the tiers slot). */
     readonly routes?: () => AgentRoute[]
     /** (CON-06) The Decision armed now by the current Concierge (the board's `armed` flag). */
@@ -256,7 +258,7 @@ export function agentRoutes(deps: AgentDeps): AgentRoute[] {
       ? conciergeBoardRoutes({ ...deps.concierge, directory: deps.directory, store: deps.store, registry: deps.registry, ...(deps.decisions ? { decisions: deps.decisions } : {}), ...(deps.intents ? { intents: deps.intents } : {}), ...launchReads(deps), ...(deps.now ? { now: deps.now } : {}) })
       : []),
     // CON-04: settings, enable/disable/restart and notes; CON-06's routes through the tiers slot.
-    ...(deps.concierge?.service && deps.concierge.identity ? conciergeRoutes({ service: deps.concierge.service, identity: deps.concierge.identity }) : []),
+    ...(deps.concierge?.service && deps.concierge.identity ? conciergeRoutes({ service: deps.concierge.service, identity: deps.concierge.identity, ...(deps.concierge.models ? { models: deps.concierge.models } : {}) }) : []),
     ...(deps.concierge?.routes ? deps.concierge.routes() : []),
   ]
   // HWA-13: side chats read, launch and message through the routes above, as the caller.

package/src/central/agent/webhooks.ts

@@ -39,6 +39,18 @@ export const CANONICAL_WEBHOOK_EVENT_TYPES: readonly string[] = [
   "blocker.opened", "blocker.closed", "machine.changed", "role.claimed", "role.released",
   "message.changed", "launch.changed",
 ]
+/** A launch.changed event for a queued launch's new wait kind (not a state step). */
+export const isWaitChange = (event: Pick<AgentEvent, "type" | "data">): boolean => event.type === "launch.changed" && event.data.wait !== undefined
+
+/**
+ * The legacy `launch.<state>` type a canonical launch.changed event also matches; none for a queued launch's
+ * change of wait kind (FX-02), so launch.queued still fires once per launch, as before.
+ */
+export function legacyLaunchType(event: Pick<AgentEvent, "type" | "data">): string | undefined {
+  if (event.type !== "launch.changed" || typeof event.data.state !== "string" || isWaitChange(event)) return undefined
+  return `launch.${event.data.state}`
+}
+
 /** Includes persisted pre-canonical launch registrations for rolling rollback compatibility. */
 export const WEBHOOK_EVENT_TYPES: readonly string[] = [...CANONICAL_WEBHOOK_EVENT_TYPES, ...LAUNCH_STATES.map((state) => `launch.${state}`)]
 export const DEFAULT_WEBHOOK_EVENTS: readonly string[] = ["launch.*"]
@@ -336,11 +348,14 @@ export class Webhooks {
   }
 
   publishCanonical(userID: string, event: AgentEvent, _family: EventFamily, audience?: EventAudience): Promise<number> {
-    const legacyLaunchType = event.type === "launch.changed" && typeof event.data.state === "string" ? `launch.${event.data.state}` : undefined
+    // (FX-02) A queued launch's new wait kind is journaled (agent events, watch) but sent to no webhook: webhooks keep
+    // one delivery per launch state, as before.
+    if (isWaitChange(event)) return Promise.resolve(0)
+    const legacy = legacyLaunchType(event)
     return this.publish(userID, canonicalWebhookEvent(this.deps.source, userID, event), {
       ...(audience?.by ? { by: audience.by } : {}),
       ...(audience?.parties ? { owners: audience.parties.filter((party) => party.startsWith("app:")) } : {}),
-      ...(legacyLaunchType ? { matchTypes: [event.type, legacyLaunchType] } : {}),
+      ...(legacy ? { matchTypes: [event.type, legacy] } : {}),
     })
   }
 

package/src/central/artifacts/jobs-routes.ts

@@ -300,13 +300,16 @@ export function artifactJobRoutes(deps: ArtifactJobRoutesDeps): AgentRoute[] {
       launchID: launch.id,
       status: ended ? "ended" : sessionID ? "ready" : "waiting",
       launchState: launch.state,
-      reason: launch.reason,
+      // A job may be read by apps and sessions: a waiting reason in its launcher-safe form (FX-02).
+      reason: (launch.state === "queued" ? launch.waiting?.shared : undefined) ?? launch.reason,
       ...(launch.outcome ? { outcome: launch.outcome } : {}),
       ...(sessionID ? { sessionID } : {}),
     }
     if (expired) return fail(userID, job.id, "The job timed out", undefined, next, sessionID)
     if (ended) return fail(userID, job.id, `The handler launch ended (${launch.outcome ?? "unknown"}) without a result`, undefined, next, sessionID)
     if (digestOf(next) === digestOf(handler) && job.launchID === launch.id) return job
+    // (FX-02) A queued launch's waiting text changes with node slot counts: shown live, without a new job revision.
+    if (digestOf({ ...next, reason: "" }) === digestOf({ ...handler, reason: "" }) && job.launchID === launch.id) return { ...job, handler: next }
     return jobs.update(userID, job.id, (current) =>
       isTerminal(current)
         ? undefined

package/src/central/concierge/board-routes.ts

@@ -319,7 +319,7 @@ export function boardRoutes(deps: BoardRouteDeps): AgentRoute[] {
           const after = query.after ? all.filter((d) => isAfter(d, query.after!)) : all
           const page = after.slice(0, query.limit)
           const more = after.length > page.length
-          return Response.json({ decisions: page, ...(more ? { cursor: encodeCursor(page.at(-1)!) } : {}) }, { headers: NO_STORE })
+          return Response.json({ decisions: page.map(conciergeDecisionView), ...(more ? { cursor: encodeCursor(page.at(-1)!) } : {}) }, { headers: NO_STORE })
         },
       },
       {
@@ -330,10 +330,21 @@ export function boardRoutes(deps: BoardRouteDeps): AgentRoute[] {
           await admit(actor, user.id)
           const decision = await decisions.get(user.id, params.id!)
           if (!decision) throw new AgentError("not_found", "No such decision")
-          return Response.json({ decision }, { headers: NO_STORE })
+          return Response.json({ decision: conciergeDecisionView(decision) }, { headers: NO_STORE })
         },
       },
     )
   }
   return routes
 }
+
+/**
+ * (FX-05, coordinator decision: Concierge prompt-injection surface) A Decision as these routes return it: exactly
+ * the record they returned before FX-05, without the structured request and reason the hub now stores on its action
+ * for the user's console (GET /api/decisions) only.
+ */
+export function conciergeDecisionView(decision: Decision): Decision {
+  if (!decision.action || (!("request" in decision.action) && !("reason" in decision.action))) return decision
+  const { request: _request, reason: _reason, ...action } = decision.action as typeof decision.action & { request?: unknown; reason?: unknown }
+  return { ...decision, action: action as Decision["action"] }
+}

package/src/central/concierge/inbound.ts

@@ -49,6 +49,8 @@ export function conciergeInbound(deps: ConciergeInboundDeps): InboundPolicy {
     try {
       return await deps.identity.current(userID)
     } catch (cause) {
+      // (FX-07) A timed-out read is `busy` (503, refused); any other failure an internal error (refused too).
+      if (cause instanceof AgentError) throw cause
       throw new AgentError("internal", `Could not check the Concierge inbound rule: ${(cause as Error).message}`.slice(0, 200))
     }
   }
@@ -63,13 +65,8 @@ export function conciergeInbound(deps: ConciergeInboundDeps): InboundPolicy {
     },
     async admit(userID, from, sessionID, kind, original) {
       if (from.kind === "user") return
-      let current: Awaited<ReturnType<ConciergeIdentity["current"]>>
-      try {
-        current = await deps.identity.current(userID)
-      } catch (cause) {
-        throw new AgentError("internal", `Could not check the Concierge inbound rule: ${(cause as Error).message}`.slice(0, 200))
-      }
-      if (!isConcierge(current, sessionID) || admitted(from, sessionID, kind, original)) return
+      const now = await current(userID)
+      if (!isConcierge(now, sessionID) || admitted(from, sessionID, kind, original)) return
       await deps.audit
         ?.record(userID, { actor: from, verb: "msg", target: { sessionID }, decision: "forbidden", reason: "concierge inbound rule", outcome: "refused" })
         .catch((cause) => console.error(`[hub] concierge inbound audit failed: ${(cause as Error).message}`))

package/src/central/concierge/prompt.ts

@@ -3,7 +3,7 @@
 // text lives here (src/central/concierge/**) and nowhere else (contract open question 1).
 import { zonedStamp } from "./board-render"
 
-export const CONCIERGE_PROMPT_VERSION = 6
+export const CONCIERGE_PROMPT_VERSION = 7
 
 /** Facts about the user the instructions depend on (hub-known, never model text). */
 export interface InstructionFacts {
@@ -22,7 +22,8 @@ export interface InstructionFacts {
  * session named by @name or title is looked up (concierge_find) before asking which one. (CON-13, v6) A form is
  * read (concierge_form) before it is answered or an answer proposed; a blocker is re-checked on a fresh board before
  * it is claimed; the user acts "in the Concierge panel" or by tapping the card, never "in the console"; a session's
- * project folder name is fine, full paths are not; a refused act is said with the hub's reason.
+ * project folder name is fine, full paths are not; a refused act is said with the hub's reason. (FX-07, v7) An
+ * action's why is read by the user in Activity: plain words, never board fields or codes (inGrant, auto, IDs).
  */
 export function conciergeInstructions(facts: InstructionFacts): string {
   const { voice } = facts
@@ -69,7 +70,7 @@ export function conciergeInstructions(facts: InstructionFacts): string {
     "- A pending permission marked inGrant=yes but auto=no (shell, outside folders, tools): do not approve it. Tell the user it needs their tap on that session's card; it cannot be armed, so do not arm or propose it.",
     "- A pending permission marked inGrant=no: do not approve or try it. Tell the user plainly it waits for them on that session's card (or Needs you), and offer only what you can do.",
     "- Never say a permission is inside or outside your grant unless the board's inGrant says so.",
-    "- Every action is audited as yours. Give a short why for each.",
+    "- Every action is audited as yours, and the user reads its why in Activity. Give a short why for each, in plain words: never board fields or codes (inGrant, auto, revisions, IDs).",
     '- A proposal\'s why is your own reason, in your words. Never say the user asked for it unless they did in this conversation; when they only asked you to propose, say so ("You asked me to propose this").',
     "",
     "Rules:",

package/src/central/concierge/proposals.ts

@@ -23,7 +23,7 @@ import type { Counters } from "../backend/types"
 import type { Acting, ProposalVerb } from "../agent/acting"
 import type { AgentActor, UserActor } from "../agent/actor"
 import type { AgentAudit } from "../agent/audit"
-import type { ActAction, ActOutcome, Decision, Decisions, Tier } from "../agent/decisions"
+import { type ActAction, type ActOutcome, type Decision, type Decisions, decisionRequest, type Tier } from "../agent/decisions"
 import { type Party, partyFromActor } from "../agent/envelope"
 import { AgentError } from "../agent/errors"
 import type { Message } from "../agent/messages"
@@ -201,7 +201,13 @@ export class Proposals {
     // The hourly budget counts created proposals only (checked here, counted once the Decision exists).
     const budget = `concierge-proposals:${userID}`
     if ((await counters.get(budget)) >= PROPOSALS_PER_HOUR) throw new AgentError("rate_limited", `At most ${PROPOSALS_PER_HOUR} proposals an hour`, { extra: { retryAfter: 3600 } })
-    const action: ActAction = { kind: "act", verb: input.verb, target: target.sessionID, input: actionInput(input) }
+    const action: ActAction = {
+      kind: "act",
+      verb: input.verb,
+      target: target.sessionID,
+      input: actionInput(input),
+      ...(input.verb === "deny" && target.request ? { request: decisionRequest(target.request) } : {}),
+    }
     const { message, decision } = await decisions.ask(
       userID,
       actor,